skalpel 2.0.13 → 2.0.15

package/dist/cli/index.js

@@ -1,4 +1,109 @@
 #!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/proxy/dispatcher.ts
+import { Agent } from "undici";
+var skalpelDispatcher;
+var init_dispatcher = __esm({
+  "src/proxy/dispatcher.ts"() {
+    "use strict";
+    skalpelDispatcher = new Agent({
+      keepAliveTimeout: 1e4,
+      keepAliveMaxTimeout: 6e4,
+      connections: 100,
+      pipelining: 1
+    });
+  }
+});
+
+// src/proxy/envelope.ts
+var init_envelope = __esm({
+  "src/proxy/envelope.ts"() {
+    "use strict";
+  }
+});
+
+// src/proxy/recovery.ts
+import { createHash } from "crypto";
+var MUTEX_MAX_ENTRIES, LruMutexMap, refreshMutex;
+var init_recovery = __esm({
+  "src/proxy/recovery.ts"() {
+    "use strict";
+    MUTEX_MAX_ENTRIES = 1024;
+    LruMutexMap = class extends Map {
+      set(key, value) {
+        if (this.has(key)) {
+          super.delete(key);
+        } else if (this.size >= MUTEX_MAX_ENTRIES) {
+          const oldest = this.keys().next().value;
+          if (oldest !== void 0) super.delete(oldest);
+        }
+        return super.set(key, value);
+      }
+    };
+    refreshMutex = new LruMutexMap();
+  }
+});
+
+// src/proxy/fetch-error.ts
+var init_fetch_error = __esm({
+  "src/proxy/fetch-error.ts"() {
+    "use strict";
+  }
+});
+
+// src/proxy/streaming.ts
+var HOP_BY_HOP, STRIP_HEADERS;
+var init_streaming = __esm({
+  "src/proxy/streaming.ts"() {
+    "use strict";
+    init_dispatcher();
+    init_handler();
+    init_envelope();
+    init_recovery();
+    init_fetch_error();
+    HOP_BY_HOP = /* @__PURE__ */ new Set([
+      "connection",
+      "keep-alive",
+      "proxy-authenticate",
+      "proxy-authorization",
+      "te",
+      "trailer",
+      "transfer-encoding",
+      "upgrade"
+    ]);
+    STRIP_HEADERS = /* @__PURE__ */ new Set([
+      ...HOP_BY_HOP,
+      "content-encoding",
+      "content-length"
+    ]);
+  }
+});
+
+// src/proxy/ws-client.ts
+import { EventEmitter } from "events";
+import WebSocket2 from "ws";
+var init_ws_client = __esm({
+  "src/proxy/ws-client.ts"() {
+    "use strict";
+  }
+});
+
+// src/proxy/handler.ts
+var init_handler = __esm({
+  "src/proxy/handler.ts"() {
+    "use strict";
+    init_streaming();
+    init_dispatcher();
+    init_envelope();
+    init_ws_client();
+    init_recovery();
+    init_fetch_error();
+  }
+});
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -207,6 +312,8 @@ ${envContent}`);
 import * as fs4 from "fs";
 import * as path4 from "path";
 import * as os2 from "os";
+import net from "net";
+import WebSocket from "ws";
 
 // src/cli/agents/detect.ts
 import { execSync } from "child_process";
@@ -319,6 +426,133 @@ function detectAgents() {
 function print2(msg) {
   console.log(msg);
 }
+function codexConfigPath() {
+  return process.platform === "win32" ? path4.join(os2.homedir(), "AppData", "Roaming", "codex", "config.toml") : path4.join(os2.homedir(), ".codex", "config.toml");
+}
+function checkCodexConfig(config) {
+  const cfgPath = codexConfigPath();
+  if (!fs4.existsSync(cfgPath)) {
+    return {
+      name: "Codex config",
+      status: "warn",
+      message: `${cfgPath} not found \u2014 run "npx skalpel" to configure Codex`
+    };
+  }
+  let content = "";
+  try {
+    content = fs4.readFileSync(cfgPath, "utf-8");
+  } catch {
+    return {
+      name: "Codex config",
+      status: "warn",
+      message: `cannot read ${cfgPath}`
+    };
+  }
+  const requiredLines = [
+    `openai_base_url = "http://localhost:${config.openaiPort}"`,
+    `model_provider = "skalpel-proxy"`,
+    `[model_providers.skalpel-proxy]`,
+    `wire_api = "responses"`,
+    `base_url = "http://localhost:${config.openaiPort}/v1"`
+  ];
+  const missing = requiredLines.filter((line) => !content.includes(line));
+  if (missing.length === 0) {
+    return {
+      name: "Codex config",
+      status: "ok",
+      message: `skalpel-proxy provider pinned (wire_api=responses) on port ${config.openaiPort}`
+    };
+  }
+  return {
+    name: "Codex config",
+    status: "fail",
+    message: `missing TOML: ${missing.map((m) => m.split("\n")[0]).join("; ")}`
+  };
+}
+async function checkCodexWebSocket(config) {
+  const tcpOk = await new Promise((resolve2) => {
+    const sock = net.connect({ host: "127.0.0.1", port: config.openaiPort, timeout: 1e3 });
+    const done = (ok) => {
+      sock.removeAllListeners();
+      try {
+        sock.destroy();
+      } catch {
+      }
+      resolve2(ok);
+    };
+    sock.once("connect", () => done(true));
+    sock.once("error", () => done(false));
+    sock.once("timeout", () => done(false));
+  });
+  if (!tcpOk) {
+    return {
+      name: "Codex WebSocket",
+      status: "skipped",
+      message: "WebSocket: SKIPPED (proxy not running)"
+    };
+  }
+  return new Promise((resolve2) => {
+    const url = `ws://localhost:${config.openaiPort}/v1/responses`;
+    let settled = false;
+    const ws = new WebSocket(url, ["skalpel-codex-v1"]);
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      try {
+        ws.close();
+      } catch {
+      }
+      resolve2(result);
+    };
+    const timeout = setTimeout(() => {
+      settle({
+        name: "Codex WebSocket",
+        status: "fail",
+        message: "WebSocket: FAIL handshake timeout after 5s"
+      });
+    }, 5e3);
+    ws.once("open", () => {
+      clearTimeout(timeout);
+      settle({ name: "Codex WebSocket", status: "ok", message: "WebSocket: OK" });
+    });
+    ws.once("error", (err) => {
+      clearTimeout(timeout);
+      settle({
+        name: "Codex WebSocket",
+        status: "fail",
+        message: `WebSocket: FAIL ${err.message}`
+      });
+    });
+    ws.once("unexpected-response", (_req, res) => {
+      clearTimeout(timeout);
+      settle({
+        name: "Codex WebSocket",
+        status: "fail",
+        message: `WebSocket: FAIL unexpected HTTP ${res.statusCode}`
+      });
+    });
+  });
+}
+async function checkCodexProxyProbe(config) {
+  const url = `http://localhost:${config.openaiPort}/v1/responses`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: "Bearer sk-codex-placeholder-skalpel" },
+      body: JSON.stringify({ model: "gpt-5-codex", input: "ping", stream: false }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (res.status === 405) {
+      return { name: "Codex proxy probe", status: "error", message: "backend rejected POST \u2014 run the fix in docs/codex-integration-fix.md" };
+    }
+    if (res.status === 401 || res.status >= 200 && res.status < 300) {
+      return { name: "Codex proxy probe", status: "ok", message: `POST /v1/responses returned ${res.status}` };
+    }
+    return { name: "Codex proxy probe", status: "warn", message: `unexpected status ${res.status}` };
+  } catch {
+    return { name: "Codex proxy probe", status: "warn", message: "proxy not reachable (is it running?)" };
+  }
+}
 function loadConfigApiKey() {
   try {
     const configPath = path4.join(os2.homedir(), ".skalpel", "config.json");
@@ -436,12 +670,22 @@ async function runDoctor() {
       checks.push({ name: agent.name, status: "warn", message: "Not installed" });
     }
   }
-  const icons = { ok: "+", warn: "!", fail: "x" };
+  let openaiPort = 18101;
+  try {
+    const raw = JSON.parse(fs4.readFileSync(skalpelConfigPath, "utf-8"));
+    if (typeof raw.openaiPort === "number") openaiPort = raw.openaiPort;
+  } catch {
+  }
+  const config = { openaiPort };
+  checks.push(checkCodexConfig(config));
+  checks.push(await checkCodexProxyProbe(config));
+  checks.push(await checkCodexWebSocket(config));
+  const icons = { ok: "+", warn: "!", fail: "x", error: "x", skipped: "-" };
   for (const check of checks) {
     const icon = icons[check.status];
     print2(`  [${icon}] ${check.name}: ${check.message}`);
   }
-  const failures = checks.filter((c) => c.status === "fail");
+  const failures = checks.filter((c) => c.status === "fail" || c.status === "error");
   const warnings = checks.filter((c) => c.status === "warn");
   print2("");
   if (failures.length > 0) {
@@ -639,7 +883,7 @@ async function runReplay(filePaths) {
 
 // src/cli/start.ts
 import { spawn } from "child_process";
-import path10 from "path";
+import path12 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/proxy/config.ts
@@ -776,6 +1020,20 @@ function removePid(pidFile) {
   }
 }
 
+// src/proxy/health-check.ts
+async function isProxyAlive(port, timeoutMs = 2e3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(`http://localhost:${port}/health`, { signal: controller.signal });
+    return res.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/cli/service/install.ts
 import fs8 from "fs";
 import path9 from "path";
@@ -1118,211 +1376,32 @@ function uninstallService() {
   }
 }
 
-// src/cli/start.ts
-function print5(msg) {
-  console.log(msg);
-}
-async function runStart() {
-  const config = loadConfig();
-  if (!config.apiKey) {
-    print5('  Error: No API key configured. Run "skalpel init" or set SKALPEL_API_KEY.');
-    process.exit(1);
-  }
-  const existingPid = readPid(config.pidFile);
-  if (existingPid !== null) {
-    print5(`  Proxy is already running (pid=${existingPid}).`);
-    return;
-  }
-  if (isServiceInstalled()) {
-    startService();
-    print5(`  Skalpel proxy started via system service on ports ${config.anthropicPort}, ${config.openaiPort}, and ${config.cursorPort}`);
-    return;
-  }
-  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"
-  });
-  child.unref();
-  print5(`  Skalpel proxy started on ports ${config.anthropicPort}, ${config.openaiPort}, and ${config.cursorPort}`);
-}
-
-// src/proxy/server.ts
-import http from "http";
-
-// src/proxy/dispatcher.ts
-import { Agent } from "undici";
-var skalpelDispatcher = new Agent({
-  keepAliveTimeout: 1e4,
-  keepAliveMaxTimeout: 6e4,
-  connections: 100,
-  pipelining: 1
-});
-
-// src/proxy/recovery.ts
-import { createHash } from "crypto";
-var MUTEX_MAX_ENTRIES = 1024;
-var LruMutexMap = class extends Map {
-  set(key, value) {
-    if (this.has(key)) {
-      super.delete(key);
-    } else if (this.size >= MUTEX_MAX_ENTRIES) {
-      const oldest = this.keys().next().value;
-      if (oldest !== void 0) super.delete(oldest);
-    }
-    return super.set(key, value);
-  }
-};
-var refreshMutex = new LruMutexMap();
-
-// src/proxy/streaming.ts
-var HOP_BY_HOP = /* @__PURE__ */ new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
-]);
-var STRIP_HEADERS = /* @__PURE__ */ new Set([
-  ...HOP_BY_HOP,
-  "content-encoding",
-  "content-length"
-]);
-
-// src/proxy/logger.ts
-import fs9 from "fs";
-import path11 from "path";
-var MAX_SIZE = 5 * 1024 * 1024;
-
-// src/proxy/server.ts
-var proxyStartTime = 0;
-function stopProxy(config) {
-  const pid = readPid(config.pidFile);
-  if (pid === null) return false;
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch {
-  }
-  removePid(config.pidFile);
-  return true;
-}
-function getProxyStatus(config) {
-  const pid = readPid(config.pidFile);
-  return {
-    running: pid !== null,
-    pid,
-    uptime: proxyStartTime > 0 ? Date.now() - proxyStartTime : 0,
-    anthropicPort: config.anthropicPort,
-    openaiPort: config.openaiPort,
-    cursorPort: config.cursorPort
-  };
-}
-
-// src/cli/stop.ts
-function print6(msg) {
-  console.log(msg);
-}
-async function runStop() {
-  const config = loadConfig();
-  if (isServiceInstalled()) {
-    stopService();
-  }
-  const stopped = stopProxy(config);
-  if (stopped) {
-    print6("  Skalpel proxy stopped.");
-  } else {
-    print6("  Proxy is not running.");
-  }
-}
-
-// src/cli/status.ts
-function print7(msg) {
-  console.log(msg);
-}
-async function runStatus() {
-  const config = loadConfig();
-  const status = getProxyStatus(config);
-  print7("");
-  print7("  Skalpel Proxy Status");
-  print7("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  print7(`  Status:      ${status.running ? "running" : "stopped"}`);
-  if (status.pid !== null) {
-    print7(`  PID:         ${status.pid}`);
-  }
-  print7(`  Anthropic:   port ${status.anthropicPort}`);
-  print7(`  OpenAI:      port ${status.openaiPort}`);
-  print7(`  Cursor:      port ${status.cursorPort}`);
-  print7(`  Config:      ${config.configFile}`);
-  print7("");
-}
-
-// src/cli/logs.ts
-import fs10 from "fs";
-function print8(msg) {
-  console.log(msg);
-}
-async function runLogs(options) {
-  const config = loadConfig();
-  const logFile = config.logFile;
-  const lineCount = parseInt(options.lines ?? "50", 10);
-  if (!fs10.existsSync(logFile)) {
-    print8(`  No log file found at ${logFile}`);
-    return;
-  }
-  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 = fs10.statSync(logFile).size;
-    fs10.watchFile(logFile, { interval: 500 }, () => {
-      try {
-        const stat = fs10.statSync(logFile);
-        if (stat.size > position) {
-          const fd = fs10.openSync(logFile, "r");
-          const buf = Buffer.alloc(stat.size - position);
-          fs10.readSync(fd, buf, 0, buf.length, position);
-          fs10.closeSync(fd);
-          process.stdout.write(buf.toString("utf-8"));
-          position = stat.size;
-        }
-      } catch {
-      }
-    });
-  }
-}
-
 // src/cli/agents/configure.ts
-import fs11 from "fs";
-import path12 from "path";
+import fs9 from "fs";
+import path10 from "path";
 import os7 from "os";
 var CURSOR_API_BASE_URL_KEY = "openai.apiBaseUrl";
 var DIRECT_MODE_BASE_URL = "https://api.skalpel.ai";
 var CODEX_DIRECT_PROVIDER_ID = "skalpel";
+var CODEX_PROXY_PROVIDER_ID = "skalpel-proxy";
 function ensureDir(dir) {
-  fs11.mkdirSync(dir, { recursive: true });
+  fs9.mkdirSync(dir, { recursive: true });
 }
 function createBackup(filePath) {
-  if (fs11.existsSync(filePath)) {
-    fs11.copyFileSync(filePath, `${filePath}.skalpel-backup`);
+  if (fs9.existsSync(filePath)) {
+    fs9.copyFileSync(filePath, `${filePath}.skalpel-backup`);
   }
 }
 function readJsonFile(filePath) {
   try {
-    return JSON.parse(fs11.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs9.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function configureClaudeCode(agent, proxyConfig, direct = false) {
-  const configPath = agent.configPath ?? path12.join(os7.homedir(), ".claude", "settings.json");
-  const configDir = path12.dirname(configPath);
+  const configPath = agent.configPath ?? path10.join(os7.homedir(), ".claude", "settings.json");
+  const configDir = path10.dirname(configPath);
   ensureDir(configDir);
   createBackup(configPath);
   const config = readJsonFile(configPath) ?? {};
@@ -1337,11 +1416,11 @@ function configureClaudeCode(agent, proxyConfig, direct = false) {
     env.ANTHROPIC_BASE_URL = `http://localhost:${proxyConfig.anthropicPort}`;
     delete env.ANTHROPIC_CUSTOM_HEADERS;
   }
-  fs11.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 function readTomlFile(filePath) {
   try {
-    return fs11.readFileSync(filePath, "utf-8");
+    return fs9.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -1396,10 +1475,43 @@ function removeCodexDirectProvider(content) {
   const rest = content.slice(end).replace(/^\n+/, "");
   return before.length > 0 && rest.length > 0 ? before + "\n" + rest : before + rest;
 }
+function buildCodexProxyProviderBlock(port) {
+  return [
+    `[model_providers.skalpel-proxy]`,
+    `name = "Skalpel Proxy"`,
+    `base_url = "http://localhost:${port}/v1"`,
+    `wire_api = "responses"`,
+    `env_key = "OPENAI_API_KEY"`
+  ].join("\n");
+}
+function upsertCodexProxyProvider(content, port) {
+  const sectionHeader = `[model_providers.${CODEX_PROXY_PROVIDER_ID}]`;
+  const block = buildCodexProxyProviderBlock(port);
+  const idx = content.indexOf(sectionHeader);
+  if (idx === -1) {
+    const separator = content.length > 0 && !content.endsWith("\n") ? "\n\n" : content.length > 0 ? "\n" : "";
+    return content + separator + block + "\n";
+  }
+  const after = content.slice(idx + sectionHeader.length);
+  const nextHeaderMatch = after.match(/\n\[[^\]]+\]/);
+  const end = nextHeaderMatch && nextHeaderMatch.index !== void 0 ? idx + sectionHeader.length + nextHeaderMatch.index : content.length;
+  return content.slice(0, idx) + block + content.slice(end);
+}
+function removeCodexProxyProvider(content) {
+  const sectionHeader = `[model_providers.${CODEX_PROXY_PROVIDER_ID}]`;
+  const idx = content.indexOf(sectionHeader);
+  if (idx === -1) return content;
+  const after = content.slice(idx + sectionHeader.length);
+  const nextHeaderMatch = after.match(/\n\[[^\]]+\]/);
+  const end = nextHeaderMatch && nextHeaderMatch.index !== void 0 ? idx + sectionHeader.length + nextHeaderMatch.index : content.length;
+  const before = content.slice(0, idx).replace(/\n+$/, "");
+  const rest = content.slice(end).replace(/^\n+/, "");
+  return before.length > 0 && rest.length > 0 ? before + "\n" + rest : before + rest;
+}
 function configureCodex(agent, proxyConfig, direct = false) {
-  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));
+  const configDir = process.platform === "win32" ? path10.join(os7.homedir(), "AppData", "Roaming", "codex") : path10.join(os7.homedir(), ".codex");
+  const configPath = agent.configPath ?? path10.join(configDir, "config.toml");
+  ensureDir(path10.dirname(configPath));
   createBackup(configPath);
   let content = readTomlFile(configPath);
   if (direct) {
@@ -1408,18 +1520,19 @@ function configureCodex(agent, proxyConfig, direct = false) {
     content = upsertCodexDirectProvider(content, proxyConfig.apiKey);
   } else {
     content = setTomlKey(content, "openai_base_url", `http://localhost:${proxyConfig.openaiPort}`);
-    content = removeTomlKey(content, "model_provider");
+    content = setTomlKey(content, "model_provider", CODEX_PROXY_PROVIDER_ID);
+    content = upsertCodexProxyProvider(content, proxyConfig.openaiPort);
     content = removeCodexDirectProvider(content);
   }
-  fs11.writeFileSync(configPath, content);
+  fs9.writeFileSync(configPath, content);
 }
 function getCursorConfigDir() {
   if (process.platform === "darwin") {
-    return path12.join(os7.homedir(), "Library", "Application Support", "Cursor", "User");
+    return path10.join(os7.homedir(), "Library", "Application Support", "Cursor", "User");
   } else if (process.platform === "win32") {
-    return path12.join(process.env.APPDATA ?? path12.join(os7.homedir(), "AppData", "Roaming"), "Cursor", "User");
+    return path10.join(process.env.APPDATA ?? path10.join(os7.homedir(), "AppData", "Roaming"), "Cursor", "User");
   }
-  return path12.join(os7.homedir(), ".config", "Cursor", "User");
+  return path10.join(os7.homedir(), ".config", "Cursor", "User");
 }
 function configureCursor(agent, proxyConfig, direct = false) {
   if (direct) {
@@ -1427,8 +1540,8 @@ function configureCursor(agent, proxyConfig, direct = false) {
     return;
   }
   const configDir = getCursorConfigDir();
-  const configPath = agent.configPath ?? path12.join(configDir, "settings.json");
-  ensureDir(path12.dirname(configPath));
+  const configPath = agent.configPath ?? path10.join(configDir, "settings.json");
+  ensureDir(path10.dirname(configPath));
   createBackup(configPath);
   const config = readJsonFile(configPath) ?? {};
   const existingUrl = config[CURSOR_API_BASE_URL_KEY];
@@ -1437,7 +1550,7 @@ function configureCursor(agent, proxyConfig, direct = false) {
     saveConfig(proxyConfig);
   }
   config[CURSOR_API_BASE_URL_KEY] = `http://localhost:${proxyConfig.cursorPort}`;
-  fs11.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 function configureAgent(agent, proxyConfig, direct = false) {
   switch (agent.name) {
@@ -1453,8 +1566,8 @@ function configureAgent(agent, proxyConfig, direct = false) {
   }
 }
 function unconfigureClaudeCode(agent) {
-  const configPath = agent.configPath ?? path12.join(os7.homedir(), ".claude", "settings.json");
-  if (!fs11.existsSync(configPath)) return;
+  const configPath = agent.configPath ?? path10.join(os7.homedir(), ".claude", "settings.json");
+  if (!fs9.existsSync(configPath)) return;
   const config = readJsonFile(configPath);
   if (config === null) {
     console.warn(`  [!] Could not parse ${configPath} \u2014 skipping to avoid data loss. Remove ANTHROPIC_BASE_URL manually if needed.`);
@@ -1468,41 +1581,42 @@ function unconfigureClaudeCode(agent) {
       delete config.env;
     }
   }
-  fs11.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
   const backupPath = `${configPath}.skalpel-backup`;
-  if (fs11.existsSync(backupPath)) {
-    fs11.unlinkSync(backupPath);
+  if (fs9.existsSync(backupPath)) {
+    fs9.unlinkSync(backupPath);
   }
 }
 function unconfigureCodex(agent) {
-  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");
-  if (fs11.existsSync(configPath)) {
+  const configDir = process.platform === "win32" ? path10.join(os7.homedir(), "AppData", "Roaming", "codex") : path10.join(os7.homedir(), ".codex");
+  const configPath = agent.configPath ?? path10.join(configDir, "config.toml");
+  if (fs9.existsSync(configPath)) {
     let content = readTomlFile(configPath);
     content = removeTomlKey(content, "openai_base_url");
     content = removeTomlKey(content, "model_provider");
     content = removeCodexDirectProvider(content);
-    fs11.writeFileSync(configPath, content);
+    content = removeCodexProxyProvider(content);
+    fs9.writeFileSync(configPath, content);
   }
   const backupPath = `${configPath}.skalpel-backup`;
-  if (fs11.existsSync(backupPath)) {
-    fs11.unlinkSync(backupPath);
+  if (fs9.existsSync(backupPath)) {
+    fs9.unlinkSync(backupPath);
   }
 }
 function unconfigureCursor(agent) {
   const configDir = getCursorConfigDir();
-  const configPath = agent.configPath ?? path12.join(configDir, "settings.json");
-  if (!fs11.existsSync(configPath)) return;
+  const configPath = agent.configPath ?? path10.join(configDir, "settings.json");
+  if (!fs9.existsSync(configPath)) return;
   const config = readJsonFile(configPath);
   if (config === null) {
     console.warn(`  [!] Could not parse ${configPath} \u2014 skipping to avoid data loss. Remove ${CURSOR_API_BASE_URL_KEY} manually if needed.`);
     return;
   }
   delete config[CURSOR_API_BASE_URL_KEY];
-  fs11.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
   const backupPath = `${configPath}.skalpel-backup`;
-  if (fs11.existsSync(backupPath)) {
-    fs11.unlinkSync(backupPath);
+  if (fs9.existsSync(backupPath)) {
+    fs9.unlinkSync(backupPath);
   }
 }
 function unconfigureAgent(agent) {
@@ -1520,8 +1634,8 @@ function unconfigureAgent(agent) {
 }
 
 // src/cli/agents/shell.ts
-import fs12 from "fs";
-import path13 from "path";
+import fs10 from "fs";
+import path11 from "path";
 import os8 from "os";
 var BEGIN_MARKER = "# BEGIN SKALPEL PROXY - do not edit manually";
 var END_MARKER = "# END SKALPEL PROXY";
@@ -1530,21 +1644,21 @@ var PS_END_MARKER = "# END SKALPEL PROXY";
 function getUnixProfilePaths() {
   const home = os8.homedir();
   const candidates = [
-    path13.join(home, ".bashrc"),
-    path13.join(home, ".zshrc"),
-    path13.join(home, ".bash_profile"),
-    path13.join(home, ".profile")
+    path11.join(home, ".bashrc"),
+    path11.join(home, ".zshrc"),
+    path11.join(home, ".bash_profile"),
+    path11.join(home, ".profile")
   ];
-  return candidates.filter((p) => fs12.existsSync(p));
+  return candidates.filter((p) => fs10.existsSync(p));
 }
 function getPowerShellProfilePath() {
   if (process.platform !== "win32") return null;
   if (process.env.PROFILE) return process.env.PROFILE;
-  const docsDir = path13.join(os8.homedir(), "Documents");
-  const psProfile = path13.join(docsDir, "PowerShell", "Microsoft.PowerShell_profile.ps1");
-  const wpProfile = path13.join(docsDir, "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
-  if (fs12.existsSync(psProfile)) return psProfile;
-  if (fs12.existsSync(wpProfile)) return wpProfile;
+  const docsDir = path11.join(os8.homedir(), "Documents");
+  const psProfile = path11.join(docsDir, "PowerShell", "Microsoft.PowerShell_profile.ps1");
+  const wpProfile = path11.join(docsDir, "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+  if (fs10.existsSync(psProfile)) return psProfile;
+  if (fs10.existsSync(wpProfile)) return wpProfile;
   return psProfile;
 }
 function generateUnixBlock(proxyConfig) {
@@ -1565,13 +1679,13 @@ function generatePowerShellBlock(proxyConfig) {
 }
 function createBackup2(filePath) {
   const backupPath = `${filePath}.skalpel-backup`;
-  fs12.copyFileSync(filePath, backupPath);
+  fs10.copyFileSync(filePath, backupPath);
 }
 function updateProfileFile(filePath, block, beginMarker, endMarker) {
-  if (fs12.existsSync(filePath)) {
+  if (fs10.existsSync(filePath)) {
     createBackup2(filePath);
   }
-  let content = fs12.existsSync(filePath) ? fs12.readFileSync(filePath, "utf-8") : "";
+  let content = fs10.existsSync(filePath) ? fs10.readFileSync(filePath, "utf-8") : "";
   const beginIdx = content.indexOf(beginMarker);
   const endIdx = content.indexOf(endMarker);
   if (beginIdx !== -1 && endIdx !== -1) {
@@ -1584,15 +1698,15 @@ function updateProfileFile(filePath, block, beginMarker, endMarker) {
       content = block + "\n";
     }
   }
-  fs12.writeFileSync(filePath, content);
+  fs10.writeFileSync(filePath, content);
 }
 function configureShellEnvVars(_agents, proxyConfig) {
   const modified = [];
   if (process.platform === "win32") {
     const psProfile = getPowerShellProfilePath();
     if (psProfile) {
-      const dir = path13.dirname(psProfile);
-      fs12.mkdirSync(dir, { recursive: true });
+      const dir = path11.dirname(psProfile);
+      fs10.mkdirSync(dir, { recursive: true });
       const block = generatePowerShellBlock(proxyConfig);
       updateProfileFile(psProfile, block, PS_BEGIN_MARKER, PS_END_MARKER);
       modified.push(psProfile);
@@ -1611,28 +1725,28 @@ function removeShellEnvVars() {
   const restored = [];
   const home = os8.homedir();
   const allProfiles = [
-    path13.join(home, ".bashrc"),
-    path13.join(home, ".zshrc"),
-    path13.join(home, ".bash_profile"),
-    path13.join(home, ".profile")
+    path11.join(home, ".bashrc"),
+    path11.join(home, ".zshrc"),
+    path11.join(home, ".bash_profile"),
+    path11.join(home, ".profile")
   ];
   if (process.platform === "win32") {
     const psProfile = getPowerShellProfilePath();
     if (psProfile) allProfiles.push(psProfile);
   }
   for (const profilePath of allProfiles) {
-    if (!fs12.existsSync(profilePath)) continue;
-    const content = fs12.readFileSync(profilePath, "utf-8");
+    if (!fs10.existsSync(profilePath)) continue;
+    const content = fs10.readFileSync(profilePath, "utf-8");
     const beginIdx = content.indexOf(BEGIN_MARKER);
     const endIdx = content.indexOf(END_MARKER);
     if (beginIdx === -1 || endIdx === -1) continue;
     const before = content.slice(0, beginIdx);
     const after = content.slice(endIdx + END_MARKER.length);
     const cleaned = (before.replace(/\n+$/, "") + after.replace(/^\n+/, "\n")).trimEnd() + "\n";
-    fs12.writeFileSync(profilePath, cleaned);
+    fs10.writeFileSync(profilePath, cleaned);
     const backupPath = `${profilePath}.skalpel-backup`;
-    if (fs12.existsSync(backupPath)) {
-      fs12.unlinkSync(backupPath);
+    if (fs10.existsSync(backupPath)) {
+      fs10.unlinkSync(backupPath);
     }
     restored.push(profilePath);
   }
@@ -1645,6 +1759,226 @@ function removeShellBlock() {
   return removeShellEnvVars();
 }
 
+// src/cli/start.ts
+function print5(msg) {
+  console.log(msg);
+}
+function reconfigureAgents(config) {
+  const direct = config.mode === "direct";
+  const agents = detectAgents();
+  for (const agent of agents) {
+    if (agent.installed) {
+      try {
+        configureAgent(agent, config, direct);
+      } catch {
+      }
+    }
+  }
+  try {
+    configureShellEnvVars(agents.filter((a) => a.installed), config);
+  } catch {
+  }
+}
+async function runStart() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    print5('  Error: No API key configured. Run "skalpel init" or set SKALPEL_API_KEY.');
+    process.exit(1);
+  }
+  const existingPid = readPid(config.pidFile);
+  if (existingPid !== null) {
+    print5(`  Proxy is already running (pid=${existingPid}).`);
+    return;
+  }
+  const alive = await isProxyAlive(config.anthropicPort);
+  if (alive) {
+    print5("  Proxy is already running (detected via health check).");
+    return;
+  }
+  if (isServiceInstalled()) {
+    startService();
+    reconfigureAgents(config);
+    print5(`  Skalpel proxy started via system service on ports ${config.anthropicPort}, ${config.openaiPort}, and ${config.cursorPort}`);
+    return;
+  }
+  const dirname = path12.dirname(fileURLToPath2(import.meta.url));
+  const runnerScript = path12.resolve(dirname, "proxy-runner.js");
+  const child = spawn(process.execPath, [runnerScript], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  reconfigureAgents(config);
+  print5(`  Skalpel proxy started on ports ${config.anthropicPort}, ${config.openaiPort}, and ${config.cursorPort}`);
+}
+
+// src/cli/stop.ts
+import { execSync as execSync5 } from "child_process";
+
+// src/proxy/server.ts
+init_handler();
+import http from "http";
+
+// src/proxy/logger.ts
+import fs11 from "fs";
+import path13 from "path";
+var MAX_SIZE = 5 * 1024 * 1024;
+
+// src/proxy/ws-server.ts
+import { WebSocketServer } from "ws";
+var wss = new WebSocketServer({ noServer: true });
+
+// src/proxy/server.ts
+var proxyStartTime = 0;
+function stopProxy(config) {
+  const pid = readPid(config.pidFile);
+  if (pid === null) return false;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  removePid(config.pidFile);
+  return true;
+}
+async function getProxyStatus(config) {
+  const pid = readPid(config.pidFile);
+  if (pid !== null) {
+    return {
+      running: true,
+      pid,
+      uptime: proxyStartTime > 0 ? Date.now() - proxyStartTime : 0,
+      anthropicPort: config.anthropicPort,
+      openaiPort: config.openaiPort,
+      cursorPort: config.cursorPort
+    };
+  }
+  const alive = await isProxyAlive(config.anthropicPort);
+  return {
+    running: alive,
+    pid: null,
+    uptime: 0,
+    anthropicPort: config.anthropicPort,
+    openaiPort: config.openaiPort,
+    cursorPort: config.cursorPort
+  };
+}
+
+// src/cli/stop.ts
+function print6(msg) {
+  console.log(msg);
+}
+async function runStop() {
+  const config = loadConfig();
+  if (isServiceInstalled()) {
+    stopService();
+  }
+  const stopped = stopProxy(config);
+  if (stopped) {
+    print6("  Skalpel proxy stopped.");
+  } else {
+    const alive = await isProxyAlive(config.anthropicPort);
+    if (alive) {
+      let killedViaPort = false;
+      if (process.platform === "darwin" || process.platform === "linux") {
+        try {
+          const pids = execSync5(`lsof -ti :${config.anthropicPort}`, { timeout: 3e3 }).toString().trim().split("\n").filter(Boolean);
+          for (const p of pids) {
+            const pid = parseInt(p, 10);
+            if (Number.isInteger(pid) && pid > 0) {
+              try {
+                process.kill(pid, "SIGTERM");
+              } catch {
+              }
+            }
+          }
+          killedViaPort = true;
+        } catch {
+        }
+      }
+      if (killedViaPort) {
+        print6("  Skalpel proxy stopped (found via port detection).");
+      } else {
+        print6("  Proxy appears to be running but could not be stopped automatically.");
+        print6(`  Try: kill $(lsof -ti :${config.anthropicPort})`);
+      }
+    } else {
+      print6("  Proxy is not running.");
+    }
+  }
+  const agents = detectAgents();
+  for (const agent of agents) {
+    if (agent.installed) {
+      try {
+        unconfigureAgent(agent);
+      } catch {
+      }
+    }
+  }
+  try {
+    removeShellEnvVars();
+  } catch {
+  }
+}
+
+// src/cli/status.ts
+function print7(msg) {
+  console.log(msg);
+}
+async function runStatus() {
+  const config = loadConfig();
+  const status = await getProxyStatus(config);
+  print7("");
+  print7("  Skalpel Proxy Status");
+  print7("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  print7(`  Status:      ${status.running ? "running" : "stopped"}`);
+  if (status.pid !== null) {
+    print7(`  PID:         ${status.pid}`);
+  }
+  print7(`  Anthropic:   port ${status.anthropicPort}`);
+  print7(`  OpenAI:      port ${status.openaiPort}`);
+  print7(`  Cursor:      port ${status.cursorPort}`);
+  print7(`  Config:      ${config.configFile}`);
+  print7("");
+}
+
+// src/cli/logs.ts
+import fs12 from "fs";
+function print8(msg) {
+  console.log(msg);
+}
+async function runLogs(options) {
+  const config = loadConfig();
+  const logFile = config.logFile;
+  const lineCount = parseInt(options.lines ?? "50", 10);
+  if (!fs12.existsSync(logFile)) {
+    print8(`  No log file found at ${logFile}`);
+    return;
+  }
+  const content = fs12.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 = fs12.statSync(logFile).size;
+    fs12.watchFile(logFile, { interval: 500 }, () => {
+      try {
+        const stat = fs12.statSync(logFile);
+        if (stat.size > position) {
+          const fd = fs12.openSync(logFile, "r");
+          const buf = Buffer.alloc(stat.size - position);
+          fs12.readSync(fd, buf, 0, buf.length, position);
+          fs12.closeSync(fd);
+          process.stdout.write(buf.toString("utf-8"));
+          position = stat.size;
+        }
+      } catch {
+      }
+    });
+  }
+}
+
 // src/cli/config-cmd.ts
 function print9(msg) {
   console.log(msg);
@@ -1901,6 +2235,13 @@ async function runWizard(options) {
         print11(`  Configured ${agent.name}${agent.configPath ? ` (${agent.configPath})` : ""}`);
       }
       print11("");
+      const codexConfigured = agentsToConfigure.some((a) => a.name === "codex");
+      if (codexConfigured && !process.env.OPENAI_API_KEY) {
+        print11("  [!] Codex expects OPENAI_API_KEY to be set. The Skalpel proxy ignores the value,");
+        print11("      so any non-empty string works, e.g.:");
+        print11("        export OPENAI_API_KEY=sk-codex-placeholder-skalpel");
+        print11("");
+      }
     }
     print11("  Installing proxy as system service...");
     try {