skalpel 2.0.23 → 3.0.0

package/dist/cli/index.js

@@ -1,2899 +0,0 @@
-#!/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/codex-oauth.ts
-import { readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function authFilePath() {
-  return join(homedir(), ".codex", "auth.json");
-}
-function readCodexAuth() {
-  const path17 = authFilePath();
-  let raw;
-  try {
-    raw = readFileSync(path17, "utf-8");
-  } catch (err) {
-    const code = err?.code;
-    if (code !== "ENOENT") {
-      process.stderr.write(`skalpel: codex-oauth: cannot read auth file (${code ?? "unknown"})
-`);
-    }
-    return null;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    process.stderr.write("skalpel: codex-oauth: auth file is not valid JSON\n");
-    return null;
-  }
-  if (parsed === null || typeof parsed !== "object" || typeof parsed.access_token !== "string" || typeof parsed.refresh_token !== "string" || typeof parsed.expires_at !== "string") {
-    process.stderr.write("skalpel: codex-oauth: auth file missing required fields\n");
-    return null;
-  }
-  const obj = parsed;
-  const auth = {
-    access_token: obj.access_token,
-    refresh_token: obj.refresh_token,
-    expires_at: obj.expires_at
-  };
-  if (typeof obj.account_id === "string") {
-    auth.account_id = obj.account_id;
-  }
-  return auth;
-}
-var init_codex_oauth = __esm({
-  "src/proxy/codex-oauth.ts"() {
-    "use strict";
-  }
-});
-
-// 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,
-      allowH2: false
-      // Force HTTP/1.1 to prevent GCP LB WebSocket downgrade
-    });
-  }
-});
-
-// 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/trace-context.ts
-import { randomBytes } from "crypto";
-var init_trace_context = __esm({
-  "src/proxy/trace-context.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();
-    init_trace_context();
-    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 https from "https";
-import http from "http";
-import WebSocket2 from "ws";
-var H1_HTTPS_AGENT, H1_HTTP_AGENT;
-var init_ws_client = __esm({
-  "src/proxy/ws-client.ts"() {
-    "use strict";
-    init_codex_oauth();
-    init_trace_context();
-    H1_HTTPS_AGENT = new https.Agent({
-      ALPNProtocols: ["http/1.1"],
-      keepAlive: true
-    });
-    H1_HTTP_AGENT = new http.Agent({ keepAlive: true });
-  }
-});
-
-// src/proxy/handler.ts
-var init_handler = __esm({
-  "src/proxy/handler.ts"() {
-    "use strict";
-    init_streaming();
-    init_dispatcher();
-    init_envelope();
-    init_ws_client();
-    init_codex_oauth();
-    init_recovery();
-    init_fetch_error();
-    init_trace_context();
-  }
-});
-
-// src/cli/index.ts
-import { Command } from "commander";
-import { createRequire as createRequire2 } from "module";
-
-// src/cli/init.ts
-import * as readline from "readline";
-import * as fs2 from "fs";
-import * as path2 from "path";
-
-// src/cli/utils.ts
-init_codex_oauth();
-import * as fs from "fs";
-import * as path from "path";
-function detectProjectType() {
-  if (fs.existsSync(path.join(process.cwd(), "package.json"))) {
-    return "node";
-  }
-  if (fs.existsSync(path.join(process.cwd(), "requirements.txt")) || fs.existsSync(path.join(process.cwd(), "pyproject.toml"))) {
-    return "python";
-  }
-  return "other";
-}
-function detectAiSdks(projectType) {
-  const providers = [];
-  if (projectType === "node") {
-    try {
-      const pkgPath = path.join(process.cwd(), "package.json");
-      const pkg3 = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-      const allDeps = {
-        ...pkg3.dependencies,
-        ...pkg3.devDependencies
-      };
-      if (allDeps["openai"]) providers.push("openai");
-      if (allDeps["@anthropic-ai/sdk"]) providers.push("anthropic");
-    } catch {
-    }
-  }
-  if (projectType === "python") {
-    try {
-      const reqPath = path.join(process.cwd(), "requirements.txt");
-      if (fs.existsSync(reqPath)) {
-        const content = fs.readFileSync(reqPath, "utf-8");
-        if (/^openai/m.test(content)) providers.push("openai");
-        if (/^anthropic/m.test(content)) providers.push("anthropic");
-      }
-    } catch {
-    }
-  }
-  return providers;
-}
-function validateApiKey(key) {
-  return key.startsWith("sk-skalpel-") && key.length >= 20;
-}
-function validateCodexOAuth() {
-  try {
-    const auth = readCodexAuth();
-    if (auth !== null) {
-      return { present: true };
-    }
-  } catch (err) {
-    return { present: false, reason: `other: ${err.message}` };
-  }
-  const candidatePath = path.join(
-    process.env.HOME ?? process.env.USERPROFILE ?? "",
-    ".codex",
-    "auth.json"
-  );
-  if (!fs.existsSync(candidatePath)) {
-    return { present: false, reason: "file missing" };
-  }
-  return { present: false, reason: "malformed JSON" };
-}
-function generateCodeSample(config) {
-  if (config.integrationMethod === "wrapper") {
-    if (config.providers.includes("openai")) {
-      return `import OpenAI from 'openai';
-import { createSkalpelClient } from 'skalpel';
-
-const openai = createSkalpelClient(new OpenAI(), {
-  apiKey: process.env.SKALPEL_API_KEY!,${config.workspace ? `
-  workspace: '${config.workspace}',` : ""}
-});
-
-const response = await openai.chat.completions.create({
-  model: 'gpt-4o',
-  messages: [{ role: 'user', content: 'Hello' }],
-});`;
-    }
-    if (config.providers.includes("anthropic")) {
-      return `import Anthropic from '@anthropic-ai/sdk';
-import { createSkalpelClient } from 'skalpel';
-
-const anthropic = createSkalpelClient(new Anthropic(), {
-  apiKey: process.env.SKALPEL_API_KEY!,${config.workspace ? `
-  workspace: '${config.workspace}',` : ""}
-});
-
-const response = await anthropic.messages.create({
-  model: 'claude-sonnet-4-20250514',
-  max_tokens: 1024,
-  messages: [{ role: 'user', content: 'Hello' }],
-});`;
-    }
-  }
-  if (config.integrationMethod === "url_swap") {
-    if (config.providers.includes("openai")) {
-      return `import OpenAI from 'openai';
-
-const openai = new OpenAI({
-  baseURL: 'https://api.skalpel.ai/v1',
-  apiKey: process.env.SKALPEL_API_KEY,
-});
-
-const response = await openai.chat.completions.create({
-  model: 'gpt-4o',
-  messages: [{ role: 'user', content: 'Hello' }],
-});`;
-    }
-    if (config.providers.includes("anthropic")) {
-      return `import Anthropic from '@anthropic-ai/sdk';
-
-const anthropic = new Anthropic({
-  baseURL: 'https://api.skalpel.ai/v1',
-  apiKey: process.env.SKALPEL_API_KEY,
-});
-
-const response = await anthropic.messages.create({
-  model: 'claude-sonnet-4-20250514',
-  max_tokens: 1024,
-  messages: [{ role: 'user', content: 'Hello' }],
-});`;
-    }
-  }
-  return `// Configure your Skalpel API key
-// SKALPEL_API_KEY=${config.apiKey}
-// See https://docs.skalpel.ai for integration guides`;
-}
-
-// src/cli/init.ts
-function print(msg) {
-  console.log(msg);
-}
-async function runInit() {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  function ask(question) {
-    return new Promise((resolve2) => {
-      rl.question(question, (answer) => resolve2(answer.trim()));
-    });
-  }
-  try {
-    print("");
-    print("  Skalpel AI \u2014 SDK Setup");
-    print("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-    print("");
-    const projectType = detectProjectType();
-    print(`  Detected project type: ${projectType}`);
-    const sdks = detectAiSdks(projectType);
-    if (sdks.length > 0) {
-      print(`  Detected AI SDKs: ${sdks.join(", ")}`);
-    } else {
-      print("  No AI SDKs detected");
-    }
-    print("");
-    let apiKey = process.env.SKALPEL_API_KEY ?? "";
-    if (apiKey && validateApiKey(apiKey)) {
-      print(`  Using API key from SKALPEL_API_KEY env var: ${apiKey.slice(0, 14)}...`);
-    } else {
-      apiKey = await ask("  Enter your Skalpel API key (sk-skalpel-...): ");
-      if (!validateApiKey(apiKey)) {
-        print('  Error: Invalid API key. Must start with "sk-skalpel-" and be at least 20 characters.');
-        rl.close();
-        process.exit(1);
-      }
-      print(`  API key set: ${apiKey.slice(0, 14)}${"*".repeat(Math.max(0, apiKey.length - 14))}`);
-    }
-    print("");
-    print("  Choose integration method:");
-    print("    1) Wrapper pattern \u2014 Wraps your existing SDK client. Adds fallback and metadata.");
-    print("    2) URL swap \u2014 Changes the base URL. Simplest, one-line change.");
-    print("");
-    const methodChoice = await ask("  Enter choice (1 or 2): ");
-    const integrationMethod = methodChoice === "2" ? "url_swap" : "wrapper";
-    print("");
-    const envPath = path2.join(process.cwd(), ".env");
-    const envContent = `SKALPEL_API_KEY=${apiKey}
-SKALPEL_BASE_URL=https://api.skalpel.ai
-`;
-    if (fs2.existsSync(envPath)) {
-      fs2.appendFileSync(envPath, `
-${envContent}`);
-      print("  Appended Skalpel config to existing .env file");
-    } else {
-      fs2.writeFileSync(envPath, envContent);
-      print("  Created .env file with Skalpel config");
-    }
-    print("");
-    const providers = sdks.length > 0 ? sdks : ["openai"];
-    const config = {
-      projectType,
-      integrationMethod,
-      providers,
-      apiKey
-    };
-    const sample = generateCodeSample(config);
-    print("  Add this to your code:");
-    print("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-    for (const line of sample.split("\n")) {
-      print(`    ${line}`);
-    }
-    print("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-    print("");
-    print("  Setup complete! Your API calls will now be optimized by Skalpel.");
-    print("");
-    rl.close();
-  } catch (err) {
-    rl.close();
-    throw err;
-  }
-}
-
-// src/cli/doctor.ts
-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";
-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 detectCursor() {
-  const agent = {
-    name: "cursor",
-    installed: false,
-    version: null,
-    configPath: null
-  };
-  const binaryPath = tryExec(`${whichCommand()} cursor`);
-  const hasBinary = binaryPath !== null && binaryPath.length > 0;
-  let cursorConfigDir;
-  if (process.platform === "darwin") {
-    cursorConfigDir = path3.join(os.homedir(), "Library", "Application Support", "Cursor", "User");
-  } else if (process.platform === "win32") {
-    cursorConfigDir = path3.join(process.env.APPDATA ?? path3.join(os.homedir(), "AppData", "Roaming"), "Cursor", "User");
-  } else {
-    cursorConfigDir = path3.join(os.homedir(), ".config", "Cursor", "User");
-  }
-  const hasConfigDir = fs3.existsSync(cursorConfigDir);
-  agent.installed = hasBinary || hasConfigDir;
-  if (hasBinary) {
-    const versionOutput = tryExec("cursor --version");
-    if (versionOutput) {
-      const match = versionOutput.match(/(\d+\.\d+[\w.-]*)/);
-      agent.version = match ? match[1] : versionOutput;
-    }
-  }
-  const settingsPath = path3.join(cursorConfigDir, "settings.json");
-  if (fs3.existsSync(settingsPath)) {
-    agent.configPath = settingsPath;
-  } else if (hasConfigDir) {
-    agent.configPath = settingsPath;
-  }
-  return agent;
-}
-function detectAgents() {
-  return [detectClaudeCode(), detectCodex(), detectCursor()];
-}
-
-// src/cli/doctor.ts
-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");
-    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 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: "ok",
-      message: `Valid key from ${source}: ${apiKey.slice(0, 14)}${"*".repeat(Math.max(0, apiKey.length - 14))}`
-    });
-  } else if (apiKey) {
-    checks.push({
-      name: "API Key",
-      status: "fail",
-      message: `Invalid format \u2014 must start with "sk-skalpel-" and be >= 20 chars`
-    });
-  } else {
-    checks.push({
-      name: "API Key",
-      status: "fail",
-      message: 'No API key found. Run "npx skalpel" to set up.'
-    });
-  }
-  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: "Skalpel config", status: "warn", message: 'No ~/.skalpel/config.json \u2014 run "npx skalpel" to set up' });
-  }
-  let mode = "proxy";
-  try {
-    const raw = JSON.parse(fs4.readFileSync(skalpelConfigPath, "utf-8"));
-    if (raw.mode === "direct") mode = "direct";
-  } catch {
-  }
-  const modeMessage = mode === "direct" ? "direct (agents point at api.skalpel.ai)" : "proxy (local proxy on ports 18100/18101/18102)";
-  checks.push({ name: "mode", status: "ok", message: modeMessage });
-  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: "Skalpel backend", status: "ok", message: `${baseURL} reachable (HTTP ${response.status})` });
-    } else {
-      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: "Skalpel backend", status: "fail", message: `Cannot reach ${baseURL} \u2014 ${msg}` });
-  }
-  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.` });
-  }
-  let cursorPort = 18102;
-  try {
-    const raw = JSON.parse(fs4.readFileSync(skalpelConfigPath, "utf-8"));
-    cursorPort = raw.cursorPort ?? 18102;
-  } catch {
-  }
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 2e3);
-    const res = await fetch(`http://localhost:${cursorPort}/health`, { signal: controller.signal });
-    clearTimeout(timeout);
-    if (res.ok) {
-      checks.push({ name: "Cursor proxy", status: "ok", message: `Running on port ${cursorPort}` });
-    } else {
-      checks.push({ name: "Cursor proxy", status: "warn", message: `Port ${cursorPort} responded with HTTP ${res.status}` });
-    }
-  } catch {
-    checks.push({ name: "Cursor proxy", status: "warn", message: `Not running on port ${cursorPort}. 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" });
-    }
-  }
-  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" || c.status === "error");
-  const warnings = checks.filter((c) => c.status === "warn");
-  print2("");
-  if (failures.length > 0) {
-    print2(`  ${failures.length} issue(s) found. Fix the above errors to use Skalpel.`);
-  } else if (warnings.length > 0) {
-    print2(`  All critical checks passed. ${warnings.length} warning(s).`);
-  } else {
-    print2("  All checks passed. Skalpel is ready.");
-  }
-  print2("");
-}
-
-// src/cli/benchmark.ts
-function print3(msg) {
-  console.log(msg);
-}
-async function timedFetch(url, body, headers) {
-  const start = performance.now();
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...headers },
-    body: JSON.stringify(body)
-  });
-  const latencyMs = performance.now() - start;
-  let responseBody = null;
-  try {
-    responseBody = await response.json();
-  } catch {
-  }
-  return { latencyMs, status: response.status, headers: response.headers, body: responseBody };
-}
-async function runBenchmark() {
-  print3("");
-  print3("  Skalpel Benchmark");
-  print3("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  print3("");
-  const apiKey = process.env.SKALPEL_API_KEY ?? "";
-  if (!validateApiKey(apiKey)) {
-    print3('  Error: SKALPEL_API_KEY not set or invalid. Run "npx skalpel doctor" to diagnose.');
-    print3("");
-    process.exit(1);
-  }
-  const baseURL = process.env.SKALPEL_BASE_URL ?? "https://api.skalpel.ai";
-  const testPrompts = [
-    { model: "gpt-4o-mini", messages: [{ role: "user", content: "Say hello in one word." }] },
-    { model: "gpt-4o-mini", messages: [{ role: "user", content: "What is 2+2?" }] },
-    { model: "gpt-4o-mini", messages: [{ role: "user", content: "Say hello in one word." }] }
-  ];
-  print3(`  Proxy: ${baseURL}`);
-  print3(`  Running ${testPrompts.length} test requests...`);
-  print3("");
-  const results = [];
-  for (let i = 0; i < testPrompts.length; i++) {
-    const prompt = testPrompts[i];
-    print3(`  Request ${i + 1}/${testPrompts.length}: ${prompt.model} \u2014 "${prompt.messages[0].content}"`);
-    let proxyLatencyMs = -1;
-    let savingsUsd = null;
-    let cacheHit = false;
-    try {
-      const proxyResult = await timedFetch(
-        `${baseURL}/v1/chat/completions`,
-        prompt,
-        { Authorization: `Bearer ${apiKey}` }
-      );
-      proxyLatencyMs = Math.round(proxyResult.latencyMs);
-      const savingsHeader = proxyResult.headers.get("x-skalpel-savings-usd");
-      if (savingsHeader) savingsUsd = parseFloat(savingsHeader);
-      cacheHit = proxyResult.headers.get("x-skalpel-cache-hit") === "true";
-    } catch (err) {
-      print3(`    Proxy request failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    results.push({
-      requestIndex: i + 1,
-      model: prompt.model,
-      directLatencyMs: 0,
-      proxyLatencyMs,
-      overheadMs: 0,
-      savingsUsd,
-      cacheHit
-    });
-    const cacheStr = cacheHit ? " (cache hit)" : "";
-    const savingsStr = savingsUsd !== null ? ` | savings: $${savingsUsd.toFixed(4)}` : "";
-    print3(`    Proxy: ${proxyLatencyMs}ms${cacheStr}${savingsStr}`);
-  }
-  print3("");
-  print3("  Summary");
-  print3("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  const validResults = results.filter((r) => r.proxyLatencyMs >= 0);
-  if (validResults.length === 0) {
-    print3("  No successful requests. Check your API key and proxy endpoint.");
-  } else {
-    const avgProxy = Math.round(validResults.reduce((s, r) => s + r.proxyLatencyMs, 0) / validResults.length);
-    const cacheHits = validResults.filter((r) => r.cacheHit).length;
-    const totalSavings = validResults.reduce((s, r) => s + (r.savingsUsd ?? 0), 0);
-    print3(`  Requests:    ${validResults.length}`);
-    print3(`  Avg latency: ${avgProxy}ms (proxy)`);
-    print3(`  Cache hits:  ${cacheHits}/${validResults.length}`);
-    if (totalSavings > 0) {
-      print3(`  Savings:     $${totalSavings.toFixed(4)}`);
-    }
-  }
-  print3("");
-}
-
-// src/cli/replay.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-function print4(msg) {
-  console.log(msg);
-}
-async function runReplay(filePaths) {
-  print4("");
-  print4("  Skalpel Replay");
-  print4("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  print4("");
-  if (filePaths.length === 0) {
-    print4("  Usage: skalpel replay <request-file.json> [request-file2.json ...]");
-    print4("");
-    print4("  Replays saved request files through the Skalpel proxy.");
-    print4('  Each file should be a JSON object with "model" and "messages" fields.');
-    print4("");
-    process.exit(1);
-  }
-  const apiKey = process.env.SKALPEL_API_KEY ?? "";
-  if (!validateApiKey(apiKey)) {
-    print4('  Error: SKALPEL_API_KEY not set or invalid. Run "npx skalpel doctor" to diagnose.');
-    print4("");
-    process.exit(1);
-  }
-  const baseURL = process.env.SKALPEL_BASE_URL ?? "https://api.skalpel.ai";
-  print4(`  Proxy: ${baseURL}`);
-  print4(`  Replaying ${filePaths.length} request file(s)...`);
-  print4("");
-  let successCount = 0;
-  let failCount = 0;
-  for (const filePath of filePaths) {
-    const resolved = path5.resolve(filePath);
-    print4(`  File: ${resolved}`);
-    if (!fs5.existsSync(resolved)) {
-      print4(`    Error: file not found`);
-      failCount++;
-      continue;
-    }
-    let requestBody;
-    try {
-      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)}`);
-      failCount++;
-      continue;
-    }
-    if (!requestBody.model || !requestBody.messages) {
-      print4('    Error: request file must contain "model" and "messages" fields');
-      failCount++;
-      continue;
-    }
-    const model = requestBody.model;
-    const messageCount = Array.isArray(requestBody.messages) ? requestBody.messages.length : 0;
-    print4(`    Model: ${model} | Messages: ${messageCount}`);
-    try {
-      const start = performance.now();
-      const response = await fetch(`${baseURL}/v1/chat/completions`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify(requestBody)
-      });
-      const latencyMs = Math.round(performance.now() - start);
-      if (!response.ok) {
-        print4(`    Failed: HTTP ${response.status}`);
-        failCount++;
-        continue;
-      }
-      const body = await response.json();
-      const content = body?.choices?.[0]?.message?.content ?? body?.content?.[0]?.text ?? "(no content)";
-      const cacheHit = response.headers.get("x-skalpel-cache-hit") === "true";
-      const savings = response.headers.get("x-skalpel-savings-usd");
-      print4(`    Status: ${response.status} | Latency: ${latencyMs}ms${cacheHit ? " (cache hit)" : ""}`);
-      if (savings) print4(`    Savings: $${parseFloat(savings).toFixed(4)}`);
-      print4(`    Response: ${content.slice(0, 120)}${content.length > 120 ? "..." : ""}`);
-      successCount++;
-    } catch (err) {
-      print4(`    Error: ${err instanceof Error ? err.message : String(err)}`);
-      failCount++;
-    }
-    print4("");
-  }
-  print4("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  print4(`  Done: ${successCount} succeeded, ${failCount} failed`);
-  print4("");
-}
-
-// src/cli/start.ts
-import { spawn } from "child_process";
-import path12 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/proxy/config.ts
-import fs6 from "fs";
-import path6 from "path";
-import os3 from "os";
-function expandHome(filePath) {
-  if (filePath.startsWith("~")) {
-    return path6.join(os3.homedir(), filePath.slice(1));
-  }
-  return filePath;
-}
-var DEFAULTS = {
-  apiKey: "",
-  remoteBaseUrl: "https://api.skalpel.ai",
-  anthropicDirectUrl: "https://api.anthropic.com",
-  openaiDirectUrl: "https://api.openai.com",
-  anthropicPort: 18100,
-  openaiPort: 18101,
-  cursorPort: 18102,
-  cursorDirectUrl: "https://api.openai.com",
-  logLevel: "info",
-  logFile: "~/.skalpel/logs/proxy.log",
-  pidFile: "~/.skalpel/proxy.pid",
-  configFile: "~/.skalpel/config.json",
-  mode: "proxy"
-};
-function coerceMode(value) {
-  return value === "direct" ? "direct" : "proxy";
-}
-function loadConfig(configPath) {
-  const filePath = expandHome(configPath ?? DEFAULTS.configFile);
-  let fileConfig = {};
-  try {
-    const raw = fs6.readFileSync(filePath, "utf-8");
-    fileConfig = JSON.parse(raw);
-  } catch {
-  }
-  return {
-    apiKey: fileConfig.apiKey ?? DEFAULTS.apiKey,
-    remoteBaseUrl: fileConfig.remoteBaseUrl ?? DEFAULTS.remoteBaseUrl,
-    anthropicDirectUrl: fileConfig.anthropicDirectUrl ?? DEFAULTS.anthropicDirectUrl,
-    openaiDirectUrl: fileConfig.openaiDirectUrl ?? DEFAULTS.openaiDirectUrl,
-    anthropicPort: fileConfig.anthropicPort ?? DEFAULTS.anthropicPort,
-    openaiPort: fileConfig.openaiPort ?? DEFAULTS.openaiPort,
-    cursorPort: fileConfig.cursorPort ?? DEFAULTS.cursorPort,
-    cursorDirectUrl: fileConfig.cursorDirectUrl ?? DEFAULTS.cursorDirectUrl,
-    logLevel: fileConfig.logLevel ?? DEFAULTS.logLevel,
-    logFile: expandHome(fileConfig.logFile ?? DEFAULTS.logFile),
-    pidFile: expandHome(fileConfig.pidFile ?? DEFAULTS.pidFile),
-    configFile: filePath,
-    mode: coerceMode(fileConfig.mode)
-  };
-}
-function saveConfig(config) {
-  const dir = path6.dirname(config.configFile);
-  fs6.mkdirSync(dir, { recursive: true });
-  const { mode, ...rest } = config;
-  const serializable = { ...rest };
-  if (mode === "direct") {
-    serializable.mode = mode;
-  }
-  fs6.writeFileSync(config.configFile, JSON.stringify(serializable, null, 2) + "\n");
-}
-
-// src/proxy/pid.ts
-import fs7 from "fs";
-import path7 from "path";
-import { execSync as execSync2 } from "child_process";
-function readPid(pidFile) {
-  try {
-    const raw = fs7.readFileSync(pidFile, "utf-8").trim();
-    try {
-      const parsed = JSON.parse(raw);
-      if (parsed && typeof parsed === "object" && typeof parsed.pid === "number" && !isNaN(parsed.pid)) {
-        const record = parsed;
-        if (record.startTime == null) {
-          return isRunning(record.pid) ? record.pid : null;
-        }
-        return isRunningWithIdentity(record.pid, record.startTime) ? record.pid : null;
-      }
-    } catch {
-    }
-    const pid = parseInt(raw, 10);
-    if (isNaN(pid)) return null;
-    return isRunning(pid) ? pid : null;
-  } catch {
-    return null;
-  }
-}
-function isRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getStartTime(pid) {
-  try {
-    if (process.platform === "linux") {
-      const stat = fs7.readFileSync(`/proc/${pid}/stat`, "utf-8");
-      const rparen = stat.lastIndexOf(")");
-      if (rparen < 0) return null;
-      const fields = stat.slice(rparen + 2).split(" ");
-      return fields[19] ?? null;
-    }
-    if (process.platform === "darwin") {
-      const out = execSync2(`ps -p ${pid} -o lstart=`, { timeout: 2e3, stdio: ["ignore", "pipe", "ignore"] });
-      const text = out.toString().trim();
-      return text || null;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function isRunningWithIdentity(pid, expectedStartTime) {
-  try {
-    if (process.platform !== "linux" && process.platform !== "darwin") {
-      return isRunning(pid);
-    }
-    const current = getStartTime(pid);
-    if (current == null) return false;
-    return current === expectedStartTime;
-  } catch {
-    return false;
-  }
-}
-function removePid(pidFile) {
-  try {
-    fs7.unlinkSync(pidFile);
-  } catch {
-  }
-}
-
-// 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";
-import os6 from "os";
-import { execSync as execSync4 } from "child_process";
-import { fileURLToPath } from "url";
-
-// src/cli/service/detect-os.ts
-import os4 from "os";
-import { execSync as execSync3 } from "child_process";
-function detectShell() {
-  if (process.platform === "win32") {
-    if (process.env.PSModulePath || process.env.POWERSHELL_DISTRIBUTION_CHANNEL) {
-      return "powershell";
-    }
-    return "cmd";
-  }
-  const shellPath = process.env.SHELL ?? "";
-  if (shellPath.includes("zsh")) return "zsh";
-  if (shellPath.includes("fish")) return "fish";
-  if (shellPath.includes("bash")) return "bash";
-  try {
-    if (process.platform === "darwin") {
-      const result = execSync3(`dscl . -read /Users/${os4.userInfo().username} UserShell`, {
-        encoding: "utf-8",
-        timeout: 3e3
-      }).trim();
-      const shell = result.split(":").pop()?.trim() ?? "";
-      if (shell.includes("zsh")) return "zsh";
-      if (shell.includes("fish")) return "fish";
-      if (shell.includes("bash")) return "bash";
-    } else {
-      const result = execSync3(`getent passwd ${os4.userInfo().username}`, {
-        encoding: "utf-8",
-        timeout: 3e3
-      }).trim();
-      const shell = result.split(":").pop() ?? "";
-      if (shell.includes("zsh")) return "zsh";
-      if (shell.includes("fish")) return "fish";
-      if (shell.includes("bash")) return "bash";
-    }
-  } catch {
-  }
-  return "bash";
-}
-function detectOS() {
-  let platform;
-  switch (process.platform) {
-    case "darwin":
-      platform = "macos";
-      break;
-    case "win32":
-      platform = "windows";
-      break;
-    default:
-      platform = "linux";
-      break;
-  }
-  return {
-    platform,
-    shell: detectShell(),
-    homeDir: os4.homedir()
-  };
-}
-
-// src/cli/service/templates.ts
-import os5 from "os";
-import path8 from "path";
-function generateLaunchdPlist(config, proxyRunnerPath) {
-  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">
-<dict>
-  <key>Label</key>
-  <string>ai.skalpel.proxy</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>${process.execPath}</string>
-    <string>${proxyRunnerPath}</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${path8.join(logDir, "proxy-stdout.log")}</string>
-  <key>StandardErrorPath</key>
-  <string>${path8.join(logDir, "proxy-stderr.log")}</string>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>SKALPEL_ANTHROPIC_PORT</key>
-    <string>${config.anthropicPort}</string>
-    <key>SKALPEL_OPENAI_PORT</key>
-    <string>${config.openaiPort}</string>
-    <key>SKALPEL_CURSOR_PORT</key>
-    <string>${config.cursorPort}</string>
-  </dict>
-</dict>
-</plist>`;
-}
-function generateSystemdUnit(config, proxyRunnerPath) {
-  return `[Unit]
-Description=Skalpel Proxy
-After=network.target
-
-[Service]
-Type=simple
-ExecStart=${process.execPath} ${proxyRunnerPath}
-Restart=always
-RestartSec=5
-Environment=SKALPEL_ANTHROPIC_PORT=${config.anthropicPort}
-Environment=SKALPEL_OPENAI_PORT=${config.openaiPort}
-Environment=SKALPEL_CURSOR_PORT=${config.cursorPort}
-
-[Install]
-WantedBy=default.target`;
-}
-function generateWindowsTask(config, proxyRunnerPath) {
-  return [
-    "/create",
-    "/tn",
-    "SkalpelProxy",
-    "/tr",
-    `"${process.execPath}" "${proxyRunnerPath}"`,
-    "/sc",
-    "ONLOGON",
-    "/rl",
-    "LIMITED",
-    "/f"
-  ];
-}
-
-// src/cli/service/install.ts
-var __dirname = path9.dirname(fileURLToPath(import.meta.url));
-function resolveProxyRunnerPath() {
-  const candidates = [
-    path9.join(__dirname, "..", "proxy-runner.js"),
-    // dist/cli/proxy-runner.js relative to dist/cli/service/
-    path9.join(__dirname, "proxy-runner.js"),
-    // same dir
-    path9.join(__dirname, "..", "..", "cli", "proxy-runner.js")
-    // dist/cli/proxy-runner.js from deeper
-  ];
-  for (const candidate of candidates) {
-    if (fs8.existsSync(candidate)) {
-      return path9.resolve(candidate);
-    }
-  }
-  try {
-    const npmRoot = execSync4("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 = path9.resolve(process.cwd(), "dist", "cli", "proxy-runner.js");
-  return devPath;
-}
-function getMacOSPlistPath() {
-  return path9.join(os6.homedir(), "Library", "LaunchAgents", "ai.skalpel.proxy.plist");
-}
-function getLinuxUnitPath() {
-  return path9.join(os6.homedir(), ".config", "systemd", "user", "skalpel-proxy.service");
-}
-function installService(config) {
-  const osInfo = detectOS();
-  const proxyRunnerPath = resolveProxyRunnerPath();
-  const logDir = path9.join(os6.homedir(), ".skalpel", "logs");
-  fs8.mkdirSync(logDir, { recursive: true });
-  switch (osInfo.platform) {
-    case "macos": {
-      const plistPath = getMacOSPlistPath();
-      const plistDir = path9.dirname(plistPath);
-      fs8.mkdirSync(plistDir, { recursive: true });
-      const plist = generateLaunchdPlist(config, proxyRunnerPath);
-      fs8.writeFileSync(plistPath, plist);
-      try {
-        execSync4(`launchctl unload "${plistPath}" 2>/dev/null || true`, { stdio: "pipe" });
-        execSync4(`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}`);
-        console.warn(`  You can manually load it: launchctl load "${plistPath}"`);
-      }
-      break;
-    }
-    case "linux": {
-      const unitPath = getLinuxUnitPath();
-      const unitDir = path9.dirname(unitPath);
-      fs8.mkdirSync(unitDir, { recursive: true });
-      const unit = generateSystemdUnit(config, proxyRunnerPath);
-      fs8.writeFileSync(unitPath, unit);
-      try {
-        execSync4("systemctl --user daemon-reload", { stdio: "pipe" });
-        execSync4("systemctl --user enable skalpel-proxy", { stdio: "pipe" });
-        execSync4("systemctl --user start skalpel-proxy", { stdio: "pipe" });
-      } catch {
-        try {
-          const autostartDir = path9.join(os6.homedir(), ".config", "autostart");
-          fs8.mkdirSync(autostartDir, { recursive: true });
-          const desktopEntry = `[Desktop Entry]
-Type=Application
-Name=Skalpel Proxy
-Exec=${process.execPath} ${proxyRunnerPath}
-Hidden=false
-NoDisplay=true
-X-GNOME-Autostart-enabled=true
-`;
-          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);
-          console.warn(`  Warning: Could not register service: ${msg}`);
-          console.warn("  You can start the proxy manually: skalpel start");
-        }
-      }
-      break;
-    }
-    case "windows": {
-      const args = generateWindowsTask(config, proxyRunnerPath);
-      try {
-        execSync4(`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}`);
-        console.warn("  You can start the proxy manually: skalpel start");
-      }
-      break;
-    }
-  }
-}
-function isServiceInstalled() {
-  const osInfo = detectOS();
-  switch (osInfo.platform) {
-    case "macos": {
-      const plistPath = getMacOSPlistPath();
-      return fs8.existsSync(plistPath);
-    }
-    case "linux": {
-      const unitPath = getLinuxUnitPath();
-      return fs8.existsSync(unitPath);
-    }
-    case "windows": {
-      try {
-        execSync4("schtasks /query /tn SkalpelProxy", { stdio: "pipe" });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  }
-}
-function stopService() {
-  const osInfo = detectOS();
-  switch (osInfo.platform) {
-    case "macos": {
-      const plistPath = getMacOSPlistPath();
-      if (!fs8.existsSync(plistPath)) return;
-      try {
-        execSync4(`launchctl unload "${plistPath}"`, { stdio: "pipe" });
-      } catch {
-      }
-      break;
-    }
-    case "linux": {
-      try {
-        execSync4("systemctl --user stop skalpel-proxy", { stdio: "pipe" });
-      } catch {
-      }
-      break;
-    }
-    case "windows": {
-      try {
-        execSync4("schtasks /end /tn SkalpelProxy", { stdio: "pipe" });
-      } catch {
-      }
-      break;
-    }
-  }
-}
-function startService() {
-  const osInfo = detectOS();
-  switch (osInfo.platform) {
-    case "macos": {
-      const plistPath = getMacOSPlistPath();
-      if (!fs8.existsSync(plistPath)) return;
-      try {
-        execSync4(`launchctl load "${plistPath}"`, { stdio: "pipe" });
-      } catch {
-      }
-      break;
-    }
-    case "linux": {
-      try {
-        execSync4("systemctl --user start skalpel-proxy", { stdio: "pipe" });
-      } catch {
-      }
-      break;
-    }
-    case "windows": {
-      try {
-        execSync4("schtasks /run /tn SkalpelProxy", { stdio: "pipe" });
-      } catch {
-      }
-      break;
-    }
-  }
-}
-function uninstallService() {
-  const osInfo = detectOS();
-  switch (osInfo.platform) {
-    case "macos": {
-      const plistPath = getMacOSPlistPath();
-      try {
-        execSync4(`launchctl unload "${plistPath}" 2>/dev/null || true`, { stdio: "pipe" });
-      } catch {
-      }
-      if (fs8.existsSync(plistPath)) fs8.unlinkSync(plistPath);
-      break;
-    }
-    case "linux": {
-      try {
-        execSync4("systemctl --user stop skalpel-proxy 2>/dev/null || true", { stdio: "pipe" });
-        execSync4("systemctl --user disable skalpel-proxy 2>/dev/null || true", { stdio: "pipe" });
-      } catch {
-      }
-      const unitPath = getLinuxUnitPath();
-      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 {
-        execSync4("schtasks /delete /tn SkalpelProxy /f", { stdio: "pipe" });
-      } catch {
-      }
-      break;
-    }
-  }
-}
-
-// src/cli/agents/configure.ts
-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) {
-  fs9.mkdirSync(dir, { recursive: true });
-}
-function createBackup(filePath) {
-  if (fs9.existsSync(filePath)) {
-    fs9.copyFileSync(filePath, `${filePath}.skalpel-backup`);
-  }
-}
-function readJsonFile(filePath) {
-  try {
-    return JSON.parse(fs9.readFileSync(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function configureClaudeCode(agent, proxyConfig, direct = false) {
-  const configPath = agent.configPath ?? path10.join(os7.homedir(), ".claude", "settings.json");
-  const configDir = path10.dirname(configPath);
-  ensureDir(configDir);
-  createBackup(configPath);
-  const config = readJsonFile(configPath) ?? {};
-  if (!config.env || typeof config.env !== "object") {
-    config.env = {};
-  }
-  const env = config.env;
-  if (direct) {
-    env.ANTHROPIC_BASE_URL = DIRECT_MODE_BASE_URL;
-    env.ANTHROPIC_CUSTOM_HEADERS = `X-Skalpel-API-Key: ${proxyConfig.apiKey}`;
-  } else {
-    env.ANTHROPIC_BASE_URL = `http://localhost:${proxyConfig.anthropicPort}`;
-    delete env.ANTHROPIC_CUSTOM_HEADERS;
-  }
-  fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-}
-function readTomlFile(filePath) {
-  try {
-    return fs9.readFileSync(filePath, "utf-8");
-  } catch {
-    return "";
-  }
-}
-function setTomlKey(content, key, value) {
-  const pattern = new RegExp(`^${key.replace(".", "\\.")}\\s*=.*$`, "m");
-  const line = `${key} = "${value}"`;
-  if (pattern.test(content)) {
-    return content.replace(pattern, line);
-  }
-  const sectionMatch = content.match(/^\[/m);
-  if (sectionMatch && sectionMatch.index !== void 0) {
-    return content.slice(0, sectionMatch.index) + line + "\n" + content.slice(sectionMatch.index);
-  }
-  const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-  return content + separator + line + "\n";
-}
-function removeTomlKey(content, key) {
-  const pattern = new RegExp(`^${key.replace(".", "\\.")}\\s*=.*\\n?`, "gm");
-  return content.replace(pattern, "");
-}
-function buildCodexDirectProviderBlock(apiKey) {
-  return [
-    `[model_providers.${CODEX_DIRECT_PROVIDER_ID}]`,
-    `name = "Skalpel"`,
-    `base_url = "${DIRECT_MODE_BASE_URL}"`,
-    `wire_api = "responses"`,
-    `http_headers = { "X-Skalpel-API-Key" = "${apiKey}" }`
-  ].join("\n");
-}
-function upsertCodexDirectProvider(content, apiKey) {
-  const sectionHeader = `[model_providers.${CODEX_DIRECT_PROVIDER_ID}]`;
-  const block = buildCodexDirectProviderBlock(apiKey);
-  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 removeCodexDirectProvider(content) {
-  const sectionHeader = `[model_providers.${CODEX_DIRECT_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 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" ? 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) {
-    content = removeTomlKey(content, "openai_base_url");
-    content = setTomlKey(content, "model_provider", CODEX_DIRECT_PROVIDER_ID);
-    content = upsertCodexDirectProvider(content, proxyConfig.apiKey);
-  } else {
-    content = setTomlKey(content, "openai_base_url", `http://localhost:${proxyConfig.openaiPort}`);
-    content = setTomlKey(content, "model_provider", CODEX_PROXY_PROVIDER_ID);
-    content = upsertCodexProxyProvider(content, proxyConfig.openaiPort);
-    content = removeCodexDirectProvider(content);
-  }
-  fs9.writeFileSync(configPath, content);
-  const oauth = validateCodexOAuth();
-  if (!oauth.present) {
-    process.stderr.write("OAuth not configured. Run: codex login\n");
-    process.stderr.write("   Then re-run: npx skalpel\n");
-    process.stderr.write("   (Skalpel will fall back to OPENAI_API_KEY env var if OAuth missing.)\n");
-  }
-}
-function getCursorConfigDir() {
-  if (process.platform === "darwin") {
-    return path10.join(os7.homedir(), "Library", "Application Support", "Cursor", "User");
-  } else if (process.platform === "win32") {
-    return path10.join(process.env.APPDATA ?? path10.join(os7.homedir(), "AppData", "Roaming"), "Cursor", "User");
-  }
-  return path10.join(os7.homedir(), ".config", "Cursor", "User");
-}
-function configureCursor(agent, proxyConfig, direct = false) {
-  if (direct) {
-    console.warn(`  [!] cursor: direct mode not supported (no custom-header injection in Cursor settings). Cursor configuration left unchanged.`);
-    return;
-  }
-  const configDir = getCursorConfigDir();
-  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];
-  if (typeof existingUrl === "string" && existingUrl.length > 0) {
-    proxyConfig.cursorDirectUrl = existingUrl;
-    saveConfig(proxyConfig);
-  }
-  config[CURSOR_API_BASE_URL_KEY] = `http://localhost:${proxyConfig.cursorPort}`;
-  fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-}
-function configureAgent(agent, proxyConfig, direct = false) {
-  switch (agent.name) {
-    case "claude-code":
-      configureClaudeCode(agent, proxyConfig, direct);
-      break;
-    case "codex":
-      configureCodex(agent, proxyConfig, direct);
-      break;
-    case "cursor":
-      configureCursor(agent, proxyConfig, direct);
-      break;
-  }
-}
-function unconfigureClaudeCode(agent) {
-  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.`);
-    return;
-  }
-  if (config.env && typeof config.env === "object") {
-    const env = config.env;
-    delete env.ANTHROPIC_BASE_URL;
-    delete env.ANTHROPIC_CUSTOM_HEADERS;
-    if (Object.keys(env).length === 0) {
-      delete config.env;
-    }
-  }
-  fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-  const backupPath = `${configPath}.skalpel-backup`;
-  if (fs9.existsSync(backupPath)) {
-    fs9.unlinkSync(backupPath);
-  }
-}
-function unconfigureCodex(agent) {
-  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);
-    content = removeCodexProxyProvider(content);
-    fs9.writeFileSync(configPath, content);
-  }
-  const backupPath = `${configPath}.skalpel-backup`;
-  if (fs9.existsSync(backupPath)) {
-    fs9.unlinkSync(backupPath);
-  }
-}
-function unconfigureCursor(agent) {
-  const configDir = getCursorConfigDir();
-  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];
-  fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-  const backupPath = `${configPath}.skalpel-backup`;
-  if (fs9.existsSync(backupPath)) {
-    fs9.unlinkSync(backupPath);
-  }
-}
-function unconfigureAgent(agent) {
-  switch (agent.name) {
-    case "claude-code":
-      unconfigureClaudeCode(agent);
-      break;
-    case "codex":
-      unconfigureCodex(agent);
-      break;
-    case "cursor":
-      unconfigureCursor(agent);
-      break;
-  }
-}
-
-// src/cli/agents/shell.ts
-import fs10 from "fs";
-import path11 from "path";
-import os8 from "os";
-import crypto from "crypto";
-var BEGIN_MARKER = "# BEGIN SKALPEL PROXY - do not edit manually";
-var END_MARKER = "# END SKALPEL PROXY";
-var PS_BEGIN_MARKER = "# BEGIN SKALPEL PROXY - do not edit manually";
-var PS_END_MARKER = "# END SKALPEL PROXY";
-function getUnixProfilePaths() {
-  const home = os8.homedir();
-  const candidates = [
-    path11.join(home, ".bashrc"),
-    path11.join(home, ".zshrc"),
-    path11.join(home, ".bash_profile"),
-    path11.join(home, ".profile")
-  ];
-  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 = 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 randomPlaceholder() {
-  return `sk-codex-skalpel-${crypto.randomBytes(8).toString("hex")}`;
-}
-function generateUnixBlock(proxyConfig) {
-  return [
-    BEGIN_MARKER,
-    `export ANTHROPIC_BASE_URL="http://localhost:${proxyConfig.anthropicPort}"`,
-    `export OPENAI_BASE_URL="http://localhost:${proxyConfig.openaiPort}"`,
-    // `:-` only evaluates the default when OPENAI_API_KEY is unset or empty,
-    // so a user-provided key always wins. Bash, zsh, and POSIX sh all
-    // support this syntax.
-    `export OPENAI_API_KEY="\${OPENAI_API_KEY:-${randomPlaceholder()}}"`,
-    END_MARKER
-  ].join("\n");
-}
-function generatePowerShellBlock(proxyConfig) {
-  return [
-    PS_BEGIN_MARKER,
-    `$env:ANTHROPIC_BASE_URL = "http://localhost:${proxyConfig.anthropicPort}"`,
-    `$env:OPENAI_BASE_URL = "http://localhost:${proxyConfig.openaiPort}"`,
-    // Conditional assignment — only set when the user hasn't already
-    // exported OPENAI_API_KEY in their session or parent profile.
-    `if (-not $env:OPENAI_API_KEY) { $env:OPENAI_API_KEY = "${randomPlaceholder()}" }`,
-    PS_END_MARKER
-  ].join("\n");
-}
-function createBackup2(filePath) {
-  const backupPath = `${filePath}.skalpel-backup`;
-  fs10.copyFileSync(filePath, backupPath);
-}
-function updateProfileFile(filePath, block, beginMarker, endMarker) {
-  if (fs10.existsSync(filePath)) {
-    createBackup2(filePath);
-  }
-  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) {
-    content = content.slice(0, beginIdx) + block + content.slice(endIdx + endMarker.length);
-  } else {
-    if (content.length > 0) {
-      const trimmed = content.replace(/\n+$/, "");
-      content = trimmed + "\n\n" + block + "\n";
-    } else {
-      content = block + "\n";
-    }
-  }
-  fs10.writeFileSync(filePath, content);
-}
-function configureShellEnvVars(_agents, proxyConfig) {
-  const modified = [];
-  if (process.platform === "win32") {
-    const psProfile = getPowerShellProfilePath();
-    if (psProfile) {
-      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);
-    }
-  } else {
-    const profiles = getUnixProfilePaths();
-    const block = generateUnixBlock(proxyConfig);
-    for (const profilePath of profiles) {
-      updateProfileFile(profilePath, block, BEGIN_MARKER, END_MARKER);
-      modified.push(profilePath);
-    }
-  }
-  return modified;
-}
-function removeShellEnvVars() {
-  const restored = [];
-  const home = os8.homedir();
-  const allProfiles = [
-    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 (!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";
-    fs10.writeFileSync(profilePath, cleaned);
-    const backupPath = `${profilePath}.skalpel-backup`;
-    if (fs10.existsSync(backupPath)) {
-      fs10.unlinkSync(backupPath);
-    }
-    restored.push(profilePath);
-  }
-  return restored;
-}
-function writeShellBlock(proxyConfig) {
-  return configureShellEnvVars([], proxyConfig);
-}
-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 http2 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 WS_SUBPROTOCOL = "skalpel-codex-v1";
-var wss = new WebSocketServer({
-  noServer: true,
-  handleProtocols: (protocols) => protocols.has(WS_SUBPROTOCOL) ? WS_SUBPROTOCOL : false
-});
-
-// src/proxy/server.ts
-init_codex_oauth();
-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);
-}
-async function runSetMode(mode, config) {
-  if (mode !== "direct" && mode !== "proxy") {
-    print9(`  Invalid mode: ${mode}. Must be 'direct' or 'proxy'.`);
-    process.exit(1);
-  }
-  if (config.mode === mode) {
-    print9(`  Already in ${mode} mode. Nothing to do.`);
-    return;
-  }
-  config.mode = mode;
-  saveConfig(config);
-  await applyModeSwitch(mode, config);
-  print9(`  Switched to ${mode} mode.`);
-}
-async function applyModeSwitch(mode, config) {
-  const direct = mode === "direct";
-  const agents = detectAgents();
-  for (const agent of agents) {
-    if (!agent.installed) continue;
-    configureAgent(agent, config, direct);
-  }
-  if (direct) {
-    uninstallService();
-    removeShellBlock();
-  } else {
-    installService(config);
-    writeShellBlock(config);
-  }
-}
-async function runConfig(subcommand, args) {
-  const config = loadConfig();
-  if (subcommand === "path") {
-    print9(config.configFile);
-    return;
-  }
-  if (subcommand === "set") {
-    if (!args || args.length < 2) {
-      print9("  Usage: skalpel config set <key> <value>");
-      process.exit(1);
-    }
-    const key = args[0];
-    const value = args[1];
-    if (key === "mode") {
-      if (value !== "direct" && value !== "proxy") {
-        print9(`  Invalid mode: ${value}. Must be 'direct' or 'proxy'.`);
-        process.exit(1);
-      }
-      await runSetMode(value, config);
-      return;
-    }
-    const validKeys = [
-      "apiKey",
-      "remoteBaseUrl",
-      "anthropicPort",
-      "openaiPort",
-      "cursorPort",
-      "cursorDirectUrl",
-      "logLevel",
-      "logFile",
-      "pidFile"
-    ];
-    if (!validKeys.includes(key)) {
-      print9(`  Unknown config key: ${key}`);
-      print9(`  Valid keys: ${validKeys.join(", ")}`);
-      process.exit(1);
-    }
-    const updated = { ...config };
-    if (key === "anthropicPort" || key === "openaiPort" || key === "cursorPort") {
-      const parsed = parseInt(value, 10);
-      if (isNaN(parsed) || parsed < 1 || parsed > 65535) {
-        print9(`  Invalid port number: ${value}`);
-        process.exit(1);
-      }
-      updated[key] = parsed;
-    } else if (key === "logLevel") {
-      const validLevels = ["debug", "info", "warn", "error"];
-      if (!validLevels.includes(value)) {
-        print9(`  Invalid log level: ${value}`);
-        print9(`  Valid levels: ${validLevels.join(", ")}`);
-        process.exit(1);
-      }
-      updated[key] = value;
-    } else {
-      updated[key] = value;
-    }
-    saveConfig(updated);
-    print9(`  Set ${key} = ${value}`);
-    return;
-  }
-  print9(JSON.stringify(config, null, 2));
-}
-
-// src/cli/update.ts
-import { exec } from "child_process";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../../package.json");
-function print10(msg) {
-  console.log(msg);
-}
-async function runUpdate() {
-  print10(`  Current version: ${pkg.version}`);
-  print10("  Checking for updates...");
-  try {
-    const latest = await new Promise((resolve2, reject) => {
-      exec("npm view skalpel version", (err, stdout) => {
-        if (err) reject(err);
-        else resolve2(stdout.trim());
-      });
-    });
-    if (latest === pkg.version) {
-      print10(`  Already on the latest version (${pkg.version}).`);
-      return;
-    }
-    print10(`  Updating to ${latest}...`);
-    await new Promise((resolve2, reject) => {
-      exec("npm install -g skalpel@latest", (err) => {
-        if (err) reject(err);
-        else resolve2();
-      });
-    });
-    print10(`  Updated to ${latest}.`);
-  } catch (err) {
-    print10(`  Update failed: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-  }
-}
-
-// src/cli/wizard.ts
-import * as readline2 from "readline";
-import * as fs13 from "fs";
-import * as path14 from "path";
-import * as os9 from "os";
-function print11(msg) {
-  console.log(msg);
-}
-async function runWizard(options) {
-  const isAuto = options?.auto === true;
-  let rl;
-  let ask;
-  if (!isAuto) {
-    rl = readline2.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    ask = (question) => {
-      return new Promise((resolve2) => {
-        rl.question(question, (answer) => resolve2(answer.trim()));
-      });
-    };
-  } else {
-    ask = () => Promise.resolve("");
-  }
-  try {
-    print11("");
-    print11("   _____ _         _            _ ");
-    print11("  / ____| |       | |          | |");
-    print11(" | (___ | | ____ _| |_ __   ___| |");
-    print11("  \\___ \\| |/ / _` | | '_ \\ / _ \\ |");
-    print11("  ____) |   < (_| | | |_) |  __/ |");
-    print11(" |_____/|_|\\_\\__,_|_| .__/ \\___|_|");
-    print11("                    | |            ");
-    print11("                    |_|            ");
-    print11("");
-    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 skalpelDir2 = path14.join(os9.homedir(), ".skalpel");
-    const configPath = path14.join(skalpelDir2, "config.json");
-    let apiKey = "";
-    if (isAuto && options?.apiKey) {
-      apiKey = options.apiKey;
-      if (!validateApiKey(apiKey)) {
-        print11('  Error: Invalid API key. Must start with "sk-skalpel-" and be at least 20 characters.');
-        process.exit(1);
-      }
-      print11(`  API key set: ${apiKey.slice(0, 14)}${"*".repeat(Math.max(0, apiKey.length - 14))}`);
-    } else if (isAuto && !options?.apiKey) {
-      print11("  Error: --api-key is required when using --auto mode.");
-      process.exit(1);
-    } else {
-      if (fs13.existsSync(configPath)) {
-        try {
-          const existing = JSON.parse(fs13.readFileSync(configPath, "utf-8"));
-          if (existing.apiKey && validateApiKey(existing.apiKey)) {
-            const masked = existing.apiKey.slice(0, 14) + "*".repeat(Math.max(0, existing.apiKey.length - 14));
-            const useExisting = await ask(`  Found existing API key: ${masked}
-  Use this key? (Y/n): `);
-            if (useExisting.toLowerCase() !== "n") {
-              apiKey = existing.apiKey;
-              print11(`  Using existing API key.`);
-            }
-          }
-        } catch {
-        }
-      }
-      if (!apiKey) {
-        apiKey = await ask("  Paste your Skalpel API key (sk-skalpel-...): ");
-        if (!validateApiKey(apiKey)) {
-          print11('  Error: Invalid API key. Must start with "sk-skalpel-" and be at least 20 characters.');
-          rl.close();
-          process.exit(1);
-        }
-        print11(`  API key set: ${apiKey.slice(0, 14)}${"*".repeat(Math.max(0, apiKey.length - 14))}`);
-      }
-    }
-    print11("");
-    fs13.mkdirSync(skalpelDir2, { recursive: true });
-    const proxyConfig = loadConfig(configPath);
-    proxyConfig.apiKey = apiKey;
-    saveConfig(proxyConfig);
-    print11("  Detecting coding agents...");
-    const agents = detectAgents();
-    const installedAgents = agents.filter((a) => a.installed);
-    const notInstalled = agents.filter((a) => !a.installed);
-    if (installedAgents.length > 0) {
-      for (const agent of installedAgents) {
-        const ver = agent.version ? ` v${agent.version}` : "";
-        print11(`  [+] Found: ${agent.name}${ver}`);
-      }
-    }
-    if (notInstalled.length > 0) {
-      for (const agent of notInstalled) {
-        print11(`  [ ] Not found: ${agent.name}`);
-      }
-    }
-    if (installedAgents.length === 0) {
-      print11("  Warning: No coding agents detected. You can install them later.");
-      print11("  The proxy will be configured and ready when agents are installed.");
-    }
-    print11("");
-    let agentsToConfigure = installedAgents.filter((a) => {
-      if (options?.skipClaude && a.name === "claude-code") return false;
-      if (options?.skipCodex && a.name === "codex") return false;
-      if (options?.skipCursor && a.name === "cursor") return false;
-      return true;
-    });
-    if (agentsToConfigure.length > 0 && !isAuto) {
-      const agentNames = installedAgents.map((a) => a.name).join(", ");
-      const confirm = await ask(`  Configure ${agentNames}? (Y/n): `);
-      if (confirm.toLowerCase() === "n") {
-        agentsToConfigure = [];
-      }
-    }
-    print11("");
-    if (agentsToConfigure.length > 0) {
-      print11("  Configuring agents...");
-      for (const agent of agentsToConfigure) {
-        configureAgent(agent, proxyConfig);
-        print11(`  Configured ${agent.name}${agent.configPath ? ` (${agent.configPath})` : ""}`);
-      }
-      print11("");
-      const codexConfigured = agentsToConfigure.some((a) => a.name === "codex");
-      if (codexConfigured) {
-        print11("  [!] Codex auth: recommended -> run 'codex login' to enable ChatGPT plan billing.");
-        print11("         Without OAuth, Skalpel uses the OPENAI_API_KEY env var; if not already set,");
-        print11("         Skalpel exports a placeholder so Codex starts. A real sk-... key is only");
-        print11("         needed if you have no ChatGPT plan and want pay-as-you-go API billing.");
-        print11("");
-      }
-    }
-    print11("  Installing proxy as system service...");
-    try {
-      installService(proxyConfig);
-      print11("  Service installed successfully.");
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      print11(`  Warning: Could not install service: ${msg}`);
-      print11("  You can start the proxy manually with: skalpel start");
-    }
-    print11("");
-    print11("  Verifying proxy...");
-    let proxyOk = false;
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 3e3);
-      const healthUrl = `http://localhost:${proxyConfig.anthropicPort}/health`;
-      const res = await fetch(healthUrl, { signal: controller.signal });
-      clearTimeout(timeout);
-      if (res.ok) {
-        print11(`  [+] Anthropic proxy (port ${proxyConfig.anthropicPort}): healthy`);
-        proxyOk = true;
-      } else {
-        print11(`  [!] Anthropic proxy (port ${proxyConfig.anthropicPort}): HTTP ${res.status}`);
-      }
-    } catch {
-      print11(`  [!] Proxy not responding yet. It may take a moment to start.`);
-      print11('      Run "npx skalpel status" to check later, or "npx skalpel start" to start manually.');
-    }
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 3e3);
-      const healthUrl = `http://localhost:${proxyConfig.openaiPort}/health`;
-      const res = await fetch(healthUrl, { signal: controller.signal });
-      clearTimeout(timeout);
-      if (res.ok) {
-        print11(`  [+] OpenAI proxy (port ${proxyConfig.openaiPort}): healthy`);
-      } else {
-        print11(`  [!] OpenAI proxy (port ${proxyConfig.openaiPort}): HTTP ${res.status}`);
-      }
-    } catch {
-    }
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 3e3);
-      const healthUrl = `http://localhost:${proxyConfig.cursorPort}/health`;
-      const res = await fetch(healthUrl, { signal: controller.signal });
-      clearTimeout(timeout);
-      if (res.ok) {
-        print11(`  [+] Cursor proxy (port ${proxyConfig.cursorPort}): healthy`);
-      } else {
-        print11(`  [!] Cursor proxy (port ${proxyConfig.cursorPort}): HTTP ${res.status}`);
-      }
-    } catch {
-    }
-    print11("");
-    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("");
-    print11("  You're all set! Your coding agents now route through Skalpel.");
-    print11("");
-    if (agentsToConfigure.length > 0) {
-      print11("  Configured agents: " + agentsToConfigure.map((a) => a.name).join(", "));
-    }
-    print11("  Proxy ports: Anthropic=" + proxyConfig.anthropicPort + ", OpenAI=" + proxyConfig.openaiPort + ", Cursor=" + proxyConfig.cursorPort);
-    print11("");
-    print11('  Run "npx skalpel status" to check proxy status');
-    print11('  Run "npx skalpel doctor" for a full health check');
-    print11('  Run "npx skalpel uninstall" to remove everything');
-    print11("");
-    if (rl) rl.close();
-  } catch (err) {
-    if (rl) rl.close();
-    throw err;
-  }
-}
-
-// src/cli/uninstall.ts
-import * as readline3 from "readline";
-import * as fs14 from "fs";
-import * as path15 from "path";
-import * as os10 from "os";
-function print12(msg) {
-  console.log(msg);
-}
-async function runUninstall(options) {
-  const force = options?.force ?? false;
-  const rl = readline3.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  function ask(question) {
-    return new Promise((resolve2) => {
-      rl.question(question, (answer) => resolve2(answer.trim()));
-    });
-  }
-  try {
-    print12("");
-    print12("  Skalpel Uninstall");
-    print12("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-    print12("");
-    if (!force) {
-      const confirm = await ask("  This will remove Skalpel proxy, service, and agent configurations. Continue? (y/N): ");
-      if (confirm.toLowerCase() !== "y") {
-        print12("  Aborted.");
-        rl.close();
-        return;
-      }
-      print12("");
-    }
-    const config = loadConfig();
-    const removed = [];
-    print12("  Removing system service...");
-    try {
-      uninstallService();
-      print12("  [+] Service removed");
-      removed.push("system service");
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      print12(`  [!] Could not remove service: ${msg}`);
-    }
-    print12("  Stopping proxy...");
-    const stopped = stopProxy(config);
-    if (stopped) {
-      print12("  [+] Proxy stopped");
-      removed.push("proxy process");
-    } else {
-      print12("  [ ] Proxy was not running");
-    }
-    print12("  Removing shell environment variables...");
-    const restoredProfiles = removeShellEnvVars();
-    if (restoredProfiles.length > 0) {
-      for (const p of restoredProfiles) {
-        print12(`  [+] Restored: ${p}`);
-      }
-      removed.push("shell env vars");
-    } else {
-      print12("  [ ] No shell profiles had Skalpel config");
-    }
-    print12("  Restoring agent configurations...");
-    const agents = detectAgents();
-    for (const agent of agents) {
-      if (agent.installed) {
-        try {
-          unconfigureAgent(agent);
-          print12(`  [+] Restored ${agent.name} config`);
-          removed.push(`${agent.name} config`);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          print12(`  [!] Could not restore ${agent.name}: ${msg}`);
-        }
-      }
-    }
-    print12("");
-    const skalpelDir2 = path15.join(os10.homedir(), ".skalpel");
-    if (fs14.existsSync(skalpelDir2)) {
-      let shouldRemove = force;
-      if (!force) {
-        const removeDir = await ask("  Remove ~/.skalpel/ directory (contains config and logs)? (y/N): ");
-        shouldRemove = removeDir.toLowerCase() === "y";
-      }
-      if (shouldRemove) {
-        fs14.rmSync(skalpelDir2, { recursive: true, force: true });
-        print12("  [+] Removed ~/.skalpel/");
-        removed.push("~/.skalpel/ directory");
-      }
-    }
-    print12("  Clearing npx cache...");
-    try {
-      clearNpxCache();
-      print12("  [+] npx cache cleared");
-      removed.push("npx cache");
-    } catch {
-      print12("  [ ] Could not clear npx cache (not critical)");
-    }
-    print12("");
-    print12("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-    if (removed.length > 0) {
-      print12("  Removed: " + removed.join(", "));
-    } else {
-      print12("  Nothing to remove.");
-    }
-    print12("  Skalpel has been uninstalled.");
-    if (restoredProfiles.length > 0) {
-      print12("  Restart your shell to apply env var changes.");
-    }
-    print12("");
-    rl.close();
-  } catch (err) {
-    rl.close();
-    throw err;
-  }
-}
-function clearNpxCache() {
-  const npxCacheDir = path15.join(os10.homedir(), ".npm", "_npx");
-  if (!fs14.existsSync(npxCacheDir)) return;
-  const entries = fs14.readdirSync(npxCacheDir);
-  for (const entry of entries) {
-    const pkgJsonPath = path15.join(npxCacheDir, entry, "node_modules", "skalpel", "package.json");
-    const pkgJsonAlt = path15.join(npxCacheDir, entry, "node_modules", ".package-lock.json");
-    if (fs14.existsSync(pkgJsonPath)) {
-      fs14.rmSync(path15.join(npxCacheDir, entry), { recursive: true, force: true });
-      continue;
-    }
-    if (fs14.existsSync(pkgJsonAlt)) {
-      try {
-        const content = fs14.readFileSync(pkgJsonAlt, "utf-8");
-        if (content.includes('"skalpel"')) {
-          fs14.rmSync(path15.join(npxCacheDir, entry), { recursive: true, force: true });
-        }
-      } catch {
-      }
-    }
-  }
-}
-
-// src/cli/auth/callback-server.ts
-import * as http3 from "http";
-import * as net2 from "net";
-
-// src/cli/auth/session-storage.ts
-import * as fs15 from "fs";
-import * as os11 from "os";
-import * as path16 from "path";
-function sessionFilePath() {
-  return path16.join(os11.homedir(), ".skalpel", "session.json");
-}
-function skalpelDir() {
-  return path16.join(os11.homedir(), ".skalpel");
-}
-function isValidSession(value) {
-  if (!value || typeof value !== "object") return false;
-  const v = value;
-  if (typeof v.accessToken !== "string" || v.accessToken.length === 0) return false;
-  if (typeof v.refreshToken !== "string" || v.refreshToken.length === 0) return false;
-  if (typeof v.expiresAt !== "number" || !Number.isFinite(v.expiresAt)) return false;
-  if (!v.user || typeof v.user !== "object") return false;
-  const user = v.user;
-  if (typeof user.id !== "string" || user.id.length === 0) return false;
-  if (typeof user.email !== "string" || user.email.length === 0) return false;
-  return true;
-}
-async function readSession() {
-  const file = sessionFilePath();
-  try {
-    const raw = await fs15.promises.readFile(file, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!isValidSession(parsed)) return null;
-    return parsed;
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    return null;
-  }
-}
-async function writeSession(session) {
-  if (!isValidSession(session)) {
-    throw new Error("writeSession: invalid session shape");
-  }
-  const dir = skalpelDir();
-  await fs15.promises.mkdir(dir, { recursive: true, mode: 448 });
-  const file = sessionFilePath();
-  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const json = JSON.stringify(session, null, 2);
-  await fs15.promises.writeFile(tmp, json, { mode: 384 });
-  try {
-    await fs15.promises.chmod(tmp, 384);
-  } catch {
-  }
-  await fs15.promises.rename(tmp, file);
-  try {
-    await fs15.promises.chmod(file, 384);
-  } catch {
-  }
-}
-async function deleteSession() {
-  const file = sessionFilePath();
-  try {
-    await fs15.promises.unlink(file);
-  } catch (err) {
-    if (err.code === "ENOENT") return;
-    throw err;
-  }
-}
-
-// src/cli/auth/callback-server.ts
-var MAX_BODY_BYTES = 16 * 1024;
-var DEFAULT_TIMEOUT_MS = 18e4;
-var DEFAULT_ALLOWED_ORIGINS = [
-  "https://app.skalpel.ai",
-  "https://skalpel.ai"
-];
-function allowedOrigins() {
-  const extras = [];
-  const webappUrl = process.env.SKALPEL_WEBAPP_URL;
-  if (webappUrl) {
-    try {
-      const u = new URL(webappUrl);
-      extras.push(`${u.protocol}//${u.host}`);
-    } catch {
-    }
-  }
-  return [...DEFAULT_ALLOWED_ORIGINS, ...extras];
-}
-function validatePort(port) {
-  if (!Number.isInteger(port) || port < 1024 || port > 65535) {
-    throw new Error(`Invalid port: ${port} (must be an integer in 1024-65535)`);
-  }
-}
-async function findOpenPort(preferred = 51732) {
-  if (preferred !== 0) validatePort(preferred);
-  const tryBind = (port) => new Promise((resolve2) => {
-    const server = net2.createServer();
-    server.once("error", () => {
-      server.close(() => resolve2(null));
-    });
-    server.listen(port, "127.0.0.1", () => {
-      const address = server.address();
-      const boundPort = address && typeof address === "object" ? address.port : null;
-      server.close(() => resolve2(boundPort));
-    });
-  });
-  const preferredResult = await tryBind(preferred);
-  if (preferredResult !== null) return preferredResult;
-  const fallback = await tryBind(0);
-  if (fallback !== null) return fallback;
-  throw new Error("findOpenPort: no open port available");
-}
-function buildCorsHeaders(origin) {
-  const allowed = allowedOrigins();
-  const selected = origin && allowed.includes(origin) ? origin : allowed[0];
-  return {
-    "Access-Control-Allow-Origin": selected,
-    "Access-Control-Allow-Methods": "POST, OPTIONS",
-    "Access-Control-Allow-Headers": "content-type",
-    "Access-Control-Max-Age": "600",
-    Vary: "Origin"
-  };
-}
-async function startCallbackServer(port, timeoutMsOrOptions = DEFAULT_TIMEOUT_MS, maxBodyBytesArg) {
-  validatePort(port);
-  const opts = typeof timeoutMsOrOptions === "number" ? { timeoutMs: timeoutMsOrOptions, maxBodyBytes: maxBodyBytesArg } : timeoutMsOrOptions ?? {};
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const maxBytes = opts.maxBodyBytes ?? MAX_BODY_BYTES;
-  return new Promise((resolve2, reject) => {
-    let settled = false;
-    let timer;
-    const server = http3.createServer((req, res) => {
-      const origin = req.headers.origin;
-      const corsHeaders = buildCorsHeaders(origin);
-      if (req.method === "OPTIONS") {
-        res.writeHead(204, corsHeaders);
-        res.end();
-        return;
-      }
-      if (req.method === "GET" && (req.url === "/callback" || req.url === "/")) {
-        res.writeHead(200, {
-          ...corsHeaders,
-          "Content-Type": "text/html; charset=utf-8"
-        });
-        res.end(
-          '<!doctype html><meta charset="utf-8"><title>Skalpel CLI</title><p>You can close this tab and return to your terminal.</p>'
-        );
-        return;
-      }
-      if (req.method !== "POST" || req.url !== "/callback") {
-        res.writeHead(404, corsHeaders);
-        res.end();
-        return;
-      }
-      const contentType = (req.headers["content-type"] || "").toLowerCase();
-      if (!contentType.includes("application/json")) {
-        res.writeHead(415, { ...corsHeaders, "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Unsupported Media Type" }));
-        return;
-      }
-      let total = 0;
-      const chunks = [];
-      let aborted = false;
-      req.on("data", (chunk) => {
-        if (aborted) return;
-        total += chunk.length;
-        if (total > maxBytes) {
-          aborted = true;
-          res.writeHead(413, {
-            ...corsHeaders,
-            "Content-Type": "application/json",
-            Connection: "close"
-          });
-          res.end(JSON.stringify({ error: "Payload too large" }));
-          return;
-        }
-        chunks.push(chunk);
-      });
-      req.on("end", () => {
-        if (aborted) return;
-        const raw = Buffer.concat(chunks).toString("utf-8");
-        let parsed;
-        try {
-          parsed = JSON.parse(raw);
-        } catch {
-          res.writeHead(400, { ...corsHeaders, "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Invalid JSON" }));
-          return;
-        }
-        if (!isValidSession(parsed)) {
-          res.writeHead(400, { ...corsHeaders, "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Invalid session shape" }));
-          if (!settled) {
-            settled = true;
-            if (timer) clearTimeout(timer);
-            server.close(() => reject(new Error("Invalid session received")));
-          }
-          return;
-        }
-        res.writeHead(200, { ...corsHeaders, "Content-Type": "application/json" });
-        res.end(JSON.stringify({ ok: true }));
-        if (!settled) {
-          settled = true;
-          if (timer) clearTimeout(timer);
-          server.close(() => resolve2(parsed));
-        }
-      });
-      req.on("error", () => {
-      });
-    });
-    server.once("error", (err) => {
-      if (settled) return;
-      settled = true;
-      if (timer) clearTimeout(timer);
-      reject(err);
-    });
-    server.listen(port, "127.0.0.1", () => {
-      timer = setTimeout(() => {
-        if (settled) return;
-        settled = true;
-        server.close(() => reject(new Error("Login timed out")));
-      }, timeoutMs);
-      if (timer.unref) timer.unref();
-    });
-  });
-}
-
-// src/cli/auth/browser.ts
-async function openUrl(url) {
-  if (!/^https?:\/\//i.test(url)) {
-    throw new Error(`openUrl: refusing to open non-http(s) URL: ${url}`);
-  }
-  try {
-    const mod = await import("open");
-    const opener = mod.default;
-    if (typeof opener !== "function") {
-      throw new Error("open package exports no default function");
-    }
-    await opener(url);
-    return { opened: true, fallback: false };
-  } catch {
-    console.log("");
-    console.log("  Could not open your browser automatically.");
-    console.log("  Please open this URL manually to continue:");
-    console.log("");
-    console.log(`    ${url}`);
-    console.log("");
-    return { opened: false, fallback: true };
-  }
-}
-
-// src/cli/login.ts
-var DEFAULT_WEBAPP_URL = "https://app.skalpel.ai";
-var DEFAULT_TIMEOUT_MS2 = 18e4;
-async function runLogin(options = {}) {
-  const webappUrl = options.webappUrl ?? process.env.SKALPEL_WEBAPP_URL ?? DEFAULT_WEBAPP_URL;
-  const preferredPort = options.preferredPort ?? 51732;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
-  const log = options.logger ?? console;
-  const _findPort = options.findOpenPort ?? findOpenPort;
-  const _startServer = options.startCallbackServer ?? startCallbackServer;
-  const _openUrl = options.openUrl ?? openUrl;
-  const _writeSession = options.writeSession ?? writeSession;
-  const port = await _findPort(preferredPort);
-  const authorizeUrl = `${webappUrl.replace(/\/$/, "")}/cli/authorize?port=${port}`;
-  log.log("");
-  log.log(`  Opening browser to ${authorizeUrl}`);
-  log.log("  Waiting for authentication (timeout 3 min)...");
-  log.log("");
-  const serverPromise = _startServer(port, timeoutMs);
-  try {
-    await _openUrl(authorizeUrl);
-  } catch {
-    log.log("  Browser launch failed. Please open the URL above manually.");
-  }
-  let session;
-  try {
-    session = await serverPromise;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    log.error("");
-    log.error(`  Login failed: ${msg}`);
-    log.error("");
-    process.exitCode = 1;
-    throw err;
-  }
-  await _writeSession(session);
-  log.log("");
-  log.log(`  \u2713 Logged in as ${session.user.email}`);
-  log.log("");
-}
-
-// src/cli/logout.ts
-async function runLogout(options = {}) {
-  const log = options.logger ?? console;
-  const _readSession = options.readSession ?? readSession;
-  const _deleteSession = options.deleteSession ?? deleteSession;
-  const existing = await _readSession();
-  if (!existing) {
-    log.log("  Not logged in.");
-    return;
-  }
-  await _deleteSession();
-  log.log(`  \u2713 Logged out.`);
-}
-
-// src/cli/index.ts
-var require3 = createRequire2(import.meta.url);
-var pkg2 = require3("../../package.json");
-var program = new Command();
-program.name("skalpel").description("Skalpel AI CLI \u2014 optimize your OpenAI and Anthropic API calls").version(pkg2.version).option("--api-key <key>", "Skalpel API key for non-interactive setup").option("--auto", "Run setup in non-interactive mode").option("--skip-claude", "Skip Claude Code configuration").option("--skip-codex", "Skip Codex configuration").option("--skip-cursor", "Skip Cursor configuration").action((options) => runWizard(options));
-program.command("init").description("Initialize Skalpel in your project").action(runInit);
-program.command("doctor").description("Check Skalpel configuration health").action(runDoctor);
-program.command("benchmark").description("Run performance benchmarks").action(runBenchmark);
-program.command("replay").description("Replay saved request files").argument("<files...>", "JSON request files").action(runReplay);
-program.command("start").description("Start the Skalpel proxy").action(runStart);
-program.command("stop").description("Stop the Skalpel proxy").action(runStop);
-program.command("status").description("Show proxy status").action(runStatus);
-program.command("login").description("Log in to your Skalpel account (opens browser)").action(() => runLogin());
-program.command("logout").description("Log out of your Skalpel account").action(() => runLogout());
-program.command("logs").description("View proxy logs").option("-n, --lines <count>", "Number of lines to show", "50").option("-f, --follow", "Follow log output").action(runLogs);
-program.command("config").description("View or edit proxy configuration").argument("[subcommand]", "path | set").argument("[args...]", "Arguments for subcommand").action(runConfig);
-program.command("update").description("Update Skalpel to the latest version").action(runUpdate);
-program.command("setup").description("Run the Skalpel setup wizard").action(runWizard);
-program.command("uninstall").description("Remove Skalpel proxy and configurations").option("--force", "Skip confirmation prompts and remove everything").action(runUninstall);
-program.parse(process.argv);
-//# sourceMappingURL=index.js.map