@spencer-kit/coder-studio 0.3.3 → 0.3.5

package/dist/esm/server-runner.mjs

@@ -863,11 +863,11 @@ function resolveSpawnArgv(argv, deps = {}) {
     return [];
   }
   const restArgs = argv.slice(1);
-  const readFileSync8 = deps.readFileSync ?? ((file) => fs2.readFileSync(file, "utf8"));
-  const existsSync9 = deps.existsSync ?? fs2.existsSync;
+  const readFileSync9 = deps.readFileSync ?? ((file) => fs2.readFileSync(file, "utf8"));
+  const existsSync10 = deps.existsSync ?? fs2.existsSync;
   const pathEnv = deps.pathEnv ?? process.env.Path ?? process.env.PATH ?? "";
   const pathExt = deps.pathExt ?? process.env.PATHEXT ?? DEFAULT_PATHEXT;
-  const resolved = resolveExecutablePath(command, pathEnv, pathExt, existsSync9);
+  const resolved = resolveExecutablePath(command, pathEnv, pathExt, existsSync10);
   if (!resolved) {
     return [...argv];
   }
@@ -878,7 +878,7 @@ function resolveSpawnArgv(argv, deps = {}) {
   if (ext === ".cmd" || ext === ".bat") {
     let content;
     try {
-      content = readFileSync8(resolved);
+      content = readFileSync9(resolved);
     } catch {
       return ["cmd.exe", "/d", "/s", "/c", resolved, ...restArgs];
     }
@@ -916,17 +916,17 @@ function expandShimVars(value, dp0Dir) {
 function parsePathExt(pathExt) {
   return pathExt.split(";").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
 }
-function resolveExecutablePath(command, pathEnv, pathExt, existsSync9) {
+function resolveExecutablePath(command, pathEnv, pathExt, existsSync10) {
   const hasExt = path2.win32.extname(command).length > 0;
   const extensions = parsePathExt(pathExt);
   if (path2.win32.isAbsolute(command)) {
-    if (existsSync9(command)) {
+    if (existsSync10(command)) {
       return command;
     }
     if (!hasExt) {
       for (const ext of extensions) {
         const candidate = command + ext;
-        if (existsSync9(candidate)) {
+        if (existsSync10(candidate)) {
           return candidate;
         }
       }
@@ -937,14 +937,14 @@ function resolveExecutablePath(command, pathEnv, pathExt, existsSync9) {
   for (const dir of dirs) {
     if (hasExt) {
       const candidate = path2.win32.join(dir, command);
-      if (existsSync9(candidate)) {
+      if (existsSync10(candidate)) {
         return candidate;
       }
       continue;
     }
     for (const ext of extensions) {
       const candidate = path2.win32.join(dir, command + ext);
-      if (existsSync9(candidate)) {
+      if (existsSync10(candidate)) {
         return candidate;
       }
     }
@@ -2107,6 +2107,157 @@ var init_command_check = __esm({
   }
 });
 
+// packages/server/src/provider-runtime/e2e-provider-mock.ts
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname4, join as join3 } from "node:path";
+function createE2EProviderMockOverrides(env = process.env) {
+  const statePath = env.CODER_STUDIO_E2E_PROVIDER_STATE_PATH;
+  if (!statePath) {
+    return null;
+  }
+  const binDir = env.CODER_STUDIO_E2E_PROVIDER_BIN_DIR;
+  const debugLogPath = env.CODER_STUDIO_E2E_PROVIDER_DEBUG_LOG_PATH;
+  appendDebugLog(debugLogPath, `init statePath=${statePath} binDir=${binDir ?? ""}`);
+  const commandExists = async (command) => {
+    const state = readMockState(statePath);
+    const override = state.commands?.[command];
+    appendDebugLog(
+      debugLogPath,
+      `commandExists ${command} override=${String(override)} state=${JSON.stringify(state.commands ?? {})}`
+    );
+    if (typeof override === "boolean") {
+      return override;
+    }
+    return checkCommandAvailable(command);
+  };
+  const runCommand2 = async (file, args, options) => {
+    const providerId = getInstallProviderId(file, args);
+    appendDebugLog(
+      debugLogPath,
+      `runCommand ${file} ${args.join(" ")} provider=${providerId ?? "none"}`
+    );
+    if (!providerId) {
+      return runCommandAsString(file, args, options);
+    }
+    const state = readMockState(statePath);
+    const behavior = state.installBehavior?.[providerId];
+    appendDebugLog(
+      debugLogPath,
+      `behavior ${providerId} ${JSON.stringify(behavior)} state=${JSON.stringify(state)}`
+    );
+    if (!behavior) {
+      return runCommandAsString(file, args, options);
+    }
+    if (behavior.result === "success") {
+      writeMockState(statePath, (draft) => {
+        draft.commands ??= {};
+        draft.commands[providerId] = true;
+      });
+      if (binDir) {
+        ensureProviderCommand(binDir, providerId);
+      }
+      appendDebugLog(debugLogPath, `install success ${providerId}`);
+      return {
+        stdout: `installed ${providerId}`,
+        stderr: ""
+      };
+    }
+    const message = behavior.message ?? (behavior.result === "permission_denied" ? "permission denied" : "command not found");
+    throw Object.assign(new Error(message), {
+      exitCode: 1,
+      stdout: "",
+      stderr: message
+    });
+  };
+  return {
+    commandExists,
+    runCommand: runCommand2
+  };
+}
+function getInstallProviderId(file, args) {
+  if (file !== "npm" || args.length !== 3) {
+    return null;
+  }
+  if (args[0] !== "install" || args[1] !== "-g") {
+    return null;
+  }
+  const packageName = args[2];
+  if (packageName === PROVIDER_INSTALL_PACKAGES.claude) {
+    return "claude";
+  }
+  if (packageName === PROVIDER_INSTALL_PACKAGES.codex) {
+    return "codex";
+  }
+  return null;
+}
+function readMockState(statePath) {
+  if (!existsSync6(statePath)) {
+    return {};
+  }
+  const raw = readFileSync5(statePath, "utf8");
+  if (!raw.trim()) {
+    return {};
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Invalid provider mock state at ${statePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function writeMockState(statePath, updater) {
+  const nextState = readMockState(statePath);
+  updater(nextState);
+  mkdirSync3(dirname4(statePath), { recursive: true });
+  writeFileSync3(statePath, JSON.stringify(nextState, null, 2));
+  return nextState;
+}
+function ensureProviderCommand(binDir, providerId) {
+  mkdirSync3(binDir, { recursive: true });
+  const scriptPath = join3(binDir, providerId);
+  writeFileSync3(scriptPath, PROVIDER_COMMAND_SCRIPTS[providerId], "utf8");
+  chmodSync(scriptPath, 493);
+}
+function appendDebugLog(path10, line) {
+  if (!path10) {
+    return;
+  }
+  mkdirSync3(dirname4(path10), { recursive: true });
+  writeFileSync3(path10, `${line}
+`, { flag: "a" });
+}
+var PROVIDER_INSTALL_PACKAGES, PROVIDER_COMMAND_SCRIPTS;
+var init_e2e_provider_mock = __esm({
+  "packages/server/src/provider-runtime/e2e-provider-mock.ts"() {
+    "use strict";
+    init_command_check();
+    init_command_runner();
+    PROVIDER_INSTALL_PACKAGES = {
+      claude: "@anthropic-ai/claude-code",
+      codex: "@openai/codex"
+    };
+    PROVIDER_COMMAND_SCRIPTS = {
+      claude: `#!/usr/bin/env bash
+set -euo pipefail
+trap 'exit 0' TERM INT
+printf 'Mock Claude ready\\n'
+while true; do
+  sleep 1
+done
+`,
+      codex: `#!/usr/bin/env bash
+set -euo pipefail
+trap 'exit 0' TERM INT
+printf 'Session ID: abcdef-123456\\n> '
+while true; do
+  sleep 1
+done
+`
+    };
+  }
+});
+
 // packages/server/src/provider-runtime/install-manager.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 function getErrorDetails(error) {
@@ -3589,8 +3740,8 @@ var init_database = __esm({
 
 // packages/server/src/storage/db.ts
 import { DatabaseSync } from "node:sqlite";
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join4 } from "path";
 function normalizeSql(sql) {
   return (sql ?? "").replace(/\s+/g, " ").trim();
 }
@@ -3737,8 +3888,8 @@ var init_db = __esm({
   "packages/server/src/storage/db.ts"() {
     "use strict";
     init_database();
-    SCHEMA_PATH = join3(import.meta.dirname, "migrations", "001_init.sql");
-    SCHEMA_SQL = readFileSync5(SCHEMA_PATH, "utf-8");
+    SCHEMA_PATH = join4(import.meta.dirname, "migrations", "001_init.sql");
+    SCHEMA_SQL = readFileSync6(SCHEMA_PATH, "utf-8");
     LEGACY_TABLES = ["hook_registrations", "_migrations"];
     LEGACY_SESSION_COLUMNS = ["resume_id", "transcript_path"];
     EXPECTED_SCHEMA_ENTRIES = buildExpectedSchemaEntries();
@@ -4670,6 +4821,7 @@ function parseFetchUpdatedRefs(stderr) {
 }
 async function runGitCheckout(cwd, ref, options) {
   const args = ["checkout"];
+  const formatCheckoutError = (error, fallbackMessage) => error instanceof GitError ? error.stderr.trim() || error.message || fallbackMessage : fallbackMessage;
   let isRemoteRef = false;
   try {
     const { stdout: remoteList } = await runGit(cwd, ["remote"]);
@@ -4681,15 +4833,22 @@ async function runGitCheckout(cwd, ref, options) {
   if (isRemoteRef && !options?.createBranch) {
     const remoteSeparatorIndex = ref.indexOf("/");
     const branchName = remoteSeparatorIndex >= 0 ? ref.slice(remoteSeparatorIndex + 1) : ref;
-    args.push("-b", branchName, ref);
+    try {
+      await runGit(cwd, ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`]);
+      const { stdout, stderr } = await runGit(cwd, ["checkout", branchName]);
+      const message = stdout || stderr || `Checkout to ${branchName} completed`;
+      return { success: true, message, branch: branchName };
+    } catch {
+      args.push("-b", branchName, ref);
+    }
     try {
       const { stdout, stderr } = await runGit(cwd, args);
       const message = stdout || stderr || `Checkout to ${ref} completed`;
       return { success: true, message, branch: branchName };
-    } catch {
+    } catch (error) {
       return {
         success: false,
-        message: `Failed to checkout remote branch '${ref}'`
+        message: formatCheckoutError(error, `Failed to checkout remote branch '${ref}'`)
       };
     }
   } else {
@@ -4703,10 +4862,10 @@ async function runGitCheckout(cwd, ref, options) {
       const branch = branchMatch?.[1] ?? ref;
       const message = stdout || stderr || `Checkout to ${ref} completed`;
       return { success: true, message, branch };
-    } catch {
+    } catch (error) {
       return {
         success: false,
-        message: `Failed to checkout '${ref}'`
+        message: formatCheckoutError(error, `Failed to checkout '${ref}'`)
       };
     }
   }
@@ -4721,23 +4880,42 @@ async function runGitCreateBranch(cwd, branchName, options) {
 }
 async function runGitListBranches(cwd) {
   const { stdout: localOutput } = await runGit(cwd, ["branch", "--list"]);
+  const { stdout: localVerboseOutput } = await runGit(cwd, ["branch", "--list", "-vv"]);
   const { stdout: remoteOutput } = await runGit(cwd, ["branch", "-r"]);
   const branches = [];
   let current = "";
+  const linkedWorktreePathsByBranch = /* @__PURE__ */ new Map();
+  const localVerboseLines = localVerboseOutput.split("\n").filter((line) => line.trim());
+  for (const line of localVerboseLines) {
+    const normalizedLine = line.replace(/^[*+ ]\s+/, "");
+    const branchMatch = normalizedLine.match(/^([^\s]+)\s+/);
+    const worktreeMatch = line.match(/\((.+?)\)\s/);
+    if (!branchMatch?.[1] || !worktreeMatch?.[1]) {
+      continue;
+    }
+    const worktreePath = worktreeMatch[1];
+    if (worktreePath.startsWith("/") || worktreePath.startsWith("~")) {
+      linkedWorktreePathsByBranch.set(branchMatch[1], worktreePath);
+    }
+  }
   const localLines = localOutput.split("\n").filter((line) => line.trim());
   for (const line of localLines) {
     const isCurrent = line.startsWith("*");
-    const name = line.replace(/^\*?\s+/, "").trim();
+    const name = line.replace(/^[*+ ]\s+/, "").trim();
     if (name.startsWith("(HEAD detached")) {
       if (isCurrent) {
         current = "";
       }
       continue;
     }
+    if (linkedWorktreePathsByBranch.has(name) && !isCurrent) {
+      continue;
+    }
     branches.push({
       name,
       isRemote: false,
-      isCurrent
+      isCurrent,
+      linkedWorktreePath: linkedWorktreePathsByBranch.get(name)
     });
     if (isCurrent) {
       current = name;
@@ -5186,7 +5364,7 @@ var init_context_builder = __esm({
 });
 
 // packages/server/src/terminal/pty-host.ts
-import { chmodSync, existsSync as existsSync6, statSync } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync7, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import path6 from "node:path";
 function ensureNodePtySpawnHelperExecutable(deps = {}) {
@@ -5196,9 +5374,9 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
   }
   const arch = deps.arch ?? process.arch;
   const resolve4 = deps.resolve ?? ((id) => require2.resolve(id));
-  const fileExists = deps.existsSync ?? existsSync6;
+  const fileExists = deps.existsSync ?? existsSync7;
   const stat7 = deps.statSync ?? statSync;
-  const chmod = deps.chmodSync ?? chmodSync;
+  const chmod = deps.chmodSync ?? chmodSync2;
   let packageJsonPath;
   try {
     packageJsonPath = resolve4(NODE_PTY_PKG);
@@ -7268,9 +7446,9 @@ var init_validator = __esm({
 });
 
 // packages/server/src/fs/gitignore.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 import ignore from "ignore";
-import { join as join4, relative as relative3 } from "path";
+import { join as join5, relative as relative3 } from "path";
 function normalizePath(path10) {
   return path10.replace(/\\/g, "/");
 }
@@ -7290,26 +7468,26 @@ function isIgnoredByGitignore(ig, path10) {
   return ig.ignores(path10) || ig.ignores(`${path10}/`);
 }
 function createGitignoreFilter(rootPath, dirPath) {
-  const gitignorePath = join4(rootPath, ".gitignore");
-  if (!existsSync7(gitignorePath)) {
+  const gitignorePath = join5(rootPath, ".gitignore");
+  if (!existsSync8(gitignorePath)) {
     return (name) => !isDefaultTreeIgnored(name);
   }
-  const gitignoreContent = readFileSync6(gitignorePath, "utf-8");
+  const gitignoreContent = readFileSync7(gitignorePath, "utf-8");
   const ig = ignore().add(gitignoreContent);
   return (name) => {
     if (isAlwaysTreeIgnored(name)) {
       return false;
     }
-    const relativePath = relativeToRoot(rootPath, join4(dirPath, name));
+    const relativePath = relativeToRoot(rootPath, join5(dirPath, name));
     return !isIgnoredByGitignore(ig, relativePath);
   };
 }
 function createWatcherIgnoreFilter(rootPath) {
-  const gitignorePath = join4(rootPath, ".gitignore");
-  if (!existsSync7(gitignorePath)) {
+  const gitignorePath = join5(rootPath, ".gitignore");
+  if (!existsSync8(gitignorePath)) {
     return (path10) => DEFAULT_WATCHER_IGNORED_PATTERNS.some((p) => p.test(normalizePath(path10)));
   }
-  const gitignoreContent = readFileSync6(gitignorePath, "utf-8");
+  const gitignoreContent = readFileSync7(gitignorePath, "utf-8");
   const ig = ignore().add(gitignoreContent);
   return (path10) => {
     const normalizedPath = normalizePath(path10);
@@ -7436,6 +7614,11 @@ var init_manager4 = __esm({
           new WorkspaceWatcher(workspaceId, rootPath, this.deps.broadcaster)
         );
       }
+      hydrateWatchers() {
+        for (const workspace of this.list()) {
+          this.startWatcher(workspace.id, workspace.path);
+        }
+      }
       updateUiState(workspaceId, uiState) {
         const workspace = this.get(workspaceId);
         if (!workspace) {
@@ -8240,8 +8423,12 @@ var init_client = __esm({
       evictedBytesSinceLastWarn = 0;
       lastStreamBufferWarnAt = 0;
       logger;
+      markAlive() {
+        this.isAlive = true;
+      }
       setupSocketHandlers() {
         this.socket.on("message", (data, isBinary) => {
+          this.markAlive();
           if (isBinary) {
             this.messageHandler?.(data);
             return;
@@ -8260,7 +8447,7 @@ var init_client = __esm({
           this.closeHandler?.();
         });
         this.socket.on("pong", () => {
-          this.isAlive = true;
+          this.markAlive();
         });
       }
       /**
@@ -8770,6 +8957,10 @@ var init_hub = __esm({
        */
       pingAll() {
         for (const client of this.clients.values()) {
+          if (!client.alive) {
+            client.close(1011, "keepalive_timeout");
+            continue;
+          }
           client.ping();
         }
       }
@@ -8911,7 +9102,7 @@ var init_hub = __esm({
 // packages/server/src/commands/workspace.ts
 import { readdir as readdir2 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { z as z6 } from "zod";
 var init_workspace = __esm({
   "packages/server/src/commands/workspace.ts"() {
@@ -8930,11 +9121,11 @@ var init_workspace = __esm({
         const entries = await readdir2(basePath, { withFileTypes: true });
         const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => ({
           name: entry.name,
-          path: join5(basePath, entry.name)
+          path: join6(basePath, entry.name)
         })).sort((a, b) => a.name.localeCompare(b.name));
         return {
           currentPath: basePath,
-          parentPath: basePath !== "/" ? join5(basePath, "..") : null,
+          parentPath: basePath !== "/" ? join6(basePath, "..") : null,
           directories
         };
       }
@@ -9028,6 +9219,18 @@ var init_workspace_activity = __esm({
   }
 });
 
+// packages/server/src/commands/connection.ts
+import { z as z8 } from "zod";
+var init_connection = __esm({
+  "packages/server/src/commands/connection.ts"() {
+    "use strict";
+    init_dispatch();
+    registerCommand("connection.probe", z8.object({}).default({}), async () => {
+      return { ok: true };
+    });
+  }
+});
+
 // packages/server/src/provider-runtime/runtime-status.ts
 function canAutoInstall(provider, platform, missingCommands, missingPrerequisites, availableCommands) {
   const strategies = provider.install.strategies[platform] ?? [];
@@ -9122,7 +9325,7 @@ var init_runtime_status = __esm({
 });
 
 // packages/server/src/commands/session.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function getProviderFromRegistry(providerId, registry) {
   return registry.find((provider) => provider.id === providerId);
 }
@@ -9133,8 +9336,8 @@ var init_session = __esm({
     init_dispatch();
     registerCommand(
       "session.list",
-      z8.object({
-        workspaceId: z8.string()
+      z9.object({
+        workspaceId: z9.string()
       }),
       async (args, ctx) => {
         return ctx.sessionMgr.getForWorkspace(args.workspaceId);
@@ -9142,10 +9345,10 @@ var init_session = __esm({
     );
     registerCommand(
       "session.create",
-      z8.object({
-        workspaceId: z8.string(),
-        providerId: z8.string(),
-        draft: z8.string().optional()
+      z9.object({
+        workspaceId: z9.string(),
+        providerId: z9.string(),
+        draft: z9.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9179,8 +9382,8 @@ var init_session = __esm({
     );
     registerCommand(
       "session.stop",
-      z8.object({
-        sessionId: z8.string()
+      z9.object({
+        sessionId: z9.string()
       }),
       async (args, ctx) => {
         await ctx.sessionMgr.stop(args.sessionId);
@@ -9188,8 +9391,8 @@ var init_session = __esm({
     );
     registerCommand(
       "session.remove",
-      z8.object({
-        sessionId: z8.string()
+      z9.object({
+        sessionId: z9.string()
       }),
       async (args, ctx) => {
         const session = ctx.sessionMgr.get(args.sessionId);
@@ -9207,9 +9410,9 @@ var init_session = __esm({
 
 // packages/server/src/fs/tree.ts
 import { readdir as readdir3, stat as stat6 } from "fs/promises";
-import { join as join6, relative as relative4 } from "path";
+import { join as join7, relative as relative4 } from "path";
 async function readTree(rootPath, subdir) {
-  const targetPath = subdir ? join6(rootPath, subdir) : rootPath;
+  const targetPath = subdir ? join7(rootPath, subdir) : rootPath;
   const filter = createGitignoreFilter(rootPath, targetPath);
   const entries = await readdir3(targetPath, { withFileTypes: true });
   const nodes = [];
@@ -9217,7 +9420,7 @@ async function readTree(rootPath, subdir) {
     if (!filter(entry.name)) {
       continue;
     }
-    const fullPath = join6(targetPath, entry.name);
+    const fullPath = join7(targetPath, entry.name);
     const relPath = relative4(rootPath, fullPath);
     if (entry.isDirectory()) {
       nodes.push({
@@ -9261,7 +9464,7 @@ async function searchFiles(rootPath, query, limit = 10) {
     const filteredEntries = entries.filter((entry) => filter(entry.name));
     filteredEntries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of filteredEntries) {
-      const fullPath = join6(dirPath, entry.name);
+      const fullPath = join7(dirPath, entry.name);
       const relPath = relative4(rootPath, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
@@ -9354,7 +9557,7 @@ var init_tree = __esm({
 });
 
 // packages/server/src/commands/file.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var init_file = __esm({
   "packages/server/src/commands/file.ts"() {
     "use strict";
@@ -9363,9 +9566,9 @@ var init_file = __esm({
     init_dispatch();
     registerCommand(
       "file.readTree",
-      z9.object({
-        workspaceId: z9.string(),
-        subPath: z9.string().optional()
+      z10.object({
+        workspaceId: z10.string(),
+        subPath: z10.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9377,10 +9580,10 @@ var init_file = __esm({
     );
     registerCommand(
       "file.search",
-      z9.object({
-        workspaceId: z9.string(),
-        query: z9.string(),
-        limit: z9.number().int().positive().max(50).optional()
+      z10.object({
+        workspaceId: z10.string(),
+        query: z10.string(),
+        limit: z10.number().int().positive().max(50).optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9392,9 +9595,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.read",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string()
+      z10.object({
+        workspaceId: z10.string(),
+        path: z10.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9406,9 +9609,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.create",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string()
+      z10.object({
+        workspaceId: z10.string(),
+        path: z10.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9426,9 +9629,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.mkdir",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string()
+      z10.object({
+        workspaceId: z10.string(),
+        path: z10.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9446,9 +9649,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.delete",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string()
+      z10.object({
+        workspaceId: z10.string(),
+        path: z10.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9466,11 +9669,11 @@ var init_file = __esm({
     );
     registerCommand(
       "file.write",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string(),
-        content: z9.string(),
-        baseHash: z9.string().optional()
+      z10.object({
+        workspaceId: z10.string(),
+        path: z10.string(),
+        content: z10.string(),
+        baseHash: z10.string().optional()
         // For conflict detection
       }),
       async (args, ctx) => {
@@ -9561,7 +9764,7 @@ var init_git_events = __esm({
 });
 
 // packages/server/src/commands/git.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 async function runGitNetworkOperation(ctx, workspaceId, op) {
   if (!ctx.autoFetch?.runExclusive) {
     return op();
@@ -9576,16 +9779,16 @@ var init_git2 = __esm({
     init_diff();
     init_dispatch();
     init_git_events();
-    gitHttpAuthSchema = z10.object({
-      username: z10.string(),
-      password: z10.string()
+    gitHttpAuthSchema = z11.object({
+      username: z11.string(),
+      password: z11.string()
     });
-    gitCommitRevisionSchema = z10.string().regex(/^[0-9a-fA-F]{7,64}$/, "Invalid git commit revision");
+    gitCommitRevisionSchema = z11.string().regex(/^[0-9a-fA-F]{7,64}$/, "Invalid git commit revision");
     GIT_BACKGROUND_FETCH_TIMEOUT_MS = 30 * 1e3;
     registerCommand(
       "git.status",
-      z10.object({
-        workspaceId: z10.string()
+      z11.object({
+        workspaceId: z11.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9597,9 +9800,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.stage",
-      z10.object({
-        workspaceId: z10.string(),
-        paths: z10.array(z10.string())
+      z11.object({
+        workspaceId: z11.string(),
+        paths: z11.array(z11.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9613,10 +9816,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.diff",
-      z10.object({
-        workspaceId: z10.string(),
-        path: z10.string(),
-        staged: z10.boolean().optional()
+      z11.object({
+        workspaceId: z11.string(),
+        path: z11.string(),
+        staged: z11.boolean().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9630,9 +9833,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.log",
-      z10.object({
-        workspaceId: z10.string(),
-        limit: z10.number().int().min(1).max(50).optional()
+      z11.object({
+        workspaceId: z11.string(),
+        limit: z11.number().int().min(1).max(50).optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9646,8 +9849,8 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.show",
-      z10.object({
-        workspaceId: z10.string(),
+      z11.object({
+        workspaceId: z11.string(),
         sha: gitCommitRevisionSchema
       }),
       async (args, ctx) => {
@@ -9662,9 +9865,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.unstage",
-      z10.object({
-        workspaceId: z10.string(),
-        paths: z10.array(z10.string())
+      z11.object({
+        workspaceId: z11.string(),
+        paths: z11.array(z11.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9678,9 +9881,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.discard",
-      z10.object({
-        workspaceId: z10.string(),
-        paths: z10.array(z10.string())
+      z11.object({
+        workspaceId: z11.string(),
+        paths: z11.array(z11.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9696,9 +9899,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.commit",
-      z10.object({
-        workspaceId: z10.string(),
-        message: z10.string()
+      z11.object({
+        workspaceId: z11.string(),
+        message: z11.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9715,11 +9918,11 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.push",
-      z10.object({
-        workspaceId: z10.string(),
-        remote: z10.string().optional(),
-        branch: z10.string().optional(),
-        force: z10.boolean().optional(),
+      z11.object({
+        workspaceId: z11.string(),
+        remote: z11.string().optional(),
+        branch: z11.string().optional(),
+        force: z11.boolean().optional(),
         auth: gitHttpAuthSchema.optional()
       }),
       async (args, ctx) => {
@@ -9746,10 +9949,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.pull",
-      z10.object({
-        workspaceId: z10.string(),
-        remote: z10.string().optional(),
-        branch: z10.string().optional(),
+      z11.object({
+        workspaceId: z11.string(),
+        remote: z11.string().optional(),
+        branch: z11.string().optional(),
         auth: gitHttpAuthSchema.optional()
       }),
       async (args, ctx) => {
@@ -9777,12 +9980,12 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.fetch",
-      z10.object({
-        workspaceId: z10.string(),
-        remote: z10.string().optional(),
-        prune: z10.boolean().optional(),
+      z11.object({
+        workspaceId: z11.string(),
+        remote: z11.string().optional(),
+        prune: z11.boolean().optional(),
         auth: gitHttpAuthSchema.optional(),
-        background: z10.boolean().optional()
+        background: z11.boolean().optional()
       }),
       async (args, ctx, clientId) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9811,10 +10014,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.checkout",
-      z10.object({
-        workspaceId: z10.string(),
-        ref: z10.string(),
-        createBranch: z10.boolean().optional()
+      z11.object({
+        workspaceId: z11.string(),
+        ref: z11.string(),
+        createBranch: z11.boolean().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9836,10 +10039,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.branch",
-      z10.object({
-        workspaceId: z10.string(),
-        name: z10.string(),
-        startPoint: z10.string().optional()
+      z11.object({
+        workspaceId: z11.string(),
+        name: z11.string(),
+        startPoint: z11.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9858,8 +10061,8 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.branches",
-      z10.object({
-        workspaceId: z10.string()
+      z11.object({
+        workspaceId: z11.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9873,37 +10076,37 @@ var init_git2 = __esm({
 });
 
 // packages/server/src/config/config-io.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { basename as basename3, dirname as dirname4, join as join7 } from "node:path";
+import { basename as basename3, dirname as dirname5, join as join8 } from "node:path";
 function resolveConfigPath(configType) {
   if (configType === "codex") {
     const testHome = process.env.CODER_STUDIO_CODEX_HOME;
     if (testHome && testHome.trim()) {
-      return join7(testHome, "config.toml");
+      return join8(testHome, "config.toml");
     }
     const codexHome = process.env.CODEX_HOME;
     if (codexHome && codexHome.trim()) {
-      return join7(codexHome, "config.toml");
+      return join8(codexHome, "config.toml");
     }
-    return join7(homedir4(), ".codex", "config.toml");
+    return join8(homedir4(), ".codex", "config.toml");
   }
   if (configType === "claude") {
     const testHome = process.env.CODER_STUDIO_CLAUDE_HOME;
     if (testHome && testHome.trim()) {
-      return join7(testHome, "settings.json");
+      return join8(testHome, "settings.json");
     }
-    return join7(homedir4(), ".claude", "settings.json");
+    return join8(homedir4(), ".claude", "settings.json");
   }
   throw new Error(`Unknown config type: ${configType}`);
 }
 function readConfigFile(configType) {
   const configPath = resolveConfigPath(configType);
-  if (!existsSync8(configPath)) {
+  if (!existsSync9(configPath)) {
     return { configPath, content: "", exists: false };
   }
   try {
-    const content = readFileSync7(configPath, "utf-8");
+    const content = readFileSync8(configPath, "utf-8");
     return { configPath, content, exists: true };
   } catch {
     return { configPath, content: "", exists: false };
@@ -9912,16 +10115,16 @@ function readConfigFile(configType) {
 function writeConfigFile(configType, content) {
   try {
     const configPath = resolveConfigPath(configType);
-    const parentDir = dirname4(configPath);
-    if (!existsSync8(parentDir)) {
-      mkdirSync3(parentDir, { recursive: true });
+    const parentDir = dirname5(configPath);
+    if (!existsSync9(parentDir)) {
+      mkdirSync4(parentDir, { recursive: true });
     }
     let backupPath = null;
-    if (existsSync8(configPath)) {
+    if (existsSync9(configPath)) {
       backupPath = createBackup(configPath);
     }
     const tempPath = `${configPath}.tmp`;
-    writeFileSync3(tempPath, content, "utf-8");
+    writeFileSync4(tempPath, content, "utf-8");
     renameSync(tempPath, configPath);
     return { success: true, backupPath };
   } catch (error) {
@@ -9933,13 +10136,13 @@ function writeConfigFile(configType, content) {
   }
 }
 function createBackup(filePath) {
-  const original = readFileSync7(filePath, "utf-8");
+  const original = readFileSync8(filePath, "utf-8");
   const ext = filePath.split(".").pop() ?? "";
   const base = basename3(filePath, `.${ext}`);
-  const dir = dirname4(filePath);
+  const dir = dirname5(filePath);
   const ts = formatTimestamp(/* @__PURE__ */ new Date());
-  const backupPath = join7(dir, `${base}.bak.${ts}.${ext}`);
-  writeFileSync3(backupPath, original, "utf-8");
+  const backupPath = join8(dir, `${base}.bak.${ts}.${ext}`);
+  writeFileSync4(backupPath, original, "utf-8");
   return backupPath;
 }
 function formatTimestamp(d) {
@@ -9953,7 +10156,7 @@ var init_config_io = __esm({
 });
 
 // packages/server/src/commands/settings.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function flattenSettings(obj, prefix = "") {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
@@ -9976,27 +10179,28 @@ var init_settings2 = __esm({
     init_provider_config_repo();
     init_settings();
     init_dispatch();
-    SettingsSchema = z11.object({
-      defaultProviderId: z11.string().optional(),
-      notifications: z11.object({
-        enabled: z11.boolean().optional(),
-        soundEnabled: z11.boolean().optional(),
+    SettingsSchema = z12.object({
+      defaultProviderId: z12.string().optional(),
+      notifications: z12.object({
+        enabled: z12.boolean().optional(),
+        soundEnabled: z12.boolean().optional(),
         // Legacy field — accepted for backward compat with older clients but
         // no longer surfaced in the UI. The web client now picks the channel
         // automatically based on workspace focus + page visibility.
-        onlyWhenBackgrounded: z11.boolean().optional()
+        onlyWhenBackgrounded: z12.boolean().optional()
       }).optional(),
-      supervisor: z11.object({
-        evaluationTimeoutSec: z11.number().int().min(1).max(MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC).default(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC).optional()
+      supervisor: z12.object({
+        evaluationTimeoutSec: z12.number().int().min(1).max(MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC).default(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC).optional()
       }).optional(),
-      appearance: z11.object({
-        theme: z11.enum(["dark"]).optional(),
-        terminalRenderer: z11.enum(["standard", "compatibility"]).optional(),
-        locale: z11.enum(["zh", "en"]).optional()
+      appearance: z12.object({
+        theme: z12.enum(["dark"]).optional(),
+        terminalRenderer: z12.enum(["standard", "compatibility"]).optional(),
+        terminalCopyOnSelect: z12.boolean().optional(),
+        locale: z12.enum(["zh", "en"]).optional()
       }).optional(),
       providers: ProviderSettingsSchema.optional()
     });
-    registerCommand("settings.get", z11.object({}), async (_args, ctx) => {
+    registerCommand("settings.get", z12.object({}), async (_args, ctx) => {
       const row = ctx.db.prepare("SELECT key, value FROM user_settings").all();
       const settings = {};
       for (const { key, value } of row) {
@@ -10029,7 +10233,7 @@ var init_settings2 = __esm({
     });
     registerCommand(
       "settings.update",
-      z11.object({
+      z12.object({
         settings: SettingsSchema
       }),
       async (args, ctx) => {
@@ -10061,10 +10265,10 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.previewCommand",
-      z11.object({
-        providerId: z11.string(),
+      z12.object({
+        providerId: z12.string(),
         config: ProviderLaunchConfigInputSchema,
-        workspacePath: z11.string().optional()
+        workspacePath: z12.string().optional()
       }),
       async (args, ctx) => {
         const provider = ctx.providerRegistry.find((item) => item.id === args.providerId);
@@ -10085,8 +10289,8 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.readConfigFile",
-      z11.object({
-        configType: z11.enum(["codex", "claude"])
+      z12.object({
+        configType: z12.enum(["codex", "claude"])
       }),
       async (args) => {
         const result = readConfigFile(args.configType);
@@ -10095,9 +10299,9 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.writeConfigFile",
-      z11.object({
-        configType: z11.enum(["codex", "claude"]),
-        content: z11.string()
+      z12.object({
+        configType: z12.enum(["codex", "claude"]),
+        content: z12.string()
       }),
       async (args) => {
         const result = writeConfigFile(args.configType, args.content);
@@ -10108,19 +10312,19 @@ var init_settings2 = __esm({
 });
 
 // packages/server/src/commands/provider.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var init_provider = __esm({
   "packages/server/src/commands/provider.ts"() {
     "use strict";
     init_runtime_status();
     init_dispatch();
-    registerCommand("provider.runtimeStatus", z12.object({}), async (_args, ctx) => {
+    registerCommand("provider.runtimeStatus", z13.object({}), async (_args, ctx) => {
       return buildProviderRuntimeStatus(ctx.providerRegistry, ctx.providerRuntimeDeps);
     });
     registerCommand(
       "provider.install.start",
-      z12.object({
-        providerId: z12.string()
+      z13.object({
+        providerId: z13.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -10134,8 +10338,8 @@ var init_provider = __esm({
     );
     registerCommand(
       "provider.install.get",
-      z12.object({
-        jobId: z12.string()
+      z13.object({
+        jobId: z13.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -10158,29 +10362,29 @@ var init_provider = __esm({
 });
 
 // packages/server/src/commands/supervisor.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var supervisorObjectiveSchema, createSupervisorSchema, updateSupervisorSchema, sessionIdSchema, supervisorIdSchema;
 var init_supervisor2 = __esm({
   "packages/server/src/commands/supervisor.ts"() {
     "use strict";
     init_dispatch();
-    supervisorObjectiveSchema = z13.string().trim().min(1).max(4e3);
-    createSupervisorSchema = z13.object({
-      sessionId: z13.string(),
-      workspaceId: z13.string(),
+    supervisorObjectiveSchema = z14.string().trim().min(1).max(4e3);
+    createSupervisorSchema = z14.object({
+      sessionId: z14.string(),
+      workspaceId: z14.string(),
       objective: supervisorObjectiveSchema,
-      evaluatorProviderId: z13.string()
+      evaluatorProviderId: z14.string()
     }).strict();
-    updateSupervisorSchema = z13.object({
-      id: z13.string(),
+    updateSupervisorSchema = z14.object({
+      id: z14.string(),
       objective: supervisorObjectiveSchema.optional(),
-      evaluatorProviderId: z13.string().optional()
+      evaluatorProviderId: z14.string().optional()
     }).strict().refine(
       (input) => input.objective !== void 0 || input.evaluatorProviderId !== void 0,
       "objective or evaluatorProviderId is required"
     );
-    sessionIdSchema = z13.object({ sessionId: z13.string() });
-    supervisorIdSchema = z13.object({ id: z13.string() });
+    sessionIdSchema = z14.object({ sessionId: z14.string() });
+    supervisorIdSchema = z14.object({ id: z14.string() });
     registerCommand("supervisor.create", createSupervisorSchema, async (args, ctx) => {
       return {
         supervisor: await ctx.supervisorMgr.create({
@@ -10358,7 +10562,7 @@ var init_worktree = __esm({
 
 // packages/server/src/commands/worktree.ts
 import path9 from "node:path";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 async function findRelatedWorkspaceIds(ctx, workspacePath) {
   const targetCommonDir = await getGitCommonDirPath(workspacePath);
   const relatedWorkspaceIds = await Promise.all(
@@ -10391,7 +10595,7 @@ var init_worktree2 = __esm({
     init_worktree();
     init_dispatch();
     init_git_events();
-    registerCommand("worktree.list", z14.object({ workspaceId: z14.string() }), async (args, ctx) => {
+    registerCommand("worktree.list", z15.object({ workspaceId: z15.string() }), async (args, ctx) => {
       const workspace = ctx.workspaceMgr.get(args.workspaceId);
       if (!workspace) {
         throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
@@ -10400,7 +10604,7 @@ var init_worktree2 = __esm({
     });
     registerCommand(
       "worktree.status",
-      z14.object({ workspaceId: z14.string(), worktreePath: z14.string() }),
+      z15.object({ workspaceId: z15.string(), worktreePath: z15.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -10412,10 +10616,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.diff",
-      z14.object({
-        workspaceId: z14.string(),
-        worktreePath: z14.string(),
-        staged: z14.boolean().optional().default(false)
+      z15.object({
+        workspaceId: z15.string(),
+        worktreePath: z15.string(),
+        staged: z15.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10428,7 +10632,7 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.tree",
-      z14.object({ workspaceId: z14.string(), worktreePath: z14.string() }),
+      z15.object({ workspaceId: z15.string(), worktreePath: z15.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -10440,10 +10644,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.create",
-      z14.object({
-        workspaceId: z14.string(),
-        branch: z14.string(),
-        path: z14.string()
+      z15.object({
+        workspaceId: z15.string(),
+        branch: z15.string(),
+        path: z15.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10458,10 +10662,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.remove",
-      z14.object({
-        workspaceId: z14.string(),
-        worktreePath: z14.string(),
-        force: z14.boolean().optional().default(false)
+      z15.object({
+        workspaceId: z15.string(),
+        worktreePath: z15.string(),
+        force: z15.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10485,7 +10689,7 @@ var init_worktree2 = __esm({
 });
 
 // packages/server/src/commands/fencing.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function createMockFencingRequest() {
   return {
     ip: "127.0.0.1",
@@ -10498,9 +10702,9 @@ var init_fencing2 = __esm({
     init_dispatch();
     registerCommand(
       "fencing.request",
-      z15.object({
-        workspaceId: z15.string(),
-        tabId: z15.string()
+      z16.object({
+        workspaceId: z16.string(),
+        tabId: z16.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.requestControl(
@@ -10513,7 +10717,7 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.heartbeat",
-      z15.object({ workspaceId: z15.string() }),
+      z16.object({ workspaceId: z16.string() }),
       async (args, ctx, clientId) => {
         const success = ctx.fencingMgr.heartbeat(args.workspaceId, clientId);
         return { success };
@@ -10521,13 +10725,13 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.release",
-      z15.object({ workspaceId: z15.string() }),
+      z16.object({ workspaceId: z16.string() }),
       async (args, ctx, clientId) => {
         ctx.fencingMgr.release(args.workspaceId, clientId);
         return {};
       }
     );
-    registerCommand("fencing.status", z15.object({ workspaceId: z15.string() }), async (args, ctx) => {
+    registerCommand("fencing.status", z16.object({ workspaceId: z16.string() }), async (args, ctx) => {
       const controller = ctx.fencingMgr.getController(args.workspaceId);
       const isUnresponsive = ctx.fencingMgr.isControllerUnresponsive(args.workspaceId);
       return {
@@ -10538,9 +10742,9 @@ var init_fencing2 = __esm({
     });
     registerCommand(
       "fencing.takeover",
-      z15.object({
-        workspaceId: z15.string(),
-        tabId: z15.string()
+      z16.object({
+        workspaceId: z16.string(),
+        tabId: z16.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.forceTakeover(
@@ -10560,6 +10764,7 @@ var init_commands = __esm({
     "use strict";
     init_workspace();
     init_workspace_activity();
+    init_connection();
     init_session();
     init_terminal();
     init_file();
@@ -10643,6 +10848,7 @@ async function createServer(configOverrides) {
       (err) => console.warn("[uploads] cascade cleanup failed", { wsId: workspaceId, err })
     )
   });
+  workspaceMgr.hydrateWatchers();
   const authSessionRepo = new AuthSessionRepo(db);
   const authLoginBlockRepo = new AuthLoginBlockRepo(db);
   const app = await buildFastifyApp({
@@ -10682,10 +10888,13 @@ async function createServer(configOverrides) {
   });
   await sessionMgr.hydrate();
   await supervisorMgr.hydrate();
-  const providerRuntimeDeps = {};
+  const providerMockOverrides = createE2EProviderMockOverrides();
+  const providerRuntimeDeps = providerMockOverrides ? {
+    commandExists: providerMockOverrides.commandExists
+  } : {};
   const providerInstallMgr = new ProviderInstallManager(providerRegistry, {
     ...providerRuntimeDeps,
-    runCommand: runCommandAsString
+    runCommand: providerMockOverrides?.runCommand ?? runCommandAsString
   });
   commandContext = {
     workspaceMgr,
@@ -10724,11 +10933,16 @@ async function createServer(configOverrides) {
     );
   }, STARTUP_GC_DELAY_MS);
   gcTimer.unref();
+  const wsKeepaliveTimer = setInterval(() => {
+    wsHub.pingAll();
+  }, WS_KEEPALIVE_INTERVAL_MS);
+  wsKeepaliveTimer.unref();
   let stopped = false;
   const stopServer = async () => {
     if (stopped) return;
     stopped = true;
     clearTimeout(gcTimer);
+    clearInterval(wsKeepaliveTimer);
     await app.close();
     autoFetch.stop();
     supervisorMgr.stop();
@@ -10844,6 +11058,7 @@ function createSessionDatabase(db) {
     }
   };
 }
+var WS_KEEPALIVE_INTERVAL_MS;
 var init_server = __esm({
   async "packages/server/src/server.ts"() {
     "use strict";
@@ -10855,6 +11070,7 @@ var init_server = __esm({
     init_config();
     init_auto_fetch();
     init_command_runner();
+    init_e2e_provider_mock();
     init_install_manager();
     init_manager();
     init_db();
@@ -10875,6 +11091,7 @@ var init_server = __esm({
     init_fencing();
     init_hub();
     init_commands();
+    WS_KEEPALIVE_INTERVAL_MS = 15e3;
     if (isDirectExecution(import.meta.url)) {
       const server = await createServer();
       process.on("SIGINT", async () => {