@monotykamary/localterm-server 2.62.3 → 2.63.0

package/dist/index.js

@@ -21,7 +21,7 @@ import { detectWithExplicitPort } from "./cdp/discover-explicit-endpoint.js";
 import { DaemonConfigStore } from "./daemon-config-store.js";
 import { formatCandidates, resolveCandidates, resolveCompletionContext, } from "./completion/index.js";
 import { z } from "zod";
-import { ACTIVITY_DIRNAME, ACTIVITY_REFRESH_DEBOUNCE_MS, ACTIVITY_WATCHED_PROGRAMS, AUTOMATION_EVENT_DEBOUNCE_MS, AUTOMATION_RECONCILE_MIN_DOWNTIME_MS, AUTOMATION_RUN_QUERY_PARAM, AUTOMATION_WATCH_DEBOUNCE_MS, AUTOMATION_WATCH_POST_RUN_GRACE_MS, AUTOMATION_WEBHOOK_DEBOUNCE_MS, DEFAULT_HOST, DEFAULT_PORT, FRIENDLY_HOSTNAME, GIT_DIRTY_THROTTLE_MS, GIT_MAX_REF_LENGTH, HTTP_STATUS_ACCEPTED, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_CONFLICT, HTTP_STATUS_CREATED, HTTP_STATUS_NOT_FOUND, HTTP_STATUS_PAYLOAD_TOO_LARGE, HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE, MAX_AUTOMATIONS, MAX_IMAGE_UPLOAD_BYTES, MAX_PROCESSES, MAX_SECRETS, MS_PER_MINUTE, PROCESSES_FILENAME, SECRETS_FILENAME, THEMES_FILENAME, FONTS_FILENAME, SECRETS_SHIMS_DIRNAME, SECRET_EXPORT_SCRYPT_WORK_FACTOR, AUTOMATION_AGENT_SESSIONS_DIRNAME, SERVER_STOP_GRACE_MS, SESSION_ID_QUERY_PARAM, SESSION_ACTIVITY_WINDOW_MS, WINDOW_ID_QUERY_PARAM, WAIT_DEFAULT_TIMEOUT_MS, WS_BACKPRESSURE_THRESHOLD_BYTES, WS_CLOSE_BACKPRESSURE, WS_CLOSE_CAPACITY_REACHED, WS_CLOSE_POLICY_VIOLATION, WS_HEARTBEAT_GRACE_MS, WS_HEARTBEAT_INTERVAL_MS, WS_HEARTBEAT_TIMEOUT_MS, WS_READY_STATE_OPEN, AUTH_SECRET_FILENAME, AUTH_COOKIE_NAME, UPDATE_CHECK_FILENAME, } from "./constants.js";
+import { ACTIVITY_DIRNAME, ACTIVITY_REFRESH_DEBOUNCE_MS, ACTIVITY_WATCHED_PROGRAMS, AUTOMATION_EVENT_DEBOUNCE_MS, AUTOMATION_RECONCILE_MIN_DOWNTIME_MS, AUTOMATION_RUN_QUERY_PARAM, AUTOMATION_WATCH_DEBOUNCE_MS, AUTOMATION_WATCH_POST_RUN_GRACE_MS, AUTOMATION_WEBHOOK_DEBOUNCE_MS, DEFAULT_HOST, DEFAULT_PORT, FRIENDLY_HOSTNAME, GIT_DIRTY_THROTTLE_MS, GIT_MAX_REF_LENGTH, HTTP_STATUS_ACCEPTED, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_CONFLICT, HTTP_STATUS_CREATED, HTTP_STATUS_NOT_FOUND, HTTP_STATUS_PAYLOAD_TOO_LARGE, HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE, MAX_AUTOMATIONS, MAX_IMAGE_UPLOAD_BYTES, MAX_PROCESSES, MAX_SECRETS, MS_PER_MINUTE, PROCESSES_FILENAME, SECRETS_FILENAME, THEMES_FILENAME, FONTS_FILENAME, SECRETS_SHIMS_DIRNAME, SECRET_EXPORT_SCRYPT_WORK_FACTOR, AUTOMATION_AGENT_SESSIONS_DIRNAME, SERVER_STOP_GRACE_MS, SESSION_ID_QUERY_PARAM, WORKSPACE_FILENAME, WORKSPACE_RESTORE_SETTLE_MS, WORKSPACE_SNAPSHOT_DEBOUNCE_MS, SESSION_ACTIVITY_WINDOW_MS, WINDOW_ID_QUERY_PARAM, WAIT_DEFAULT_TIMEOUT_MS, WS_BACKPRESSURE_THRESHOLD_BYTES, WS_CLOSE_BACKPRESSURE, WS_CLOSE_CAPACITY_REACHED, WS_CLOSE_POLICY_VIOLATION, WS_HEARTBEAT_GRACE_MS, WS_HEARTBEAT_INTERVAL_MS, WS_HEARTBEAT_TIMEOUT_MS, WS_READY_STATE_OPEN, AUTH_SECRET_FILENAME, AUTH_COOKIE_NAME, UPDATE_CHECK_FILENAME, } from "./constants.js";
 import { getDefaultShell, listKnownShells, resolveShellOverride } from "./default-shell.js";
 import { resolveWindowId } from "./utils/resolve-window-id.js";
 import { shellPathForUserShell } from "./utils/shell-path.js";
@@ -35,6 +35,7 @@ import { SessionEventManager } from "./session-event-manager.js";
 import { WebhookTriggerManager } from "./webhook-trigger-manager.js";
 import { getGitBranchInfo, getGitBranchPr, getGitDiff, getGitDiffFilePatch, getGitDiffFiles, getGitDiffSummary, } from "./git-diff.js";
 import { HeartbeatStore } from "./heartbeat-store.js";
+import { WorkspaceStore } from "./workspace-store.js";
 import { createDefaultSecretBackend } from "./secret-backend.js";
 import { SecretStore } from "./secret-store.js";
 import { ProcessStore } from "./process-store.js";
@@ -187,7 +188,7 @@ const normalizeMouseAction = (input) => {
 };
 const buildApiRoutes = (ctx) => {
     const api = new Hono();
-    const { registry, ownerFor, cdpClient, secretBackend, secretExportScryptWorkFactor, secretStore, shimsDir, processStore, themeStore, fontStore, syncSecretShims, automationStore, broadcastAutomations, syncFolderWatchers, syncSessionEventListeners, webhookTriggerManager, worktreeConfigStore, portsSnapshotProcesses, portsSnapshotListeners, toAutomationWithNextRun, listAutomationsWithNextRun, tryLaunch, getCdpPort, applyCdpPort, getGraceSeconds, applyGraceSeconds, connectCdpNow, buildTabUrl, mintViewerCookie, stateDirectory, broadcastThemes, broadcastFonts, updateCheckStore, } = ctx;
+    const { registry, ownerFor, cdpClient, secretBackend, secretExportScryptWorkFactor, secretStore, shimsDir, processStore, themeStore, fontStore, syncSecretShims, automationStore, broadcastAutomations, syncFolderWatchers, syncSessionEventListeners, webhookTriggerManager, worktreeConfigStore, portsSnapshotProcesses, portsSnapshotListeners, toAutomationWithNextRun, listAutomationsWithNextRun, tryLaunch, getCdpPort, applyCdpPort, getGraceSeconds, applyGraceSeconds, getWorkspaceRestore, applyWorkspaceRestore, connectCdpNow, buildTabUrl, mintViewerCookie, stateDirectory, broadcastThemes, broadcastFonts, updateCheckStore, } = ctx;
     // Headless SGR-1006 fallback for `mouse` when no CDP tab is reachable:
     // encode the gesture as SGR bytes and write them straight to the PTY. Closes
     // over `registry` so the automation layer stays CDP-agnostic. Coords arrive
@@ -1550,6 +1551,7 @@ const buildApiRoutes = (ctx) => {
     api.get("/config", (context) => context.json({
         cdpPort: getCdpPort(),
         graceSeconds: getGraceSeconds(),
+        workspaceRestore: getWorkspaceRestore(),
         defaultShell: getDefaultShell(),
         shells: listKnownShells(),
     }));
@@ -1562,6 +1564,9 @@ const buildApiRoutes = (ctx) => {
             graceSeconds: parsed.data.graceSeconds === undefined
                 ? getGraceSeconds()
                 : applyGraceSeconds(parsed.data.graceSeconds),
+            workspaceRestore: parsed.data.workspaceRestore === undefined
+                ? getWorkspaceRestore()
+                : applyWorkspaceRestore(parsed.data.workspaceRestore),
             defaultShell: getDefaultShell(),
             shells: listKnownShells(),
         });
@@ -1632,8 +1637,17 @@ export const createServer = async (options = {}) => {
         sendControl: safeSend,
         hooks: {
             onOutputActivity: () => caffeinateManager.noteOutputActivity(),
-            onSessionActivity: () => caffeinateManager.pokeAuto(),
-            onSessionEvent: (event, cwd) => sessionEventManager.onSessionEvent(event, cwd),
+            onSessionActivity: () => {
+                caffeinateManager.pokeAuto();
+                scheduleWorkspaceSnapshot();
+            },
+            onSessionEvent: (event, cwd) => {
+                sessionEventManager.onSessionEvent(event, cwd);
+                // A cwd change reshapes the workspace manifest (the tab's respawn cwd
+                // moves), so re-snapshot alongside the attach/detach-driven snapshot.
+                if (event === "cwd")
+                    scheduleWorkspaceSnapshot();
+            },
             onAutomationExit: (automationId, runId, exitCode, log) => {
                 automationStore.updateRun(automationId, runId, {
                     status: exitCode === 0 ? "completed" : "failed",
@@ -1715,6 +1729,7 @@ export const createServer = async (options = {}) => {
     const caffeinateController = options.caffeinateController ?? new CaffeinateController();
     const caffeinatePreferencesStore = new CaffeinatePreferencesStore(path.join(stateDirectory, "caffeinate.json"));
     const worktreeConfigStore = new WorktreeConfigStore(stateDirectory);
+    const workspaceStore = new WorkspaceStore(path.join(stateDirectory, WORKSPACE_FILENAME));
     // Per-process secret injection: a backend (macOS Keychain on darwin) holds
     // secret values; a secret is an identity + the env var it exports
     // (~/.localterm/secrets.json, names + env var only — never values), and a
@@ -2217,6 +2232,11 @@ export const createServer = async (options = {}) => {
         registry.rearmGrace();
         return next;
     };
+    // Persist + read the workspace-restore toggle. Read at restore time, so a
+    // `PUT /api/config` change takes effect on the next start (the restore runs
+    // once at startup, not live-reactively).
+    const getWorkspaceRestore = () => daemonConfigStore.getWorkspaceRestore();
+    const applyWorkspaceRestore = (enabled) => daemonConfigStore.setWorkspaceRestore(enabled);
     // Explicit "Connect now" (Settings → Automation browser → Connect): drop any
     // live socket and await a fresh connect so the caller learns the outcome —
     // connected + which browser, or the error that explains a failure (e.g. a
@@ -2241,6 +2261,110 @@ export const createServer = async (options = {}) => {
             };
         }
     };
+    // Workspace restore: reopen the user's last tabs via CDP on start (a
+    // tmux-resurrect/herdr-style restore of the *layout*; the shells themselves
+    // don't survive a stop). The manifest is snapshotted to disk — debounced on
+    // attach/detach churn (scheduleWorkspaceSnapshot, hooked into onSessionActivity)
+    // and flushed on graceful stop — so a restart, graceful or a crash, can reopen
+    // the same tabs. Triggered once per (owner, windowId) after the first desktop
+    // tab pairs with CDP, on a quiet window so surviving tabs (a daemon restart
+    // with the browser left open) reattach and are counted before the deficit is
+    // opened. Excludes automation-run tabs and dormant shells (filtered in
+    // SessionManager.workspaceEntries), so only tabs that were actively open
+    // come back. Opt out via Settings → Sessions (config.json workspaceRestore).
+    let workspaceSnapshotTimer = null;
+    const scheduleWorkspaceSnapshot = () => {
+        if (workspaceSnapshotTimer !== null)
+            clearTimeout(workspaceSnapshotTimer);
+        const timer = setTimeout(() => {
+            workspaceSnapshotTimer = null;
+            workspaceStore.write(registry.workspaceEntries());
+        }, WORKSPACE_SNAPSHOT_DEBOUNCE_MS);
+        timer.unref?.();
+        workspaceSnapshotTimer = timer;
+    };
+    const flushWorkspaceSnapshot = () => {
+        if (workspaceSnapshotTimer !== null) {
+            clearTimeout(workspaceSnapshotTimer);
+            workspaceSnapshotTimer = null;
+        }
+        workspaceStore.write(registry.workspaceEntries());
+    };
+    const buildSpawnTabUrl = (cwd, shell) => {
+        const url = new URL(localOrigin ?? publicOrigin ?? `http://${FRIENDLY_HOSTNAME}:${actualPort}`);
+        if (cwd)
+            url.searchParams.set("cwd", cwd);
+        if (shell)
+            url.searchParams.set("shell", shell);
+        return url.toString();
+    };
+    const restoredWorkspaceKeys = new Set();
+    const workspaceRestoreTimers = new Map();
+    const scheduleWorkspaceRestore = (owner, windowId) => {
+        if (!windowId)
+            return;
+        const key = `${owner ?? ""}\u0000${windowId}`;
+        if (restoredWorkspaceKeys.has(key))
+            return;
+        const existing = workspaceRestoreTimers.get(key);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            workspaceRestoreTimers.delete(key);
+            if (restoredWorkspaceKeys.has(key))
+                return;
+            restoredWorkspaceKeys.add(key);
+            void restoreWorkspace(owner, windowId);
+        }, WORKSPACE_RESTORE_SETTLE_MS);
+        timer.unref?.();
+        workspaceRestoreTimers.set(key, timer);
+    };
+    const restoreWorkspace = async (owner, windowId) => {
+        if (!daemonConfigStore.getWorkspaceRestore())
+            return;
+        if (!cdpClient || !cdpClient.isConnected())
+            return;
+        const entry = workspaceStore
+            .read()
+            .find((candidate) => candidate.owner === owner && candidate.windowId === windowId);
+        if (!entry || entry.tabs.length === 0)
+            return;
+        const manifest = entry.tabs;
+        const openCount = registry.attachedClientCount(owner, windowId);
+        if (openCount >= manifest.length)
+            return;
+        if (openCount === 0) {
+            for (const tab of manifest) {
+                await cdpClient.openBackgroundTab(buildSpawnTabUrl(tab.cwd, tab.shell));
+            }
+            return;
+        }
+        if (openCount === 1) {
+            // Browser was fully closed; the lone bootstrap tab is repointed to the
+            // first restored shell (navigate-the-bootstrap) so the reopen lands
+            // exactly N tabs in the manifest's cwds instead of N−1 + one stray in
+            // the default directory.
+            const firstTargetId = [...wsToTargetId.entries()].find(([ws]) => {
+                const profile = registry.clientProfile(ws);
+                return profile !== null && profile.owner === owner && profile.windowId === windowId;
+            })?.[1];
+            if (firstTargetId) {
+                await cdpClient.navigateTab(firstTargetId, buildSpawnTabUrl(manifest[0].cwd, manifest[0].shell));
+            }
+            for (let index = 1; index < manifest.length; index++) {
+                await cdpClient.openBackgroundTab(buildSpawnTabUrl(manifest[index].cwd, manifest[index].shell));
+            }
+            return;
+        }
+        // Partial survival (a daemon restart with some tabs left open): surviving
+        // tabs self-healed to their live cwds, so only the deficit is opened. Which
+        // manifest cwds the survivors cover can't be matched (their URLs carry the
+        // spawn cwd, stale after a `cd`), so the tail is opened as a best-effort
+        // placement — the count is exact, the cwd placement is approximate.
+        for (let index = openCount; index < manifest.length; index++) {
+            await cdpClient.openBackgroundTab(buildSpawnTabUrl(manifest[index].cwd, manifest[index].shell));
+        }
+    };
     const updateCheckStore = new UpdateCheckStore({
         filePath: path.join(stateDirectory, UPDATE_CHECK_FILENAME),
         currentVersion: options.currentVersion ?? readServerVersion(),
@@ -2276,6 +2400,8 @@ export const createServer = async (options = {}) => {
         applyCdpPort,
         getGraceSeconds,
         applyGraceSeconds,
+        getWorkspaceRestore,
+        applyWorkspaceRestore,
         broadcastThemes,
         broadcastFonts,
         connectCdpNow,
@@ -2557,8 +2683,16 @@ export const createServer = async (options = {}) => {
                     const token = parsed.data.token;
                     if (token !== null) {
                         const targetId = cdpClient?.findTargetIdForToken(token);
-                        if (targetId)
+                        if (targetId) {
                             wsToTargetId.set(ws, targetId);
+                            // A desktop tab just paired with CDP — arm a one-shot restore
+                            // for its (owner, windowId) so missing workspace tabs reopen
+                            // once the reconnection burst settles. Phone PWA tabs never pair
+                            // (no debug port), so restore stays scoped to the desktop.
+                            const profile = registry.clientProfile(ws);
+                            if (profile)
+                                scheduleWorkspaceRestore(profile.owner, profile.windowId);
+                        }
                     }
                     safeSend(ws, {
                         type: "cdp-controlled",
@@ -2693,6 +2827,7 @@ export const createServer = async (options = {}) => {
         });
     }
     const stop = async () => {
+        flushWorkspaceSnapshot();
         automationScheduler.dispose();
         folderWatchManager.dispose();
         automationGitWatcher.dispose();