@shardflux/cli 0.20.0 → 0.23.0

package/dist/t3-launch.js

@@ -9,7 +9,6 @@ import { conversationWorkspace, getConversation } from "./conversations.js";
 import { resolveOn } from "./thread-on-computer.js";
 import { ensureCloudClaude } from "./claude-cloud-login.js";
 import { modelChoice } from "./agent-models.js";
-import { conversationPooled } from "./account-pool.js";
 /**
  * A `t3_*` refusal raised once the workspace, conversation or thread exists names them (details.workspace_key,
  * conversation_id, t3_thread_id), so a client opens what exists instead of starting it again.
@@ -100,13 +99,22 @@ export function t3Fields(ws, project, install, started, conversation) {
 }
 /**
  * `agents open t3 <conversation>` for a conversation that runs on T3's Shardflux provider (ACP mode): T3 is brought to
- * the front with that thread's id. A conversation of another route opens its VM as T3's SSH environment.
+ * the front with that thread's id. A Codex Cloud conversation opens its Codex chat; a conversation of another route
+ * opens its VM as T3's SSH environment.
  */
 export async function openT3Conversation(ctx, conversationId, values = {}) {
+    const conversation = await getConversation(ctx, conversationId);
+    // A Codex Cloud conversation's chat is its Codex thread, which T3 Code cannot show: its existing history opens (as
+    // `agents open` does), without waking the VM, linking it to T3 or starting another conversation (0.23.0+).
+    if (conversation.route === 'codex-cloud') {
+        if (!ctx.json)
+            ctx.io.stderr.write('Codex Cloud runs this conversation, so its chat is in Codex, not T3 Code.\n');
+        const { openCodexConversation } = await import("./codex-cloud.js");
+        return openCodexConversation(ctx, conversation);
+    }
     const install = t3Install(ctx.io.env);
     if (!install)
         throw t3NotInstalled();
-    const conversation = await getConversation(ctx, conversationId);
     if (install.mode === 'acp' && conversation.route === 'acp') {
         let threadId;
         try {
@@ -130,9 +138,7 @@ export async function openT3Conversation(ctx, conversationId, values = {}) {
     let { ws } = await reopenConversation(ctx, conversation, values);
     if (values.reachable !== undefined)
         ws = await ctx.cloud().workspaces.open({ key: ws.key, ...agentReachability(values), wait: false });
-    // A pooled thread (0.18.0+) runs on the account hub, not on the account's cloud Claude login.
-    if (!conversationPooled(conversation))
-        await ensureCloudClaude(ctx, ws);
+    await ensureCloudClaude(ctx, ws);
     const { openDesktopWorkspace } = await import("./agent-target-commands.js");
     return openDesktopWorkspace(ctx, ws, 't3', install.version ?? undefined, false, undefined, install, conversationId);
 }

package/dist/t3-mode.d.ts

@@ -8,7 +8,10 @@ export declare const T3_BUNDLE_ID = "com.t3tools.t3code";
 export type T3Mode = 'acp' | 'ssh';
 export type AgentApp = 'claude' | 'codex';
 export type OpenIn = 'terminal' | 'claude-desktop' | 'web' | 'codex-app' | 't3';
-/** Where each app's new conversations can open: Claude in a terminal, Claude Desktop, claude.ai or T3; Codex in the Codex app or T3. */
+/**
+ * Where each app's new conversations can open: Claude in a terminal app, Claude Desktop, claude.ai or T3; Codex in the
+ * Codex app, a terminal app (0.21.1+ on macOS) or T3. `agents targets --json` reports them as `open_in_targets`.
+ */
 export declare const OPEN_IN_TARGETS: Record<AgentApp, readonly OpenIn[]>;
 export declare const openInTargets: (app: AgentApp, platform?: NodeJS.Platform) => readonly OpenIn[];
 /** The T3 Code `shard` uses: its .app bundle (macOS) or program (Linux, with how it was installed in `linux`). */
@@ -89,7 +92,10 @@ export declare function openInFor(ctx: Ctx, project: string | null, known?: {
 export declare function openInChoices(ctx: Ctx, project: string | null, known?: {
     clients?: readonly string[];
 }): Record<AgentApp, OpenIn>;
-/** `--open-in claude=t3,codex=t3`: validated against what is installed, then saved in agents.json. */
+/**
+ * `--open-in claude=t3,codex=t3`: validated against what is installed, then saved in agents.json. A bare target
+ * (`--open-in terminal`, 0.20.1+) is the choice of every app that opens there (terminal: Claude and Codex).
+ */
 export declare function saveOpenIn(ctx: Ctx, spec: string, status: T3Status, clients: readonly string[]): void;
 /** A T3 thread was started, then a later step failed: the error names the thread so a client opens it, never starts another. */
 export declare function t3OpenFailed(error: unknown, ref: {

package/dist/t3-mode.js

@@ -35,8 +35,11 @@ import { T3_THREAD_SCRIPT } from "./t3-thread-script.js";
 import { t3InstallScript } from "./t3-runtime.js";
 import { uploadInitialImages } from "./initial-prompt.js";
 export const T3_BUNDLE_ID = 'com.t3tools.t3code';
-/** Where each app's new conversations can open: Claude in a terminal, Claude Desktop, claude.ai or T3; Codex in the Codex app or T3. */
-export const OPEN_IN_TARGETS = { claude: ['terminal', 'claude-desktop', 'web', 't3'], codex: ['codex-app', 't3'] };
+/**
+ * Where each app's new conversations can open: Claude in a terminal app, Claude Desktop, claude.ai or T3; Codex in the
+ * Codex app, a terminal app (0.21.1+ on macOS) or T3. `agents targets --json` reports them as `open_in_targets`.
+ */
+export const OPEN_IN_TARGETS = { claude: ['terminal', 'claude-desktop', 'web', 't3'], codex: ['codex-app', 'terminal', 't3'] };
 export const openInTargets = (app, platform = process.platform) => platform === 'linux' && app === 'codex' ? ['terminal', 't3'] : OPEN_IN_TARGETS[app];
 /** T3 0.0.45's built-in defaults (DEFAULT_MODEL_BY_PROVIDER), used only when T3 in the VM has not described its models yet. */
 const T3_DEFAULT_MODEL = { claude: 'claude-fable-5-1', codex: 'gpt-6-astra' };
@@ -173,10 +176,22 @@ export function openInChoices(ctx, project, known = {}) {
     return { claude: choices.claude.target, codex: choices.codex.target };
 }
 const available = (target, status, clients) => target === 't3' ? status.installed : target === 'claude-desktop' ? clients.includes('claude-desktop') : true;
-/** `--open-in claude=t3,codex=t3`: validated against what is installed, then saved in agents.json. */
+/**
+ * `--open-in claude=t3,codex=t3`: validated against what is installed, then saved in agents.json. A bare target
+ * (`--open-in terminal`, 0.20.1+) is the choice of every app that opens there (terminal: Claude and Codex).
+ */
 export function saveOpenIn(ctx, spec, status, clients) {
     const choices = {};
-    for (const part of spec.split(',').map(s => s.trim()).filter(Boolean)) {
+    const apps = ['claude', 'codex'];
+    const parts = spec.split(',').map(s => s.trim()).filter(Boolean).flatMap(part => {
+        if (part.includes('='))
+            return [part];
+        const fits = apps.filter(app => openInTargets(app).includes(part));
+        if (!fits.length)
+            throw new UsageError(`--open-in: a target is one of ${[...new Set(apps.flatMap(app => openInTargets(app)))].join(', ')}, or app=target pairs such as claude=t3,codex=t3.`);
+        return fits.map(app => `${app}=${part}`);
+    });
+    for (const part of parts) {
         const [app, target, extra] = part.split('=').map(s => s.trim());
         if (app !== 'claude' && app !== 'codex' || !target || extra !== undefined)
             throw new UsageError('--open-in takes app=target pairs, e.g. claude=t3,codex=t3.');

package/dist/t3-phone.d.ts

@@ -12,6 +12,8 @@ export interface T3PhoneLink {
 }
 /**
  * Links a workspace for the T3 app on the phone (0.17.0+). An API key links with its creator's sign-in; starting that
- * sign-in takes the person's own session, so the sign-in comes from `shard`'s session when the key has none yet.
+ * sign-in takes the person's own session, so the sign-in comes from `shard`'s session when the key has none yet. That
+ * sign-in is for the workspace's organization: `projectId` (the workspace's project) scopes it, which a person in more
+ * than one organization needs (0.20.2+; without it the API answers 422 project_id is required).
  */
-export declare function t3PhoneLink(ctx: Ctx, workspaceId: string): Promise<T3PhoneLink>;
+export declare function t3PhoneLink(ctx: Ctx, workspaceId: string, projectId?: string): Promise<T3PhoneLink>;

package/dist/t3-phone.js

@@ -1,8 +1,11 @@
+import { t3NeedsProject } from "./account-scope.js";
 /**
  * Links a workspace for the T3 app on the phone (0.17.0+). An API key links with its creator's sign-in; starting that
- * sign-in takes the person's own session, so the sign-in comes from `shard`'s session when the key has none yet.
+ * sign-in takes the person's own session, so the sign-in comes from `shard`'s session when the key has none yet. That
+ * sign-in is for the workspace's organization: `projectId` (the workspace's project) scopes it, which a person in more
+ * than one organization needs (0.20.2+; without it the API answers 422 project_id is required).
  */
-export async function t3PhoneLink(ctx, workspaceId) {
+export async function t3PhoneLink(ctx, workspaceId, projectId) {
     const link = await ctx.cloud().t3.link(workspaceId);
     if (link.status !== 'needs_sign_in')
         return { link };
@@ -10,6 +13,11 @@ export async function t3PhoneLink(ctx, workspaceId) {
         return { link, signIn: link.sign_in };
     if (ctx.store.profile(ctx.apiUrl).session?.state !== 'active')
         return { link, needsLogin: true };
-    const flow = await ctx.account().t3.signIn();
-    return { link, signIn: flow };
+    try {
+        const flow = await ctx.account().t3.signIn(projectId ? { projectId } : {});
+        return { link, signIn: flow };
+    }
+    catch (error) {
+        throw t3NeedsProject(error) ?? error;
+    }
 }

package/dist/t3-proxy.d.ts

@@ -0,0 +1,81 @@
+import type { TomlTable } from 'smol-toml';
+import type { CellClient, Workspace } from '@shardflux/sdk';
+import type { Ctx } from './commands.js';
+type Env = Record<string, string | undefined>;
+export interface ProxyRoute {
+    /** The proxy's base URL as the setup names it. */
+    url: string;
+    /** It points at this computer. */
+    local: boolean;
+    /** Its port (the scheme's default when the URL names none). */
+    port: number;
+}
+export interface ClaudeProxy extends ProxyRoute {
+    /** The `ANTHROPIC_*` variables (and `API_TIMEOUT_MS`) Claude Code runs with. */
+    env: Record<string, string>;
+    /** The setup brings its own credential (`ANTHROPIC_AUTH_TOKEN` or `ANTHROPIC_API_KEY`). */
+    credential: boolean;
+}
+export interface CodexProxy extends ProxyRoute {
+    /** The variables the provider names (`env_key`, `env_http_headers`), or `OPENAI_BASE_URL` and `OPENAI_API_KEY`. */
+    env: Record<string, string>;
+    /** `model_provider` and its `model_providers.<id>` table; null when `OPENAI_BASE_URL` names the proxy. */
+    config: TomlTable | null;
+}
+export interface T3ProxySetup {
+    claude: ClaudeProxy | null;
+    codex: CodexProxy | null;
+}
+export interface ProxyReadOptions {
+    env: Env;
+    /** A file's text, null when it is missing or unreadable (tests replace it). */
+    read?: (path: string) => string | null;
+}
+/** A URL whose host is this computer: 127.0.0.0/8, localhost, ::1 (and 0.0.0.0, which a local listener answers on). */
+export declare function onThisComputer(url: string): boolean;
+/** The proxy each app of T3 Code's own providers uses on this computer (null: it talks to its provider directly). */
+export declare function readT3ProxySetup(opts: ProxyReadOptions): T3ProxySetup;
+export interface VmProxy {
+    /** Variables for each app's agent in the VM, with proxy URLs as the VM reaches them. */
+    env: {
+        claude: Record<string, string>;
+        codex: Record<string, string>;
+    };
+    /** Keys for the VM's ~/.codex/config.toml (null: it stays as it is). */
+    codexConfig: TomlTable | null;
+    /** The VM forwarder's hub info, when a proxy on this computer is reached through the hosted CLIProxyAPI. */
+    hubInfo: string | null;
+    /** Claude Code goes through the proxy with the setup's own credential: no Shardflux Claude sign-in is needed. */
+    claudeCredential: boolean;
+    /** Apps whose proxy only this computer reaches: their VM agents use Shardflux's sign-ins. */
+    unreachable: Array<'claude' | 'codex'>;
+    /** Of those, the apps whose proxy is a CLIProxyAPI address here: VMs reach it once it is in the account (import). */
+    importable: Array<'claude' | 'codex'>;
+}
+/** The proxy URL as a VM reaches it: one on this computer becomes the VM forwarder's address (same path). */
+export declare function vmProxyUrl(url: string): string;
+/**
+ * What a conversation VM needs to follow the setup. `hubInfo` is the account's VM hub info (vmHubInfoText), if any;
+ * `hubPorts` are the ports a CLIProxyAPI on this computer answers on (8317, and the one the import recorded).
+ */
+export declare function vmProxy(setup: T3ProxySetup, hubInfo: string | null, hubPorts?: readonly number[]): VmProxy;
+/** The T3 Code proxy setup as this account's VMs follow it (read again on every call: settings change). */
+export declare function accountVmProxy(ctx: Pick<Ctx, 'io' | 'store' | 'apiUrl' | 'addSecret'>): VmProxy;
+/**
+ * Puts what the VM's agents need in place before they start: the forwarder's hub info (0600), and the Codex provider in
+ * ~/.codex/config.toml (its other settings kept). Writes only what differs.
+ */
+export declare function prepareVmProxy(cell: Pick<CellClient, 'files'>, plan: VmProxy): Promise<void>;
+/**
+ * The VM's own T3 Code (SSH and the T3 app through T3 Connect) runs its Claude Code and Codex providers with the setup's
+ * variables, stored as T3 stores them: plain values in its settings.json, credentials in its secret store
+ * (`secrets/provider-env-<base64url instance>-<base64url name>.bin`, 0600) with `valueRedacted` in the settings. The
+ * instances' other variables and the file's other settings stay. Also places prepareVmProxy's files.
+ */
+export declare function prepareVmT3(cell: Pick<CellClient, 'files'>, plan: VmProxy): Promise<void>;
+/**
+ * Before T3 Code opens a project VM (`shard agents new|open --in t3`): its T3 Code follows the user's proxy setup. A
+ * proxy on this computer without the hosted copy is named with the import; nothing here fails the open.
+ */
+export declare function followT3ProxyInVm(ctx: Ctx, ws: Workspace): Promise<void>;
+export {};

package/dist/t3-proxy.js

@@ -0,0 +1,325 @@
+/**
+ * A T3 Code user's proxy setup (CLIProxyAPI, or any Claude- or OpenAI-compatible proxy), read the way T3 Code's own
+ * Claude Code and Codex providers run, so a Shardflux conversation in T3 Code sends its model traffic the same way
+ * (0.23.0+):
+ *
+ * - Claude Code: T3's Claude provider (its default instance `claudeAgent`, else another enabled one) runs with its
+ *   environment variables over T3's own, and Claude Code applies its settings.json `env` over both. `ANTHROPIC_BASE_URL`
+ *   names the proxy; the `ANTHROPIC_*` variables (base URL, token, models, headers) go to the VM's Claude Code.
+ * - Codex: config.toml in the provider's home (`CODEX_HOME`, default ~/.codex): a `model_provider` (the active
+ *   profile's first) with a `base_url`, else `OPENAI_BASE_URL`. The provider's table and the variables it names
+ *   (`env_key`, `env_http_headers`) go to the VM's Codex.
+ *
+ * A CLIProxyAPI on this computer (127.0.0.1, localhost or ::1 at port 8317, or the port the import recorded) is reached
+ * from VMs through the account's hosted copy (`shard cli-proxy import`), whose VM forwarder answers on
+ * http://127.0.0.1:8317. Another service on this computer stays here (the VM uses Shardflux's sign-ins); any other URL
+ * is used as written. T3 Code's default provider instance is the one followed while it is enabled.
+ * Sensitive T3 variables come from T3's secret store (`<T3 home>/userdata/secrets/*.bin`); none is ever printed.
+ */
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { parse, stringify } from 'smol-toml';
+import { ShardfluxApiError } from '@shardflux/sdk';
+import { CLI_PROXY_PORT, readHubInfo, vmHubInfoText } from "./cli-proxy-hub.js";
+import { VM_HUB_INFO_PATH } from "./cli-proxy.js";
+import { t3HomeDir } from "./t3-provider.js";
+import { AgentStateStore } from "./agent-state.js";
+const readText = (path) => { try {
+    return readFileSync(path, 'utf8');
+}
+catch {
+    return null;
+} };
+const object = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+const text = (v) => (typeof v === 'string' && v.trim() ? v.trim() : null);
+const json = (t) => { try {
+    return object(JSON.parse(t ?? ''));
+}
+catch {
+    return {};
+} };
+const httpUrl = (v) => { try {
+    return ['http:', 'https:'].includes(new URL(v).protocol);
+}
+catch {
+    return false;
+} };
+const b64 = (s) => Buffer.from(s, 'utf8').toString('base64url');
+/** A URL whose host is this computer: 127.0.0.0/8, localhost, ::1 (and 0.0.0.0, which a local listener answers on). */
+export function onThisComputer(url) {
+    let host;
+    try {
+        host = new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return host === 'localhost' || host.endsWith('.localhost') || host === '[::1]' || host === '0.0.0.0' || /^127\.\d+\.\d+\.\d+$/.test(host);
+}
+const portOf = (url) => { const u = new URL(url); return Number(u.port) || (u.protocol === 'https:' ? 443 : 80); };
+const route = (url) => ({ url, local: onThisComputer(url), port: portOf(url) });
+/**
+ * T3's enabled instances of a driver, its default one (the driver's own id) first. The default runs on the legacy
+ * `providers.<driver>` settings when it has no entry of its own. Variables marked sensitive are read from T3's secret
+ * store, as T3 does before it starts the provider.
+ */
+function t3Instances(t3, driver, read) {
+    const settings = json(read(join(t3, 'userdata', 'settings.json')));
+    const all = object(settings.providerInstances), legacy = object(object(settings.providers)[driver]);
+    const ids = Object.keys(all).filter((id) => object(all[id]).driver === driver && object(all[id]).enabled !== false);
+    if (!(driver in all) && legacy.enabled !== false)
+        ids.push(driver);
+    ids.sort((a, b) => Number(b === driver) - Number(a === driver));
+    return ids.map((id) => {
+        const entry = object(all[id]), env = {};
+        for (const v of Array.isArray(entry.environment) ? entry.environment : []) {
+            const variable = object(v), name = text(variable.name);
+            if (!name)
+                continue;
+            env[name] = variable.sensitive === true && variable.valueRedacted === true
+                ? read(join(t3, 'userdata', 'secrets', `provider-env-${b64(id)}-${b64(name)}.bin`)) ?? ''
+                : typeof variable.value === 'string' ? variable.value : '';
+        }
+        return { id, env, homePath: text(object(entry.config).homePath) ?? (id === driver ? text(legacy.homePath) : null) };
+    });
+}
+const expand = (path, home) => (path === '~' ? home : path.startsWith('~/') ? join(home, path.slice(2)) : path);
+const pick = (env, names) => {
+    const out = {};
+    for (const n of names) {
+        const v = env[n];
+        if (typeof v === 'string' && v !== '')
+            out[n] = v;
+    }
+    return out;
+};
+function claudeProxy(instance, base, home, read) {
+    const env = { ...base, ...instance?.env };
+    const dir = instance?.homePath ? expand(instance.homePath, home) : text(env.CLAUDE_CONFIG_DIR) ? expand(text(env.CLAUDE_CONFIG_DIR), home) : join(home, '.claude');
+    // Claude Code applies its settings' env over the environment it was started with.
+    for (const [k, v] of Object.entries(object(json(read(join(dir, 'settings.json'))).env)))
+        if (typeof v === 'string')
+            env[k] = v;
+    const url = text(env.ANTHROPIC_BASE_URL);
+    if (!url || !httpUrl(url))
+        return null;
+    const vars = pick(env, Object.keys(env).filter((k) => k.startsWith('ANTHROPIC_') || k === 'API_TIMEOUT_MS'));
+    return { ...route(url), env: vars, credential: Boolean(vars.ANTHROPIC_AUTH_TOKEN || vars.ANTHROPIC_API_KEY) };
+}
+function codexProxy(instance, base, home, read) {
+    const env = { ...base, ...instance?.env };
+    const dir = instance?.homePath ? expand(instance.homePath, home) : text(env.CODEX_HOME) ? expand(text(env.CODEX_HOME), home) : join(home, '.codex');
+    let config = {};
+    try {
+        config = parse(read(join(dir, 'config.toml')) ?? '');
+    }
+    catch { /* not TOML: Codex refuses it too */ }
+    const profile = object(object(config.profiles)[text(config.profile) ?? '']);
+    const id = text(profile.model_provider) ?? text(config.model_provider);
+    const provider = id ? object(object(config.model_providers)[id]) : {};
+    const url = text(provider.base_url);
+    if (id && id !== 'openai' && url && httpUrl(url)) {
+        const names = [text(provider.env_key), ...Object.values(object(provider.env_http_headers)).map(text)].filter((n) => n !== null);
+        return { ...route(url), env: pick(env, names), config: { model_provider: id, model_providers: { [id]: provider } } };
+    }
+    const openai = text(env.OPENAI_BASE_URL);
+    if (openai && httpUrl(openai))
+        return { ...route(openai), env: pick(env, ['OPENAI_BASE_URL', 'OPENAI_API_KEY']), config: null };
+    return null;
+}
+/** The proxy each app of T3 Code's own providers uses on this computer (null: it talks to its provider directly). */
+export function readT3ProxySetup(opts) {
+    const read = opts.read ?? readText, home = opts.env.HOME || homedir(), t3 = t3HomeDir(opts.env);
+    const first = (driver, fn) => {
+        // T3 Code's default instance while it is enabled; otherwise its other enabled instances, the first with a proxy.
+        const list = t3Instances(t3, driver, read);
+        for (const i of list[0]?.id === driver ? [list[0]] : list.length ? list : [null]) {
+            const found = fn(i);
+            if (found)
+                return found;
+        }
+        return null;
+    };
+    return {
+        claude: first('claudeAgent', (i) => claudeProxy(i, opts.env, home, read)),
+        codex: first('codex', (i) => codexProxy(i, opts.env, home, read)),
+    };
+}
+// ---- the VM side ---------------------------------------------------------------------------------------------------
+const VM_CODEX_CONFIG = '/home/user/.codex/config.toml';
+/** The proxy URL as a VM reaches it: one on this computer becomes the VM forwarder's address (same path). */
+export function vmProxyUrl(url) {
+    const u = new URL(url);
+    return `http://127.0.0.1:${CLI_PROXY_PORT}${u.pathname === '/' && !url.endsWith('/') ? '' : u.pathname}${u.search}`;
+}
+/**
+ * What a conversation VM needs to follow the setup. `hubInfo` is the account's VM hub info (vmHubInfoText), if any;
+ * `hubPorts` are the ports a CLIProxyAPI on this computer answers on (8317, and the one the import recorded).
+ */
+export function vmProxy(setup, hubInfo, hubPorts = [CLI_PROXY_PORT]) {
+    const out = { env: { claude: {}, codex: {} }, codexConfig: null, hubInfo: null, claudeCredential: false, unreachable: [], importable: [] };
+    const reach = (app, r) => {
+        if (!r.local)
+            return r.url;
+        if (!hubPorts.includes(r.port)) {
+            out.unreachable.push(app);
+            return null;
+        }
+        if (!hubInfo) {
+            out.unreachable.push(app);
+            out.importable.push(app);
+            return null;
+        }
+        out.hubInfo = hubInfo;
+        return vmProxyUrl(r.url);
+    };
+    if (setup.claude) {
+        const url = reach('claude', setup.claude);
+        if (url) {
+            out.env.claude = { ...setup.claude.env, ANTHROPIC_BASE_URL: url };
+            out.claudeCredential = setup.claude.credential;
+        }
+    }
+    if (setup.codex) {
+        const url = reach('codex', setup.codex);
+        if (url && setup.codex.config) {
+            const id = setup.codex.config.model_provider;
+            const provider = object(object(setup.codex.config.model_providers)[id]);
+            out.codexConfig = { model_provider: id, model_providers: { [id]: { ...provider, base_url: url } } };
+            out.env.codex = setup.codex.env;
+        }
+        else if (url)
+            out.env.codex = { ...setup.codex.env, OPENAI_BASE_URL: url };
+    }
+    return out;
+}
+/** The variables that carry a credential: kept out of every message, and in T3's secret store in a VM. */
+function secretVar(app, name) {
+    return app === 'codex' ? name !== 'OPENAI_BASE_URL' : /KEY|TOKEN|SECRET|PASSWORD|HEADER|AUTH|CREDENTIAL/i.test(name);
+}
+/** The T3 Code proxy setup as this account's VMs follow it (read again on every call: settings change). */
+export function accountVmProxy(ctx) {
+    const info = readHubInfo(ctx.store.dir, ctx.apiUrl);
+    // The port the imported CLIProxyAPI listened on here (tools that used it reach the hosted copy the same way).
+    const imported = object(new AgentStateStore(ctx.store.dir).read().cli_proxy_local);
+    const ports = [CLI_PROXY_PORT, ...(imported.api_url === ctx.apiUrl && typeof imported.port === 'number' ? [imported.port] : [])];
+    const plan = vmProxy(readT3ProxySetup({ env: ctx.io.env }), info ? vmHubInfoText(info) : null, ports);
+    for (const app of ['claude', 'codex'])
+        for (const [name, value] of Object.entries(plan.env[app]))
+            if (secretVar(app, name))
+                ctx.addSecret(value);
+    if (plan.hubInfo && info?.vm_callback_url)
+        ctx.addSecret(info.vm_callback_url);
+    return plan;
+}
+const missing = (e) => e instanceof ShardfluxApiError && e.status === 404;
+async function remoteText(cell, path) {
+    try {
+        return await cell.files.readText(path);
+    }
+    catch (error) {
+        if (missing(error))
+            return null;
+        throw error;
+    }
+}
+/**
+ * Puts what the VM's agents need in place before they start: the forwarder's hub info (0600), and the Codex provider in
+ * ~/.codex/config.toml (its other settings kept). Writes only what differs.
+ */
+export async function prepareVmProxy(cell, plan) {
+    // The VM's copy stays when it is this hub's with an address at least as new (another computer may have renewed it).
+    const hub = async (info) => {
+        const current = await remoteText(cell, VM_HUB_INFO_PATH);
+        if (current === info)
+            return;
+        const mine = json(info), theirs = json(current);
+        if (current !== null && theirs.workspace_id === mine.workspace_id && Date.parse(String(theirs.callback_created_at)) >= Date.parse(String(mine.callback_created_at)))
+            return;
+        await cell.files.write(VM_HUB_INFO_PATH, info, { mode: '0600', createParents: true });
+    };
+    const codex = async (keys) => {
+        const current = await remoteText(cell, VM_CODEX_CONFIG);
+        let config;
+        try {
+            config = parse(current ?? '');
+        }
+        catch {
+            return; /* the VM's own config is not TOML: Codex reports it there */
+        }
+        const id = keys.model_provider;
+        const next = { ...config, model_provider: id, model_providers: { ...object(config.model_providers), ...object(keys.model_providers) } };
+        // An active profile's own model_provider would win over the top-level one.
+        const active = text(config.profile), profiles = object(config.profiles);
+        if (active && active in profiles)
+            next.profiles = { ...profiles, [active]: { ...object(profiles[active]), model_provider: id } };
+        const out = stringify(next);
+        if (current === null || stringify(config) !== out)
+            await cell.files.write(VM_CODEX_CONFIG, out, { mode: '0600', createParents: true });
+    };
+    await Promise.all([plan.hubInfo ? hub(plan.hubInfo) : undefined, plan.codexConfig ? codex(plan.codexConfig) : undefined]);
+}
+const VM_T3 = '/home/user/.t3/userdata';
+/**
+ * The VM's own T3 Code (SSH and the T3 app through T3 Connect) runs its Claude Code and Codex providers with the setup's
+ * variables, stored as T3 stores them: plain values in its settings.json, credentials in its secret store
+ * (`secrets/provider-env-<base64url instance>-<base64url name>.bin`, 0600) with `valueRedacted` in the settings. The
+ * instances' other variables and the file's other settings stay. Also places prepareVmProxy's files.
+ */
+export async function prepareVmT3(cell, plan) {
+    await prepareVmProxy(cell, plan);
+    const wanted = [['claudeAgent', 'claude', plan.env.claude], ['codex', 'codex', plan.env.codex]];
+    if (wanted.every(([, , vars]) => !Object.keys(vars).length))
+        return;
+    const path = `${VM_T3}/settings.json`, current = await remoteText(cell, path);
+    let doc = {};
+    try {
+        if (current !== null)
+            doc = JSON.parse(current);
+    }
+    catch {
+        return; /* T3 reports its own unreadable settings */
+    }
+    if (!doc || typeof doc !== 'object' || Array.isArray(doc))
+        return;
+    const instances = { ...object(doc.providerInstances) }, secrets = [];
+    for (const [id, app, vars] of wanted) {
+        if (!Object.keys(vars).length)
+            continue;
+        const entry = object(instances[id]);
+        const kept = (Array.isArray(entry.environment) ? entry.environment : []).filter((v) => !(String(object(v).name) in vars));
+        const added = Object.entries(vars).map(([name, value]) => {
+            if (!secretVar(app, name))
+                return { name, value, sensitive: false };
+            secrets.push([`${VM_T3}/secrets/provider-env-${b64(id)}-${b64(name)}.bin`, value]);
+            return { name, value: '', sensitive: true, valueRedacted: true };
+        });
+        instances[id] = { ...entry, driver: id, environment: [...kept, ...added] };
+    }
+    // The secrets first: T3 reloads its settings when the file changes and reads them then.
+    await Promise.all(secrets.map(async ([p, v]) => { if ((await remoteText(cell, p)) !== v)
+        await cell.files.write(p, v, { mode: '0600', createParents: true }); }));
+    const next = `${JSON.stringify({ ...doc, providerInstances: instances }, null, 2)}\n`;
+    if (next !== current)
+        await cell.files.write(path, next, { mode: '0600', createParents: true });
+}
+/**
+ * Before T3 Code opens a project VM (`shard agents new|open --in t3`): its T3 Code follows the user's proxy setup. A
+ * proxy on this computer without the hosted copy is named with the import; nothing here fails the open.
+ */
+export async function followT3ProxyInVm(ctx, ws) {
+    const plan = accountVmProxy(ctx);
+    if (plan.importable.length) {
+        const apps = plan.importable.map((a) => (a === 'claude' ? 'Claude Code' : 'Codex')).join(' and ');
+        ctx.io.stderr.write(`Your T3 Code setup sends ${apps} through CLIProxyAPI on this computer. Cloud VMs use it once it is in your account: shard cli-proxy import\n`);
+    }
+    if (!plan.hubInfo && !plan.codexConfig && !Object.keys(plan.env.claude).length && !Object.keys(plan.env.codex).length)
+        return;
+    try {
+        await prepareVmT3(ws.cell(), plan);
+    }
+    catch (error) {
+        ctx.io.stderr.write(`T3 Code in ${ws.key} uses your Shardflux sign-ins for now: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+}