fix: avoid echoing server workspace views

pallyoung · pallyoung · commit 346452b4f247 · 2026-03-29T00:34:11.000+08:00
diff --git a/apps/web/src/features/workspace/WorkspaceScreen.tsx b/apps/web/src/features/workspace/WorkspaceScreen.tsx
@@ -100,6 +100,11 @@ import {
   resolveTerminalRecoveryAction,
 } from "./workspace-recovery";
 import { attachWorkspaceRuntimeWithRetry } from "./runtime-attach";
+import {
+  pruneWorkspaceViewBaselines,
+  rememberWorkspaceViewBaseline,
+  shouldPersistWorkspaceView,
+} from "./workspace-view-persistence";
 import {
   createInitialHistoryExpansion,
   groupSessionHistory,
@@ -453,7 +458,6 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
   const validatedRuntimeTargetsRef = useRef(new Set<string>());
   const runtimeValidationRequestIdRef = useRef(0);
   const persistedLayoutRef = useRef<string>("");
-  const persistedWorkspaceViewsRef = useRef(new Map<string, string>());
   const agentStartupStateRef = useRef(new Map<string, {
     token: number;
     startedAt: number;
@@ -841,26 +845,21 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
     state.tabs.forEach((tab) => {
       if (tab.status !== "ready" || !tab.project?.path) return;
       if (!canMutateWorkspace(tab.controller, "switch_pane")) return;
+      if (!shouldPersistWorkspaceView(tab)) return;
       const patch = {
         active_session_id: tab.activeSessionId,
         active_pane_id: tab.activePaneId,
         active_terminal_id: tab.activeTerminalId,
         pane_layout: tab.paneLayout,
         file_preview: tab.filePreview,
       };
-      const serialized = JSON.stringify(patch);
-      if (persistedWorkspaceViewsRef.current.get(tab.id) === serialized) return;
-      persistedWorkspaceViewsRef.current.set(tab.id, serialized);
+      rememberWorkspaceViewBaseline(tab);
       void withServiceFallback(
         () => updateWorkspaceView(tab.id, patch, tab.controller),
         null,
       );
     });
-    Array.from(persistedWorkspaceViewsRef.current.keys()).forEach((workspaceId) => {
-      if (!liveWorkspaceIds.has(workspaceId)) {
-        persistedWorkspaceViewsRef.current.delete(workspaceId);
-      }
-    });
+    pruneWorkspaceViewBaselines(liveWorkspaceIds);
   }, [bootstrapReady, state.tabs]);
 
   useEffect(() => {
diff --git a/apps/web/src/features/workspace/workspace-view-persistence.ts b/apps/web/src/features/workspace/workspace-view-persistence.ts
@@ -0,0 +1,55 @@
+import type { Tab } from "../../state/workbench-core.ts";
+import type { WorkspaceViewPatch } from "../../types/app.ts";
+
+type WorkspaceViewTab = Pick<
+  Tab,
+  "id" | "activeSessionId" | "activePaneId" | "activeTerminalId" | "paneLayout" | "filePreview"
+>;
+
+const persistedWorkspaceViews = new Map<string, string>();
+
+export const createWorkspaceViewPatchFromTab = (
+  tab: WorkspaceViewTab,
+): WorkspaceViewPatch => ({
+  active_session_id: tab.activeSessionId,
+  active_pane_id: tab.activePaneId,
+  active_terminal_id: tab.activeTerminalId,
+  pane_layout: tab.paneLayout,
+  file_preview: tab.filePreview,
+});
+
+export const serializeWorkspaceViewPatch = (patch: WorkspaceViewPatch) => JSON.stringify(patch);
+
+const serializeWorkspaceViewTab = (tab: WorkspaceViewTab) => serializeWorkspaceViewPatch(
+  createWorkspaceViewPatchFromTab(tab),
+);
+
+export const rememberWorkspaceViewBaseline = (tab: WorkspaceViewTab) => {
+  persistedWorkspaceViews.set(tab.id, serializeWorkspaceViewTab(tab));
+};
+
+export const rememberWorkspaceViewBaselines = (tabs: WorkspaceViewTab[]) => {
+  tabs.forEach((tab) => {
+    rememberWorkspaceViewBaseline(tab);
+  });
+};
+
+export const shouldPersistWorkspaceView = (tab: WorkspaceViewTab) => (
+  persistedWorkspaceViews.get(tab.id) !== serializeWorkspaceViewTab(tab)
+);
+
+export const forgetWorkspaceViewBaseline = (workspaceId: string) => {
+  persistedWorkspaceViews.delete(workspaceId);
+};
+
+export const pruneWorkspaceViewBaselines = (workspaceIds: ReadonlySet<string>) => {
+  Array.from(persistedWorkspaceViews.keys()).forEach((workspaceId) => {
+    if (!workspaceIds.has(workspaceId)) {
+      persistedWorkspaceViews.delete(workspaceId);
+    }
+  });
+};
+
+export const resetWorkspaceViewBaselines = () => {
+  persistedWorkspaceViews.clear();
+};
diff --git a/apps/web/src/shared/utils/workspace.ts b/apps/web/src/shared/utils/workspace.ts
@@ -34,6 +34,10 @@ import {
   isDraftSession,
   resolveVisibleStatus,
 } from "./session.ts";
+import {
+  rememberWorkspaceViewBaseline,
+  rememberWorkspaceViewBaselines,
+} from "../../features/workspace/workspace-view-persistence.ts";
 
 const unique = (values: string[]) => Array.from(new Set(values.filter(Boolean)));
 
@@ -388,7 +392,7 @@ export const buildWorkbenchStateFromBootstrap = (
     })
     .filter((tab): tab is Tab => Boolean(tab));
 
-  return {
+  const nextState = {
     tabs,
     activeTabId: resolveActiveWorkspaceId(tabs, bootstrap.ui_state.active_workspace_id),
     layout: workbenchLayoutFromBackend(bootstrap.ui_state.layout),
@@ -398,6 +402,8 @@ export const buildWorkbenchStateFromBootstrap = (
       input: tabs.length === 0 ? current.overlay.input : "",
     },
   };
+  rememberWorkspaceViewBaselines(nextState.tabs);
+  return nextState;
 };
 
 export const upsertWorkspaceSnapshot = (
@@ -417,7 +423,7 @@ export const upsertWorkspaceSnapshot = (
   }
   const tabs = orderTabsByUiState(Array.from(tabMap.values()), openWorkspaceIds);
 
-  return {
+  const nextState = {
     ...current,
     tabs,
     activeTabId: resolveActiveWorkspaceId(tabs, uiState?.active_workspace_id ?? nextTab.id),
@@ -428,6 +434,8 @@ export const upsertWorkspaceSnapshot = (
       input: "",
     },
   };
+  rememberWorkspaceViewBaseline(nextTab);
+  return nextState;
 };
 
 export const applyWorkspaceRuntimeSnapshot = (
@@ -481,9 +489,10 @@ export const applyWorkspaceControllerEvent = (
 export const applyWorkspaceRuntimeStateEvent = (
   current: WorkbenchState,
   payload: WorkspaceRuntimeStateEvent,
-): WorkbenchState => ({
-  ...current,
-  tabs: current.tabs.map((tab) => {
+): WorkbenchState => {
+  const nextState = {
+    ...current,
+    tabs: current.tabs.map((tab) => {
     if (tab.id !== payload.workspace_id) return tab;
     const nextActiveSessionId = tab.sessions.some((session) => session.id === payload.view_state.active_session_id)
       ? payload.view_state.active_session_id
@@ -500,8 +509,14 @@ export const applyWorkspaceRuntimeStateEvent = (
       filePreview: normalizeFilePreview(payload.view_state.file_preview, tab.filePreview),
       viewingArchiveId: undefined,
     };
-  }),
-});
+    }),
+  };
+  const nextTab = nextState.tabs.find((tab) => tab.id === payload.workspace_id);
+  if (nextTab) {
+    rememberWorkspaceViewBaseline(nextTab);
+  }
+  return nextState;
+};
 
 export const applyWorkbenchUiState = (
   current: WorkbenchState,
diff --git a/tests/workspace-view-persistence.test.ts b/tests/workspace-view-persistence.test.ts
@@ -0,0 +1,171 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  applyWorkspaceRuntimeStateEvent,
+  buildWorkbenchStateFromBootstrap,
+} from "../apps/web/src/shared/utils/workspace.ts";
+import { createDefaultWorkbenchState } from "../apps/web/src/state/workbench-core.ts";
+import {
+  resetWorkspaceViewBaselines,
+  shouldPersistWorkspaceView,
+} from "../apps/web/src/features/workspace/workspace-view-persistence.ts";
+
+const APP_SETTINGS = {
+  agentProvider: "claude" as const,
+  agentCommand: "claude",
+  idlePolicy: {
+    enabled: true,
+    idleMinutes: 10,
+    maxActive: 3,
+    pressure: true,
+  },
+  completionNotifications: {
+    enabled: true,
+    onlyWhenBackground: true,
+  },
+  terminalCompatibilityMode: "standard" as const,
+};
+
+const createWorkspaceSnapshot = (activeSessionId: string) => ({
+  workspace: {
+    workspace_id: "ws-1",
+    title: "Workspace 1",
+    project_path: "/tmp/ws-1",
+    source_kind: "local" as const,
+    source_value: "/tmp/ws-1",
+    git_url: null,
+    target: { type: "native" as const },
+    idle_policy: {
+      enabled: true,
+      idle_minutes: 10,
+      max_active: 3,
+      pressure: true,
+    },
+  },
+  sessions: [
+    {
+      id: 1,
+      title: "Session 1",
+      status: "idle" as const,
+      mode: "branch" as const,
+      auto_feed: true,
+      queue: [],
+      messages: [],
+      stream: "",
+      unread: 0,
+      last_active_at: 1,
+      claude_session_id: null,
+    },
+    {
+      id: 2,
+      title: "Session 2",
+      status: "waiting" as const,
+      mode: "branch" as const,
+      auto_feed: true,
+      queue: [],
+      messages: [],
+      stream: "",
+      unread: 0,
+      last_active_at: 2,
+      claude_session_id: null,
+    },
+  ],
+  archive: [],
+  view_state: {
+    active_session_id: activeSessionId,
+    active_pane_id: `pane-${activeSessionId}`,
+    active_terminal_id: "",
+    pane_layout: {
+      type: "leaf" as const,
+      id: `pane-${activeSessionId}`,
+      sessionId: activeSessionId,
+    },
+    file_preview: {
+      path: "",
+      content: "",
+      mode: "preview" as const,
+      originalContent: "",
+      modifiedContent: "",
+      dirty: false,
+    },
+  },
+  terminals: [],
+});
+
+test.afterEach(() => {
+  resetWorkspaceViewBaselines();
+});
+
+test("buildWorkbenchStateFromBootstrap seeds workspace view persistence baselines for hydrated tabs", () => {
+  const state = buildWorkbenchStateFromBootstrap(
+    createDefaultWorkbenchState(),
+    {
+      ui_state: {
+        open_workspace_ids: ["ws-1"],
+        active_workspace_id: "ws-1",
+        layout: {
+          left_width: 320,
+          right_width: 320,
+          right_split: 64,
+          show_code_panel: false,
+          show_terminal_panel: false,
+        },
+      },
+      workspaces: [createWorkspaceSnapshot("2")],
+    },
+    "en",
+    APP_SETTINGS,
+  );
+
+  const tab = state.tabs[0];
+  assert.equal(shouldPersistWorkspaceView(tab), false);
+  assert.equal(shouldPersistWorkspaceView({ ...tab, activeSessionId: "1" }), true);
+});
+
+test("runtime state events refresh workspace view persistence baselines", () => {
+  const initial = buildWorkbenchStateFromBootstrap(
+    createDefaultWorkbenchState(),
+    {
+      ui_state: {
+        open_workspace_ids: ["ws-1"],
+        active_workspace_id: "ws-1",
+        layout: {
+          left_width: 320,
+          right_width: 320,
+          right_split: 64,
+          show_code_panel: false,
+          show_terminal_panel: false,
+        },
+      },
+      workspaces: [createWorkspaceSnapshot("2")],
+    },
+    "en",
+    APP_SETTINGS,
+  );
+
+  const next = applyWorkspaceRuntimeStateEvent(initial, {
+    workspace_id: "ws-1",
+    view_state: {
+      active_session_id: "1",
+      active_pane_id: "pane-1",
+      active_terminal_id: "",
+      pane_layout: {
+        type: "leaf",
+        id: "pane-1",
+        sessionId: "1",
+      },
+      file_preview: {
+        path: "",
+        content: "",
+        mode: "preview",
+        originalContent: "",
+        modifiedContent: "",
+        dirty: false,
+      },
+    },
+  });
+
+  const tab = next.tabs[0];
+  assert.equal(shouldPersistWorkspaceView(tab), false);
+  assert.equal(shouldPersistWorkspaceView({ ...tab, activePaneId: "pane-2" }), true);
+});
