skalpel 2.0.2 → 2.0.5

package/dist/cli/index.js

@@ -204,79 +204,176 @@ ${envContent}`);
 }
 
 // src/cli/doctor.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os2 from "os";
+
+// src/cli/agents/detect.ts
+import { execSync } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+import os from "os";
+function whichCommand() {
+  return process.platform === "win32" ? "where" : "which";
+}
+function tryExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function detectClaudeCode() {
+  const agent = {
+    name: "claude-code",
+    installed: false,
+    version: null,
+    configPath: null
+  };
+  const binaryPath = tryExec(`${whichCommand()} claude`);
+  const hasBinary = binaryPath !== null && binaryPath.length > 0;
+  const claudeDir = path3.join(os.homedir(), ".claude");
+  const hasConfigDir = fs3.existsSync(claudeDir);
+  agent.installed = hasBinary || hasConfigDir;
+  if (hasBinary) {
+    const versionOutput = tryExec("claude --version");
+    if (versionOutput) {
+      const match = versionOutput.match(/(\d+\.\d+[\w.-]*)/);
+      agent.version = match ? match[1] : versionOutput;
+    }
+  }
+  const settingsPath = path3.join(claudeDir, "settings.json");
+  if (fs3.existsSync(settingsPath)) {
+    agent.configPath = settingsPath;
+  } else if (hasConfigDir) {
+    agent.configPath = settingsPath;
+  }
+  return agent;
+}
+function detectCodex() {
+  const agent = {
+    name: "codex",
+    installed: false,
+    version: null,
+    configPath: null
+  };
+  const binaryPath = tryExec(`${whichCommand()} codex`);
+  const hasBinary = binaryPath !== null && binaryPath.length > 0;
+  const codexConfigDir = process.platform === "win32" ? path3.join(os.homedir(), "AppData", "Roaming", "codex") : path3.join(os.homedir(), ".codex");
+  const hasConfigDir = fs3.existsSync(codexConfigDir);
+  agent.installed = hasBinary || hasConfigDir;
+  if (hasBinary) {
+    const versionOutput = tryExec("codex --version");
+    if (versionOutput) {
+      const match = versionOutput.match(/(\d+\.\d+[\w.-]*)/);
+      agent.version = match ? match[1] : versionOutput;
+    }
+  }
+  const configFile = path3.join(codexConfigDir, "config.toml");
+  if (fs3.existsSync(configFile)) {
+    agent.configPath = configFile;
+  } else if (hasConfigDir) {
+    agent.configPath = configFile;
+  }
+  return agent;
+}
+function detectAgents() {
+  return [detectClaudeCode(), detectCodex()];
+}
+
+// src/cli/doctor.ts
 function print2(msg) {
   console.log(msg);
 }
+function loadConfigApiKey() {
+  try {
+    const configPath = path4.join(os2.homedir(), ".skalpel", "config.json");
+    const raw = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
+    if (typeof raw.apiKey === "string" && raw.apiKey.length > 0) {
+      return raw.apiKey;
+    }
+  } catch {
+  }
+  return null;
+}
 async function runDoctor() {
   print2("");
   print2("  Skalpel Doctor");
   print2("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
   print2("");
   const checks = [];
-  const apiKey = process.env.SKALPEL_API_KEY ?? "";
-  if (!apiKey) {
+  const configKey = loadConfigApiKey();
+  const envKey = process.env.SKALPEL_API_KEY ?? "";
+  const apiKey = configKey || envKey;
+  if (apiKey && validateApiKey(apiKey)) {
+    const source = configKey ? "~/.skalpel/config.json" : "environment";
     checks.push({
       name: "API Key",
-      status: "fail",
-      message: "SKALPEL_API_KEY not set in environment"
+      status: "ok",
+      message: `Valid key from ${source}: ${apiKey.slice(0, 14)}${"*".repeat(Math.max(0, apiKey.length - 14))}`
     });
-  } else if (!validateApiKey(apiKey)) {
+  } else if (apiKey) {
     checks.push({
       name: "API Key",
       status: "fail",
-      message: `Invalid format \u2014 must start with "sk-skalpel-" and be >= 20 chars (got "${apiKey.slice(0, 10)}...")`
+      message: `Invalid format \u2014 must start with "sk-skalpel-" and be >= 20 chars`
     });
   } else {
     checks.push({
       name: "API Key",
-      status: "ok",
-      message: `Valid key: ${apiKey.slice(0, 14)}${"*".repeat(Math.max(0, apiKey.length - 14))}`
+      status: "fail",
+      message: 'No API key found. Run "npx skalpel" to set up.'
     });
   }
-  const envPath = path3.join(process.cwd(), ".env");
-  if (fs3.existsSync(envPath)) {
-    const content = fs3.readFileSync(envPath, "utf-8");
-    if (content.includes("SKALPEL_API_KEY")) {
-      checks.push({ name: ".env file", status: "ok", message: "Found SKALPEL_API_KEY in .env" });
-    } else {
-      checks.push({ name: ".env file", status: "warn", message: ".env exists but no SKALPEL_API_KEY entry" });
-    }
+  const skalpelConfigPath = path4.join(os2.homedir(), ".skalpel", "config.json");
+  if (fs4.existsSync(skalpelConfigPath)) {
+    checks.push({ name: "Skalpel config", status: "ok", message: "~/.skalpel/config.json found" });
   } else {
-    checks.push({ name: ".env file", status: "warn", message: "No .env file found in current directory" });
+    checks.push({ name: "Skalpel config", status: "warn", message: 'No ~/.skalpel/config.json \u2014 run "npx skalpel" to set up' });
   }
-  const baseURL = process.env.SKALPEL_BASE_URL ?? "https://api.skalpel.ai";
+  const baseURL = "https://api.skalpel.ai";
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 5e3);
     const response = await fetch(`${baseURL}/health`, { signal: controller.signal });
     clearTimeout(timeout);
     if (response.ok) {
-      checks.push({ name: "Proxy endpoint", status: "ok", message: `${baseURL} reachable (HTTP ${response.status})` });
+      checks.push({ name: "Skalpel backend", status: "ok", message: `${baseURL} reachable (HTTP ${response.status})` });
     } else {
-      checks.push({ name: "Proxy endpoint", status: "warn", message: `${baseURL} responded with HTTP ${response.status}` });
+      checks.push({ name: "Skalpel backend", status: "warn", message: `${baseURL} responded with HTTP ${response.status}` });
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    checks.push({ name: "Proxy endpoint", status: "fail", message: `Cannot reach ${baseURL} \u2014 ${msg}` });
+    checks.push({ name: "Skalpel backend", status: "fail", message: `Cannot reach ${baseURL} \u2014 ${msg}` });
   }
-  const skalpelDir = path3.join(process.cwd(), ".skalpel");
-  if (fs3.existsSync(path3.join(skalpelDir, "config.json"))) {
-    checks.push({ name: "Workspace config", status: "ok", message: ".skalpel/config.json found" });
-  } else {
-    checks.push({ name: "Workspace config", status: "warn", message: 'No .skalpel/config.json \u2014 run "skalpel init" first' });
-  }
-  const hasPackageJson = fs3.existsSync(path3.join(process.cwd(), "package.json"));
-  const hasPyProject = fs3.existsSync(path3.join(process.cwd(), "pyproject.toml"));
-  const hasRequirements = fs3.existsSync(path3.join(process.cwd(), "requirements.txt"));
-  if (hasPackageJson || hasPyProject || hasRequirements) {
-    const types = [];
-    if (hasPackageJson) types.push("Node.js");
-    if (hasPyProject || hasRequirements) types.push("Python");
-    checks.push({ name: "Project detected", status: "ok", message: types.join(", ") });
-  } else {
-    checks.push({ name: "Project detected", status: "warn", message: "No package.json or Python config found" });
+  let proxyPort = 18100;
+  try {
+    const raw = JSON.parse(fs4.readFileSync(skalpelConfigPath, "utf-8"));
+    proxyPort = raw.anthropicPort ?? 18100;
+  } catch {
+  }
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2e3);
+    const res = await fetch(`http://localhost:${proxyPort}/health`, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (res.ok) {
+      checks.push({ name: "Local proxy", status: "ok", message: `Running on port ${proxyPort}` });
+    } else {
+      checks.push({ name: "Local proxy", status: "warn", message: `Port ${proxyPort} responded with HTTP ${res.status}` });
+    }
+  } catch {
+    checks.push({ name: "Local proxy", status: "warn", message: `Not running on port ${proxyPort}. Run "npx skalpel start" to start.` });
+  }
+  const agents = detectAgents();
+  for (const agent of agents) {
+    if (agent.installed) {
+      const ver = agent.version ? ` v${agent.version}` : "";
+      const configured = agent.configPath && fs4.existsSync(agent.configPath) ? " (configured)" : "";
+      checks.push({ name: agent.name, status: "ok", message: `Installed${ver}${configured}` });
+    } else {
+      checks.push({ name: agent.name, status: "warn", message: "Not installed" });
+    }
   }
   const icons = { ok: "+", warn: "!", fail: "x" };
   for (const check of checks) {
@@ -389,8 +486,8 @@ async function runBenchmark() {
 }
 
 // src/cli/replay.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function print4(msg) {
   console.log(msg);
 }
@@ -420,16 +517,16 @@ async function runReplay(filePaths) {
   let successCount = 0;
   let failCount = 0;
   for (const filePath of filePaths) {
-    const resolved = path4.resolve(filePath);
+    const resolved = path5.resolve(filePath);
     print4(`  File: ${resolved}`);
-    if (!fs4.existsSync(resolved)) {
+    if (!fs5.existsSync(resolved)) {
       print4(`    Error: file not found`);
       failCount++;
       continue;
     }
     let requestBody;
     try {
-      const raw = fs4.readFileSync(resolved, "utf-8");
+      const raw = fs5.readFileSync(resolved, "utf-8");
       requestBody = JSON.parse(raw);
     } catch (err) {
       print4(`    Error: invalid JSON \u2014 ${err instanceof Error ? err.message : String(err)}`);
@@ -481,16 +578,16 @@ async function runReplay(filePaths) {
 
 // src/cli/start.ts
 import { spawn } from "child_process";
-import path9 from "path";
+import path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/proxy/config.ts
-import fs5 from "fs";
-import path5 from "path";
-import os from "os";
+import fs6 from "fs";
+import path6 from "path";
+import os3 from "os";
 function expandHome(filePath) {
   if (filePath.startsWith("~")) {
-    return path5.join(os.homedir(), filePath.slice(1));
+    return path6.join(os3.homedir(), filePath.slice(1));
   }
   return filePath;
 }
@@ -509,7 +606,7 @@ function loadConfig(configPath) {
   const filePath = expandHome(configPath ?? DEFAULTS.configFile);
   let fileConfig = {};
   try {
-    const raw = fs5.readFileSync(filePath, "utf-8");
+    const raw = fs6.readFileSync(filePath, "utf-8");
     fileConfig = JSON.parse(raw);
   } catch {
   }
@@ -526,17 +623,17 @@ function loadConfig(configPath) {
   };
 }
 function saveConfig(config) {
-  const dir = path5.dirname(config.configFile);
-  fs5.mkdirSync(dir, { recursive: true });
-  fs5.writeFileSync(config.configFile, JSON.stringify(config, null, 2) + "\n");
+  const dir = path6.dirname(config.configFile);
+  fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(config.configFile, JSON.stringify(config, null, 2) + "\n");
 }
 
 // src/proxy/pid.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 function readPid(pidFile) {
   try {
-    const raw = fs6.readFileSync(pidFile, "utf-8").trim();
+    const raw = fs7.readFileSync(pidFile, "utf-8").trim();
     const pid = parseInt(raw, 10);
     if (isNaN(pid)) return null;
     return isRunning(pid) ? pid : null;
@@ -554,21 +651,21 @@ function isRunning(pid) {
 }
 function removePid(pidFile) {
   try {
-    fs6.unlinkSync(pidFile);
+    fs7.unlinkSync(pidFile);
   } catch {
   }
 }
 
 // src/cli/service/install.ts
-import fs7 from "fs";
-import path8 from "path";
-import os4 from "os";
-import { execSync as execSync2 } from "child_process";
+import fs8 from "fs";
+import path9 from "path";
+import os6 from "os";
+import { execSync as execSync3 } from "child_process";
 import { fileURLToPath } from "url";
 
 // src/cli/service/detect-os.ts
-import os2 from "os";
-import { execSync } from "child_process";
+import os4 from "os";
+import { execSync as execSync2 } from "child_process";
 function detectShell() {
   if (process.platform === "win32") {
     if (process.env.PSModulePath || process.env.POWERSHELL_DISTRIBUTION_CHANNEL) {
@@ -582,7 +679,7 @@ function detectShell() {
   if (shellPath.includes("bash")) return "bash";
   try {
     if (process.platform === "darwin") {
-      const result = execSync(`dscl . -read /Users/${os2.userInfo().username} UserShell`, {
+      const result = execSync2(`dscl . -read /Users/${os4.userInfo().username} UserShell`, {
         encoding: "utf-8",
         timeout: 3e3
       }).trim();
@@ -591,7 +688,7 @@ function detectShell() {
       if (shell.includes("fish")) return "fish";
       if (shell.includes("bash")) return "bash";
     } else {
-      const result = execSync(`getent passwd ${os2.userInfo().username}`, {
+      const result = execSync2(`getent passwd ${os4.userInfo().username}`, {
         encoding: "utf-8",
         timeout: 3e3
       }).trim();
@@ -620,15 +717,15 @@ function detectOS() {
   return {
     platform,
     shell: detectShell(),
-    homeDir: os2.homedir()
+    homeDir: os4.homedir()
   };
 }
 
 // src/cli/service/templates.ts
-import os3 from "os";
-import path7 from "path";
+import os5 from "os";
+import path8 from "path";
 function generateLaunchdPlist(config, proxyRunnerPath) {
-  const logDir = path7.join(os3.homedir(), ".skalpel", "logs");
+  const logDir = path8.join(os5.homedir(), ".skalpel", "logs");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -645,9 +742,9 @@ function generateLaunchdPlist(config, proxyRunnerPath) {
   <key>KeepAlive</key>
   <true/>
   <key>StandardOutPath</key>
-  <string>${path7.join(logDir, "proxy-stdout.log")}</string>
+  <string>${path8.join(logDir, "proxy-stdout.log")}</string>
   <key>StandardErrorPath</key>
-  <string>${path7.join(logDir, "proxy-stderr.log")}</string>
+  <string>${path8.join(logDir, "proxy-stderr.log")}</string>
   <key>EnvironmentVariables</key>
   <dict>
     <key>SKALPEL_ANTHROPIC_PORT</key>
@@ -690,51 +787,51 @@ function generateWindowsTask(config, proxyRunnerPath) {
 }
 
 // src/cli/service/install.ts
-var __dirname = path8.dirname(fileURLToPath(import.meta.url));
+var __dirname = path9.dirname(fileURLToPath(import.meta.url));
 function resolveProxyRunnerPath() {
   const candidates = [
-    path8.join(__dirname, "..", "proxy-runner.js"),
+    path9.join(__dirname, "..", "proxy-runner.js"),
     // dist/cli/proxy-runner.js relative to dist/cli/service/
-    path8.join(__dirname, "proxy-runner.js"),
+    path9.join(__dirname, "proxy-runner.js"),
     // same dir
-    path8.join(__dirname, "..", "..", "cli", "proxy-runner.js")
+    path9.join(__dirname, "..", "..", "cli", "proxy-runner.js")
     // dist/cli/proxy-runner.js from deeper
   ];
   for (const candidate of candidates) {
-    if (fs7.existsSync(candidate)) {
-      return path8.resolve(candidate);
+    if (fs8.existsSync(candidate)) {
+      return path9.resolve(candidate);
     }
   }
   try {
-    const npmRoot = execSync2("npm root -g", { encoding: "utf-8" }).trim();
-    const globalPath = path8.join(npmRoot, "skalpel", "dist", "cli", "proxy-runner.js");
-    if (fs7.existsSync(globalPath)) return globalPath;
+    const npmRoot = execSync3("npm root -g", { encoding: "utf-8" }).trim();
+    const globalPath = path9.join(npmRoot, "skalpel", "dist", "cli", "proxy-runner.js");
+    if (fs8.existsSync(globalPath)) return globalPath;
   } catch {
   }
-  const devPath = path8.resolve(process.cwd(), "dist", "cli", "proxy-runner.js");
+  const devPath = path9.resolve(process.cwd(), "dist", "cli", "proxy-runner.js");
   return devPath;
 }
 function getMacOSPlistPath() {
-  return path8.join(os4.homedir(), "Library", "LaunchAgents", "ai.skalpel.proxy.plist");
+  return path9.join(os6.homedir(), "Library", "LaunchAgents", "ai.skalpel.proxy.plist");
 }
 function getLinuxUnitPath() {
-  return path8.join(os4.homedir(), ".config", "systemd", "user", "skalpel-proxy.service");
+  return path9.join(os6.homedir(), ".config", "systemd", "user", "skalpel-proxy.service");
 }
 function installService(config) {
   const osInfo = detectOS();
   const proxyRunnerPath = resolveProxyRunnerPath();
-  const logDir = path8.join(os4.homedir(), ".skalpel", "logs");
-  fs7.mkdirSync(logDir, { recursive: true });
+  const logDir = path9.join(os6.homedir(), ".skalpel", "logs");
+  fs8.mkdirSync(logDir, { recursive: true });
   switch (osInfo.platform) {
     case "macos": {
       const plistPath = getMacOSPlistPath();
-      const plistDir = path8.dirname(plistPath);
-      fs7.mkdirSync(plistDir, { recursive: true });
+      const plistDir = path9.dirname(plistPath);
+      fs8.mkdirSync(plistDir, { recursive: true });
       const plist = generateLaunchdPlist(config, proxyRunnerPath);
-      fs7.writeFileSync(plistPath, plist);
+      fs8.writeFileSync(plistPath, plist);
       try {
-        execSync2(`launchctl unload "${plistPath}" 2>/dev/null || true`, { stdio: "pipe" });
-        execSync2(`launchctl load "${plistPath}"`, { stdio: "pipe" });
+        execSync3(`launchctl unload "${plistPath}" 2>/dev/null || true`, { stdio: "pipe" });
+        execSync3(`launchctl load "${plistPath}"`, { stdio: "pipe" });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         console.warn(`  Warning: Could not register launchd service: ${msg}`);
@@ -744,18 +841,18 @@ function installService(config) {
     }
     case "linux": {
       const unitPath = getLinuxUnitPath();
-      const unitDir = path8.dirname(unitPath);
-      fs7.mkdirSync(unitDir, { recursive: true });
+      const unitDir = path9.dirname(unitPath);
+      fs8.mkdirSync(unitDir, { recursive: true });
       const unit = generateSystemdUnit(config, proxyRunnerPath);
-      fs7.writeFileSync(unitPath, unit);
+      fs8.writeFileSync(unitPath, unit);
       try {
-        execSync2("systemctl --user daemon-reload", { stdio: "pipe" });
-        execSync2("systemctl --user enable skalpel-proxy", { stdio: "pipe" });
-        execSync2("systemctl --user start skalpel-proxy", { stdio: "pipe" });
+        execSync3("systemctl --user daemon-reload", { stdio: "pipe" });
+        execSync3("systemctl --user enable skalpel-proxy", { stdio: "pipe" });
+        execSync3("systemctl --user start skalpel-proxy", { stdio: "pipe" });
       } catch {
         try {
-          const autostartDir = path8.join(os4.homedir(), ".config", "autostart");
-          fs7.mkdirSync(autostartDir, { recursive: true });
+          const autostartDir = path9.join(os6.homedir(), ".config", "autostart");
+          fs8.mkdirSync(autostartDir, { recursive: true });
           const desktopEntry = `[Desktop Entry]
 Type=Application
 Name=Skalpel Proxy
@@ -764,7 +861,7 @@ Hidden=false
 NoDisplay=true
 X-GNOME-Autostart-enabled=true
 `;
-          fs7.writeFileSync(path8.join(autostartDir, "skalpel-proxy.desktop"), desktopEntry);
+          fs8.writeFileSync(path9.join(autostartDir, "skalpel-proxy.desktop"), desktopEntry);
           console.warn("  Warning: systemd --user not available. Created .desktop autostart entry instead.");
         } catch (err2) {
           const msg = err2 instanceof Error ? err2.message : String(err2);
@@ -777,7 +874,7 @@ X-GNOME-Autostart-enabled=true
     case "windows": {
       const args = generateWindowsTask(config, proxyRunnerPath);
       try {
-        execSync2(`schtasks ${args.join(" ")}`, { stdio: "pipe" });
+        execSync3(`schtasks ${args.join(" ")}`, { stdio: "pipe" });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         console.warn(`  Warning: Could not create scheduled task: ${msg}`);
@@ -792,15 +889,15 @@ function isServiceInstalled() {
   switch (osInfo.platform) {
     case "macos": {
       const plistPath = getMacOSPlistPath();
-      return fs7.existsSync(plistPath);
+      return fs8.existsSync(plistPath);
     }
     case "linux": {
       const unitPath = getLinuxUnitPath();
-      return fs7.existsSync(unitPath);
+      return fs8.existsSync(unitPath);
     }
     case "windows": {
       try {
-        execSync2("schtasks /query /tn SkalpelProxy", { stdio: "pipe" });
+        execSync3("schtasks /query /tn SkalpelProxy", { stdio: "pipe" });
         return true;
       } catch {
         return false;
@@ -813,23 +910,23 @@ function stopService() {
   switch (osInfo.platform) {
     case "macos": {
       const plistPath = getMacOSPlistPath();
-      if (!fs7.existsSync(plistPath)) return;
+      if (!fs8.existsSync(plistPath)) return;
       try {
-        execSync2(`launchctl unload "${plistPath}"`, { stdio: "pipe" });
+        execSync3(`launchctl unload "${plistPath}"`, { stdio: "pipe" });
       } catch {
       }
       break;
     }
     case "linux": {
       try {
-        execSync2("systemctl --user stop skalpel-proxy", { stdio: "pipe" });
+        execSync3("systemctl --user stop skalpel-proxy", { stdio: "pipe" });
       } catch {
       }
       break;
     }
     case "windows": {
       try {
-        execSync2("schtasks /end /tn SkalpelProxy", { stdio: "pipe" });
+        execSync3("schtasks /end /tn SkalpelProxy", { stdio: "pipe" });
       } catch {
       }
       break;
@@ -841,23 +938,23 @@ function startService() {
   switch (osInfo.platform) {
     case "macos": {
       const plistPath = getMacOSPlistPath();
-      if (!fs7.existsSync(plistPath)) return;
+      if (!fs8.existsSync(plistPath)) return;
       try {
-        execSync2(`launchctl load "${plistPath}"`, { stdio: "pipe" });
+        execSync3(`launchctl load "${plistPath}"`, { stdio: "pipe" });
       } catch {
       }
       break;
     }
     case "linux": {
       try {
-        execSync2("systemctl --user start skalpel-proxy", { stdio: "pipe" });
+        execSync3("systemctl --user start skalpel-proxy", { stdio: "pipe" });
       } catch {
       }
       break;
     }
     case "windows": {
       try {
-        execSync2("schtasks /run /tn SkalpelProxy", { stdio: "pipe" });
+        execSync3("schtasks /run /tn SkalpelProxy", { stdio: "pipe" });
       } catch {
       }
       break;
@@ -870,27 +967,27 @@ function uninstallService() {
     case "macos": {
       const plistPath = getMacOSPlistPath();
       try {
-        execSync2(`launchctl unload "${plistPath}" 2>/dev/null || true`, { stdio: "pipe" });
+        execSync3(`launchctl unload "${plistPath}" 2>/dev/null || true`, { stdio: "pipe" });
       } catch {
       }
-      if (fs7.existsSync(plistPath)) fs7.unlinkSync(plistPath);
+      if (fs8.existsSync(plistPath)) fs8.unlinkSync(plistPath);
       break;
     }
     case "linux": {
       try {
-        execSync2("systemctl --user stop skalpel-proxy 2>/dev/null || true", { stdio: "pipe" });
-        execSync2("systemctl --user disable skalpel-proxy 2>/dev/null || true", { stdio: "pipe" });
+        execSync3("systemctl --user stop skalpel-proxy 2>/dev/null || true", { stdio: "pipe" });
+        execSync3("systemctl --user disable skalpel-proxy 2>/dev/null || true", { stdio: "pipe" });
       } catch {
       }
       const unitPath = getLinuxUnitPath();
-      if (fs7.existsSync(unitPath)) fs7.unlinkSync(unitPath);
-      const desktopPath = path8.join(os4.homedir(), ".config", "autostart", "skalpel-proxy.desktop");
-      if (fs7.existsSync(desktopPath)) fs7.unlinkSync(desktopPath);
+      if (fs8.existsSync(unitPath)) fs8.unlinkSync(unitPath);
+      const desktopPath = path9.join(os6.homedir(), ".config", "autostart", "skalpel-proxy.desktop");
+      if (fs8.existsSync(desktopPath)) fs8.unlinkSync(desktopPath);
       break;
     }
     case "windows": {
       try {
-        execSync2("schtasks /delete /tn SkalpelProxy /f", { stdio: "pipe" });
+        execSync3("schtasks /delete /tn SkalpelProxy /f", { stdio: "pipe" });
       } catch {
       }
       break;
@@ -918,8 +1015,8 @@ async function runStart() {
     print5(`  Skalpel proxy started via system service on ports ${config.anthropicPort} and ${config.openaiPort}`);
     return;
   }
-  const dirname = path9.dirname(fileURLToPath2(import.meta.url));
-  const runnerScript = path9.resolve(dirname, "proxy-runner.js");
+  const dirname = path10.dirname(fileURLToPath2(import.meta.url));
+  const runnerScript = path10.resolve(dirname, "proxy-runner.js");
   const child = spawn(process.execPath, [runnerScript], {
     detached: true,
     stdio: "ignore"
@@ -932,8 +1029,8 @@ async function runStart() {
 import http from "http";
 
 // src/proxy/logger.ts
-import fs8 from "fs";
-import path10 from "path";
+import fs9 from "fs";
+import path11 from "path";
 var MAX_SIZE = 5 * 1024 * 1024;
 
 // src/proxy/server.ts
@@ -997,7 +1094,7 @@ async function runStatus() {
 }
 
 // src/cli/logs.ts
-import fs9 from "fs";
+import fs10 from "fs";
 function print8(msg) {
   console.log(msg);
 }
@@ -1005,26 +1102,26 @@ async function runLogs(options) {
   const config = loadConfig();
   const logFile = config.logFile;
   const lineCount = parseInt(options.lines ?? "50", 10);
-  if (!fs9.existsSync(logFile)) {
+  if (!fs10.existsSync(logFile)) {
     print8(`  No log file found at ${logFile}`);
     return;
   }
-  const content = fs9.readFileSync(logFile, "utf-8");
+  const content = fs10.readFileSync(logFile, "utf-8");
   const lines = content.trimEnd().split("\n");
   const tail = lines.slice(-lineCount);
   for (const line of tail) {
     print8(line);
   }
   if (options.follow) {
-    let position = fs9.statSync(logFile).size;
-    fs9.watchFile(logFile, { interval: 500 }, () => {
+    let position = fs10.statSync(logFile).size;
+    fs10.watchFile(logFile, { interval: 500 }, () => {
       try {
-        const stat = fs9.statSync(logFile);
+        const stat = fs10.statSync(logFile);
         if (stat.size > position) {
-          const fd = fs9.openSync(logFile, "r");
+          const fd = fs10.openSync(logFile, "r");
           const buf = Buffer.alloc(stat.size - position);
-          fs9.readSync(fd, buf, 0, buf.length, position);
-          fs9.closeSync(fd);
+          fs10.readSync(fd, buf, 0, buf.length, position);
+          fs10.closeSync(fd);
           process.stdout.write(buf.toString("utf-8"));
           position = stat.size;
         }
@@ -1131,85 +1228,12 @@ async function runUpdate() {
 import * as readline2 from "readline";
 import * as fs12 from "fs";
 import * as path13 from "path";
-import * as os7 from "os";
-
-// src/cli/agents/detect.ts
-import { execSync as execSync3 } from "child_process";
-import fs10 from "fs";
-import path11 from "path";
-import os5 from "os";
-function whichCommand() {
-  return process.platform === "win32" ? "where" : "which";
-}
-function tryExec(cmd) {
-  try {
-    return execSync3(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
-  } catch {
-    return null;
-  }
-}
-function detectClaudeCode() {
-  const agent = {
-    name: "claude-code",
-    installed: false,
-    version: null,
-    configPath: null
-  };
-  const binaryPath = tryExec(`${whichCommand()} claude`);
-  const hasBinary = binaryPath !== null && binaryPath.length > 0;
-  const claudeDir = path11.join(os5.homedir(), ".claude");
-  const hasConfigDir = fs10.existsSync(claudeDir);
-  agent.installed = hasBinary || hasConfigDir;
-  if (hasBinary) {
-    const versionOutput = tryExec("claude --version");
-    if (versionOutput) {
-      const match = versionOutput.match(/(\d+\.\d+[\w.-]*)/);
-      agent.version = match ? match[1] : versionOutput;
-    }
-  }
-  const settingsPath = path11.join(claudeDir, "settings.json");
-  if (fs10.existsSync(settingsPath)) {
-    agent.configPath = settingsPath;
-  } else if (hasConfigDir) {
-    agent.configPath = settingsPath;
-  }
-  return agent;
-}
-function detectCodex() {
-  const agent = {
-    name: "codex",
-    installed: false,
-    version: null,
-    configPath: null
-  };
-  const binaryPath = tryExec(`${whichCommand()} codex`);
-  const hasBinary = binaryPath !== null && binaryPath.length > 0;
-  const codexConfigDir = process.platform === "win32" ? path11.join(os5.homedir(), "AppData", "Roaming", "codex") : path11.join(os5.homedir(), ".codex");
-  const hasConfigDir = fs10.existsSync(codexConfigDir);
-  agent.installed = hasBinary || hasConfigDir;
-  if (hasBinary) {
-    const versionOutput = tryExec("codex --version");
-    if (versionOutput) {
-      const match = versionOutput.match(/(\d+\.\d+[\w.-]*)/);
-      agent.version = match ? match[1] : versionOutput;
-    }
-  }
-  const configFile = path11.join(codexConfigDir, "config.toml");
-  if (fs10.existsSync(configFile)) {
-    agent.configPath = configFile;
-  } else if (hasConfigDir) {
-    agent.configPath = configFile;
-  }
-  return agent;
-}
-function detectAgents() {
-  return [detectClaudeCode(), detectCodex()];
-}
+import * as os8 from "os";
 
 // src/cli/agents/configure.ts
 import fs11 from "fs";
 import path12 from "path";
-import os6 from "os";
+import os7 from "os";
 function ensureDir(dir) {
   fs11.mkdirSync(dir, { recursive: true });
 }
@@ -1226,7 +1250,7 @@ function readJsonFile(filePath) {
   }
 }
 function configureClaudeCode(agent, proxyConfig) {
-  const configPath = agent.configPath ?? path12.join(os6.homedir(), ".claude", "settings.json");
+  const configPath = agent.configPath ?? path12.join(os7.homedir(), ".claude", "settings.json");
   const configDir = path12.dirname(configPath);
   ensureDir(configDir);
   createBackup(configPath);
@@ -1262,7 +1286,7 @@ function removeTomlKey(content, key) {
   return content.replace(pattern, "");
 }
 function configureCodex(agent, proxyConfig) {
-  const configDir = process.platform === "win32" ? path12.join(os6.homedir(), "AppData", "Roaming", "codex") : path12.join(os6.homedir(), ".codex");
+  const configDir = process.platform === "win32" ? path12.join(os7.homedir(), "AppData", "Roaming", "codex") : path12.join(os7.homedir(), ".codex");
   const configPath = agent.configPath ?? path12.join(configDir, "config.toml");
   ensureDir(path12.dirname(configPath));
   createBackup(configPath);
@@ -1281,7 +1305,7 @@ function configureAgent(agent, proxyConfig) {
   }
 }
 function unconfigureClaudeCode(agent) {
-  const configPath = agent.configPath ?? path12.join(os6.homedir(), ".claude", "settings.json");
+  const configPath = agent.configPath ?? path12.join(os7.homedir(), ".claude", "settings.json");
   const backupPath = `${configPath}.skalpel-backup`;
   if (fs11.existsSync(backupPath)) {
     fs11.copyFileSync(backupPath, configPath);
@@ -1299,7 +1323,7 @@ function unconfigureClaudeCode(agent) {
   fs11.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 function unconfigureCodex(agent) {
-  const configDir = process.platform === "win32" ? path12.join(os6.homedir(), "AppData", "Roaming", "codex") : path12.join(os6.homedir(), ".codex");
+  const configDir = process.platform === "win32" ? path12.join(os7.homedir(), "AppData", "Roaming", "codex") : path12.join(os7.homedir(), ".codex");
   const configPath = agent.configPath ?? path12.join(configDir, "config.toml");
   const backupPath = `${configPath}.skalpel-backup`;
   if (fs11.existsSync(backupPath)) {
@@ -1358,7 +1382,7 @@ async function runWizard(options) {
     print11("  Welcome to Skalpel! Let's optimize your coding agent costs.");
     print11("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     print11("");
-    const skalpelDir = path13.join(os7.homedir(), ".skalpel");
+    const skalpelDir = path13.join(os8.homedir(), ".skalpel");
     const configPath = path13.join(skalpelDir, "config.json");
     let apiKey = "";
     if (isAuto && options?.apiKey) {
@@ -1509,18 +1533,18 @@ async function runWizard(options) {
 import * as readline3 from "readline";
 import * as fs14 from "fs";
 import * as path15 from "path";
-import * as os9 from "os";
+import * as os10 from "os";
 
 // src/cli/agents/shell.ts
 import fs13 from "fs";
 import path14 from "path";
-import os8 from "os";
+import os9 from "os";
 var BEGIN_MARKER = "# BEGIN SKALPEL PROXY - do not edit manually";
 var END_MARKER = "# END SKALPEL PROXY";
 function getPowerShellProfilePath() {
   if (process.platform !== "win32") return null;
   if (process.env.PROFILE) return process.env.PROFILE;
-  const docsDir = path14.join(os8.homedir(), "Documents");
+  const docsDir = path14.join(os9.homedir(), "Documents");
   const psProfile = path14.join(docsDir, "PowerShell", "Microsoft.PowerShell_profile.ps1");
   const wpProfile = path14.join(docsDir, "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
   if (fs13.existsSync(psProfile)) return psProfile;
@@ -1529,7 +1553,7 @@ function getPowerShellProfilePath() {
 }
 function removeShellEnvVars() {
   const restored = [];
-  const home = os8.homedir();
+  const home = os9.homedir();
   const allProfiles = [
     path14.join(home, ".bashrc"),
     path14.join(home, ".zshrc"),
@@ -1631,7 +1655,7 @@ async function runUninstall() {
       }
     }
     print12("");
-    const skalpelDir = path15.join(os9.homedir(), ".skalpel");
+    const skalpelDir = path15.join(os10.homedir(), ".skalpel");
     if (fs14.existsSync(skalpelDir)) {
       const removeDir = await ask("  Remove ~/.skalpel/ directory (contains config and logs)? (y/N): ");
       if (removeDir.toLowerCase() === "y") {