@omnicross/cli-launcher 0.1.0

package/dist/index.js

@@ -0,0 +1,851 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pty-adapter.ts
+var pty_adapter_exports = {};
+__export(pty_adapter_exports, {
+  buildPtyEnv: () => buildPtyEnv,
+  createPtyAdapter: () => createPtyAdapter
+});
+function buildPtyEnv(overlay) {
+  return overlay ? { ...process.env, ...overlay } : { ...process.env };
+}
+function createPtyAdapter(input) {
+  const nodePty = __require("node-pty");
+  const shell = input.shell ?? (process.platform === "win32" ? "powershell.exe" : "/bin/bash");
+  const pty = nodePty.spawn(shell, input.args ?? [], {
+    name: "xterm-256color",
+    cols: input.cols ?? 120,
+    rows: input.rows ?? 30,
+    cwd: input.cwd,
+    env: buildPtyEnv(input.env)
+  });
+  const stdoutListeners = [];
+  const stderrListeners = [];
+  const dataDisposable = pty.onData((data) => {
+    for (const cb of stdoutListeners) cb(data);
+  });
+  let exitResolve = null;
+  const exitPromise = new Promise((resolve) => {
+    exitResolve = resolve;
+  });
+  const exitDisposable = pty.onExit(({ exitCode, signal }) => {
+    exitResolve?.({ code: exitCode, signal: signal != null ? String(signal) : null });
+  });
+  let disposed = false;
+  return {
+    pid: pty.pid,
+    onStdout(cb) {
+      stdoutListeners.push(cb);
+    },
+    onStderr(cb) {
+      stderrListeners.push(cb);
+    },
+    stdin: {
+      write(data) {
+        if (!disposed) pty.write(data);
+      },
+      end() {
+        if (!disposed) pty.write("");
+      },
+      destroy() {
+      }
+    },
+    write(data) {
+      if (!disposed) pty.write(data);
+    },
+    resize(cols, rows) {
+      if (!disposed) pty.resize(cols, rows);
+    },
+    wait() {
+      return exitPromise;
+    },
+    kill(signal) {
+      if (disposed) return;
+      try {
+        pty.kill(signal);
+      } catch {
+      }
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      dataDisposable.dispose();
+      exitDisposable.dispose();
+      try {
+        pty.kill();
+      } catch {
+      }
+    }
+  };
+}
+var init_pty_adapter = __esm({
+  "src/pty-adapter.ts"() {
+    "use strict";
+  }
+});
+
+// src/supervisor.ts
+import { randomUUID } from "crypto";
+import { serializeError } from "@omnicross/core/serializeError";
+
+// src/child-adapter.ts
+import { spawn as cpSpawn2 } from "child_process";
+
+// src/kill-tree.ts
+import { spawn as cpSpawn } from "child_process";
+var TAG = "[ProcessSupervisor]";
+var MIN_GRACE_MS = 0;
+var MAX_GRACE_MS = 6e4;
+var DEFAULT_GRACE_MS = 3e3;
+var IS_WIN = process.platform === "win32";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killProcessTree(pid, opts) {
+  const graceMs = Math.max(MIN_GRACE_MS, Math.min(MAX_GRACE_MS, opts?.graceMs ?? DEFAULT_GRACE_MS));
+  if (!isProcessAlive(pid)) return;
+  if (IS_WIN) {
+    killTreeWindows(pid, graceMs);
+  } else {
+    killTreeUnix(pid, graceMs);
+  }
+}
+function killTreeWindows(pid, graceMs) {
+  try {
+    cpSpawn("taskkill", ["/T", "/PID", String(pid)], {
+      detached: true,
+      windowsHide: true,
+      stdio: "ignore"
+    }).unref();
+  } catch (err) {
+    console.warn(TAG, `taskkill graceful failed for pid=${pid}:`, err);
+  }
+  const timer = setTimeout(() => {
+    if (!isProcessAlive(pid)) return;
+    try {
+      cpSpawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+        detached: true,
+        windowsHide: true,
+        stdio: "ignore"
+      }).unref();
+    } catch (err) {
+      console.warn(TAG, `taskkill forced failed for pid=${pid}:`, err);
+    }
+  }, graceMs);
+  timer.unref();
+}
+function killTreeUnix(pid, graceMs) {
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch (err) {
+    if (err.code !== "ESRCH") {
+      console.warn(TAG, `SIGTERM failed for pgid=${pid}:`, err);
+    }
+    return;
+  }
+  const timer = setTimeout(() => {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch (err) {
+      if (err.code !== "ESRCH") {
+        console.warn(TAG, `SIGKILL failed for pgid=${pid}:`, err);
+      }
+    }
+  }, graceMs);
+  timer.unref();
+}
+
+// src/child-adapter.ts
+var TAG2 = "[ProcessSupervisor]";
+var IS_WIN2 = process.platform === "win32";
+function createChildAdapter(input) {
+  const [command, ...args] = input.argv;
+  if (!command) {
+    throw new Error(`${TAG2} argv must have at least one element (the command)`);
+  }
+  const opts = {
+    cwd: input.cwd,
+    env: input.env ? { ...process.env, ...input.env } : void 0,
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: IS_WIN2,
+    windowsVerbatimArguments: input.windowsVerbatimArguments,
+    detached: !IS_WIN2
+  };
+  const child = cpSpawn2(command, args, opts);
+  const stdinMode = input.stdinMode ?? (input.input ? "pipe-closed" : "pipe-open");
+  if (input.input && child.stdin) {
+    child.stdin.write(input.input, () => {
+      if (stdinMode === "pipe-closed") {
+        child.stdin?.end();
+      }
+    });
+  } else if (stdinMode === "pipe-closed" && child.stdin) {
+    child.stdin.end();
+  }
+  let disposed = false;
+  return {
+    pid: child.pid,
+    onStdout(cb) {
+      child.stdout?.setEncoding("utf8");
+      child.stdout?.on("data", cb);
+    },
+    onStderr(cb) {
+      child.stderr?.setEncoding("utf8");
+      child.stderr?.on("data", cb);
+    },
+    wait() {
+      return new Promise((resolve) => {
+        child.on("error", (err) => {
+          console.error(TAG2, `spawn error for "${command}":`, err.message);
+          resolve({ code: -1, signal: null });
+        });
+        child.on("close", (code, signal) => {
+          resolve({ code, signal: signal ?? null });
+        });
+      });
+    },
+    kill(signal) {
+      if (disposed || !child.pid) return;
+      if (signal === "SIGKILL") {
+        killProcessTree(child.pid);
+      } else {
+        try {
+          child.kill(signal ?? "SIGTERM");
+        } catch (err) {
+          console.warn(TAG2, `child.kill failed for pid=${child.pid}:`, err);
+        }
+      }
+    },
+    stdin: child.stdin,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      child.stdout?.removeAllListeners();
+      child.stderr?.removeAllListeners();
+      child.removeAllListeners();
+    }
+  };
+}
+
+// src/run-registry.ts
+var MAX_EXITED = 500;
+function createRunRegistry() {
+  const records = /* @__PURE__ */ new Map();
+  function shallowCopy(r) {
+    return { ...r };
+  }
+  function pruneExited() {
+    const exited = [];
+    for (const r of records.values()) {
+      if (r.state === "exited") exited.push(r);
+    }
+    if (exited.length <= MAX_EXITED) return;
+    exited.sort((a, b) => a.updatedAtMs - b.updatedAtMs);
+    const toRemove = exited.length - MAX_EXITED;
+    for (let i = 0; i < toRemove; i++) {
+      records.delete(exited[i].runId);
+    }
+  }
+  return {
+    add(record) {
+      records.set(record.runId, { ...record });
+    },
+    get(runId) {
+      const r = records.get(runId);
+      return r ? shallowCopy(r) : void 0;
+    },
+    list() {
+      return Array.from(records.values()).map(shallowCopy);
+    },
+    listByScope(scopeKey) {
+      const result = [];
+      for (const r of records.values()) {
+        if (r.scopeKey === scopeKey) result.push(shallowCopy(r));
+      }
+      return result;
+    },
+    updateState(runId, state, patch) {
+      const r = records.get(runId);
+      if (!r) return;
+      r.state = state;
+      r.updatedAtMs = Date.now();
+      if (patch) {
+        if (patch.pid !== void 0) r.pid = patch.pid;
+        if (patch.terminationReason !== void 0) r.terminationReason = patch.terminationReason;
+        if (patch.exitCode !== void 0) r.exitCode = patch.exitCode;
+        if (patch.exitSignal !== void 0) r.exitSignal = patch.exitSignal;
+      }
+    },
+    touchOutput(runId) {
+      const r = records.get(runId);
+      if (!r) return;
+      const now = Date.now();
+      r.lastOutputAtMs = now;
+      r.updatedAtMs = now;
+    },
+    finalize(runId, reason, exitCode, exitSignal) {
+      const r = records.get(runId);
+      if (!r) return;
+      r.state = "exited";
+      if (!r.terminationReason) {
+        r.terminationReason = reason;
+      }
+      if (exitCode !== void 0) r.exitCode = exitCode;
+      if (exitSignal !== void 0) r.exitSignal = exitSignal;
+      r.updatedAtMs = Date.now();
+      pruneExited();
+    },
+    delete(runId) {
+      records.delete(runId);
+    }
+  };
+}
+
+// src/supervisor.ts
+var TAG3 = "[ProcessSupervisor]";
+function createProcessSupervisor() {
+  const registry = createRunRegistry();
+  const active = /* @__PURE__ */ new Map();
+  function spawn(input) {
+    const runId = input.runId ?? randomUUID();
+    const now = Date.now();
+    const captureOutput = input.captureOutput ?? true;
+    if (input.replaceExistingScope && input.scopeKey) {
+      cancelScope(input.scopeKey, "manual-cancel");
+    }
+    const record = {
+      runId,
+      sessionId: input.sessionId,
+      backendId: input.backendId,
+      scopeKey: input.scopeKey,
+      startedAtMs: now,
+      lastOutputAtMs: now,
+      createdAtMs: now,
+      updatedAtMs: now,
+      state: "starting"
+    };
+    registry.add(record);
+    let stdout = "";
+    let stderr = "";
+    let forcedReason = null;
+    let settled = false;
+    let overallTimer = null;
+    let noOutputTimer = null;
+    let adapter;
+    try {
+      if (input.mode === "pty") {
+        const { createPtyAdapter: createPtyAdapter2 } = (init_pty_adapter(), __toCommonJS(pty_adapter_exports));
+        adapter = createPtyAdapter2(input);
+      } else {
+        adapter = createChildAdapter(input);
+      }
+    } catch (err) {
+      registry.finalize(runId, "spawn-error", -1, null);
+      const exit = {
+        reason: "spawn-error",
+        exitCode: -1,
+        exitSignal: null,
+        durationMs: 0,
+        stdout: "",
+        stderr: serializeError(err),
+        timedOut: false,
+        noOutputTimedOut: false
+      };
+      return {
+        runId,
+        startedAtMs: now,
+        wait: () => Promise.resolve(exit),
+        cancel: () => {
+        }
+      };
+    }
+    registry.updateState(runId, "running", { pid: adapter.pid });
+    function cancelRun(reason) {
+      if (settled) return;
+      forcedReason = reason ?? "manual-cancel";
+      registry.updateState(runId, "exiting", { terminationReason: forcedReason });
+      adapter.kill("SIGKILL");
+    }
+    active.set(runId, { cancel: cancelRun, adapter, scopeKey: input.scopeKey });
+    function clearTimers() {
+      if (overallTimer) {
+        clearTimeout(overallTimer);
+        overallTimer = null;
+      }
+      if (noOutputTimer) {
+        clearTimeout(noOutputTimer);
+        noOutputTimer = null;
+      }
+    }
+    if (input.timeoutMs && input.timeoutMs > 0) {
+      overallTimer = setTimeout(() => {
+        if (!settled) {
+          console.warn(TAG3, `overall timeout (${input.timeoutMs}ms) for run=${runId}`);
+          cancelRun("overall-timeout");
+        }
+      }, input.timeoutMs);
+      overallTimer.unref();
+    }
+    function resetNoOutputTimer() {
+      if (noOutputTimer) clearTimeout(noOutputTimer);
+      if (!input.noOutputTimeoutMs || input.noOutputTimeoutMs <= 0 || settled) return;
+      noOutputTimer = setTimeout(() => {
+        if (!settled) {
+          console.warn(TAG3, `no-output timeout (${input.noOutputTimeoutMs}ms) for run=${runId}`);
+          cancelRun("no-output-timeout");
+        }
+      }, input.noOutputTimeoutMs);
+      noOutputTimer.unref();
+    }
+    resetNoOutputTimer();
+    adapter.onStdout((chunk) => {
+      if (captureOutput) stdout += chunk;
+      registry.touchOutput(runId);
+      resetNoOutputTimer();
+      input.onStdout?.(chunk);
+    });
+    adapter.onStderr((chunk) => {
+      if (captureOutput) stderr += chunk;
+      registry.touchOutput(runId);
+      resetNoOutputTimer();
+      input.onStderr?.(chunk);
+    });
+    let stdinHandle;
+    if (adapter.stdin) {
+      stdinHandle = {
+        write(data) {
+          adapter.stdin?.write(data);
+        },
+        end() {
+          adapter.stdin?.end();
+        },
+        destroy() {
+          adapter.stdin?.destroy();
+        }
+      };
+    }
+    const waitPromise = adapter.wait().then(({ code, signal }) => {
+      settled = true;
+      clearTimers();
+      const reason = forcedReason ?? (code === -1 ? "spawn-error" : signal ? "signal" : "exit");
+      registry.finalize(runId, reason, code, signal);
+      active.delete(runId);
+      adapter.dispose();
+      return {
+        reason,
+        exitCode: code,
+        exitSignal: signal,
+        durationMs: Date.now() - now,
+        stdout,
+        stderr,
+        timedOut: reason === "overall-timeout",
+        noOutputTimedOut: reason === "no-output-timeout"
+      };
+    });
+    let cachedWait = null;
+    return {
+      runId,
+      pid: adapter.pid,
+      startedAtMs: now,
+      stdin: stdinHandle,
+      wait() {
+        if (!cachedWait) cachedWait = waitPromise;
+        return cachedWait;
+      },
+      cancel: cancelRun
+    };
+  }
+  function cancel(runId, reason) {
+    const entry = active.get(runId);
+    if (!entry) return;
+    entry.cancel(reason);
+  }
+  function cancelScope(scopeKey, reason) {
+    for (const [runId, entry] of active) {
+      if (entry.scopeKey === scopeKey) {
+        entry.cancel(reason);
+        console.warn(TAG3, `cancelled run=${runId} in scope="${scopeKey}"`);
+      }
+    }
+  }
+  function getRecord(runId) {
+    return registry.get(runId);
+  }
+  function resizePty(runId, cols, rows) {
+    const entry = active.get(runId);
+    if (!entry) return false;
+    if ("resize" in entry.adapter && typeof entry.adapter.resize === "function") {
+      entry.adapter.resize(cols, rows);
+      return true;
+    }
+    return false;
+  }
+  return { spawn, cancel, cancelScope, getRecord, resizePty };
+}
+
+// src/proxy-env/claude-proxy-env.ts
+import { resolveProviderEndpoint } from "@omnicross/core/completion";
+import { getProviderProxy } from "@omnicross/core/provider-proxy";
+var CLAUDE_PROXY_API_KEY_SENTINEL = "omnicross-proxy";
+async function buildClaudeCliLaunchConfig(inputs) {
+  const provider = await inputs.llmConfig.getProvider(inputs.providerId);
+  if (!provider) {
+    throw new Error(
+      `claude proxy: provider not found: ${inputs.providerId}. Add a provider row to the daemon config (omnicross providers add \u2026).`
+    );
+  }
+  const { apiKey } = resolveProviderEndpoint(provider);
+  if (!resolveApiKey(apiKey)) {
+    throw new Error(
+      `claude proxy: provider "${inputs.providerId}" has no valid API key. Set apiKey (or a $ENV_VAR reference) on the provider row.`
+    );
+  }
+  const route = {
+    sessionId: inputs.sessionId ?? null,
+    targetProviderFormat: provider.apiFormat === "anthropic" ? "anthropic" : "transform",
+    model: inputs.model,
+    ingressFormat: "anthropic-messages",
+    authMode: "byo",
+    providerId: inputs.providerId
+  };
+  const proxy = getProviderProxy();
+  const token = proxy.addRoute(route);
+  const baseUrl = proxy.getBaseUrl();
+  console.info("[buildClaudeCliLaunchConfig] claude route ready", {
+    sessionId: inputs.sessionId,
+    baseUrl,
+    providerId: inputs.providerId,
+    model: inputs.model
+  });
+  const env = {
+    ANTHROPIC_BASE_URL: baseUrl,
+    ANTHROPIC_AUTH_TOKEN: token,
+    ANTHROPIC_API_KEY: CLAUDE_PROXY_API_KEY_SENTINEL,
+    ANTHROPIC_MODEL: inputs.model
+  };
+  return {
+    env,
+    baseUrl,
+    onSessionEnd: () => {
+      try {
+        proxy.removeRoute(token);
+      } catch {
+      }
+    }
+  };
+}
+function resolveApiKey(apiKey) {
+  if (!apiKey) return "";
+  if (apiKey.startsWith("$")) {
+    return process.env[apiKey.slice(1)] || "";
+  }
+  return apiKey;
+}
+
+// src/proxy-env/cli-proxy-env.ts
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { resolveProviderEndpoint as resolveProviderEndpoint2 } from "@omnicross/core/completion";
+import { getProviderProxy as getProviderProxy2 } from "@omnicross/core/provider-proxy";
+var CHAT_PROXY_BASE_PATH = "/v1";
+var OPENCODE_PROXY_PROVIDER_ID = "omnicross";
+var OPENCODE_PROXY_TOKEN_ENV = "OMNICROSS_OPENCODE_TOKEN";
+async function buildChatCliLaunchConfig(inputs) {
+  const provider = await inputs.llmConfig.getProvider(inputs.providerId);
+  if (!provider) {
+    throw new Error(
+      `${inputs.backendId} proxy: provider not found: ${inputs.providerId}. Add an OpenAI-compatible provider in Settings \u2192 LLM Providers.`
+    );
+  }
+  const { apiKey } = resolveProviderEndpoint2(provider);
+  if (!resolveApiKey2(apiKey)) {
+    throw new Error(
+      `${inputs.backendId} proxy: provider "${inputs.providerId}" has no valid API key. Add an API key in Settings \u2192 LLM Providers.`
+    );
+  }
+  const route = {
+    sessionId: inputs.sessionId ?? null,
+    targetProviderFormat: "transform",
+    model: inputs.model,
+    ingressFormat: "openai-chat",
+    authMode: "byo",
+    providerId: inputs.providerId
+  };
+  const proxy = getProviderProxy2();
+  const token = proxy.addRoute(route);
+  const baseUrl = proxy.getBaseUrl();
+  const chatBase = `${baseUrl}${CHAT_PROXY_BASE_PATH}`;
+  const cleanups = [() => proxy.removeRoute(token)];
+  const env = buildBackendEnv(inputs.backendId, {
+    chatBase,
+    baseUrl,
+    token,
+    model: inputs.model,
+    cleanups
+  });
+  console.log("[buildChatCliLaunchConfig] chat-CLI route ready", {
+    backendId: inputs.backendId,
+    sessionId: inputs.sessionId,
+    baseUrl,
+    providerId: inputs.providerId,
+    model: inputs.model
+  });
+  return {
+    env,
+    baseUrl,
+    onSessionEnd: () => {
+      for (const c of cleanups) {
+        try {
+          c();
+        } catch {
+        }
+      }
+    }
+  };
+}
+function buildBackendEnv(backendId, ctx) {
+  switch (backendId) {
+    case "qwen":
+      return {
+        OPENAI_BASE_URL: ctx.chatBase,
+        OPENAI_API_KEY: ctx.token,
+        OPENAI_MODEL: ctx.model
+      };
+    case "copilot":
+      return {
+        COPILOT_PROVIDER_BASE_URL: ctx.chatBase,
+        COPILOT_PROVIDER_TYPE: "openai",
+        COPILOT_PROVIDER_API_KEY: ctx.token,
+        COPILOT_MODEL: ctx.model
+      };
+    case "opencode":
+      return buildOpencodeEnv(ctx);
+    default: {
+      const _exhaustive = backendId;
+      throw new Error(`Unsupported chat CLI backend: ${String(_exhaustive)}`);
+    }
+  }
+}
+function buildOpencodeEnv(ctx) {
+  const id = OPENCODE_PROXY_PROVIDER_ID;
+  const config = {
+    $schema: "https://opencode.ai/config.json",
+    provider: {
+      [id]: {
+        npm: "@ai-sdk/openai-compatible",
+        name: "Omnicross Proxy",
+        options: {
+          baseURL: ctx.chatBase,
+          apiKey: `{env:${OPENCODE_PROXY_TOKEN_ENV}}`
+        },
+        models: {
+          [ctx.model]: {}
+        }
+      }
+    }
+  };
+  const dir = mkdtempSync(join(tmpdir(), "omnicross-opencode-"));
+  const configPath = join(dir, "opencode.json");
+  writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  ctx.cleanups.push(() => rmSync(dir, { recursive: true, force: true }));
+  return {
+    OPENCODE_CONFIG: configPath,
+    [OPENCODE_PROXY_TOKEN_ENV]: ctx.token
+  };
+}
+async function buildGeminiCliLaunchConfig(inputs) {
+  const provider = await inputs.llmConfig.getProvider(inputs.providerId);
+  if (!provider) {
+    throw new Error(
+      `gemini-cli proxy: provider not found: ${inputs.providerId}. Add a Gemini-compatible provider in Settings \u2192 LLM Providers.`
+    );
+  }
+  const { apiKey } = resolveProviderEndpoint2(provider);
+  if (!resolveApiKey2(apiKey)) {
+    throw new Error(
+      `gemini-cli proxy: provider "${inputs.providerId}" has no valid API key. Add an API key in Settings \u2192 LLM Providers.`
+    );
+  }
+  const route = {
+    sessionId: inputs.sessionId ?? null,
+    targetProviderFormat: "transform",
+    model: inputs.model,
+    ingressFormat: "gemini-generatecontent",
+    authMode: "byo",
+    providerId: inputs.providerId
+  };
+  const proxy = getProviderProxy2();
+  const token = proxy.addRoute(route);
+  const baseUrl = proxy.getBaseUrl();
+  console.log("[buildGeminiCliLaunchConfig] gemini-CLI route ready (forced API-key)", {
+    sessionId: inputs.sessionId,
+    baseUrl,
+    providerId: inputs.providerId,
+    model: inputs.model
+  });
+  const env = {
+    GOOGLE_GEMINI_BASE_URL: baseUrl,
+    GEMINI_API_KEY: token,
+    GEMINI_MODEL: inputs.model,
+    // Force API-key mode off the OAuth/Code-Assist (non-interceptable) path.
+    GOOGLE_GENAI_USE_GCA: "false"
+  };
+  return {
+    env,
+    baseUrl,
+    onSessionEnd: () => {
+      try {
+        proxy.removeRoute(token);
+      } catch {
+      }
+    }
+  };
+}
+function resolveApiKey2(apiKey) {
+  if (!apiKey) return "";
+  if (apiKey.startsWith("$")) {
+    return process.env[apiKey.slice(1)] || "";
+  }
+  return apiKey;
+}
+
+// src/proxy-env/codex-proxy-env.ts
+import { resolveProviderEndpoint as resolveProviderEndpoint3 } from "@omnicross/core/completion";
+import { getProviderProxy as getProviderProxy3 } from "@omnicross/core/provider-proxy";
+var CODEX_PROXY_PROVIDER_NAME = "omnicross";
+var CODEX_PROXY_BASE_PATH = "/openai";
+function buildCodexConfigOverrides(baseUrl) {
+  const name = CODEX_PROXY_PROVIDER_NAME;
+  const providerBaseUrl = `${baseUrl}${CODEX_PROXY_BASE_PATH}`;
+  return [
+    "-c",
+    `model_provider="${name}"`,
+    "-c",
+    `model_providers.${name}.name="${name}"`,
+    "-c",
+    `model_providers.${name}.base_url="${providerBaseUrl}"`,
+    "-c",
+    `model_providers.${name}.wire_api="responses"`,
+    // requires_openai_auth is a boolean — UNQUOTED so the TOML override is typed
+    // as a bool, not the string "true".
+    "-c",
+    `model_providers.${name}.requires_openai_auth=true`,
+    // disable_response_storage: the CLI sends full context each turn (no
+    // server-side response store) — required because the proxy upstream is
+    // stateless w.r.t. Codex's response-id store (design Q3 contract).
+    "-c",
+    "disable_response_storage=true"
+  ];
+}
+async function buildCodexLaunchConfig(inputs) {
+  const authMode = inputs.authMode ?? "byo";
+  if (authMode === "byo") {
+    const provider = await inputs.llmConfig.getProvider(inputs.providerId);
+    if (!provider) {
+      throw new Error(
+        `Codex proxy: provider not found: ${inputs.providerId}. Add an OpenAI-compatible provider in Settings \u2192 LLM Providers.`
+      );
+    }
+    const { apiKey } = resolveProviderEndpoint3(provider);
+    const resolved = resolveApiKey3(apiKey);
+    if (!resolved) {
+      throw new Error(
+        `Codex proxy: provider "${inputs.providerId}" has no valid API key. Add an API key in Settings \u2192 LLM Providers.`
+      );
+    }
+  } else if (!inputs.subscriptionProfile) {
+    throw new Error("Codex proxy: subscription mode requires a codex subscription profile.");
+  }
+  const route = {
+    sessionId: inputs.sessionId ?? null,
+    targetProviderFormat: "openai-responses",
+    model: inputs.model,
+    ingressFormat: "openai-responses",
+    authMode,
+    providerId: inputs.providerId,
+    subscriptionProfile: inputs.subscriptionProfile ?? null
+  };
+  const proxy = getProviderProxy3();
+  const token = proxy.addRoute(route);
+  const baseUrl = proxy.getBaseUrl();
+  console.log("[buildCodexLaunchConfig] Codex route ready", {
+    sessionId: inputs.sessionId,
+    baseUrl,
+    providerId: inputs.providerId,
+    model: inputs.model,
+    authMode
+  });
+  return {
+    env: {
+      // Satisfy the CLI's `requires_openai_auth = true` precondition. The CLI
+      // forwards this as the Responses-API key; the resident proxy uses it as
+      // the route TOKEN (looked up, then discarded) and re-authenticates
+      // upstream from the route's own provider/subscription credential.
+      OPENAI_API_KEY: token
+    },
+    extraArgs: buildCodexConfigOverrides(baseUrl),
+    baseUrl,
+    onSessionEnd: () => {
+      proxy.removeRoute(token);
+    }
+  };
+}
+function resolveApiKey3(apiKey) {
+  if (!apiKey) return "";
+  if (apiKey.startsWith("$")) {
+    return process.env[apiKey.slice(1)] || "";
+  }
+  return apiKey;
+}
+
+// src/index.ts
+var instance = null;
+function getProcessSupervisor() {
+  if (!instance) instance = createProcessSupervisor();
+  return instance;
+}
+export {
+  CHAT_PROXY_BASE_PATH,
+  CLAUDE_PROXY_API_KEY_SENTINEL,
+  CODEX_PROXY_BASE_PATH,
+  CODEX_PROXY_PROVIDER_NAME,
+  OPENCODE_PROXY_PROVIDER_ID,
+  OPENCODE_PROXY_TOKEN_ENV,
+  buildChatCliLaunchConfig,
+  buildClaudeCliLaunchConfig,
+  buildCodexConfigOverrides,
+  buildCodexLaunchConfig,
+  buildGeminiCliLaunchConfig,
+  getProcessSupervisor
+};