@hanamorilabs/tab 0.1.20 → 0.1.21

package/dist/cli.js

@@ -34,7 +34,7 @@ import { describeLogin, localLogin } from "./logins.js";
 import { prepareCodexHome } from "./codex-home.js";
 import { addMember, loadPool, memberEnv, memberHome, POOL_VENDORS, poolVendorFor, prepareClaudeMember, prepareSharedSessions, limitsFor, removeMember, savePool, setGuard, setThreshold, thresholdFor, usage as quotaUsage } from "./pool.js";
 import { runPooled } from "./pool-run.js";
-import { claudeSettingsArg, installStatusLine, statusline } from "./statusline.js";
+import { claudeSettingsArg, composedStatusline, installStatusLine } from "./statusline.js";
 import { renderPool } from "./pool-view.js";
 import { renderHelp } from "./help.js";
 import { findTabCommand } from "./tab-docs.js";
@@ -588,7 +588,10 @@ async function poolIdle(config, vendor, agentName) {
     const recent = Date.now() - 20_000;
     return !(await flockAccounts(config)).some((a) => a.provider === vendor && new Date(a.lastSeenAt).getTime() > recent);
 }
+/** `FLOCKTAB_TIMING=1`: one line per launch step on stderr, with the seconds since the process began. */
+const timing = process.env.FLOCKTAB_TIMING ? (label) => process.stderr.write(`  ⏱ ${(process.uptime()).toFixed(2)}s ${label}\n`) : () => undefined;
 async function runAgent(name, argv) {
+    timing("runAgent");
     const observationFlags = takeObserveFlag(argv);
     const { args, noPool, asked, pinned } = takePoolFlags(observationFlags.args);
     if (observationFlags.observe && name !== "claude" && name !== "codex") {
@@ -598,12 +601,15 @@ async function runAgent(name, argv) {
     const config = await ensureLogin();
     if (!config)
         return 2;
+    timing("login");
     // Hosted whoami below proves readiness and current Agent kind in one round trip.
     if (config.mode === "self-hosted" && !(await ensureProxy(config)))
         return 1;
+    timing("proxy");
     const agent = await resolveAgent(config, { harness: harnessOf(name) });
     if (!agent)
         return 1;
+    timing("agent");
     // 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
@@ -611,6 +617,7 @@ async function runAgent(name, argv) {
     // 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 });
+    timing("whoami");
     if (config.mode === "hosted" && "error" in me) {
         fail(me.error);
         return 1;
@@ -640,6 +647,7 @@ async function runAgent(name, argv) {
     const { spec, env } = envFor({ name, proxyUrl: config.proxyUrl, presentedKey: key, auth });
     const poolVendor = auth === "subscription" ? poolVendorFor(name) : undefined;
     const pool = poolVendor ? await loadPool() : undefined;
+    timing("pool");
     const members = (poolVendor && pool?.members[poolVendor]) || [];
     const pooled = members.length > 0 && !noPool;
     if (asked && !pooled) {
@@ -697,6 +705,7 @@ async function runAgent(name, argv) {
         });
         return { done, stop: () => void child.kill("SIGTERM") };
     };
+    timing("home");
     if (!pooled || !poolVendor || !pool)
         return launch(args, env).done.finally(() => observation?.stop().catch(() => undefined));
     // Codex members each need their own home written before the first launch;
@@ -713,14 +722,20 @@ async function runAgent(name, argv) {
             await prepareCodexHome({ baseDir: member.dir, proxyUrl: config.proxyUrl, presentedKey: key, mode: config.mode, auth, userCodexHome: path.join(member.dir, "no-personal-login") });
         }
     }
+    timing("members");
     return runPooled(args, {
         harness: name,
         limits: limitsFor(pool, poolVendor),
         swap: pool.swap,
         ...(pinned ? { pinned } : {}),
-        standings: () => poolStandings(config, poolVendor, members),
+        standings: () => poolStandings(config, poolVendor, members).finally(() => timing("standings")),
         idle: () => poolIdle(config, poolVendor, agent.agentName),
-        start: (standing, launchArgs) => launch(launchArgs, { ...env, ...memberEnv(poolVendor, standing.member) }),
+        start: (standing, launchArgs) => {
+            timing("launch");
+            // The status line says which pool login this run is on; the harness passes its environment to it.
+            const poolEnv = { FLOCKTAB_POOL_LOGIN: standing.member.name, FLOCKTAB_POOL_SIZE: String(members.length) };
+            return launch(launchArgs, { ...env, ...memberEnv(poolVendor, standing.member), ...poolEnv });
+        },
         wait: (ms, until) => new Promise((resolve) => {
             const timer = setTimeout(() => resolve(true), ms);
             void until.then(() => {
@@ -944,7 +959,7 @@ async function statuslineInstall(args) {
     if (!/^y(es)?$/i.test(go))
         return 1;
     const done = await installStatusLine(vendor, home, process.env.FLOCKTAB_DEV ? "tabdev" : "tab");
-    ok(done === "already" ? `${file} already has a status line; left as it is.` : `Added. It shows on the next ${word} launch.`);
+    ok(done === "already" ? `${file} already runs tab's status line.` : done === "composed" ? `Added after yours: the file is backed up next to it, and your own line still runs first. It shows on the next ${word} launch.` : `Added. It shows on the next ${word} launch.`);
     return 0;
 }
 /** `tab use [claude|codex|grok|kimi]`: pick or change the Agent this folder runs a harness as; bare, the folder's default. */
@@ -1187,7 +1202,9 @@ async function main(argv) {
                 console.log("FlockTab · not logged in");
                 return 0;
             }
-            console.log(await statusline(config, rest[0] && harnessOf(rest[0]) !== "any" ? harnessOf(rest[0]) : "any"));
+            // The harness hands its state on stdin; the person's own status line gets the same, and runs first.
+            const stdin = process.stdin.isTTY ? "" : await new Promise((resolve) => { let d = ""; process.stdin.setEncoding("utf8"); process.stdin.on("data", (c) => { d += c; }); process.stdin.on("end", () => resolve(d)); process.stdin.on("error", () => resolve(d)); setTimeout(() => resolve(d), 500); });
+            console.log(await composedStatusline(config, rest[0] && harnessOf(rest[0]) !== "any" ? harnessOf(rest[0]) : "any", stdin));
             return 0;
         }
         case "log":

package/dist/codex-home.js

@@ -56,6 +56,16 @@ export function codexSubscriptionParts(proxyUrl, presentedKey, model) {
                 `requires_openai_auth = true`,
                 `supports_websockets = false`,
             ].join("\n"),
+            // A session that started on an API-key Agent remembers one of the metered provider ids; on
+            // this Agent those names run the login through the tab as well.
+            ...["hosted", "self-hosted"].map((mode) => [
+                `[model_providers.${JSON.stringify(codexProviderId(mode))}]`,
+                `name = ${JSON.stringify(codexProviderId(mode))}`,
+                `base_url = ${JSON.stringify(codex)}`,
+                `wire_api = "responses"`,
+                `requires_openai_auth = true`,
+                `supports_websockets = false`,
+            ].join("\n")),
         ],
     };
 }
@@ -111,6 +121,16 @@ export function codexKeyParts(proxyUrl, model, mode = "hosted") {
                 `env_key = "OPENAI_API_KEY"`,
                 `wire_api = "responses"`,
             ].join("\n"),
+            // A session that ran on a subscription Agent remembers the `flocktab` provider. Here that name
+            // is the metered provider under another id, so the session resumes on this Agent's key
+            // instead of being refused at the passthrough.
+            [
+                `[model_providers.${CODEX_TAB_PROVIDER}]`,
+                `name = "OpenAI through FlockTab"`,
+                `base_url = ${JSON.stringify(`${proxyUrl}/v1`)}`,
+                `env_key = "OPENAI_API_KEY"`,
+                `wire_api = "responses"`,
+            ].join("\n"),
         ],
     };
 }

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

package/dist/statusline.js

@@ -5,7 +5,9 @@
  * from the console with a short cache, so a status bar that polls every
  * few seconds costs one request a minute.
  */
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
 import path from "node:path";
 import { configDir } from "./config.js";
 import { readProject } from "./project.js";
@@ -19,25 +21,38 @@ function money(cents) {
     const n = BigInt(cents);
     return `$${n / 100n}.${(n % 100n).toString().padStart(2, "0")}`;
 }
-/** "5h 36% · 7d 29%", shortest window first; nothing when the vendor said nothing yet. */
+/**
+ * "5h 36% · 7d 29%", shortest window first; nothing before the first call. A vendor that
+ * names the login but reports no usage on the wire (SuperGrok, Kimi) gets the login and says so.
+ */
 export function planLine(accounts, now = new Date()) {
     // The account most recently seen with quota: the login in use.
     const withQuota = accounts.filter((a) => a.quota.length > 0);
-    const account = withQuota[0];
+    const account = withQuota[0] ?? accounts[0];
     if (!account)
         return undefined;
+    if (account.quota.length === 0)
+        return `${account.email ?? `account ${account.externalId.slice(0, 8)}`} · usage not reported by the vendor`;
     const windows = [...account.quota]
         .filter((w) => !w.resetsAt || new Date(w.resetsAt).getTime() > now.getTime())
         .sort((a, b) => windowMinutes(a.window) - windowMinutes(b.window));
     const who = account.email ?? `account ${account.externalId.slice(0, 8)}`;
     return `${who} · ${windows.length === 0 ? "windows reset" : windows.map((w) => `${w.window} ${Math.round(w.usedPct)}%`).join(" · ")}`;
 }
-/** The line itself, from what the console said. */
-export function statusText(info, now = new Date()) {
+/** The line itself, from what the console said, and the pool login this run is on when there is one. */
+export function statusText(info, now = new Date(), pool) {
     const { tab } = info;
     const closed = tab.state !== "open";
     const head = `${tab.name}${closed ? " CLOSED" : ""}`;
     if (tab.kind === "subscription") {
+        if (pool) {
+            // The pool picked this login for the run: its own windows, not another login's that the
+            // console saw last on this Agent; the login is said once.
+            const mine = (info.accounts ?? []).filter((a) => a.email === pool.login || a.externalId === pool.login);
+            const plan = planLine(mine, now);
+            const windows = plan && plan.startsWith(`${pool.login} · `) ? plan.slice(pool.login.length + 3) : plan;
+            return `${head} · pool ${pool.login} (${pool.size}) · ${windows ?? "no call yet on this login"}`;
+        }
         return `${head} · ${planLine(info.accounts ?? [], now) ?? "no call yet"}`;
     }
     const spent = BigInt(tab.spentCents);
@@ -45,13 +60,22 @@ export function statusText(info, now = new Date()) {
     const pct = cap > 0n ? Number((spent * 100n) / cap) : 0;
     return `${head} · ${money(tab.spentCents)} of ${money(tab.capCents)} / ${tab.window} (${pct}%)`;
 }
+/** The pool login a pooled launch put in the harness's environment, which it passes on to us. */
+export function poolFromEnv(env = process.env) {
+    const login = env.FLOCKTAB_POOL_LOGIN?.trim();
+    if (!login)
+        return undefined;
+    const size = Number(env.FLOCKTAB_POOL_SIZE);
+    return { login, size: Number.isFinite(size) && size > 0 ? size : 1 };
+}
 /** The tab of this folder's Agent for `harness`, from a one-minute cache, else the console. */
 export async function statusline(config, harness, cwd = process.cwd(), env = process.env) {
     const project = await readProject(cwd, harness);
     if (!project)
         return "FlockTab · no Agent here (tab use)";
     const login = config.agents?.[project.agent];
-    const cacheFile = path.join(configDir(env), "cache", `status-${project.agent}.json`);
+    const pool = poolFromEnv(env);
+    const cacheFile = path.join(configDir(env), "cache", `status-${project.agent}${pool ? `-${pool.login.replace(/[^a-z0-9]+/gi, "_")}` : ""}.json`);
     try {
         const cached = JSON.parse(await readFile(cacheFile, "utf8"));
         if (Date.now() - cached.at < CACHE_MS)
@@ -63,7 +87,7 @@ export async function statusline(config, harness, cwd = process.cwd(), env = pro
     let text;
     try {
         const info = await api(config)("GET", `/api/cli/tabs/${encodeURIComponent(project.agent)}`);
-        text = `FlockTab · ${statusText(info)}`;
+        text = `FlockTab · ${statusText(info, new Date(), poolFromEnv(env))}`;
     }
     catch {
         return `FlockTab · ${login?.agentName ?? project.agent} · console unreachable`;
@@ -77,6 +101,83 @@ export async function statusline(config, harness, cwd = process.cwd(), env = pro
     }
     return text;
 }
+/**
+ * The status line command the person had before tab, if any. Their own files are read, never
+ * changed: Claude Code's `settings.local.json` then `settings.json`, Grok Build's `config.toml`,
+ * Kimi Code's `tui.toml`. When `tab statusline install` took the slot in a Grok or Kimi config,
+ * the original command it set aside under `<tab home>/statusline/` is what counts.
+ */
+export async function theirStatusCommand(harness, env = process.env) {
+    const ours = (cmd) => /\btab(dev)? statusline\b/.test(cmd);
+    try {
+        const saved = (await readFile(path.join(configDir(env), "statusline", `${harness}.original`), "utf8")).trim();
+        if (saved && !ours(saved))
+            return saved;
+    }
+    catch {
+        // Nothing set aside.
+    }
+    const home = env.HOME || homedir();
+    if (harness === "claude") {
+        for (const file of ["settings.local.json", "settings.json"]) {
+            try {
+                const parsed = JSON.parse(await readFile(path.join(home, ".claude", file), "utf8"));
+                const cmd = parsed.statusLine?.type === "command" ? parsed.statusLine.command?.trim() : undefined;
+                if (cmd && !ours(cmd))
+                    return cmd;
+            }
+            catch {
+                // No such file, or not JSON.
+            }
+        }
+        return undefined;
+    }
+    const file = harness === "grok" ? path.join(home, ".grok", "config.toml") : harness === "kimi" ? path.join(home, ".kimi-code", "tui.toml") : undefined;
+    if (!file)
+        return undefined;
+    try {
+        const cmd = statusCommandIn(await readFile(file, "utf8"), harness === "grok" ? "[ui.status_line]" : "[status_line]");
+        return cmd && !ours(cmd) ? cmd : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The `command = "…"` of one TOML table, read by line so no TOML parser is needed. */
+export function statusCommandIn(toml, marker) {
+    const lines = toml.split("\n");
+    const start = lines.findIndex((l) => l.trim() === marker);
+    if (start < 0)
+        return undefined;
+    for (const line of lines.slice(start + 1)) {
+        if (/^\s*\[/.test(line))
+            break;
+        const m = /^\s*command\s*=\s*"((?:[^"\\]|\\.)*)"/.exec(line);
+        if (m)
+            return m[1].replace(/\\"/g, '"');
+    }
+    return undefined;
+}
+/** Run the person's own status command with the same stdin the harness gave us; all its lines, or nothing. */
+export function runTheirs(command, stdin, env = process.env) {
+    return new Promise((resolve) => {
+        const child = spawn("/bin/sh", ["-c", command], { env, stdio: ["pipe", "pipe", "ignore"] });
+        let out = "";
+        const timer = setTimeout(() => { child.kill("SIGKILL"); resolve(undefined); }, 4000);
+        child.stdout.on("data", (d) => { out += d.toString(); });
+        child.on("error", () => { clearTimeout(timer); resolve(undefined); });
+        child.on("close", () => { clearTimeout(timer); const text = out.replace(/\s+$/, ""); resolve(text.trim() ? text : undefined); });
+        child.stdin.end(stdin);
+    });
+}
+/** tab's line added after the person's own (every line of it), never instead of it. */
+export async function composedStatusline(config, harness, stdin, env = process.env) {
+    const mine = statusline(config, harness, process.cwd(), env);
+    const theirs = await theirStatusCommand(harness === "any" ? "claude" : harness, env);
+    const output = theirs ? await runTheirs(theirs, stdin, env) : undefined;
+    const ours = await mine;
+    return output ? `${output}\n${ours}` : ours;
+}
 /**
  * How each harness is told to run `tab statusline`. Claude Code takes it on
  * the command line, so every `tab claude` has it. Grok Build and Kimi Code
@@ -95,10 +196,15 @@ export function grokStatusToml(tabBin = "tab") {
 export function kimiStatusToml(tabBin = "tab") {
     return `\n[status_line]\ncommand = "${tabBin} statusline kimi"\n`;
 }
-/** Add the status line to a harness home that does not have one. Returns what was done. */
-export async function installStatusLine(vendor, home, tabBin = "tab") {
+/**
+ * Put tab's status line into a harness home. A status line already there is not lost: the file is
+ * copied to `<file>.bak-<date>` first and the original command is set aside under
+ * `<tab home>/statusline/<harness>.original`, which `tab statusline` runs and adds its own line to.
+ */
+export async function installStatusLine(vendor, home, tabBin = "tab", tabHome = configDir()) {
     const file = vendor === "xai" ? path.join(home, "config.toml") : path.join(home, "tui.toml");
     const marker = vendor === "xai" ? "[ui.status_line]" : "[status_line]";
+    const harness = vendor === "xai" ? "grok" : "kimi";
     let current = "";
     try {
         current = await readFile(file, "utf8");
@@ -106,9 +212,25 @@ export async function installStatusLine(vendor, home, tabBin = "tab") {
     catch {
         // No file yet.
     }
-    if (current.includes(marker))
-        return "already";
     await mkdir(home, { recursive: true, mode: 0o700 });
-    await writeFile(file, `${current.replace(/\s*$/, "\n")}${vendor === "xai" ? grokStatusToml(tabBin) : kimiStatusToml(tabBin)}`);
-    return "written";
+    if (!current.includes(marker)) {
+        await writeFile(file, `${current.replace(/\s*$/, "\n")}${vendor === "xai" ? grokStatusToml(tabBin) : kimiStatusToml(tabBin)}`);
+        return "written";
+    }
+    const existing = statusCommandIn(current, marker);
+    if (!existing || /\btab(dev)? statusline\b/.test(existing))
+        return "already";
+    // Theirs stays: backed up whole, its command set aside, and run first by tab's line.
+    const stamp = new Date().toISOString().slice(0, 10);
+    await copyFile(file, `${file}.bak-${stamp}`);
+    await mkdir(path.join(tabHome, "statusline"), { recursive: true, mode: 0o700 });
+    await writeFile(path.join(tabHome, "statusline", `${harness}.original`), `${existing}\n`, { mode: 0o600 });
+    const lines = current.split("\n");
+    const start = lines.findIndex((l) => l.trim() === marker);
+    for (let i = start + 1; i < lines.length && !/^\s*\[/.test(lines[i]); i++) {
+        if (/^\s*command\s*=/.test(lines[i]))
+            lines[i] = `command = "${tabBin} statusline ${harness}"`;
+    }
+    await writeFile(file, lines.join("\n"));
+    return "composed";
 }

package/dist/tab-docs.js

@@ -279,8 +279,8 @@ export const TAB_COMMANDS = [
         usage: ["statusline [claude|codex|grok|kimi]", "statusline install grok|kimi"],
         summary: "One line for a harness's status bar: the Agent and its tab, or the plan's windows.",
         details: [
-            "Prints what this folder runs the harness as, then either spent of cap for an API-key Agent or, for a subscription, the login in use and each window's usage as the vendor last reported it (5h 36% · 7d 29%). Read from the console at most once a minute, so a status bar that refreshes every few seconds costs nothing.",
-            "Claude Code shows it on every tab claude, passed on the command line so no file of yours is touched (your own --settings wins). Grok Build and Kimi Code read a status line only from their config; a pool member gets it (that home is tab's), and tab statusline install grok|kimi adds it to your own config after asking. Codex takes no command and already shows its own limits.",
+            "Prints what this folder runs the harness as, then either spent of cap for an API-key Agent or, for a subscription, the login in use and each window's usage as the vendor last reported it (5h 36% · 7d 29%). On a pooled run it names the pool login the run is on and how many logins the pool has (pool me@x.com (4)). Read from the console at most once a minute, so a status bar that refreshes every few seconds costs nothing.",
+            "Your own status line stays. tab runs it first (Claude Code's from settings.local.json or settings.json, Grok's and Kimi's from their config, with the same stdin the harness gives) and adds its own line after it, every line of yours kept. Claude Code shows the pair on every tab claude, passed on the command line so no file of yours is touched (your own --settings wins). Grok Build and Kimi Code read a status line only from their config; a pool member gets it (that home is tab's), and tab statusline install grok|kimi puts it in your own config after asking: the file is backed up next to it first and a command already there is set aside and keeps running first. Codex takes no command and already shows its own limits.",
         ],
         examples: [
             { cmd: "tab statusline claude", what: "the line, as Claude Code's status bar would show it" },
@@ -343,15 +343,18 @@ export const TAB_COMMANDS = [
         group: "watch",
         usage: ["outside"],
         summary: "The outside-spend connections and their totals per project.",
-        details: ["Connections are made in the console (Control, Outside spend): provider admin APIs and cloud billing. They answer whether a dollar went through a tab or around it."],
+        details: [
+            "Connections are made in the console (Control, Outside spend): provider admin APIs and cloud billing. They answer whether a dollar went through a tab or around it.",
+            "The console pulls every connected source on its own, once an hour; the last sync shows per connection.",
+        ],
         see: ["spend", "project"],
     },
     {
         name: "live",
         group: "watch",
         usage: ["live"],
-        summary: "Who is working right now.",
-        details: ["Each Agent's pulse (working, recent, idle, stopped), calls per minute and last decision."],
+        summary: "Who is active right now.",
+        details: ["Each Agent's pulse (active, quiet, idle, stopped), calls per minute and last decision. Active means a call was admitted in the last minute. Quiet means calls in the last five minutes, but not the last minute."],
         options: [{ flag: "--watch N", what: "refresh every N seconds" }],
     },
     {

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanamorilabs/tab",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "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.14",
-    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.14",
-    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.14",
-    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.14",
-    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.14"
+    "@hanamorilabs/flocktab-proxy-darwin-arm64": "0.1.16",
+    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.16",
+    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.16",
+    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.16",
+    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.16"
   },
   "devDependencies": {
     "@types/node": "^22.18.6",