@hanamorilabs/tab 0.1.11 → 0.1.13

package/dist/pool.js

@@ -8,11 +8,14 @@
  * 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 { chmod, mkdir, readdir, readFile, readlink, symlink, unlink, writeFile, lstat } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
+import { moveInto } from "./codex-home.js";
 import { configDir } from "./config.js";
+export const POOL_VENDORS = ["anthropic", "openai", "xai", "kimi"];
 export const DEFAULT_AT = 80;
+export const DEFAULT_GUARD = 95;
 export function poolPath(env = process.env) {
     return path.join(configDir(env), "pool.json");
 }
@@ -21,20 +24,33 @@ export function poolVendorFor(harness) {
         return "anthropic";
     if (harness === "codex")
         return "openai";
+    if (harness === "grok")
+        return "xai";
+    if (harness === "kimi")
+        return "kimi";
     return undefined;
 }
 export async function loadPool(env = process.env) {
-    const empty = { at: DEFAULT_AT, swap: "auto", members: {} };
+    const empty = { at: DEFAULT_AT, atByVendor: {}, guard: DEFAULT_GUARD, guardByVendor: {}, 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 valid = (n) => typeof n === "number" && n >= 1 && n <= 100;
+        const at = valid(raw.at) ? raw.at : DEFAULT_AT;
         const members = {};
-        for (const vendor of ["anthropic", "openai"]) {
+        const atByVendor = {};
+        const guardByVendor = {};
+        for (const vendor of POOL_VENDORS) {
+            const own = raw.atByVendor?.[vendor];
+            if (valid(own))
+                atByVendor[vendor] = own;
+            const ownGuard = raw.guardByVendor?.[vendor];
+            if (valid(ownGuard))
+                guardByVendor[vendor] = ownGuard;
             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 };
+        return { at, atByVendor, guard: valid(raw.guard) ? raw.guard : DEFAULT_GUARD, guardByVendor, swap: raw.swap === "launch" ? "launch" : "auto", members };
     }
     catch {
         return empty;
@@ -47,6 +63,46 @@ export async function savePool(pool, env = process.env) {
     await chmod(file, 0o600);
     return file;
 }
+/** The threshold one vendor's logins move at: its own, else the shared one. */
+export function thresholdFor(pool, vendor) {
+    return pool.atByVendor[vendor] ?? pool.at;
+}
+/** Both limits for one vendor: its own where set, else the shared ones. */
+export function limitsFor(pool, vendor) {
+    return { at: thresholdFor(pool, vendor), guard: pool.guardByVendor[vendor] ?? pool.guard };
+}
+/** Set the weekly guard, shared or one vendor's; `undefined` for a vendor clears its override. */
+export function setGuard(pool, pct, vendor) {
+    if (pct !== undefined && (!Number.isFinite(pct) || pct < 1 || pct > 100))
+        throw new Error("A threshold is a percent from 1 to 100.");
+    if (!vendor) {
+        if (pct === undefined)
+            throw new Error("A threshold is a percent from 1 to 100.");
+        return { ...pool, guard: Math.round(pct) };
+    }
+    const guardByVendor = { ...pool.guardByVendor };
+    if (pct === undefined)
+        delete guardByVendor[vendor];
+    else
+        guardByVendor[vendor] = Math.round(pct);
+    return { ...pool, guardByVendor };
+}
+/** Set the shared threshold, or one vendor's; `undefined` for a vendor clears its override. */
+export function setThreshold(pool, pct, vendor) {
+    if (pct !== undefined && (!Number.isFinite(pct) || pct < 1 || pct > 100))
+        throw new Error("A threshold is a percent from 1 to 100.");
+    if (!vendor) {
+        if (pct === undefined)
+            throw new Error("A threshold is a percent from 1 to 100.");
+        return { ...pool, at: Math.round(pct) };
+    }
+    const atByVendor = { ...pool.atByVendor };
+    if (pct === undefined)
+        delete atByVendor[vendor];
+    else
+        atByVendor[vendor] = Math.round(pct);
+    return { ...pool, atByVendor };
+}
 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.");
@@ -59,34 +115,115 @@ export function addMember(pool, vendor, name, dir, env = process.env) {
 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. */
+/** The folder the harness itself treats as home for this member. */
+export function memberHome(vendor, member) {
+    return vendor === "openai" ? path.join(member.dir, "codex") : member.dir;
+}
+/** The env that makes a harness use this member's login folder. Each name is the harness's own. */
 export function memberEnv(vendor, member) {
-    return vendor === "anthropic" ? { CLAUDE_CONFIG_DIR: member.dir } : { CODEX_HOME: path.join(member.dir, "codex") };
+    const home = memberHome(vendor, member);
+    if (vendor === "anthropic")
+        return { CLAUDE_CONFIG_DIR: home };
+    if (vendor === "openai")
+        return { CODEX_HOME: home };
+    if (vendor === "xai")
+        return { GROK_HOME: home };
+    // Two CLIs answer to `kimi`: Kimi Code reads KIMI_CODE_HOME, the older kimi-cli KIMI_SHARE_DIR.
+    return { KIMI_CODE_HOME: home, KIMI_SHARE_DIR: home };
+}
+/**
+ * Codex, Grok Build and Kimi Code keep conversations in `sessions` inside
+ * their home. Every member links that to one place, so the login that takes
+ * over finds the conversation the other was in. A home
+ * that already has its own `sessions` is left as it is.
+ */
+export async function prepareSharedSessions(vendor, member, env = process.env, userHome = homedir()) {
+    if (vendor === "anthropic")
+        return;
+    const home = memberHome(vendor, member);
+    const link = path.join(home, "sessions");
+    const poolShared = path.join(configDir(env), "pool", vendor, ".shared", "sessions");
+    const existing = await lstat(link).catch(() => undefined);
+    const pointsAt = existing?.isSymbolicLink() ? await readlink(link).catch(() => undefined) : undefined;
+    // A folder of its own, or a link somewhere we did not choose, is left alone.
+    if (existing && pointsAt !== poolShared)
+        return;
+    // The person's own conversations where that harness has a home here, so a
+    // pooled launch can resume what was started without the pool; else one
+    // folder shared by this vendor's members.
+    const own = { openai: [".codex"], xai: [".grok"], kimi: [".kimi-code", ".kimi"] }[vendor].map((d) => path.join(userHome, d));
+    let shared = poolShared;
+    for (const dir of own) {
+        if (path.resolve(dir) !== path.resolve(home) && (await lstat(dir).then((s) => s.isDirectory(), () => false))) {
+            shared = path.join(dir, "sessions");
+            break;
+        }
+    }
+    if (existing && shared === poolShared)
+        return;
+    await mkdir(shared, { recursive: true, mode: 0o700 });
+    await mkdir(home, { recursive: true, mode: 0o700 });
+    if (existing) {
+        // An earlier link to the pool-only folder: carry its conversations over, then point at the person's own.
+        await moveInto(poolShared, shared).catch(() => undefined);
+        await unlink(link);
+    }
+    await symlink(shared, link);
+}
+/** `5h` is 300 minutes, `7d` 10080; a name that is not a length sorts last. */
+export function windowMinutes(window) {
+    const m = /^(\d+)([mhd])$/.exec(window);
+    return m ? Number(m[1]) * (m[2] === "d" ? 1440 : m[2] === "h" ? 60 : 1) : Number.MAX_SAFE_INTEGER;
 }
-/** 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());
+/**
+ * How used an account is. The short window (Claude's 5 hours, Codex's
+ * primary) is the usage: it runs out first and comes back within hours. The
+ * long one (the week) is kept apart as `longUsed`, and only matters once it
+ * is nearly spent. A window past its reset counts as nothing used.
+ */
+export function usage(quota, now = new Date()) {
     if (quota.length === 0)
-        return undefined;
-    return live.reduce((max, w) => Math.max(max, w.usedPct), 0);
+        return {};
+    const sorted = [...quota].sort((x, y) => windowMinutes(x.window) - windowMinutes(y.window));
+    const pct = (w) => (!w.resetsAt || new Date(w.resetsAt).getTime() > now.getTime() ? w.usedPct : 0);
+    const short = sorted[0];
+    const long = sorted.length > 1 ? sorted.at(-1) : undefined;
+    return { used: pct(short), ...(long ? { longUsed: pct(long) } : {}) };
 }
 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) {
+const longRoom = (s) => s.longUsed ?? 0;
+export function isOver(s, limits) {
+    return room(s) >= limits.at || longRoom(s) >= limits.guard;
+}
+/** The vendor refuses every call: a window is fully spent. */
+const spent = (s) => room(s) >= 100 || longRoom(s) >= 100;
+/** Least short-window usage first, in steps of five points; within a step, the emptier week first. */
+function byRoom(a, b) {
+    return Math.floor(room(a) / 5) - Math.floor(room(b) / 5) || longRoom(a) - longRoom(b) || room(a) - room(b);
+}
+/**
+ * Stay on the current login while it is fine; else the login with most
+ * room among those that are fine; and when none is, the least used that the
+ * vendor would still answer, rather than refusing to run.
+ */
+export function pickMember(all, limits, current) {
     if (all.length === 0)
         return undefined;
     const now = all.find((s) => s.member.name === current);
-    if (now && room(now) < at)
+    if (now && !isOver(now, limits))
         return now;
-    return [...all].sort((a, b) => room(a) - room(b))[0];
+    const fine = all.filter((s) => !isOver(s, limits)).sort(byRoom);
+    if (fine.length > 0)
+        return fine[0];
+    return [...all].sort((a, b) => Number(spent(a)) - Number(spent(b)) || byRoom(a, b))[0];
 }
-/** The login to move to, when the current one is over and another has room. */
-export function shouldSwap(all, at, current) {
+/** The login to move to, when the current one is over and another is not. */
+export function shouldSwap(all, limits, current) {
     const now = all.find((s) => s.member.name === current);
-    if (!now || room(now) < at)
+    if (!now || !isOver(now, limits))
         return undefined;
-    const best = pickMember(all, at, current);
-    return best && best.member.name !== current && room(best) < at ? best : undefined;
+    const best = pickMember(all, limits, current);
+    return best && best.member.name !== current && !isOver(best, limits) ? best : undefined;
 }
 /** Arguments that reopen the conversation the previous login was in. */
 export function relaunchArgs(harness, args) {
@@ -95,7 +232,7 @@ export function relaunchArgs(harness, args) {
     const kept = [];
     for (let i = 0; i < args.length; i += 1) {
         const a = args[i];
-        if (a === "--continue" || a === "-c")
+        if (a === "--continue" || a === "-c" || a === "-C")
             continue;
         // One-shot and resume arguments belong to the first launch only.
         if (a === "--resume" || a === "-r" || a === "-p" || a === "--print") {

package/dist/project.js

@@ -8,6 +8,14 @@
 import { access, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 export const PROJECT_FILE = ".flocktab";
+/**
+ * The file's name. `tabdev` sets `FLOCKTAB_PROJECT_FILE=.flocktabdev` so a
+ * checkout under test never rewrites the folder's real `.flocktab`.
+ */
+export function projectFileName(env = process.env) {
+    const name = env.FLOCKTAB_PROJECT_FILE?.trim();
+    return name && /^\.[A-Za-z0-9._-]{1,40}$/.test(name) ? name : PROJECT_FILE;
+}
 async function exists(file) {
     try {
         await access(file);
@@ -21,7 +29,7 @@ async function exists(file) {
 export async function findProjectFile(cwd) {
     let dir = path.resolve(cwd);
     for (;;) {
-        const candidate = path.join(dir, PROJECT_FILE);
+        const candidate = path.join(dir, projectFileName());
         if (await exists(candidate))
             return candidate;
         if (await exists(path.join(dir, ".git")))
@@ -60,7 +68,7 @@ export async function projectRoot(cwd) {
     }
 }
 export async function writeProject(dir, config) {
-    const file = path.join(dir, PROJECT_FILE);
+    const file = path.join(dir, projectFileName());
     await writeFile(file, `${JSON.stringify(config)}\n`);
     return file;
 }

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

package/dist/proxy-identity.js

@@ -0,0 +1,32 @@
+import { presentedKey } from "./config.js";
+import { requestJson } from "./network.js";
+/** A fresh authenticated identity also proves the hosted proxy is ready for this Agent. */
+export async function whoami(proxyUrl, login, fetchImpl = fetch) {
+    try {
+        const { response, body } = await requestJson(`${proxyUrl}/v1/whoami`, {
+            headers: { authorization: `Bearer ${presentedKey(login)}` },
+        }, fetchImpl);
+        if (!response.ok)
+            return {
+                error: body.error?.message ?? `whoami returned ${response.status}`,
+            };
+        if (!body.agent?.id ||
+            typeof body.agent.name !== "string" ||
+            typeof body.flock?.plan !== "string" ||
+            typeof body.byok !== "boolean") {
+            return { error: "proxy returned an invalid identity" };
+        }
+        if (body.kind !== undefined &&
+            body.kind !== "api" &&
+            body.kind !== "subscription")
+            return { error: "proxy returned an invalid Agent kind" };
+        return body;
+    }
+    catch (error) {
+        return {
+            error: error instanceof DOMException && error.name === "TimeoutError"
+                ? "proxy timed out"
+                : "proxy unreachable",
+        };
+    }
+}