@hanamorilabs/tab 0.1.8 → 0.1.9

package/README.md

@@ -94,6 +94,8 @@ tab accounts         accounts your subscription Agents were seen on: plan, price
 tab alias setup <name>...   make plain `codex` run `tab codex` (shims in ~/.flocktab/bin)
 tab alias remove <name>...  undo that; `tab alias list` shows them
 tab status           flock, folder Agent, proxy health, provider key state
+tab log [-f] [--all] everything through the tab for this machine's Agents, one line per call
+tab log --proxy [-f] self-hosted: the local proxy's own log (cached tokens, milliseconds)
 tab version          tab and proxy versions
 tab up | down        self-hosted: start or stop the local proxy
 tab update           the newest tab and proxy from npm; restarts a running local proxy

package/dist/cli.js

@@ -37,7 +37,7 @@ import { reportFolder } from "./folder.js";
 import { listAliases, pathLine, pathWithoutShims, removeAlias, shimDir, shimDirOnPath, validAliasName, writeAlias } from "./alias.js";
 import * as manage from "./manage.js";
 import { agentNameFor, projectRoot, readProject, writeProject } from "./project.js";
-import { downloadProxy, hasProxyEnv, packagedBinPath, proxyBinPath, proxyEnvPath, proxyInstalled, proxyLogPath, PROXY_VERSION, startProxy, stopProxy, tailProxyLog, writeProxyEnv, } from "./proxy-bin.js";
+import { downloadProxy, hasProxyEnv, packagedBinPath, proxyBinPath, proxyEnvPath, proxyInstalled, proxyLogPath, hasProxyLog, PROXY_VERSION, startProxy, stopProxy, tailProxyLog, writeProxyEnv, } from "./proxy-bin.js";
 import { proxyHealth, waitHealthy } from "./selfhost.js";
 import { TAB_VERSION } from "./version.js";
 const say = (text) => console.error(text);
@@ -62,6 +62,8 @@ function usage() {
         cmd("alias setup <name>...", "make plain `codex` run `tab codex` (shims in ~/.flocktab/bin)"),
         cmd("alias remove <name>...", "undo that; `tab alias list` shows them"),
         cmd("status", "which flock, which Agent here, is the proxy up"),
+        cmd("log [-f] [--all]", "everything through the tab on this machine's Agents, one line per call; -f follows"),
+        cmd("log --proxy [-f]", "self-hosted: the local proxy's own log (cached tokens, milliseconds; no keys, logins or prompts)"),
         cmd("version", "tab and proxy versions"),
         cmd("list", "every Agent: state, spent of cap, window, project"),
         cmd("close | open [agent]", "the kill switch; omit the Agent for this folder's"),
@@ -525,7 +527,24 @@ async function runAgent(name, args) {
     // consumer plan, is metered with the flock's key.
     const vendor = subscriptionVendorFor(name);
     const me = await whoami(config.proxyUrl, { key: agent.key, unlock: config.unlock });
-    const kind = !("error" in me) && me.kind === "subscription" ? "subscription" : "api";
+    let kind = !("error" in me) && me.kind === "subscription" ? "subscription" : "api";
+    // A proxy older than 0.1.7 answers whoami without the kind. Guessing api
+    // would hand a subscription Agent's harness the tab key, so ask the console.
+    const { consoleUrl, token } = config;
+    if (!("error" in me) && me.kind === undefined && config.mode === "self-hosted") {
+        // Not restarted here: other harnesses may be streaming through it.
+        warn(`The local proxy is older than this tab. When nothing is running through it: ${bold("tab down && tab up")}`);
+    }
+    if (consoleUrl && token && ("error" in me || me.kind === undefined)) {
+        try {
+            const listed = await listAgents(consoleUrl, token);
+            if (listed.agents.find((a) => a.id === agent.agentId)?.kind === "subscription")
+                kind = "subscription";
+        }
+        catch {
+            // Console unreachable: stay on what the proxy said.
+        }
+    }
     const auth = kind === "subscription" && vendor ? "subscription" : "key";
     // On a subscription there is no provider key to unlock; the bare key rides in the URL.
     const key = auth === "subscription" ? agent.key : presentedKey({ key: agent.key, unlock: config.unlock });
@@ -695,6 +714,29 @@ ${installed}` : "Updated.");
     await stopProxy();
     return (await bringUp(config.proxyUrl)) ? 0 : 1;
 }
+/**
+ * `tab logs`: the local proxy's log. One line per call: kind, vendor, Agent,
+ * model, outcome, status, tokens (cached apart) and duration. The proxy never
+ * writes a key, a login, a prompt or an email there. `-f` follows it.
+ */
+async function logs(args) {
+    const flags = manage.parseFlags(args);
+    const follow = args.includes("-f") || flags.opts.follow !== undefined;
+    const lines = Math.min(5000, Math.max(1, Number(flags.opts.lines ?? 50) || 50));
+    const file = proxyLogPath();
+    if (!(await hasProxyLog())) {
+        warn(`No local proxy log yet (${file}). It is written by the self-hosted proxy: ${bold("tab up")}.`);
+        return 1;
+    }
+    const [cmd, cmdArgs] = process.platform === "win32"
+        ? ["powershell", ["-NoProfile", "-Command", `Get-Content -Path '${file}' -Tail ${lines}${follow ? " -Wait" : ""}`]]
+        : ["tail", [`-n`, String(lines), ...(follow ? ["-f"] : []), file]];
+    const child = spawn(cmd, cmdArgs, { stdio: "inherit" });
+    return new Promise((resolve) => {
+        child.on("error", () => resolve(1));
+        child.on("close", (code) => resolve(code ?? 0));
+    });
+}
 async function selfHosted(action) {
     const config = await loadConfig();
     const proxyUrl = config?.mode === "self-hosted" ? config.proxyUrl : LOCAL_PROXY;
@@ -751,6 +793,8 @@ async function managed(command, rest) {
                 return await manage.outside(config, flags);
             case "live":
                 return await manage.live(config, flags);
+            case "log":
+                return await manage.log(config, manage.parseFlags(rest.filter((a) => a !== "-f")), rest.includes("-f") || flags.opts.follow !== undefined);
             case "accounts":
             case "quota":
                 return await manage.accounts(config, flags);
@@ -812,6 +856,12 @@ async function main(argv) {
             return managed(command, rest);
         case "status":
             return status();
+        case "log":
+            if (rest.includes("--proxy"))
+                return logs(rest.filter((a) => a !== "--proxy"));
+            return managed("log", rest);
+        case "logs":
+            return logs(rest);
         case "up":
             return selfHosted("up");
         case "down":

package/dist/clients.js

@@ -107,10 +107,14 @@ export function envFor(input) {
             return;
         }
         env.ANTHROPIC_BASE_URL = input.proxyUrl;
-        env.ANTHROPIC_API_KEY = input.presentedKey;
-        // Claude Code prefers an auth token when one is set; make sure a stale
-        // one cannot win over the tab key.
-        delete env.ANTHROPIC_AUTH_TOKEN;
+        // The tab key goes in as the auth token, not the API key. Claude Code
+        // asks a person to approve an `ANTHROPIC_API_KEY` once and remembers a
+        // No, after which it silently uses its own Claude login and the call
+        // arrives without the tab key. `ANTHROPIC_AUTH_TOKEN` is checked first,
+        // never asks, and switches the Claude login off for the session. It is
+        // sent as `Authorization: Bearer`, which the proxy reads like `x-api-key`.
+        env.ANTHROPIC_AUTH_TOKEN = input.presentedKey;
+        delete env.ANTHROPIC_API_KEY;
     };
     const setOpenAI = () => {
         if (auth === "subscription") {

package/dist/manage.js

@@ -298,6 +298,55 @@ export async function key(config, flags) {
         (flags.opts.show !== undefined ? `\n${issued.key}` : `\n${dim("Add --show to print it once.")}`));
     return 0;
 }
+/** One call, one condensed line: when, which Agent, how it went, what it cost or was worth, what it used. */
+export function logLine(r) {
+    const shadow = r.status === "shadow";
+    const status = shadow ? "SUBSCRIPTION" : (r.status ?? r.decision).toUpperCase();
+    const paint = status === "BLOCKED" || status === "CLOSED" ? red : status === "PENDING" ? yellow : green;
+    return `${dim(r.at)}  ${bold(r.agent)}  ${paint(status)}  ${money(r.cents)}${shadow ? dim(" at list") : ""}  ${dim(r.reason)}`;
+}
+/**
+ * `tab log`: everything that went through the tab for the Agents on this
+ * machine, one condensed line per call, hosted or self-hosted alike because
+ * it is the ledger's own record. `-f` follows it; `--all` is the whole flock.
+ */
+export async function log(config, flags, follow) {
+    const call = api(config);
+    const limit = Math.min(500, Math.max(1, Number(flags.opts.lines ?? 30) || 30));
+    const mine = new Set(Object.values(config.agents ?? {}).map((a) => a.agentName.toLowerCase()));
+    const wanted = (r) => flags.opts.all !== undefined || mine.size === 0 || mine.has(r.agent.toLowerCase());
+    const fetchRows = async () => (await call("GET", `/api/cli/ledger?limit=${flags.opts.all !== undefined ? limit : limit * 4}`)).rows.filter(wanted).slice(0, limit);
+    const first = await fetchRows();
+    if (flags.json && !follow) {
+        out(JSON.stringify({ rows: first }, null, 2));
+        return 0;
+    }
+    if (first.length === 0 && !follow)
+        out(dim("Nothing yet. Run tab claude or tab codex in a project folder."));
+    const seen = new Set();
+    for (const r of [...first].reverse()) {
+        seen.add(r.id);
+        out(flags.json ? JSON.stringify(r) : logLine(r));
+    }
+    if (!follow)
+        return 0;
+    for (;;) {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        let rows;
+        try {
+            rows = await fetchRows();
+        }
+        catch {
+            continue;
+        }
+        for (const r of [...rows].reverse()) {
+            if (seen.has(r.id))
+                continue;
+            seen.add(r.id);
+            out(flags.json ? JSON.stringify(r) : logLine(r));
+        }
+    }
+}
 export async function ledger(config, flags) {
     const call = api(config);
     const params = new URLSearchParams();
@@ -311,9 +360,11 @@ export async function ledger(config, flags) {
     emit(flags.json, { timezone, rows: list }, () => list.length === 0
         ? dim("No decisions yet.")
         : table(["time", "agent", "action", "amount", "status", "reason"], list.map((r) => {
-            const status = (r.status ?? r.decision).toUpperCase();
+            // A subscription call is recorded at list price; nothing was held, so there is no "of".
+            const shadow = r.status === "shadow";
+            const status = shadow ? "SUBSCRIPTION" : (r.status ?? r.decision).toUpperCase();
             const paint = status === "BLOCKED" || status === "CLOSED" ? red : status === "PENDING" ? yellow : green;
-            const held = r.reservedCents && r.reservedCents !== r.cents ? dim(` of ${money(r.reservedCents)}`) : "";
+            const held = !shadow && r.reservedCents && r.reservedCents !== r.cents ? dim(` of ${money(r.reservedCents)}`) : "";
             return [r.at, r.agent, r.action.length > 28 ? `${r.action.slice(0, 27)}…` : r.action, `${money(r.cents)}${held}`, paint(status), r.reason];
         }), { right: [3] }) + `\n${dim(`times in ${timezone}`)}`);
     return 0;

package/dist/proxy-bin.js

@@ -8,12 +8,12 @@
  * runtime beyond the binary itself.
  */
 import { spawn } from "node:child_process";
-import { chmod, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { access, chmod, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { configDir } from "./config.js";
 /** The proxy release `tab up` fetches. Bump with each proxy tag. */
-export const PROXY_VERSION = "0.1.5";
+export const PROXY_VERSION = "0.1.7";
 export const RELEASES = "https://github.com/joseairosa/flocktab/releases/download";
 export function targetFor(platform = process.platform, arch = process.arch) {
     if (platform === "darwin")
@@ -214,3 +214,13 @@ export async function tailProxyLog(lines = 8, env = process.env) {
         return [];
     }
 }
+/** Whether the local proxy has written a log yet. */
+export async function hasProxyLog(env = process.env) {
+    try {
+        await access(proxyLogPath(env));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Written by scripts/write-version.mjs from package.json at build; `tab version` prints it. */
-export const TAB_VERSION = "0.1.8";
+export const TAB_VERSION = "0.1.9";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanamorilabs/tab",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Run any AI agent on a FlockTab tab: tab claude, tab codex, tab <command>.",
   "license": "MIT",
   "type": "module",
@@ -22,11 +22,11 @@
     "prepublishOnly": "pnpm build"
   },
   "optionalDependencies": {
-    "@hanamorilabs/flocktab-proxy-darwin-arm64": "0.1.5",
-    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.5",
-    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.5",
-    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.5",
-    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.5"
+    "@hanamorilabs/flocktab-proxy-darwin-arm64": "0.1.7",
+    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.7",
+    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.7",
+    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.7",
+    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.7"
   },
   "devDependencies": {
     "@types/node": "^22.18.6",