@hanamorilabs/tab 0.1.9 → 0.1.11

package/README.md

@@ -51,7 +51,9 @@ 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 accounts         # accounts seen: plan, seat price, 30 days at list, how much is used
+tab pool add claude work   # another Claude login in its own folder; tab claude then runs as the one with most room
+tab pool             # the logins, and how used each is; tab pool at 80 sets when to move
 tab agent kind me@joseairosa.com api   # back to the meter
 ```
 
@@ -90,7 +92,8 @@ tab <agent> [args]   claude, codex, grok, kimi, gemini, or any command, on the t
 tab use              pick or change the Agent this folder runs as (.flocktab)
 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 accounts         accounts your subscription Agents were seen on: plan, price, quota used
+tab pool             several logins of one vendor: add claude|codex <name>, at <percent>, swap auto|launch
 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

package/dist/cli.js

@@ -23,13 +23,17 @@
  * terminal, so an interactive agent behaves exactly as it does without `tab`.
  */
 import { spawn } from "node:child_process";
+import { mkdir } from "node:fs/promises";
 import { hostname } from "node:os";
+import path from "node:path";
 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, subscriptionVendorFor } from "./clients.js";
 import { describeLogin, localLogin } from "./logins.js";
 import { prepareCodexHome } from "./codex-home.js";
+import { addMember, loadPool, memberEnv, poolVendorFor, prepareClaudeMember, removeMember, savePool, usedPct } from "./pool.js";
+import { runPooled } from "./pool-run.js";
 import { ConsoleApiError, createAgent, issueAgentKey, listAgents } from "./console-api.js";
 import { consoleUrlFor, DeviceLoginError, startDeviceLogin, waitForApproval } from "./device-login.js";
 import { clearConfig, configDir, configPath, HOSTED_PROXY, isLocalProxy, loadConfig, LOCAL_PROXY, normalizeProxyUrl, presentedKey, saveConfig, } from "./config.js";
@@ -58,7 +62,10 @@ function usage() {
         cmd("use", "pick or change the Agent this folder runs as (.flocktab)"),
         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("accounts", "accounts your subscription Agents were seen on: plan, price, quota used"),
+        cmd("pool", "several logins of one vendor; tab claude runs as the one with most room"),
+        cmd("pool add claude|codex <name>", "sign another login in through the browser (--email to prefill, --dir <path> to use a folder you have)"),
+        cmd("pool at <percent>", "move to another login once this much of a window is used (default 80)"),
         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"),
@@ -511,7 +518,51 @@ async function status() {
     say(box(rows(pairs, 0).split("\n"), { title: "FlockTab", tone }));
     return tone === "ok" ? 0 : 1;
 }
-async function runAgent(name, args) {
+/** `--pool`, `--no-pool` and `--as <member>` are tab's; everything else is the harness's. */
+function takePoolFlags(argv) {
+    const args = [];
+    let noPool = false;
+    let asked = false;
+    let pinned;
+    for (let i = 0; i < argv.length; i += 1) {
+        const a = argv[i];
+        if (a === "--no-pool")
+            noPool = true;
+        else if (a === "--pool")
+            asked = true;
+        else if (a === "--as" && argv[i + 1])
+            pinned = argv[(i += 1)];
+        else if (a.startsWith("--as="))
+            pinned = a.slice(5);
+        else
+            args.push(a);
+    }
+    return { args, noPool, asked: asked || pinned !== undefined, ...(pinned ? { pinned } : {}) };
+}
+async function flockAccounts(config) {
+    return (await manage.api(config)("GET", "/api/cli/accounts")).accounts;
+}
+/** Each member with the login its folder holds and how used the vendor last said that account is. */
+async function poolStandings(config, vendor, members) {
+    const accounts = await flockAccounts(config).catch(() => []);
+    return Promise.all(members.map(async (member) => {
+        const login = await localLogin(vendor, vendor === "anthropic" ? { claudeConfigDir: member.dir } : { codexHome: path.join(member.dir, "codex") });
+        const email = login?.email;
+        const account = email ? accounts.find((a) => a.provider === vendor && a.email?.toLowerCase() === email.toLowerCase()) : undefined;
+        return { member, used: account ? usedPct(account.quota) : undefined, ...(email ? { email } : {}) };
+    }));
+}
+/** Quiet: no call of this Agent in flight, and no reply from the vendor in the last 20 seconds. */
+async function poolIdle(config, vendor, agentName) {
+    const call = manage.api(config);
+    const { rows } = await call("GET", "/api/cli/ledger?limit=20");
+    if (rows.some((r) => r.agent === agentName && r.status === "pending"))
+        return false;
+    const recent = Date.now() - 20_000;
+    return !(await flockAccounts(config)).some((a) => a.provider === vendor && new Date(a.lastSeenAt).getTime() > recent);
+}
+async function runAgent(name, argv) {
+    const { args, noPool, asked, pinned } = takePoolFlags(argv);
     const config = await ensureLogin();
     if (!config)
         return 2;
@@ -550,7 +601,20 @@ async function runAgent(name, args) {
     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") {
+    const poolVendor = auth === "subscription" ? poolVendorFor(name) : undefined;
+    const pool = poolVendor ? await loadPool() : undefined;
+    const members = (poolVendor && pool?.members[poolVendor]) || [];
+    const pooled = members.length > 0 && !noPool;
+    if (asked && !pooled) {
+        fail(auth !== "subscription"
+            ? `A pool is for subscription Agents; this folder runs as an API-key Agent. ${dim("tab agent kind <agent> subscription")}`
+            : `No ${name} logins in the pool yet. ${dim(`tab pool add ${name} <name>`)}`);
+        return 2;
+    }
+    if (pooled) {
+        // The member's folder is where the harness keeps that login; tab sets the folder, never the login.
+    }
+    else if (auth === "subscription") {
         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.`));
@@ -569,22 +633,162 @@ async function runAgent(name, args) {
             auth,
         });
     }
-    const child = spawn(spec.command, [...(spec.args ?? []), ...args], { stdio: "inherit", env });
-    return new Promise((resolve) => {
-        child.on("error", (err) => {
-            if (err.code === "ENOENT") {
-                fail(`${spec.label} is not installed (${spec.command} not on PATH). ${dim(spec.install)}`);
-                if (!knownClients().includes(name))
-                    say(dim(`Not a tab command either; see ${bold("tab help")}.`));
-                resolve(127);
-                return;
-            }
-            fail(err.message);
-            resolve(1);
+    const launch = (launchArgs, launchEnv) => {
+        const child = spawn(spec.command, [...(spec.args ?? []), ...launchArgs], { stdio: "inherit", env: launchEnv });
+        const done = new Promise((resolve) => {
+            child.on("error", (err) => {
+                if (err.code === "ENOENT") {
+                    fail(`${spec.label} is not installed (${spec.command} not on PATH). ${dim(spec.install)}`);
+                    if (!knownClients().includes(name))
+                        say(dim(`Not a tab command either; see ${bold("tab help")}.`));
+                    resolve(127);
+                    return;
+                }
+                fail(err.message);
+                resolve(1);
+            });
+            child.on("close", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
         });
-        child.on("close", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+        return { done, stop: () => void child.kill("SIGTERM") };
+    };
+    if (!pooled || !poolVendor || !pool)
+        return launch(args, env).done;
+    // Codex members each need their own home written before the first launch.
+    if (poolVendor === "openai") {
+        for (const member of members) {
+            await prepareCodexHome({ baseDir: member.dir, proxyUrl: config.proxyUrl, presentedKey: key, mode: config.mode, auth, userCodexHome: path.join(member.dir, "no-personal-login") });
+        }
+    }
+    return runPooled(args, {
+        harness: name,
+        at: pool.at,
+        swap: pool.swap,
+        ...(pinned ? { pinned } : {}),
+        standings: () => poolStandings(config, poolVendor, members),
+        idle: () => poolIdle(config, poolVendor, agent.agentName),
+        start: (standing, launchArgs) => launch(launchArgs, { ...env, ...memberEnv(poolVendor, standing.member) }),
+        wait: (ms, until) => new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(true), ms);
+            void until.then(() => {
+                clearTimeout(timer);
+                resolve(false);
+            });
+        }),
+        say: (text) => say(dim(text)),
     });
 }
+/**
+ * `tab pool`: several logins of one vendor on this machine. Each member is
+ * a folder the harness signs in to itself; tab only chooses which folder a
+ * launch uses, from the usage the vendors report.
+ */
+async function poolCommand(argv) {
+    const [sub, ...rest] = argv;
+    const pool = await loadPool();
+    const vendorOf = (word) => poolVendorFor(word === "chatgpt" ? "codex" : (word ?? ""));
+    if (sub === "at") {
+        const pct = Number(rest[0]);
+        if (!Number.isFinite(pct) || pct < 1 || pct > 100) {
+            fail("tab pool at <percent>, from 1 to 100.");
+            return 2;
+        }
+        await savePool({ ...pool, at: Math.round(pct) });
+        ok(`The pool moves to another login at ${Math.round(pct)}% used.`);
+        return 0;
+    }
+    if (sub === "swap") {
+        if (rest[0] !== "auto" && rest[0] !== "launch") {
+            fail(`tab pool swap auto|launch. ${dim("auto: relaunch into the same conversation when idle. launch: only choose when a harness starts.")}`);
+            return 2;
+        }
+        await savePool({ ...pool, swap: rest[0] });
+        ok(rest[0] === "auto" ? "The pool moves a running harness when it is idle." : "The pool only chooses at launch.");
+        return 0;
+    }
+    if (sub === "add" || sub === "remove" || sub === "rm") {
+        const vendor = vendorOf(rest[0]);
+        const flags = manage.parseFlags(rest.slice(1));
+        const memberName = flags.args[0];
+        if (!vendor || !memberName) {
+            fail(`tab pool ${sub} claude|codex <name>${sub === "add" ? " [--dir <folder>]" : ""}`);
+            return 2;
+        }
+        if (sub !== "add") {
+            await savePool(removeMember(pool, vendor, memberName));
+            ok(`Removed ${bold(memberName)} from the pool. Its folder and login are left where they are.`);
+            return 0;
+        }
+        let next;
+        try {
+            next = addMember(pool, vendor, memberName, flags.opts.dir);
+        }
+        catch (err) {
+            fail(err.message);
+            return 2;
+        }
+        const member = next.members[vendor].at(-1);
+        const loginOf = () => localLogin(vendor, vendor === "anthropic" ? { claudeConfigDir: member.dir } : { codexHome: path.join(member.dir, "codex") });
+        if (!flags.opts.dir && vendor === "anthropic")
+            await prepareClaudeMember(member.dir);
+        if (vendor === "openai")
+            await mkdir(path.join(member.dir, "codex"), { recursive: true, mode: 0o700 });
+        if (!(await loginOf())?.email) {
+            const harness = vendor === "anthropic" ? "claude" : "codex";
+            // `claude auth login` does the browser sign-in and exits: no session to open, no /login, no /exit.
+            const email = flags.opts.email ?? (memberName.includes("@") ? memberName : undefined);
+            say(dim(`Signing ${vendor === "anthropic" ? "Claude Code" : "Codex"} in for ${memberName}. Your browser opens; pick the account for this login.`));
+            // Plain launch: no proxy, no tab key. This only creates the login, in the harness's own store.
+            const loginEnv = { ...process.env, ...memberEnv(vendor, member), PATH: pathWithoutShims() };
+            for (const k of ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "OPENAI_BASE_URL", "OPENAI_API_KEY"])
+                delete loginEnv[k];
+            const run = (argv) => new Promise((resolve) => {
+                const child = spawn(harness, argv, { stdio: "inherit", env: loginEnv });
+                child.on("error", () => resolve(127));
+                child.on("close", (c) => resolve(c ?? 1));
+            });
+            let code = await run(vendor === "anthropic" ? ["auth", "login", "--claudeai", ...(email ? ["--email", email] : [])] : ["login"]);
+            if (vendor === "anthropic" && code !== 0 && code !== 127 && !(await loginOf())?.email) {
+                // A Claude Code too old for `auth login`: sign in from inside it.
+                say(dim("That did not sign in. Opening Claude Code instead: /login as this account, then /exit."));
+                code = await run([]);
+            }
+            if (code === 127) {
+                fail(`${harness} is not installed.`);
+                return 127;
+            }
+        }
+        const login = await loginOf();
+        if (!login?.email) {
+            fail(`No login found in ${member.dir}. Nothing was added; run the same command again to retry.`);
+            return 1;
+        }
+        await savePool(next);
+        ok(`${bold(memberName)} is in the pool as ${describeLogin(login)}.`);
+        return 0;
+    }
+    if (sub && sub !== "list" && sub !== "ls") {
+        fail(`Unknown: tab pool ${sub}. ${dim("tab pool | add | remove | at | swap")}`);
+        return 2;
+    }
+    const config = await ensureLogin();
+    if (!config)
+        return 2;
+    const vendors = ["anthropic", "openai"].filter((v) => (pool.members[v] ?? []).length > 0);
+    if (vendors.length === 0) {
+        say(dim(`No logins in the pool. ${bold("tab pool add claude work")} signs one in; then ${bold("tab claude")} runs as whichever has most room.`));
+        return 0;
+    }
+    for (const vendor of vendors) {
+        const standings = await poolStandings(config, vendor, pool.members[vendor]);
+        say(heading(vendor === "anthropic" ? "Claude" : "ChatGPT (Codex)"));
+        say(rows(standings.map((s) => [
+            s.member.name,
+            `${s.email ?? yellow("not signed in")}  ${s.used === undefined ? dim("not seen yet") : s.used >= pool.at ? yellow(`${Math.round(s.used)}% used`) : green(`${Math.round(s.used)}% used`)}  ${dim(s.member.dir)}`,
+        ]), 0));
+    }
+    say(dim(`Moves at ${pool.at}% used (${pool.swap === "auto" ? "also while running, when idle" : "at launch only"}). tab claude --as <name> pins one; --no-pool uses your usual login.`));
+    return 0;
+}
 /**
  * `tab alias codex claude`: shims so the plain commands run on the tab.
  * `tab alias` alone lists them; `tab unalias codex` removes one.
@@ -854,6 +1058,8 @@ async function main(argv) {
         case "agent":
         case "web":
             return managed(command, rest);
+        case "pool":
+            return poolCommand(rest);
         case "status":
             return status();
         case "log":

package/dist/logins.js

@@ -44,7 +44,9 @@ function jwtClaims(token) {
 export async function localLogin(vendor, opts = {}) {
     const home = opts.home ?? homedir();
     if (vendor === "anthropic") {
-        const account = (await jsonFile(path.join(home, ".claude.json")))?.oauthAccount;
+        // With CLAUDE_CONFIG_DIR set (a pool member), Claude Code keeps the file inside that folder.
+        const file = opts.claudeConfigDir ? path.join(opts.claudeConfigDir, ".claude.json") : path.join(home, ".claude.json");
+        const account = (await jsonFile(file))?.oauthAccount;
         if (!account)
             return undefined;
         const email = str(account.emailAddress);

package/dist/manage.js

@@ -182,7 +182,7 @@ export async function agent(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.
+ * what the last 30 days would have cost at list, and how much of the plan is used.
  */
 export async function accounts(config, flags) {
     const call = api(config);
@@ -193,9 +193,9 @@ export async function accounts(config, flags) {
         const left = (w) => {
             const pctLeft = Math.max(0, 100 - w.usedPct);
             const paint = pctLeft <= 10 ? red : pctLeft <= 30 ? yellow : green;
-            return paint(`${pctLeft}%`);
+            return paint(`${Math.min(100, Math.max(0, w.usedPct))}%`);
         };
-        return table(["vendor", "account", "plan", "/month", "30d at list", "calls", "left", "agents"], list.map((a) => [
+        return table(["vendor", "account", "plan", "/month", "30d at list", "calls", "used", "agents"], list.map((a) => [
             a.vendor,
             a.label ?? a.email ?? dim(a.id),
             a.planLabel ?? dim("unknown"),

package/dist/pool-run.js

@@ -0,0 +1,42 @@
+/**
+ * Running a harness on the pool: choose the login at launch, watch what the
+ * vendors report, and when the login in use is over the threshold while
+ * another has room, wait for a quiet moment and relaunch into the same
+ * conversation as that other login.
+ */
+import { pickMember, relaunchArgs, shouldSwap } from "./pool.js";
+const label = (s) => `${s.member.name}${s.email ? ` (${s.email})` : ""}${s.used === undefined ? "" : `, ${Math.round(s.used)}% used`}`;
+export async function runPooled(args, deps) {
+    const all = await deps.standings();
+    let current = deps.pinned ? all.find((s) => s.member.name === deps.pinned) : pickMember(all, deps.at);
+    if (!current) {
+        deps.say(deps.pinned ? `No pool member named ${deps.pinned}. See tab pool.` : "The pool is empty. Add a login with tab pool add.");
+        return 2;
+    }
+    if (!deps.pinned && (current.used ?? 0) >= deps.at)
+        deps.say(`Every login in the pool is over ${deps.at}%. Running as the least used.`);
+    let launchArgs = args;
+    for (;;) {
+        deps.say(`Pool: running as ${label(current)}.`);
+        const child = deps.start(current, launchArgs);
+        let next;
+        if (!deps.pinned && deps.swap === "auto") {
+            while (await deps.wait(deps.intervalMs ?? 60_000, child.done)) {
+                // A failed look at the console is not a reason to touch a running harness.
+                const now = await deps.standings().catch(() => undefined);
+                const to = now ? shouldSwap(now, deps.at, current.member.name) : undefined;
+                if (to && (await deps.idle().catch(() => false))) {
+                    next = to;
+                    child.stop();
+                    break;
+                }
+            }
+        }
+        const code = await child.done;
+        if (!next)
+            return code;
+        deps.say(`Pool: ${current.member.name} is over ${deps.at}%. Continuing as ${label(next)}; the conversation carries over, the vendor's prompt cache does not.`);
+        current = next;
+        launchArgs = relaunchArgs(deps.harness, args);
+    }
+}

package/dist/pool.js

@@ -0,0 +1,142 @@
+/**
+ * A subscription pool: several logins of one vendor on this machine, and the
+ * rule for which one a harness runs as. Each member is a folder the harness
+ * itself signs in to (`CLAUDE_CONFIG_DIR` for Claude Code, `CODEX_HOME` for
+ * Codex), so the login stays where the harness keeps it: `tab` never reads,
+ * copies or forwards a token. Usage comes from what the vendors report on
+ * every reply, already kept per account. When the login in use crosses the
+ * threshold and another has room, the harness is relaunched into the same
+ * conversation as that other login.
+ */
+import { chmod, mkdir, readdir, readFile, symlink, writeFile, lstat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { configDir } from "./config.js";
+export const DEFAULT_AT = 80;
+export function poolPath(env = process.env) {
+    return path.join(configDir(env), "pool.json");
+}
+export function poolVendorFor(harness) {
+    if (harness === "claude")
+        return "anthropic";
+    if (harness === "codex")
+        return "openai";
+    return undefined;
+}
+export async function loadPool(env = process.env) {
+    const empty = { at: DEFAULT_AT, swap: "auto", members: {} };
+    try {
+        const raw = JSON.parse(await readFile(poolPath(env), "utf8"));
+        const at = typeof raw.at === "number" && raw.at >= 1 && raw.at <= 100 ? raw.at : DEFAULT_AT;
+        const members = {};
+        for (const vendor of ["anthropic", "openai"]) {
+            const list = raw.members?.[vendor];
+            if (Array.isArray(list))
+                members[vendor] = list.filter((m) => typeof m?.name === "string" && typeof m?.dir === "string").map((m) => ({ name: m.name, dir: m.dir }));
+        }
+        return { at, swap: raw.swap === "launch" ? "launch" : "auto", members };
+    }
+    catch {
+        return empty;
+    }
+}
+export async function savePool(pool, env = process.env) {
+    const file = poolPath(env);
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    await writeFile(file, `${JSON.stringify(pool, null, 2)}\n`, { mode: 0o600 });
+    await chmod(file, 0o600);
+    return file;
+}
+export function addMember(pool, vendor, name, dir, env = process.env) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._@-]{0,63}$/.test(name))
+        throw new Error("A member name is letters, digits, dot, dash, underscore or @, up to 64.");
+    const list = pool.members[vendor] ?? [];
+    if (list.some((m) => m.name === name))
+        throw new Error(`${name} is already in the pool.`);
+    const member = { name, dir: dir ? path.resolve(dir) : path.join(configDir(env), "pool", vendor, name) };
+    return { ...pool, members: { ...pool.members, [vendor]: [...list, member] } };
+}
+export function removeMember(pool, vendor, name) {
+    return { ...pool, members: { ...pool.members, [vendor]: (pool.members[vendor] ?? []).filter((m) => m.name !== name) } };
+}
+/** The env that makes a harness use this member's login folder. */
+export function memberEnv(vendor, member) {
+    return vendor === "anthropic" ? { CLAUDE_CONFIG_DIR: member.dir } : { CODEX_HOME: path.join(member.dir, "codex") };
+}
+/** How used an account is: its fullest window that has not reset yet. */
+export function usedPct(quota, now = new Date()) {
+    const live = quota.filter((w) => !w.resetsAt || new Date(w.resetsAt).getTime() > now.getTime());
+    if (quota.length === 0)
+        return undefined;
+    return live.reduce((max, w) => Math.max(max, w.usedPct), 0);
+}
+const room = (s) => s.used ?? 0;
+/** Stay on the current login while it is under the threshold; else the one with most room. */
+export function pickMember(all, at, current) {
+    if (all.length === 0)
+        return undefined;
+    const now = all.find((s) => s.member.name === current);
+    if (now && room(now) < at)
+        return now;
+    return [...all].sort((a, b) => room(a) - room(b))[0];
+}
+/** The login to move to, when the current one is over and another has room. */
+export function shouldSwap(all, at, current) {
+    const now = all.find((s) => s.member.name === current);
+    if (!now || room(now) < at)
+        return undefined;
+    const best = pickMember(all, at, current);
+    return best && best.member.name !== current && room(best) < at ? best : undefined;
+}
+/** Arguments that reopen the conversation the previous login was in. */
+export function relaunchArgs(harness, args) {
+    if (harness === "codex")
+        return ["resume", "--last"];
+    const kept = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--continue" || a === "-c")
+            continue;
+        // One-shot and resume arguments belong to the first launch only.
+        if (a === "--resume" || a === "-r" || a === "-p" || a === "--print") {
+            if (args[i + 1] && !args[i + 1].startsWith("-"))
+                i += 1;
+            continue;
+        }
+        kept.push(a);
+    }
+    return [...kept, "--continue"];
+}
+const NEVER_SHARED = new Set([".credentials.json", ".claude.json", ".claude.json.backup"]);
+/**
+ * A Claude member folder: everything in `~/.claude` linked in (settings,
+ * skills, and `projects`, which is what lets `--continue` find the
+ * conversation under another login), except the login itself. The member's
+ * own `.claude.json` starts as a copy of the person's without the account.
+ */
+export async function prepareClaudeMember(dir, home = homedir()) {
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    const shared = path.join(home, ".claude");
+    for (const entry of await readdir(shared).catch(() => [])) {
+        if (NEVER_SHARED.has(entry))
+            continue;
+        const target = path.join(dir, entry);
+        if (await lstat(target).then(() => true, () => false))
+            continue;
+        await symlink(path.join(shared, entry), target);
+    }
+    const own = path.join(dir, ".claude.json");
+    if (await lstat(own).then(() => true, () => false))
+        return;
+    let seed = {};
+    try {
+        const parsed = JSON.parse(await readFile(path.join(home, ".claude.json"), "utf8"));
+        if (parsed && typeof parsed === "object")
+            seed = { ...parsed };
+    }
+    catch {
+        // No file to start from: Claude Code makes its own.
+    }
+    delete seed.oauthAccount;
+    await writeFile(own, JSON.stringify(seed), { mode: 0o600 });
+}

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

package/package.json

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