/** * Shared server settings. * * Every server keeps its own `settings.json`, but some keys are user * preferences that only live on the server because the server has to act on * them (auto-settlement runs with no client attached). A user does not want * those to differ per machine. Clients write these keys to every connected * environment, and warn when a connected environment still holds a different * value so the user can push their current value out. */import type { EnvironmentId, ServerSettings, ServerSettingsPatch } from "@t3tools/contracts";import * as Equal from "effect/Equal";import * as Struct from "effect/Struct"; import type { EnvironmentPresentation } from "../connection/presentation.ts"; /** Server keys that hold a user preference rather than machine config. */export const SHARED_SERVER_SETTING_KEYS = [  "sidebarAutoSettleAfterDays",  "sidebarAutoSettleOnMerge",  "defaultThreadEnvMode",  "newWorktreesStartFromOrigin",  "sourceControlWritingStyle",] as const satisfies ReadonlyArray<keyof ServerSettings & keyof ServerSettingsPatch>; export type SharedServerSettingKey = (typeof SHARED_SERVER_SETTING_KEYS)[number]; const SHARED_KEY_SET = new Set<string>(SHARED_SERVER_SETTING_KEYS); /** Split a server patch into the keys every environment should receive and the primary-only rest. */export function splitSharedServerPatch(patch: ServerSettingsPatch): {  sharedPatch: ServerSettingsPatch;  localPatch: ServerSettingsPatch;} {  const sharedPatch: Record<string, unknown> = {};  const localPatch: Record<string, unknown> = {};  for (const [key, value] of Object.entries(patch)) {    if (SHARED_KEY_SET.has(key)) {      sharedPatch[key] = value;    } else {      localPatch[key] = value;    }  }  return {    sharedPatch: sharedPatch as ServerSettingsPatch,    localPatch: localPatch as ServerSettingsPatch,  };} /** The shared subset of one environment's settings, as a patch that can be written elsewhere. */export function pickSharedServerSettings(settings: ServerSettings): ServerSettingsPatch {  return Struct.pick(settings, SHARED_SERVER_SETTING_KEYS);} /** * Whether an environment can hold every shared key right now. Gated on the * auto-settlement capability because it is the newest of the shared keys: a * server that has it has all of them. Older servers drop unknown keys on * write, so a mismatch against them could never clear, and their decoded * defaults must not be treated as real values. */export function supportsSharedSettings(environment: EnvironmentPresentation): boolean {  return (    environment.connection.phase === "connected" &&    environment.serverConfig?.environment.capabilities.threadAutoSettlement === true  );} /** * One line per environment that rejected a settings write, each with its own * reason. Two environments can fail for different reasons (one dropped its * session, one refused the scope), so the reasons are never collapsed. */export function describeRejectedSettingsWrites(  failed: ReadonlyArray<{ readonly label: string; readonly error: unknown }>,): string {  return failed    .map(      ({ label, error }) =>        `${label}: ${error instanceof Error ? error.message : "The server rejected the change."}`,    )    .join("\n");} export interface SharedSettingsEnvironment {  readonly environmentId: EnvironmentId;  readonly label: string;  readonly connected: boolean;  readonly settings: ServerSettings | null;} /** * Connected environments whose shared settings differ from the primary * environment's. Offline environments are skipped: nothing can be read from * or written to them, and the warning would never clear. With no primary * settings loaded there is nothing to compare against, so nothing is * reported. Callers must pass the real loaded settings, never a default * fallback, or "apply to all" would push defaults over real values. */export function findSharedSettingsMismatches(input: {  readonly primaryEnvironmentId: EnvironmentId | null;  readonly primarySettings: ServerSettings | null;  readonly environments: ReadonlyArray<SharedSettingsEnvironment>;}): ReadonlyArray<{ readonly environmentId: EnvironmentId; readonly label: string }> {  if (input.primaryEnvironmentId === null || input.primarySettings === null) {    return [];  }  const expected = pickSharedServerSettings(input.primarySettings);  return input.environments.flatMap((environment) => {    if (      environment.environmentId === input.primaryEnvironmentId ||      !environment.connected ||      environment.settings === null    ) {      return [];    }    const actual = pickSharedServerSettings(environment.settings);    return Equal.equals(actual, expected)      ? []      : [{ environmentId: environment.environmentId, label: environment.label }];  });}