@spencer-kit/coder-studio 0.3.1 → 0.3.2

package/dist/esm/bin.mjs

@@ -115,8 +115,8 @@ var init_plugin = __esm({
     init_web_ui_routing();
     init_login_protection();
     AUTH_COOKIE_NAME = "coder_studio_auth";
-    isPublicPath = (path8) => {
-      const pathname = getRequestPathname(path8);
+    isPublicPath = (path9) => {
+      const pathname = getRequestPathname(path9);
       return pathname === "/" || pathname === "/login" || pathname === "/healthz" || pathname === "/auth/status" || pathname === "/auth/login" || pathname === "/auth/logout" || pathname.startsWith("/@") || isPublicStaticPath(pathname);
     };
     parseCookies = (cookieHeader) => {
@@ -307,6 +307,25 @@ function parseLogLevel(value) {
       return void 0;
   }
 }
+function resolveDefaultAppVersion() {
+  if (cachedAppVersion) {
+    return cachedAppVersion;
+  }
+  const packageJsonPath = [new URL("../../cli/package.json", import.meta.url)].find(
+    (candidate) => fs.existsSync(candidate)
+  );
+  if (!packageJsonPath) {
+    cachedAppVersion = "0.0.0";
+    return cachedAppVersion;
+  }
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    cachedAppVersion = typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    cachedAppVersion = "0.0.0";
+  }
+  return cachedAppVersion;
+}
 function resolveDbPath(explicit) {
   if (explicit) return explicit;
   if (process.env.NODE_ENV !== "production") {
@@ -345,6 +364,7 @@ function parseServerConfig(overrides) {
     uploadsDir,
     logLevel: overrides?.logLevel ?? parseLogLevel(process.env.LOG_LEVEL) ?? "info",
     webRoot: overrides?.webRoot,
+    appVersion: overrides?.appVersion ?? process.env.CODER_STUDIO_APP_VERSION ?? resolveDefaultAppVersion(),
     auth: overrides?.auth || {
       enabled: !noAuth && !!password,
       password
@@ -357,7 +377,7 @@ function ensureDataDir(config) {
   }
   fs.mkdirSync(path.dirname(config.dataDir), { recursive: true });
 }
-var cachedTestUploadsDir;
+var cachedTestUploadsDir, cachedAppVersion;
 var init_config = __esm({
   "packages/server/src/config.ts"() {
     "use strict";
@@ -787,6 +807,190 @@ var init_src = __esm({
   }
 });
 
+// packages/utils/src/direct-execution.ts
+import { posix, resolve } from "node:path";
+function isWindowsDrivePath(path9) {
+  return /^[A-Za-z]:\//.test(path9);
+}
+function normalizeComparablePath(path9) {
+  let normalized = path9.replace(/\\/g, "/");
+  if (/^\/[A-Za-z]:\//.test(normalized)) {
+    normalized = normalized.slice(1);
+  }
+  if (normalized.startsWith("//")) {
+    normalized = `//${posix.normalize(normalized.slice(2))}`;
+  } else {
+    normalized = posix.normalize(normalized);
+  }
+  if (isWindowsDrivePath(normalized) || normalized.startsWith("//")) {
+    normalized = normalized.toLowerCase();
+  }
+  return normalized;
+}
+function normalizeModuleUrlPath(moduleUrl) {
+  let url;
+  try {
+    url = new URL(moduleUrl);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "file:") {
+    return null;
+  }
+  const path9 = `${url.host ? `//${url.host}` : ""}${decodeURIComponent(url.pathname)}`;
+  return normalizeComparablePath(path9);
+}
+function normalizeArgvPath(argv1) {
+  const isAbsoluteWindowsPath = /^[A-Za-z]:[\\/]/.test(argv1) || /^\\\\/.test(argv1);
+  return normalizeComparablePath(isAbsoluteWindowsPath ? argv1 : resolve(argv1));
+}
+function isDirectExecution(moduleUrl, argv1 = process.argv[1]) {
+  if (argv1 === void 0) {
+    return false;
+  }
+  const modulePath = normalizeModuleUrlPath(moduleUrl);
+  if (modulePath === null) {
+    return false;
+  }
+  return modulePath === normalizeArgvPath(argv1);
+}
+var init_direct_execution = __esm({
+  "packages/utils/src/direct-execution.ts"() {
+    "use strict";
+  }
+});
+
+// packages/utils/src/windows-shim.ts
+function shouldUseShellForCommand(command, platform = process.platform) {
+  return platform === "win32" && WINDOWS_CMD_SHIMS.has(command.toLowerCase());
+}
+var WINDOWS_CMD_SHIMS;
+var init_windows_shim = __esm({
+  "packages/utils/src/windows-shim.ts"() {
+    "use strict";
+    WINDOWS_CMD_SHIMS = /* @__PURE__ */ new Set(["pnpm", "npm", "npx"]);
+  }
+});
+
+// packages/utils/src/windows-shim-resolver.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+function resolveSpawnArgv(argv, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "win32") {
+    return [...argv];
+  }
+  const command = argv[0];
+  if (command === void 0) {
+    return [];
+  }
+  const restArgs = argv.slice(1);
+  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, existsSync12);
+  if (!resolved) {
+    return [...argv];
+  }
+  const ext = path2.win32.extname(resolved).toLowerCase();
+  if (ext === ".exe" || ext === ".com") {
+    return [resolved, ...restArgs];
+  }
+  if (ext === ".cmd" || ext === ".bat") {
+    let content;
+    try {
+      content = readFileSync9(resolved);
+    } catch {
+      return ["cmd.exe", "/d", "/s", "/c", resolved, ...restArgs];
+    }
+    const parsed = parseCmdShim(resolved, content);
+    if (parsed) {
+      return [parsed.node, parsed.entry, ...restArgs];
+    }
+    return ["cmd.exe", "/d", "/s", "/c", resolved, ...restArgs];
+  }
+  return [...argv];
+}
+function parseCmdShim(shimPath, content) {
+  const dp0Dir = path2.win32.dirname(shimPath);
+  const entryMatch = content.match(/"([^"\r\n]+\.js)"\s+%\*/i);
+  const entryRaw = entryMatch?.[1];
+  if (!entryRaw) {
+    return null;
+  }
+  const entry = expandShimVars(entryRaw, dp0Dir);
+  const nodeMatch = content.match(/"([^"\r\n]*node\.exe)"/i) ?? content.match(/"([^"\r\n]*node)"/i);
+  const nodeRaw = nodeMatch?.[1];
+  const node = nodeRaw ? expandShimVars(nodeRaw, dp0Dir) : "node";
+  return { node, entry };
+}
+function expandShimVars(value, dp0Dir) {
+  const dp0WithSlash = dp0Dir.endsWith("\\") ? dp0Dir : `${dp0Dir}\\`;
+  let expanded = value;
+  expanded = expanded.replace(/%~dp0/gi, dp0WithSlash);
+  expanded = expanded.replace(/%dp0%/gi, dp0WithSlash);
+  if (path2.win32.isAbsolute(expanded)) {
+    return path2.win32.normalize(expanded);
+  }
+  return path2.win32.resolve(dp0Dir, expanded);
+}
+function parsePathExt(pathExt) {
+  return pathExt.split(";").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
+}
+function resolveExecutablePath(command, pathEnv, pathExt, existsSync12) {
+  const hasExt = path2.win32.extname(command).length > 0;
+  const extensions = parsePathExt(pathExt);
+  if (path2.win32.isAbsolute(command)) {
+    if (existsSync12(command)) {
+      return command;
+    }
+    if (!hasExt) {
+      for (const ext of extensions) {
+        const candidate = command + ext;
+        if (existsSync12(candidate)) {
+          return candidate;
+        }
+      }
+    }
+    return null;
+  }
+  const dirs = pathEnv.split(";").map((dir) => dir.trim()).filter((dir) => dir.length > 0);
+  for (const dir of dirs) {
+    if (hasExt) {
+      const candidate = path2.win32.join(dir, command);
+      if (existsSync12(candidate)) {
+        return candidate;
+      }
+      continue;
+    }
+    for (const ext of extensions) {
+      const candidate = path2.win32.join(dir, command + ext);
+      if (existsSync12(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+var DEFAULT_PATHEXT;
+var init_windows_shim_resolver = __esm({
+  "packages/utils/src/windows-shim-resolver.ts"() {
+    "use strict";
+    DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC";
+  }
+});
+
+// packages/utils/src/index.ts
+var init_src2 = __esm({
+  "packages/utils/src/index.ts"() {
+    "use strict";
+    init_direct_execution();
+    init_windows_shim();
+    init_windows_shim_resolver();
+  }
+});
+
 // packages/server/src/fs/image.ts
 import { extname } from "path";
 function getImageTypeInfo(filePath) {
@@ -813,10 +1017,10 @@ var init_image = __esm({
 // packages/server/src/fs/file-io.ts
 import { createHash } from "crypto";
 import { readFile as fsReadFile, writeFile as fsWriteFile, mkdir, rm, stat } from "fs/promises";
-import { dirname as dirname2, resolve } from "path";
-async function statSafe(path8) {
+import { dirname as dirname2, resolve as resolve2 } from "path";
+async function statSafe(path9) {
   try {
-    return await stat(path8);
+    return await stat(path9);
   } catch {
     return null;
   }
@@ -847,8 +1051,8 @@ async function deleteEntry(rootPath, relPath) {
   await rm(abs, { recursive: true });
 }
 function resolveSafe(root, relPath) {
-  const absRoot = resolve(root);
-  const abs = resolve(absRoot, relPath);
+  const absRoot = resolve2(root);
+  const abs = resolve2(absRoot, relPath);
   if (!abs.startsWith(absRoot + "/") && abs !== absRoot) {
     throw { code: "path_escape", message: "Path escapes workspace root" };
   }
@@ -986,7 +1190,7 @@ var init_constants = __esm({
 // packages/server/src/uploads/paths.ts
 import { randomUUID } from "node:crypto";
 import { lstat, mkdir as mkdir2 } from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 function sanitizeOriginalName(input2) {
   let sanitized = "";
   for (const char of input2.trim()) {
@@ -1022,9 +1226,9 @@ async function assertDirectorySegmentSafe(segmentPath) {
   }
 }
 async function ensureSafeUploadDir(rootDir, targetDir) {
-  const resolvedRoot = path2.resolve(rootDir);
-  const resolvedTarget = path2.resolve(targetDir);
-  if (resolvedTarget !== resolvedRoot && !resolvedTarget.startsWith(`${resolvedRoot}${path2.sep}`)) {
+  const resolvedRoot = path3.resolve(rootDir);
+  const resolvedTarget = path3.resolve(targetDir);
+  if (resolvedTarget !== resolvedRoot && !resolvedTarget.startsWith(`${resolvedRoot}${path3.sep}`)) {
     throw new Error(`target dir escaped uploads root: ${resolvedTarget}`);
   }
   try {
@@ -1037,13 +1241,13 @@ async function ensureSafeUploadDir(rootDir, targetDir) {
     await mkdir2(resolvedRoot, { recursive: true });
     await assertDirectorySegmentSafe(resolvedRoot);
   }
-  const relative3 = path2.relative(resolvedRoot, resolvedTarget);
+  const relative3 = path3.relative(resolvedRoot, resolvedTarget);
   if (!relative3) {
     return;
   }
   let current = resolvedRoot;
-  for (const segment of relative3.split(path2.sep)) {
-    current = path2.join(current, segment);
+  for (const segment of relative3.split(path3.sep)) {
+    current = path3.join(current, segment);
     try {
       await assertDirectorySegmentSafe(current);
       continue;
@@ -1068,11 +1272,11 @@ function generateBucketPath(input2) {
   validateWorkspaceId(input2.workspaceId);
   const now = input2.now ?? /* @__PURE__ */ new Date();
   const dateStr = now.toISOString().slice(0, 10);
-  const dir = path2.join(input2.uploadsDir, input2.workspaceId, dateStr);
+  const dir = path3.join(input2.uploadsDir, input2.workspaceId, dateStr);
   const sanitizedName = sanitizeOriginalName(input2.originalName);
   const uuid8 = randomUUID().replace(/-/g, "").slice(0, 8);
-  const absolutePath = path2.resolve(dir, `${uuid8}-${sanitizedName}`);
-  const uploadsRoot = `${path2.resolve(input2.uploadsDir)}${path2.sep}`;
+  const absolutePath = path3.resolve(dir, `${uuid8}-${sanitizedName}`);
+  const uploadsRoot = `${path3.resolve(input2.uploadsDir)}${path3.sep}`;
   if (!absolutePath.startsWith(uploadsRoot)) {
     throw new Error(`generated upload path escaped uploads root: ${absolutePath}`);
   }
@@ -1095,7 +1299,7 @@ var init_paths = __esm({
 
 // packages/server/src/uploads/cleanup.ts
 import { readdir, rm as rm2, rmdir, stat as stat3, unlink } from "node:fs/promises";
-import path3 from "node:path";
+import path4 from "node:path";
 async function listFilesRecursive(root) {
   let entries;
   try {
@@ -1108,7 +1312,7 @@ async function listFilesRecursive(root) {
   }
   const files = [];
   for (const entry of entries) {
-    const childPath = path3.join(root, entry.name);
+    const childPath = path4.join(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFilesRecursive(childPath));
       continue;
@@ -1139,7 +1343,7 @@ async function pruneEmptyDirectories(root) {
     if (!entry.isDirectory()) {
       continue;
     }
-    await pruneEmptyDirectories(path3.join(root, entry.name));
+    await pruneEmptyDirectories(path4.join(root, entry.name));
   }
   const remainingEntries = await readdir(root).catch(() => []);
   if (remainingEntries.length === 0) {
@@ -1148,12 +1352,12 @@ async function pruneEmptyDirectories(root) {
 }
 async function deleteWorkspaceUploads(uploadsDir, workspaceId) {
   validateWorkspaceId(workspaceId);
-  const bucket = path3.join(uploadsDir, workspaceId);
+  const bucket = path4.join(uploadsDir, workspaceId);
   await rm2(bucket, { recursive: true, force: true });
 }
 async function enforceBucketCap(uploadsDir, workspaceId, capBytes, logger) {
   validateWorkspaceId(workspaceId);
-  const bucket = path3.join(uploadsDir, workspaceId);
+  const bucket = path4.join(uploadsDir, workspaceId);
   const files = await listFilesRecursive(bucket);
   const totalBytes = files.reduce((sum, file) => sum + file.size, 0);
   if (totalBytes <= capBytes) {
@@ -1193,7 +1397,7 @@ async function runStartupGc(uploadsDir, logger) {
     if (!workspaceEntry.isDirectory()) {
       continue;
     }
-    const workspaceDir = path3.join(uploadsDir, workspaceEntry.name);
+    const workspaceDir = path4.join(uploadsDir, workspaceEntry.name);
     const dateEntries = await readdir(workspaceDir, { withFileTypes: true }).catch(
       () => []
     );
@@ -1201,7 +1405,7 @@ async function runStartupGc(uploadsDir, logger) {
       if (!dateEntry.isDirectory()) {
         continue;
       }
-      const dateDir = path3.join(workspaceDir, dateEntry.name);
+      const dateDir = path4.join(workspaceDir, dateEntry.name);
       const files = await listFilesRecursive(dateDir);
       for (const file of files) {
         if (file.mtimeMs >= cutoffMs) {
@@ -1592,7 +1796,7 @@ var init_app = __esm({
 });
 
 // packages/server/src/config/codex-config-audit.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname3, join as join2 } from "node:path";
 function resolveCodexConfigPath() {
@@ -1603,15 +1807,15 @@ function resolveCodexConfigPath() {
   return join2(homedir2(), ".codex", "config.toml");
 }
 function auditCodexConfigToml(configPath) {
-  const path8 = configPath ?? resolveCodexConfigPath();
-  if (!existsSync2(path8)) {
-    return { configPath: path8, exists: false, findings: [] };
+  const path9 = configPath ?? resolveCodexConfigPath();
+  if (!existsSync3(path9)) {
+    return { configPath: path9, exists: false, findings: [] };
   }
   let content;
   try {
-    content = readFileSync2(path8, "utf-8");
+    content = readFileSync3(path9, "utf-8");
   } catch {
-    return { configPath: path8, exists: false, findings: [] };
+    return { configPath: path9, exists: false, findings: [] };
   }
   const lines = content.split(/\r?\n/);
   const findings = [];
@@ -1619,13 +1823,13 @@ function auditCodexConfigToml(configPath) {
   if (notifyFinding) findings.push(notifyFinding);
   const codexHooksFinding = detectCodexHooksFlag(lines);
   if (codexHooksFinding) findings.push(codexHooksFinding);
-  return { configPath: path8, exists: true, findings };
+  return { configPath: path9, exists: true, findings };
 }
 function cleanupCodexConfigToml(configPath, opts) {
   if (opts.removeIds.length === 0) {
     return { removed: [], backupPath: null, noop: true };
   }
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     return { removed: [], backupPath: null, noop: true };
   }
   const audit = auditCodexConfigToml(configPath);
@@ -1633,7 +1837,7 @@ function cleanupCodexConfigToml(configPath, opts) {
   if (selected.length === 0) {
     return { removed: [], backupPath: null, noop: true };
   }
-  const original = readFileSync2(configPath, "utf-8");
+  const original = readFileSync3(configPath, "utf-8");
   const backupPath = writeBackup(configPath, original, opts.backupDir);
   const linesToDrop = /* @__PURE__ */ new Set();
   for (const finding of selected) {
@@ -1735,7 +1939,7 @@ function countBrackets(s) {
 }
 function writeBackup(configPath, original, backupDir) {
   const dir = backupDir ?? dirname3(configPath);
-  if (!existsSync2(dir)) {
+  if (!existsSync3(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   const ts = formatTimestamp(/* @__PURE__ */ new Date());
@@ -1776,35 +1980,78 @@ var init_codex_config_audit = __esm({
   }
 });
 
+// packages/server/src/provider-runtime/command-runner.ts
+import { spawn } from "node:child_process";
+async function runCommandAsString(file, args, options) {
+  return new Promise((resolve4, reject) => {
+    const child = spawn(file, args, {
+      shell: shouldUseShellForCommand(file, process.platform),
+      windowsHide: options?.windowsHide ?? true
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout?.on("data", (chunk) => {
+      stdoutChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    child.on("error", (error) => {
+      reject(
+        Object.assign(error, {
+          stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+          stderr: Buffer.concat(stderrChunks).toString("utf8")
+        })
+      );
+    });
+    child.on("close", (code) => {
+      const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+      const stderr = Buffer.concat(stderrChunks).toString("utf8");
+      if (code === 0) {
+        resolve4({ stdout, stderr });
+        return;
+      }
+      reject(
+        Object.assign(new Error(`Command failed with exit code ${code ?? "unknown"}`), {
+          exitCode: code ?? void 0,
+          stdout,
+          stderr
+        })
+      );
+    });
+  });
+}
+var init_command_runner = __esm({
+  "packages/server/src/provider-runtime/command-runner.ts"() {
+    "use strict";
+    init_src2();
+  }
+});
+
 // packages/server/src/provider-runtime/command-check.ts
-import { execFile as nodeExecFile } from "node:child_process";
-import { promisify } from "node:util";
 function getCommandLookupExecutable(platform) {
   return platform === "win32" ? "where" : "which";
 }
 async function checkCommandAvailable(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const execFile2 = deps.execFile ?? ((file, args) => execFileAsync(file, args));
+  const runCommand2 = deps.runCommand ?? runCommandAsString;
   const lookup = getCommandLookupExecutable(platform);
   try {
-    await execFile2(lookup, [command]);
-    return true;
+    const { stdout } = await runCommand2(lookup, [command], { windowsHide: true });
+    return stdout.trim().length > 0;
   } catch {
     return false;
   }
 }
-var execFileAsync;
 var init_command_check = __esm({
   "packages/server/src/provider-runtime/command-check.ts"() {
     "use strict";
-    execFileAsync = promisify(nodeExecFile);
+    init_command_runner();
   }
 });
 
 // packages/server/src/provider-runtime/install-manager.ts
-import { execFile as nodeExecFile2 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { promisify as promisify2 } from "node:util";
 function getErrorDetails(error) {
   if (error instanceof Error) {
     const record = error;
@@ -1879,12 +2126,12 @@ function cloneFailure(failure) {
     }
   };
 }
-var execFileAsync2, EXCERPT_LIMIT, ProviderInstallManager;
+var EXCERPT_LIMIT, ProviderInstallManager;
 var init_install_manager = __esm({
   "packages/server/src/provider-runtime/install-manager.ts"() {
     "use strict";
     init_command_check();
-    execFileAsync2 = promisify2(nodeExecFile2);
+    init_command_runner();
     EXCERPT_LIMIT = 400;
     ProviderInstallManager = class {
       providers = /* @__PURE__ */ new Map();
@@ -2069,7 +2316,7 @@ var init_install_manager = __esm({
         };
       }
       async runPreparedJob(provider, job) {
-        const execFile2 = this.deps.execFile ?? ((file, args) => execFileAsync2(file, args));
+        const runCommand2 = this.deps.runCommand ?? runCommandAsString;
         job.status = "running";
         this.jobs.set(job.jobId, job);
         for (const step of job.steps) {
@@ -2096,7 +2343,7 @@ var init_install_manager = __esm({
                 return;
               }
             } else {
-              const result = await execFile2(step.command, step.args);
+              const result = await runCommand2(step.command, step.args, { windowsHide: true });
               step.stdoutExcerpt = excerpt(result.stdout);
               step.stderrExcerpt = excerpt(result.stderr);
             }
@@ -2432,7 +2679,7 @@ var init_idle_heuristics2 = __esm({
 });
 
 // packages/core/src/index.ts
-var init_src2 = __esm({
+var init_src3 = __esm({
   "packages/core/src/index.ts"() {
     "use strict";
     init_events();
@@ -2469,14 +2716,16 @@ var init_provider_config = __esm({
     SUPPORTED_PROVIDER_IDS = ["claude", "codex"];
     supportedProviderIds = new Set(SUPPORTED_PROVIDER_IDS);
     ProviderLaunchConfigInputSchema = z4.object({
-      additionalArgs: z4.array(z4.string()).optional()
+      additionalArgs: z4.array(z4.string()).optional(),
+      envVars: z4.record(z4.string(), z4.string()).optional()
     }).strict();
     ProviderSettingsSchema = z4.object({
       claude: ProviderLaunchConfigInputSchema.optional(),
       codex: ProviderLaunchConfigInputSchema.optional()
     }).strict();
     ProviderLaunchConfigSchema = z4.object({
-      additionalArgs: z4.array(z4.string()).default([])
+      additionalArgs: z4.array(z4.string()).default([]),
+      envVars: z4.record(z4.string(), z4.string()).optional()
     });
   }
 });
@@ -2742,7 +2991,7 @@ var NOOP_SESSION_LOGGER, SessionManager, ActiveSession;
 var init_manager = __esm({
   "packages/server/src/session/manager.ts"() {
     "use strict";
-    init_src2();
+    init_src3();
     init_provider_config();
     init_session_repo();
     init_pty_state_detector();
@@ -3283,7 +3532,7 @@ var init_database = __esm({
 
 // packages/server/src/storage/db.ts
 import { DatabaseSync } from "node:sqlite";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { join as join3 } from "path";
 function normalizeSql(sql) {
   return (sql ?? "").replace(/\s+/g, " ").trim();
@@ -3432,7 +3681,7 @@ var init_db = __esm({
     "use strict";
     init_database();
     SCHEMA_PATH = join3(import.meta.dirname, "migrations", "001_init.sql");
-    SCHEMA_SQL = readFileSync3(SCHEMA_PATH, "utf-8");
+    SCHEMA_SQL = readFileSync4(SCHEMA_PATH, "utf-8");
     LEGACY_TABLES = ["hook_registrations", "_migrations"];
     LEGACY_SESSION_COLUMNS = ["resume_id", "transcript_path"];
     EXPECTED_SCHEMA_ENTRIES = buildExpectedSchemaEntries();
@@ -3982,11 +4231,11 @@ function parseOrdinaryChangedEntry(record, staged, modified, deleted) {
   if (!xy) {
     return;
   }
-  const path8 = parts.slice(8).join(" ");
-  if (!path8) {
+  const path9 = parts.slice(8).join(" ");
+  if (!path9) {
     return;
   }
-  pushChange({ path: path8 }, xy, staged, modified, deleted);
+  pushChange({ path: path9 }, xy, staged, modified, deleted);
 }
 function parseRenamedEntry(record, oldPathRecord, staged, modified, deleted) {
   const parts = record.split(" ");
@@ -3998,12 +4247,12 @@ function parseRenamedEntry(record, oldPathRecord, staged, modified, deleted) {
   const pathAndMaybeOldPath = pathTokens.join(" ");
   const inlinePathParts = pathAndMaybeOldPath.split("	");
   const fallbackPath = !oldPathRecord && inlinePathParts.length === 1 && pathTokens.length > 1 ? pathTokens.slice(0, -1).join(" ") : void 0;
-  const path8 = fallbackPath ?? inlinePathParts[0];
-  if (!path8) {
+  const path9 = fallbackPath ?? inlinePathParts[0];
+  if (!path9) {
     return;
   }
   const oldPath = (oldPathRecord && !oldPathRecord.startsWith("#") ? oldPathRecord : void 0) ?? inlinePathParts[1] ?? (pathTokens.length > 1 ? pathTokens[pathTokens.length - 1] : void 0);
-  pushChange({ path: path8, oldPath }, xy, staged, modified, deleted);
+  pushChange({ path: path9, oldPath }, xy, staged, modified, deleted);
 }
 function pushChange(change, xy, staged, modified, deleted) {
   const indexStatus = xy[0];
@@ -4030,9 +4279,9 @@ var init_status_parser = __esm({
 import { execFile } from "child_process";
 import { mkdir as mkdir3, mkdtemp, rm as rm4, writeFile as writeFile3 } from "fs/promises";
 import os2 from "os";
-import path4 from "path";
+import path5 from "path";
 async function runGit(cwd, args, options = {}) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const gitArgs = [
       ...options.config?.flatMap(([key, value]) => ["-c", `${key}=${value}`]) ?? [],
       ...args
@@ -4052,13 +4301,14 @@ async function runGit(cwd, args, options = {}) {
           ...options.env
         },
         maxBuffer: 10 * 1024 * 1024,
-        timeout: options.timeoutMs
+        timeout: options.timeoutMs,
+        windowsHide: true
       },
       (err, stdout, stderr) => {
         if (err) {
           reject(new GitError(err.message, stderr));
         } else {
-          resolve3({ stdout, stderr });
+          resolve4({ stdout, stderr });
         }
       }
     );
@@ -4107,12 +4357,12 @@ async function discardChanges(cwd, paths) {
   if (paths.length === 0) return;
   const trackedPaths = [];
   const untrackedPaths = [];
-  for (const path8 of paths) {
+  for (const path9 of paths) {
     try {
-      await runGit(cwd, ["ls-files", "--error-unmatch", "--", path8]);
-      trackedPaths.push(path8);
+      await runGit(cwd, ["ls-files", "--error-unmatch", "--", path9]);
+      trackedPaths.push(path9);
     } catch {
-      untrackedPaths.push(path8);
+      untrackedPaths.push(path9);
     }
   }
   if (trackedPaths.length > 0) {
@@ -4380,9 +4630,9 @@ async function prepareGitAuthExecution(auth, remoteMetadata) {
       }
     };
   }
-  const tempDir = await mkdtemp(path4.join(os2.tmpdir(), "coder-studio-git-auth-"));
-  const hooksDir = path4.join(tempDir, "hooks");
-  const askPassPath = path4.join(tempDir, "askpass.sh");
+  const tempDir = await mkdtemp(path5.join(os2.tmpdir(), "coder-studio-git-auth-"));
+  const hooksDir = path5.join(tempDir, "hooks");
+  const askPassPath = path5.join(tempDir, "askpass.sh");
   await mkdir3(hooksDir, { recursive: true, mode: 448 });
   await writeFile3(
     askPassPath,
@@ -4736,31 +4986,31 @@ var init_context_builder = __esm({
 });
 
 // packages/server/src/terminal/pty-host.ts
-import { chmodSync, existsSync as existsSync3, statSync } from "node:fs";
+import { chmodSync, existsSync as existsSync4, statSync } from "node:fs";
 import { createRequire } from "node:module";
-import path5 from "node:path";
+import path6 from "node:path";
 function ensureNodePtySpawnHelperExecutable(deps = {}) {
   const platform = deps.platform ?? process.platform;
   if (platform !== "darwin") {
     return;
   }
   const arch = deps.arch ?? process.arch;
-  const resolve3 = deps.resolve ?? ((id) => require2.resolve(id));
-  const fileExists = deps.existsSync ?? existsSync3;
+  const resolve4 = deps.resolve ?? ((id) => require2.resolve(id));
+  const fileExists = deps.existsSync ?? existsSync4;
   const stat7 = deps.statSync ?? statSync;
   const chmod = deps.chmodSync ?? chmodSync;
   let packageJsonPath;
   try {
-    packageJsonPath = resolve3(NODE_PTY_PKG);
+    packageJsonPath = resolve4(NODE_PTY_PKG);
   } catch {
     return;
   }
-  const packageDir = path5.dirname(packageJsonPath);
+  const packageDir = path6.dirname(packageJsonPath);
   const helperDir = arch === "arm64" ? "darwin-arm64" : arch === "x64" ? "darwin-x64" : null;
   if (!helperDir) {
     return;
   }
-  const helperPath = path5.join(packageDir, "prebuilds", helperDir, "spawn-helper");
+  const helperPath = path6.join(packageDir, "prebuilds", helperDir, "spawn-helper");
   try {
     if (!fileExists(helperPath)) {
       return;
@@ -4816,7 +5066,7 @@ async function escalateKillWithPolling(pid, signal, options) {
   const startTime = Date.now();
   const deadline = startTime + timeoutMs;
   while (Date.now() < deadline) {
-    await new Promise((resolve3) => setTimeout(resolve3, pollIntervalMs));
+    await new Promise((resolve4) => setTimeout(resolve4, pollIntervalMs));
     if (!isProcessAlive(pid)) {
       return true;
     }
@@ -4828,6 +5078,7 @@ var require2, NODE_PTY_PKG, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, NodePt
 var init_pty_host = __esm({
   "packages/server/src/terminal/pty-host.ts"() {
     "use strict";
+    init_src2();
     require2 = createRequire(import.meta.url);
     NODE_PTY_PKG = "node-pty/package.json";
     DEFAULT_POLL_INTERVAL_MS = 50;
@@ -4842,7 +5093,13 @@ var init_pty_host = __esm({
           const message = err instanceof Error ? err.message : String(err);
           throw new Error(`node-pty native module not available. ${message}`);
         }
-        const [command, ...args] = argv;
+        if (argv.length === 0) {
+          throw new Error("PTY spawn requires a command");
+        }
+        const [command, ...args] = resolveSpawnArgv(argv, {
+          pathEnv: options.env.Path ?? options.env.PATH,
+          pathExt: options.env.PATHEXT
+        });
         if (command === void 0) {
           throw new Error("PTY spawn requires a command");
         }
@@ -4903,13 +5160,13 @@ var SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY;
 var init_settings = __esm({
   "packages/server/src/supervisor/settings.ts"() {
     "use strict";
-    init_src2();
+    init_src3();
     SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY = "supervisor.evaluationTimeoutSec";
   }
 });
 
 // packages/server/src/supervisor/evaluator.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 function buildPrompt(context) {
   const agentOutput = context.transcriptExcerpt ?? context.terminalExcerpt ?? "";
   const userInput = context.latestUserInput?.trim() ?? "";
@@ -4940,12 +5197,13 @@ async function runCommand(command, timeoutMs, options = {}) {
   if (options.signal?.aborted) {
     throw createSupervisorEvalAbortedError();
   }
-  return await new Promise((resolve3, reject) => {
-    const child = spawn(command.argv[0], command.argv.slice(1), {
+  return await new Promise((resolve4, reject) => {
+    const child = spawn2(command.argv[0], command.argv.slice(1), {
       cwd: command.cwd,
       detached: process.platform !== "win32",
       env: { ...process.env, ...command.env },
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
     });
     const stdout = [];
     const stderr = [];
@@ -4969,7 +5227,7 @@ async function runCommand(command, timeoutMs, options = {}) {
       }
       settled = true;
       cleanup();
-      resolve3(value);
+      resolve4(value);
     };
     const terminate = (error) => {
       if (terminationError) {
@@ -5176,7 +5434,7 @@ var NOOP_LOGGER2, SupervisorEvaluator;
 var init_evaluator = __esm({
   "packages/server/src/supervisor/evaluator.ts"() {
     "use strict";
-    init_src2();
+    init_src3();
     init_provider_config();
     init_pty_host();
     init_settings();
@@ -5279,7 +5537,7 @@ var INJECTABLE_SESSION_STATES, SupervisorInjector;
 var init_injector = __esm({
   "packages/server/src/supervisor/injector.ts"() {
     "use strict";
-    init_src2();
+    init_src3();
     INJECTABLE_SESSION_STATES = /* @__PURE__ */ new Set([
       "idle",
       "running"
@@ -5356,12 +5614,12 @@ var init_scheduler = __esm({
 
 // packages/server/src/supervisor/manager.ts
 function createDeferredCompletion() {
-  let resolve3 = () => {
+  let resolve4 = () => {
   };
   const promise = new Promise((innerResolve) => {
-    resolve3 = innerResolve;
+    resolve4 = innerResolve;
   });
-  return { promise, resolve: resolve3 };
+  return { promise, resolve: resolve4 };
 }
 function generateSupervisorId() {
   return `sup_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
@@ -5391,7 +5649,7 @@ var NOOP_LOGGER3, SupervisorManager;
 var init_manager2 = __esm({
   "packages/server/src/supervisor/manager.ts"() {
     "use strict";
-    init_src2();
+    init_src3();
     init_context_builder();
     init_evaluator();
     init_injector();
@@ -6300,8 +6558,8 @@ var init_terminal_snapshot_buffer = __esm({
         if (this.pendingWriteCount === 0) {
           return Promise.resolve();
         }
-        return new Promise((resolve3) => {
-          this.drainResolvers.push(resolve3);
+        return new Promise((resolve4) => {
+          this.drainResolvers.push(resolve4);
         });
       }
       resolveDrainIfIdle() {
@@ -6310,8 +6568,8 @@ var init_terminal_snapshot_buffer = __esm({
         }
         const resolvers = this.drainResolvers;
         this.drainResolvers = [];
-        for (const resolve3 of resolvers) {
-          resolve3();
+        for (const resolve4 of resolvers) {
+          resolve4();
         }
       }
       requireTerminal() {
@@ -6630,10 +6888,10 @@ var init_manager3 = __esm({
           }
           return existing.promise;
         }
-        let resolve3 = () => {
+        let resolve4 = () => {
         };
         const promise = new Promise((innerResolve) => {
-          resolve3 = innerResolve;
+          resolve4 = innerResolve;
         });
         let markKillCompleted = () => {
         };
@@ -6646,7 +6904,7 @@ var init_manager3 = __esm({
           markKillCompleted,
           finalized: false,
           promise,
-          resolve: resolve3
+          resolve: resolve4
         });
         void terminal.pty.kill(signal).finally(() => {
           const waiter = this.explicitCloseWaiters.get(terminalId);
@@ -6775,14 +7033,14 @@ var init_manager3 = __esm({
 // packages/server/src/workspace/validator.ts
 import { constants } from "fs";
 import { access, stat as stat5 } from "fs/promises";
-async function validatePath(path8) {
+async function validatePath(path9) {
   try {
-    const stats = await stat5(path8);
+    const stats = await stat5(path9);
     if (!stats.isDirectory()) {
       return { valid: false, error: "Path is not a directory" };
     }
-    await access(path8, constants.R_OK);
-    await access(path8, constants.W_OK);
+    await access(path9, constants.R_OK);
+    await access(path9, constants.W_OK);
     return { valid: true };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -6799,8 +7057,8 @@ var init_validator = __esm({
   "packages/server/src/workspace/validator.ts"() {
     "use strict";
     WorkspaceValidator = class {
-      async validate(path8) {
-        const result = await validatePath(path8);
+      async validate(path9) {
+        const result = await validatePath(path9);
         if (!result.valid) {
           throw new Error(`Invalid workspace path: ${result.error}`);
         }
@@ -6810,14 +7068,14 @@ 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 join4, relative } from "path";
-function normalizePath(path8) {
-  return path8.replace(/\\/g, "/");
+function normalizePath(path9) {
+  return path9.replace(/\\/g, "/");
 }
-function relativeToRoot(rootPath, path8) {
-  return normalizePath(relative(rootPath, path8));
+function relativeToRoot(rootPath, path9) {
+  return normalizePath(relative(rootPath, path9));
 }
 function isDefaultTreeIgnored(name) {
   return name.startsWith(".") || name === "node_modules" || name === ".git";
@@ -6825,18 +7083,18 @@ function isDefaultTreeIgnored(name) {
 function isAlwaysTreeIgnored(name) {
   return name === "node_modules" || name === ".git";
 }
-function isIgnoredByGitignore(ig, path8) {
-  if (!path8 || path8.startsWith("..")) {
+function isIgnoredByGitignore(ig, path9) {
+  if (!path9 || path9.startsWith("..")) {
     return false;
   }
-  return ig.ignores(path8) || ig.ignores(`${path8}/`);
+  return ig.ignores(path9) || ig.ignores(`${path9}/`);
 }
 function createGitignoreFilter(rootPath, dirPath) {
   const gitignorePath = join4(rootPath, ".gitignore");
-  if (!existsSync4(gitignorePath)) {
+  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)) {
@@ -6848,17 +7106,17 @@ function createGitignoreFilter(rootPath, dirPath) {
 }
 function createWatcherIgnoreFilter(rootPath) {
   const gitignorePath = join4(rootPath, ".gitignore");
-  if (!existsSync4(gitignorePath)) {
-    return (path8) => DEFAULT_WATCHER_IGNORED_PATTERNS.some((p) => p.test(normalizePath(path8)));
+  if (!existsSync5(gitignorePath)) {
+    return (path9) => DEFAULT_WATCHER_IGNORED_PATTERNS.some((p) => p.test(normalizePath(path9)));
   }
-  const gitignoreContent = readFileSync4(gitignorePath, "utf-8");
+  const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
   const ig = ignore().add(gitignoreContent);
-  return (path8) => {
-    const normalizedPath = normalizePath(path8);
+  return (path9) => {
+    const normalizedPath = normalizePath(path9);
     if (DEFAULT_WATCHER_IGNORED_PATTERNS.some((p) => p.test(normalizedPath))) {
       return true;
     }
-    const relativePath = relativeToRoot(rootPath, path8);
+    const relativePath = relativeToRoot(rootPath, path9);
     return isIgnoredByGitignore(ig, relativePath);
   };
 }
@@ -6881,7 +7139,7 @@ var WorkspaceWatcher;
 var init_watcher = __esm({
   "packages/server/src/fs/watcher.ts"() {
     "use strict";
-    init_src2();
+    init_src3();
     init_gitignore();
     WorkspaceWatcher = class {
       constructor(workspaceId, rootPath, broadcaster) {
@@ -7133,12 +7391,12 @@ var init_manager4 = __esm({
        * @param path - Workspace path
        * @returns Workspace or undefined
        */
-      getByPath(path8) {
+      getByPath(path9) {
         const row = this.deps.db.prepare(
           `SELECT id, path, target_runtime, wsl_distro, opened_at, last_active_at, ui_state
          FROM workspaces
          WHERE path = ?`
-        ).get(path8);
+        ).get(path9);
         if (!row) return void 0;
         return {
           id: row.id,
@@ -7342,16 +7600,16 @@ async function debounce(key, op, windowMs) {
     clearTimeout(entry.timer);
     entry.op = op;
   } else {
-    let resolve3;
+    let resolve4;
     let reject;
     const promise = new Promise((res, rej) => {
-      resolve3 = res;
+      resolve4 = res;
       reject = rej;
     });
     entry = {
       timer: void 0,
       promise,
-      resolve: resolve3,
+      resolve: resolve4,
       reject,
       op
     };
@@ -7527,7 +7785,7 @@ var TerminalInputActivitySchema, TerminalInputSchema, pendingTerminalInput, next
 var init_terminal = __esm({
   "packages/server/src/commands/terminal.ts"() {
     "use strict";
-    init_src2();
+    init_src3();
     init_dispatch();
     TerminalInputActivitySchema = z5.enum(TERMINAL_INPUT_ACTIVITIES).optional();
     TerminalInputSchema = z5.union([
@@ -8135,7 +8393,7 @@ var BINARY_PAYLOAD_TIMEOUT_MS, isBinaryTerminalInputArgs, WsHub;
 var init_hub = __esm({
   "packages/server/src/ws/hub.ts"() {
     "use strict";
-    init_src2();
+    init_src3();
     init_terminal();
     init_client();
     init_dispatch();
@@ -8174,7 +8432,10 @@ var init_hub = __esm({
           status: "connected",
           clientId: client.id,
           authEnabled: this.deps.config.auth.enabled,
-          binaryTerminalTransport: true
+          binaryTerminalTransport: true,
+          version: this.deps.config.appVersion ?? "0.0.0",
+          serverInstanceId: `server-${process.pid}`,
+          isWriter: false
         });
         client.onMessage((msg) => this.routeMessage(client, msg));
         client.onClose(() => this.handleClose(client));
@@ -8228,7 +8489,7 @@ var init_hub = __esm({
         }
       }
       awaitBinaryPayload(clientId) {
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve4, reject) => {
           const timer = setTimeout(() => {
             const waiters = this.pendingBinaryWaiters.get(clientId);
             if (!waiters) return;
@@ -8240,7 +8501,7 @@ var init_hub = __esm({
             }
             reject(new Error("Timeout waiting for terminal input binary payload"));
           }, BINARY_PAYLOAD_TIMEOUT_MS);
-          const waiter = { resolve: resolve3, reject, timer };
+          const waiter = { resolve: resolve4, reject, timer };
           const queue = this.pendingBinaryWaiters.get(clientId);
           if (queue) {
             queue.push(waiter);
@@ -9047,7 +9308,7 @@ var init_file = __esm({
 // packages/server/src/git/diff.ts
 import { mkdtemp as mkdtemp2, rm as rm5 } from "fs/promises";
 import os3 from "os";
-import path6 from "path";
+import path7 from "path";
 async function isTrackedPath(cwd, filePath) {
   try {
     await runGit(cwd, ["ls-files", "--error-unmatch", "--", filePath]);
@@ -9057,8 +9318,8 @@ async function isTrackedPath(cwd, filePath) {
   }
 }
 async function getUntrackedFileDiff(cwd, filePath) {
-  const tempDir = await mkdtemp2(path6.join(os3.tmpdir(), "coder-studio-git-diff-"));
-  const tempIndex = path6.join(tempDir, "index");
+  const tempDir = await mkdtemp2(path7.join(os3.tmpdir(), "coder-studio-git-diff-"));
+  const tempIndex = path7.join(tempDir, "index");
   try {
     try {
       await runGit(cwd, ["read-tree", "HEAD"], {
@@ -9083,11 +9344,11 @@ async function getUntrackedFileDiff(cwd, filePath) {
     await rm5(tempDir, { recursive: true, force: true });
   }
 }
-async function getFileDiff(cwd, path8, staged = false) {
-  if (!staged && !await isTrackedPath(cwd, path8)) {
-    return getUntrackedFileDiff(cwd, path8);
+async function getFileDiff(cwd, path9, staged = false) {
+  if (!staged && !await isTrackedPath(cwd, path9)) {
+    return getUntrackedFileDiff(cwd, path9);
   }
-  const args = staged ? ["diff", "--staged", "--", path8] : ["diff", "--", path8];
+  const args = staged ? ["diff", "--staged", "--", path9] : ["diff", "--", path9];
   const result = await runGit(cwd, args);
   return result.stdout;
 }
@@ -9336,7 +9597,7 @@ var init_git2 = __esm({
 });
 
 // packages/server/src/config/config-io.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { basename as basename2, dirname as dirname4, join as join7 } from "node:path";
 function resolveConfigPath(configType) {
@@ -9358,11 +9619,11 @@ function resolveConfigPath(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 };
@@ -9372,11 +9633,11 @@ function writeConfigFile(configType, content) {
   try {
     const configPath = resolveConfigPath(configType);
     const parentDir = dirname4(configPath);
-    if (!existsSync5(parentDir)) {
+    if (!existsSync6(parentDir)) {
       mkdirSync3(parentDir, { recursive: true });
     }
     let backupPath = null;
-    if (existsSync5(configPath)) {
+    if (existsSync6(configPath)) {
       backupPath = createBackup(configPath);
     }
     const tempPath = `${configPath}.tmp`;
@@ -9392,7 +9653,7 @@ 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 = dirname4(filePath);
@@ -9430,7 +9691,7 @@ var EMPTY_CODEX_AUDIT, SettingsSchema;
 var init_settings2 = __esm({
   "packages/server/src/commands/settings.ts"() {
     "use strict";
-    init_src2();
+    init_src3();
     init_config_io();
     init_provider_config();
     init_provider_config_repo();
@@ -9710,9 +9971,9 @@ var init_supervisor2 = __esm({
 });
 
 // packages/server/src/git/worktree.ts
-import path7 from "node:path";
+import path8 from "node:path";
 function normalizeWorktreePath(worktreePath) {
-  return path7.resolve(worktreePath);
+  return path8.resolve(worktreePath);
 }
 async function resolveWorktreePath(repoPath, worktreePath) {
   const normalizedRequested = normalizeWorktreePath(worktreePath);
@@ -9799,19 +10060,19 @@ async function getWorktreeTree(worktreePath) {
   for (const line of lines) {
     const isDir = line.endsWith("/");
     const name = isDir ? line.slice(0, -1) : line;
-    const path8 = `${worktreePath}/${name}`;
+    const path9 = `${worktreePath}/${name}`;
     nodes.push({
       name,
-      path: path8,
+      path: path9,
       kind: isDir ? "dir" : "file"
     });
   }
   return nodes;
 }
-async function createWorktree(repoPath, branch, path8) {
-  await runGit(repoPath, ["worktree", "add", path8, branch]);
+async function createWorktree(repoPath, branch, path9) {
+  await runGit(repoPath, ["worktree", "add", path9, branch]);
   const worktrees = await listWorktrees(repoPath);
-  const created = worktrees.find((wt) => wt.path === path8);
+  const created = worktrees.find((wt) => wt.path === path9);
   if (!created) {
     throw new Error("Failed to find created worktree");
   }
@@ -10009,8 +10270,6 @@ var init_commands = __esm({
 });
 
 // packages/server/src/server.ts
-import { execFile as nodeExecFile3 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
 function createCodexConfigAuditApi() {
   return {
     audit: () => ({ codex: auditCodexConfigToml() }),
@@ -10038,7 +10297,6 @@ async function logCodexConfigFindings(auditApi, logger) {
   }
 }
 async function createServer(configOverrides) {
-  const execFileAsync3 = promisify3(nodeExecFile3);
   const config = parseServerConfig(configOverrides);
   ensureDataDir(config);
   const db = openDatabase(config.dataDir);
@@ -10120,7 +10378,7 @@ async function createServer(configOverrides) {
   const providerRuntimeDeps = {};
   const providerInstallMgr = new ProviderInstallManager(providerRegistry, {
     ...providerRuntimeDeps,
-    execFile: (file, args) => execFileAsync3(file, args)
+    runCommand: runCommandAsString
   });
   const commandContext = {
     workspaceMgr,
@@ -10283,10 +10541,12 @@ var init_server = __esm({
     "use strict";
     init_runtime();
     init_src();
+    init_src2();
     init_app();
     init_event_bus();
     init_codex_config_audit();
     init_config();
+    init_command_runner();
     init_install_manager();
     init_manager();
     init_db();
@@ -10306,7 +10566,7 @@ var init_server = __esm({
     init_fencing();
     init_hub();
     init_commands();
-    if (import.meta.url === `file://${process.argv[1]}`) {
+    if (isDirectExecution(import.meta.url)) {
       const server = await createServer();
       process.on("SIGINT", async () => {
         console.log("\nShutting down...");
@@ -10456,8 +10716,8 @@ var init_workspace_repo = __esm({
       /**
        * Finds a workspace by path
        */
-      findByPath(path8) {
-        const row = this.db.prepare("SELECT * FROM workspaces WHERE path = ?").get(path8);
+      findByPath(path9) {
+        const row = this.db.prepare("SELECT * FROM workspaces WHERE path = ?").get(path9);
         return row ? this.rowToWorkspace(row) : void 0;
       }
       /**
@@ -10578,7 +10838,7 @@ __export(src_exports, {
   sessionToRow: () => sessionToRow,
   withTransaction: () => withTransaction
 });
-var init_src3 = __esm({
+var init_src4 = __esm({
   async "packages/server/src/index.ts"() {
     "use strict";
     init_auth();
@@ -10592,15 +10852,15 @@ var init_src3 = __esm({
 });
 
 // packages/cli/src/cli.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+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_src3();
+await init_src4();
 
 // packages/cli/src/config-store.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir5 } from "os";
 import { basename as basename3, join as join8 } from "path";
 var DEFAULT_DB_FILE = "coder-studio.db";
@@ -10617,12 +10877,12 @@ function normalizeDataDir(input2) {
   return join8(input2, DEFAULT_DB_FILE);
 }
 function readCliConfig() {
-  const path8 = getCliConfigPath();
-  if (!existsSync6(path8)) {
+  const path9 = getCliConfigPath();
+  if (!existsSync7(path9)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync6(path8, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(path9, "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;
     }
@@ -10632,7 +10892,7 @@ function readCliConfig() {
   }
 }
 function writeCliConfig(config) {
-  const path8 = getCliConfigPath();
+  const path9 = getCliConfigPath();
   const dir = join8(homedir5(), ".coder-studio");
   const normalizedConfig = {
     ...config.host !== void 0 ? { host: config.host } : {},
@@ -10640,10 +10900,10 @@ function writeCliConfig(config) {
     ...config.dataDir !== void 0 ? { dataDir: normalizeDataDir(config.dataDir) } : {},
     ...config.password !== void 0 ? { password: config.password } : {}
   };
-  if (!existsSync6(dir)) {
+  if (!existsSync7(dir)) {
     mkdirSync4(dir, { recursive: true });
   }
-  writeFileSync4(path8, JSON.stringify(normalizedConfig, null, 2), "utf-8");
+  writeFileSync4(path9, JSON.stringify(normalizedConfig, null, 2), "utf-8");
 }
 
 // packages/cli/src/auth-control.ts
@@ -10679,7 +10939,7 @@ async function clearAuthBlockByIp(ip) {
 }
 
 // packages/cli/src/browser.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 function getOpenCommand(url) {
   switch (process.platform) {
     case "darwin":
@@ -10692,44 +10952,45 @@ function getOpenCommand(url) {
 }
 async function openBrowser(url) {
   const { command, args } = getOpenCommand(url);
-  await new Promise((resolve3, reject) => {
-    const child = spawn2(command, args, {
+  await new Promise((resolve4, reject) => {
+    const child = spawn3(command, args, {
       detached: true,
-      stdio: "ignore"
+      stdio: "ignore",
+      windowsHide: true
     });
     child.once("error", reject);
     child.once("spawn", () => {
       child.unref();
-      resolve3();
+      resolve4();
     });
   });
 }
 
 // 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 = (path8) => {
-  if (!existsSync7(path8)) {
+var getFileSize = (path9) => {
+  if (!existsSync8(path9)) {
     return 0;
   }
   try {
-    return statSync2(path8).size;
+    return statSync2(path9).size;
   } catch {
     return 0;
   }
 };
-var readLogExcerpt = (path8, {
+var readLogExcerpt = (path9, {
   startOffset = 0,
   maxBytes = DEFAULT_MAX_BYTES,
   maxLines = DEFAULT_MAX_LINES,
   maxChars = DEFAULT_MAX_CHARS
 } = {}) => {
-  if (!existsSync7(path8)) {
+  if (!existsSync8(path9)) {
     return null;
   }
-  const fileSize = getFileSize(path8);
+  const fileSize = getFileSize(path9);
   const safeOffset = startOffset > fileSize ? 0 : Math.max(0, startOffset);
   if (fileSize === safeOffset) {
     return null;
@@ -10737,7 +10998,7 @@ var readLogExcerpt = (path8, {
   const bytesToRead = Math.min(fileSize - safeOffset, maxBytes);
   const readStart = fileSize - bytesToRead;
   const buffer = Buffer.allocUnsafe(bytesToRead);
-  const fd = openSync(path8, "r");
+  const fd = openSync(path9, "r");
   let content = "";
   let startsMidLine = false;
   try {
@@ -10804,6 +11065,27 @@ function assertSupportedNodeVersion(version = process.versions.node) {
   );
 }
 
+// packages/cli/src/package-manifest.ts
+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) => existsSync9(candidate));
+  if (!manifestUrl) {
+    throw new Error("Unable to locate CLI package.json");
+  }
+  return manifestUrl;
+}
+function getCliPackageManifest(importMetaUrl) {
+  return JSON.parse(
+    readFileSync8(resolveCliPackageManifestUrl(importMetaUrl), "utf-8")
+  );
+}
+function getCliVersion(importMetaUrl) {
+  return getCliPackageManifest(importMetaUrl).version ?? "0.0.0";
+}
+
 // packages/cli/src/parse-args.ts
 var RUNTIME_CONFIG_ERROR = "Host, port, data-dir, password, and auth settings must be configured via the config command";
 function getActiveCommand(args) {
@@ -11013,6 +11295,8 @@ var MANAGED_SERVER_NAME = "coder-studio-server";
 var PM2_RESTART_DELAY_MS = 2e3;
 var PM2_MIN_UPTIME = "5s";
 var PM2_MAX_RESTARTS = 10;
+var PM2_DELETE_WAIT_MS = 5e3;
+var PM2_DISCONNECT_WAIT_MS = 1e3;
 var STARTUP_POLL_INTERVAL_MS = 100;
 var STARTUP_FAILURE_GUIDANCE = "Run `coder-studio logs` for details or `coder-studio serve --foreground` for interactive debugging.";
 var isMissingManagedServerError = (error) => {
@@ -11046,58 +11330,72 @@ async function loadPm2() {
 }
 var connectPm2 = async () => {
   const pm2 = await loadPm2();
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     pm2.connect((error) => {
       if (error) {
         reject(error);
         return;
       }
-      resolve3();
+      resolve4();
     });
   });
 };
-var sleep = async (ms) => new Promise((resolve3) => {
-  setTimeout(resolve3, ms);
+var sleep = async (ms) => new Promise((resolve4) => {
+  setTimeout(resolve4, ms);
 });
 var disconnectPm2 = async () => {
   const pm2 = await loadPm2();
-  pm2.disconnect();
-};
-var describeManagedServer = async () => {
-  const pm2 = await loadPm2();
-  return new Promise((resolve3, reject) => {
-    pm2.describe(MANAGED_SERVER_NAME, (error, result) => {
-      if (error) {
-        reject(error);
+  await new Promise((resolve4) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) {
         return;
       }
-      resolve3(result ?? []);
-    });
+      settled = true;
+      resolve4();
+    };
+    const timer = setTimeout(finish, PM2_DISCONNECT_WAIT_MS);
+    try {
+      pm2.disconnect(() => {
+        clearTimeout(timer);
+        finish();
+      });
+    } catch {
+      clearTimeout(timer);
+      finish();
+    }
   });
 };
-var removeManagedServer = async () => {
-  const pm2 = await loadPm2();
-  return new Promise((resolve3, reject) => {
-    pm2.delete(MANAGED_SERVER_NAME, (error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve3();
-    });
+var describeManagedServer = async (pm2) => new Promise((resolve4, reject) => {
+  pm2.describe(MANAGED_SERVER_NAME, (error, result) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve4(result ?? []);
   });
-};
+});
+var removeManagedServer = async (pm2) => new Promise((resolve4, reject) => {
+  pm2.delete(MANAGED_SERVER_NAME, (error) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve4();
+  });
+});
 var killPm2Daemon = async () => {
   const pm2 = await loadPm2();
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     pm2.kill(() => {
-      resolve3();
+      resolve4();
     });
   });
 };
 var connectWithRecovery = async () => {
   try {
     await connectPm2();
+    return loadPm2();
   } catch (error) {
     if (isPm2BrokenStateError(error)) {
       console.warn("PM2 daemon is in a stale state. Killing and reconnecting...");
@@ -11108,26 +11406,27 @@ var connectWithRecovery = async () => {
       await sleep(1e3);
       cachedPm2 = null;
       await connectPm2();
+      return loadPm2();
     } else {
       throw error;
     }
   }
 };
 var withPm2Connection = async (operation) => {
-  await connectWithRecovery();
+  const pm2 = await connectWithRecovery();
   try {
-    return await operation();
+    return await operation(pm2);
   } finally {
     await disconnectPm2();
   }
 };
-var waitForRuntimeReady = async (waitMs, logOffsets) => {
+var waitForRuntimeReady = async (pm2, waitMs, logOffsets) => {
   const deadline = Date.now() + waitMs;
   while (Date.now() <= deadline) {
     if (readRuntimeConfig()) {
       return;
     }
-    const processes = await describeManagedServer();
+    const processes = await describeManagedServer(pm2);
     const process2 = processes[0];
     if (!process2) {
       throw createStartupError(
@@ -11147,14 +11446,39 @@ var waitForRuntimeReady = async (waitMs, logOffsets) => {
   }
   throw createStartupError(`runtime readiness timed out after ${waitMs}ms`, logOffsets);
 };
-var waitForManagedServerExit = async () => {
-  while (true) {
-    const processes = await describeManagedServer();
+var waitForManagedServerDeletion = async (pm2, waitMs) => {
+  const deadline = Date.now() + waitMs;
+  while (Date.now() <= deadline) {
+    const processes = await describeManagedServer(pm2);
     if (processes.length === 0) {
       return;
     }
-    await sleep(STARTUP_POLL_INTERVAL_MS);
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      break;
+    }
+    await sleep(Math.min(STARTUP_POLL_INTERVAL_MS, remainingMs));
   }
+  throw new Error(`Timed out waiting for the managed server to stop after ${waitMs}ms.`);
+};
+var deleteManagedServerInSession = async (pm2, {
+  ignoreMissing = false
+} = {}) => {
+  const processes = await describeManagedServer(pm2);
+  if (processes.length === 0) {
+    return false;
+  }
+  try {
+    await removeManagedServer(pm2);
+  } catch (error) {
+    if (ignoreMissing && isMissingManagedServerError(error)) {
+      await waitForManagedServerDeletion(pm2, PM2_DELETE_WAIT_MS);
+      return false;
+    }
+    throw error;
+  }
+  await waitForManagedServerDeletion(pm2, PM2_DELETE_WAIT_MS);
+  return true;
 };
 var ensureLogDirectory = () => {
   mkdirSync5(join9(homedir6(), ".coder-studio", "logs"), { recursive: true });
@@ -11196,69 +11520,51 @@ var createStartupError = (reason, offsets) => {
 };
 var deleteManagedServer = async ({
   ignoreMissing = false
-} = {}) => withPm2Connection(async () => {
-  const processes = await describeManagedServer();
-  if (processes.length === 0) {
-    return false;
-  }
-  try {
-    await removeManagedServer();
-    return true;
-  } catch (error) {
-    if (ignoreMissing && isMissingManagedServerError(error)) {
-      return false;
-    }
-    throw error;
-  }
-});
+} = {}) => withPm2Connection((pm2) => deleteManagedServerInSession(pm2, { ignoreMissing }));
 var startManagedServer = async ({
   script,
   cwd,
   waitMs,
   args
-}) => {
-  await deleteManagedServer({ ignoreMissing: true });
-  await withPm2Connection(waitForManagedServerExit);
+}) => withPm2Connection(async (pm2) => {
+  await deleteManagedServerInSession(pm2, { ignoreMissing: true });
   if (readRuntimeConfig()) {
     deleteRuntimeConfig();
   }
   ensureLogDirectory();
   const { outFile, errFile } = getLogPaths();
-  const pm2 = await loadPm2();
-  await withPm2Connection(async () => {
-    const logOffsets = captureStartupLogOffsets();
-    await new Promise((resolve3, reject) => {
-      pm2.start(
-        {
-          name: MANAGED_SERVER_NAME,
-          script,
-          cwd,
-          ...args !== void 0 ? { args } : {},
-          env: {
-            ...process.env,
-            NODE_ENV: "production"
-          },
-          autorestart: true,
-          restart_delay: PM2_RESTART_DELAY_MS,
-          min_uptime: PM2_MIN_UPTIME,
-          max_restarts: PM2_MAX_RESTARTS,
-          out_file: outFile,
-          error_file: errFile
+  const logOffsets = captureStartupLogOffsets();
+  await new Promise((resolve4, reject) => {
+    pm2.start(
+      {
+        name: MANAGED_SERVER_NAME,
+        script,
+        cwd,
+        ...args !== void 0 ? { args } : {},
+        env: {
+          ...process.env,
+          NODE_ENV: "production"
         },
-        (error) => {
-          if (error) {
-            reject(error);
-            return;
-          }
-          resolve3();
+        autorestart: true,
+        restart_delay: PM2_RESTART_DELAY_MS,
+        min_uptime: PM2_MIN_UPTIME,
+        max_restarts: PM2_MAX_RESTARTS,
+        out_file: outFile,
+        error_file: errFile
+      },
+      (error) => {
+        if (error) {
+          reject(error);
+          return;
         }
-      );
-    });
-    await waitForRuntimeReady(waitMs, logOffsets);
+        resolve4();
+      }
+    );
   });
-};
-var getManagedServerStatus = async () => withPm2Connection(async () => {
-  const processes = await describeManagedServer();
+  await waitForRuntimeReady(pm2, waitMs, logOffsets);
+});
+var getManagedServerStatus = async () => withPm2Connection(async (pm2) => {
+  const processes = await describeManagedServer(pm2);
   const process2 = processes[0];
   if (!process2) {
     return {
@@ -11291,6 +11597,13 @@ var getManagedServerStatus = async () => withPm2Connection(async () => {
       restartCount
     };
   }
+  if (pm2Pid === null || pm2Pid === 0) {
+    return {
+      status: "stopped",
+      pm2Pid: null,
+      restartCount
+    };
+  }
   return {
     status: "errored",
     pm2Pid,
@@ -11327,7 +11640,7 @@ async function getServerStatus() {
   const managedStatus = await getManagedServerStatus();
   const runtime = readRuntimeConfig();
   const { outFile, errFile } = getLogPaths();
-  if (managedStatus.status === "stopped") {
+  if (managedStatus.status === "stopped" || managedStatus.pm2Pid === null && runtime === null) {
     if (runtime) {
       deleteRuntimeConfig();
     }
@@ -11358,17 +11671,17 @@ async function getServerStatus() {
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/cli/src/embed.ts
-import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname5, resolve as resolve2 } 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 = dirname5(__filename);
-var WEB_ASSETS_DIR = resolve2(__dirname, "../web");
+var WEB_ASSETS_DIR = resolve3(__dirname, "../web");
 function getStaticAssetsDir() {
   return WEB_ASSETS_DIR;
 }
 function hasWebAssets() {
-  return existsSync8(WEB_ASSETS_DIR);
+  return existsSync10(WEB_ASSETS_DIR);
 }
 
 // packages/cli/src/server-runner.ts
@@ -11376,6 +11689,7 @@ var MISSING_WEB_ASSETS_WARNING = "Warning: Web assets not found. Frontend will n
 var buildServerConfig = () => {
   const savedConfig = readCliConfig();
   const config = {
+    appVersion: getCliVersion(import.meta.url),
     ...savedConfig?.host !== void 0 ? { host: savedConfig.host } : {},
     ...savedConfig?.port !== void 0 && savedConfig.port > 0 ? { port: savedConfig.port } : {},
     ...savedConfig?.dataDir !== void 0 ? { dataDir: savedConfig.dataDir } : {},
@@ -11418,7 +11732,7 @@ var runServerEntrypoint = async (moduleUrl, argvEntry) => {
 };
 var startServer = async () => {
   assertSupportedNodeVersion();
-  const { createServer: createServer2 } = await init_src3().then(() => src_exports);
+  const { createServer: createServer2 } = await init_src4().then(() => src_exports);
   const server = await createServer2(buildServerConfig());
   const shutdown = createShutdownHandler(server);
   process.on("SIGINT", shutdown);
@@ -11480,8 +11794,8 @@ function showLogs(status, {
   errorsOnly = false
 } = {}) {
   const paths = errorsOnly ? [status.errFile] : [status.outFile, status.errFile];
-  const contents = paths.filter((path8, index, paths2) => paths2.indexOf(path8) === index).flatMap((path8) => {
-    const content = readLogExcerpt(path8, { maxLines: tail, maxChars: null });
+  const contents = paths.filter((path9, index, paths2) => paths2.indexOf(path9) === index).flatMap((path9) => {
+    const content = readLogExcerpt(path9, { maxLines: tail, maxChars: null });
     return content ? [content] : [];
   });
   console.log(contents.length === 0 ? "No logs available." : contents.join("\n"));
@@ -11559,16 +11873,7 @@ EXAMPLES:
 `);
 }
 function showVersion() {
-  const manifestPath = [
-    new URL("../package.json", import.meta.url),
-    new URL("../../package.json", import.meta.url)
-  ].find((candidate) => existsSync9(candidate));
-  if (!manifestPath) {
-    throw new Error("Unable to locate CLI package.json");
-  }
-  const manifest = JSON.parse(readFileSync7(manifestPath, "utf-8"));
-  const version = manifest.version ?? "0.0.0";
-  console.log(`@spencer-kit/coder-studio v${version}`);
+  console.log(`@spencer-kit/coder-studio v${getCliVersion(import.meta.url)}`);
 }
 function formatAuthBlocks(blocks) {
   if (blocks.length === 0) {
@@ -11584,7 +11889,7 @@ function resolveManagedScriptPath() {
     join10(currentDir, "server-runner.mjs"),
     join10(currentDir, "../src/server-runner.ts")
   ];
-  const scriptPath = candidates.find((candidate) => existsSync9(candidate));
+  const scriptPath = candidates.find((candidate) => existsSync11(candidate));
   if (!scriptPath) {
     throw new Error("Unable to locate the managed server entry script");
   }