@hanamorilabs/tab 0.1.5 → 0.1.7

package/README.md

@@ -38,6 +38,29 @@ 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)
+
+```
+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
+```
+
+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.
+
 ## Self-hosted
 
 The proxy runs on your box and holds the provider keys; the ledger, tabs and
@@ -59,6 +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 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
@@ -76,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, 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
@@ -121,5 +147,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
 byok    provider keys on this box
 ```

package/dist/cli.js

@@ -7,6 +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 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
@@ -25,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";
@@ -53,6 +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("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"),
@@ -480,6 +486,8 @@ 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")]);
             const byok = !me.byok
                 ? dim("no provider key on this flock")
                 : me.unlock === "none"
@@ -506,9 +514,21 @@ async function runAgent(name, args) {
     const agent = await resolveAgent(config);
     if (!agent)
         return 1;
-    const key = presentedKey({ key: agent.key, unlock: config.unlock });
+    // 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 = 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 });
+    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.`));
+    }
     // An alias shim named like the agent must not be what we spawn.
     env.PATH = pathWithoutShims();
     if (spec.isolatedHome === "codex") {
@@ -517,6 +537,7 @@ async function runAgent(name, args) {
             proxyUrl: config.proxyUrl,
             presentedKey: key,
             mode: config.mode,
+            auth,
         });
     }
     const child = spawn(spec.command, [...(spec.args ?? []), ...args], { stdio: "inherit", env });
@@ -720,6 +741,12 @@ async function managed(command, rest) {
                 return await manage.outside(config, flags);
             case "live":
                 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);
         }
@@ -769,6 +796,9 @@ async function main(argv) {
         case "spend":
         case "outside":
         case "live":
+        case "quota":
+        case "subscribe":
+        case "unsubscribe":
         case "web":
             return managed(command, rest);
         case "status":

package/dist/clients.js

@@ -72,11 +72,27 @@ export function openaiBase(proxyUrl, provider) {
  * overridden on purpose: a stray `OPENAI_BASE_URL` from another tool would
  * otherwise route around the tab, which is the one thing this must not do.
  */
+/** `<proxy>/t/<key>/<provider>`: the subscription passthrough base for a vendor. */
+export function passthroughBase(proxyUrl, key, provider) {
+    return `${proxyUrl}/t/${key}/${provider}`;
+}
 export function envFor(input) {
-    const spec = clientFor(input.name);
+    const base = clientFor(input.name);
     const known = input.name in KNOWN;
+    const auth = input.auth ?? "key";
     const env = { ...(input.base ?? process.env) };
+    // Codex: pinned to the API key on a metered tab, to the ChatGPT login on a subscription.
+    const spec = base.isolatedHome === "codex"
+        ? { ...base, args: ["-c", auth === "subscription" ? 'preferred_auth_method="chatgpt"' : 'preferred_auth_method="apikey"'] }
+        : base;
     const setAnthropic = () => {
+        if (auth === "subscription") {
+            // Claude Code signs in with its own Claude account; FlockTab only moves the base URL.
+            env.ANTHROPIC_BASE_URL = passthroughBase(input.proxyUrl, input.presentedKey, "anthropic");
+            delete env.ANTHROPIC_API_KEY;
+            delete env.ANTHROPIC_AUTH_TOKEN;
+            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
@@ -84,6 +100,13 @@ export function envFor(input) {
         delete env.ANTHROPIC_AUTH_TOKEN;
     };
     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.
+            delete env.OPENAI_BASE_URL;
+            delete env.OPENAI_API_KEY;
+            return;
+        }
         env.OPENAI_BASE_URL = openaiBase(input.proxyUrl, spec.provider);
         env.OPENAI_API_KEY = input.presentedKey;
     };
@@ -99,5 +122,6 @@ export function envFor(input) {
     }
     // So the child, and anything it spawns, can tell it is on a tab.
     env.FLOCKTAB_PROXY_URL = input.proxyUrl;
+    env.FLOCKTAB_AUTH_MODE = auth;
     return { spec, env };
 }

package/dist/codex-home.js

@@ -10,8 +10,10 @@
  *
  * The person's own `~/.codex` is never read or written.
  */
-import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { chmod, copyFile, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import path from "node:path";
+import { passthroughBase } from "./clients.js";
 export function codexAuthJson(presentedKey) {
     return `${JSON.stringify({ auth_mode: "apikey", OPENAI_API_KEY: presentedKey })}\n`;
 }
@@ -19,6 +21,20 @@ export function codexAuthJson(presentedKey) {
 export function codexProviderId(mode) {
     return mode === "self-hosted" ? "FlockTab - Self-hosted" : "FlockTab - Hosted";
 }
+/**
+ * On a ChatGPT subscription Codex talks to `chatgpt_base_url` with its own
+ * login, so that is what moves: to the passthrough, where the tab keeps the
+ * record. No provider block; the default OpenAI provider is the ChatGPT one.
+ */
+export function codexSubscriptionToml(proxyUrl, presentedKey, model) {
+    const lines = [
+        `preferred_auth_method = "chatgpt"`,
+        `chatgpt_base_url = ${JSON.stringify(`${passthroughBase(proxyUrl, presentedKey, "openai")}/backend-api/`)}`,
+        ...(model ? [`model = ${JSON.stringify(model)}`] : []),
+        ``,
+    ];
+    return lines.join("\n");
+}
 export function codexConfigToml(proxyUrl, model, mode = "hosted") {
     const id = codexProviderId(mode);
     const lines = [
@@ -41,9 +57,46 @@ export async function prepareCodexHome(input) {
     await chmod(home, 0o700);
     const auth = path.join(home, "auth.json");
     const config = path.join(home, "config.toml");
-    await writeFile(auth, codexAuthJson(input.presentedKey), { mode: 0o600 });
-    await writeFile(config, codexConfigToml(input.proxyUrl, input.model, input.mode ?? "hosted"), { mode: 0o600 });
-    await chmod(auth, 0o600);
+    if (input.auth === "subscription") {
+        await adoptChatGptLogin(auth, input.userCodexHome ?? path.join(homedir(), ".codex"));
+        await writeFile(config, codexSubscriptionToml(input.proxyUrl, input.presentedKey, input.model), { mode: 0o600 });
+    }
+    else {
+        await writeFile(auth, codexAuthJson(input.presentedKey), { mode: 0o600 });
+        await chmod(auth, 0o600);
+        await writeFile(config, codexConfigToml(input.proxyUrl, input.model, input.mode ?? "hosted"), { mode: 0o600 });
+    }
     await chmod(config, 0o600);
     return home;
 }
+/**
+ * The ChatGPT login for the tab's Codex home. A login already there (from
+ * `codex login` run through `tab codex`) stays. Otherwise the person's own
+ * `~/.codex/auth.json` is copied, owner-only: same machine, same person,
+ * and `~/.codex` itself is still never written. A leftover API-key auth
+ * file from metered mode is replaced; with nothing to copy, Codex asks the
+ * person to sign in and keeps that login in the tab home.
+ */
+async function adoptChatGptLogin(auth, userCodexHome) {
+    const isApiKey = async (file) => {
+        try {
+            const parsed = JSON.parse(await readFile(file, "utf8"));
+            return parsed.auth_mode === "apikey" || (typeof parsed.OPENAI_API_KEY === "string" && parsed.OPENAI_API_KEY.startsWith("ft_"));
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const existing = await isApiKey(auth);
+    if (existing === false)
+        return "kept";
+    if (existing === true)
+        await unlink(auth).catch(() => undefined);
+    const theirs = path.join(userCodexHome, "auth.json");
+    if ((await isApiKey(theirs)) === false) {
+        await copyFile(theirs, auth);
+        await chmod(auth, 0o600);
+        return "copied";
+    }
+    return "none";
+}

package/dist/manage.js

@@ -59,6 +59,12 @@ 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(", ");
+};
 async function tabsOf(call) {
     return (await call("GET", "/api/cli/tabs")).tabs;
 }
@@ -92,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", "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] }));
+        : 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) {
@@ -139,6 +145,59 @@ export async function archive(config, flags, ask) {
     emit(flags.json, { tab, archived: true }, () => `${bold(tab.name)} archived.`);
     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.
+ */
+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 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;
+}
+/** `tab quota [agent]`: what the vendor said the plan has left, on the last call. */
+export async function quota(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 left = (w) => {
+            const pctLeft = Math.max(0, 100 - w.usedPct);
+            const paint = pctLeft <= 10 ? red : pctLeft <= 30 ? yellow : green;
+            return paint(`${pctLeft}% left`);
+        };
+        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 0;
+}
 function listOpt(raw) {
     if (raw === undefined)
         return undefined;

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

package/package.json

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