@hanamorilabs/tab 0.1.2 → 0.1.4

package/README.md

@@ -59,8 +59,8 @@ Codex shows `FlockTab - Self-hosted` as its provider.
 tab login            approve this machine in the console, once
 tab <agent> [args]   claude, codex, grok, kimi, gemini, or any command, on the tab
 tab use              pick or change the Agent this folder runs as (.flocktab)
-tab alias <name>...  make plain `codex` run `tab codex` (shims in ~/.flocktab/bin)
-tab unalias <name>   remove such a shim
+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 version          tab and proxy versions
 tab up | down        self-hosted: start or stop the local proxy
@@ -69,19 +69,44 @@ tab logout           forget the session and keys on this machine
 tab help             this list
 ```
 
+## The console from the terminal
+
+Everything the console does to a tab, `tab` does too, with the machine
+session from `tab login`. An Agent is named by slug or name; left out, it is
+this folder's Agent. Every read takes `--json`.
+
+```
+tab list                                 every Agent: state, spent of cap, window, project
+tab close crawler        tab open crawler   the kill switch (402 tab_closed on the next call)
+tab cap crawler 25 --window week         cap in dollars, and the window
+tab rename crawler "Nightly crawler"     the slug stays
+tab policy crawler --velocity 60 --models gpt-5,claude-sonnet-5 --allow email.send
+tab project crawler Foley --create       attribute to a project (--repo owner/name; none clears)
+tab projects add Foley                   projects
+tab key rotate crawler [--show]          new key, kept on this machine; --show prints it once
+tab archive crawler                      closes for good, leaves the bill (asks first; -y skips)
+tab ledger [crawler] --limit 20 --blocked   one row per call: settled of held, status, reason
+tab spend [agent|project|day] --since 7d    meter and outside spend, the console's numbers
+tab outside                              connections, per-project outside spend, unattributed
+tab live --watch 4                       who is working now, refreshed every 4 seconds
+tab web [crawler]                        the Agent's console page in the browser
+```
+
 ## Aliases: plain `codex` on the tab
 
 ```
-tab alias codex claude
+tab alias setup codex claude
 export PATH="$HOME/.flocktab/bin:$PATH"   # once, in your shell rc
 codex                                     # now runs: tab codex
+tab alias remove codex                    # back to the plain codex
 ```
 
-`tab alias` writes a shim named after the command into `~/.flocktab/bin`
-(`codex.cmd` on Windows). With that folder first on `PATH`, the plain
-command runs on the tab. When `tab` spawns the real agent it removes its
-own shim folder from the child's `PATH`, so nothing loops. `tab alias` with
-no name lists them; `tab unalias codex` removes one. Prefer a shell alias?
+`tab alias setup` writes a shim named after the command into
+`~/.flocktab/bin` (`codex.cmd` on Windows). With that folder first on
+`PATH`, the plain command runs on the tab. When `tab` spawns the real agent
+it removes its own shim folder from the child's `PATH`, so nothing loops.
+`tab alias list` shows them; `tab alias remove <name>` deletes the shim, and
+the plain command is the real one again. Prefer a shell alias?
 `alias codex='tab codex'` in your rc does the same for that shell only.
 
 ## Secrets and colour

package/dist/cli.js

@@ -7,7 +7,8 @@
  *   tab codex  [...args]   Codex on the tab
  *   tab <cmd>  [...args]   anything else, both APIs pointed at the tab
  *   tab use                pick (or change) the Agent this folder runs as
- *   tab alias codex ...    make plain `codex` run `tab codex` (shims in ~/.flocktab/bin)
+ *   tab alias setup codex  make plain `codex` run `tab codex` (shims in ~/.flocktab/bin)
+ *   tab alias remove codex undo that; `tab alias list` shows them
  *   tab status             which flock, which Agent here, is the proxy up
  *   tab version            tab and proxy versions
  *   tab up | down | update self-hosted: start, stop, or fetch the newest proxy
@@ -30,6 +31,7 @@ import { consoleUrlFor, DeviceLoginError, startDeviceLogin, waitForApproval } fr
 import { clearConfig, configDir, configPath, HOSTED_PROXY, isLocalProxy, loadConfig, LOCAL_PROXY, normalizeProxyUrl, presentedKey, saveConfig, } from "./config.js";
 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 { proxyHealth, waitHealthy } from "./selfhost.js";
@@ -50,10 +52,25 @@ function usage() {
         cmd(others.join(" | tab "), "the same, for those agents"),
         cmd("<command> [args]", "any other agent, both APIs pointed at the tab"),
         cmd("use", "pick or change the Agent this folder runs as (.flocktab)"),
-        cmd("alias <name>...", "make plain `codex` run `tab codex` (shims in ~/.flocktab/bin)"),
-        cmd("unalias <name>", "remove such a shim"),
+        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("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"),
+        cmd("cap [agent] <dollars>", "set the cap (--window day|week|month|run|hour|lifetime)"),
+        cmd("rename <agent> <name>", "rename it (the slug stays)"),
+        cmd("policy [agent]", "show or set: --velocity N|none --models a,b|none --allow tool|none"),
+        cmd("project [agent] <name>", "attribute to a project (--create, --repo owner/name, none)"),
+        cmd("projects [add <name>]", "list or add projects"),
+        cmd("key rotate [agent]", "new key, kept on this machine (--show prints it once)"),
+        cmd("archive [agent]", "close for good and leave the bill"),
+        cmd("ledger [agent]", "one row per call (--limit N --blocked)"),
+        cmd("spend [agent|project|day]", "meter and outside spend (--since 7d --agent x)"),
+        cmd("outside", "outside-spend connections and per-project totals"),
+        cmd("live", "who is working now (--watch 4)"),
+        cmd("web [agent]", "open the Agent's console page"),
+        cmd("... --json", "every read command as JSON, for scripts and agents"),
         cmd("up", "self-hosted: start the local proxy (fetches it the first time)"),
         cmd("down", "self-hosted: stop the local proxy"),
         cmd("update", "self-hosted: fetch the newest proxy and restart it"),
@@ -521,7 +538,20 @@ async function runAgent(name, args) {
  * `tab alias codex claude`: shims so the plain commands run on the tab.
  * `tab alias` alone lists them; `tab unalias codex` removes one.
  */
-async function alias(names, remove = false) {
+async function alias(args, removeFlag = false) {
+    // `tab alias setup codex`, `tab alias remove codex`, `tab alias list`;
+    // the bare `tab alias codex` and `tab unalias codex` mean the same.
+    const [first, ...rest] = args;
+    let names = args;
+    let remove = removeFlag;
+    if (first === "setup" || first === "add")
+        names = rest;
+    else if (first === "remove" || first === "rm") {
+        names = rest;
+        remove = true;
+    }
+    else if (first === "list" || first === "ls")
+        names = [];
     if (names.length === 0 && !remove) {
         const existing = await listAliases();
         if (existing.length === 0)
@@ -531,7 +561,7 @@ async function alias(names, remove = false) {
         return pathHint();
     }
     if (names.length === 0) {
-        fail("tab unalias needs a name.");
+        fail("tab alias remove needs a name, e.g. tab alias remove codex");
         return 2;
     }
     for (const name of names) {
@@ -634,6 +664,52 @@ async function selfHosted(action) {
         say(`Next: ${bold("tab login")} and pick 2 Self-hosted to approve this machine.`);
     return 0;
 }
+/** Console management from the terminal; every command needs the machine session. */
+async function managed(command, rest) {
+    const config = await ensureLogin();
+    if (!config)
+        return 2;
+    const flags = manage.parseFlags(rest);
+    try {
+        switch (command) {
+            case "list":
+            case "ls":
+                return await manage.list(config, flags);
+            case "close":
+                return await manage.setState(config, flags, "closed");
+            case "open":
+                return await manage.setState(config, flags, "open");
+            case "cap":
+                return await manage.cap(config, flags);
+            case "rename":
+                return await manage.rename(config, flags);
+            case "policy":
+                return await manage.policy(config, flags);
+            case "project":
+                return await manage.project(config, flags);
+            case "projects":
+                return await manage.projects(config, flags);
+            case "key":
+                return await manage.key(config, flags);
+            case "archive":
+                return await manage.archive(config, flags, ask);
+            case "ledger":
+                return await manage.ledger(config, flags);
+            case "spend":
+                return await manage.spend(config, flags);
+            case "outside":
+                return await manage.outside(config, flags);
+            case "live":
+                return await manage.live(config, flags);
+            default:
+                return await manage.web(config, flags);
+        }
+    }
+    catch (err) {
+        fail(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+}
 async function main(argv) {
     const [command, ...rest] = argv;
     switch (command) {
@@ -659,6 +735,23 @@ async function main(argv) {
         case "--version":
         case "-v":
             return version();
+        case "list":
+        case "ls":
+        case "close":
+        case "open":
+        case "cap":
+        case "rename":
+        case "policy":
+        case "project":
+        case "projects":
+        case "key":
+        case "archive":
+        case "ledger":
+        case "spend":
+        case "outside":
+        case "live":
+        case "web":
+            return managed(command, rest);
         case "status":
             return status();
         case "up":

package/dist/manage.js

@@ -0,0 +1,329 @@
+/**
+ * The console from the terminal: tabs, caps, policies, keys, projects, the
+ * ledger and spend, all through the machine session from `tab login`. Every
+ * read takes `--json` for scripts and other agents. An Agent argument is a
+ * slug or a name; omitted, it is this folder's Agent from `.flocktab`.
+ */
+import { spawn } from "node:child_process";
+import { readProject } from "./project.js";
+import { saveConfig } from "./config.js";
+import { ConsoleApiError } from "./console-api.js";
+import { bold, dim, green, money, red, rows, table, yellow } from "./ui.js";
+export class ManageError extends Error {
+}
+/** One place to talk to `/api/cli/*` with the session. */
+export function api(config, fetchImpl = fetch) {
+    const base = config.consoleUrl;
+    const token = config.token;
+    if (!base || !token)
+        throw new ManageError("This machine is not logged in. Run tab login.");
+    return async (method, path, body) => {
+        const res = await fetchImpl(`${base}${path}`, {
+            method,
+            headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        const json = (await res.json().catch(() => ({})));
+        if (!res.ok) {
+            const detail = json.error ?? `console answered ${res.status}`;
+            throw new ConsoleApiError(res.status === 401 ? "Session expired. Run tab login." : json.hint ? `${detail} (${json.hint})` : detail, res.status);
+        }
+        return json;
+    };
+}
+/** `--json`, `--yes`, `--name value` or `--name=value`; the rest are positional. */
+export function parseFlags(argv) {
+    const flags = { json: false, yes: false, opts: {}, args: [] };
+    for (let i = 0; i < argv.length; i += 1) {
+        const a = argv[i];
+        if (a === "--json")
+            flags.json = true;
+        else if (a === "--yes" || a === "-y")
+            flags.yes = true;
+        else if (a.startsWith("--")) {
+            const eq = a.indexOf("=");
+            if (eq > 0)
+                flags.opts[a.slice(2, eq)] = a.slice(eq + 1);
+            else {
+                const next = argv[i + 1];
+                if (next !== undefined && !next.startsWith("--")) {
+                    flags.opts[a.slice(2)] = next;
+                    i += 1;
+                }
+                else
+                    flags.opts[a.slice(2)] = "";
+            }
+        }
+        else
+            flags.args.push(a);
+    }
+    return flags;
+}
+async function tabsOf(call) {
+    return (await call("GET", "/api/cli/tabs")).tabs;
+}
+/** Slug or name (case-insensitive); omitted means this folder's Agent. */
+export async function resolveSlug(call, given, cwd = process.cwd()) {
+    const tabs = await tabsOf(call);
+    if (!given) {
+        const project = await readProject(cwd);
+        if (!project)
+            throw new ManageError("No Agent named and this folder has none yet (tab use), so say which: tab <command> <agent>.");
+        return project.agent;
+    }
+    const want = given.trim().toLowerCase();
+    const hit = tabs.find((t) => t.slug.toLowerCase() === want) ?? tabs.find((t) => t.name.toLowerCase() === want);
+    if (!hit)
+        throw new ManageError(`No Agent called ${given}. tab list shows them.`);
+    return hit.slug;
+}
+const state = (s) => (s === "open" ? green("open") : red(s));
+const pct = (spent, cap) => {
+    const c = BigInt(cap || "0");
+    return c === 0n ? "" : `${Number((BigInt(spent) * 100n) / c)}%`;
+};
+function out(text) {
+    console.log(text);
+}
+function emit(json, value, text) {
+    out(json ? JSON.stringify(value, null, 2) : text());
+}
+export async function list(config, flags) {
+    const tabs = await tabsOf(api(config));
+    emit(flags.json, { tabs }, () => tabs.length === 0
+        ? dim("No Agents yet. Run tab claude or tab codex in a project folder.")
+        : table(["agent", "state", "spent", "cap", "used", "window", "project"], tabs.map((t) => [t.name === t.slug ? t.slug : `${t.name} ${dim(t.slug)}`, state(t.state), money(t.spentCents), money(t.capCents), pct(t.spentCents, t.capCents), t.window, t.projectName ?? dim("-")]), { right: [2, 3, 4] }));
+    return 0;
+}
+export async function setState(config, flags, next) {
+    const call = api(config);
+    const slug = await resolveSlug(call, flags.args[0]);
+    const { tab } = await call("POST", `/api/cli/tabs/${encodeURIComponent(slug)}/state`, { state: next });
+    emit(flags.json, { tab }, () => `${bold(tab.name)} is ${state(tab.state)}${next === "closed" ? dim("  (the next call answers 402 tab_closed)") : ""}`);
+    return 0;
+}
+export async function cap(config, flags) {
+    const call = api(config);
+    const [given, dollars] = flags.args.length >= 2 ? [flags.args[0], flags.args[1]] : [undefined, flags.args[0]];
+    if (!dollars && !flags.opts.window)
+        throw new ManageError("tab cap [agent] <dollars> [--window day|week|month|run|hour|lifetime]");
+    const slug = await resolveSlug(call, given);
+    const body = {};
+    if (dollars)
+        body.capDollars = dollars.replace(/^\$/, "");
+    if (flags.opts.window)
+        body.window = flags.opts.window;
+    const { tab } = await call("PATCH", `/api/cli/tabs/${encodeURIComponent(slug)}`, body);
+    emit(flags.json, { tab }, () => `${bold(tab.name)}: cap ${money(tab.capCents)} per ${tab.window}, ${money(tab.spentCents)} spent`);
+    return 0;
+}
+export async function rename(config, flags) {
+    const call = api(config);
+    if (flags.args.length < 2)
+        throw new ManageError('tab rename <agent> "new name"');
+    const slug = await resolveSlug(call, flags.args[0]);
+    const name = flags.args.slice(1).join(" ");
+    const { tab } = await call("PATCH", `/api/cli/tabs/${encodeURIComponent(slug)}`, { name });
+    emit(flags.json, { tab }, () => `Renamed to ${bold(tab.name)} ${dim(`(slug stays ${tab.slug})`)}`);
+    return 0;
+}
+export async function archive(config, flags, ask) {
+    const call = api(config);
+    const slug = await resolveSlug(call, flags.args[0]);
+    if (!flags.yes) {
+        const go = await ask(`Archive ${bold(slug)}? Its tab closes for good and it leaves the bill. [y/N]: `);
+        if (!/^y(es)?$/i.test(go))
+            return 1;
+    }
+    const { tab } = await call("DELETE", `/api/cli/tabs/${encodeURIComponent(slug)}`);
+    emit(flags.json, { tab, archived: true }, () => `${bold(tab.name)} archived.`);
+    return 0;
+}
+function listOpt(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (raw.trim().toLowerCase() === "none" || raw.trim() === "")
+        return [];
+    return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+export async function policy(config, flags) {
+    const call = api(config);
+    const slug = await resolveSlug(call, flags.args[0]);
+    const patch = {};
+    if (flags.opts.velocity !== undefined) {
+        patch.velocityMaxCalls = flags.opts.velocity.toLowerCase() === "none" ? null : Number(flags.opts.velocity);
+    }
+    const models = listOpt(flags.opts.models);
+    if (models)
+        patch.models = models;
+    const allow = listOpt(flags.opts.allow);
+    if (allow)
+        patch.irreversibleTools = allow;
+    const path = `/api/cli/tabs/${encodeURIComponent(slug)}`;
+    const { tab, policy } = Object.keys(patch).length > 0
+        ? await call("PATCH", path, { policy: patch })
+        : await call("GET", path);
+    emit(flags.json, { tab, policy }, () => `${bold(tab.name)}\n` +
+        rows([
+            ["cap", `${money(tab.capCents)} per ${tab.window}`],
+            ["velocity", policy?.velocityMaxCalls ? `${policy.velocityMaxCalls} calls/min` : dim("ledger default")],
+            ["models", policy?.models.length ? policy.models.join(", ") : dim("any")],
+            ["irreversible", policy?.irreversibleTools.length ? policy.irreversibleTools.join(", ") : dim("none allowed")],
+        ]) +
+        `\n${dim("Change with --velocity N|none --models a,b|none --allow tool,tool|none")}`);
+    return 0;
+}
+export async function projects(config, flags) {
+    const call = api(config);
+    if (flags.args[0] === "add") {
+        const name = flags.args.slice(1).join(" ");
+        if (!name)
+            throw new ManageError("tab projects add <name>");
+        const { project } = await call("POST", "/api/cli/projects", { name });
+        emit(flags.json, { project }, () => `Created project ${bold(project.name)}`);
+        return 0;
+    }
+    const { projects } = await call("GET", "/api/cli/projects");
+    emit(flags.json, { projects }, () => (projects.length === 0 ? dim("No projects. tab projects add <name>") : projects.map((p) => `  ${p.name}`).join("\n")));
+    return 0;
+}
+/** `tab project [agent] <project name|none> [--repo owner/name]` */
+export async function project(config, flags) {
+    const call = api(config);
+    const [given, ...rest] = flags.args.length >= 2 ? [flags.args[0], ...flags.args.slice(1)] : [undefined, ...flags.args];
+    const target = rest.join(" ").trim();
+    if (!target && flags.opts.repo === undefined)
+        throw new ManageError("tab project [agent] <project name|none> [--repo owner/name]");
+    const slug = await resolveSlug(call, given);
+    const body = {};
+    if (target) {
+        if (target.toLowerCase() === "none")
+            body.projectId = null;
+        else {
+            const { projects } = await call("GET", "/api/cli/projects");
+            let hit = projects.find((p) => p.name.toLowerCase() === target.toLowerCase());
+            if (!hit) {
+                if (!flags.opts.create && flags.opts.create !== "")
+                    throw new ManageError(`No project called ${target}. Add --create to make it.`);
+                hit = (await call("POST", "/api/cli/projects", { name: target })).project;
+            }
+            body.projectId = hit.id;
+        }
+    }
+    if (flags.opts.repo !== undefined)
+        body.githubRepo = flags.opts.repo || null;
+    const { tab } = await call("PATCH", `/api/cli/tabs/${encodeURIComponent(slug)}`, body);
+    emit(flags.json, { tab }, () => `${bold(tab.name)} → project ${tab.projectName ?? dim("none")}${tab.githubRepo ? dim(`  repo ${tab.githubRepo}`) : ""}`);
+    return 0;
+}
+/** `tab key rotate [agent]`: a fresh key; this machine keeps using the Agent without a new login. */
+export async function key(config, flags) {
+    const call = api(config);
+    if (flags.args[0] !== "rotate")
+        throw new ManageError("tab key rotate [agent] [--show]");
+    const slug = await resolveSlug(call, flags.args[1]);
+    const issued = await call("POST", `/api/cli/tabs/${encodeURIComponent(slug)}/key`);
+    const agents = { ...(config.agents ?? {}), [issued.agent.slug]: { key: issued.key, agentId: issued.agent.id, agentName: issued.agent.name } };
+    await saveConfig({ ...config, agents });
+    emit(flags.json, { agent: issued.agent, rotated: issued.rotated, ...(flags.opts.show !== undefined ? { key: issued.key } : {}) }, () => `${bold(issued.agent.name)}: new key saved on this machine${issued.rotated ? "; anything using the old one is refused from now on" : ""}.` +
+        (flags.opts.show !== undefined ? `\n${issued.key}` : `\n${dim("Add --show to print it once.")}`));
+    return 0;
+}
+export async function ledger(config, flags) {
+    const call = api(config);
+    const params = new URLSearchParams();
+    if (flags.args[0])
+        params.set("agent", await resolveSlug(call, flags.args[0]));
+    if (flags.opts.limit)
+        params.set("limit", flags.opts.limit);
+    if (flags.opts.blocked !== undefined)
+        params.set("blocked", "1");
+    const { rows: list, timezone } = await call("GET", `/api/cli/ledger?${params}`);
+    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();
+            const paint = status === "BLOCKED" || status === "CLOSED" ? red : status === "PENDING" ? yellow : green;
+            const held = 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;
+}
+export async function spend(config, flags) {
+    const call = api(config);
+    const by = flags.opts.by ?? (flags.args[0] === "day" || flags.args[0] === "project" || flags.args[0] === "agent" ? flags.args[0] : "agent");
+    const params = new URLSearchParams({ by });
+    if (flags.opts.since)
+        params.set("since", flags.opts.since);
+    if (flags.opts.agent)
+        params.set("agent", await resolveSlug(call, flags.opts.agent));
+    const data = await call("GET", `/api/cli/spend?${params}`);
+    emit(flags.json, data, () => {
+        if (by === "day") {
+            const days = data.days;
+            return days.length === 0
+                ? dim("Nothing settled in the window.")
+                : table(["day", "calls", "settled", "in", "out"], days.map((d) => [d.day, String(d.calls), money(d.settledCents), d.promptTokens, d.completionTokens]), { right: [1, 2, 3, 4] });
+        }
+        if (by === "project") {
+            const ps = data.projects;
+            const lines = table(["project", "agents", "meter", "outside", "total"], ps.map((p) => [p.name, String(p.agents), money(p.meterCents), money(p.outsideCents), money(BigInt(p.meterCents) + BigInt(p.outsideCents))]), { right: [1, 2, 3, 4] });
+            const un = data.unattributedOutsideCents;
+            return `${lines}\n${dim(`unattributed outside spend ${money(un)}`)}`;
+        }
+        const as = data.agents;
+        return table(["agent", "state", "spent", "cap", "window", "in", "out", "project"], as.map((a) => [a.slug, state(a.state), money(a.spentCents), money(a.capCents), a.window, a.promptTokens, a.completionTokens, a.project ?? dim("-")]), { right: [2, 3, 5, 6] });
+    });
+    return 0;
+}
+export async function outside(config, flags) {
+    const call = api(config);
+    const data = await call("GET", "/api/cli/outside");
+    emit(flags.json, data, () => {
+        const conns = data.connections.length === 0
+            ? dim("No connections. Console → Outside spend → Connect.")
+            : table(["connection", "30 days", "status", "note"], data.connections.map((c) => [c.label ? `${c.provider} (${c.label})` : c.provider, money(c.windowCents), c.lastError ? red("error") : c.status, c.notice ?? c.lastError ?? ""]), { right: [1] });
+        const projects = data.byProject.length === 0 ? "" : `\n\n${table(["project", "outside", "events"], data.byProject.map((p) => [p.projectName, money(p.cents), String(p.events)]), { right: [1, 2] })}`;
+        return `${conns}${projects}\n${dim(`unattributed ${money(data.unattributedCents)}`)}`;
+    });
+    return 0;
+}
+export async function live(config, flags) {
+    const call = api(config);
+    const once = async () => {
+        const feed = await call("GET", "/api/cli/live");
+        emit(flags.json, feed, () => `${dim("active")} ${feed.totals.active}  ${dim("calls/min")} ${feed.totals.callsPerMinute}  ${dim("blocked 5m")} ${feed.totals.blocked}  ${dim("spend 5m")} ${money(feed.totals.windowCents)}\n` +
+            table(["agent", "pulse", "calls/min", "blocked", "5m", "last"], feed.agents.map((a) => [a.slug, a.pulse, String(a.callsPerMinute), String(a.blocked), money(a.windowCents), a.lastDecision ? `${a.lastDecision.toLowerCase()} ${dim(a.lastReason ?? "")}` : dim("-")]), { right: [2, 3, 4] }));
+    };
+    await once();
+    if (flags.opts.watch === undefined)
+        return 0;
+    const every = Math.max(2, Number(flags.opts.watch) || 4) * 1000;
+    await new Promise((resolve) => {
+        const timer = setInterval(() => {
+            out("");
+            once().catch((err) => out(red(String(err instanceof Error ? err.message : err))));
+        }, every);
+        process.on("SIGINT", () => {
+            clearInterval(timer);
+            resolve();
+        });
+    });
+    return 0;
+}
+/** `tab web [agent]`: this folder's Agent in the console. */
+export async function web(config, flags) {
+    const call = api(config);
+    const slug = flags.args[0] || (await readProject(process.cwd()))?.agent;
+    const url = slug ? `${config.consoleUrl}/console/tabs/${encodeURIComponent(await resolveSlug(call, slug))}` : `${config.consoleUrl}/console`;
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    try {
+        spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+    }
+    catch {
+        // The URL is printed either way.
+    }
+    out(url);
+    return 0;
+}

package/dist/ui.js

@@ -97,3 +97,26 @@ export function rows(pairs, indent = 2) {
 export function heading(text) {
     return bold(text);
 }
+/**
+ * A plain table: header dimmed, columns padded to their widest cell, numbers
+ * right-aligned when the column says so. Visible width, so painted cells
+ * line up.
+ */
+export function table(header, body, options = {}) {
+    const right = new Set(options.right ?? []);
+    const cols = header.length;
+    const widths = header.map((h, i) => Math.max(width(h), ...body.map((r) => width(r[i] ?? ""))));
+    const cell = (text, i) => {
+        const pad = " ".repeat(Math.max(0, widths[i] - width(text)));
+        return right.has(i) ? `${pad}${text}` : `${text}${pad}`;
+    };
+    const line = (r) => `${" ".repeat(options.indent ?? 2)}${r.map((c, i) => cell(c ?? "", i)).join("  ").trimEnd()}`;
+    return [line(header.map((h) => dim(h))), ...body.map((r) => line(r.slice(0, cols)))].join("\n");
+}
+/** "$0.14" from a cents string or bigint. */
+export function money(cents) {
+    const n = typeof cents === "bigint" ? cents : BigInt(String(cents).replace(/[^0-9-]/g, "") || "0");
+    const negative = n < 0n;
+    const abs = negative ? -n : n;
+    return `${negative ? "-" : ""}$${abs / 100n}.${(abs % 100n).toString().padStart(2, "0")}`;
+}

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.2";
+export const TAB_VERSION = "0.1.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanamorilabs/tab",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Run any AI agent on a FlockTab tab: tab claude, tab codex, tab <command>.",
   "license": "MIT",
   "type": "module",