@hanamorilabs/tab 0.1.18 → 0.1.19

package/dist/codex-home.js

@@ -8,7 +8,9 @@
  * therefore points `CODEX_HOME` at a directory it owns, with an API-key auth
  * file and one provider: the tab, over the Responses wire the proxy serves.
  *
- * The person's own `~/.codex` is never read or written.
+ * The person's own `~/.codex` is never written. Its `config.toml` is read:
+ * the tab's config starts from it (approval policy, sandbox, model, MCP
+ * servers, trusted folders), with the tab's few keys layered on top.
  */
 import { chmod, copyFile, lstat, mkdir, readdir, readFile, rename, rm, symlink, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -24,40 +26,97 @@ export function codexProviderId(mode) {
 /**
  * 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.
+ * record. The provider is a ChatGPT-auth one of the tab's (`flocktab`), so
+ * Codex is told there is no WebSocket to open. Its id is what `/status` shows.
  */
-export function codexSubscriptionToml(proxyUrl, presentedKey, model) {
-    const lines = [
-        `preferred_auth_method = "chatgpt"`,
-        `chatgpt_base_url = ${JSON.stringify(`${passthroughBase(proxyUrl, presentedKey, "openai")}/backend-api/`)}`,
-        // Codex 0.155+ sends the model calls of a ChatGPT login to `openai_base_url` (fixed to
-        // chatgpt.com/backend-api/codex unless set); `chatgpt_base_url` only covers the rest.
-        `openai_base_url = ${JSON.stringify(`${passthroughBase(proxyUrl, presentedKey, "openai")}/backend-api/codex`)}`,
-        ...(model ? [`model = ${JSON.stringify(model)}`] : []),
-        ``,
+export const CODEX_TAB_PROVIDER = "flocktab";
+export function codexSubscriptionParts(proxyUrl, presentedKey, model) {
+    const codex = `${passthroughBase(proxyUrl, presentedKey, "openai")}/backend-api/codex`;
+    return {
+        top: [
+            `preferred_auth_method = "chatgpt"`,
+            `model_provider = ${JSON.stringify(CODEX_TAB_PROVIDER)}`,
+            `chatgpt_base_url = ${JSON.stringify(`${passthroughBase(proxyUrl, presentedKey, "openai")}/backend-api/`)}`,
+            // Codex 0.155+ sends the model calls of a ChatGPT login to `openai_base_url` (fixed to
+            // chatgpt.com/backend-api/codex unless set); `chatgpt_base_url` only covers the rest. Kept for a
+            // profile of the person's own that names the built-in "openai" provider: it still runs through the tab.
+            `openai_base_url = ${JSON.stringify(codex)}`,
+            ...(model ? [`model = ${JSON.stringify(model)}`] : []),
+        ],
         // Codex 0.155+ opens a WebSocket for responses on the ChatGPT provider. The tab is plain HTTP
-        // (no upgrade on either proxy), so with it on the first prompt hangs. Off, Codex uses HTTP streaming.
-        `[features]`,
-        `responses_websockets = false`,
-        `responses_websockets_v2 = false`,
-        ``,
-    ];
-    return lines.join("\n");
+        // (no upgrade on either proxy). Codex 0.155.1 ignores these two flags, so the provider below
+        // says so as well (`supports_websockets = false`); the flags stay for the builds that read them.
+        features: [`responses_websockets = false`, `responses_websockets_v2 = false`],
+        tables: [
+            [
+                `[model_providers.${CODEX_TAB_PROVIDER}]`,
+                `name = "OpenAI through FlockTab"`,
+                `base_url = ${JSON.stringify(codex)}`,
+                `wire_api = "responses"`,
+                `requires_openai_auth = true`,
+                `supports_websockets = false`,
+            ].join("\n"),
+        ],
+    };
 }
-export function codexConfigToml(proxyUrl, model, mode = "hosted") {
+export function codexSubscriptionToml(proxyUrl, presentedKey, model) {
+    const parts = codexSubscriptionParts(proxyUrl, presentedKey, model);
+    return [...parts.top, ``, `[features]`, ...parts.features, ``, ...parts.tables, ``].join("\n");
+}
+/**
+ * The person's own config with the tab's keys on top. TOML forbids a key or
+ * table twice, so the lines the tab sets are dropped from theirs first; the
+ * tab's top-level keys go before any table, its `[features]` keys join an
+ * existing `[features]` table, and its own tables go last. Trust answers
+ * Codex wrote under the tab (`[projects."…"]`) are carried from the previous
+ * tab config when the person's own file does not name that folder.
+ */
+export function layerCodexConfig(input) {
+    const setKeys = new Set([...input.top, ...(input.features ?? [])].map((line) => line.split("=")[0].trim()));
+    const kept = input.theirs
+        .split("\n")
+        .filter((line) => {
+        const key = line.split("=")[0].trim().replace(/^features\./, "");
+        return !(setKeys.has(key) && /=/.test(line));
+    })
+        .join("\n")
+        .trimEnd();
+    const lead = [...input.top, ""].join("\n");
+    let body = kept;
+    if (input.features?.length) {
+        if (/^\[features\]\s*$/m.test(body))
+            body = body.replace(/^\[features\]\s*$/m, ["[features]", ...input.features].join("\n"));
+        else
+            body = `${body}\n\n[features]\n${input.features.join("\n")}`;
+    }
+    for (const table of input.tables ?? [])
+        body = `${body}\n\n${table}`;
+    let out = `${lead}\n${body.trim()}\n`;
+    for (const block of input.previous?.match(/^\[projects\."[^"\n]+"\]\n(?:(?!\[)[^\n]*\n?)*/gm) ?? []) {
+        const header = block.split("\n")[0];
+        if (!out.includes(header))
+            out = `${out}\n${block.trimEnd()}\n`;
+    }
+    return out;
+}
+export function codexKeyParts(proxyUrl, model, mode = "hosted") {
     const id = codexProviderId(mode);
-    const lines = [
-        `model_provider = ${JSON.stringify(id)}`,
-        ...(model ? [`model = ${JSON.stringify(model)}`] : []),
-        ``,
-        `[model_providers.${JSON.stringify(id)}]`,
-        `name = ${JSON.stringify(id)}`,
-        `base_url = ${JSON.stringify(`${proxyUrl}/v1`)}`,
-        `env_key = "OPENAI_API_KEY"`,
-        `wire_api = "responses"`,
-        ``,
-    ];
-    return lines.join("\n");
+    return {
+        top: [`model_provider = ${JSON.stringify(id)}`, ...(model ? [`model = ${JSON.stringify(model)}`] : [])],
+        tables: [
+            [
+                `[model_providers.${JSON.stringify(id)}]`,
+                `name = ${JSON.stringify(id)}`,
+                `base_url = ${JSON.stringify(`${proxyUrl}/v1`)}`,
+                `env_key = "OPENAI_API_KEY"`,
+                `wire_api = "responses"`,
+            ].join("\n"),
+        ],
+    };
+}
+export function codexConfigToml(proxyUrl, model, mode = "hosted") {
+    const parts = codexKeyParts(proxyUrl, model, mode);
+    return [...parts.top, ``, ...parts.tables, ``].join("\n");
 }
 /** Write the home and return its path. Files are owner-only. */
 export async function prepareCodexHome(input) {
@@ -66,14 +125,18 @@ export async function prepareCodexHome(input) {
     await chmod(home, 0o700);
     const auth = path.join(home, "auth.json");
     const config = path.join(home, "config.toml");
+    const theirs = await readFile(input.userConfig ?? path.join(homedir(), ".codex", "config.toml"), "utf8").catch(() => "");
+    const previous = await readFile(config, "utf8").catch(() => undefined);
     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 });
+        const parts = codexSubscriptionParts(input.proxyUrl, input.presentedKey, input.model);
+        await writeFile(config, layerCodexConfig({ theirs, previous, top: parts.top, features: parts.features, tables: parts.tables }), { 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 });
+        const parts = codexKeyParts(input.proxyUrl, input.model, input.mode ?? "hosted");
+        await writeFile(config, layerCodexConfig({ theirs, previous, top: parts.top, tables: parts.tables }), { mode: 0o600 });
     }
     await chmod(config, 0o600);
     await shareConversations(home, input.userCodexHome ?? path.join(homedir(), ".codex"));

package/dist/tab-docs.js

@@ -38,7 +38,7 @@ export const TAB_COMMANDS = [
         usage: ["use", "use claude|codex|grok|kimi"],
         summary: "Pick or change the Agent this folder runs a harness as.",
         details: [
-            "An Agent is one harness on one project. tab claude and tab codex in the same folder are two Agents (that is what the plan counts), each asked for once: the first run of a harness in a folder lists the flock's Agents of that harness (and untied ones it can tie), or makes a new one named after the folder (its slug is <folder>-<harness>, since a project's Claude and Codex Agents are two) and asks its kind. The choice goes into .flocktab at the git root, one entry per harness, and a key for that Agent is minted and kept on this machine.",
+            "An Agent is one harness on one project. tab claude and tab codex in the same folder are two Agents (that is what the plan counts), each asked for once: the first run of a harness in a folder lists the flock's Agents of that harness (and untied ones it can tie), or makes a new one named <folder>-<harness> and asks its kind. The choice goes into .flocktab at the git root, one entry per harness, and a key for that Agent is minted and kept on this machine.",
             "tab use codex changes the answer for one harness; bare tab use sets the folder's default, which every other command (tab python …) runs as. An older .flocktab with a single Agent applies to every harness until one is set apart.",
             "An Agent that already holds a key on another machine can be used here too, but minting a key here replaces the one there. tab asks before doing it.",
         ],
@@ -50,20 +50,19 @@ export const TAB_COMMANDS = [
         aliases: ["codex", "grok", "kimi", "gemini", "aider", "cursor", "<command>"],
         group: "run",
         usage: ["claude [args]", "codex [args]", "grok [args]", "kimi [args]", "<any command> [args]"],
-        summary: "Run an agent on this folder's tab. Harness arguments pass through after tab's run options.",
+        summary: "Run an agent on this folder's tab. Everything after the name goes to the agent untouched.",
         details: [
             "tab sets the environment that agent reads (its base URL and key, or for Codex a home folder of its own) and starts it. It does not wrap or parse the agent's traffic; the proxy does the gating.",
+            "Codex's tab home starts from your own ~/.codex/config.toml: approval policy, sandbox mode, model and effort, MCP servers, profiles and trusted folders all apply under tab codex. Only the tab's keys (where the calls go, the flocktab provider) are layered on top.",
             "On an API-key Agent the agent presents the tab's key, the flock's provider key pays, and every call is held, settled and charged to the cap. A call that would pass the cap is refused before the provider with 402 tab_closed.",
             "On a Subscription Agent the agent keeps its own login (Claude Max, ChatGPT, SuperGrok, Kimi). The tab key rides in the base URL, the same kill switch and policies apply before the vendor is reached, the call is recorded at list price under the account the vendor names, and nothing is charged to the cap.",
             "Any other command works too: tab points both the OpenAI and the Anthropic variables at the proxy and runs it. An agent with no consumer plan on a Subscription Agent runs metered on the flock's key, and tab says so.",
             "With logins in the pool for that vendor, a Subscription Agent runs as the login with most room. See tab pool.",
-            "Opt in with tab claude --observe or tab codex --observe to show native sessions, workers and observed messages in Observability. Review and trust the added hooks in the harness normally; collection is unavailable if hooks are skipped. Only identifiers, timestamps and tool outcomes leave the machine, never prompts, message bodies or transcripts. A successful send is not a read receipt. Collection is experimental: Claude 2.1.278+ in the 2.1 family and Codex 0.155.1+ in the 0.155 family, on macOS/Linux. Offline metadata is bounded and retried on another observed launch of the same Agent; inactive queues older than seven days are removed on the next observed launch, and overflow is counted as a coverage gap.",
         ],
         options: [
             { flag: "--as <login>", what: "run as one pool login and never move off it" },
             { flag: "--no-pool", what: "ignore the pool and use the agent's usual login" },
             { flag: "--pool", what: "require the pool; fail rather than fall back when it cannot be used" },
-            { flag: "--observe", what: "opt in to metadata-only native communication hooks for this Claude/Codex launch; put before --" },
         ],
         examples: [
             { cmd: "tab claude", what: "Claude Code on this folder's tab" },
@@ -329,7 +328,7 @@ export const TAB_COMMANDS = [
         summary: "What was spent through the tab, and outside it, grouped: by Agent, project, day, or model and effort.",
         details: [
             "Meter spend is what went through FlockTab. Outside spend is what the connected billing sources report (Team plan and up), so the two can be told apart.",
-            "tab spend model lists each model with the reasoning effort the requests asked for (OpenAI's reasoning effort, Anthropic's effort or thinking budget) and the speed tier (fast, priority, flex), how many calls, what they cost and how they were paid: charged to a tab, or priced at list on a plan. The console shows the same under Spend, Models.",
+            "tab spend model lists each model with the reasoning effort the requests asked for (OpenAI's reasoning effort, Anthropic's effort or thinking budget), how many calls, what they cost and how they were paid: charged to a tab, or priced at list on a plan. The console shows the same under Spend, Models.",
         ],
         options: [
             { flag: "--by agent|project|day|model", what: "how to group" },
@@ -435,7 +434,6 @@ export const TAB_GLOSSARY = [
     { term: "Account switch", meaning: "An Agent's call landing on a different account of the same vendor than its previous one: a new login mid-session, another machine, or the pool moving. Shown on the Agent's page and under Control, Subscriptions." },
     { term: "Project", meaning: "A label grouping Agents for chargeback on FlockTab's own meter, optionally linked to a GitHub repository. Team plan and up." },
     { term: "Outside spend", meaning: "Money that did not go through a tab, read from provider admin APIs and cloud billing, so it can be told apart from metered spend. Team plan and up." },
-    { term: "Tier", also: ["service tier", "fast mode", "speed"], meaning: "A speed the request asked for, in the request's own words: OpenAI's and xAI's service_tier (fast, priority, flex), Anthropic's speed (fast). Vendors price these apart, so it is kept on every call and shown beside the model on the ledger and under Spend, Models." },
     { term: "Effort", also: ["reasoning effort", "thinking budget"], meaning: "How hard a request asked the model to think, in the request's own words: OpenAI's reasoning effort (low, medium, high, xhigh), Anthropic's effort or a thinking budget in tokens. Kept on every call, shown on the ledger and under Spend, Models, because it is where the money goes." },
     { term: "Ledger", meaning: "Every decision, one row per call: allowed, settled, refunded, blocked and why. Money is whole cents, never a fraction. If the ledger cannot be reached, no call goes out." },
     { term: "Fail closed", meaning: "When FlockTab cannot be sure a call fits (the ledger is down, the key is unknown, the unlock is missing) the call is refused rather than let through." },

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

package/package.json

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