@hanamorilabs/tab 0.1.7 → 0.1.9

package/README.md

@@ -38,28 +38,34 @@ is keyed, and keeps it in the config file so `tab claude` is one command.
 Set `FLOCKTAB_PROXY_URL`, `FLOCKTAB_KEY` and `FLOCKTAB_UNLOCK` instead when
 you would rather not have a file or a folder, for example in CI.
 
-## On a subscription (Claude Max, ChatGPT)
+## On a subscription (Claude Max, ChatGPT, SuperGrok, Kimi)
+
+An Agent is **api** (the flock's provider key, metered) or **subscription**
+(the harnesses' own logins), chosen when it is made: the first `tab claude`
+in a folder asks, or
 
 ```
-tab subscribe claude --plan "Claude Max 5x" --price 100   # Claude Code on your Max plan
-tab subscribe codex                                        # Codex on your ChatGPT plan
-tab claude        # your own Claude login through the tab
-tab codex         # your own ChatGPT login (codex login once, inside tab codex)
-tab grok          # still metered: the flock's xAI key, charged to the cap
-tab quota         # 5h / 7d windows the vendors reported on the last call
-tab unsubscribe codex                                      # Codex back on the meter
+tab agent create "me@joseairosa.com" --subscription
+tab use              # this folder runs as it
+tab claude           # your own Claude login through the tab
+tab codex            # your own ChatGPT login (codex login once, inside tab codex)
+tab grok             # your SuperGrok login
+tab kimi             # your Kimi Code login
+tab accounts         # accounts seen: plan, seat price, 30 days at list, what is left
+tab agent kind me@joseairosa.com api   # back to the meter
 ```
 
-A subscription belongs to the harness, not the Agent: Claude Code can be on
-Max while Codex and Grok on the same Agent stay on the meter. The plan pays
-for the tokens; the tab still gates every call (kill switch, velocity, model
-and tool policy) and records it at list price as a `SUBSCRIPTION` row that
-never touches the cap. Claude Code gets
-`ANTHROPIC_BASE_URL=<proxy>/t/<key>/anthropic` and no API key; Codex gets a
-home whose `chatgpt_base_url` is `<proxy>/t/<key>/openai/backend-api/`, with
-your existing `~/.codex/auth.json` copied in once (never written back). The
-rows are read on every launch, so the console's **Subscriptions** panel and
-`tab subscribe` agree. `docs/subscriptions.md` has the wire.
+The plan pays for the tokens; the tab still gates every call (kill switch,
+velocity, model and tool policy) and records it at list price as a
+`SUBSCRIPTION` row that never touches the cap. The account is not declared:
+the vendor names it on every reply (Anthropic's organization id, ChatGPT's
+account id, the login token for xAI and Kimi), FlockTab files the call under
+it, learns the email and plan tier, and prices the seat from the tier. Four
+Max accounts are four accounts; `claude /login` to another one mid-session
+and the next call lands on it. Claude Code gets
+`ANTHROPIC_BASE_URL=<proxy>/t/<key>/anthropic` and no API key; Codex a home
+whose `chatgpt_base_url` is the passthrough; Grok Build `GROK_XAI_API_BASE_URL`;
+Kimi Code `KIMI_BASE_URL`. `docs/subscriptions.md` has the wire.
 
 ## Self-hosted
 
@@ -82,12 +88,14 @@ 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 subscribe claude|codex [agent]   that harness on your own plan (--plan, --price)
-tab unsubscribe claude|codex [agent] back on the metered tab for that harness
-tab quota [agent]    what the plans have left: 5h and 7d windows
+tab agent create <name> --subscription|--api   a new Agent of that kind (--cap 50)
+tab agent kind <agent> api|subscription        change it
+tab accounts         accounts your subscription Agents were seen on: plan, price, quota left
 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
@@ -102,7 +110,7 @@ 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, plans (claude, codex), project
+tab list                                 every Agent: kind, state, spent of cap, window, project
 tab close my-project        tab open my-project   the kill switch (402 tab_closed on the next call)
 tab cap my-project 25 --window week         cap in dollars, and the window
 tab rename my-project "My project (nightly)"     the slug stays
@@ -147,6 +155,6 @@ proxy   http://127.0.0.1:8787  (self-hosted)  up
 flock   Hanamori Labs
 folder  flocktab-codex
 plan    team
-plans   none; every harness on the metered tab
+kind    api (the flock's provider key, metered on the tab)
 byok    provider keys on this box
 ```

package/dist/cli.js

@@ -7,9 +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 subscribe claude   this folder's Agent runs Claude Code on your Claude Max plan
- *   tab subscribe codex    ...and Codex on your ChatGPT plan; tab unsubscribe undoes it
- *   tab quota              what the plans have left (5h / 7d windows) for this Agent
+ *   tab agent create <name> --subscription   an Agent whose harnesses use your own logins
+ *   tab accounts           the accounts your subscription Agents were seen on, with quota left
  *   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
@@ -28,7 +27,8 @@ import { hostname } from "node:os";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { bold, box, cyan, dim, green, heading, line, rows, underline, yellow } from "./ui.js";
-import { clientFor, envFor, knownClients } from "./clients.js";
+import { envFor, knownClients, subscriptionVendorFor } from "./clients.js";
+import { describeLogin, localLogin } from "./logins.js";
 import { prepareCodexHome } from "./codex-home.js";
 import { ConsoleApiError, createAgent, issueAgentKey, listAgents } from "./console-api.js";
 import { consoleUrlFor, DeviceLoginError, startDeviceLogin, waitForApproval } from "./device-login.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);
@@ -56,12 +56,14 @@ 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("subscribe claude|codex", "run that harness on your own plan (--plan \"Max 5x\" --price 100)"),
-        cmd("unsubscribe claude|codex", "back on the metered tab for that harness"),
-        cmd("quota [agent]", "what the plans have left: 5h and 7d windows"),
+        cmd("agent create <name>", "a new Agent: --subscription (your own logins) or --api (the flock's key, metered)"),
+        cmd("agent kind <agent> api|subscription", "change it"),
+        cmd("accounts", "accounts your subscription Agents were seen on: plan, price, quota left"),
         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"),
@@ -398,14 +400,19 @@ async function resolveAgent(config, opts = {}) {
         say(rows([
             ...options.map((a, i) => [
                 `${bold(String(i + 1))}  ${a.name}`,
-                `${a.state === "open" ? green("open") : yellow(a.state)}  ${dim(`$${(Number(a.capCents) / 100).toFixed(2)} cap`)}${agents[a.slug] ? dim("  keyed here") : a.hasKey ? dim("  keyed elsewhere") : ""}`,
+                `${a.state === "open" ? green("open") : yellow(a.state)}  ${a.kind === "subscription" ? yellow("subscription") : dim("api")}  ${dim(`$${(Number(a.capCents) / 100).toFixed(2)} cap`)}${agents[a.slug] ? dim("  keyed here") : a.hasKey ? dim("  keyed elsewhere") : ""}`,
             ]),
             [`${bold("n")}  New Agent`, dim(`named ${suggested}, $50.00 cap`)],
         ]));
         const answer = await ask(`Choose 1-${options.length} or ${bold("n")} ${dim("[n]")}: `);
         if (answer === "" || answer.toLowerCase() === "n") {
             const name = (await ask(`${cyan("?")} Agent name ${dim(`[${suggested}]`)}: `)) || suggested;
-            created = { name };
+            say(rows([
+                [`${bold("1")}  API key`, dim("the flock's provider key; every call metered against the cap")],
+                [`${bold("2")}  Subscription`, dim("your own Claude Max / ChatGPT / SuperGrok / Kimi logins; gated and recorded, never charged")],
+            ]));
+            const which = await ask(`Which kind? ${bold("1")} or ${bold("2")} ${dim("[1]")}: `);
+            created = { name, kind: which.trim() === "2" ? "subscription" : "api" };
         }
         else {
             const index = Number.parseInt(answer, 10);
@@ -419,8 +426,8 @@ async function resolveAgent(config, opts = {}) {
     let issued;
     try {
         if (created) {
-            issued = await createAgent(config.consoleUrl, config.token, { name: created.name });
-            ok(`Created Agent ${bold(issued.agent.name)} with a $50.00 cap. Change it in the console.`);
+            issued = await createAgent(config.consoleUrl, config.token, { name: created.name, kind: created.kind });
+            ok(`Created ${created.kind === "subscription" ? "subscription" : "API-key"} Agent ${bold(issued.agent.name)} with a $50.00 cap. Change it in the console.`);
         }
         else if (chosen) {
             if (chosen.hasKey && !agents[chosen.slug]) {
@@ -486,8 +493,7 @@ async function status() {
         }
         else {
             pairs.push(["plan", me.flock.plan]);
-            const plans = (me.subscriptions ?? []).map((p) => (p === "anthropic" ? "claude" : p === "openai" ? "codex" : p));
-            pairs.push(["plans", plans.length > 0 ? `${bold(plans.join(", "))} ${dim("on your own login; everything else metered")}` : dim("none; every harness on the metered tab")]);
+            pairs.push(["kind", me.kind === "subscription" ? `${bold("subscription")} ${dim("(your own logins; gated and recorded, never charged)")}` : `api ${dim("(the flock's provider key, metered on the tab)")}`]);
             const byok = !me.byok
                 ? dim("no provider key on this flock")
                 : me.unlock === "none"
@@ -514,20 +520,43 @@ async function runAgent(name, args) {
     const agent = await resolveAgent(config);
     if (!agent)
         return 1;
-    // Which harness is this, and is it on the person's own plan? The
-    // subscription belongs to the harness (Claude Code: anthropic, Codex:
-    // openai), read fresh on every launch so `tab subscribe` or the console
-    // applies to the next run. Any other harness is metered.
-    const base = clientFor(name);
-    const vendor = base.shape === "anthropic" ? "anthropic" : base.isolatedHome === "codex" ? "openai" : undefined;
+    // The Agent's kind decides: a subscription Agent's harness brings its own
+    // login (Claude Code its Claude one, Codex ChatGPT, Grok SuperGrok, Kimi
+    // Code its Kimi plan), read fresh on every launch so a change in the
+    // console applies to the next run. An api Agent, or a harness with no
+    // 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 auth = vendor && !("error" in me) && (me.subscriptions ?? []).includes(vendor) ? "subscription" : "key";
+    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 });
     reportFolder(config.proxyUrl, key);
     const { spec, env } = envFor({ name, proxyUrl: config.proxyUrl, presentedKey: key, auth });
     if (auth === "subscription") {
-        say(dim(`${spec.label} runs on your own ${vendor === "openai" ? "ChatGPT" : "Claude"} login; FlockTab keeps the record and the kill switch.`));
+        const login = describeLogin(await localLogin(vendor));
+        const vendorName = vendor === "openai" ? "ChatGPT" : vendor === "xai" ? "SuperGrok" : vendor === "kimi" ? "Kimi" : "Claude";
+        say(dim(`${spec.label} on your own ${vendorName} login${login ? `: ${login}` : ""}. FlockTab keeps the record and the kill switch; the account is read off each reply.`));
+    }
+    else if (kind === "subscription") {
+        say(dim(`${spec.label} has no consumer plan FlockTab can pass through, so it runs metered on the flock's key.`));
     }
     // An alias shim named like the agent must not be what we spawn.
     env.PATH = pathWithoutShims();
@@ -685,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;
@@ -741,12 +793,13 @@ 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.quota(config, flags);
-            case "subscribe":
-                return await manage.subscribe(config, flags, true);
-            case "unsubscribe":
-                return await manage.subscribe(config, flags, false);
+                return await manage.accounts(config, flags);
+            case "agent":
+                return await manage.agent(config, flags);
             default:
                 return await manage.web(config, flags);
         }
@@ -797,12 +850,18 @@ async function main(argv) {
         case "outside":
         case "live":
         case "quota":
-        case "subscribe":
-        case "unsubscribe":
+        case "accounts":
+        case "agent":
         case "web":
             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

@@ -76,6 +76,19 @@ export function openaiBase(proxyUrl, provider) {
 export function passthroughBase(proxyUrl, key, provider) {
     return `${proxyUrl}/t/${key}/${provider}`;
 }
+/** Which vendor's login a harness carries: Claude Code its Claude one, Codex ChatGPT, Grok SuperGrok, Kimi Code a Kimi plan. */
+export function subscriptionVendorFor(name) {
+    const spec = clientFor(name);
+    if (spec.shape === "anthropic")
+        return "anthropic";
+    if (spec.isolatedHome === "codex")
+        return "openai";
+    if (spec.provider === "xai")
+        return "xai";
+    if (spec.provider === "moonshot")
+        return "kimi";
+    return undefined;
+}
 export function envFor(input) {
     const base = clientFor(input.name);
     const known = input.name in KNOWN;
@@ -94,17 +107,30 @@ 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") {
-            // Only Codex has a subscription route (its own home points at it); a
-            // plain OpenAI key would bypass the plan, so none is set.
+            // Each harness carries its own login; a plain OpenAI key would bypass
+            // the plan, so none is set. Codex's own home points at the passthrough;
+            // Grok Build and Kimi Code read a base URL of their own.
             delete env.OPENAI_BASE_URL;
             delete env.OPENAI_API_KEY;
+            if (spec.provider === "xai") {
+                env.GROK_XAI_API_BASE_URL = `${passthroughBase(input.proxyUrl, input.presentedKey, "xai")}/v1`;
+                delete env.XAI_API_KEY;
+            }
+            if (spec.provider === "moonshot") {
+                env.KIMI_BASE_URL = `${passthroughBase(input.proxyUrl, input.presentedKey, "kimi")}/coding/v1`;
+                delete env.KIMI_API_KEY;
+            }
             return;
         }
         env.OPENAI_BASE_URL = openaiBase(input.proxyUrl, spec.provider);

package/dist/logins.js

@@ -0,0 +1,77 @@
+/**
+ * Which account each harness is signed in with on this machine, read from
+ * the files the harnesses keep themselves. Used for one thing: telling the
+ * person, before a subscription Agent launches, which login is about to be
+ * used. Nothing here is sent anywhere; tokens are never read, only the
+ * account fields beside them.
+ */
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+async function jsonFile(file) {
+    try {
+        const parsed = JSON.parse(await readFile(file, "utf8"));
+        return parsed && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function str(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+/** The claims of a JWT, unverified; only the account fields are looked at. */
+function jwtClaims(token) {
+    if (typeof token !== "string")
+        return undefined;
+    const parts = token.split(".");
+    if (parts.length !== 3)
+        return undefined;
+    try {
+        const parsed = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+        return parsed && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Claude Code keeps the signed-in account (not the token) in `~/.claude.json`
+ * under `oauthAccount`; Codex keeps its ChatGPT login in `auth.json` under
+ * the home it runs with. Grok Build and Kimi Code are asked nothing: their
+ * accounts are read off the wire by the proxy.
+ */
+export async function localLogin(vendor, opts = {}) {
+    const home = opts.home ?? homedir();
+    if (vendor === "anthropic") {
+        const account = (await jsonFile(path.join(home, ".claude.json")))?.oauthAccount;
+        if (!account)
+            return undefined;
+        const email = str(account.emailAddress);
+        const plan = str(account.organizationRateLimitTier) ?? str(account.organizationType);
+        const accountId = str(account.organizationUuid);
+        return { ...(email ? { email } : {}), ...(plan ? { plan } : {}), ...(accountId ? { accountId } : {}) };
+    }
+    if (vendor === "openai") {
+        const auth = await jsonFile(path.join(opts.codexHome ?? path.join(home, ".codex"), "auth.json"));
+        const tokens = auth?.tokens;
+        if (!tokens)
+            return undefined;
+        const claims = jwtClaims(tokens.id_token);
+        const authClaims = claims?.["https://api.openai.com/auth"];
+        const email = str(claims?.email);
+        const plan = str(authClaims?.chatgpt_plan_type);
+        const accountId = str(tokens.account_id) ?? str(authClaims?.chatgpt_account_id);
+        return { ...(email ? { email } : {}), ...(plan ? { plan } : {}), ...(accountId ? { accountId } : {}) };
+    }
+    return undefined;
+}
+/** "me@x.com (Claude Max 20x)" or nothing worth saying. */
+export function describeLogin(login) {
+    if (!login)
+        return undefined;
+    const plan = login.plan?.replace(/^default_/, "").replaceAll("_", " ");
+    if (login.email && plan)
+        return `${login.email} (${plan})`;
+    return login.email ?? plan ?? (login.accountId ? `account ${login.accountId}` : undefined);
+}

package/dist/manage.js

@@ -59,12 +59,7 @@ export function parseFlags(argv) {
     }
     return flags;
 }
-/** `anthropic` is Claude Code, `openai` is Codex: say the harness, not the vendor. */
-const HARNESS = { anthropic: "claude", openai: "codex" };
-const plans = (t) => {
-    const subs = t.subscriptions ?? [];
-    return subs.length === 0 ? dim("-") : subs.map((s) => `${yellow(HARNESS[s.provider] ?? s.provider)}${s.plan ? dim(` ${s.plan}`) : ""}`).join(", ");
-};
+const kindOf = (t) => (t.kind === "subscription" ? yellow("subscription") : "api");
 async function tabsOf(call) {
     return (await call("GET", "/api/cli/tabs")).tabs;
 }
@@ -98,7 +93,7 @@ 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", "plans", "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, plans(t), t.projectName ?? dim("-")]), { right: [2, 3, 4] }));
+        : table(["agent", "kind", "state", "spent", "cap", "used", "window", "project"], tabs.map((t) => [t.name === t.slug ? t.slug : `${t.name} ${dim(t.slug)}`, kindOf(t), state(t.state), money(t.spentCents), money(t.capCents), pct(t.spentCents, t.capCents), t.window, t.projectName ?? dim("-")]), { right: [3, 4, 5] }));
     return 0;
 }
 export async function setState(config, flags, next) {
@@ -146,55 +141,70 @@ export async function archive(config, flags, ask) {
     return 0;
 }
 /**
- * `tab subscribe claude [--plan "Claude Max 5x"] [--price 100]` and
- * `tab unsubscribe codex`: which harness of an Agent runs on the person's
- * own plan. The subscription belongs to the harness, so Claude Code can be
- * on Max while Codex and Grok on the same Agent stay on the meter. On a
- * plan the vendor pays; the tab still gates every call and records it at
- * list price as a shadow row, and the seat's monthly price sits beside the
- * meter in the project rollup.
+ * `tab agent create <name> [--subscription|--api] [--cap 50]` makes an Agent
+ * of one of the two kinds; `tab agent kind <agent> api|subscription` changes
+ * it. A subscription Agent's harnesses (Claude Code, Codex, Grok, Kimi Code)
+ * bring their own logins: every call is still gated by the tab and recorded
+ * at list price, filed under the account the vendor names, never charged.
  */
-export async function subscribe(config, flags, on) {
+export async function agent(config, flags) {
     const call = api(config);
-    const verb = on ? "subscribe" : "unsubscribe";
-    const [harness, given] = flags.args;
-    if (!harness)
-        throw new ManageError(`tab ${verb} claude|codex [agent]${on ? ' [--plan "Claude Max 5x"] [--price 100]' : ""}`);
-    const slug = await resolveSlug(call, given);
-    const path = `/api/cli/tabs/${encodeURIComponent(slug)}/subscriptions/${encodeURIComponent(harness.toLowerCase())}`;
-    const body = {};
-    if (flags.opts.plan !== undefined)
-        body.plan = flags.opts.plan;
-    if (flags.opts.price !== undefined)
-        body.monthlyDollars = flags.opts.price.replace(/^\$/, "");
-    const { tab } = await call(on ? "PUT" : "DELETE", path, on ? body : undefined);
-    const provider = harness.toLowerCase() === "codex" || harness.toLowerCase() === "chatgpt" || harness.toLowerCase() === "openai" ? "openai" : "anthropic";
-    const seat = (tab.subscriptions ?? []).find((s) => s.provider === provider);
-    const label = HARNESS[provider] ?? provider;
-    emit(flags.json, { tab }, () => on
-        ? `${bold(tab.name)}: ${bold(label)} runs on your own ${provider === "openai" ? "ChatGPT" : "Claude"} login${seat?.plan ? ` (${seat.plan}${seat.monthlyCents && seat.monthlyCents !== "0" ? `, ${money(seat.monthlyCents)}/mo` : ""})` : ""}.\n` +
-            `${dim(`tab ${label} uses that login from the next run. The kill switch and policies still apply; calls land in the ledger at list price, never on the tab's spend. Other harnesses stay metered.`)}`
-        : `${bold(tab.name)}: ${bold(label)} is back on the metered tab: the flock's provider key, charged to the cap.`);
-    return 0;
+    const [verb, ...rest] = flags.args;
+    if (verb === "create" || verb === "new") {
+        const name = rest.join(" ").trim();
+        if (!name)
+            throw new ManageError('tab agent create <name> [--subscription|--api] [--cap 50]');
+        const kind = flags.opts.subscription !== undefined ? "subscription" : "api";
+        const body = { name, kind };
+        if (flags.opts.cap)
+            body.capDollars = flags.opts.cap.replace(/^\$/, "");
+        const made = await call("POST", "/api/cli/agents", body);
+        // The key comes back once; it is this machine's, so keep it like tab use would.
+        const agents = { ...(config.agents ?? {}), [made.agent.slug]: { key: made.key, agentId: made.agent.id, agentName: made.agent.name } };
+        await saveConfig({ ...config, agents });
+        emit(flags.json, { agent: made.agent, kind }, () => `Created ${kind === "subscription" ? bold("subscription") : bold("API-key")} Agent ${bold(made.agent.name)} ${dim(`(${made.agent.slug})`)}; its key is saved on this machine.\n` +
+            dim(kind === "subscription"
+                ? "Its harnesses use your own logins: tab claude your Claude one, tab codex ChatGPT, tab grok SuperGrok, tab kimi Kimi. Gated and recorded, never charged. tab use picks it for a folder."
+                : "Its calls use the flock's provider key and are metered against the cap. tab use picks it for a folder."));
+        return 0;
+    }
+    if (verb === "kind" || verb === "type") {
+        const [given, wanted] = rest;
+        if (!given || !wanted)
+            throw new ManageError("tab agent kind <agent> api|subscription");
+        const slug = await resolveSlug(call, given);
+        const { tab } = await call("PATCH", `/api/cli/tabs/${encodeURIComponent(slug)}`, { kind: wanted });
+        emit(flags.json, { tab }, () => `${bold(tab.name)} is now ${tab.kind === "subscription" ? bold("a subscription Agent") + dim(": its harnesses use your own logins from the next run") : bold("an API-key Agent") + dim(": metered with the flock's key from the next run")}.`);
+        return 0;
+    }
+    throw new ManageError("tab agent create <name> [--subscription|--api] | tab agent kind <agent> api|subscription");
 }
-/** `tab quota [agent]`: what the vendor said the plan has left, on the last call. */
-export async function quota(config, flags) {
+/**
+ * `tab accounts` (also `tab quota`): every account the flock's subscription
+ * Agents were seen on, with the plan the vendor reported, its seat price,
+ * what the last 30 days would have cost at list, and what the plan has left.
+ */
+export async function accounts(config, flags) {
     const call = api(config);
-    const slug = await resolveSlug(call, flags.args[0]);
-    const { tab, quota: windows } = await call("GET", `/api/cli/tabs/${encodeURIComponent(slug)}/quota`);
-    emit(flags.json, { tab, quota: windows }, () => {
-        if ((tab.subscriptions ?? []).length === 0)
-            return `${bold(tab.name)} has no harness on a plan; ${dim("tab subscribe claude")} or ${dim("tab subscribe codex")} puts one there.`;
-        if (windows.length === 0)
-            return `${bold(tab.name)}: no quota reported yet. It shows after the first call through tab claude or tab codex.`;
+    const { accounts: list } = await call("GET", "/api/cli/accounts");
+    emit(flags.json, { accounts: list }, () => {
+        if (list.length === 0)
+            return dim("No accounts seen yet. Run tab claude or tab codex on a subscription Agent; the account shows after the first call.");
         const left = (w) => {
             const pctLeft = Math.max(0, 100 - w.usedPct);
             const paint = pctLeft <= 10 ? red : pctLeft <= 30 ? yellow : green;
-            return paint(`${pctLeft}% left`);
+            return paint(`${pctLeft}%`);
         };
-        const when = (iso) => (iso ? new Date(iso).toLocaleString() : dim("-"));
-        return (`${bold(tab.name)}  ${plans(tab)}\n` +
-            table(["provider", "window", "used", "left", "resets", "seen"], windows.map((w) => [w.provider, w.window, `${w.usedPct}%`, left(w), when(w.resetsAt), when(w.observedAt)]), { right: [2] }));
+        return table(["vendor", "account", "plan", "/month", "30d at list", "calls", "left", "agents"], list.map((a) => [
+            a.vendor,
+            a.label ?? a.email ?? dim(a.id),
+            a.planLabel ?? dim("unknown"),
+            a.monthlyCents ? money(a.monthlyCents) : dim("-"),
+            money(a.listCents),
+            String(a.calls),
+            a.quota.length === 0 ? dim("-") : a.quota.map((q) => `${q.window} ${left(q)}`).join("  "),
+            a.agents.join(", "),
+        ]), { right: [3, 4, 5] }) + `\n${dim("Set a price or label in the console, Control, Accounts.")}`;
     });
     return 0;
 }
@@ -288,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();
@@ -301,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.4";
+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.7";
+export const TAB_VERSION = "0.1.9";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanamorilabs/tab",
-  "version": "0.1.7",
+  "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.4",
-    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.4",
-    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.4",
-    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.4",
-    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.4"
+    "@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",