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

package/README.md

@@ -1,3 +1,59 @@
-# Temporary Holding Version
+# Brink
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Made by rexy and brink.** Brink is a local AgentRouter proxy for Claude Code and Codex. It provides guided client setup, protocol bridges, bounded retries for transient provider failures, and a terminal dashboard.
+
+## Install and run
+
+Install [Node.js 24 or newer](https://nodejs.org/en/download) with npm, then install Brink:
+
+```sh
+npm install --global @ar-ai/brink-cli
+brink
+```
+
+On first run, Brink opens guided setup and starts the proxy after setup succeeds. Choose Claude Code, Codex, or both; enter your own AgentRouter API key at the hidden prompt and select a model. Setup can install a missing selected client. npm installation itself only installs Brink; it does not ask for credentials or change client settings.
+
+Keep Brink open. In a second terminal, open your project and run `claude` or `codex`. Use `/model` inside the client. The proxy listens on `127.0.0.1:8787` by default. Stop it with Ctrl+C.
+
+You can also run Brink without a global installation:
+
+```sh
+npx @ar-ai/brink-cli
+```
+
+For a project-local installation, use `npm install @ar-ai/brink-cli`, then `npx brink`. The runtime supports Windows, macOS, and Linux; selected client installers require a supported 64-bit platform.
+
+## Commands
+
+| Command | Purpose |
+| --- | --- |
+| `brink` | Start the proxy, opening setup on first run. |
+| `brink setup` | Install/connect clients or change models. |
+| `brink start --plain` | Start the proxy with ordinary line logs. |
+| `brink check` | Repair Brink-managed client settings. |
+| `brink update` | Replace the saved API key through hidden input. |
+| `brink art` | Display the supplied artwork. |
+| `brink --help` | Display help. |
+
+`brink update` changes credentials. To update the software, stop Brink and run `npm install --global @ar-ai/brink-cli@latest`.
+
+Settings are saved in `~/.config/brink/config.json` (or `BRINK_CONFIG_HOME`). Setup also writes selected clients' user settings. Credentials are stored locally without encryption; Windows file access follows your profile permissions. Model access, quota, and billing remain controlled by AgentRouter.
+
+## Develop and verify
+
+Run these commands from the repository root:
+
+```sh
+npm ci
+node support/brink.js --help
+npm pack
+```
+
+The help command checks CLI startup without provider calls or client settings changes. npm needs registry access or cached runtime dependencies.
+
+Before publishing, you can distribute and install the tarball locally:
+
+```sh
+npm install --global ./ar-ai-brink-cli-1.0.4.tgz
+brink --help
+```

package/package.json

@@ -1,6 +1,20 @@
 {
   "name": "@ar-ai/brink-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.6",
+  "description": "Local AgentRouter proxy and guided setup for Claude Code and Codex.",
+  "author": "rexy and brink",
+  "license": "UNLICENSED",
+  "type": "commonjs",
+  "bin": {
+    "brink": "support/brink.js"
+  },
+  "files": [
+    "support/*.js"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "toml-eslint-parser": "1.0.3"
+  }
+}

package/support/activity.js

@@ -0,0 +1,102 @@
+"use strict";
+
+// UI activity from public Responses output only. Never inspect prompts,
+// arguments, tool-result bodies, encrypted_content, or raw reasoning content.
+function observeActivity(value, tracker, { summaries = true } = {}) {
+  if (!tracker?.activity || !value || typeof value !== "object") return;
+  const type = value.type;
+  const id = String(value.item_id ?? value.output_index ?? "message");
+  if (
+    type === "response.output_text.delta" ||
+    type === "response.refusal.delta"
+  ) {
+    if (typeof value.delta === "string")
+      tracker.activity({ kind: "assistant", id, text: value.delta });
+  } else if (
+    type === "response.output_text.done" ||
+    type === "response.refusal.done"
+  ) {
+    const text = value.text ?? value.refusal;
+    if (typeof text === "string")
+      tracker.activity({ kind: "assistant", id, text, replace: true });
+  } else if (summaries && type === "response.reasoning_summary_text.delta") {
+    if (typeof value.delta === "string")
+      tracker.activity({ kind: "summary", id, text: value.delta });
+  } else if (summaries && type === "response.reasoning_summary_text.done") {
+    if (typeof value.text === "string")
+      tracker.activity({
+        kind: "summary",
+        id,
+        text: value.text,
+        replace: true,
+      });
+  } else if (
+    type === "response.output_item.added" ||
+    type === "response.output_item.done"
+  ) {
+    item(value.item, tracker, type.endsWith(".done"), summaries);
+  }
+  const response =
+    value.response ?? (value.object === "response" ? value : null);
+  if (Array.isArray(response?.output)) {
+    for (const output of response.output)
+      item(output, tracker, response.status !== "in_progress", summaries);
+  }
+}
+
+function item(output, tracker, done, summaries) {
+  if (!output || typeof output !== "object") return;
+  const id = String(output.id ?? output.call_id ?? "message");
+  if (["function_call", "custom_tool_call"].includes(output.type)) {
+    const name = typeof output.name === "string" ? output.name : "tool";
+    tracker.activity({
+      kind: "tool",
+      id,
+      name: output.namespace ? `${output.namespace}.${name}` : name,
+      status: done ? "requested" : "preparing",
+    });
+  } else if (output.type === "message" && output.role === "assistant") {
+    const text = Array.isArray(output.content)
+      ? output.content
+          .map((part) =>
+            part.type === "output_text"
+              ? part.text
+              : part.type === "refusal"
+                ? part.refusal
+                : "",
+          )
+          .filter((part) => typeof part === "string")
+          .join("")
+      : "";
+    if (text) tracker.activity({ kind: "assistant", id, text, replace: true });
+  } else if (output.type === "reasoning") {
+    tracker.activity({ kind: "reasoning" });
+    if (summaries && Array.isArray(output.summary)) {
+      const text = output.summary
+        .filter(
+          (part) =>
+            part.type === "summary_text" && typeof part.text === "string",
+        )
+        .map((part) => part.text)
+        .join("");
+      if (text) tracker.activity({ kind: "summary", id, text, replace: true });
+    }
+  } else if (
+    typeof output.type === "string" &&
+    [
+      "web_search_call",
+      "file_search_call",
+      "computer_call",
+      "code_interpreter_call",
+    ].includes(output.type)
+  ) {
+    tracker.activity({
+      kind: "tool",
+      id,
+      name: output.type,
+      status: done ? "requested" : "preparing",
+    });
+  }
+}
+
+module.exports = { observeActivity };

package/support/brand.js

@@ -0,0 +1,110 @@
+"use strict";
+
+const duck = `⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⡶⠿⠿⠷⣶⣄⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⡿⠁⠀⠀⢀⣀⡀⠙⣷⡀⠀⠀⠀
+⠀⠀⠀⡀⠀⠀⠀⠀⠀⢠⣿⠁⠀⠀⠀⠘⠿⠃⠀⢸⣿⣿⣿⣿
+⠀⣠⡿⠛⢷⣦⡀⠀⠀⠈⣿⡄⠀⠀⠀⠀⠀⠀⠀⣸⣿⣿⣿⠟
+⢰⡿⠁⠀⠀⠙⢿⣦⣤⣤⣼⣿⣄⠀⠀⠀⠀⠀⢴⡟⠛⠋⠁⠀
+⣿⠇⠀⠀⠀⠀⠀⠉⠉⠉⠉⠉⠉⠁⠀⠀⠀⠀⠀⠈⣿⡀⠀⠀⠀
+⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⡇⠀⠀⠀
+⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡇⠀⠀⠀
+⠸⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡿⠀⠀⠀⠀
+⠀⠹⣷⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣰⡿⠁⠀⠀⠀⠀
+⠀⠀⠀⠉⠙⠛⠿⠶⣶⣶⣶⣶⣶⠶⠿⠟⠛⠉⠀⠀⠀⠀⠀⠀`;
+const cat = `⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡀⠀⠀⠀⠀⠀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡿⠇⠀⠀⠀⠀⢻⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡇⠀⠀⠀⠀⡸⣞⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠃⠀⠀⠀⢀⣧⢿⣽⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⢴⣿⠆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⣼⣞⡿⣞⡅⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠓⢤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠀⠀⠀⣰⣟⢾⣽⢫⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣠⢤⣶⡻⣞⣿⣺⢯⣽⣳⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⢠⣄⡀⠀⠀⠀⠀⠙⢦⡀⠀⠀⠀⠀⣀⣠⣤⣿⣽⣻⢾⣽⣷⣾⣽⣻⣞⣷⣳⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠈⢻⣿⣶⣄⡀⠀⠀⠀⣉⣲⣴⢶⣞⡿⣽⣞⡷⣯⢿⡽⣞⣿⠟⠋⠁⠉⠈⠳⣟⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣿⣿⢶⣾⣿⡽⣯⣟⡾⣽⡷⣯⣟⡽⡾⣽⡯⠁⠀⠀⠀⠀⠀⠀⢮⣭⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢞⣿⣿⢯⡿⣿⣯⣟⣷⣯⢿⣳⣟⡷⣽⣼⣻⣽⠀⠀⠀⠀⠀⠀⠀⢀⣼⡯⡗⠋⠤⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢾⣿⣿⣯⣽⣾⣿⣾⣗⡿⣯⡷⣯⣟⡷⣞⣼⣿⣀⠀⠀⠀⠀⢀⣠⡿⣏⡗⠈⠐⠈⠅⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⠛⠏⠉⠉⠽⢟⢿⣿⣿⣿⣿⣷⣻⢾⡽⣞⡷⠄⡹⣶⢿⣻⢿⣻⡽⢯⣼⢦⠶⠁⠈⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣯⠇⠀⠀⠀⠀⠀⠁⣽⣿⣿⣿⣷⣯⣿⣽⣛⡦⠀⠀⢩⣿⣹⢯⣷⢻⣟⠺⢣⡖⣘⠤⠓⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⣿⡃⠁⠀⠀⠀⢀⣤⣾⣟⢿⣻⣿⣿⣟⡾⣽⡳⠄⠎⢳⣯⢯⣟⡾⢯⣞⣯⣓⠉⢀⠀⠀⡄⢢⡀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣷⣷⣶⣳⣶⣺⣿⣿⣳⢯⣟⣿⣿⣳⢯⠛⠅⠃⠀⠀⣴⣿⡿⣬⢶⠾⠙⣊⣥⠾⡒⠊⢁⢠⠣⣌⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢺⡽⣾⡽⣯⣟⣿⡿⣯⣿⣿⣾⢿⣿⠳⢏⣈⢠⠀⠀⣰⢿⡿⣽⣉⡶⠌⠋⠉⣀⡀⠁⠀⠀⠀⣘⡐⣂⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣽⣳⣟⣳⣟⣾⣽⣿⣿⣿⣿⣿⣦⣜⡻⡽⠆⠧⣴⡟⣯⢟⡳⣭⠲⠄⠐⠀⠀⠀⠈⠁⠉⠑⢊⡕⢃⠄⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣿⣾⣿⣯⣿⣾⣿⣿⣿⣿⣿⣿⣿⣿⣾⢧⠀⠹⠾⡵⡞⡽⢢⣃⠐⠀⠀⠄⡐⠀⠀⠀⡘⢦⠘⣌⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⠹⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢯⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠒⡈⠀⡀⠄⡑⠢⣉⠴⣈⣆
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢯⣏⡴⣶⣵⣢⢤⢠⡀⡄⢠⠐⡰⢌⡱⠀⡁⡀⠆⡥⠆⡥⣛⡽⣾
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠔⠉⠀⠀⢽⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣼⣻⢷⣯⡽⣞⣷⣻⡼⣡⢋⡔⠣⠜⡐⢐⠠⡓⣤⣙⣲⣽⣻⢷
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡿⣽⣞⣷⣻⡴⣣⢜⡱⣊⡕⣊⠠⡙⡰⣭⢷⣯⣿⢿`;
+
+// Keep the supplied originals above intact. Compact marks are reduced from
+// their braille dots, not substituted with a different duck or cat drawing.
+const BRAILLE_DOTS = [[1, 8], [2, 16], [4, 32], [64, 128]];
+const mascotCache = new Map();
+
+function compactArt(value, maxRows) {
+  const source = value.split("\n");
+  const blank = /^[ \u2800]*$/;
+  const sourceWidth = Math.max(...source.map((row) => row.length));
+  let left = sourceWidth;
+  let right = 0;
+  for (const row of source) {
+    for (let x = 0; x < row.length; x++) {
+      if (!blank.test(row[x])) {
+        left = Math.min(left, x);
+        right = Math.max(right, x + 1);
+      }
+    }
+  }
+  const sourceRows = source.map((row) => row.slice(left, right).padEnd(right - left, "\u2800"));
+  if (sourceRows.length <= maxRows) return sourceRows;
+  const scale = maxRows / sourceRows.length;
+  const columns = Math.max(1, Math.round((right - left) * scale));
+  const pixelWidth = (right - left) * 2;
+  const pixelHeight = sourceRows.length * 4;
+  const rows = [];
+  for (let y = 0; y < maxRows; y++) {
+    let row = "";
+    for (let x = 0; x < columns; x++) {
+      let dots = 0;
+      for (let dy = 0; dy < 4; dy++) {
+        for (let dx = 0; dx < 2; dx++) {
+          const x0 = Math.floor((x * 2 + dx) * pixelWidth / (columns * 2));
+          const x1 = Math.max(x0 + 1, Math.floor((x * 2 + dx + 1) * pixelWidth / (columns * 2)));
+          const y0 = Math.floor((y * 4 + dy) * pixelHeight / (maxRows * 4));
+          const y1 = Math.max(y0 + 1, Math.floor((y * 4 + dy + 1) * pixelHeight / (maxRows * 4)));
+          let ink = 0;
+          for (let sy = y0; sy < y1; sy++) {
+            for (let sx = x0; sx < x1; sx++) {
+              const cell = sourceRows[Math.floor(sy / 4)].charCodeAt(Math.floor(sx / 2)) - 0x2800;
+              if (cell & BRAILLE_DOTS[sy % 4][sx % 2]) ink++;
+            }
+          }
+          if (ink / ((x1 - x0) * (y1 - y0)) >= 0.25) dots |= BRAILLE_DOTS[dy][dx];
+        }
+      }
+      row += String.fromCharCode(0x2800 + dots);
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+
+function mascotLines(width, maxRows) {
+  for (const height of [23, 11, 6, 3]) {
+    if (height > maxRows) continue;
+    let pair = mascotCache.get(height);
+    if (!pair) {
+      const duckRows = compactArt(duck, height);
+      const catRows = compactArt(cat, height);
+      const duckWidth = duckRows[0].length;
+      const rows = Math.max(duckRows.length, catRows.length);
+      pair = Array.from({ length: rows }, (_, i) =>
+        `${duckRows[i - rows + duckRows.length] || " ".repeat(duckWidth)}   ${catRows[i - rows + catRows.length] || ""}`,
+      );
+      mascotCache.set(height, pair);
+    }
+    if (pair[0].length <= width) return pair;
+  }
+  return [];
+}
+
+module.exports = { duck, cat, mascotLines, credit: "made by rexy and brink" };

package/support/bridge-stream.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const { StringDecoder } = require("string_decoder");
+const zlib = require("zlib");
+function failure(message, status = 502, code = "bridge_error") {
+  return Object.assign(new Error(message), { status, code });
+}
+async function writeChunk(res, chunk) {
+  if (res.destroyed || res.writableEnded)
+    throw failure("Client disconnected", 499, "client_disconnected");
+  if (res.write(chunk)) return;
+  await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      res.off("drain", drained);
+      res.off("close", closed);
+      res.off("error", errored);
+    };
+    const drained = () => {
+      cleanup();
+      resolve();
+    };
+    const closed = () => {
+      cleanup();
+      reject(failure("Client disconnected", 499, "client_disconnected"));
+    };
+    const errored = (error) => {
+      cleanup();
+      reject(error);
+    };
+    res.once("drain", drained);
+    res.once("close", closed);
+    res.once("error", errored);
+    if (res.destroyed) closed();
+  });
+}
+async function* sseEvents(stream) {
+  const decoder = new StringDecoder("utf8");
+  let line = "";
+  let skipLF = false;
+  let first = true;
+  let data = [];
+  let event = "";
+  function consumeLine() {
+    if (!line) {
+      const result = data.length ? { data: data.join("\n"), event } : null;
+      data = [];
+      event = "";
+      return result;
+    }
+    const colon = line.indexOf(":");
+    const field = colon < 0 ? line : line.slice(0, colon);
+    let value = colon < 0 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "data") data.push(value);
+    else if (field === "event") event = value;
+    return null;
+  }
+  for await (const chunk of stream) {
+    let text = decoder.write(chunk);
+    if (first && text.length) {
+      first = false;
+      if (text.charCodeAt(0) === 0xfeff) text = text.slice(1);
+    }
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      if (skipLF) {
+        skipLF = false;
+        if (char === "\n") {
+          start = i + 1;
+          continue;
+        }
+      }
+      if (char === "\r" || char === "\n") {
+        line += text.slice(start, i);
+        const parsed = consumeLine();
+        line = "";
+        start = i + 1;
+        skipLF = char === "\r";
+        if (parsed) yield parsed;
+      }
+    }
+    line += text.slice(start);
+  }
+  line += decoder.end();
+  // SSE requires an empty line to dispatch an event. Do not accept an
+  // unterminated final JSON event as a successful stream termination.
+  if (line.trim() || data.length)
+    throw failure("Truncated upstream SSE event", 502, "incomplete_stream");
+}
+function decodedStream(upstream, source = upstream) {
+  const encoding = String(
+    upstream.headers["content-encoding"] || "identity",
+  ).toLowerCase();
+  let decoder;
+  if (encoding === "gzip") decoder = zlib.createGunzip();
+  else if (encoding === "deflate") decoder = zlib.createInflate();
+  else if (encoding === "br") decoder = zlib.createBrotliDecompress();
+  else if (encoding !== "identity")
+    throw failure(`Unsupported upstream content encoding: ${encoding}`);
+  if (!decoder) return source;
+  source.on("error", (error) => decoder.destroy(error));
+  source.on("aborted", () =>
+    decoder.destroy(failure("Upstream response aborted")),
+  );
+  return source.pipe(decoder);
+}
+
+module.exports = { failure, writeChunk, sseEvents, decodedStream };