Merge branch 'feat/terminal-copy-on-select' into develop

Author: pallyoung

packages/server/src/commands/settings.test.ts

@@ -67,6 +67,31 @@ describe("settings commands", () => {
     ).toEqual({ value: "600" });
   });
 
+  it("settings.update persists appearance.terminalCopyOnSelect into user_settings", async () => {
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "settings-update-terminal-copy-on-select",
+        op: "settings.update",
+        args: {
+          settings: {
+            appearance: {
+              terminalCopyOnSelect: true,
+            },
+          },
+        },
+      },
+      ctx
+    );
+
+    expect(result.ok).toBe(true);
+    expect(
+      db
+        .prepare("SELECT value FROM user_settings WHERE key = ?")
+        .get("appearance.terminalCopyOnSelect")
+    ).toEqual({ value: "true" });
+  });
+
   it("settings.update rejects fractional supervisor timeout values", async () => {
     const result = await dispatch(
       {
@@ -270,6 +295,26 @@ describe("settings commands", () => {
     });
   });
 
+  it("settings.get reads appearance.terminalCopyOnSelect from user_settings", async () => {
+    db.prepare("INSERT INTO user_settings (key, value) VALUES (?, ?)").run(
+      "appearance.terminalCopyOnSelect",
+      "true"
+    );
+
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "settings-get-terminal-copy-on-select",
+        op: "settings.get",
+        args: {},
+      },
+      ctx
+    );
+
+    expect(result.ok).toBe(true);
+    expect(result.data?.["appearance.terminalCopyOnSelect"]).toBe(true);
+  });
+
   it("settings.get normalizes invalid persisted supervisor timeout values", async () => {
     db.prepare("INSERT INTO user_settings (key, value) VALUES (?, ?)").run(
       "supervisor.evaluationTimeoutSec",

packages/server/src/commands/settings.ts

@@ -48,6 +48,7 @@ const SettingsSchema = z.object({
     .object({
       theme: z.enum(["dark"]).optional(),
       terminalRenderer: z.enum(["standard", "compatibility"]).optional(),
+      terminalCopyOnSelect: z.boolean().optional(),
       locale: z.enum(["zh", "en"]).optional(),
     })
     .optional(),

packages/web/src/app/providers.lifecycle.test.tsx

@@ -10,6 +10,7 @@ import {
   workspacesAtom,
   workspacesLoadStateAtom,
 } from "../atoms/workspaces";
+import { terminalPreferencesAtom } from "../features/terminal-panel/preferences";
 import {
   fileTreeStaleAtomFamily,
   gitBranchListAtomFamily,
@@ -97,9 +98,11 @@ function seedWorkspaces(
 describe("AppProviders lifecycle recovery", () => {
   const originalFetch = globalThis.fetch;
   const originalVisibilityState = Object.getOwnPropertyDescriptor(document, "visibilityState");
+  const originalTerminalPreferences = localStorage.getItem("ui.terminalPreferences");
 
   beforeEach(() => {
     resetAppProvidersSingletonsForTests();
+    localStorage.removeItem("ui.terminalPreferences");
     globalThis.fetch = vi.fn().mockResolvedValue({
       json: async () => ({ authEnabled: false }),
     }) as unknown as typeof fetch;
@@ -133,6 +136,11 @@ describe("AppProviders lifecycle recovery", () => {
     resetAppProvidersSingletonsForTests();
     globalThis.fetch = originalFetch;
     vi.restoreAllMocks();
+    if (originalTerminalPreferences === null) {
+      localStorage.removeItem("ui.terminalPreferences");
+    } else {
+      localStorage.setItem("ui.terminalPreferences", originalTerminalPreferences);
+    }
     if (originalVisibilityState) {
       Object.defineProperty(document, "visibilityState", originalVisibilityState);
     } else {
@@ -374,6 +382,131 @@ describe("AppProviders lifecycle recovery", () => {
     });
   });
 
+  it("hydrates terminal copy-on-select preferences from settings.get once connected", async () => {
+    const store = createStore();
+    setVisibilityState("visible");
+
+    const sendCommand = vi.fn().mockImplementation(async (op: string) => {
+      if (op === "settings.get") {
+        return {
+          "appearance.terminalCopyOnSelect": true,
+        };
+      }
+
+      return undefined;
+    });
+    wsState.client!.sendCommand = sendCommand;
+
+    renderProviders(store);
+
+    await vi.waitFor(() => {
+      expect(wsState.client?.connect).toHaveBeenCalled();
+    });
+
+    act(() => {
+      wsState.client?.statusHandler?.("connected");
+    });
+
+    await vi.waitFor(() => {
+      expect(store.get(terminalPreferencesAtom)).toEqual({ copyOnSelect: true });
+    });
+
+    expect(sendCommand).toHaveBeenCalledWith("settings.get", {}, undefined);
+  });
+
+  it("preserves a newer local terminal copy-on-select update when startup hydration resolves later", async () => {
+    const store = createStore();
+    setVisibilityState("visible");
+
+    let resolveSettingsGet: ((value: Record<string, unknown>) => void) | undefined;
+    const settingsGetPromise = new Promise<Record<string, unknown>>((resolve) => {
+      resolveSettingsGet = resolve;
+    });
+    const sendCommand = vi.fn().mockImplementation(async (op: string) => {
+      if (op === "settings.get") {
+        return await settingsGetPromise;
+      }
+
+      return undefined;
+    });
+    wsState.client!.sendCommand = sendCommand;
+
+    renderProviders(store);
+
+    await vi.waitFor(() => {
+      expect(wsState.client?.connect).toHaveBeenCalled();
+    });
+
+    act(() => {
+      wsState.client?.statusHandler?.("connected");
+    });
+
+    await vi.waitFor(() => {
+      expect(sendCommand).toHaveBeenCalledWith("settings.get", {}, undefined);
+    });
+
+    act(() => {
+      store.set(terminalPreferencesAtom, { copyOnSelect: true });
+    });
+
+    await act(async () => {
+      resolveSettingsGet?.({});
+      await settingsGetPromise;
+    });
+
+    expect(store.get(terminalPreferencesAtom)).toEqual({ copyOnSelect: true });
+  });
+
+  it("preserves an ABA local terminal copy-on-select update when startup hydration resolves later", async () => {
+    const store = createStore();
+    setVisibilityState("visible");
+
+    act(() => {
+      store.set(terminalPreferencesAtom, { copyOnSelect: true });
+    });
+
+    let resolveSettingsGet: ((value: Record<string, unknown>) => void) | undefined;
+    const settingsGetPromise = new Promise<Record<string, unknown>>((resolve) => {
+      resolveSettingsGet = resolve;
+    });
+    const sendCommand = vi.fn().mockImplementation(async (op: string) => {
+      if (op === "settings.get") {
+        return await settingsGetPromise;
+      }
+
+      return undefined;
+    });
+    wsState.client!.sendCommand = sendCommand;
+
+    renderProviders(store);
+
+    await vi.waitFor(() => {
+      expect(wsState.client?.connect).toHaveBeenCalled();
+    });
+
+    act(() => {
+      wsState.client?.statusHandler?.("connected");
+    });
+
+    await vi.waitFor(() => {
+      expect(sendCommand).toHaveBeenCalledWith("settings.get", {}, undefined);
+    });
+
+    act(() => {
+      store.set(terminalPreferencesAtom, { copyOnSelect: false });
+      store.set(terminalPreferencesAtom, { copyOnSelect: true });
+    });
+
+    await act(async () => {
+      resolveSettingsGet?.({
+        "appearance.terminalCopyOnSelect": false,
+      });
+      await settingsGetPromise;
+    });
+
+    expect(store.get(terminalPreferencesAtom)).toEqual({ copyOnSelect: true });
+  });
+
   it("marks the session authenticated when /auth/status confirms an existing server session", async () => {
     globalThis.fetch = vi.fn().mockResolvedValue({
       json: async () => ({ authEnabled: true, authenticated: true }),

packages/web/src/app/providers.tsx

@@ -39,6 +39,10 @@ import { activeWorkspaceIdAtom } from "../atoms/workspaces";
 import { useSessionNotifications } from "../features/notifications";
 import { supervisorCyclesAtom, supervisorsAtom } from "../features/supervisor/atoms";
 import { terminalMetaAtomFamily } from "../features/terminal-panel/atoms";
+import {
+  resolveTerminalCopyOnSelectSetting,
+  terminalPreferencesAtom,
+} from "../features/terminal-panel/preferences";
 import {
   editorRefreshTokenAtomFamily,
   fileTreeStaleAtomFamily,
@@ -173,6 +177,7 @@ export function AppProviders({ children }: AppProvidersProps) {
   // Supervisor state atoms
   const setSupervisors = useSetAtom(supervisorsAtom);
   const setSupervisorCycles = useSetAtom(supervisorCyclesAtom);
+  const setTerminalPreferences = useSetAtom(terminalPreferencesAtom);
 
   // Get Jotai store for writing to atomFamily atoms
   const store = useStore();
@@ -197,6 +202,40 @@ export function AppProviders({ children }: AppProvidersProps) {
     dispatchRef.current = dispatch;
   }, [dispatch]);
 
+  useEffect(() => {
+    if (connectionStatus !== "connected") {
+      return;
+    }
+
+    let cancelled = false;
+    let localTerminalPreferencesUpdated = false;
+    const unsubscribeTerminalPreferences = store.sub(terminalPreferencesAtom, () => {
+      localTerminalPreferencesUpdated = true;
+    });
+
+    const hydrateTerminalPreferences = async () => {
+      const result = await dispatch<Record<string, unknown>>("settings.get", {});
+      if (cancelled || !result.ok || !result.data) {
+        return;
+      }
+
+      if (localTerminalPreferencesUpdated) {
+        return;
+      }
+
+      setTerminalPreferences({
+        copyOnSelect: resolveTerminalCopyOnSelectSetting(result.data),
+      });
+    };
+
+    void hydrateTerminalPreferences();
+
+    return () => {
+      cancelled = true;
+      unsubscribeTerminalPreferences();
+    };
+  }, [connectionStatus, dispatch, setTerminalPreferences, store]);
+
   useEffect(() => {
     activeWorkspaceIdRef.current = activeWorkspaceId;
   }, [activeWorkspaceId]);