@shunirr/cc-glm 0.1.0

package/dist/bin/cli.js

@@ -0,0 +1,722 @@
+#!/usr/bin/env node
+
+// src/bin/cli.ts
+import { spawn as spawn3 } from "child_process";
+
+// src/config/loader.ts
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+var VALID_UPSTREAMS = /* @__PURE__ */ new Set(["anthropic", "zai"]);
+var VALID_LOG_LEVELS = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]);
+var DEFAULTS = {
+  proxy: {
+    port: 8787,
+    host: "127.0.0.1"
+  },
+  upstream: {
+    anthropic: {
+      url: "https://api.anthropic.com"
+    },
+    zai: {
+      url: "https://api.z.ai/api/anthropic",
+      apiKey: ""
+    }
+  },
+  lifecycle: {
+    stopGraceSeconds: 8,
+    startWaitSeconds: 8,
+    stateDir: `${process.env.TMPDIR ?? "/tmp"}/claude-code-proxy`
+  },
+  logging: {
+    level: "info"
+  },
+  routing: {
+    rules: [],
+    default: "anthropic"
+  },
+  claude: { path: "" }
+};
+function expandEnvVars(str) {
+  if (typeof str !== "string") return str;
+  return str.replace(/\$\{([^}:]+)(:-([^}]*))?\}/g, (_, name, _defaultValue, defaultValue) => {
+    return process.env[name] ?? defaultValue ?? "";
+  });
+}
+function getDefaultConfigPath() {
+  const home = process.env.HOME ?? "";
+  return join(home, ".config", "cc-glm", "config.yml");
+}
+async function loadConfig(filePath = getDefaultConfigPath()) {
+  let raw = {};
+  if (existsSync(filePath)) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const parsed = parseYaml(content);
+      if (parsed && typeof parsed === "object") {
+        raw = parsed;
+      }
+    } catch (error) {
+      throw new Error(`Failed to parse config file at ${filePath}: ${error}`);
+    }
+  }
+  return mergeAndValidateConfig(raw);
+}
+function mergeAndValidateConfig(raw) {
+  const config = {
+    proxy: mergeProxyConfig(raw.proxy),
+    upstream: mergeUpstreamConfig(raw.upstream),
+    lifecycle: mergeLifecycleConfig(raw.lifecycle),
+    logging: mergeLoggingConfig(raw.logging),
+    routing: mergeRoutingConfig(raw.routing),
+    signatureStore: mergeSignatureStoreConfig(raw.signature_store),
+    claude: mergeClaudeConfig(raw.claude)
+  };
+  validateConfig(config);
+  return config;
+}
+function mergeProxyConfig(raw) {
+  const rawPort = raw?.port;
+  let port;
+  if (typeof rawPort === "number" && Number.isFinite(rawPort) && !isNaN(rawPort)) {
+    port = rawPort;
+  } else {
+    port = DEFAULTS.proxy.port;
+  }
+  if (!Number.isInteger(port)) {
+    throw new Error(`Invalid port: ${port}. Must be an integer.`);
+  }
+  if (port < 1 || port > 65535) {
+    throw new Error(`Invalid port: ${port}. Must be between 1 and 65535.`);
+  }
+  const rawHost = raw?.host;
+  const host = typeof rawHost === "string" ? rawHost : DEFAULTS.proxy.host;
+  if (typeof host !== "string" || host.length === 0) {
+    throw new Error(`Invalid host: must be a non-empty string.`);
+  }
+  return {
+    host,
+    port
+  };
+}
+function mergeUpstreamConfig(raw) {
+  const rawAnthropic = raw?.anthropic;
+  const rawZai = raw?.zai;
+  return {
+    anthropic: {
+      url: rawAnthropic?.url ? expandEnvVars(rawAnthropic.url) : DEFAULTS.upstream.anthropic.url
+    },
+    zai: {
+      url: rawZai?.url ? expandEnvVars(rawZai.url) : DEFAULTS.upstream.zai.url,
+      apiKey: expandEnvVars(rawZai?.apiKey ?? "") || process.env.ZAI_API_KEY || DEFAULTS.upstream.zai.apiKey
+    }
+  };
+}
+function mergeLifecycleConfig(raw) {
+  const stateDir = raw?.stateDir ?? DEFAULTS.lifecycle.stateDir;
+  const expandedStateDir = expandEnvVars(typeof stateDir === "string" ? stateDir : DEFAULTS.lifecycle.stateDir);
+  const finalStateDir = expandedStateDir || `${process.env.TMPDIR || "/tmp"}/claude-code-proxy`;
+  if (typeof finalStateDir !== "string" || finalStateDir.length === 0) {
+    throw new Error(`Invalid stateDir: must be a non-empty string.`);
+  }
+  const rawStopGrace = raw?.stopGraceSeconds;
+  const rawStartWait = raw?.startWaitSeconds;
+  let stopGraceSeconds;
+  if (typeof rawStopGrace === "number" && Number.isFinite(rawStopGrace) && !isNaN(rawStopGrace)) {
+    stopGraceSeconds = rawStopGrace;
+  } else {
+    stopGraceSeconds = DEFAULTS.lifecycle.stopGraceSeconds;
+  }
+  if (!Number.isInteger(stopGraceSeconds)) {
+    throw new Error(`Invalid stopGraceSeconds: ${stopGraceSeconds}. Must be an integer.`);
+  }
+  if (stopGraceSeconds < 0 || stopGraceSeconds > 300) {
+    throw new Error(`Invalid stopGraceSeconds: ${stopGraceSeconds}. Must be between 0 and 300.`);
+  }
+  let startWaitSeconds;
+  if (typeof rawStartWait === "number" && Number.isFinite(rawStartWait) && !isNaN(rawStartWait)) {
+    startWaitSeconds = rawStartWait;
+  } else {
+    startWaitSeconds = DEFAULTS.lifecycle.startWaitSeconds;
+  }
+  if (!Number.isInteger(startWaitSeconds)) {
+    throw new Error(`Invalid startWaitSeconds: ${startWaitSeconds}. Must be an integer.`);
+  }
+  if (startWaitSeconds < 1 || startWaitSeconds > 60) {
+    throw new Error(`Invalid startWaitSeconds: ${startWaitSeconds}. Must be between 1 and 60.`);
+  }
+  return {
+    stopGraceSeconds,
+    startWaitSeconds,
+    stateDir: finalStateDir
+  };
+}
+function mergeLoggingConfig(raw) {
+  const level = raw?.level ?? DEFAULTS.logging.level;
+  if (!VALID_LOG_LEVELS.has(level)) {
+    throw new Error(`Invalid logging level: ${level}. Must be one of: ${Array.from(VALID_LOG_LEVELS).join(", ")}`);
+  }
+  return {
+    level
+  };
+}
+function mergeRoutingConfig(raw) {
+  const rules = raw?.rules ?? DEFAULTS.routing.rules;
+  const defaultUpstream = raw?.default ?? DEFAULTS.routing.default;
+  if (!Array.isArray(rules)) {
+    throw new Error(`Invalid routing.rules: must be an array, got ${typeof rules}`);
+  }
+  for (let i = 0; i < rules.length; i++) {
+    const rule = rules[i];
+    if (!rule || typeof rule !== "object") {
+      throw new Error(`Invalid routing rule at index ${i}: must be an object`);
+    }
+    if (typeof rule.match !== "string") {
+      throw new Error(`Invalid routing rule at index ${i}: match must be a string`);
+    }
+    if (typeof rule.upstream !== "string") {
+      throw new Error(`Invalid routing rule at index ${i}: upstream must be a string`);
+    }
+    if (!VALID_UPSTREAMS.has(rule.upstream)) {
+      throw new Error(
+        `Invalid routing rule at index ${i}: upstream "${rule.upstream}" is not valid. Must be one of: ${Array.from(VALID_UPSTREAMS).join(", ")}`
+      );
+    }
+    if (rule.model !== void 0 && typeof rule.model !== "string") {
+      throw new Error(`Invalid routing rule at index ${i}: model must be a string if provided`);
+    }
+  }
+  if (!VALID_UPSTREAMS.has(defaultUpstream)) {
+    throw new Error(
+      `Invalid routing.default: "${defaultUpstream}" is not valid. Must be one of: ${Array.from(VALID_UPSTREAMS).join(", ")}`
+    );
+  }
+  return {
+    rules,
+    default: defaultUpstream
+  };
+}
+function mergeSignatureStoreConfig(raw) {
+  const DEFAULT_MAX_SIZE = 1e3;
+  const rawMaxSize = raw?.maxSize;
+  let maxSize;
+  if (typeof rawMaxSize === "number" && Number.isFinite(rawMaxSize) && !isNaN(rawMaxSize)) {
+    maxSize = rawMaxSize;
+  } else {
+    maxSize = DEFAULT_MAX_SIZE;
+  }
+  if (!Number.isInteger(maxSize)) {
+    throw new Error(`Invalid signatureStore.maxSize: ${maxSize}. Must be an integer.`);
+  }
+  if (maxSize < 1 || maxSize > 1e5) {
+    throw new Error(`Invalid signatureStore.maxSize: ${maxSize}. Must be between 1 and 100000.`);
+  }
+  return { maxSize };
+}
+function mergeClaudeConfig(raw) {
+  const path = raw?.path ?? DEFAULTS.claude.path;
+  if (typeof path !== "string") {
+    throw new Error(`Invalid claude.path: must be a string`);
+  }
+  return { path };
+}
+function validateConfig(config) {
+  try {
+    new URL(config.upstream.anthropic.url);
+  } catch {
+    throw new Error(`Invalid anthropic URL: ${config.upstream.anthropic.url}`);
+  }
+  try {
+    new URL(config.upstream.zai.url);
+  } catch {
+    throw new Error(`Invalid zai URL: ${config.upstream.zai.url}`);
+  }
+  if (!config.upstream.zai.apiKey) {
+    console.warn("Warning: zai API key is not set. Requests to z.ai will fail without ZAI_API_KEY.");
+  }
+}
+
+// src/lifecycle/singleton.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync3, openSync, closeSync } from "fs";
+import { mkdir as mkdir2, rmdir } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/process.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { mkdir, writeFile, unlink } from "fs/promises";
+var MIN_VALID_PID = 1;
+async function execCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        const error = new Error(`${command} failed with code ${code}: ${stderr}`);
+        error.code = code;
+        error.command = command;
+        reject(error);
+      }
+    });
+    proc.on("error", (err) => {
+      const error = err;
+      if (error.code === "ENOENT") {
+        const enhancedError = new Error(`Command not found: ${command}`);
+        enhancedError.code = "ENOENT";
+        enhancedError.command = command;
+        reject(enhancedError);
+      } else {
+        reject(err);
+      }
+    });
+  });
+}
+function pidIsAlive(pid) {
+  if (!Number.isFinite(pid) || pid < MIN_VALID_PID) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isPortListening(port) {
+  try {
+    await execCommand("lsof", [`-nP`, `-iTCP:${port}`, `-sTCP:LISTEN`]);
+    return true;
+  } catch (err) {
+    const error = err;
+    if (error.code === "ENOENT" && error.command === "lsof") {
+      throw new Error(
+        `lsof command is required but not found. Please install lsof or ensure it's in your PATH.`
+      );
+    }
+    return false;
+  }
+}
+async function ensureStateDir(stateDir) {
+  if (!existsSync2(stateDir)) {
+    await mkdir(stateDir, { recursive: true });
+  }
+}
+function readPidFile(pidFile) {
+  try {
+    if (!existsSync2(pidFile)) {
+      return null;
+    }
+    const content = readFileSync(pidFile, "utf-8");
+    const pid = parseInt(content.trim(), 10);
+    if (isNaN(pid) || pid < MIN_VALID_PID) {
+      return null;
+    }
+    return pid;
+  } catch {
+    return null;
+  }
+}
+async function writePidFile(pidFile, pid) {
+  if (!Number.isFinite(pid) || pid < MIN_VALID_PID) {
+    throw new Error(`Invalid PID ${pid}: cannot write to PID file`);
+  }
+  await writeFile(pidFile, pid.toString(), "utf-8");
+}
+async function removePidFile(pidFile) {
+  try {
+    await unlink(pidFile);
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/lifecycle/singleton.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var SingletonProxy = class {
+  config;
+  pidFile;
+  lockDir;
+  logFile;
+  constructor(config) {
+    this.config = config;
+    const stateDir = config.lifecycle.stateDir;
+    this.pidFile = join2(stateDir, "proxy.pid");
+    this.lockDir = join2(stateDir, "lock");
+    this.logFile = join2(stateDir, "proxy.log");
+  }
+  /**
+   * Start proxy if not already running
+   * Uses lock directory for atomic singleton behavior
+   */
+  async start() {
+    await ensureStateDir(this.config.lifecycle.stateDir);
+    await this.recoverStaleLock();
+    if (await isPortListening(this.config.proxy.port)) {
+      const pid = readPidFile(this.pidFile);
+      if (pid && pid > 0 && pidIsAlive(pid) && await this.verifyPidOwnsPort(pid)) {
+        console.log(`Proxy already running on port ${this.config.proxy.port} (PID ${pid})`);
+        return;
+      } else {
+        throw new Error(
+          `Port ${this.config.proxy.port} is already in use by another process. Please stop the other process or configure a different port.`
+        );
+      }
+    }
+    const lockAcquired = await this.acquireLock();
+    if (!lockAcquired) {
+      await this.waitForReady();
+      return;
+    }
+    try {
+      if (await isPortListening(this.config.proxy.port)) {
+        const pid = readPidFile(this.pidFile);
+        if (pid && pid > 0 && pidIsAlive(pid) && await this.verifyPidOwnsPort(pid)) {
+          return;
+        } else {
+          throw new Error(
+            `Port ${this.config.proxy.port} is already in use by another process.`
+          );
+        }
+      }
+      await this.startProxyProcess();
+      await this.waitForReady();
+    } finally {
+      await this.releaseLock();
+    }
+  }
+  /**
+   * Stop proxy if no Claude processes are running
+   */
+  async stopIfNoClaude(hasClaude) {
+    const { stopGraceSeconds } = this.config.lifecycle;
+    for (let i = 0; i < stopGraceSeconds; i++) {
+      if (await hasClaude()) {
+        return;
+      }
+      await sleep(1e3);
+    }
+    await this.stop();
+  }
+  /**
+   * Stop the proxy process
+   * Verifies PID owns the target port before killing to avoid PID reuse issues
+   */
+  async stop() {
+    const pid = readPidFile(this.pidFile);
+    if (pid && pid > 0) {
+      const isOurProcess = await this.verifyPidOwnsPort(pid);
+      if (isOurProcess) {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch (err) {
+          const error = err;
+          if ("code" in error && (error.code === "ESRCH" || error.code === "EPERM")) {
+            console.warn(`Failed to send SIGTERM to PID ${pid}: ${error.message}`);
+          } else {
+            throw error;
+          }
+        }
+        const deadline = Date.now() + 3e3;
+        while (Date.now() < deadline) {
+          if (!pidIsAlive(pid)) {
+            break;
+          }
+          await sleep(100);
+        }
+        if (pidIsAlive(pid) && await this.verifyPidOwnsPort(pid)) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch (err) {
+            const error = err;
+            if ("code" in error && (error.code === "ESRCH" || error.code === "EPERM")) {
+              console.warn(`Failed to send SIGKILL to PID ${pid}: ${error.message}`);
+            } else {
+              throw error;
+            }
+          }
+        }
+      } else {
+        console.warn(`PID ${pid} does not own port ${this.config.proxy.port}, treating as stale`);
+      }
+    }
+    await removePidFile(this.pidFile);
+  }
+  /**
+   * Get the proxy base URL
+   */
+  getBaseUrl() {
+    const { host, port } = this.config.proxy;
+    return `http://${host}:${port}`;
+  }
+  /**
+   * Try to acquire lock directory
+   */
+  async acquireLock() {
+    try {
+      await mkdir2(this.lockDir, { recursive: false });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Release lock directory
+   */
+  async releaseLock() {
+    try {
+      await rmdir(this.lockDir);
+    } catch {
+    }
+  }
+  /**
+   * Recover from a stale lock directory
+   * Handles cases where:
+   * - Lock exists but port is not listening and PID is dead
+   * - Lock exists but PID is alive but doesn't own the port (PID reuse)
+   */
+  async recoverStaleLock() {
+    if (!existsSync3(this.lockDir)) {
+      return;
+    }
+    const portListening = await isPortListening(this.config.proxy.port);
+    const pid = readPidFile(this.pidFile);
+    const pidAlive = pid !== null && pid > 0 && pidIsAlive(pid);
+    let lockIsStale = false;
+    if (!portListening && !pidAlive) {
+      lockIsStale = true;
+    } else if (pidAlive && !portListening) {
+      const ownsPort = await this.verifyPidOwnsPort(pid);
+      if (!ownsPort) {
+        lockIsStale = true;
+      }
+    }
+    if (lockIsStale) {
+      console.warn("Detected stale lock directory, recovering...");
+      try {
+        await rmdir(this.lockDir);
+        await removePidFile(this.pidFile);
+        console.warn("Stale lock recovered");
+      } catch (err) {
+        const error = err;
+        console.error(`Failed to recover stale lock: ${error.message}`);
+      }
+    }
+  }
+  /**
+   * Verify that a PID is actually listening on the target port
+   * This prevents killing a reused PID that doesn't belong to our proxy
+   */
+  async verifyPidOwnsPort(pid) {
+    if (!await isPortListening(this.config.proxy.port)) {
+      return false;
+    }
+    if (!pidIsAlive(pid)) {
+      return false;
+    }
+    try {
+      const output = await execCommand("lsof", [
+        "-nP",
+        `-iTCP:${this.config.proxy.port}`,
+        "-sTCP:LISTEN",
+        "-p",
+        pid.toString()
+      ]);
+      return output.includes(pid.toString());
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Wait for proxy to be ready (port listening)
+   */
+  async waitForReady() {
+    const { startWaitSeconds } = this.config.lifecycle;
+    const deadline = Date.now() + startWaitSeconds * 1e3;
+    while (Date.now() < deadline) {
+      if (await isPortListening(this.config.proxy.port)) {
+        return;
+      }
+      await sleep(100);
+    }
+    throw new Error(
+      `Proxy did not become ready at ${this.getBaseUrl()} (log: ${this.logFile})`
+    );
+  }
+  /**
+   * Start the proxy server as a detached process
+   */
+  async startProxyProcess() {
+    const serverPath = join2(__dirname, "..", "proxy", "server.js");
+    if (!existsSync3(serverPath)) {
+      throw new Error(`Proxy entry not found: ${serverPath}`);
+    }
+    const logFd = openSync(this.logFile, "a");
+    const proc = spawn2(process.execPath, [serverPath], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: { ...process.env }
+      // Inherit all environment variables
+    });
+    const pid = proc.pid;
+    if (!pid || pid < 1) {
+      closeSync(logFd);
+      throw new Error("Failed to get valid PID from spawned process");
+    }
+    proc.unref();
+    await writePidFile(this.pidFile, pid);
+    closeSync(logFd);
+  }
+};
+
+// src/lifecycle/tracker.ts
+async function hasClaudeProcess() {
+  try {
+    const uid = process.getuid?.() ?? process.env.UID ?? "";
+    await execCommand("pgrep", [`-u`, uid.toString(), `-x`, `claude`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var LOG_LEVEL_VALUES = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Update log level */
+  setLevel(level) {
+    this.config.level = level;
+  }
+  /** Check if a message should be logged */
+  shouldLog(level) {
+    return LOG_LEVEL_VALUES[level] >= LOG_LEVEL_VALUES[this.config.level];
+  }
+  /** Format log message */
+  format(level, message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const levelStr = level.toUpperCase().padEnd(5);
+    return `[${timestamp}] ${levelStr} ${message}`;
+  }
+  /** Log debug message */
+  debug(message) {
+    if (this.shouldLog("debug")) {
+      console.log(chalk.gray(this.format("debug", message)));
+    }
+  }
+  /** Log info message */
+  info(message) {
+    if (this.shouldLog("info")) {
+      console.log(chalk.white(this.format("info", message)));
+    }
+  }
+  /** Log warning message */
+  warn(message) {
+    if (this.shouldLog("warn")) {
+      console.log(chalk.yellow(this.format("warn", message)));
+    }
+  }
+  /** Log error message */
+  error(message) {
+    if (this.shouldLog("error")) {
+      console.error(chalk.red(this.format("error", message)));
+    }
+  }
+};
+
+// src/utils/claude.ts
+import { existsSync as existsSync4 } from "fs";
+async function resolveClaudePath(configPath) {
+  if (configPath) {
+    if (!existsSync4(configPath)) {
+      throw new Error(`Claude executable not found at: ${configPath}`);
+    }
+    return configPath;
+  }
+  const detector = process.platform === "win32" ? "where" : "which";
+  try {
+    return await execCommand(detector, ["claude"]);
+  } catch (err) {
+    const error = err;
+    if (error.code === "ENOENT") {
+      throw new Error(
+        `Claude command not found. Install Claude Code CLI or set 'claude.path' in config.yml`
+      );
+    }
+    throw err;
+  }
+}
+
+// src/bin/cli.ts
+async function main() {
+  const config = await loadConfig();
+  const logger = new Logger(config.logging);
+  let claudePath;
+  try {
+    claudePath = await resolveClaudePath(config.claude.path);
+    logger.debug(`Using claude: ${claudePath}`);
+  } catch (err) {
+    logger.error(`Failed to locate claude: ${err}`);
+    process.exit(1);
+    return;
+  }
+  const proxy = new SingletonProxy(config);
+  logger.info("Starting proxy...");
+  await proxy.start();
+  logger.info(`Proxy ready at ${proxy.getBaseUrl()}`);
+  const baseUrl = proxy.getBaseUrl();
+  process.env.ANTHROPIC_BASE_URL = baseUrl;
+  const args = process.argv.slice(2);
+  logger.info(`Starting claude with args: ${args.join(" ") || "(no args)"}`);
+  const claude = spawn3(claudePath, args, {
+    stdio: "inherit",
+    env: { ...process.env, ANTHROPIC_BASE_URL: baseUrl }
+  });
+  const exitCode = await new Promise((resolve) => {
+    claude.on("close", (code) => {
+      resolve(code ?? 0);
+    });
+    claude.on("error", (err) => {
+      logger.error(`Failed to start claude: ${err.message}`);
+      resolve(1);
+    });
+  });
+  logger.info(`Claude exited with code ${exitCode}`);
+  logger.info("Checking for other Claude processes...");
+  const hasClaude = await hasClaudeProcess();
+  if (!hasClaude) {
+    logger.info("No other Claude processes running, stopping proxy...");
+    await proxy.stopIfNoClaude(hasClaudeProcess);
+  } else {
+    logger.info("Other Claude processes still running, keeping proxy alive");
+  }
+  process.exit(exitCode);
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map