@hanamorilabs/tab 0.1.6 → 0.1.7

package/README.md

@@ -41,21 +41,25 @@ you would rather not have a file or a folder, for example in CI.
 ## On a subscription (Claude Max, ChatGPT)
 
 ```
-tab use --subscription --plan "Claude Max 5x" --price 100
+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 quota         # 5h / 7d windows the vendor reported on the last call
-tab use --api-key # back to the metered tab
+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
 ```
 
-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
+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
-mode is the Agent's, read on every launch, so the console's **Runs on** panel
-and `tab use` agree. `docs/subscriptions.md` has the wire.
+rows are read on every launch, so the console's **Subscriptions** panel and
+`tab subscribe` agree. `docs/subscriptions.md` has the wire.
 
 ## Self-hosted
 
@@ -78,8 +82,9 @@ 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 use --subscription | --api-key   this Agent on your Claude Max / ChatGPT plan, or back on the meter
-tab quota [agent]    what the subscription has left: 5h and 7d windows
+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 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
@@ -97,7 +102,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, mode (meter | plan), spent of cap, window, project
+tab list                                 every Agent: state, spent of cap, window, plans (claude, codex), 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
@@ -142,6 +147,6 @@ proxy   http://127.0.0.1:8787  (self-hosted)  up
 flock   Hanamori Labs
 folder  flocktab-codex
 plan    team
-mode    metered (the flock's provider key, charged to the tab)
+plans   none; every harness on the metered tab
 byok    provider keys on this box
 ```

package/dist/cli.js

@@ -7,8 +7,9 @@
  *   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 use --subscription this folder's Agent runs on your Claude Max / ChatGPT plan
- *   tab quota              what the plan has left (5h / 7d windows) for this Agent
+ *   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 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
@@ -27,7 +28,7 @@ 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 { envFor, knownClients } from "./clients.js";
+import { clientFor, envFor, knownClients } from "./clients.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";
@@ -55,9 +56,9 @@ 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("use --subscription", "this Agent runs on your Claude Max / ChatGPT plan (--plan \"Max 5x\" --price 100)"),
-        cmd("use --api-key", "back to the metered tab with the flock's provider key"),
-        cmd("quota [agent]", "what the subscription has left: 5h and 7d windows"),
+        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("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"),
@@ -485,7 +486,8 @@ async function status() {
         }
         else {
             pairs.push(["plan", me.flock.plan]);
-            pairs.push(["mode", me.authMode === "subscription" ? `${bold("subscription")} ${dim("(your Claude Max / ChatGPT login; FlockTab keeps the record)")}` : `metered ${dim("(the flock's provider key, charged to the tab)")}`]);
+            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")]);
             const byok = !me.byok
                 ? dim("no provider key on this flock")
                 : me.unlock === "none"
@@ -512,20 +514,20 @@ async function runAgent(name, args) {
     const agent = await resolveAgent(config);
     if (!agent)
         return 1;
-    // The Agent's mode is the console's call, read fresh on every launch so a
-    // switch there (or `tab use --subscription`) applies to the next run.
+    // 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;
     const me = await whoami(config.proxyUrl, { key: agent.key, unlock: config.unlock });
-    const auth = !("error" in me) && me.authMode === "subscription" ? "subscription" : "key";
+    const auth = vendor && !("error" in me) && (me.subscriptions ?? []).includes(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") {
-        if (spec.shape === "openai" && spec.isolatedHome !== "codex") {
-            fail(`${spec.label} has no subscription route. Only Claude Code and Codex can run on a plan; switch this Agent back with ${bold("tab use --api-key")}.`);
-            return 2;
-        }
-        say(dim(`${agent.agentName} runs on your own ${spec.isolatedHome === "codex" ? "ChatGPT" : "Claude"} login; FlockTab keeps the record and the kill switch.`));
+        say(dim(`${spec.label} runs on your own ${vendor === "openai" ? "ChatGPT" : "Claude"} login; FlockTab keeps the record and the kill switch.`));
     }
     // An alias shim named like the agent must not be what we spawn.
     env.PATH = pathWithoutShims();
@@ -607,39 +609,15 @@ function pathHint() {
     say(`  ${bold(pathLine())}`);
     return 0;
 }
-/**
- * `tab use`: pick or change the Agent for this folder. With `--subscription`
- * or `--api-key` the folder's Agent (picked first if there is none) is
- * switched in the console; `--plan` and `--price` label the seat.
- */
-async function use(args) {
+/** `tab use`: pick or change the Agent for this folder. */
+async function use() {
     const config = await ensureLogin();
     if (!config)
         return 2;
-    const flags = manage.parseFlags(args);
-    const wantsSubscription = flags.opts.subscription !== undefined;
-    const wantsKey = flags.opts["api-key"] !== undefined || flags.opts.apikey !== undefined;
-    if (wantsSubscription && wantsKey) {
-        fail("Pick one: tab use --subscription or tab use --api-key.");
-        return 2;
-    }
     if (!(await ensureProxy(config)))
         return 1;
-    if (!wantsSubscription && !wantsKey) {
-        const agent = await resolveAgent(config, { pick: true });
-        return agent ? 0 : 1;
-    }
-    const agent = await resolveAgent(config);
-    if (!agent)
-        return 1;
-    try {
-        const project = await readProject(process.cwd());
-        return await manage.setAuthMode(config, flags, project?.agent ?? agent.agentName, wantsSubscription ? "subscription" : "api_key");
-    }
-    catch (err) {
-        fail(err instanceof Error ? err.message : String(err));
-        return 1;
-    }
+    const agent = await resolveAgent(config, { pick: true });
+    return agent ? 0 : 1;
 }
 /**
  * First `tab up` on a box: the provider keys the proxy will spend, typed
@@ -765,6 +743,10 @@ async function managed(command, rest) {
                 return await manage.live(config, flags);
             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);
             default:
                 return await manage.web(config, flags);
         }
@@ -790,7 +772,7 @@ async function main(argv) {
             ok("Forgot the session and keys on this machine.");
             return 0;
         case "use":
-            return use(rest);
+            return use();
         case "alias":
             return alias(rest);
         case "unalias":
@@ -815,6 +797,8 @@ async function main(argv) {
         case "outside":
         case "live":
         case "quota":
+        case "subscribe":
+        case "unsubscribe":
         case "web":
             return managed(command, rest);
         case "status":

package/dist/manage.js

@@ -59,7 +59,12 @@ export function parseFlags(argv) {
     }
     return flags;
 }
-const mode = (t) => (t.authMode === "subscription" ? `${yellow("plan")}${t.subscriptionPlan ? dim(` ${t.subscriptionPlan}`) : ""}` : "meter");
+/** `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(", ");
+};
 async function tabsOf(call) {
     return (await call("GET", "/api/cli/tabs")).tabs;
 }
@@ -93,7 +98,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", "mode", "spent", "cap", "used", "window", "project"], tabs.map((t) => [t.name === t.slug ? t.slug : `${t.name} ${dim(t.slug)}`, state(t.state), mode(t), money(t.spentCents), money(t.capCents), pct(t.spentCents, t.capCents), t.window, t.projectName ?? dim("-")]), { right: [3, 4, 5] }));
+        : 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] }));
     return 0;
 }
 export async function setState(config, flags, next) {
@@ -141,25 +146,35 @@ export async function archive(config, flags, ask) {
     return 0;
 }
 /**
- * `tab use --subscription [--plan "Claude Max 5x"] [--price 100]` and
- * `tab use --api-key`: which login the Agent runs on. On a subscription the
- * vendor's plan 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 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.
  */
-export async function setAuthMode(config, flags, given, authMode) {
+export async function subscribe(config, flags, on) {
     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 body = { authMode };
+    const path = `/api/cli/tabs/${encodeURIComponent(slug)}/subscriptions/${encodeURIComponent(harness.toLowerCase())}`;
+    const body = {};
     if (flags.opts.plan !== undefined)
-        body.subscriptionPlan = flags.opts.plan;
+        body.plan = flags.opts.plan;
     if (flags.opts.price !== undefined)
-        body.subscriptionMonthlyDollars = flags.opts.price.replace(/^\$/, "");
-    const { tab } = await call("PATCH", `/api/cli/tabs/${encodeURIComponent(slug)}`, body);
-    emit(flags.json, { tab }, () => authMode === "subscription"
-        ? `${bold(tab.name)} runs on a subscription${tab.subscriptionPlan ? ` (${tab.subscriptionPlan}${tab.subscriptionMonthlyCents ? `, ${money(tab.subscriptionMonthlyCents)}/mo` : ""})` : ""}.\n` +
-            `${dim("tab claude uses your own Claude login, tab codex your ChatGPT login. The kill switch and policies still apply; calls land in the ledger at list price, never on the tab's spend.")}`
-        : `${bold(tab.name)} is back on the metered tab: the flock's provider key, charged to the cap.`);
+        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;
 }
 /** `tab quota [agent]`: what the vendor said the plan has left, on the last call. */
@@ -168,8 +183,8 @@ export async function quota(config, flags) {
     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.authMode !== "subscription")
-            return `${bold(tab.name)} is on the metered tab; ${dim("tab use --subscription")} puts it on a plan.`;
+        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 left = (w) => {
@@ -178,7 +193,7 @@ export async function quota(config, flags) {
             return paint(`${pctLeft}% left`);
         };
         const when = (iso) => (iso ? new Date(iso).toLocaleString() : dim("-"));
-        return (`${bold(tab.name)}${tab.subscriptionPlan ? dim(`  ${tab.subscriptionPlan}`) : ""}\n` +
+        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 0;

package/dist/proxy-bin.js

@@ -13,7 +13,7 @@ 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.3";
+export const PROXY_VERSION = "0.1.4";
 export const RELEASES = "https://github.com/joseairosa/flocktab/releases/download";
 export function targetFor(platform = process.platform, arch = process.arch) {
     if (platform === "darwin")

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanamorilabs/tab",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "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.3",
-    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.3",
-    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.3",
-    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.3",
-    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.3"
+    "@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"
   },
   "devDependencies": {
     "@types/node": "^22.18.6",