@spencer-kit/coder-studio 0.3.3 → 0.3.4

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) {
@@ -8933,7 +9116,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 +9135,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
         };
       }
@@ -9229,9 +9412,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 +9422,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 +9466,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);
@@ -9895,37 +10078,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 +10117,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 +10138,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) {
@@ -10665,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({
@@ -10704,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,
@@ -10877,6 +11064,7 @@ var init_server = __esm({
     init_config();
     init_auto_fetch();
     init_command_runner();
+    init_e2e_provider_mock();
     init_install_manager();
     init_manager();
     init_db();
@@ -11183,20 +11371,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 +11393,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 +11412,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 +11486,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 +11506,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 +11585,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 +11598,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 +11807,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 +12000,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 +12190,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 +12402,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");
   }