@spencer-kit/coder-studio 0.3.3 → 0.3.5

package/dist/esm/bin.mjs

@@ -885,11 +885,11 @@ function resolveSpawnArgv(argv, deps = {}) {
     return [];
   }
   const restArgs = argv.slice(1);
-  const readFileSync8 = deps.readFileSync ?? ((file) => fs2.readFileSync(file, "utf8"));
-  const existsSync11 = deps.existsSync ?? fs2.existsSync;
+  const readFileSync9 = deps.readFileSync ?? ((file) => fs2.readFileSync(file, "utf8"));
+  const existsSync12 = 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, existsSync11);
+  const resolved = resolveExecutablePath(command, pathEnv, pathExt, existsSync12);
   if (!resolved) {
     return [...argv];
   }
@@ -900,7 +900,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];
     }
@@ -938,17 +938,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, existsSync11) {
+function resolveExecutablePath(command, pathEnv, pathExt, existsSync12) {
   const hasExt = path2.win32.extname(command).length > 0;
   const extensions = parsePathExt(pathExt);
   if (path2.win32.isAbsolute(command)) {
-    if (existsSync11(command)) {
+    if (existsSync12(command)) {
       return command;
     }
     if (!hasExt) {
       for (const ext of extensions) {
         const candidate = command + ext;
-        if (existsSync11(candidate)) {
+        if (existsSync12(candidate)) {
           return candidate;
         }
       }
@@ -959,14 +959,14 @@ function resolveExecutablePath(command, pathEnv, pathExt, existsSync11) {
   for (const dir of dirs) {
     if (hasExt) {
       const candidate = path2.win32.join(dir, command);
-      if (existsSync11(candidate)) {
+      if (existsSync12(candidate)) {
         return candidate;
       }
       continue;
     }
     for (const ext of extensions) {
       const candidate = path2.win32.join(dir, command + ext);
-      if (existsSync11(candidate)) {
+      if (existsSync12(candidate)) {
         return candidate;
       }
     }
@@ -2129,6 +2129,157 @@ var init_command_check = __esm({
   }
 });
 
+// packages/server/src/provider-runtime/e2e-provider-mock.ts
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join2 } 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 (!existsSync3(statePath)) {
+    return {};
+  }
+  const raw = readFileSync3(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);
+  mkdirSync2(dirname3(statePath), { recursive: true });
+  writeFileSync2(statePath, JSON.stringify(nextState, null, 2));
+  return nextState;
+}
+function ensureProviderCommand(binDir, providerId) {
+  mkdirSync2(binDir, { recursive: true });
+  const scriptPath = join2(binDir, providerId);
+  writeFileSync2(scriptPath, PROVIDER_COMMAND_SCRIPTS[providerId], "utf8");
+  chmodSync(scriptPath, 493);
+}
+function appendDebugLog(path10, line) {
+  if (!path10) {
+    return;
+  }
+  mkdirSync2(dirname3(path10), { recursive: true });
+  writeFileSync2(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) {
@@ -3611,8 +3762,8 @@ var init_database = __esm({
 
 // packages/server/src/storage/db.ts
 import { DatabaseSync } from "node:sqlite";
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join2 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join3 } from "path";
 function normalizeSql(sql) {
   return (sql ?? "").replace(/\s+/g, " ").trim();
 }
@@ -3759,8 +3910,8 @@ var init_db = __esm({
   "packages/server/src/storage/db.ts"() {
     "use strict";
     init_database();
-    SCHEMA_PATH = join2(import.meta.dirname, "migrations", "001_init.sql");
-    SCHEMA_SQL = readFileSync3(SCHEMA_PATH, "utf-8");
+    SCHEMA_PATH = join3(import.meta.dirname, "migrations", "001_init.sql");
+    SCHEMA_SQL = readFileSync4(SCHEMA_PATH, "utf-8");
     LEGACY_TABLES = ["hook_registrations", "_migrations"];
     LEGACY_SESSION_COLUMNS = ["resume_id", "transcript_path"];
     EXPECTED_SCHEMA_ENTRIES = buildExpectedSchemaEntries();
@@ -4692,6 +4843,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"]);
@@ -4703,15 +4855,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 {
@@ -4725,10 +4884,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}'`)
       };
     }
   }
@@ -4743,23 +4902,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;
@@ -5208,7 +5386,7 @@ var init_context_builder = __esm({
 });
 
 // packages/server/src/terminal/pty-host.ts
-import { chmodSync, existsSync as existsSync3, statSync } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync4, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import path6 from "node:path";
 function ensureNodePtySpawnHelperExecutable(deps = {}) {
@@ -5218,9 +5396,9 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
   }
   const arch = deps.arch ?? process.arch;
   const resolve4 = deps.resolve ?? ((id) => require2.resolve(id));
-  const fileExists = deps.existsSync ?? existsSync3;
+  const fileExists = deps.existsSync ?? existsSync4;
   const stat7 = deps.statSync ?? statSync;
-  const chmod = deps.chmodSync ?? chmodSync;
+  const chmod = deps.chmodSync ?? chmodSync2;
   let packageJsonPath;
   try {
     packageJsonPath = resolve4(NODE_PTY_PKG);
@@ -7290,9 +7468,9 @@ var init_validator = __esm({
 });
 
 // packages/server/src/fs/gitignore.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import ignore from "ignore";
-import { join as join3, relative as relative3 } from "path";
+import { join as join4, relative as relative3 } from "path";
 function normalizePath(path10) {
   return path10.replace(/\\/g, "/");
 }
@@ -7312,26 +7490,26 @@ function isIgnoredByGitignore(ig, path10) {
   return ig.ignores(path10) || ig.ignores(`${path10}/`);
 }
 function createGitignoreFilter(rootPath, dirPath) {
-  const gitignorePath = join3(rootPath, ".gitignore");
-  if (!existsSync4(gitignorePath)) {
+  const gitignorePath = join4(rootPath, ".gitignore");
+  if (!existsSync5(gitignorePath)) {
     return (name) => !isDefaultTreeIgnored(name);
   }
-  const gitignoreContent = readFileSync4(gitignorePath, "utf-8");
+  const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
   const ig = ignore().add(gitignoreContent);
   return (name) => {
     if (isAlwaysTreeIgnored(name)) {
       return false;
     }
-    const relativePath = relativeToRoot(rootPath, join3(dirPath, name));
+    const relativePath = relativeToRoot(rootPath, join4(dirPath, name));
     return !isIgnoredByGitignore(ig, relativePath);
   };
 }
 function createWatcherIgnoreFilter(rootPath) {
-  const gitignorePath = join3(rootPath, ".gitignore");
-  if (!existsSync4(gitignorePath)) {
+  const gitignorePath = join4(rootPath, ".gitignore");
+  if (!existsSync5(gitignorePath)) {
     return (path10) => DEFAULT_WATCHER_IGNORED_PATTERNS.some((p) => p.test(normalizePath(path10)));
   }
-  const gitignoreContent = readFileSync4(gitignorePath, "utf-8");
+  const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
   const ig = ignore().add(gitignoreContent);
   return (path10) => {
     const normalizedPath = normalizePath(path10);
@@ -7458,6 +7636,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) {
@@ -8262,8 +8445,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;
@@ -8282,7 +8469,7 @@ var init_client = __esm({
           this.closeHandler?.();
         });
         this.socket.on("pong", () => {
-          this.isAlive = true;
+          this.markAlive();
         });
       }
       /**
@@ -8792,6 +8979,10 @@ var init_hub = __esm({
        */
       pingAll() {
         for (const client of this.clients.values()) {
+          if (!client.alive) {
+            client.close(1011, "keepalive_timeout");
+            continue;
+          }
           client.ping();
         }
       }
@@ -8933,7 +9124,7 @@ var init_hub = __esm({
 // packages/server/src/commands/workspace.ts
 import { readdir as readdir2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { z as z6 } from "zod";
 var init_workspace = __esm({
   "packages/server/src/commands/workspace.ts"() {
@@ -8952,11 +9143,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: join4(basePath, entry.name)
+          path: join5(basePath, entry.name)
         })).sort((a, b) => a.name.localeCompare(b.name));
         return {
           currentPath: basePath,
-          parentPath: basePath !== "/" ? join4(basePath, "..") : null,
+          parentPath: basePath !== "/" ? join5(basePath, "..") : null,
           directories
         };
       }
@@ -9050,6 +9241,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] ?? [];
@@ -9144,7 +9347,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);
 }
@@ -9155,8 +9358,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);
@@ -9164,10 +9367,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);
@@ -9201,8 +9404,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);
@@ -9210,8 +9413,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);
@@ -9229,9 +9432,9 @@ var init_session = __esm({
 
 // packages/server/src/fs/tree.ts
 import { readdir as readdir3, stat as stat6 } from "fs/promises";
-import { join as join5, relative as relative4 } from "path";
+import { join as join6, relative as relative4 } from "path";
 async function readTree(rootPath, subdir) {
-  const targetPath = subdir ? join5(rootPath, subdir) : rootPath;
+  const targetPath = subdir ? join6(rootPath, subdir) : rootPath;
   const filter = createGitignoreFilter(rootPath, targetPath);
   const entries = await readdir3(targetPath, { withFileTypes: true });
   const nodes = [];
@@ -9239,7 +9442,7 @@ async function readTree(rootPath, subdir) {
     if (!filter(entry.name)) {
       continue;
     }
-    const fullPath = join5(targetPath, entry.name);
+    const fullPath = join6(targetPath, entry.name);
     const relPath = relative4(rootPath, fullPath);
     if (entry.isDirectory()) {
       nodes.push({
@@ -9283,7 +9486,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 = join5(dirPath, entry.name);
+      const fullPath = join6(dirPath, entry.name);
       const relPath = relative4(rootPath, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
@@ -9376,7 +9579,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";
@@ -9385,9 +9588,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);
@@ -9399,10 +9602,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);
@@ -9414,9 +9617,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);
@@ -9428,9 +9631,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);
@@ -9448,9 +9651,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);
@@ -9468,9 +9671,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);
@@ -9488,11 +9691,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) => {
@@ -9583,7 +9786,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();
@@ -9598,16 +9801,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);
@@ -9619,9 +9822,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);
@@ -9635,10 +9838,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);
@@ -9652,9 +9855,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);
@@ -9668,8 +9871,8 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.show",
-      z10.object({
-        workspaceId: z10.string(),
+      z11.object({
+        workspaceId: z11.string(),
         sha: gitCommitRevisionSchema
       }),
       async (args, ctx) => {
@@ -9684,9 +9887,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);
@@ -9700,9 +9903,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);
@@ -9718,9 +9921,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);
@@ -9737,11 +9940,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) => {
@@ -9768,10 +9971,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) => {
@@ -9799,12 +10002,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);
@@ -9833,10 +10036,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);
@@ -9858,10 +10061,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);
@@ -9880,8 +10083,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);
@@ -9895,37 +10098,37 @@ var init_git2 = __esm({
 });
 
 // packages/server/src/config/config-io.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename2, dirname as dirname3, join as join6 } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join7 } from "node:path";
 function resolveConfigPath(configType) {
   if (configType === "codex") {
     const testHome = process.env.CODER_STUDIO_CODEX_HOME;
     if (testHome && testHome.trim()) {
-      return join6(testHome, "config.toml");
+      return join7(testHome, "config.toml");
     }
     const codexHome = process.env.CODEX_HOME;
     if (codexHome && codexHome.trim()) {
-      return join6(codexHome, "config.toml");
+      return join7(codexHome, "config.toml");
     }
-    return join6(homedir3(), ".codex", "config.toml");
+    return join7(homedir3(), ".codex", "config.toml");
   }
   if (configType === "claude") {
     const testHome = process.env.CODER_STUDIO_CLAUDE_HOME;
     if (testHome && testHome.trim()) {
-      return join6(testHome, "settings.json");
+      return join7(testHome, "settings.json");
     }
-    return join6(homedir3(), ".claude", "settings.json");
+    return join7(homedir3(), ".claude", "settings.json");
   }
   throw new Error(`Unknown config type: ${configType}`);
 }
 function readConfigFile(configType) {
   const configPath = resolveConfigPath(configType);
-  if (!existsSync5(configPath)) {
+  if (!existsSync6(configPath)) {
     return { configPath, content: "", exists: false };
   }
   try {
-    const content = readFileSync5(configPath, "utf-8");
+    const content = readFileSync6(configPath, "utf-8");
     return { configPath, content, exists: true };
   } catch {
     return { configPath, content: "", exists: false };
@@ -9934,16 +10137,16 @@ function readConfigFile(configType) {
 function writeConfigFile(configType, content) {
   try {
     const configPath = resolveConfigPath(configType);
-    const parentDir = dirname3(configPath);
-    if (!existsSync5(parentDir)) {
-      mkdirSync2(parentDir, { recursive: true });
+    const parentDir = dirname4(configPath);
+    if (!existsSync6(parentDir)) {
+      mkdirSync3(parentDir, { recursive: true });
     }
     let backupPath = null;
-    if (existsSync5(configPath)) {
+    if (existsSync6(configPath)) {
       backupPath = createBackup(configPath);
     }
     const tempPath = `${configPath}.tmp`;
-    writeFileSync2(tempPath, content, "utf-8");
+    writeFileSync3(tempPath, content, "utf-8");
     renameSync(tempPath, configPath);
     return { success: true, backupPath };
   } catch (error) {
@@ -9955,13 +10158,13 @@ function writeConfigFile(configType, content) {
   }
 }
 function createBackup(filePath) {
-  const original = readFileSync5(filePath, "utf-8");
+  const original = readFileSync6(filePath, "utf-8");
   const ext = filePath.split(".").pop() ?? "";
   const base = basename2(filePath, `.${ext}`);
-  const dir = dirname3(filePath);
+  const dir = dirname4(filePath);
   const ts = formatTimestamp(/* @__PURE__ */ new Date());
-  const backupPath = join6(dir, `${base}.bak.${ts}.${ext}`);
-  writeFileSync2(backupPath, original, "utf-8");
+  const backupPath = join7(dir, `${base}.bak.${ts}.${ext}`);
+  writeFileSync3(backupPath, original, "utf-8");
   return backupPath;
 }
 function formatTimestamp(d) {
@@ -9975,7 +10178,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)) {
@@ -9998,27 +10201,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) {
@@ -10051,7 +10255,7 @@ var init_settings2 = __esm({
     });
     registerCommand(
       "settings.update",
-      z11.object({
+      z12.object({
         settings: SettingsSchema
       }),
       async (args, ctx) => {
@@ -10083,10 +10287,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);
@@ -10107,8 +10311,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);
@@ -10117,9 +10321,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);
@@ -10130,19 +10334,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) {
@@ -10156,8 +10360,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) {
@@ -10180,29 +10384,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(
       (input2) => input2.objective !== void 0 || input2.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({
@@ -10380,7 +10584,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(
@@ -10413,7 +10617,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}` };
@@ -10422,7 +10626,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) {
@@ -10434,10 +10638,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);
@@ -10450,7 +10654,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) {
@@ -10462,10 +10666,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);
@@ -10480,10 +10684,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);
@@ -10507,7 +10711,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",
@@ -10520,9 +10724,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(
@@ -10535,7 +10739,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 };
@@ -10543,13 +10747,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 {
@@ -10560,9 +10764,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(
@@ -10582,6 +10786,7 @@ var init_commands = __esm({
     "use strict";
     init_workspace();
     init_workspace_activity();
+    init_connection();
     init_session();
     init_terminal();
     init_file();
@@ -10665,6 +10870,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({
@@ -10704,10 +10910,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,
@@ -10746,11 +10955,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();
@@ -10866,6 +11080,7 @@ function createSessionDatabase(db) {
     }
   };
 }
+var WS_KEEPALIVE_INTERVAL_MS;
 var init_server = __esm({
   async "packages/server/src/server.ts"() {
     "use strict";
@@ -10877,6 +11092,7 @@ var init_server = __esm({
     init_config();
     init_auto_fetch();
     init_command_runner();
+    init_e2e_provider_mock();
     init_install_manager();
     init_manager();
     init_db();
@@ -10897,6 +11113,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 () => {
@@ -11183,20 +11400,20 @@ var init_src4 = __esm({
 });
 
 // packages/cli/src/cli.ts
-import { existsSync as existsSync10 } from "fs";
-import { dirname as dirname5, join as join9 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { dirname as dirname6, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // packages/cli/src/auth-control.ts
 await init_src4();
 
 // packages/cli/src/config-store.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename3, join as join7 } from "path";
+import { basename as basename3, join as join8 } from "path";
 var DEFAULT_DB_FILE = "coder-studio.db";
 function getCliConfigPath() {
-  return join7(homedir4(), ".coder-studio", "config.json");
+  return join8(homedir4(), ".coder-studio", "config.json");
 }
 function normalizeDataDir(input2) {
   if (input2.endsWith(".db")) {
@@ -11205,15 +11422,15 @@ function normalizeDataDir(input2) {
   if (basename3(input2).includes(".")) {
     return input2;
   }
-  return join7(input2, DEFAULT_DB_FILE);
+  return join8(input2, DEFAULT_DB_FILE);
 }
 function readCliConfig() {
   const path10 = getCliConfigPath();
-  if (!existsSync6(path10)) {
+  if (!existsSync7(path10)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync6(path10, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(path10, "utf-8"));
     if (parsed.host !== void 0 && typeof parsed.host !== "string" || parsed.port !== void 0 && typeof parsed.port !== "number" || parsed.dataDir !== void 0 && typeof parsed.dataDir !== "string" || parsed.password !== void 0 && typeof parsed.password !== "string") {
       return null;
     }
@@ -11224,17 +11441,17 @@ function readCliConfig() {
 }
 function writeCliConfig(config) {
   const path10 = getCliConfigPath();
-  const dir = join7(homedir4(), ".coder-studio");
+  const dir = join8(homedir4(), ".coder-studio");
   const normalizedConfig = {
     ...config.host !== void 0 ? { host: config.host } : {},
     ...config.port !== void 0 && config.port > 0 ? { port: config.port } : {},
     ...config.dataDir !== void 0 ? { dataDir: normalizeDataDir(config.dataDir) } : {},
     ...config.password !== void 0 ? { password: config.password } : {}
   };
-  if (!existsSync6(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  if (!existsSync7(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
-  writeFileSync3(path10, JSON.stringify(normalizedConfig, null, 2), "utf-8");
+  writeFileSync4(path10, JSON.stringify(normalizedConfig, null, 2), "utf-8");
 }
 
 // packages/cli/src/auth-control.ts
@@ -11298,12 +11515,12 @@ async function openBrowser(url) {
 }
 
 // packages/cli/src/log-excerpt.ts
-import { closeSync, existsSync as existsSync7, openSync, readSync, statSync as statSync2 } from "fs";
+import { closeSync, existsSync as existsSync8, openSync, readSync, statSync as statSync2 } from "fs";
 var DEFAULT_MAX_LINES = 40;
 var DEFAULT_MAX_CHARS = 4e3;
 var DEFAULT_MAX_BYTES = 16 * 1024;
 var getFileSize = (path10) => {
-  if (!existsSync7(path10)) {
+  if (!existsSync8(path10)) {
     return 0;
   }
   try {
@@ -11318,7 +11535,7 @@ var readLogExcerpt = (path10, {
   maxLines = DEFAULT_MAX_LINES,
   maxChars = DEFAULT_MAX_CHARS
 } = {}) => {
-  if (!existsSync7(path10)) {
+  if (!existsSync8(path10)) {
     return null;
   }
   const fileSize = getFileSize(path10);
@@ -11397,12 +11614,12 @@ function assertSupportedNodeVersion(version = process.versions.node) {
 }
 
 // packages/cli/src/package-manifest.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
 function resolveCliPackageManifestUrl(importMetaUrl) {
   const manifestUrl = [
     new URL("../package.json", importMetaUrl),
     new URL("../../package.json", importMetaUrl)
-  ].find((candidate) => existsSync8(candidate));
+  ].find((candidate) => existsSync9(candidate));
   if (!manifestUrl) {
     throw new Error("Unable to locate CLI package.json");
   }
@@ -11410,7 +11627,7 @@ function resolveCliPackageManifestUrl(importMetaUrl) {
 }
 function getCliPackageManifest(importMetaUrl) {
   return JSON.parse(
-    readFileSync7(resolveCliPackageManifestUrl(importMetaUrl), "utf-8")
+    readFileSync8(resolveCliPackageManifestUrl(importMetaUrl), "utf-8")
   );
 }
 function getCliVersion(importMetaUrl) {
@@ -11619,9 +11836,9 @@ function parseArgs(argv) {
 
 // packages/cli/src/pm2-control.ts
 init_runtime();
-import { mkdirSync as mkdirSync4 } from "fs";
+import { mkdirSync as mkdirSync5 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var MANAGED_SERVER_NAME = "coder-studio-server";
 var PM2_RESTART_DELAY_MS = 2e3;
 var PM2_MIN_UPTIME = "5s";
@@ -11812,11 +12029,11 @@ var deleteManagedServerInSession = async (pm2, {
   return true;
 };
 var ensureLogDirectory = () => {
-  mkdirSync4(join8(homedir5(), ".coder-studio", "logs"), { recursive: true });
+  mkdirSync5(join9(homedir5(), ".coder-studio", "logs"), { recursive: true });
 };
 var getLogPaths = () => ({
-  outFile: join8(homedir5(), ".coder-studio", "logs", "server.out.log"),
-  errFile: join8(homedir5(), ".coder-studio", "logs", "server.err.log")
+  outFile: join9(homedir5(), ".coder-studio", "logs", "server.out.log"),
+  errFile: join9(homedir5(), ".coder-studio", "logs", "server.err.log")
 });
 var captureStartupLogOffsets = () => {
   const { outFile, errFile } = getLogPaths();
@@ -12002,17 +12219,17 @@ async function getServerStatus() {
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/cli/src/embed.ts
-import { existsSync as existsSync9 } from "fs";
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { dirname as dirname5, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname4(__filename);
+var __dirname = dirname5(__filename);
 var WEB_ASSETS_DIR = resolve3(__dirname, "../web");
 function getStaticAssetsDir() {
   return WEB_ASSETS_DIR;
 }
 function hasWebAssets() {
-  return existsSync9(WEB_ASSETS_DIR);
+  return existsSync10(WEB_ASSETS_DIR);
 }
 
 // packages/cli/src/server-runner.ts
@@ -12214,13 +12431,13 @@ function formatAuthBlocks(blocks) {
 }
 function resolveManagedScriptPath() {
   const currentFile = fileURLToPath3(import.meta.url);
-  const currentDir = dirname5(currentFile);
+  const currentDir = dirname6(currentFile);
   const candidates = [
-    join9(currentDir, "server-runner.js"),
-    join9(currentDir, "server-runner.mjs"),
-    join9(currentDir, "../src/server-runner.ts")
+    join10(currentDir, "server-runner.js"),
+    join10(currentDir, "server-runner.mjs"),
+    join10(currentDir, "../src/server-runner.ts")
   ];
-  const scriptPath = candidates.find((candidate) => existsSync10(candidate));
+  const scriptPath = candidates.find((candidate) => existsSync11(candidate));
   if (!scriptPath) {
     throw new Error("Unable to locate the managed server entry script");
   }