@bman654/clodex 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jacob Ben David
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,183 @@
+# clodex
+
+**clodex** bridges [Claude Code](https://docs.anthropic.com/en/docs/claude-code) to OpenAI models — with an OpenAI API key or a ChatGPT/Codex-plan OAuth login. It translates Claude Code's Anthropic wire format to the OpenAI API through the Vercel AI SDK, with working prompt caching, accurate context windows and auto-compaction, live mid-session model switching, and an optional Claude Code binary patcher that makes your OpenAI models first-class citizens inside Claude Code (validated names, `/model` entries, correct context reporting).
+
+> clodex is derived from the original [relay-ai](https://github.com/jacob-bd/relay-ai) project, heavily modified and streamlined for this one use case, with the full commit history preserved.
+
+## Get started (ChatGPT/Codex plan)
+
+```bash
+npm install -g @bman654/clodex          # 1. install the CLI (Node 22+)
+clodex providers auth openai   # 2. sign in with your ChatGPT/Codex plan (device-code OAuth)
+clodex models                  # 3. pick favorite models and short aliases
+clodex patch                   # 4. (optional) patch Claude Code so those models are first-class
+clodex claude                  # 5. launch Claude Code on an OpenAI model
+```
+
+1. **Install** — puts the `clodex` command on your PATH.
+2. **Sign in** — opens a device-code OAuth flow for your ChatGPT/Codex plan; the token is stored in your OS credential store. (API-key users: `clodex providers add` instead.)
+3. **Pick models** — an interactive manager for favorites (max 20) and short aliases like `sol`. Favorites drive the `/model` switch menu, proxy-mode routing, and the patcher.
+4. **Patch** *(optional but recommended for proxy mode)* — bakes your favorites and aliases into the Claude Code binary so they pass model validation, appear in `/model`, and report their real context windows. Re-run after each `claude` update; `clodex patch --restore` undoes it.
+5. **Launch** — starts Claude Code bridged to the model you choose.
+
+## Bridge modes
+
+Both `clodex claude` and `clodex server` support two bridge modes. A mode flag applies to **that run only**; to change a command's default, add `--save-mode` (e.g. `clodex claude --endpoint --save-mode`). With no flag and nothing saved, both commands default to **proxy** mode, which works with your existing Claude auth.
+
+- **`--proxy`** (the default): a selective man-in-the-middle proxy for `api.anthropic.com`. Claude Code keeps its normal Anthropic login — Anthropic models work untouched — while models named `clodex:<provider-id>:<model-id>` (or their saved aliases) route to OpenAI. Switch with `/model clodex:openai-oauth:gpt-5.6-sol` or `/model sol` after patching.
+- **`--endpoint`**: clodex runs a local Anthropic-format gateway and launches Claude Code with `ANTHROPIC_BASE_URL` pointed at it. All traffic goes through the gateway. With favorites saved, the gateway is multi-route and Claude Code's `/model` menu lists your starting model plus favorites for live switching.
+
+In proxy mode, Claude Code keeps its own Anthropic credentials and only requests naming a `clodex:` model or alias are rerouted:
+
+```mermaid
+flowchart LR
+    CC["Claude Code<br/>(own Anthropic login)"] -->|"HTTPS via HTTPS_PROXY,<br/>trusts the clodex CA"| MITM["clodex MITM proxy"]
+    MITM --> DEC{"model is clodex:...<br/>or a saved alias?"}
+    DEC -->|"yes — translated request,<br/>clodex-managed OpenAI credentials"| OAI["OpenAI<br/>(OAuth: Responses WebSocket /<br/>API key: HTTPS)"]
+    DEC -->|"no — passed through untouched,<br/>Claude Code's Anthropic credentials ride along"| ANT["api.anthropic.com"]
+```
+
+In endpoint mode, no Anthropic account is involved — Claude Code is launched pointing at the local gateway with a local API key, and its startup `/v1/models` fetch powers the `/model` menu:
+
+```mermaid
+flowchart LR
+    CC["Claude Code<br/>(ANTHROPIC_BASE_URL + local API key,<br/>no Anthropic account credentials)"] -->|"Anthropic-format /v1/messages<br/>+ local API key"| GW["clodex gateway<br/>(:17645/anthropic)"]
+    CC -->|"GET /v1/models at startup"| GW
+    GW -->|"model catalog with context windows<br/>(feeds the /model menu)"| CC
+    GW -->|"translated request,<br/>clodex-managed OpenAI credentials"| OAI["OpenAI"]
+```
+
+Using Claude Code's agents view or background agents? Ask your Claude Code agent to read [docs/background-agents.md](docs/background-agents.md) and set it up for you — one global `clodex server --proxy` plus the `clodex-claude` wrapper bin bridges every claude process automatically.
+
+## CLI reference
+
+### `clodex claude [options] [claude-flags]`
+
+Launch Claude Code bridged to OpenAI models. Unrecognized flags (and everything after `--`) pass through to Claude Code (`-c`, `--resume`, `--print`, …).
+
+| Flag | Effect |
+| --- | --- |
+| `--endpoint` | Endpoint bridge mode for this run: local gateway + `ANTHROPIC_BASE_URL` |
+| `--proxy` | Proxy bridge mode for this run: keep Claude Code's Anthropic auth; `clodex:` models route to OpenAI (default when nothing is saved) |
+| `--save-mode` | With `--endpoint`/`--proxy`: save that mode as the `claude` default |
+| `--dry-run` | Run the wizard but print a launch preview instead of launching (never persists anything) |
+| `--trace` | Write debug logs to `~/.clodex/logs/` and show errors on exit |
+| `--provider <id>` | Boot provider id (`openai` or `openai-oauth`); with `--model`, skips the wizard |
+| `--model <id>` | Boot model id; with `--provider`, skips the wizard |
+| `--help`, `--version` | Help / version |
+
+Notes:
+
+- Claude Code may save the launched model to `~/.claude/settings.json`, so bare `claude` later can still show a clodex model name. Reset with `claude --model sonnet`.
+- Non-interactive stdin reuses your last provider/model instead of showing the wizard.
+
+### `clodex server [options]`
+
+Foreground gateway, same two bridge modes, no Claude Code launch — point any Anthropic-format (or OpenAI-format) client at it.
+
+Common options (both modes):
+
+| Flag | Effect |
+| --- | --- |
+| `--endpoint` | Endpoint mode for this run: Anthropic-format HTTP gateway |
+| `--proxy` | Proxy mode for this run: selective `api.anthropic.com` MITM proxy (default when nothing is saved; local only) |
+| `--save-mode` | With `--endpoint`/`--proxy`: save that mode as the `server` default |
+| `--port <1-65535>` | Listen port (default 17645) |
+| `--ws-diagnostics` | Log sanitized request envelopes and WebSocket head decisions |
+| `--help`, `--version` | Help / version |
+
+Endpoint mode only (an error if combined with `--proxy`):
+
+| Flag | Effect |
+| --- | --- |
+| `--quick`, `--saved` | Start immediately from saved/default settings, skipping the wizard |
+| `--listen local\|network` | One-run listen mode override |
+| `--providers all\|favorites\|id1,id2` | One-run provider catalog override |
+| `--mask-gateway-ids` / `--no-mask-gateway-ids` | Mask or expose vendor names in discovery model ids (see below) |
+| `--password <value>` | One-run network-mode server password |
+
+Proxy mode has no extra options — it takes only the common options.
+
+Bare `clodex server` uses the saved default mode (proxy if none saved). Proxy mode starts immediately. Endpoint mode on a TTY opens a short wizard — start from saved settings, or configure: favorites-only catalog?, which providers to expose, discovery-id masking, and listen local/network (network asks for a password). Without a TTY (or with `--quick`/any endpoint-mode option) it skips all prompts and starts from saved settings; network mode then needs a saved password or `--password`.
+
+**`--mask-gateway-ids`:** endpoint-mode discovery ids look like `anthropic-openai-oauth__gpt-5.6`. Some Claude clients validate model names (Claude Desktop / Cowork pickers, Claude Code skill/agent `model:` frontmatter) and reject or filter ids containing non-Anthropic vendor names. Masking reverses the provider and model segments (`anthropic-htuao-ianepo__6.5-tpg`) so vendor strings never appear literally; display names stay readable (`GPT 5.6 (OpenAI)`), and the gateway accepts both masked and unmasked ids in chat requests. Tradeoff: masked ids are unreadable — copy them exactly from the printed catalog. Masking is on by default; use `--no-mask-gateway-ids` for clients that don't need it.
+
+Endpoint-mode endpoints (default port 17645):
+
+```
+ANTHROPIC_BASE_URL=http://127.0.0.1:17645/anthropic
+OPENAI_BASE_URL=http://127.0.0.1:17645/openai/v1
+```
+
+Use any API key locally; network mode requires the server password. Proxy mode prints `HTTPS_PROXY`, `HTTP_PROXY`, and `NODE_EXTRA_CA_CERTS` values to export — do **not** set `ANTHROPIC_BASE_URL` in that mode.
+
+Examples:
+
+```bash
+# Endpoint gateway serving only your favorites, no prompts, for a local client
+clodex server --endpoint --quick --providers favorites
+
+# Proxy mode for an existing-auth Claude Code (export the env it prints)
+clodex server --proxy
+```
+
+### `clodex patch [--restore]`
+
+Patch the installed Claude Code binary so clodex favorites and aliases are first-class: accepted by the Agent tool's model field, listed in `/model`, resolved to their real ids, and reporting the correct context window.
+
+| Flag | Effect |
+| --- | --- |
+| `--restore` | Restore the pristine (unpatched) Claude Code binary |
+| `--trace` | Show the underlying tweakcc output |
+| `--help` | Help |
+
+The patch map is built from your favorites and aliases; context windows come from provider metadata. A pristine per-version backup is kept, and a manifest (`~/.clodex/patch-state.json`) makes re-runs no-ops until your config or Claude Code version changes — then the binary is restored first and re-patched fresh. `clodex claude` checks patch freshness at launch and offers to re-patch (a non-blocking notice when not interactive). Re-run `clodex patch` after every `claude` update.
+
+### `clodex models` / `clodex favorites`
+
+Manage favorite models (max 20) and short aliases. Favorites feed the endpoint-mode `/model` switch menu, proxy-mode routing, and the patcher. Saved to `~/.clodex/config.json`.
+
+| Flag | Effect |
+| --- | --- |
+| *(none)* | Interactive manager: search all providers or browse one at a time |
+| `--list` | Print the exact `clodex:<provider-id>:<model-id>` names (and aliases) without opening the manager |
+| `--alias <name=target>` | Save a short name for a favorite, e.g. `--alias sol=clodex:openai-oauth:gpt-5.6-sol` (the `clodex:` prefix is optional in the target) |
+| `--unalias <name>` | Remove a saved short name |
+| `--help`, `--version` | Help / version |
+
+### `clodex providers [subcommand]`
+
+| Subcommand | Effect |
+| --- | --- |
+| *(none)* | Provider hub wizard |
+| `add` | Add OpenAI with an API key (choose OAuth or API key) |
+| `auth openai` | Sign in with ChatGPT/Codex-plan OAuth (device code) |
+| `list` | Show configured providers |
+| `remove <id>` | Remove a provider by id |
+| `refresh-models [id]` | Update cached model lists |
+
+Providers supported: `openai` (API key, platform.openai.com) and `openai-oauth` (ChatGPT/Codex plan).
+
+### Root
+
+```
+clodex --help       # overview of all commands
+clodex --version    # version
+```
+
+## Configuration
+
+- Config home: `~/.clodex` (override with `CLODEX_HOME`). On first run, config is migrated automatically from a legacy `~/.relay-ai` directory if present; the legacy directory is never modified.
+- Credentials live in the OS credential store (Keychain / Windows Credential Manager / Secret Service) under the `clodex` service.
+- `CLODEX_CLAUDE_PATH` overrides Claude Code binary discovery.
+- **Outbound proxy:** when `HTTP_PROXY`/`HTTPS_PROXY` (and optionally `NO_PROXY`) are set in clodex's environment, all clodex-originated network calls honor them — OAuth sign-in and token refresh, model-list and models.dev refreshes, upstream OpenAI API calls, and the ChatGPT/Codex OAuth WebSocket transport (tunneled via HTTP CONNECT).
+
+## Known limitations
+
+- Cost display inside Claude Code is inaccurate for OpenAI models (Claude Code applies its own pricing table).
+- In the endpoint-mode switch menu, the displayed context window reflects the launch model and does not update on live `/model` switches (Claude Code fetches window metadata once at startup). Proxy mode with `clodex patch` reports correct per-model windows.
+- ChatGPT/Codex OAuth requires `store:false` upstream; some OpenAI cache controls are intentionally omitted on OAuth routes because they returned empty responses during compatibility testing.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/chunk-C7N2JI7Z.js

@@ -0,0 +1,430 @@
+#!/usr/bin/env node
+
+// src/server-runtime.ts
+import { mkdirSync as mkdirSync2, readFileSync, rmSync, writeFileSync } from "fs";
+import { dirname, join as join2 } from "path";
+
+// src/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { cpSync, existsSync, mkdirSync, readdirSync } from "fs";
+var APP_DIR_NAME = "clodex";
+var LEGACY_APP_DIR_NAME = "relay-ai";
+function userHome(env = process.env) {
+  return env.HOME ?? env.USERPROFILE ?? homedir();
+}
+function resolveAppHomeOverride(env = process.env) {
+  const override = env.CLODEX_HOME;
+  return override?.trim() || void 0;
+}
+function getAppHome(env = process.env) {
+  const override = resolveAppHomeOverride(env);
+  if (override) return override;
+  return join(userHome(env), `.${APP_DIR_NAME}`);
+}
+function getLegacyAppHome(env = process.env) {
+  return join(userHome(env), `.${LEGACY_APP_DIR_NAME}`);
+}
+var legacyMigrationDone = false;
+function ensureLegacyAppHomeMigrated(env = process.env) {
+  if (legacyMigrationDone) return;
+  legacyMigrationDone = true;
+  try {
+    const appHome = getAppHome(env);
+    if (existsSync(appHome)) return;
+    const legacyHome = getLegacyAppHome(env);
+    if (!existsSync(legacyHome)) return;
+    mkdirSync(appHome, { recursive: true, mode: 448 });
+    for (const entry of readdirSync(legacyHome)) {
+      if (entry === "logs") continue;
+      cpSync(join(legacyHome, entry), join(appHome, entry), { recursive: true });
+    }
+  } catch {
+  }
+}
+function getConfigPath(env = process.env) {
+  return join(getAppHome(env), "config.json");
+}
+function getProvidersPath(env = process.env) {
+  return join(getAppHome(env), "providers.json");
+}
+function getLogsPath(env = process.env) {
+  return join(getAppHome(env), "logs");
+}
+
+// src/server-runtime.ts
+function getServerRuntimePath(env = process.env) {
+  return join2(getAppHome(env), "server-runtime.json");
+}
+function isPort(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 65535;
+}
+function parseServerRuntimeState(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const record = parsed;
+  const mode = record["mode"];
+  if (mode !== "endpoint" && mode !== "proxy") return null;
+  if (!isPort(record["port"])) return null;
+  const pid = record["pid"];
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return null;
+  const startedAt = typeof record["startedAt"] === "string" ? record["startedAt"] : "";
+  const caPath = record["caPath"];
+  if (mode === "proxy") {
+    if (typeof caPath !== "string" || !caPath.trim()) return null;
+    return { mode, port: record["port"], pid, caPath, startedAt };
+  }
+  return { mode, port: record["port"], pid, startedAt };
+}
+function isPidAlive(pid, kill = process.kill.bind(process)) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function writeServerRuntimeState(state, env = process.env) {
+  try {
+    const path = getServerRuntimePath(env);
+    mkdirSync2(dirname(path), { recursive: true, mode: 448 });
+    writeFileSync(path, `${JSON.stringify(state, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  } catch {
+  }
+}
+function removeServerRuntimeState(env = process.env) {
+  try {
+    rmSync(getServerRuntimePath(env), { force: true });
+  } catch {
+  }
+}
+function readLiveServerRuntimeState(env = process.env, options = {}) {
+  let raw;
+  try {
+    raw = readFileSync(getServerRuntimePath(env), "utf8");
+  } catch {
+    return null;
+  }
+  const state = parseServerRuntimeState(raw);
+  if (!state) return null;
+  const alive = options.isAlive ?? isPidAlive;
+  return alive(state.pid) ? state : null;
+}
+
+// src/config.ts
+import { dirname as dirname2 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+function readJsonFile(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readConfig() {
+  ensureLegacyAppHomeMigrated();
+  return readJsonFile(getConfigPath()) ?? {};
+}
+function writeConfig(config) {
+  const configPath = getConfigPath();
+  mkdirSync3(dirname2(configPath), { recursive: true, mode: 448 });
+  writeFileSync2(configPath, `${JSON.stringify(config, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+}
+function loadPreferences() {
+  const config = readConfig();
+  return {
+    lastModel: config.lastModel,
+    lastProvider: config.lastProvider,
+    recentModelsByProvider: config.recentModelsByProvider,
+    favoriteModels: config.favoriteModels,
+    modelAliases: config.modelAliases,
+    claudeBridgeMode: config.claudeBridgeMode,
+    serverBridgeMode: config.serverBridgeMode,
+    appPathOverrides: config.appPathOverrides,
+    recentLaunchFolders: config.recentLaunchFolders,
+    server: config.server
+  };
+}
+function savePreferences(prefs) {
+  const config = readConfig();
+  if (prefs.lastModel !== void 0) config.lastModel = prefs.lastModel;
+  if (prefs.lastProvider !== void 0) config.lastProvider = prefs.lastProvider;
+  if (prefs.recentModelsByProvider !== void 0) config.recentModelsByProvider = prefs.recentModelsByProvider;
+  if (prefs.favoriteModels !== void 0) config.favoriteModels = prefs.favoriteModels;
+  if (prefs.modelAliases !== void 0) config.modelAliases = prefs.modelAliases;
+  if (prefs.claudeBridgeMode !== void 0) config.claudeBridgeMode = prefs.claudeBridgeMode;
+  if (prefs.serverBridgeMode !== void 0) config.serverBridgeMode = prefs.serverBridgeMode;
+  if (prefs.appPathOverrides !== void 0) config.appPathOverrides = prefs.appPathOverrides;
+  if (prefs.recentLaunchFolders !== void 0) config.recentLaunchFolders = prefs.recentLaunchFolders;
+  writeConfig(config);
+}
+function getAppPathOverride(appId) {
+  const value = loadPreferences().appPathOverrides?.[appId];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function resolveBridgeMode(command, explicit, opts = {}) {
+  const key = command === "claude" ? "claudeBridgeMode" : "serverBridgeMode";
+  if (explicit) {
+    if (opts.persist === true) savePreferences({ [key]: explicit });
+    return explicit;
+  }
+  return loadPreferences()[key] ?? "proxy";
+}
+var MAX_RECENT_MODELS = 3;
+function recordLaunchSelection(_agent, providerId, modelId, prefs) {
+  const prevRecent = prefs.recentModelsByProvider?.[providerId] ?? [];
+  const updatedRecent = [modelId, ...prevRecent.filter((id) => id !== modelId)].slice(0, MAX_RECENT_MODELS);
+  savePreferences({
+    lastProvider: providerId,
+    lastModel: modelId,
+    recentModelsByProvider: { ...prefs.recentModelsByProvider, [providerId]: updatedRecent }
+  });
+}
+var SERVER_PASSWORD_SERVICE = "clodex-server-password";
+var SERVER_PASSWORD_ACCOUNT = "server-password";
+async function getServerPasswordKeyring() {
+  try {
+    const { Entry } = await import("@napi-rs/keyring");
+    return new Entry(SERVER_PASSWORD_SERVICE, SERVER_PASSWORD_ACCOUNT);
+  } catch {
+    return null;
+  }
+}
+async function getSavedServerPassword() {
+  const config = readConfig();
+  if (config.server?.savedPassword) {
+    const pwd = config.server.savedPassword;
+    const keyring2 = await getServerPasswordKeyring();
+    if (keyring2) {
+      try {
+        await keyring2.setPassword(pwd);
+        delete config.server.savedPassword;
+        if (Object.keys(config.server).length === 0) delete config.server;
+        writeConfig(config);
+      } catch {
+      }
+    }
+    return pwd;
+  }
+  const keyring = await getServerPasswordKeyring();
+  if (keyring) {
+    try {
+      return await keyring.getPassword();
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function setSavedServerPassword(password) {
+  const keyring = await getServerPasswordKeyring();
+  if (keyring) {
+    try {
+      await keyring.setPassword(password);
+      return;
+    } catch {
+    }
+  }
+  const config = readConfig();
+  config.server = {
+    ...config.server ?? {},
+    savedPassword: password
+  };
+  writeConfig(config);
+}
+function getServerExposedProviders() {
+  const list = readConfig().server?.exposedProviders;
+  return list && list.length > 0 ? list : null;
+}
+function setServerExposedProviders(providerIds) {
+  const config = readConfig();
+  config.server = {
+    ...config.server ?? {},
+    exposedProviders: providerIds
+  };
+  writeConfig(config);
+}
+function getServerMaskGatewayIds() {
+  return readConfig().server?.maskGatewayIds ?? true;
+}
+function setServerMaskGatewayIds(mask) {
+  const config = readConfig();
+  config.server = {
+    ...config.server ?? {},
+    maskGatewayIds: mask
+  };
+  writeConfig(config);
+}
+function getServerFavoritesOnly() {
+  return readConfig().server?.favoritesOnly ?? false;
+}
+function setServerFavoritesOnly(favoritesOnly) {
+  const config = readConfig();
+  config.server = {
+    ...config.server ?? {},
+    favoritesOnly
+  };
+  writeConfig(config);
+}
+function getServerListenMode() {
+  return readConfig().server?.listenMode === "network" ? "network" : "local";
+}
+function setServerListenMode(listenMode) {
+  const config = readConfig();
+  config.server = {
+    ...config.server ?? {},
+    listenMode
+  };
+  writeConfig(config);
+}
+
+// src/launch.ts
+import { execSync, spawn } from "child_process";
+import { existsSync as existsSync3, appendFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+
+// src/binary-lookup.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+function findBinaryOnPath(name, fallbackPaths, options = {}) {
+  const isWindows2 = options.isWindows ?? process.platform === "win32";
+  const exists = options.exists ?? existsSync2;
+  const runWhich = options.runWhich ?? ((binary, win) => execFileSync(win ? "where.exe" : "which", [binary], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }));
+  try {
+    const lines = runWhich(name, isWindows2).trim().split("\n").map((line) => line.trim()).filter(Boolean);
+    const path = (isWindows2 ? lines.find((line) => line.toLowerCase().endsWith(".cmd")) : null) ?? lines[0];
+    if (path && (!options.verifyWhichResult || exists(path))) return path;
+  } catch {
+  }
+  for (const path of fallbackPaths) {
+    if (exists(path)) return path;
+  }
+  return null;
+}
+
+// src/launch.ts
+var isWindows = process.platform === "win32";
+var FALLBACK_PATHS = isWindows ? [
+  join3(process.env["APPDATA"] ?? homedir2(), "npm", "claude.cmd"),
+  join3(process.env["APPDATA"] ?? homedir2(), "npm", "claude"),
+  join3(homedir2(), "AppData", "Roaming", "npm", "claude.cmd")
+] : [
+  join3(homedir2(), ".local", "bin", "claude"),
+  join3(homedir2(), ".npm", "bin", "claude"),
+  "/usr/local/bin/claude",
+  "/opt/homebrew/bin/claude"
+];
+function findClaudeBinary() {
+  const environmentOverride = process.env["CLODEX_CLAUDE_PATH"];
+  if (environmentOverride?.trim()) {
+    return existsSync3(environmentOverride) ? environmentOverride : null;
+  }
+  const override = getAppPathOverride("claude");
+  if (override) return existsSync3(override) ? override : null;
+  return findBinaryOnPath("claude", FALLBACK_PATHS);
+}
+function getInstalledClaudeVersion() {
+  try {
+    const claudePath = findClaudeBinary();
+    if (!claudePath) return "2.1.183";
+    const result = execSync(`${isWindows ? `"${claudePath}"` : claudePath} --version`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const match = result.match(/(\d+\.\d+\.\d+)/);
+    if (match) return match[1];
+  } catch {
+  }
+  return "2.1.183";
+}
+function buildClaudeArgs(model, extraArgs) {
+  return model ? ["--model", model, ...extraArgs] : [...extraArgs];
+}
+function launchClaude(env, model, extraArgs) {
+  return new Promise((resolve) => {
+    const claudePath = findClaudeBinary();
+    const args = buildClaudeArgs(model, extraArgs);
+    const debugFileIdx = extraArgs.indexOf("--debug-file");
+    const debugLogPath = debugFileIdx !== -1 && extraArgs[debugFileIdx + 1] ? extraArgs[debugFileIdx + 1] : void 0;
+    const originalStdoutWrite = process.stdout.write;
+    const originalStderrWrite = process.stderr.write;
+    const muteWrite = (chunk, encoding, callback) => {
+      if (typeof encoding === "function") {
+        callback = encoding;
+      }
+      if (debugLogPath) {
+        try {
+          const str = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+          appendFileSync(debugLogPath, `[parent] ${str}`);
+        } catch {
+        }
+      }
+      if (callback) callback();
+      return true;
+    };
+    process.stdout.write = muteWrite;
+    process.stderr.write = muteWrite;
+    const restore = () => {
+      process.stdout.write = originalStdoutWrite;
+      process.stderr.write = originalStderrWrite;
+    };
+    const child = spawn(claudePath, args, {
+      stdio: "inherit",
+      env,
+      shell: isWindows
+    });
+    const forward = (signal) => {
+      child.kill(signal);
+    };
+    process.once("SIGINT", () => forward("SIGINT"));
+    process.once("SIGTERM", () => forward("SIGTERM"));
+    child.on("exit", (code) => {
+      restore();
+      resolve(code ?? 0);
+    });
+    child.on("error", (err) => {
+      restore();
+      resolve(1);
+    });
+  });
+}
+
+export {
+  getAppHome,
+  ensureLegacyAppHomeMigrated,
+  getProvidersPath,
+  getLogsPath,
+  writeServerRuntimeState,
+  removeServerRuntimeState,
+  readLiveServerRuntimeState,
+  loadPreferences,
+  savePreferences,
+  resolveBridgeMode,
+  recordLaunchSelection,
+  getSavedServerPassword,
+  setSavedServerPassword,
+  getServerExposedProviders,
+  setServerExposedProviders,
+  getServerMaskGatewayIds,
+  setServerMaskGatewayIds,
+  getServerFavoritesOnly,
+  setServerFavoritesOnly,
+  getServerListenMode,
+  setServerListenMode,
+  findClaudeBinary,
+  getInstalledClaudeVersion,
+  launchClaude
+};
+//# sourceMappingURL=chunk-C7N2JI7Z.js.map