feat: add multi-session desktop workspace

2026-08-13 21:34:04 +02:00
parent 12b9b83d51
commit 475f95ba70
56 changed files with 8998 additions and 3805 deletions
@@ -0,0 +1,147 @@
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { useCallback, useEffect, useReducer, useRef } from "react";
+import { initialWorkspaceState, workspaceReducer } from "./reducer";
+import { legacyPreferences, loadPresentation, presentationState, removeLegacyPreferences, savePresentation } from "./persistence";
+import type { HostEvent, RuntimeSnapshot, UiState, Workspace, WorkspaceSummary } from "./types";
+
+export function useWorkspace() {
+  const [state, dispatch] = useReducer(workspaceReducer, initialWorkspaceState);
+  const stateRef = useRef(state); stateRef.current = state;
+  const loadGeneration = useRef<Record<string, number>>({});
+  const timers = useRef<Record<string, number>>({});
+  const initialized = useRef(false);
+  const legacyMigrationPending = useRef(false);
+  const disposed = useRef(true);
+  const refreshGeneration = useRef(0);
+
+  const loadSnapshot = useCallback(async (runtimeId: string) => {
+    if (disposed.current) return;
+    const generation = (loadGeneration.current[runtimeId] ?? 0) + 1;
+    loadGeneration.current[runtimeId] = generation;
+    dispatch({ type: "snapshotRequested", runtimeId, generation });
+    try {
+      const snapshot = await invoke<RuntimeSnapshot>("get_session_runtime_snapshot", { runtimeId });
+      if (!disposed.current)
+        dispatch({ type: "snapshotLoaded", runtimeId, generation, snapshot });
+    } catch (error) {
+      if (!disposed.current)
+        dispatch({ type: "snapshotFailed", runtimeId, generation, error: String(error) });
+    }
+  }, []);
+
+  const scheduleSnapshot = useCallback((runtimeId: string) => {
+    if (timers.current[runtimeId]) return;
+    timers.current[runtimeId] = window.setTimeout(() => {
+      delete timers.current[runtimeId]; void loadSnapshot(runtimeId);
+    }, 120);
+  }, [loadSnapshot]);
+
+  const refresh = useCallback(async (initialUiState?: UiState, reloadAllSnapshots = false) => {
+    const generation = ++refreshGeneration.current;
+    const cancelled = () => disposed.current || generation !== refreshGeneration.current;
+    const workspace = await invoke<Workspace>("get_workspace");
+    if (cancelled()) return;
+    let nextPersisted = initialUiState;
+    if (nextPersisted) {
+      const legacy = legacyPreferences(localStorage);
+      const candidate = nextPersisted.selectedRuntimeId
+        ? undefined
+        : workspace.directories.find((directory) => directory.worktreePath === legacy.path)?.runtimes[0];
+      nextPersisted = {
+        ...nextPersisted,
+        ...(candidate ? { selectedRuntimeId: candidate.runtimeId } : {}),
+        ...(nextPersisted.interfaceScale === undefined && legacy.scale !== undefined
+          ? { interfaceScale: legacy.scale }
+          : {}),
+      };
+      legacyMigrationPending.current = Boolean(
+        (!initialUiState?.selectedRuntimeId && candidate) ||
+        (initialUiState?.interfaceScale === undefined && legacy.scale !== undefined),
+      );
+    }
+    dispatch({ type: "workspaceLoaded", workspace, persisted: nextPersisted });
+    const summary = await invoke<WorkspaceSummary>("get_workspace_summary");
+    if (cancelled()) return;
+    dispatch({ type: "setResourceWarning", value: summary.resourceWarning });
+    const selected = nextPersisted?.selectedRuntimeId && workspace.directories.some((directory) => directory.runtimes.some((runtime) => runtime.runtimeId === nextPersisted?.selectedRuntimeId))
+      ? nextPersisted.selectedRuntimeId : workspace.directories[0]?.runtimes[0]?.runtimeId;
+    const runtimeIds = workspace.directories.flatMap((directory) => directory.runtimes.map((runtime) => runtime.runtimeId));
+    for (const runtimeId of reloadAllSnapshots ? runtimeIds : selected ? [selected] : []) {
+      if (cancelled()) return;
+      void loadSnapshot(runtimeId);
+    }
+    if (cancelled()) return;
+    await invoke("subscribe_workspace", { cursor: { bridgeInstanceId: workspace.bridgeInstanceId, seq: workspace.latestSeq } });
+    if (cancelled()) await invoke("unsubscribe_workspace").catch(() => {});
+  }, [loadSnapshot]);
+
+  useEffect(() => {
+    disposed.current = false;
+    let stop: (() => void) | undefined;
+    void listen<HostEvent>("workspace-bridge", (message) => {
+      if (disposed.current) return;
+      const host = message.payload;
+      dispatch({ type: "hostEvent", host });
+      if (host.kind === "resetRequired") void refresh(undefined, true);
+      else if (host.kind === "event") {
+        const runtimeId = host.event.data?.runtimeId;
+        const eventType = host.event.type;
+        const piType = String(host.event.data?.eventData?.event?.type ?? "");
+        if (["runtime_opened", "runtime_closed", "runtime_recovered", "runtime_restore_failed"].includes(eventType ?? "")) {
+          void refresh();
+        } else if (runtimeId && (host.event.data?.eventType === "transcript" || piType === "agent_settled" || piType === "compaction_end")) {
+          scheduleSnapshot(runtimeId);
+        }
+      }
+    }).then((unlisten) => { if (disposed.current) unlisten(); else stop = unlisten; });
+    void (async () => {
+      try {
+        const loaded = await loadPresentation();
+        if (disposed.current) return;
+        await refresh(loaded);
+        if (disposed.current) return;
+        initialized.current = true;
+      } catch (error) {
+        if (!disposed.current)
+          dispatch({ type: "hostEvent", host: { kind: "disconnected", message: String(error), retryInMs: 0 } });
+      }
+    })();
+    const appWindow = getCurrentWindow();
+    const visibility = () => dispatch({ type: "setWindowActive", active: document.visibilityState === "visible" && document.hasFocus() });
+    window.addEventListener("focus", visibility); window.addEventListener("blur", visibility); document.addEventListener("visibilitychange", visibility);
+    return () => {
+      disposed.current = true;
+      refreshGeneration.current += 1;
+      stop?.();
+      void invoke("unsubscribe_workspace").catch(() => {});
+      window.removeEventListener("focus", visibility);
+      window.removeEventListener("blur", visibility);
+      document.removeEventListener("visibilitychange", visibility);
+      Object.values(timers.current).forEach(clearTimeout);
+      void appWindow;
+    };
+  }, [refresh, scheduleSnapshot]);
+
+  useEffect(() => {
+    if (!initialized.current) return;
+    const timer = window.setTimeout(() => {
+      void savePresentation(presentationState(state)).then(() => {
+        if (legacyMigrationPending.current) {
+          removeLegacyPreferences(localStorage);
+          legacyMigrationPending.current = false;
+        }
+      }).catch(() => {});
+    }, 300);
+    return () => clearTimeout(timer);
+  }, [state.directoryOrder, state.runtimeOrderByDirectory, state.selectedRuntimeId, state.interfaceScale, state.bridge.latestSeq, state.runtimesById]);
+
+  useEffect(() => {
+    const id = state.selectedRuntimeId; if (!id) return;
+    if (!state.runtimesById[id]?.loading && !state.runtimesById[id]?.messages.length) void loadSnapshot(id);
+  }, [state.selectedRuntimeId, loadSnapshot]);
+
+  return { state, dispatch, refresh, loadSnapshot, scheduleSnapshot };
+}
+