@spencer-kit/coder-studio 0.3.3 → 0.3.4

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) {
@@ -8911,7 +9094,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 +9113,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
         };
       }
@@ -9207,9 +9390,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 +9400,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 +9444,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);
@@ -9873,37 +10056,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 +10095,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 +10116,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) {
@@ -10643,6 +10826,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 +10866,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,
@@ -10855,6 +11042,7 @@ var init_server = __esm({
     init_config();
     init_auto_fetch();
     init_command_runner();
+    init_e2e_provider_mock();
     init_install_manager();
     init_manager();
     init_db();