@ar-ai/brink-cli 0.0.0-stage → 1.0.4

package/support/brink.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const os = require("node:os");
+const net = require("node:net");
+const { createSetupUI } = require("./setup-ui");
+const { ensureClient, configureClient, existingKey, checkClientConfig } = require("./client-setup");
+const { duck, cat, credit } = require("./brand");
+
+// Onboarding ports the key/model/config flow of AgentRouterCodexProxy.ps1.
+// Unlike its temporary session restore, Brink persists only user-approved settings.
+const SHIPPED_MODELS = ["claude-opus-5", "claude-opus-4-8", "gpt-6-astra", "gpt-5.6-sol", "glm-5.3", "deepseek-v4-flash"];
+const configDir = process.env.BRINK_CONFIG_HOME || path.join(os.homedir(), ".config", "brink");
+const configPath = path.join(configDir, "config.json");
+const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+const claudeHome = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+
+function safeError(error) {
+  return String(error?.message || error).replace(/sk-[A-Za-z0-9_-]+/g, "[redacted]").replace(/Bearer\s+\S+/gi, "Bearer [redacted]").replace(/[\x00-\x1f\x7f]/g, " ");
+}
+async function readConfig() {
+  try {
+    const value = JSON.parse(await fs.readFile(configPath, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid Brink settings");
+    return value;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new Error(`Could not read ${configPath}. Existing settings were not changed.`);
+  }
+}
+async function saveConfig(config) {
+  await fs.mkdir(configDir, { recursive: true, mode: 0o700 });
+  const temporary = `${configPath}.${process.pid}.tmp`;
+  try {
+    await fs.writeFile(temporary, JSON.stringify(config, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+    await fs.rename(temporary, configPath);
+    await fs.chmod(configPath, 0o600);
+  } finally { await fs.rm(temporary, { force: true }); }
+}
+function usableIds(catalog) {
+  const entries = Array.isArray(catalog?.data) ? catalog.data : Array.isArray(catalog?.models) ? catalog.models : [];
+  return [...new Set(entries.map((entry) => typeof entry === "string" ? entry : entry?.id || entry?.slug).filter((id) => typeof id === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/.test(id)))];
+}
+async function loadModels(apiKey, ui, signal) {
+  ui.section("Model");
+  ui.step("Model catalog", "Fetching model IDs only. No generation or token-usage test.");
+  try {
+    const response = await fetch("https://agentrouter.org/v1/models", {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.any([signal, AbortSignal.timeout(12000)]),
+      redirect: "error",
+    });
+    if (!response.ok) throw new Error(`Catalog HTTP ${response.status}`);
+    const reader = response.body.getReader();
+    const chunks = []; let bytes = 0;
+    for (;;) {
+      const { done, value } = await reader.read(); if (done) break;
+      bytes += value.byteLength;
+      if (bytes > 8 * 1024 * 1024) { await reader.cancel(); throw new Error("Catalog exceeds size limit"); }
+      chunks.push(Buffer.from(value));
+    }
+    const ids = usableIds(JSON.parse(Buffer.concat(chunks, bytes).toString("utf8")));
+    if (!ids.length) throw new Error("Catalog contained no models");
+    ui.step("Catalog received", `${ids.length} models listed; access and API compatibility are controlled by AgentRouter.`);
+    return { ids, source: "agentrouter", fetchedAt: new Date().toISOString() };
+  } catch (error) {
+    if (signal.aborted) throw error;
+    ui.step("Catalog unavailable", `${safeError(error)}. Shipped model IDs are available below; access is not verified.`);
+    return { ids: SHIPPED_MODELS, source: "shipped-unverified" };
+  }
+}
+async function selectModel(ui, client, ids, previous) {
+  const defaultModel = previous && ids.includes(previous) ? previous : ids.find((id) => client === "claude" ? id.startsWith("claude-") : id === "gpt-6-astra") || ids[0];
+  const preferred = [defaultModel, ...ids.filter((id) => id !== defaultModel).slice(0, 8)];
+  const index = await ui.choose(`${client === "claude" ? "Claude Code" : "Codex"}: choose a starting model`, [...preferred, "Enter another exact model ID"], 0);
+  if (index < preferred.length) return preferred[index];
+  for (;;) {
+    const model = (await ui.text("Exact AgentRouter model ID", defaultModel)).trim();
+    if (/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/.test(model)) return model;
+    ui.step("Invalid model ID", "Use the exact ID from AgentRouter, without spaces.");
+  }
+}
+async function setup() {
+  const ui = createSetupUI();
+  const controller = new AbortController();
+  const cancel = () => controller.abort(new Error("Setup cancelled"));
+  process.once("SIGINT", cancel);
+  try {
+    ui.welcome();
+    const current = await readConfig();
+    ui.section("Client");
+    ui.step("Choose your coding client", "Connect your AgentRouter key. Unrelated settings stay in place.");
+    const selection = await ui.choose("Which client should Brink set up?", ["Claude Code (recommended)", "Codex", "Both — Claude Code and Codex"], 0);
+    const clients = selection === 0 ? ["claude"] : selection === 1 ? ["codex"] : ["claude", "codex"];
+    ui.section("Key");
+    let apiKey = current?.apiKey || await existingKey({ codexHome, claudeHome });
+    if (apiKey) {
+      const keyChoice = await ui.choose("AgentRouter key found on this computer", ["Use the saved key (never displayed)", "Enter a different key"], 0);
+      if (keyChoice === 1) apiKey = null;
+    }
+    while (!apiKey) {
+      apiKey = (await ui.secret("Paste your AgentRouter API key")).trim();
+      if (!apiKey || /\s/.test(apiKey)) { apiKey = null; ui.step("Key not saved", "Enter a non-empty key without spaces."); }
+    }
+    ui.step("Key stays on this computer", "Private local files; Windows inherits your profile permissions. API-key access, not a subscription login.");
+    const catalog = await loadModels(apiKey, ui, controller.signal);
+    const port = Number(current?.port || 8787);
+    const results = { ...(current?.clients || {}) };
+    const failures = [];
+    for (const client of clients) {
+      if (controller.signal.aborted) throw controller.signal.reason;
+      try {
+        const model = await selectModel(ui, client, catalog.ids, results[client]?.model);
+        ui.step("Prepare your client", `${client === "claude" ? "Claude Code" : "Codex"} is checked before settings change.`);
+        const installed = await ensureClient(client, { onProgress: ui.progress, signal: controller.signal });
+        if (controller.signal.aborted) throw controller.signal.reason;
+        ui.step("Connect to Brink", "Saving endpoint, key and model picker. No prompt is sent.");
+        const configured = await configureClient(client, {
+          apiKey, model, modelIds: [...new Set([...catalog.ids, model])], port, codexHome, claudeHome, onProgress: ui.progress,
+        });
+        results[client] = { ...installed, ...configured, model };
+        await saveConfig({ version: 1, port, apiKey, clients: results, catalog });
+        ui.step(`${client === "claude" ? "Claude Code" : "Codex"} connected`, configured.configPath);
+      } catch (error) {
+        if (controller.signal.aborted || error.code === "ABORT_ERR") throw error;
+        failures.push(client);
+        ui.step(`${client === "claude" ? "Claude Code" : "Codex"} setup needs attention`, safeError(error));
+      }
+    }
+    const ready = Object.keys(results);
+    if (ready.length) {
+      ui.section("Ready");
+      ui.success([
+        "Run brink and keep that terminal open.",
+        ...ready.map((client) => `In a second terminal, run ${results[client].executable || client}.`),
+        "In either client, use /model to choose a model.",
+        "Rate-limit, server-error and connection-reset retry waits: 1, 2, 3, 4, 5 seconds. No model substitution.",
+        ...(failures.length ? ["Some clients were not changed. Run brink setup again to finish them."] : []),
+      ]);
+    } else { ui.step("No client was configured", "Fix the issue above, then run brink setup again."); }
+    return ready.length > 0 && failures.length === 0;
+  } finally {
+    process.removeListener("SIGINT", cancel);
+    ui.close();
+  }
+}
+function portAvailable(port) {
+  return new Promise((resolve, reject) => {
+    const probe = net.createServer();
+    probe.once("error", (error) => error.code === "EADDRINUSE" ? resolve(false) : reject(error));
+    probe.listen(port, "127.0.0.1", () => probe.close(() => resolve(true)));
+  });
+}
+async function check(config = null) {
+  config ||= await readConfig();
+  if (!config?.apiKey || !Object.keys(config.clients || {}).length) {
+    console.log("Run brink setup first to connect a client.");
+    return;
+  }
+  for (const [client, saved] of Object.entries(config.clients)) {
+    if (!["claude", "codex"].includes(client)) continue;
+    try {
+      const options = { apiKey: config.apiKey, model: saved.model,
+        modelIds: config.catalog?.ids || SHIPPED_MODELS, port: config.port || 8787,
+        codexHome, claudeHome };
+      const status = await checkClientConfig(client, options);
+      if (status.needsRepair) {
+        await configureClient(client, { ...options, model: status.model });
+        console.log(`Brink: repaired ${client} managed settings (${status.issues.join(", ")}).`);
+      }
+    } catch (error) {
+      console.error(`Brink: ${client} settings need attention: ${safeError(error)}. Existing file preserved; other clients remain available.`);
+    }
+  }
+}
+
+async function update() {
+  const ui = createSetupUI();
+  try {
+    const config = await readConfig();
+    const clients = Object.entries(config?.clients || {}).filter(([client]) => ["claude", "codex"].includes(client));
+    if (!config?.apiKey || !clients.length) {
+      ui.step("No configured clients", "Run brink setup first. No settings were changed.");
+      return;
+    }
+    ui.section("Key");
+    ui.step("Update your AgentRouter API key", "Changes the saved key for your configured clients, not the Brink software. No network request is sent.");
+    const choice = await ui.choose("Would you like to change your key?", ["Keep my current key", "Enter a new API key"], 0);
+    if (choice === 0) {
+      ui.step("Current key kept", "No settings were changed.");
+      return;
+    }
+    let apiKey;
+    for (;;) {
+      apiKey = (await ui.secret("New AgentRouter API key (Enter empty to keep current)")).trim();
+      if (!apiKey || apiKey === config.apiKey) {
+        ui.step("Current key kept", "No settings were changed.");
+        return;
+      }
+      if (!/[\x00-\x20\x7f]/.test(apiKey)) break;
+      ui.step("Key not saved", "Enter a key without spaces or control characters.");
+    }
+    // Check all client files before committing; malformed configs leave the key unchanged.
+    const prepared = [];
+    for (const [client, saved] of clients) {
+      const options = { apiKey, model: saved.model, modelIds: config.catalog?.ids || SHIPPED_MODELS,
+        port: config.port || 8787, codexHome, claudeHome };
+      const status = await checkClientConfig(client, options);
+      prepared.push({ client, options: { ...options, model: status.model } });
+    }
+    // Commit the authoritative key first, so check/start can finish a failed client write.
+    await saveConfig({ ...config, apiKey });
+    const pending = [];
+    for (const { client, options } of prepared) {
+      try {
+        await configureClient(client, options);
+        ui.step(`${client === "claude" ? "Claude Code" : "Codex"} key updated`);
+      } catch {
+        pending.push(client);
+      }
+    }
+    if (pending.length) {
+      throw new Error(`The new key is saved in Brink, but these client settings could not be written: ${pending.join(", ")}. Check file permissions, then run brink check to finish. No key was tested online.`);
+    }
+    ui.step("New key saved", "Restart running Claude Code/Codex sessions to load it. Brink can stay running. Model choices and unrelated settings were preserved.");
+    ui.step("No provider verification performed", "This does not revoke the previous key at AgentRouter or remove it from external backups or shell overrides.");
+  } finally {
+    ui.close();
+  }
+}
+
+async function start(plain) {
+  let config = await readConfig();
+  if (!config || !Object.keys(config.clients || {}).length) {
+    console.log("First run: connect a coding client with brink setup.");
+    if (!process.stdin.isTTY || !await setup()) return;
+    config = await readConfig();
+  }
+  const port = Number(config.port || 8787);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Invalid Brink port. Run brink setup.");
+  await check(config);
+  if (!await portAvailable(port)) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(1500) });
+      const health = await response.json();
+      if (health.service === "brink") { console.log(`Brink is already running on port ${port}. Open your coding client in another terminal.`); return; }
+    } catch {}
+    throw new Error(`Port ${port} belongs to another process. Brink did not stop it. Close that process or change Brink's port.`);
+  }
+  process.env.AGENTROUTER_PROXY_PORT = String(port);
+  process.env.BRINK_CLIENTS = Object.keys(config.clients || {}).join(",");
+  if (plain) process.env.AGENTROUTER_PROXY_PLAIN = "1";
+  require("./proxy");
+}
+function help() {
+  console.log(`\nBRINK\n${credit}\n\n  brink                Open the live dashboard (setup on first run)\n  brink setup          Install and connect Claude Code or Codex\n  brink start          Explicitly start the proxy and dashboard\n  brink start --plain  Start with ordinary line logs\n  brink check          Repair stale Brink-managed client settings\n  brink update         Optionally replace your saved API key\n  brink art            Show the creator artwork\n  brink --help         Show these commands\n\nSetup saves API-key access locally. Brink keeps running until Ctrl+C or q.\nKeep Brink open; run claude or codex in a second terminal.\n`);
+}
+async function main(args = process.argv.slice(2)) {
+  const [command, ...flags] = args;
+  if (!command) return start(false);
+  if (["help", "--help", "-h"].includes(command)) return help();
+  if (command === "setup" && !flags.length) { await setup(); return; }
+  if (command === "start" && flags.every((flag) => flag === "--plain")) return start(flags.includes("--plain"));
+  if (command === "check" && !flags.length) return check();
+  if (command === "update" && !flags.length) return update();
+  if (command === "art" && !flags.length) { console.log(`BRINK\n${credit}\n\n${duck}\n\n${cat}`); return; }
+  throw new Error("Unknown command. Use brink --help. Enter API keys only at the hidden prompt, never as arguments.");
+}
+if (require.main === module) main().catch((error) => {
+  console.error(`Brink: ${safeError(error)}`);
+  process.exitCode = error.code === "ABORT_ERR" ? 130 : 1;
+});
+module.exports = { setup, start, check, update, main, usableIds };