falconsh 1.0.0

package/dist/cli.js

@@ -0,0 +1,2191 @@
+#!/usr/bin/env node
+// src/cli.ts
+import chalk from "chalk";
+import { Command } from "commander";
+
+// src/agents/claude.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+
+// src/agents/shared/bifrost.ts
+import { spawn } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+// src/utils.ts
+import net from "net";
+function getFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = typeof address === "string" ? 0 : address?.port || 0;
+      server.close(() => {
+        resolve(port);
+      });
+    });
+  });
+}
+function waitForPort(port, timeoutMs = 5e3) {
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    function check() {
+      const socket = new net.Socket();
+      socket.setTimeout(200);
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve();
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        if (Date.now() - start > timeoutMs) {
+          reject(new Error(`Timeout waiting for port ${port}`));
+        } else {
+          setTimeout(check, 100);
+        }
+      });
+      socket.on("timeout", () => {
+        socket.destroy();
+        if (Date.now() - start > timeoutMs) {
+          reject(new Error(`Timeout waiting for port ${port}`));
+        } else {
+          setTimeout(check, 100);
+        }
+      });
+      socket.connect(port, "127.0.0.1");
+    }
+    check();
+  });
+}
+function formatCtx(len) {
+  if (len >= 1e6) return `${(len / 1e6).toFixed(0)}M ctx`;
+  if (len >= 1e3) return `${(len / 1e3).toFixed(0)}k ctx`;
+  return `${len} ctx`;
+}
+function maskString(val) {
+  if (!val) return "";
+  return val.length > 16 ? val.substring(0, 8) + "..." + val.substring(val.length - 4) : val;
+}
+function formatPricePerM(perM) {
+  if (perM === 0) return "free";
+  if (perM < 0.01) return `$${perM.toFixed(4)}/1M`;
+  return `$${perM.toFixed(2)}/1M`;
+}
+function sortModels(a, b) {
+  const createdDiff = (b.created ?? 0) - (a.created ?? 0);
+  if (createdDiff !== 0) return createdDiff;
+  const aPrice = a.pricing?.promptPerM ?? 0;
+  const bPrice = b.pricing?.promptPerM ?? 0;
+  const priceDiff = aPrice - bPrice;
+  if (priceDiff !== 0) return priceDiff;
+  const ctxDiff = (b.contextLength ?? 0) - (a.contextLength ?? 0);
+  if (ctxDiff !== 0) return ctxDiff;
+  return 0;
+}
+
+// src/agents/shared/bifrost.ts
+async function startBifrost(provider, apiKey) {
+  const bifrostPort = await getFreePort();
+  const appDir = fs.mkdtempSync(path.join(os.tmpdir(), "bifrost-app-"));
+  const envKey = provider === "openai" ? "OPENAI_API_KEY" : "ANTHROPIC_API_KEY";
+  const configContent = {
+    providers: {
+      [provider]: {
+        keys: [
+          {
+            name: "default",
+            value: `env.${envKey}`,
+            weight: 1,
+            models: ["*"]
+          }
+        ]
+      }
+    }
+  };
+  fs.writeFileSync(path.join(appDir, "config.json"), JSON.stringify(configContent, null, 2));
+  const logFile = fs.openSync(path.join(appDir, "bifrost.log"), "a");
+  const proc = spawn(
+    "npx",
+    ["--no-install", "bifrost", "-port", String(bifrostPort), "-app-dir", appDir],
+    {
+      env: { ...process.env, [envKey]: apiKey },
+      detached: true,
+      stdio: ["ignore", logFile, logFile]
+    }
+  );
+  proc.unref();
+  const cleanup = () => {
+    if (proc) {
+      try {
+        if (proc.pid) {
+          process.kill(-proc.pid, "SIGTERM");
+        } else {
+          proc.kill();
+        }
+      } catch (_) {
+        try {
+          proc.kill();
+        } catch (__) {
+        }
+      }
+    }
+    try {
+      fs.rmSync(appDir, { recursive: true, force: true });
+    } catch (_) {
+    }
+  };
+  try {
+    await waitForPort(bifrostPort, 15e3);
+  } catch (err) {
+    if (fs.existsSync(path.join(appDir, "bifrost.log"))) {
+      try {
+        const logs = fs.readFileSync(path.join(appDir, "bifrost.log"), "utf8");
+        console.error(`\x1B[33mBifrost Startup Logs:
+${logs}\x1B[0m`);
+      } catch (_) {
+      }
+    }
+    cleanup();
+    throw err;
+  }
+  return {
+    port: bifrostPort,
+    appDir,
+    proc,
+    cleanup
+  };
+}
+
+// src/constants.ts
+import os2 from "os";
+import path2 from "path";
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+var DEFAULT_OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_OPENROUTER_ANTHROPIC_BASE_URL = "https://openrouter.ai/api";
+var DEFAULT_CLOUDFLARE_BASE_URL = "https://gateway.ai.cloudflare.com/v1";
+var PROVIDER_HOST_MAPPINGS = {
+  "api.openai.com": "OpenAI Official",
+  "api.anthropic.com": "Anthropic Official"
+};
+var ENV_FALCON_DIR = "FALCON_DIR";
+var ENV_CLAUDE_CONFIG_DIR = "CLAUDE_CONFIG_DIR";
+var ENV_CODEX_HOME = "CODEX_HOME";
+var ENV_FALCON_CONFIG_FILE = "FALCON_CONFIG_FILE";
+var DEFAULT_FALCON_DIR = path2.join(os2.homedir(), ".falcon");
+
+// src/agents/claude.ts
+var ClaudeLauncher = class {
+  name = "Claude Code";
+  slug = "claude";
+  async resolveConfig(gatewayConfig, gatewaySlug, apiKey, model, options) {
+    const env = { ...gatewayConfig.env };
+    let cleanup;
+    if (gatewaySlug === "openai") {
+      if (options?.dryRun) {
+        env["ANTHROPIC_BASE_URL"] = "http://localhost:<BIFROST_PORT>/anthropic";
+        env["ANTHROPIC_API_KEY"] = apiKey;
+      } else {
+        const bifrost = await startBifrost("openai", apiKey);
+        env["ANTHROPIC_BASE_URL"] = `http://localhost:${bifrost.port}/anthropic`;
+        env["ANTHROPIC_API_KEY"] = apiKey;
+        cleanup = bifrost.cleanup;
+      }
+    }
+    const baseUrl = env["ANTHROPIC_BASE_URL"];
+    const isOfficialAnthropic = baseUrl === DEFAULT_ANTHROPIC_BASE_URL || baseUrl === `${DEFAULT_ANTHROPIC_BASE_URL}/` || baseUrl === `${DEFAULT_ANTHROPIC_BASE_URL}/v1` || baseUrl === `${DEFAULT_ANTHROPIC_BASE_URL}/v1/`;
+    if (isOfficialAnthropic) {
+      delete env["ANTHROPIC_AUTH_TOKEN"];
+    } else {
+      env["ANTHROPIC_AUTH_TOKEN"] = env["ANTHROPIC_API_KEY"];
+      env["ANTHROPIC_API_KEY"] = "";
+    }
+    env["CLAUDE_CODE_ATTRIBUTION_HEADER"] = "0";
+    env["DISABLE_TELEMETRY"] = "1";
+    env["CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"] = "1";
+    env["DISABLE_ERROR_REPORTING"] = "1";
+    env["CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY"] = "1";
+    if (model) {
+      env["ANTHROPIC_DEFAULT_OPUS_MODEL"] = model;
+      env["ANTHROPIC_DEFAULT_SONNET_MODEL"] = model;
+      env["ANTHROPIC_DEFAULT_HAIKU_MODEL"] = model;
+      env["CLAUDE_CODE_SUBAGENT_MODEL"] = model;
+    }
+    const falconDir = process.env[ENV_FALCON_DIR] || DEFAULT_FALCON_DIR;
+    const claudeDir = process.env[ENV_CLAUDE_CONFIG_DIR] || path3.join(falconDir, this.slug);
+    env[ENV_CLAUDE_CONFIG_DIR] = claudeDir;
+    if (!options?.dryRun) {
+      if (!fs2.existsSync(claudeDir)) {
+        fs2.mkdirSync(claudeDir, { recursive: true, mode: 448 });
+      }
+    }
+    return {
+      env,
+      cleanup
+    };
+  }
+  buildSpawnConfig(resolvedConfig, model, extraArgs) {
+    const args = [];
+    if (model) {
+      args.push("--model", model);
+    }
+    args.push("--dangerously-skip-permissions");
+    args.push(...extraArgs);
+    return {
+      command: "claude",
+      args,
+      env: resolvedConfig.env,
+      cleanup: resolvedConfig.cleanup
+    };
+  }
+};
+
+// src/agents/codex.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+var CodexLauncher = class {
+  name = "Codex";
+  slug = "codex";
+  async resolveConfig(gatewayConfig, gatewaySlug, apiKey, model, options) {
+    const env = { ...gatewayConfig.env };
+    let baseUrl = gatewayConfig.baseUrl;
+    let cleanup;
+    if (gatewaySlug === "anthropic") {
+      if (options?.dryRun) {
+        baseUrl = "http://localhost:<BIFROST_PORT>/openai";
+        env["OPENAI_BASE_URL"] = baseUrl;
+        env["OPENAI_API_KEY"] = apiKey;
+      } else {
+        const bifrost = await startBifrost("anthropic", apiKey);
+        baseUrl = `http://localhost:${bifrost.port}/openai`;
+        env["OPENAI_BASE_URL"] = baseUrl;
+        env["OPENAI_API_KEY"] = apiKey;
+        cleanup = bifrost.cleanup;
+      }
+    }
+    const codexDir = this.getCodexDir();
+    env[ENV_CODEX_HOME] = codexDir;
+    if (model) {
+      try {
+        ensureCodexConfig(codexDir, model, baseUrl, env["OPENAI_BASE_URL"]);
+      } catch (err) {
+        console.error(
+          `Warning: Failed to configure Codex: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    }
+    return {
+      env,
+      baseUrl,
+      cleanup
+    };
+  }
+  buildSpawnConfig(resolvedConfig, model, extraArgs) {
+    const codexDir = this.getCodexDir();
+    const catalogPath = path4.join(codexDir, "model.json");
+    const args = ["--profile", "falcon"];
+    if (model) {
+      args.push("-c", `model_catalog_json=${catalogPath}`);
+      args.push("-m", model);
+    }
+    args.push(...extraArgs);
+    return {
+      command: "codex",
+      args,
+      env: resolvedConfig.env,
+      cleanup: resolvedConfig.cleanup
+    };
+  }
+  getCodexDir() {
+    const falconDir = process.env[ENV_FALCON_DIR] || DEFAULT_FALCON_DIR;
+    return process.env[ENV_CODEX_HOME] || path4.join(falconDir, this.slug);
+  }
+};
+function getContextWindow(modelName) {
+  const name = modelName.toLowerCase();
+  if (name.includes("claude-3")) {
+    return 2e5;
+  }
+  if (name.includes("gpt-4o") || name.includes("gpt-4-turbo") || name.includes("gpt-4")) {
+    return 128e3;
+  }
+  if (name.includes("gpt-3.5")) {
+    return 16385;
+  }
+  if (name.includes("gemini-1.5") || name.includes("gemini-2.0") || name.includes("gemini-2.5")) {
+    return 1e6;
+  }
+  return 128e3;
+}
+function getModalities(modelName) {
+  const name = modelName.toLowerCase();
+  const hasVision = name.includes("vision") || name.includes("gpt-4o") || name.includes("claude-3") || name.includes("gemini");
+  const modalities = ["text"];
+  if (hasVision) {
+    modalities.push("image");
+  }
+  return modalities;
+}
+function writeCodexModelCatalog(catalogPath, modelName) {
+  let catalog = { models: [] };
+  if (fs3.existsSync(catalogPath)) {
+    try {
+      const data = fs3.readFileSync(catalogPath, "utf8");
+      const parsed = JSON.parse(data);
+      if (parsed && Array.isArray(parsed.models)) {
+        catalog = parsed;
+      }
+    } catch (_e) {
+    }
+  }
+  const contextWindow = getContextWindow(modelName);
+  const modalities = getModalities(modelName);
+  const truncationMode = modelName.includes("/") ? "tokens" : "bytes";
+  const entry = {
+    slug: modelName,
+    display_name: modelName,
+    context_window: contextWindow,
+    shell_type: "default",
+    visibility: "list",
+    supported_in_api: true,
+    priority: 0,
+    truncation_policy: { mode: truncationMode, limit: 1e4 },
+    input_modalities: modalities,
+    base_instructions: "",
+    support_verbosity: true,
+    default_verbosity: "low",
+    supports_parallel_tool_calls: false,
+    supports_reasoning_summaries: false,
+    supported_reasoning_levels: [],
+    experimental_supported_tools: []
+  };
+  const existingIndex = catalog.models.findIndex((m) => m.slug === modelName);
+  if (existingIndex !== -1) {
+    catalog.models[existingIndex] = entry;
+  } else {
+    catalog.models.push(entry);
+  }
+  fs3.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2), "utf8");
+}
+function upsertSection(text, header, lines) {
+  const fileLines = text.split(/\r?\n/);
+  const targetHeader = header.trim();
+  let startIndex = -1;
+  let endIndex = -1;
+  for (let i = 0; i < fileLines.length; i++) {
+    const trimmed = fileLines[i].trim();
+    if (trimmed === targetHeader) {
+      startIndex = i;
+      for (let j = i + 1; j < fileLines.length; j++) {
+        const nextTrimmed = fileLines[j].trim();
+        if (nextTrimmed.startsWith("[") && nextTrimmed.endsWith("]")) {
+          endIndex = j;
+          break;
+        }
+      }
+      if (endIndex === -1) {
+        endIndex = fileLines.length;
+      }
+      break;
+    }
+  }
+  const blockLines = [targetHeader, ...lines, ""];
+  if (startIndex !== -1) {
+    fileLines.splice(startIndex, endIndex - startIndex, ...blockLines);
+  } else {
+    if (fileLines.length > 0 && fileLines[fileLines.length - 1].trim() !== "") {
+      fileLines.push("");
+    }
+    fileLines.push(...blockLines);
+  }
+  return fileLines.join("\n");
+}
+function ensureCodexConfig(codexDir, modelName, resolvedBaseUrl, envBaseUrl) {
+  if (!fs3.existsSync(codexDir)) {
+    fs3.mkdirSync(codexDir, { recursive: true, mode: 448 });
+  }
+  const configPath = path4.join(codexDir, "config.toml");
+  const catalogPath = path4.join(codexDir, "model.json");
+  writeCodexModelCatalog(catalogPath, modelName);
+  let baseUrl = resolvedBaseUrl || envBaseUrl || process.env["OPENAI_BASE_URL"] || DEFAULT_OPENAI_BASE_URL;
+  if (!baseUrl.endsWith("/")) {
+    baseUrl += "/";
+  }
+  let text = "";
+  if (fs3.existsSync(configPath)) {
+    try {
+      text = fs3.readFileSync(configPath, "utf8");
+    } catch (_e) {
+    }
+  }
+  const profileName = "falcon";
+  let providerKey = "falcon";
+  if (resolvedBaseUrl) {
+    try {
+      const urlStr = resolvedBaseUrl.includes("://") ? resolvedBaseUrl : `http://${resolvedBaseUrl}`;
+      const sanitizedUrlStr = urlStr.replace("<BIFROST_PORT>", "9999");
+      const parsedUrl = new URL(sanitizedUrlStr);
+      if (parsedUrl.hostname) {
+        providerKey = parsedUrl.hostname.replaceAll(".", "-");
+      }
+    } catch (_e) {
+    }
+  }
+  const profileLines = [
+    `model = "${modelName}"`,
+    `model_provider = "${providerKey}"`,
+    `forced_login_method = "api"`,
+    `model_catalog_json = "${catalogPath}"`
+  ];
+  const providerLines = [
+    `name = "${providerKey}"`,
+    `base_url = "${baseUrl}"`,
+    `wire_api = "responses"`
+  ];
+  text = upsertSection(text, `[profiles.${profileName}]`, profileLines);
+  text = upsertSection(text, `[model_providers.${providerKey}]`, providerLines);
+  text = upsertSection(text, `[analytics]`, [`enabled = false`]);
+  text = upsertSection(text, `[feedback]`, [`enabled = false`]);
+  fs3.writeFileSync(configPath, text, "utf8");
+  return catalogPath;
+}
+
+// src/agents/index.ts
+var ALL_AGENTS = [new CodexLauncher(), new ClaudeLauncher()];
+function findAgent(name) {
+  return ALL_AGENTS.find(
+    (a) => a.slug === name.toLowerCase() || a.name.toLowerCase() === name.toLowerCase()
+  );
+}
+
+// src/gateways/shared/modelEnricher.ts
+function normalizeModelId(id) {
+  let normalized = id.toLowerCase();
+  const parts = normalized.split("/");
+  normalized = parts[parts.length - 1] || normalized;
+  normalized = normalized.split(":")[0] || normalized;
+  normalized = normalized.replace(/-latest$/, "");
+  normalized = normalized.replace(/-\d{4}-\d{2}-\d{2}$/, "");
+  normalized = normalized.replace(/-\d{8}$/, "");
+  normalized = normalized.replace(/-\d{4}$/, "");
+  normalized = normalized.replace(/-latest$/, "");
+  normalized = normalized.replace(/[._]/g, "-");
+  normalized = normalized.replace(/-+/g, "-");
+  return normalized.trim();
+}
+var metadataCache = null;
+async function fetchModelMetadataCatalog() {
+  if (metadataCache) {
+    return metadataCache;
+  }
+  if (process.env.NODE_ENV === "test") {
+    return {};
+  }
+  const cache = {};
+  try {
+    const res = await fetch("https://openrouter.ai/api/v1/models");
+    if (!res.ok) return cache;
+    const data = await res.json();
+    for (const m of data.data) {
+      if (!m.id) continue;
+      const parts = m.id.split("/");
+      const strippedId = parts[1] || parts[0] || m.id;
+      const contextLength = m.context_length ?? 0;
+      const promptRaw = parseFloat(m.pricing?.prompt ?? "0");
+      const completionRaw = parseFloat(m.pricing?.completion ?? "0");
+      const promptPerM = promptRaw * 1e6;
+      const completionPerM = completionRaw * 1e6;
+      const metadata = {
+        contextLength,
+        pricing: {
+          prompt: formatPricePerM(promptPerM),
+          completion: formatPricePerM(completionPerM),
+          promptPerM
+        }
+      };
+      const fullId = m.id.toLowerCase();
+      cache[fullId] = metadata;
+      const key1 = strippedId.toLowerCase();
+      cache[key1] = metadata;
+      const normId = normalizeModelId(m.id);
+      cache[normId] = metadata;
+      const key2 = key1.replace(/\./g, "-");
+      if (key2 !== key1) {
+        cache[key2] = metadata;
+      }
+    }
+    metadataCache = cache;
+  } catch {
+  }
+  return cache;
+}
+function enrichModelWithCatalog(model, catalog) {
+  if (model.contextLength && model.pricing) {
+    return model;
+  }
+  const id = model.id.toLowerCase();
+  const idNormalized = normalizeModelId(id);
+  const match = catalog[id] || catalog[idNormalized];
+  if (match) {
+    const updated = { ...model };
+    if (!updated.contextLength) {
+      updated.contextLength = match.contextLength;
+    }
+    if (!updated.pricing) {
+      updated.pricing = match.pricing;
+    }
+    return updated;
+  }
+  return model;
+}
+function enrichModelInfo(model) {
+  return enrichModelWithCatalog(model, metadataCache || {});
+}
+
+// src/gateways/anthropic.ts
+var AnthropicGateway = class {
+  name = "Anthropic";
+  slug = "anthropic";
+  detectKey() {
+    return process.env["ANTHROPIC_API_KEY"];
+  }
+  async listModels(apiKey) {
+    try {
+      await fetchModelMetadataCatalog();
+    } catch {
+    }
+    const baseUrl = process.env.ANTHROPIC_BASE_URL || DEFAULT_ANTHROPIC_BASE_URL;
+    let url = baseUrl;
+    if (!url.includes("/v1") && !url.includes("/v2")) {
+      url = url.endsWith("/") ? `${url}v1/models` : `${url}/v1/models`;
+    } else {
+      url = url.endsWith("/") ? `${url}models` : `${url}/models`;
+    }
+    const res = await fetch(url, {
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`Anthropic API error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.data.map(
+      (m) => enrichModelInfo({
+        id: m.id,
+        name: m.display_name || m.id,
+        contextLength: m.context_window,
+        provider: "Anthropic"
+      })
+    ).sort(sortModels);
+  }
+  getEnvConfig(apiKey, _model) {
+    return {
+      env: {
+        ANTHROPIC_API_KEY: apiKey,
+        ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL || DEFAULT_ANTHROPIC_BASE_URL
+      }
+    };
+  }
+};
+
+// src/gateways/cloudflare.ts
+var CloudflareGateway = class {
+  name = "Cloudflare AI Gateway";
+  slug = "cloudflare";
+  detectKey() {
+    return process.env["CLOUDFLARE_API_KEY"] || process.env["CF_API_KEY"];
+  }
+  getAccountId() {
+    return process.env["CLOUDFLARE_ACCOUNT_ID"] || process.env["CF_ACCOUNT_ID"] || "";
+  }
+  getGatewayId() {
+    return process.env["CLOUDFLARE_GATEWAY_ID"] || process.env["CF_GATEWAY_ID"] || "default";
+  }
+  async listModels(_apiKey) {
+    return [
+      { id: "gpt-4o", name: "GPT-4o (via CF Gateway)", provider: "Cloudflare" },
+      { id: "gpt-4o-mini", name: "GPT-4o Mini (via CF Gateway)", provider: "Cloudflare" },
+      {
+        id: "claude-sonnet-4-20250514",
+        name: "Claude Sonnet 4 (via CF Gateway)",
+        provider: "Cloudflare"
+      },
+      {
+        id: "claude-3-5-haiku-20241022",
+        name: "Claude 3.5 Haiku (via CF Gateway)",
+        provider: "Cloudflare"
+      }
+    ];
+  }
+  getEnvConfig(apiKey, _model) {
+    const accountId = this.getAccountId();
+    const gatewayId = this.getGatewayId();
+    const baseUrl = accountId ? `https://gateway.ai.cloudflare.com/v1/${accountId}/${gatewayId}/openai` : DEFAULT_CLOUDFLARE_BASE_URL;
+    return {
+      env: {
+        OPENAI_API_KEY: apiKey,
+        OPENAI_BASE_URL: baseUrl
+      },
+      baseUrl
+    };
+  }
+};
+
+// src/gateways/openai.ts
+var OpenAIGateway = class {
+  name = "OpenAI";
+  slug = "openai";
+  detectKey() {
+    return process.env["OPENAI_API_KEY"];
+  }
+  async listModels(apiKey) {
+    try {
+      await fetchModelMetadataCatalog();
+    } catch {
+    }
+    const baseUrl = process.env.OPENAI_BASE_URL || DEFAULT_OPENAI_BASE_URL;
+    let url = baseUrl;
+    if (!url.includes("/v1") && !url.includes("/v2")) {
+      url = url.endsWith("/") ? `${url}v1/models` : `${url}/v1/models`;
+    } else {
+      url = url.endsWith("/") ? `${url}models` : `${url}/models`;
+    }
+    const res = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`OpenAI API error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    const useful = data.data.filter((m) => {
+      const id = m.id.toLowerCase();
+      return id.includes("gpt") || id.includes("o1") || id.includes("o3") || id.includes("o4") || id.includes("codex") || id.startsWith("chatgpt");
+    }).map(
+      (m) => enrichModelInfo({
+        id: m.id,
+        name: m.id,
+        provider: "OpenAI"
+      })
+    ).sort(sortModels);
+    return useful;
+  }
+  getEnvConfig(apiKey, _model) {
+    const config = {
+      env: {
+        OPENAI_API_KEY: apiKey
+      }
+    };
+    if (process.env.OPENAI_BASE_URL) {
+      config.env.OPENAI_BASE_URL = process.env.OPENAI_BASE_URL;
+    }
+    return config;
+  }
+};
+
+// src/gateways/openrouter.ts
+var OpenRouterGateway = class {
+  name = "OpenRouter";
+  slug = "openrouter";
+  detectKey() {
+    return process.env["OPENROUTER_API_KEY"];
+  }
+  async listModels(apiKey) {
+    const res = await fetch(`${DEFAULT_OPENROUTER_BASE_URL}/models`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`OpenRouter API error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.data.filter((m) => m.id && m.name).map((m) => {
+      const promptRaw = parseFloat(m.pricing?.prompt ?? "0");
+      const completionRaw = parseFloat(m.pricing?.completion ?? "0");
+      const promptPerM = promptRaw * 1e6;
+      const completionPerM = completionRaw * 1e6;
+      return {
+        id: m.id,
+        name: m.name,
+        contextLength: m.context_length,
+        pricing: m.pricing ? {
+          prompt: formatPricePerM(promptPerM),
+          completion: formatPricePerM(completionPerM),
+          promptPerM
+        } : void 0,
+        provider: "OpenRouter",
+        created: m.created
+      };
+    }).sort(sortModels);
+  }
+  getEnvConfig(apiKey, _model) {
+    return {
+      env: {
+        OPENROUTER_API_KEY: apiKey,
+        OPENAI_API_KEY: apiKey,
+        OPENAI_BASE_URL: DEFAULT_OPENROUTER_BASE_URL,
+        ANTHROPIC_API_KEY: apiKey,
+        ANTHROPIC_BASE_URL: DEFAULT_OPENROUTER_ANTHROPIC_BASE_URL
+      },
+      baseUrl: DEFAULT_OPENROUTER_BASE_URL
+    };
+  }
+};
+
+// src/config.ts
+import crypto from "crypto";
+import fs4 from "fs";
+import os3 from "os";
+import path5 from "path";
+var ALGORITHM = "aes-256-cbc";
+function getFalconDir() {
+  return process.env[ENV_FALCON_DIR] || DEFAULT_FALCON_DIR;
+}
+function getConfigFile() {
+  return process.env[ENV_FALCON_CONFIG_FILE] || path5.join(getFalconDir(), "config.json");
+}
+function getEncryptionKey() {
+  let userIdentifier = "falcon-default-user";
+  try {
+    userIdentifier = os3.userInfo().username;
+  } catch {
+  }
+  const rawKeyMaterial = [
+    os3.platform(),
+    os3.hostname(),
+    os3.homedir(),
+    userIdentifier,
+    "falcon-secure-salt-2026"
+  ].join(":");
+  return crypto.createHash("sha256").update(rawKeyMaterial).digest();
+}
+function encrypt(text) {
+  const iv = crypto.randomBytes(16);
+  const key = getEncryptionKey();
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(text, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  return {
+    iv: iv.toString("hex"),
+    data: encrypted
+  };
+}
+function decrypt(encryptedData, ivHex) {
+  const iv = Buffer.from(ivHex, "hex");
+  const key = getEncryptionKey();
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+  let decrypted = decipher.update(encryptedData, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function loadFalconConfigV2() {
+  const configFile = getConfigFile();
+  try {
+    if (fs4.existsSync(configFile)) {
+      const raw = fs4.readFileSync(configFile, "utf8").trim();
+      if (!raw) return { version: 2, gateways: [] };
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") {
+        let decryptedJson = null;
+        if (parsed.encrypted === true && typeof parsed.data === "string" && typeof parsed.iv === "string") {
+          try {
+            const decryptedText = decrypt(parsed.data, parsed.iv);
+            decryptedJson = JSON.parse(decryptedText);
+          } catch {
+            return { version: 2, gateways: [] };
+          }
+        } else {
+          decryptedJson = parsed;
+        }
+        if (decryptedJson && typeof decryptedJson === "object") {
+          const obj = decryptedJson;
+          if (obj.version === 2 && Array.isArray(obj.gateways)) {
+            return decryptedJson;
+          } else {
+            const gateways = [];
+            const flat = decryptedJson;
+            if (flat.OPENROUTER_API_KEY) {
+              gateways.push({
+                id: "migrated-openrouter",
+                gatewaySlug: "openrouter",
+                fields: { OPENROUTER_API_KEY: flat.OPENROUTER_API_KEY }
+              });
+            }
+            if (flat.OPENAI_API_KEY) {
+              gateways.push({
+                id: "migrated-openai",
+                gatewaySlug: "openai",
+                fields: {
+                  OPENAI_API_KEY: flat.OPENAI_API_KEY,
+                  OPENAI_BASE_URL: flat.OPENAI_BASE_URL || ""
+                }
+              });
+            }
+            if (flat.ANTHROPIC_API_KEY) {
+              gateways.push({
+                id: "migrated-anthropic",
+                gatewaySlug: "anthropic",
+                fields: {
+                  ANTHROPIC_API_KEY: flat.ANTHROPIC_API_KEY,
+                  ANTHROPIC_BASE_URL: flat.ANTHROPIC_BASE_URL || ""
+                }
+              });
+            }
+            const cfKey = flat.CLOUDFLARE_API_KEY || flat.CF_API_KEY;
+            if (cfKey) {
+              gateways.push({
+                id: "migrated-cloudflare",
+                gatewaySlug: "cloudflare",
+                fields: {
+                  CLOUDFLARE_API_KEY: cfKey,
+                  CLOUDFLARE_ACCOUNT_ID: flat.CLOUDFLARE_ACCOUNT_ID || flat.CF_ACCOUNT_ID || "",
+                  CLOUDFLARE_GATEWAY_ID: flat.CLOUDFLARE_GATEWAY_ID || flat.CF_GATEWAY_ID || ""
+                }
+              });
+            }
+            const migratedConfig = { version: 2, gateways };
+            saveFalconConfigV2(migratedConfig);
+            return migratedConfig;
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return { version: 2, gateways: [] };
+}
+function saveFalconConfigV2(config) {
+  const falconDir = getFalconDir();
+  const configFile = getConfigFile();
+  try {
+    if (!fs4.existsSync(falconDir)) {
+      fs4.mkdirSync(falconDir, { recursive: true });
+    }
+    const plainText = JSON.stringify(config);
+    const encrypted = encrypt(plainText);
+    const payload = {
+      version: 2,
+      encrypted: true,
+      iv: encrypted.iv,
+      data: encrypted.data
+    };
+    fs4.writeFileSync(configFile, JSON.stringify(payload, null, 2), "utf8");
+  } catch {
+  }
+}
+
+// src/gateways/index.ts
+var ALL_GATEWAYS = [
+  new OpenRouterGateway(),
+  new OpenAIGateway(),
+  new AnthropicGateway(),
+  new CloudflareGateway()
+];
+function getGatewayInstanceLabel(gatewaySlug, fields) {
+  if (gatewaySlug === "openai") {
+    const baseUrl = fields.OPENAI_BASE_URL || DEFAULT_OPENAI_BASE_URL;
+    try {
+      const url = baseUrl.includes("://") ? baseUrl : `http://${baseUrl}`;
+      const parsed = new URL(url);
+      if (PROVIDER_HOST_MAPPINGS[parsed.host]) {
+        return PROVIDER_HOST_MAPPINGS[parsed.host];
+      }
+      return `OpenAI@${parsed.host}`;
+    } catch {
+      return `OpenAI@${baseUrl}`;
+    }
+  }
+  if (gatewaySlug === "anthropic") {
+    const baseUrl = fields.ANTHROPIC_BASE_URL || DEFAULT_ANTHROPIC_BASE_URL;
+    try {
+      const url = baseUrl.includes("://") ? baseUrl : `http://${baseUrl}`;
+      const parsed = new URL(url);
+      if (PROVIDER_HOST_MAPPINGS[parsed.host]) {
+        return PROVIDER_HOST_MAPPINGS[parsed.host];
+      }
+      return `Anthropic@${parsed.host}`;
+    } catch {
+      return `Anthropic@${baseUrl}`;
+    }
+  }
+  if (gatewaySlug === "openrouter") {
+    return "OpenRouter";
+  }
+  if (gatewaySlug === "cloudflare") {
+    const accountId = fields.CLOUDFLARE_ACCOUNT_ID || fields.CF_ACCOUNT_ID;
+    return accountId ? `Cloudflare@${accountId}` : "Cloudflare AI Gateway";
+  }
+  const gw = ALL_GATEWAYS.find((g) => g.slug === gatewaySlug);
+  return gw ? gw.name : gatewaySlug;
+}
+function detectGatewayInstances() {
+  const instances = [];
+  if (process.env.OPENROUTER_API_KEY) {
+    const gw = ALL_GATEWAYS.find((g) => g.slug === "openrouter");
+    instances.push({
+      id: "env-openrouter",
+      gateway: gw,
+      name: "OpenRouter",
+      apiKey: process.env.OPENROUTER_API_KEY,
+      fields: { OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY },
+      isEnv: true
+    });
+  }
+  if (process.env.OPENAI_API_KEY) {
+    const gw = ALL_GATEWAYS.find((g) => g.slug === "openai");
+    const fields = {
+      OPENAI_API_KEY: process.env.OPENAI_API_KEY
+    };
+    if (process.env.OPENAI_BASE_URL) {
+      fields.OPENAI_BASE_URL = process.env.OPENAI_BASE_URL;
+    }
+    instances.push({
+      id: "env-openai",
+      gateway: gw,
+      name: getGatewayInstanceLabel("openai", fields),
+      apiKey: process.env.OPENAI_API_KEY,
+      fields,
+      isEnv: true
+    });
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    const gw = ALL_GATEWAYS.find((g) => g.slug === "anthropic");
+    const fields = {
+      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY
+    };
+    if (process.env.ANTHROPIC_BASE_URL) {
+      fields.ANTHROPIC_BASE_URL = process.env.ANTHROPIC_BASE_URL;
+    }
+    instances.push({
+      id: "env-anthropic",
+      gateway: gw,
+      name: getGatewayInstanceLabel("anthropic", fields),
+      apiKey: process.env.ANTHROPIC_API_KEY,
+      fields,
+      isEnv: true
+    });
+  }
+  const cfKey = process.env.CLOUDFLARE_API_KEY || process.env.CF_API_KEY;
+  if (cfKey) {
+    const gw = ALL_GATEWAYS.find((g) => g.slug === "cloudflare");
+    const fields = {
+      CLOUDFLARE_API_KEY: cfKey
+    };
+    const cfAcc = process.env.CLOUDFLARE_ACCOUNT_ID || process.env.CF_ACCOUNT_ID;
+    if (cfAcc) fields.CLOUDFLARE_ACCOUNT_ID = cfAcc;
+    const cfGw = process.env.CLOUDFLARE_GATEWAY_ID || process.env.CF_GATEWAY_ID;
+    if (cfGw) fields.CLOUDFLARE_GATEWAY_ID = cfGw;
+    instances.push({
+      id: "env-cloudflare",
+      gateway: gw,
+      name: getGatewayInstanceLabel("cloudflare", fields),
+      apiKey: cfKey,
+      fields,
+      isEnv: true
+    });
+  }
+  const config = loadFalconConfigV2();
+  for (const gwConfig of config.gateways) {
+    const gw = ALL_GATEWAYS.find((g) => g.slug === gwConfig.gatewaySlug);
+    if (gw) {
+      let apiKey = "";
+      if (gwConfig.gatewaySlug === "openrouter") {
+        apiKey = gwConfig.fields.OPENROUTER_API_KEY || "";
+      } else if (gwConfig.gatewaySlug === "openai") {
+        apiKey = gwConfig.fields.OPENAI_API_KEY || "";
+      } else if (gwConfig.gatewaySlug === "anthropic") {
+        apiKey = gwConfig.fields.ANTHROPIC_API_KEY || "";
+      } else if (gwConfig.gatewaySlug === "cloudflare") {
+        apiKey = gwConfig.fields.CLOUDFLARE_API_KEY || "";
+      }
+      instances.push({
+        id: gwConfig.id,
+        gateway: gw,
+        name: getGatewayInstanceLabel(gwConfig.gatewaySlug, gwConfig.fields),
+        apiKey,
+        fields: gwConfig.fields
+      });
+    }
+  }
+  return instances;
+}
+function withGatewayEnv(instance, fn) {
+  const keysToSave = [
+    "OPENAI_API_KEY",
+    "OPENAI_BASE_URL",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_BASE_URL",
+    "CLOUDFLARE_API_KEY",
+    "CF_API_KEY",
+    "CLOUDFLARE_ACCOUNT_ID",
+    "CF_ACCOUNT_ID",
+    "CLOUDFLARE_GATEWAY_ID",
+    "CF_GATEWAY_ID",
+    "OPENROUTER_API_KEY"
+  ];
+  const saved = {};
+  for (const k of keysToSave) {
+    saved[k] = process.env[k];
+    delete process.env[k];
+  }
+  for (const [k, v] of Object.entries(instance.fields)) {
+    if (v !== void 0) {
+      process.env[k] = v;
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    for (const k of keysToSave) {
+      if (saved[k] !== void 0) {
+        process.env[k] = saved[k];
+      } else {
+        delete process.env[k];
+      }
+    }
+  }
+}
+async function withGatewayEnvAsync(instance, fn) {
+  const keysToSave = [
+    "OPENAI_API_KEY",
+    "OPENAI_BASE_URL",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_BASE_URL",
+    "CLOUDFLARE_API_KEY",
+    "CF_API_KEY",
+    "CLOUDFLARE_ACCOUNT_ID",
+    "CF_ACCOUNT_ID",
+    "CLOUDFLARE_GATEWAY_ID",
+    "CF_GATEWAY_ID",
+    "OPENROUTER_API_KEY"
+  ];
+  const saved = {};
+  for (const k of keysToSave) {
+    saved[k] = process.env[k];
+    delete process.env[k];
+  }
+  for (const [k, v] of Object.entries(instance.fields)) {
+    if (v !== void 0) {
+      process.env[k] = v;
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    for (const k of keysToSave) {
+      if (saved[k] !== void 0) {
+        process.env[k] = saved[k];
+      } else {
+        delete process.env[k];
+      }
+    }
+  }
+}
+
+// src/ui/App.tsx
+import { spawn as spawn2 } from "child_process";
+import { Box as Box7, render, Text as Text7, useApp } from "ink";
+import React, { useCallback, useEffect, useState as useState5 } from "react";
+
+// src/recents.ts
+import fs5 from "fs";
+import path6 from "path";
+function getFalconDir2() {
+  return process.env[ENV_FALCON_DIR] || DEFAULT_FALCON_DIR;
+}
+function getRecentsFile() {
+  return path6.join(getFalconDir2(), "recents.json");
+}
+var MAX_RECENTS = 5;
+function readRecents() {
+  try {
+    const raw = fs5.readFileSync(getRecentsFile(), "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function writeRecents(entries) {
+  const falconDir = getFalconDir2();
+  try {
+    if (!fs5.existsSync(falconDir)) {
+      fs5.mkdirSync(falconDir, { recursive: true });
+    }
+    fs5.writeFileSync(getRecentsFile(), JSON.stringify(entries, null, 2), "utf8");
+  } catch {
+  }
+}
+function recordRecentModel(model) {
+  const entries = readRecents().filter((e) => e.id !== model.id);
+  entries.unshift({
+    id: model.id,
+    name: model.name,
+    contextLength: model.contextLength,
+    pricing: model.pricing,
+    provider: model.provider,
+    lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeRecents(entries.slice(0, MAX_RECENTS));
+}
+function getRecentModels() {
+  return readRecents().map((e) => ({
+    id: e.id,
+    name: e.name,
+    contextLength: e.contextLength,
+    pricing: e.pricing,
+    provider: e.provider
+  }));
+}
+
+// src/ui/GatewayPicker.tsx
+import { Box, Text, useInput } from "ink";
+import { useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function GatewayPicker({
+  instances,
+  onAdd,
+  onDelete,
+  onUpdate,
+  onBack
+}) {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [message, setMessage] = useState(null);
+  useInput((input, key) => {
+    if (input === "a" || input === "A") {
+      onAdd();
+      return;
+    }
+    if (key.escape) {
+      onBack();
+      return;
+    }
+    if (instances.length === 0) {
+      return;
+    }
+    const highlighted = instances[selectedIndex];
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+      setMessage(null);
+    } else if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(instances.length - 1, prev + 1));
+      setMessage(null);
+    } else if (key.return) {
+      onBack();
+    } else if (input === "d" || input === "D") {
+      if (highlighted) {
+        if (highlighted.isEnv) {
+          setMessage("Cannot delete system environment gateways.");
+        } else {
+          onDelete(highlighted);
+          setSelectedIndex((prev) => Math.max(0, prev - 1));
+          setMessage(`Deleted gateway: ${highlighted.name}`);
+        }
+      }
+    } else if (input === "u" || input === "U") {
+      if (highlighted) {
+        if (highlighted.isEnv) {
+          setMessage("Cannot update system environment gateways.");
+        } else {
+          onUpdate(highlighted);
+        }
+      }
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "\u{1F985} Falcon Gateway Manager" }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Manage your API key configurations and providers." }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: instances.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "yellow", children: "No active gateways. Press 'a' to add one." }) : instances.map((inst, i) => {
+      const isSelected = i === selectedIndex;
+      const maskedKey = inst.apiKey ? inst.apiKey.substring(0, 8) + "..." + inst.apiKey.substring(inst.apiKey.length - 4) : "None";
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: isSelected ? "cyan" : "white", children: isSelected ? "\u276F " : "  " }),
+        /* @__PURE__ */ jsx(Text, { color: isSelected ? "cyan" : "white", bold: isSelected, children: inst.name }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          " (",
+          maskedKey,
+          ")"
+        ] }),
+        inst.isEnv && /* @__PURE__ */ jsxs(Text, { color: "magenta", bold: true, children: [
+          " ",
+          "[Env] [read-only]"
+        ] })
+      ] }, inst.id);
+    }) }),
+    message && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "yellow", bold: true, children: message }) }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \u2022 a add new gateway \u2022 Esc/Enter back" }),
+      instances.length > 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: "d delete selected \u2022 u update selected" })
+    ] })
+  ] });
+}
+
+// src/ui/Header.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var FALCON_LOGO = `
+  \u256D\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\u256E
+  \u2502  \u{1F985}  F A L C O N               \u2502
+  \u2502     Multi-Gateway Agent Runner  \u2502
+  \u2570\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\u256F`;
+function Header({ agent }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Text2, { color: "magenta", bold: true, children: FALCON_LOGO }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, marginLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { children: [
+      "Agent:",
+      " ",
+      /* @__PURE__ */ jsx2(Text2, { bold: true, color: "green", children: agent.name }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " \u2022 v0.1.0" })
+    ] }) })
+  ] });
+}
+
+// src/ui/LaunchConfirm.tsx
+import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function LaunchConfirm({ agent, gateway, model, onConfirm, onCancel }) {
+  useInput2((_input, key) => {
+    if (key.return) {
+      onConfirm();
+    } else if (key.escape) {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2713" }),
+      " Connected to",
+      " ",
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: gateway.name })
+    ] }),
+    /* @__PURE__ */ jsxs3(
+      Box3,
+      {
+        marginTop: 1,
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "magenta",
+        paddingX: 2,
+        paddingY: 1,
+        children: [
+          /* @__PURE__ */ jsx3(Text3, { bold: true, color: "white", children: "Launch Configuration" }),
+          /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs3(Box3, { children: [
+              /* @__PURE__ */ jsx3(Box3, { width: 14, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Agent:" }) }),
+              /* @__PURE__ */ jsx3(Text3, { bold: true, color: "green", children: agent.name })
+            ] }),
+            /* @__PURE__ */ jsxs3(Box3, { children: [
+              /* @__PURE__ */ jsx3(Box3, { width: 14, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Gateway:" }) }),
+              /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: gateway.name })
+            ] }),
+            /* @__PURE__ */ jsxs3(Box3, { children: [
+              /* @__PURE__ */ jsx3(Box3, { width: 14, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Model:" }) }),
+              /* @__PURE__ */ jsx3(Text3, { bold: true, color: "yellow", children: model.name })
+            ] }),
+            /* @__PURE__ */ jsxs3(Box3, { children: [
+              /* @__PURE__ */ jsx3(Box3, { width: 14, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Model ID:" }) }),
+              /* @__PURE__ */ jsx3(Text3, { color: "gray", children: model.id })
+            ] }),
+            model.contextLength && /* @__PURE__ */ jsxs3(Box3, { children: [
+              /* @__PURE__ */ jsx3(Box3, { width: 14, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Context:" }) }),
+              /* @__PURE__ */ jsx3(Text3, { children: formatContextLength(model.contextLength) })
+            ] }),
+            model.pricing && /* @__PURE__ */ jsxs3(Box3, { children: [
+              /* @__PURE__ */ jsx3(Box3, { width: 14, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Pricing:" }) }),
+              /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
+                model.pricing.prompt,
+                " in / ",
+                model.pricing.completion,
+                " out"
+              ] })
+            ] })
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "Enter" }),
+      " ",
+      "to launch \u2022",
+      " ",
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", bold: true, children: "Esc" }),
+      " ",
+      "to go back"
+    ] }) })
+  ] });
+}
+function formatContextLength(len) {
+  if (len >= 1e6) return `${(len / 1e6).toFixed(1)}M tokens`;
+  if (len >= 1e3) return `${(len / 1e3).toFixed(0)}k tokens`;
+  return `${len} tokens`;
+}
+
+// src/ui/ModelPicker.tsx
+import { Box as Box4, Text as Text4, useInput as useInput3 } from "ink";
+import { useMemo, useState as useState2 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var PAGE_SIZE = 12;
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: (m + 1) * (n + 1) }, () => 0);
+  const idx = (i, j) => i * (n + 1) + j;
+  for (let i = 0; i <= m; i++) dp[idx(i, 0)] = i;
+  for (let j = 0; j <= n; j++) dp[idx(0, j)] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[idx(i, j)] = dp[idx(i - 1, j - 1)];
+      } else {
+        dp[idx(i, j)] = 1 + Math.min(
+          dp[idx(i - 1, j)],
+          // deletion
+          dp[idx(i, j - 1)],
+          // insertion
+          dp[idx(i - 1, j - 1)]
+          // substitution
+        );
+      }
+    }
+  }
+  return dp[idx(m, n)] ?? 0;
+}
+function fuzzyMatch(query, target) {
+  const q = query.toLowerCase();
+  const t = target.toLowerCase();
+  if (!q) return true;
+  if (t.includes(q)) return true;
+  const threshold = Math.min(3, Math.floor(q.length / 4));
+  if (threshold === 0) return false;
+  const winLen = q.length;
+  for (let start = 0; start <= t.length - winLen; start++) {
+    const window = t.slice(start, start + winLen);
+    if (levenshtein(q, window) <= threshold) return true;
+  }
+  return levenshtein(q, t) <= threshold;
+}
+function modelMatchesQuery(model, query) {
+  if (!query) return true;
+  return fuzzyMatch(query, model.name) || fuzzyMatch(query, model.id) || !!model.provider && fuzzyMatch(query, model.provider);
+}
+function ModelPicker({
+  models,
+  recentModels = [],
+  onSelect,
+  onCancel,
+  onConfigure,
+  showGatewayBadge
+}) {
+  const [searchQuery, setSearchQuery] = useState2("");
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const recentIds = useMemo(() => new Set(recentModels.map((m) => m.id)), [recentModels]);
+  const filteredModels = useMemo(() => {
+    if (!searchQuery) {
+      const rest = models.filter((m) => !recentIds.has(m.id));
+      return [...recentModels, ...rest];
+    }
+    return models.filter((m) => modelMatchesQuery(m, searchQuery));
+  }, [models, recentModels, recentIds, searchQuery]);
+  const safeIndex = Math.min(selectedIndex, Math.max(0, filteredModels.length - 1));
+  const scrollOffset = Math.max(0, safeIndex - PAGE_SIZE + 3);
+  const visibleModels = filteredModels.slice(scrollOffset, scrollOffset + PAGE_SIZE);
+  useInput3((input, key) => {
+    if (onConfigure && key.ctrl && input === "g") {
+      onConfigure();
+      return;
+    }
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      if (filteredModels.length > 0) {
+        const model = filteredModels[safeIndex];
+        if (model) {
+          onSelect(model);
+        }
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(filteredModels.length - 1, prev + 1));
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setSearchQuery((prev) => prev.slice(0, -1));
+      setSelectedIndex(0);
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      setSearchQuery((prev) => prev + input);
+      setSelectedIndex(0);
+    }
+  });
+  const hasRecents = !searchQuery && recentModels.length > 0;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "cyan", bold: true, children: [
+        "\u276F",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Search: " }),
+      /* @__PURE__ */ jsx4(Text4, { color: "white", bold: true, children: searchQuery || "" }),
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", children: searchQuery ? "" : "(type to filter)" })
+    ] }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, flexDirection: "column", children: filteredModels.length === 0 ? /* @__PURE__ */ jsxs4(Text4, { color: "yellow", children: [
+      'No models match "',
+      searchQuery,
+      '"'
+    ] }) : visibleModels.map((model, i) => {
+      const actualIndex = scrollOffset + i;
+      const isSelected = actualIndex === safeIndex;
+      const isRecentItem = hasRecents && recentIds.has(model.id);
+      const showRecentsHeader = hasRecents && actualIndex === 0;
+      const showDivider = hasRecents && actualIndex === recentModels.length && filteredModels.length > recentModels.length;
+      return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+        showRecentsHeader && /* @__PURE__ */ jsxs4(Text4, { color: "yellow", dimColor: true, children: [
+          " ",
+          "Recently used"
+        ] }),
+        showDivider && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\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" }),
+        /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { color: isSelected ? "cyan" : "white", children: isSelected ? "\u276F " : "  " }),
+          /* @__PURE__ */ jsxs4(Box4, { width: 65, flexDirection: "row", children: [
+            /* @__PURE__ */ jsx4(
+              Text4,
+              {
+                color: isSelected ? "cyan" : isRecentItem ? "yellow" : "white",
+                bold: isSelected,
+                children: model.name.length > 40 ? model.name.substring(0, 37) + "..." : model.name
+              }
+            ),
+            showGatewayBadge && model.gatewayInstance && /* @__PURE__ */ jsxs4(Text4, { color: "gray", children: [
+              " (",
+              model.gatewayInstance.name,
+              ")"
+            ] })
+          ] }),
+          model.contextLength && /* @__PURE__ */ jsx4(Box4, { width: 12, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: formatContextLength2(model.contextLength) }) }),
+          model.pricing && /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { color: "green", dimColor: true, children: model.pricing.prompt }) })
+        ] })
+      ] }, model.id + "-" + actualIndex);
+    }) }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      filteredModels.length,
+      " model",
+      filteredModels.length !== 1 ? "s" : "",
+      " \u2022 \u2191\u2193 navigate \u2022 Enter select \u2022 Esc cancel",
+      onConfigure ? " \u2022 Ctrl+G configure" : ""
+    ] }) }),
+    filteredModels.length > PAGE_SIZE && /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "Showing ",
+      scrollOffset + 1,
+      "-",
+      Math.min(scrollOffset + PAGE_SIZE, filteredModels.length),
+      " of",
+      " ",
+      filteredModels.length
+    ] })
+  ] });
+}
+function formatContextLength2(len) {
+  if (len >= 1e6) return `${(len / 1e6).toFixed(0)}M ctx`;
+  if (len >= 1e3) return `${(len / 1e3).toFixed(0)}k ctx`;
+  return `${len} ctx`;
+}
+
+// src/ui/ConfigureGatewayPicker.tsx
+import { Box as Box5, Text as Text5, useInput as useInput4 } from "ink";
+import { useState as useState3 } from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function ConfigureGatewayPicker({ onSelect, onCancel, title }) {
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  useInput4((_input, key) => {
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(ALL_GATEWAYS.length - 1, prev + 1));
+    } else if (key.return) {
+      const selected = ALL_GATEWAYS[selectedIndex];
+      if (selected) {
+        onSelect(selected);
+      }
+    } else if (key.escape) {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { color: "yellow", bold: true, children: title || "No API keys detected. Select a provider to configure:" }),
+    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginTop: 1, children: ALL_GATEWAYS.map((gw, i) => {
+      const isSelected = i === selectedIndex;
+      return /* @__PURE__ */ jsxs5(Box5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: isSelected ? "cyan" : "white", children: isSelected ? "\u276F " : "  " }),
+        /* @__PURE__ */ jsx5(Text5, { color: isSelected ? "cyan" : "white", bold: isSelected, children: gw.name })
+      ] }, gw.slug);
+    }) }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2191\u2193 navigate \u2022 Enter select \u2022 Esc exit" }) })
+  ] });
+}
+
+// src/ui/ConfigureGatewayInput.tsx
+import { Box as Box6, Text as Text6, useInput as useInput5 } from "ink";
+import TextInput from "ink-text-input";
+import { useState as useState4 } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var CONFIG_FIELDS = {
+  openrouter: [{ label: "OpenRouter API Key", envVar: "OPENROUTER_API_KEY", mask: true }],
+  openai: [
+    { label: "OpenAI API Key", envVar: "OPENAI_API_KEY", mask: true },
+    {
+      label: "OpenAI Base URL",
+      envVar: "OPENAI_BASE_URL",
+      defaultValue: DEFAULT_OPENAI_BASE_URL,
+      optional: true
+    }
+  ],
+  anthropic: [
+    { label: "Anthropic API Key", envVar: "ANTHROPIC_API_KEY", mask: true },
+    {
+      label: "Anthropic Base URL",
+      envVar: "ANTHROPIC_BASE_URL",
+      defaultValue: DEFAULT_ANTHROPIC_BASE_URL,
+      optional: true
+    }
+  ],
+  cloudflare: [
+    { label: "Cloudflare API Key", envVar: "CLOUDFLARE_API_KEY", mask: true },
+    { label: "Cloudflare Account ID", envVar: "CLOUDFLARE_ACCOUNT_ID" },
+    { label: "Cloudflare Gateway ID", envVar: "CLOUDFLARE_GATEWAY_ID", defaultValue: "default" }
+  ]
+};
+function ConfigureGatewayInput({
+  gateway,
+  editingInstance,
+  onConfigured,
+  onCancel
+}) {
+  const fields = CONFIG_FIELDS[gateway.slug] || [
+    {
+      label: `${gateway.name} API Key`,
+      envVar: `${gateway.slug.toUpperCase()}_API_KEY`,
+      mask: true
+    }
+  ];
+  const [fieldIndex, setFieldIndex] = useState4(0);
+  const [values, setValues] = useState4(() => {
+    if (editingInstance) {
+      return { ...editingInstance.fields };
+    }
+    return {};
+  });
+  const [currentVal, setCurrentVal] = useState4(() => {
+    const currentField2 = fields[0];
+    if (editingInstance && currentField2) {
+      return editingInstance.fields[currentField2.envVar] || currentField2.defaultValue || "";
+    }
+    return currentField2?.defaultValue || "";
+  });
+  const [isValidating, setIsValidating] = useState4(false);
+  const [validationError, setValidationError] = useState4(null);
+  useInput5((_input, key) => {
+    if (key.escape) {
+      onCancel();
+    }
+  });
+  const currentField = fields[fieldIndex];
+  const handleSubmit = async (val) => {
+    if (!currentField || isValidating) {
+      return;
+    }
+    const trimmed = val.trim();
+    if (!trimmed && !currentField.optional && !currentField.defaultValue) {
+      return;
+    }
+    const finalVal = trimmed || "";
+    const newValues = { ...values, [currentField.envVar]: finalVal };
+    setValues(newValues);
+    if (fieldIndex < fields.length - 1) {
+      const nextIndex = fieldIndex + 1;
+      setFieldIndex(nextIndex);
+      const nextField = fields[nextIndex];
+      const nextVal = (editingInstance ? newValues[nextField.envVar] : void 0) ?? nextField?.defaultValue ?? "";
+      setCurrentVal(nextVal);
+    } else {
+      setIsValidating(true);
+      setValidationError(null);
+      let apiKey = "";
+      if (gateway.slug === "openrouter") {
+        apiKey = newValues.OPENROUTER_API_KEY || "";
+      } else if (gateway.slug === "openai") {
+        apiKey = newValues.OPENAI_API_KEY || "";
+      } else if (gateway.slug === "anthropic") {
+        apiKey = newValues.ANTHROPIC_API_KEY || "";
+      } else if (gateway.slug === "cloudflare") {
+        apiKey = newValues.CLOUDFLARE_API_KEY || "";
+      }
+      try {
+        await withGatewayEnvAsync({ fields: newValues }, async () => {
+          await gateway.listModels(apiKey);
+        });
+        setIsValidating(false);
+        onConfigured(newValues);
+      } catch (err) {
+        setIsValidating(false);
+        setValidationError(err instanceof Error ? err.message : String(err));
+        setFieldIndex(0);
+        const firstField = fields[0];
+        setCurrentVal(newValues[firstField.envVar] || firstField.defaultValue || "");
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: editingInstance ? `Updating ${editingInstance.name}` : `Configuring ${gateway.name}` }),
+    fields.slice(0, fieldIndex).map((f) => {
+      const val = values[f.envVar] || "";
+      const displayVal = val ? f.mask ? val.substring(0, 8) + "..." + val.substring(val.length - 4) : val : "<default>";
+      return /* @__PURE__ */ jsxs6(Box6, { marginTop: 0.5, marginLeft: 2, children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713 " }),
+        /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+          f.label,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx6(Text6, { color: "white", children: displayVal })
+      ] }, f.envVar);
+    }),
+    !isValidating && currentField && /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [
+      /* @__PURE__ */ jsxs6(Text6, { bold: true, children: [
+        "Enter ",
+        currentField.label,
+        ": ",
+        currentField.optional ? "(optional)" : ""
+      ] }),
+      currentField.defaultValue && /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        "Default: ",
+        currentField.defaultValue
+      ] }),
+      /* @__PURE__ */ jsx6(Box6, { borderStyle: "single", borderColor: "cyan", paddingX: 1, marginTop: 0.5, width: 60, children: /* @__PURE__ */ jsx6(
+        TextInput,
+        {
+          value: currentVal,
+          onChange: setCurrentVal,
+          onSubmit: handleSubmit,
+          showCursor: true,
+          placeholder: currentField.defaultValue,
+          mask: currentField.mask ? "*" : void 0
+        }
+      ) })
+    ] }),
+    isValidating && /* @__PURE__ */ jsx6(Box6, { marginTop: 1, marginLeft: 2, flexDirection: "column", children: /* @__PURE__ */ jsx6(Text6, { color: "yellow", bold: true, children: "\u280B Validating connection with gateway API..." }) }),
+    validationError && /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, marginLeft: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "red", bold: true, children: "\u2716 Validation Error:" }),
+      /* @__PURE__ */ jsx6(Text6, { color: "red", children: validationError })
+    ] }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, marginLeft: 2, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Enter to submit \u2022 Esc to cancel" }) })
+  ] });
+}
+
+// src/ui/App.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function App({ agent, preselectedModel, preselectedGateway, extraArgs }) {
+  const { exit } = useApp();
+  const [state, setState] = useState5({ phase: "detect" });
+  const [recentModels] = useState5(() => getRecentModels());
+  const normalizedPreselectedGateway = preselectedGateway?.toLowerCase();
+  const launchAgent = useCallback(
+    async (gateway, model) => {
+      recordRecentModel(model);
+      setState({ phase: "launching", gateway, model });
+      const config = gateway.gateway.getEnvConfig(gateway.apiKey, model.id);
+      let resolved;
+      try {
+        resolved = await withGatewayEnvAsync({ fields: gateway.fields }, async () => {
+          return await agent.resolveConfig(config, gateway.gateway.slug, gateway.apiKey, model.id);
+        });
+      } catch (err) {
+        console.error(
+          `\x1B[31mFailed to resolve config: ${err instanceof Error ? err.message : err}\x1B[0m`
+        );
+        process.exit(1);
+      }
+      const spawnConfig = withGatewayEnv({ fields: gateway.fields }, () => {
+        return agent.buildSpawnConfig(resolved, model.id, extraArgs);
+      });
+      const cleanUp = () => {
+        if (spawnConfig.cleanup) {
+          try {
+            spawnConfig.cleanup();
+          } catch (_) {
+          }
+        }
+      };
+      const handleSignalDuringLaunch = () => {
+        cleanUp();
+        process.exit(1);
+      };
+      process.on("SIGINT", handleSignalDuringLaunch);
+      process.on("SIGTERM", handleSignalDuringLaunch);
+      process.on("exit", cleanUp);
+      setTimeout(() => {
+        exit();
+        setTimeout(() => {
+          process.off("SIGINT", handleSignalDuringLaunch);
+          process.off("SIGTERM", handleSignalDuringLaunch);
+          const ignoreSignal = () => {
+          };
+          process.on("SIGINT", ignoreSignal);
+          process.on("SIGTERM", ignoreSignal);
+          const proc = spawn2(spawnConfig.command, spawnConfig.args, {
+            stdio: "inherit",
+            env: { ...process.env, ...gateway.fields, ...spawnConfig.env }
+          });
+          proc.on("error", (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`\x1B[31mFailed to launch ${agent.name}: ${message}\x1B[0m`);
+            process.off("SIGINT", ignoreSignal);
+            process.off("SIGTERM", ignoreSignal);
+            cleanUp();
+            process.exit(1);
+          });
+          proc.on("exit", (code) => {
+            process.off("SIGINT", ignoreSignal);
+            process.off("SIGTERM", ignoreSignal);
+            cleanUp();
+            process.exit(code ?? 0);
+          });
+        }, 100);
+      }, 800);
+    },
+    [agent, extraArgs, exit]
+  );
+  useEffect(() => {
+    if (state.phase !== "detect") return;
+    const instances = detectGatewayInstances();
+    if (instances.length === 0) {
+      if (normalizedPreselectedGateway) {
+        const matchGateway = ALL_GATEWAYS.find((g) => g.slug === normalizedPreselectedGateway);
+        if (matchGateway) {
+          setState({ phase: "configure-gateway-input", gateway: matchGateway });
+          return;
+        }
+      }
+      setState({ phase: "configure-gateway-list" });
+      return;
+    }
+    if (normalizedPreselectedGateway) {
+      const match = instances.find(
+        (inst) => inst.gateway.slug === normalizedPreselectedGateway || inst.name.toLowerCase() === normalizedPreselectedGateway
+      );
+      if (match) {
+        if (preselectedModel) {
+          launchAgent(match, { id: preselectedModel, name: preselectedModel });
+          return;
+        }
+        setState({ phase: "loading-models", instances: [match] });
+        return;
+      }
+    }
+    if (preselectedModel && instances.length > 0) {
+      const match = instances[0];
+      if (match) {
+        launchAgent(match, { id: preselectedModel, name: preselectedModel });
+        return;
+      }
+    }
+    setState({ phase: "loading-models", instances });
+  }, [launchAgent, normalizedPreselectedGateway, preselectedModel, state.phase]);
+  useEffect(() => {
+    if (state.phase !== "loading-models") return;
+    const { instances } = state;
+    const promises = instances.map(async (inst) => {
+      try {
+        const models = await withGatewayEnvAsync({ fields: inst.fields }, async () => {
+          return await inst.gateway.listModels(inst.apiKey);
+        });
+        return models.map((m) => ({
+          ...m,
+          gatewayInstance: inst
+        }));
+      } catch {
+        return [];
+      }
+    });
+    Promise.all(promises).then((results) => {
+      const allModels = results.flat();
+      if (allModels.length === 0) {
+        setState({
+          phase: "error",
+          message: "Failed to load models from any configured gateways. Please check your configurations."
+        });
+      } else {
+        setState({ phase: "pick-model", instances, models: allModels });
+      }
+    }).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      setState({ phase: "error", message: `Failed to load models: ${message}` });
+    });
+  }, [state]);
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx7(Header, { agent }),
+    state.phase === "detect" && /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: "\u280B" }),
+      " Detecting API keys..."
+    ] }) }),
+    state.phase === "gateway-manager" && /* @__PURE__ */ jsx7(
+      GatewayPicker,
+      {
+        instances: state.instances,
+        onAdd: () => {
+          setState({
+            phase: "configure-gateway-list",
+            title: "Select a provider to configure:"
+          });
+        },
+        onDelete: (instance) => {
+          const config = loadFalconConfigV2();
+          config.gateways = config.gateways.filter((g) => g.id !== instance.id);
+          saveFalconConfigV2(config);
+          const nextInstances = detectGatewayInstances();
+          setState({ phase: "gateway-manager", instances: nextInstances });
+        },
+        onUpdate: (instance) => {
+          setState({
+            phase: "configure-gateway-input",
+            gateway: instance.gateway,
+            editingInstance: instance
+          });
+        },
+        onBack: () => {
+          const current = detectGatewayInstances();
+          if (current.length > 0) {
+            setState({ phase: "detect" });
+          } else {
+            exit();
+          }
+        }
+      }
+    ),
+    state.phase === "configure-gateway-list" && /* @__PURE__ */ jsx7(
+      ConfigureGatewayPicker,
+      {
+        title: state.title,
+        onSelect: (gw) => {
+          setState({
+            phase: "configure-gateway-input",
+            gateway: gw
+          });
+        },
+        onCancel: () => {
+          const detected = detectGatewayInstances();
+          if (detected.length > 0) {
+            setState({ phase: "gateway-manager", instances: detected });
+          } else {
+            exit();
+          }
+        }
+      }
+    ),
+    state.phase === "configure-gateway-input" && /* @__PURE__ */ jsx7(
+      ConfigureGatewayInput,
+      {
+        gateway: state.gateway,
+        editingInstance: state.editingInstance,
+        onConfigured: (newValues) => {
+          const config = loadFalconConfigV2();
+          const inst = state.editingInstance;
+          if (inst) {
+            const existing = config.gateways.find((g) => g.id === inst.id);
+            if (existing) {
+              existing.fields = newValues;
+            }
+          } else {
+            const newInstanceId = `gw-${state.gateway.slug}-${Date.now()}`;
+            config.gateways.push({
+              id: newInstanceId,
+              gatewaySlug: state.gateway.slug,
+              fields: newValues
+            });
+          }
+          saveFalconConfigV2(config);
+          setState({ phase: "detect" });
+        },
+        onCancel: () => {
+          const detected = detectGatewayInstances();
+          if (detected.length > 0) {
+            setState({ phase: "gateway-manager", instances: detected });
+          } else {
+            setState({ phase: "configure-gateway-list" });
+          }
+        }
+      }
+    ),
+    state.phase === "loading-models" && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsx7(Text7, { color: "green", children: "\u2713" }),
+        " Connected to",
+        " ",
+        /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: state.instances.map((inst) => inst.name).join(", ") })
+      ] }),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(LoadingSpinner, { text: "Fetching available models..." }) })
+    ] }),
+    state.phase === "pick-model" && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsx7(Text7, { color: "green", children: "\u2713" }),
+        " Connected to",
+        " ",
+        /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: state.instances.map((inst) => inst.name).join(", ") }),
+        /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          " \u2022 ",
+          state.models.length,
+          " models available"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx7(
+        ModelPicker,
+        {
+          models: state.models,
+          recentModels,
+          showGatewayBadge: state.instances.length > 1,
+          onSelect: (model) => {
+            const targetInstance = model.gatewayInstance || state.instances[0];
+            if (targetInstance) {
+              setState({
+                phase: "confirm",
+                gateway: targetInstance,
+                model,
+                instances: state.instances,
+                models: state.models
+              });
+            }
+          },
+          onCancel: () => exit(),
+          onConfigure: () => {
+            setState({ phase: "gateway-manager", instances: state.instances });
+          }
+        }
+      )
+    ] }),
+    state.phase === "confirm" && /* @__PURE__ */ jsx7(
+      LaunchConfirm,
+      {
+        agent,
+        gateway: { name: state.gateway.name, slug: state.gateway.gateway.slug },
+        model: state.model,
+        onConfirm: () => launchAgent(state.gateway, state.model),
+        onCancel: () => setState({
+          phase: "pick-model",
+          instances: state.instances,
+          models: state.models
+        })
+      }
+    ),
+    state.phase === "launching" && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsx7(Text7, { color: "green", children: "\u2713" }),
+        " Connected to",
+        " ",
+        /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: state.gateway.name })
+      ] }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsx7(Text7, { color: "green", children: "\u2713" }),
+        " Model:",
+        " ",
+        /* @__PURE__ */ jsx7(Text7, { bold: true, color: "yellow", children: state.model.name })
+      ] }),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: "magenta", bold: true, children: [
+        "\u{1F680} Launching ",
+        agent.name,
+        "..."
+      ] }) })
+    ] }),
+    state.phase === "error" && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "red", bold: true, children: "\u2716 Error" }),
+      /* @__PURE__ */ jsx7(Text7, { color: "red", children: state.message }),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Press Ctrl+C to exit" }) })
+    ] })
+  ] });
+}
+function LoadingSpinner({ text }) {
+  const [frame, setFrame] = useState5(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % SPINNER_FRAMES.length);
+    }, 80);
+    return () => clearInterval(timer);
+  }, []);
+  return /* @__PURE__ */ jsxs7(Text7, { children: [
+    /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: SPINNER_FRAMES[frame] }),
+    " ",
+    text
+  ] });
+}
+function renderApp(props) {
+  render(React.createElement(App, props));
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var program = new Command().name("falcon").version(VERSION).description(
+  chalk.magenta("\u{1F985} Falcon") + " \u2014 Launch coding agents with multi-gateway API support"
+);
+async function handleLaunch(agentName, agentArgs, options) {
+  const extraArgs = agentArgs || [];
+  if (!agentName) {
+    console.log(chalk.magenta.bold("\n  \u{1F985} Falcon \u2014 Available Agents\n"));
+    for (const agent2 of ALL_AGENTS) {
+      console.log(`  ${chalk.cyan("\u2022")} ${chalk.bold(agent2.name)} ${chalk.dim(`(${agent2.slug})`)}`);
+    }
+    console.log();
+    console.log(
+      chalk.dim("  Usage: falcon launch <agent> [--model <model>] [--gateway <gateway>]\n")
+    );
+    return;
+  }
+  const agent = findAgent(agentName);
+  if (!agent) {
+    console.error(
+      chalk.red(
+        `Unknown agent: "${agentName}". Available agents: ${ALL_AGENTS.map((a) => a.slug).join(", ")}`
+      )
+    );
+    process.exit(1);
+  }
+  if (options.dryRun) {
+    const detected = detectGatewayInstances();
+    const targetGateway = options.gateway;
+    const gw = targetGateway ? detected.find(
+      (d) => d.gateway.slug === targetGateway || d.name.toLowerCase() === targetGateway.toLowerCase()
+    ) : detected[0];
+    if (!gw) {
+      console.error(chalk.red("No API gateway available for dry run."));
+      process.exit(1);
+    }
+    const model = options.model || "interactive-selection";
+    const config = gw.gateway.getEnvConfig(gw.apiKey, model);
+    const resolved = await withGatewayEnvAsync({ fields: gw.fields }, async () => {
+      return await agent.resolveConfig(config, gw.gateway.slug, gw.apiKey, model, {
+        dryRun: true
+      });
+    });
+    const spawnConfig = withGatewayEnv({ fields: gw.fields }, () => {
+      return agent.buildSpawnConfig(resolved, model, extraArgs);
+    });
+    console.log(chalk.bold("\nDry Run Configuration:\n"));
+    console.log(`  Agent:   ${chalk.green(agent.name)}`);
+    console.log(`  Gateway: ${chalk.cyan(gw.name)}`);
+    console.log(`  Model:   ${chalk.yellow(model)}`);
+    console.log(`  Command: ${chalk.dim(`${spawnConfig.command} ${spawnConfig.args.join(" ")}`)}`);
+    console.log(chalk.bold("\n  Environment:"));
+    for (const [key, value] of Object.entries(spawnConfig.env)) {
+      const masked = maskString(value);
+      console.log(`    ${chalk.dim(key)}=${chalk.dim(masked)}`);
+    }
+    console.log();
+    return;
+  }
+  renderApp({
+    agent,
+    preselectedModel: options.model,
+    preselectedGateway: options.gateway,
+    extraArgs
+  });
+}
+program.command("launch").argument("[agent]", "Agent to launch (codex, claude)").argument("[agentArgs...]", "Arguments to pass to the agent").option("-m, --model <model>", "Model to use").option(
+  "-g, --gateway <gateway>",
+  "API gateway to use (openrouter, openai, anthropic, cloudflare)"
+).option("--dry-run", "Show what would be launched without actually launching").option("--list-gateways", "List detected API gateways and exit").allowUnknownOption(true).description("Launch a coding agent with a specific model via an API gateway").action(
+  async (agentName, agentArgs, options) => {
+    if (options.listGateways) {
+      const detected = detectGatewayInstances();
+      if (detected.length === 0) {
+        console.log(chalk.red("No API keys detected."));
+        console.log(
+          chalk.dim(
+            "Set one of: OPENROUTER_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY, CLOUDFLARE_API_KEY"
+          )
+        );
+        process.exit(1);
+      }
+      console.log(chalk.bold("\nDetected API Gateways:\n"));
+      for (const { name, apiKey, isEnv } of detected) {
+        const masked = maskString(apiKey);
+        const typeStr = isEnv ? chalk.magenta(" [Env] [read-only]") : "";
+        console.log(
+          `  ${chalk.green("\u2713")} ${chalk.bold(name)} ${chalk.dim(`(${masked})`)}${typeStr}`
+        );
+      }
+      console.log();
+      return;
+    }
+    await handleLaunch(agentName, agentArgs, options);
+  }
+);
+for (const agent of ALL_AGENTS) {
+  program.command(agent.slug).argument("[agentArgs...]", "Arguments to pass to the agent").option("-m, --model <model>", "Model to use").option(
+    "-g, --gateway <gateway>",
+    "API gateway to use (openrouter, openai, anthropic, cloudflare)"
+  ).option("--dry-run", "Show what would be launched without actually launching").allowUnknownOption(true).description(`Launch ${agent.name} with a specific model via an API gateway`).action(
+    async (agentArgs, options) => {
+      await handleLaunch(agent.slug, agentArgs, options);
+    }
+  );
+}
+program.command("models").option("-g, --gateway <gateway>", "API gateway to query").description("List available models from detected API gateways").action(async (options) => {
+  const detected = detectGatewayInstances();
+  if (detected.length === 0) {
+    console.error(chalk.red("No API keys detected."));
+    process.exit(1);
+  }
+  const targetGateway = options.gateway;
+  const target = targetGateway ? detected.find(
+    (d) => d.gateway.slug === targetGateway || d.name.toLowerCase() === targetGateway.toLowerCase()
+  ) : detected[0];
+  if (!target) {
+    console.error(chalk.red(`Gateway "${options.gateway}" not found or no key set.`));
+    process.exit(1);
+  }
+  console.log(chalk.dim(`
+Fetching models from ${target.name}...
+`));
+  try {
+    const models = await withGatewayEnvAsync({ fields: target.fields }, async () => {
+      return await target.gateway.listModels(target.apiKey);
+    });
+    console.log(chalk.bold(`${target.name} \u2014 ${models.length} models:
+`));
+    for (const model of models.slice(0, 50)) {
+      const ctx = model.contextLength ? chalk.dim(` (${formatCtx(model.contextLength)})`) : "";
+      const price = model.pricing ? chalk.green(` ${model.pricing.prompt}`) : "";
+      console.log(`  ${chalk.cyan(model.id)}${ctx}${price}`);
+    }
+    if (models.length > 50) {
+      console.log(
+        chalk.dim(
+          `
+  ... and ${models.length - 50} more. Use 'falcon launch' for interactive search.
+`
+        )
+      );
+    }
+    console.log();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`Failed to fetch models: ${message}`));
+    process.exit(1);
+  }
+});
+program.parse();