bridgerapi 1.0.0

package/dist/cli.js

@@ -0,0 +1,701 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/server.ts
+var import_http = require("http");
+var import_crypto = require("crypto");
+
+// src/messages.ts
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p.type === "text").map((p) => p.text ?? "").join(" ");
+  }
+  return String(content ?? "");
+}
+function messagesToPrompt(messages) {
+  const system = [];
+  const turns = [];
+  for (const m of messages) {
+    const text = extractText(m.content).trim();
+    if (!text) continue;
+    if (m.role === "system") {
+      system.push(text);
+    } else if (m.role === "assistant") {
+      turns.push(`Assistant: ${text}`);
+    } else {
+      turns.push(`User: ${text}`);
+    }
+  }
+  const parts = [];
+  if (system.length) parts.push("System instructions:\n" + system.join("\n"));
+  if (turns.length) parts.push(turns.join("\n"));
+  return parts.join("\n\n");
+}
+
+// src/backends.ts
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_os = require("os");
+var HOME = (0, import_os.homedir)();
+function which(cmd2) {
+  try {
+    return (0, import_child_process.execFileSync)("which", [cmd2], { encoding: "utf8" }).trim();
+  } catch {
+    return "";
+  }
+}
+async function* spawnStream(cmd2, args, stdin, env) {
+  const proc = (0, import_child_process.spawn)(cmd2, args, {
+    env: env ?? process.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (stdin) {
+    proc.stdin.end(stdin);
+  }
+  for await (const chunk2 of proc.stdout) {
+    yield chunk2;
+  }
+}
+var ClaudeBackend = class {
+  constructor() {
+    this.name = "claude";
+    this.models = ["claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"];
+    this.prefixes = ["claude"];
+  }
+  get bin() {
+    return process.env.CLAUDE_BIN ?? `${HOME}/.local/bin/claude`;
+  }
+  available() {
+    return (0, import_fs.existsSync)(this.bin) || Boolean(which("claude"));
+  }
+  async runBlocking(prompt, model) {
+    const bin = which("claude") || this.bin;
+    let out;
+    try {
+      out = (0, import_child_process.execFileSync)(bin, ["-p", "--output-format", "json", "--model", model], {
+        input: prompt,
+        encoding: "utf8",
+        timeout: 3e5
+      });
+    } catch (e) {
+      throw new Error(e.stderr?.trim() || `claude exited non-zero`);
+    }
+    const data = JSON.parse(out.trim() || "{}");
+    return [data.result ?? "", data.usage ?? null];
+  }
+  async *stream(prompt, model) {
+    const bin = which("claude") || this.bin;
+    yield* spawnStream(bin, ["-p", "--output-format", "text", "--model", model], prompt);
+  }
+};
+var GeminiBackend = class {
+  constructor() {
+    this.name = "gemini";
+    this.models = ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash", "gemini-1.5-pro"];
+    this.prefixes = ["gemini"];
+  }
+  get bin() {
+    return process.env.GEMINI_BIN ?? which("gemini") ?? "/opt/homebrew/bin/gemini";
+  }
+  available() {
+    return Boolean(which("gemini")) || (0, import_fs.existsSync)(this.bin);
+  }
+  async runBlocking(prompt, model) {
+    const bin = which("gemini") || this.bin;
+    let out;
+    try {
+      out = (0, import_child_process.execFileSync)(
+        bin,
+        ["--output-format", "json", "--model", model, "--approval-mode", "yolo"],
+        { input: prompt, encoding: "utf8", timeout: 3e5, env: process.env }
+      );
+    } catch (e) {
+      const err = e.stderr?.trim() ?? "";
+      if (/auth|login|sign.?in/i.test(err)) {
+        throw new Error(`Gemini not authenticated. Run: gemini auth  OR  export GEMINI_API_KEY=<key>`);
+      }
+      throw new Error(err || `gemini exited non-zero`);
+    }
+    const raw = out.trim();
+    try {
+      const data = JSON.parse(raw);
+      const text = String(data.response ?? data.result ?? data.text ?? raw);
+      const usage = data.tokenCount ?? data.usage ?? null;
+      return [text, usage];
+    } catch {
+      return [raw, null];
+    }
+  }
+  async *stream(prompt, model) {
+    const bin = which("gemini") || this.bin;
+    yield* spawnStream(
+      bin,
+      ["--output-format", "text", "--model", model, "--approval-mode", "yolo"],
+      prompt
+    );
+  }
+};
+var CodexBackend = class {
+  constructor() {
+    this.name = "codex";
+    this.models = ["o3", "o4-mini", "gpt-4.1", "gpt-4o"];
+    this.prefixes = ["gpt", "o3", "o4", "o1"];
+  }
+  get bin() {
+    return process.env.CODEX_BIN ?? which("codex") ?? "codex";
+  }
+  available() {
+    return Boolean(which("codex"));
+  }
+  async runBlocking(prompt, model) {
+    let out;
+    try {
+      out = (0, import_child_process.execFileSync)(this.bin, ["-q", "--model", model, prompt], {
+        encoding: "utf8",
+        timeout: 3e5
+      });
+    } catch (e) {
+      throw new Error(e.stderr?.trim() || `codex exited non-zero`);
+    }
+    return [out.trim(), null];
+  }
+  async *stream(prompt, model) {
+    yield* spawnStream(this.bin, ["-q", "--model", model, prompt]);
+  }
+};
+var CopilotBackend = class {
+  constructor() {
+    this.name = "copilot";
+    this.models = ["copilot", "github-copilot"];
+    this.prefixes = ["copilot", "github-copilot"];
+  }
+  get bin() {
+    return process.env.GH_BIN ?? which("gh") ?? "gh";
+  }
+  available() {
+    if (!which("gh")) return false;
+    try {
+      (0, import_child_process.execFileSync)("gh", ["copilot", "--version"], { encoding: "utf8", stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async runBlocking(prompt, model) {
+    let out;
+    try {
+      out = (0, import_child_process.execFileSync)(this.bin, ["copilot", "suggest", "-t", "general", prompt], {
+        encoding: "utf8",
+        timeout: 12e4
+      });
+    } catch (e) {
+      throw new Error(e.stderr?.trim() || `gh copilot exited non-zero`);
+    }
+    return [out.trim(), null];
+  }
+  async *stream(prompt, model) {
+    yield* spawnStream(this.bin, ["copilot", "suggest", "-t", "general", prompt]);
+  }
+};
+var BACKENDS = [
+  new ClaudeBackend(),
+  new GeminiBackend(),
+  new CodexBackend(),
+  new CopilotBackend()
+];
+function pickBackend(model) {
+  const m = model.toLowerCase();
+  for (const b of BACKENDS) {
+    if (b.prefixes.some((p) => m.startsWith(p))) {
+      if (b.available()) return b;
+    }
+  }
+  return BACKENDS.find((b) => b.available()) ?? BACKENDS[0];
+}
+function allModels() {
+  return BACKENDS.filter((b) => b.available()).flatMap((b) => [...b.models]);
+}
+
+// src/server.ts
+function sse(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function chunk(id, ts, model, delta, finish) {
+  return sse({
+    id,
+    object: "chat.completion.chunk",
+    created: ts,
+    model,
+    choices: [{ index: 0, delta, finish_reason: finish ?? null }]
+  });
+}
+function completion(id, ts, model, text, usage) {
+  const pt = usage ? (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.promptTokenCount ?? 0) : 0;
+  const ct = usage ? (usage.output_tokens ?? 0) + (usage.candidatesTokenCount ?? 0) : 0;
+  return {
+    id,
+    object: "chat.completion",
+    created: ts,
+    model,
+    choices: [{ index: 0, message: { role: "assistant", content: text }, finish_reason: "stop" }],
+    usage: { prompt_tokens: pt, completion_tokens: ct, total_tokens: pt + ct }
+  };
+}
+function cors(res, statusCode) {
+  res.writeHead(statusCode, {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization"
+  });
+}
+function sendJson(res, statusCode, body) {
+  const payload = Buffer.from(JSON.stringify(body));
+  cors(res, statusCode);
+  res.setHeader("Content-Type", "application/json");
+  res.setHeader("Content-Length", payload.byteLength);
+  res.end(payload);
+}
+async function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+function handleModels(res) {
+  const ts = Math.floor(Date.now() / 1e3);
+  sendJson(res, 200, {
+    object: "list",
+    data: allModels().map((id) => ({ id, object: "model", created: ts, owned_by: "bridge" }))
+  });
+}
+function handleHealth(res, port2) {
+  const backends = {};
+  for (const b of BACKENDS) backends[b.name] = b.available();
+  sendJson(res, 200, { status: "ok", port: port2, backends });
+}
+async function handleChat(req, res) {
+  let body;
+  try {
+    body = JSON.parse(await readBody(req));
+  } catch {
+    sendJson(res, 400, { error: { message: "invalid JSON", type: "invalid_request_error" } });
+    return;
+  }
+  const messages = body?.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    sendJson(res, 400, { error: { message: "messages required", type: "invalid_request_error" } });
+    return;
+  }
+  const model = body.model ?? "claude-sonnet-4-6";
+  const streaming = Boolean(body.stream);
+  const prompt = messagesToPrompt(messages);
+  const backend = pickBackend(model);
+  const id = `chatcmpl-${(0, import_crypto.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
+  const ts = Math.floor(Date.now() / 1e3);
+  console.log(`  ${backend.name}  model=${model}  stream=${streaming}  turns=${messages.length}`);
+  if (streaming) {
+    cors(res, 200);
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    res.write(chunk(id, ts, model, { role: "assistant" }));
+    try {
+      for await (const raw of backend.stream(prompt, model)) {
+        res.write(chunk(id, ts, model, { content: raw.toString("utf8") }));
+      }
+    } catch (err) {
+      console.error(`  stream error: ${err.message}`);
+    }
+    res.write(chunk(id, ts, model, {}, "stop"));
+    res.write("data: [DONE]\n\n");
+    res.end();
+  } else {
+    try {
+      const [text, usage] = await backend.runBlocking(prompt, model);
+      sendJson(res, 200, completion(id, ts, model, text, usage));
+    } catch (err) {
+      console.error(`  error: ${err.message}`);
+      sendJson(res, 500, { error: { message: err.message, type: "server_error" } });
+    }
+  }
+}
+function createBridgeServer(port2) {
+  const server = (0, import_http.createServer)(async (req, res) => {
+    const path = (req.url ?? "/").split("?")[0];
+    const method = req.method ?? "GET";
+    if (method === "OPTIONS") {
+      cors(res, 200);
+      res.end();
+      return;
+    }
+    if (method === "GET" && (path === "/v1/models" || path === "/models")) {
+      handleModels(res);
+      return;
+    }
+    if (method === "GET" && path === "/health") {
+      handleHealth(res, port2);
+      return;
+    }
+    if (method === "POST" && (path === "/v1/chat/completions" || path === "/chat/completions")) {
+      await handleChat(req, res);
+      return;
+    }
+    sendJson(res, 404, { error: { message: "not found", type: "not_found_error" } });
+  });
+  return server;
+}
+
+// src/service.ts
+var import_child_process2 = require("child_process");
+var import_fs2 = require("fs");
+var import_os2 = require("os");
+var import_path = require("path");
+var HOME2 = (0, import_os2.homedir)();
+var LABEL = "com.bridgerapi.server";
+function plistPath() {
+  return (0, import_path.join)(HOME2, "Library/LaunchAgents", `${LABEL}.plist`);
+}
+function writePlist(port2, scriptPath, nodePath) {
+  const logDir = (0, import_path.join)(HOME2, ".bridgerapi");
+  (0, import_fs2.mkdirSync)(logDir, { recursive: true });
+  (0, import_fs2.mkdirSync)((0, import_path.join)(HOME2, "Library/LaunchAgents"), { recursive: true });
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${scriptPath}</string>
+    <string>start</string>
+  </array>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>BRIDGERAPI_PORT</key>
+    <string>${port2}</string>
+    <key>PATH</key>
+    <string>${HOME2}/.local/bin:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+    <key>HOME</key>
+    <string>${HOME2}</string>
+    <key>CUSTOM_OKBRIDGER_API_KEY</key>
+    <string>local</string>
+  </dict>
+
+  <key>StandardOutPath</key>
+  <string>${logDir}/server.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logDir}/server.log</string>
+  <key>WorkingDirectory</key>
+  <string>${HOME2}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+</dict>
+</plist>`;
+  (0, import_fs2.writeFileSync)(plistPath(), plist);
+}
+function unitPath() {
+  const configHome = process.env.XDG_CONFIG_HOME ?? (0, import_path.join)(HOME2, ".config");
+  return (0, import_path.join)(configHome, "systemd/user/bridgerapi.service");
+}
+function writeUnit(port2, scriptPath, nodePath) {
+  const logDir = (0, import_path.join)(HOME2, ".bridgerapi");
+  (0, import_fs2.mkdirSync)(logDir, { recursive: true });
+  (0, import_fs2.mkdirSync)((0, import_path.join)(HOME2, ".config/systemd/user"), { recursive: true });
+  const unit = `[Unit]
+Description=bridgerapi \u2014 OpenAI-compatible bridge for AI CLIs
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${scriptPath} start
+Environment=BRIDGERAPI_PORT=${port2}
+Environment=HOME=${HOME2}
+Environment=CUSTOM_OKBRIDGER_API_KEY=local
+Environment=PATH=${HOME2}/.local/bin:/usr/local/bin:/usr/bin:/bin
+Restart=always
+StandardOutput=append:${logDir}/server.log
+StandardError=append:${logDir}/server.log
+
+[Install]
+WantedBy=default.target
+`;
+  (0, import_fs2.writeFileSync)(unitPath(), unit);
+}
+function installService(port2) {
+  const scriptPath = process.argv[1];
+  const nodePath = process.execPath;
+  const os = (0, import_os2.platform)();
+  if (os === "darwin") {
+    try {
+      (0, import_child_process2.execSync)(`launchctl unload "${plistPath()}" 2>/dev/null`, { stdio: "ignore" });
+    } catch {
+    }
+    writePlist(port2, scriptPath, nodePath);
+    (0, import_child_process2.execSync)(`launchctl load -w "${plistPath()}"`);
+    console.log(`\u2713  LaunchAgent installed \u2192 ${plistPath()}`);
+  } else if (os === "linux") {
+    writeUnit(port2, scriptPath, nodePath);
+    try {
+      (0, import_child_process2.execSync)("systemctl --user daemon-reload");
+    } catch {
+    }
+    (0, import_child_process2.execSync)("systemctl --user enable --now bridgerapi");
+    console.log(`\u2713  systemd user service installed`);
+  } else {
+    throw new Error(`Auto-install not supported on ${os}. Run 'bridgerapi start' manually.`);
+  }
+}
+function uninstallService() {
+  const os = (0, import_os2.platform)();
+  if (os === "darwin") {
+    const p = plistPath();
+    if ((0, import_fs2.existsSync)(p)) {
+      try {
+        (0, import_child_process2.execSync)(`launchctl unload "${p}"`);
+      } catch {
+      }
+      (0, import_fs2.unlinkSync)(p);
+      console.log("\u2713  LaunchAgent removed");
+    } else {
+      console.log("  bridgerapi service is not installed");
+    }
+  } else if (os === "linux") {
+    const p = unitPath();
+    try {
+      (0, import_child_process2.execSync)("systemctl --user disable --now bridgerapi");
+    } catch {
+    }
+    if ((0, import_fs2.existsSync)(p)) {
+      (0, import_fs2.unlinkSync)(p);
+      try {
+        (0, import_child_process2.execSync)("systemctl --user daemon-reload");
+      } catch {
+      }
+    }
+    console.log("\u2713  systemd service removed");
+  } else {
+    throw new Error(`Not supported on ${os}`);
+  }
+}
+function serviceStatus() {
+  const os = (0, import_os2.platform)();
+  try {
+    if (os === "darwin") {
+      const out = (0, import_child_process2.execSync)(`launchctl list ${LABEL} 2>/dev/null`, { encoding: "utf8" });
+      const pid = parseInt(out.match(/"PID"\s*=\s*(\d+)/)?.[1] ?? "0");
+      return { running: pid > 0, pid: pid || void 0 };
+    } else if (os === "linux") {
+      (0, import_child_process2.execSync)("systemctl --user is-active bridgerapi", { stdio: "ignore" });
+      return { running: true };
+    }
+  } catch {
+  }
+  return { running: false };
+}
+
+// src/cli.ts
+var import_fs3 = require("fs");
+var import_os3 = require("os");
+var import_path2 = require("path");
+var PORT = parseInt(process.env.BRIDGERAPI_PORT ?? "8082");
+var LOG_DIR = (0, import_path2.join)((0, import_os3.homedir)(), ".bridgerapi");
+var USAGE = `
+bridgerapi \u2014 OpenAI-compatible API bridge for AI CLI tools
+
+Commands:
+  start   [--port <n>]   Start server in the foreground (default port: 8082)
+  install [--port <n>]   Install as a background service (auto-starts on login)
+  uninstall              Remove background service
+  status                 Show whether the service is running
+  backends               List detected CLI backends and their status
+
+Examples:
+  bridgerapi start
+  bridgerapi start --port 9000
+  bridgerapi install
+  bridgerapi backends
+
+Supported backends (auto-detected):
+  claude-*   \u2192  Claude Code CLI   (oauth via Claude Code login)
+  gemini-*   \u2192  Gemini CLI        (run: gemini auth)
+  gpt-*, o3  \u2192  Codex CLI         (run: codex auth)
+  copilot    \u2192  GitHub Copilot    (run: gh auth login)
+
+Logs:  ${LOG_DIR}/server.log
+`.trim();
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const cmd2 = args[0] ?? "help";
+  let port2 = PORT;
+  for (let i = 1; i < args.length; i++) {
+    if ((args[i] === "--port" || args[i] === "-p") && args[i + 1]) {
+      port2 = parseInt(args[++i]);
+    }
+  }
+  return { cmd: cmd2, port: port2 };
+}
+function cmdStart(port2) {
+  (0, import_fs3.mkdirSync)(LOG_DIR, { recursive: true });
+  const available = BACKENDS.filter((b) => b.available());
+  const unavailable = BACKENDS.filter((b) => !b.available());
+  console.log(`bridgerapi  http://127.0.0.1:${port2}`);
+  console.log(`  backends ready   : ${available.map((b) => b.name).join(", ") || "none!"}`);
+  if (unavailable.length) {
+    console.log(`  backends missing : ${unavailable.map((b) => b.name).join(", ")}`);
+  }
+  console.log(`  logs             : ${LOG_DIR}/server.log`);
+  console.log();
+  if (available.length === 0) {
+    console.error("Error: no CLI backends found. Install claude / gemini / codex first.");
+    process.exit(1);
+  }
+  const server = createBridgeServer(port2);
+  server.listen(port2, "127.0.0.1", () => {
+    console.log(`  GET  /v1/models`);
+    console.log(`  POST /v1/chat/completions  (stream + blocking)`);
+    console.log(`  GET  /health`);
+    console.log();
+    console.log(`  Goose provider config:`);
+    console.log(`    Base URL : http://127.0.0.1:${port2}/v1`);
+    console.log(`    API Key  : local`);
+    console.log(`    Model    : claude-sonnet-4-6`);
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`Port ${port2} is already in use. Try: bridgerapi start --port 9000`);
+    } else {
+      console.error("Server error:", err.message);
+    }
+    process.exit(1);
+  });
+}
+function cmdInstall(port2) {
+  try {
+    installService(port2);
+    console.log();
+    console.log("  Waiting for server to start\u2026");
+    let attempts = 0;
+    const poll = setInterval(async () => {
+      attempts++;
+      try {
+        const http = await import("http");
+        http.get(`http://127.0.0.1:${port2}/health`, (res) => {
+          if (res.statusCode === 200) {
+            clearInterval(poll);
+            console.log(`
+\u2713  bridgerapi running on http://127.0.0.1:${port2}`);
+            console.log();
+            console.log("  Goose config:");
+            console.log(`    Provider : OpenAI Compatible`);
+            console.log(`    Base URL : http://127.0.0.1:${port2}/v1`);
+            console.log(`    API Key  : local`);
+            console.log(`    Model    : claude-sonnet-4-6`);
+            console.log();
+            console.log(`  Logs  : tail -f ${LOG_DIR}/server.log`);
+            console.log(`  Stop  : bridgerapi uninstall`);
+            process.exit(0);
+          }
+        }).on("error", () => {
+        });
+      } catch {
+      }
+      if (attempts >= 10) {
+        clearInterval(poll);
+        console.log(`
+  Server did not start. Check: tail -f ${LOG_DIR}/server.log`);
+        process.exit(1);
+      }
+    }, 600);
+  } catch (err) {
+    console.error("Install failed:", err.message);
+    process.exit(1);
+  }
+}
+function cmdUninstall() {
+  try {
+    uninstallService();
+  } catch (err) {
+    console.error("Uninstall failed:", err.message);
+    process.exit(1);
+  }
+}
+function cmdStatus(port2) {
+  const { running, pid } = serviceStatus();
+  if (running) {
+    console.log(`\u2713  bridgerapi is running${pid ? ` (pid ${pid})` : ""} on port ${port2}`);
+  } else {
+    console.log("  bridgerapi is not running");
+    console.log("  Start with: bridgerapi start   or   bridgerapi install");
+  }
+}
+function cmdBackends() {
+  console.log("CLI backends:\n");
+  for (const b of BACKENDS) {
+    const ok = b.available();
+    const icon = ok ? "\u2713" : "\u2717";
+    const models = ok ? b.models.join(", ") : "(not installed)";
+    console.log(`  ${icon}  ${b.name.padEnd(10)} ${models}`);
+  }
+  console.log();
+  const available = BACKENDS.filter((b) => b.available());
+  if (available.length) {
+    console.log(`All available models:
+  ${allModels().join(", ")}`);
+  }
+}
+var { cmd, port } = parseArgs();
+switch (cmd) {
+  case "start":
+    cmdStart(port);
+    break;
+  case "install":
+    cmdInstall(port);
+    break;
+  case "uninstall":
+    cmdUninstall();
+    break;
+  case "status":
+    cmdStatus(port);
+    break;
+  case "backends":
+    cmdBackends();
+    break;
+  default:
+    console.log(USAGE);
+    if (cmd !== "help") process.exit(1);
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "bridgerapi",
+  "version": "1.0.0",
+  "description": "Turn any AI CLI (Claude Code, Gemini, Codex, GitHub Copilot) into an OpenAI-compatible API — no API keys needed",
+  "keywords": [
+    "claude",
+    "gemini",
+    "codex",
+    "copilot",
+    "openai",
+    "api",
+    "proxy",
+    "bridge",
+    "goose",
+    "oauth",
+    "llm"
+  ],
+  "homepage": "https://github.com/teodorwaltervido/bridgerapi#readme",
+  "bugs": "https://github.com/teodorwaltervido/bridgerapi/issues",
+  "license": "MIT",
+  "author": "teodorwaltervido",
+  "main": "dist/cli.js",
+  "bin": {
+    "bridgerapi": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/cli.ts start",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}