@shardflux/cli 0.20.0 → 0.23.0

package/dist/account-scope.js

@@ -0,0 +1,246 @@
+/**
+ * Which organization and project an account command acts in: --org/--project (id or slug), else the saved default
+ * (`shard orgs use`, `shard projects use`, `shard setup`), else the only one there is; with several the usage error
+ * lists them. Also the checks that say plainly when the saved default or the API key belongs to an organization the
+ * person is no longer in, with the command that fixes it (0.20.2+), and the project a T3 Connect sign-in is scoped by.
+ */
+import { Shardflux, ShardfluxApiError } from '@shardflux/sdk';
+import { UUID } from "./args.js";
+import { AuthConfigError, NotFoundError, UsageError } from "./errors.js";
+/** commands.ts's `str`, here so this module does not import commands.ts (which imports it). */
+const str = (v) => (typeof v === 'string' ? v : undefined);
+export async function allOrgs(account) {
+    const rows = [];
+    for await (const o of account.organizations.listAll())
+        rows.push(o);
+    return rows;
+}
+export async function allProjects(account, organizationId) {
+    const rows = [];
+    for await (const p of account.projects.listAll(organizationId))
+        rows.push(p);
+    return rows;
+}
+export const choices = (rows) => rows.map((r) => `  ${r.id}  ${r.slug}  ${r.name}`).join('\n');
+export function byRef(rows, ref) {
+    const exact = rows.find((r) => r.id === ref || r.slug === ref);
+    if (exact)
+        return exact;
+    const named = rows.filter((r) => r.name.toLowerCase() === ref.toLowerCase());
+    return named.length === 1 ? named[0] : undefined;
+}
+export const gone = (err) => err instanceof ShardfluxApiError && (err.status === 404 || err.status === 403);
+export async function findOrg(account, ref) {
+    if (UUID.test(ref)) {
+        try {
+            return await account.organizations.get(ref);
+        }
+        catch (err) {
+            if (!gone(err))
+                throw err;
+            throw new NotFoundError(`Organization ${ref} is not one of yours.`, 'list yours: shard orgs list');
+        }
+    }
+    const hit = byRef(await allOrgs(account), ref);
+    if (!hit)
+        throw new NotFoundError(`No organization "${ref}" among yours.`, 'list them: shard orgs list');
+    return hit;
+}
+/** `<slug>` of the only organization, else the placeholder: the fix commands below are exact when they can be. */
+const orgArg = (orgs) => (orgs.length === 1 ? orgs[0].slug : '<id|slug>');
+/** The fix for a saved default organization the person is no longer in. */
+export function staleDefaultOrg(saved, orgs) {
+    const list = orgs.length ? `\nYour organizations:\n${choices(orgs)}\n` : '\n';
+    return new UsageError(`Your saved default organization ${saved} is no longer one of yours (it is not in shard orgs list).${list}`, orgs.length
+        ? `save another: shard orgs use ${orgArg(orgs)}   (with a new API key for it: shard setup --org ${orgArg(orgs)} --new-key)`
+        : 'create one with a project and an API key: shard setup');
+}
+/** `ref` (a positional), else --org, else the saved default, else the only organization. */
+export async function resolveOrg(ctx, account, values, ref) {
+    const given = ref ?? str(values.org);
+    if (given !== undefined)
+        return findOrg(account, given);
+    const saved = ctx.store.profile(ctx.apiUrl).organization_id;
+    if (saved) {
+        try {
+            return await account.organizations.get(saved);
+        }
+        catch (err) {
+            if (gone(err))
+                throw staleDefaultOrg(saved, await allOrgs(account));
+            throw err;
+        }
+    }
+    const orgs = await allOrgs(account);
+    if (orgs.length === 1)
+        return orgs[0];
+    if (orgs.length === 0)
+        throw new UsageError('You have no organization yet.', 'create one with a project and an API key: shard setup (or shard orgs create <name>)');
+    throw new UsageError(`You belong to ${orgs.length} organizations; pick one with --org <id|slug>:\n${choices(orgs)}\n`, 'or save a default: shard orgs use <id|slug>');
+}
+/** `ref` (a positional), else --project, else the saved default (unless --org names another), else the only project. */
+export async function resolveProject(ctx, account, values, ref) {
+    const given = ref ?? str(values.project);
+    const orgFlag = str(values.org);
+    if (given !== undefined && UUID.test(given)) {
+        const p = await account.projects.get(given);
+        if (orgFlag !== undefined) {
+            const org = await findOrg(account, orgFlag);
+            if (p.organization_id !== org.id)
+                throw new UsageError(`project ${given} is not in organization ${org.slug}`);
+        }
+        return p;
+    }
+    const profile = ctx.store.profile(ctx.apiUrl);
+    if (given === undefined && profile.project_id && orgFlag === undefined) {
+        try {
+            return await account.projects.get(profile.project_id);
+        }
+        catch (err) {
+            if (!gone(err))
+                throw err;
+            const orgs = await allOrgs(account);
+            // The whole saved default is from an organization this person left: say that, not only "the project".
+            if (profile.organization_id && !orgs.some((o) => o.id === profile.organization_id))
+                throw staleDefaultOrg(profile.organization_id, orgs);
+            throw new NotFoundError(`The default project ${profile.project_id} is no longer available to you.`, 'pick another: shard projects use <project> (list: shard projects list)');
+        }
+    }
+    const org = await resolveOrg(ctx, account, values);
+    const projects = await allProjects(account, org.id);
+    if (given !== undefined) {
+        const hit = byRef(projects, given);
+        if (!hit)
+            throw new NotFoundError(`No project "${given}" in ${org.name} (${org.slug}).`, 'list them: shard projects list');
+        return hit;
+    }
+    const saved = profile.project_id ? projects.find((p) => p.id === profile.project_id) : undefined;
+    if (saved)
+        return saved;
+    if (projects.length === 1)
+        return projects[0];
+    if (projects.length === 0)
+        throw new UsageError(`${org.name} (${org.slug}) has no project yet.`, 'create one: shard projects create <name> (or shard setup)');
+    throw new UsageError(`${org.name} has ${projects.length} projects; pick one with --project <id|slug>:\n${choices(projects)}\n`, 'or save a default: shard projects use <id|slug>');
+}
+export async function keyScope(ctx) {
+    let token;
+    let source;
+    try {
+        ({ token, source } = ctx.apiKey());
+    }
+    catch (err) {
+        if (err instanceof AuthConfigError)
+            return null;
+        throw err;
+    }
+    try {
+        const me = await new Shardflux({ ...ctx.accountOptions(), apiKey: token }).me();
+        if (me.type !== 'api_key' || !me.api_key)
+            return null;
+        return { keyId: token.split('_')[1] ?? '', source, organizationId: me.api_key.organization_id, projectId: me.api_key.project_id };
+    }
+    catch (err) {
+        // A rejected or unreadable key is reported where it is used; here it only means "no key to compare".
+        if (err instanceof ShardfluxApiError || (err instanceof Error && /apiKey must be/.test(err.message)))
+            return null;
+        throw err;
+    }
+}
+const keyName = (k) => (k.source === 'env' ? `The API key in SHARDFLUX_API_KEY (${k.keyId})` : `The saved API key ${k.keyId}`);
+/**
+ * Plain warnings about defaults that point into an organization the signed-in person is no longer in: the saved
+ * default organization, and the API key's organization. Each names the command that fixes it.
+ */
+export function staleScopeWarnings(ctx, orgs, key) {
+    const out = [];
+    const mine = (id) => orgs.some((o) => o.id === id);
+    const arg = orgArg(orgs);
+    const saved = ctx.store.profile(ctx.apiUrl).organization_id;
+    if (saved && !mine(saved)) {
+        out.push({ code: 'default_organization_gone', message: `Your saved default organization ${saved} is no longer one of yours (it is not in shard orgs list).`, fix: `shard orgs use ${arg}` });
+    }
+    const target = orgs.find((o) => o.id === saved);
+    const warning = key ? keyOrganizationWarning(key, orgs, target) : null;
+    if (warning)
+        out.push(warning);
+    return out;
+}
+/** Compare membership before defaults: a departed organization is different from another one still accessible. */
+export function keyOrganizationWarning(key, orgs, target, projectId) {
+    const departed = !orgs.some((o) => o.id === key.organizationId);
+    if (!departed && (!target || key.organizationId === target.id))
+        return null;
+    const arg = target?.slug ?? orgArg(orgs);
+    const command = target || orgs.length ? `shard setup --org ${arg}${projectId ? ` --project ${projectId}` : ''} --new-key` : 'shard setup --new-key';
+    return {
+        code: departed ? 'api_key_organization_gone' : 'api_key_in_other_organization',
+        message: departed
+            ? `${keyName(key)} belongs to organization ${key.organizationId}, which you are no longer in; commands that use the key still act there.`
+            : keyElsewhere(key, target),
+        fix: `${command}${key.source === 'env' ? ', then unset SHARDFLUX_API_KEY' : ''}`,
+    };
+}
+/**
+ * The stale-default warnings for the signed-in person, or none: without a session (or with one the API no longer
+ * accepts) there is no list of their organizations to compare with, and the command itself goes on either way.
+ */
+export async function sessionScopeWarnings(ctx, key) {
+    if (ctx.sessionSource() === null)
+        return [];
+    let orgs;
+    try {
+        orgs = await allOrgs(ctx.account());
+    }
+    catch (err) {
+        if (err instanceof ShardfluxApiError || err instanceof AuthConfigError)
+            return [];
+        throw err;
+    }
+    return staleScopeWarnings(ctx, orgs, key);
+}
+/** Warnings on stderr, one `warning:` line and its `fix:` each (text mode). */
+export function writeWarnings(ctx, warnings) {
+    if (ctx.json)
+        return;
+    for (const w of warnings)
+        ctx.io.stderr.write(`warning: ${w.message}\nfix: ${w.fix}\n`);
+}
+/** The note for a default just saved in `org` while the API key acts in another organization (orgs use, projects use). */
+export function keyElsewhere(key, org) {
+    return `${keyName(key)} belongs to organization ${key.organizationId}, not ${org.name} (${org.slug}): workspace, agent and usage commands use the key, so they still act there.`;
+}
+// ---- T3 Connect --------------------------------------------------------------------------------------------------
+/**
+ * The project a T3 Connect sign-in is scoped by (0.20.2+). A sign-in is per person and organization, and a session in
+ * more than one organization must name one (the API answers 422 without `project_id`). --project, else a project of
+ * --org (the saved default or the key's project when it is in that organization, else its first), else the API key's
+ * project (T3 links the key's workspaces with the sign-in of the key's organization, and the onboarding row checks it
+ * with the key), else the saved default project. Undefined when none is known: one organization needs none.
+ */
+export async function t3SignInProject(ctx, values) {
+    const profile = ctx.store.profile(ctx.apiUrl);
+    const project = str(values.project);
+    if (project !== undefined && UUID.test(project) && str(values.org) === undefined)
+        return project;
+    if (project !== undefined)
+        return (await resolveProject(ctx, ctx.account(), values)).id;
+    if (str(values.org) !== undefined) {
+        const account = ctx.account();
+        const org = await resolveOrg(ctx, account, values);
+        const projects = await allProjects(account, org.id);
+        const pick = projects.find((p) => p.id === profile.project_id) ?? projects.find((p) => p.id === profile.api_key?.project_id) ?? projects[0];
+        if (!pick)
+            throw new UsageError(`${org.name} (${org.slug}) has no project yet.`, `create one: shard projects create <name> --org ${org.slug}`);
+        return pick.id;
+    }
+    // The saved key's project is in the credentials file; a key in SHARDFLUX_API_KEY (which wins) is asked where it acts.
+    const key = ctx.io.env.SHARDFLUX_API_KEY?.trim() ? (await keyScope(ctx))?.projectId : profile.api_key?.project_id;
+    return key ?? profile.project_id;
+}
+/** The API's 422 for a session in several organizations without a project (production before train 22): what to run. */
+export function t3NeedsProject(err) {
+    if (!(err instanceof ShardfluxApiError) || err.code !== 'validation_failed' || err.details?.field !== 'project_id')
+        return null;
+    return new UsageError('You belong to more than one organization, and T3 Connect signs you in for one of them.', 'name it: --project <id|slug> (or --org <id|slug>), or save a default: shard projects use <id|slug>');
+}

package/dist/acp-journal.js

@@ -1,6 +1,18 @@
 import { randomUUID } from 'node:crypto';
 import { StringDecoder } from 'node:string_decoder';
+import { setTimeout as delay } from 'node:timers/promises';
+import { ShardfluxApiError, ShardfluxProtocolError } from '@shardflux/sdk';
 import { AcpRpc } from "./acp-rpc.js";
+import { reattachDelayMs } from "./agent-terminal.js";
+const RECONNECT_BUDGET_MS = 120_000;
+function retryableRead(error) {
+    if (error instanceof ShardfluxApiError)
+        return error.retryable || ['stale_epoch', 'token_expired', 'workspace_not_running', 'workspace_busy'].includes(error.code);
+    return error instanceof TypeError || error instanceof ShardfluxProtocolError && error.status === 0;
+}
+// An input this small (every RPC but a long prompt) travels in its command's start request: one request instead of a
+// start, a stdin frame, an output stream and a cancel (0.23.0+).
+const ONE_SHOT_INPUT = 192 << 10;
 // InputACP's private, same-uid socket receipt protocol. Stdin avoids Linux's 128 KiB per-argument limit.
 export const ACP_INPUT_SCRIPT = `import json, os, socket, sys
 payload = sys.stdin.buffer.readline((2 << 20) + 1024)
@@ -70,6 +82,19 @@ export class AcpJournal {
     async #deliver(inputId, message) {
         const dir = `/home/user/.local/share/shardflux/acp/${this.#conversation}`;
         const payload = Buffer.from(`{"mode":"input","input_id":${JSON.stringify(inputId)},"message":${message}}\n`);
+        if (payload.length <= ONE_SHOT_INPUT) {
+            const r = await this.#cell.exec.run(['python3', '-c', ACP_INPUT_SCRIPT, dir], { cwd: this.#cwd, stdin: payload, timeoutMs: 15_000, maxOutputBytes: 65536, signal: this.#signal });
+            let receipt;
+            try {
+                receipt = JSON.parse(r.stdout);
+            }
+            catch {
+                receipt = undefined;
+            }
+            if (r.exitCode !== 0 || receipt?.accepted !== true)
+                throw new Error('ACP delivery is unverified; load this session before continuing.');
+            return;
+        }
         const session = await this.#cell.exec.start({ argv: ['python3', '-c', ACP_INPUT_SCRIPT, dir], cwd: this.#cwd, stdin_open: true, timeout_ms: 15_000 }, this.#signal);
         let offset = 0, stdout = '';
         try {
@@ -167,17 +192,22 @@ export class AcpJournal {
         const signal = AbortSignal.any([this.#signal, reader.signal]);
         try {
             let failures = 0;
+            let outageStarted;
             while (this.#wanted() && !signal.aborted) {
                 const decoder = new StringDecoder('utf8');
                 let tail = '', offset = 0;
+                let interruption;
                 try {
                     const session = await this.#cell.exec.start({ argv: ['sf-agent', 'acp', 'attach', '--conversation', this.#conversation, '--from-seq', String(this.#cursor.from_seq), '--follow'], cwd: this.#cwd, timeout_ms: 0 }, signal);
                     this.#follower = session.session_id;
                     for await (const event of await this.#cell.exec.output(session.session_id, { follow: true, signal })) {
-                        if (event.type === 'error')
-                            throw new Error(event.error?.error.message ?? 'ACP journal failed');
+                        if (event.type === 'error') {
+                            if (event.error)
+                                throw new ShardfluxApiError(502, event.error, 'cell');
+                            throw new Error('ACP journal failed without an error envelope');
+                        }
                         if (event.type === 'exit')
-                            throw new Error('ACP journal detached');
+                            throw new ShardfluxProtocolError('ACP journal detached', 0, 'cell');
                         if (event.type !== 'output' || event.stream !== 'stdout' || !event.data)
                             continue;
                         const bytes = Buffer.from(event.data, 'base64'), at = event.offset ?? offset;
@@ -189,8 +219,12 @@ export class AcpJournal {
                         for (let newline; (newline = tail.indexOf('\n')) >= 0;) {
                             const line = tail.slice(0, newline);
                             tail = tail.slice(newline + 1);
+                            const before = this.#cursor.from_seq;
                             await this.#entry(line);
-                            failures = 0;
+                            if (this.#cursor.from_seq > before) {
+                                failures = 0;
+                                outageStarted = undefined;
+                            }
                         }
                         if (Buffer.byteLength(tail) > 4 << 20)
                             throw new Error('ACP journal frame exceeds 4 MiB');
@@ -198,17 +232,35 @@ export class AcpJournal {
                             return;
                     }
                     if (!signal.aborted)
-                        throw new Error('ACP journal connection ended');
+                        throw new ShardfluxProtocolError('ACP journal connection ended', 0, 'cell');
                 }
                 catch (error) {
                     if (signal.aborted)
                         break;
-                    if (++failures > 3)
+                    if (!retryableRead(error))
                         throw error;
+                    outageStarted ??= performance.now();
+                    if (performance.now() - outageStarted >= RECONNECT_BUDGET_MS)
+                        throw new Error('ACP journal reconnect timed out; load this session to continue.', { cause: error });
+                    failures++;
+                    interruption = error;
                 }
                 finally {
                     await this.#detach();
                 }
+                // Retrying only the read follower cannot submit a second turn. Keep
+                // the original sequence/prompt cursor and stop waits on editor exit.
+                // A stopped reader (pause, idle) ends the wait as it ends an attach:
+                // the loop exits without closing the editor's connection.
+                if (this.#wanted() && !signal.aborted && interruption !== undefined) {
+                    try {
+                        await delay(Math.min(reattachDelayMs(interruption, failures), RECONNECT_BUDGET_MS - (performance.now() - outageStarted)), undefined, { signal });
+                    }
+                    catch (error) {
+                        if (!signal.aborted)
+                            throw error;
+                    }
+                }
             }
         }
         catch (error) {

package/dist/acp-login.d.ts

@@ -1,7 +1,9 @@
 import type { Ctx } from './commands.js';
+import type { ImportResult, LocalCliProxy } from './cli-proxy.js';
 /**
- * The ACP terminal sign-in method. An editor (T3 Code) runs `shard acp --login` in its own terminal when the user
- * chooses it, then reconnects; ACP appends these args to the configured `shard acp` invocation.
+ * The ACP terminal sign-in method. An editor runs it in its own terminal when the user chooses it, then reconnects:
+ * T3 Code appends these args to the configured `shard acp` (`shard acp --login`); ACP registry clients run the agent
+ * with them in place of `acp` (`shard --login`). Both start the same flow.
  */
 export declare const ACP_LOGIN_METHOD: {
     readonly id: "shardflux-login";
@@ -12,9 +14,15 @@ export declare const ACP_LOGIN_METHOD: {
 };
 /** Whether an API key is configured (no request; a revoked key surfaces as auth_required on its first call). */
 export declare function acpSignedIn(ctx: Ctx): boolean;
+/** How the sign-in finds and moves this computer's CLIProxyAPI (tests replace both). */
+export interface AcpLoginDeps {
+    detect?: (env: Record<string, string | undefined>) => Promise<LocalCliProxy | null>;
+    move?: (ctx: Ctx) => Promise<ImportResult>;
+}
 /**
  * `shard acp --login`: everything a first conversation needs, each step skipped when it is already done: the
- * account (signed up or in with this Mac's Codex login, else an email), its API key, the Codex login copy and the
- * cloud Claude sign-in.
+ * account (signed up or in with this computer's Codex login, else an email), its API key, the Codex login copy, the
+ * user's T3 Code proxy setup (a CLIProxyAPI on this computer, moved into the account when they say so) and the cloud
+ * Claude sign-in (not needed when Claude Code goes through that proxy with its own token).
  */
-export declare function runAcpLogin(ctx: Ctx): Promise<number>;
+export declare function runAcpLogin(ctx: Ctx, deps?: AcpLoginDeps): Promise<number>;

package/dist/acp-login.js

@@ -5,9 +5,13 @@ import { join } from 'node:path';
 import { describeError } from "./errors.js";
 import { cloudClaudeLogin, loginClaudeInWorkspace } from "./claude-cloud-login.js";
 import { syncAgentCredentials } from "./agent-credentials.js";
+import { thisComputer } from "./this-computer.js";
+import { detectLocalCliProxy, importCliProxy } from "./cli-proxy.js";
+import { accountVmProxy, readT3ProxySetup } from "./t3-proxy.js";
 /**
- * The ACP terminal sign-in method. An editor (T3 Code) runs `shard acp --login` in its own terminal when the user
- * chooses it, then reconnects; ACP appends these args to the configured `shard acp` invocation.
+ * The ACP terminal sign-in method. An editor runs it in its own terminal when the user chooses it, then reconnects:
+ * T3 Code appends these args to the configured `shard acp` (`shard acp --login`); ACP registry clients run the agent
+ * with them in place of `acp` (`shard --login`). Both start the same flow.
  */
 export const ACP_LOGIN_METHOD = {
     id: 'shardflux-login',
@@ -44,10 +48,11 @@ async function accountReady(ctx) {
 const say = (ctx, text) => { ctx.io.stderr.write(text); };
 /**
  * `shard acp --login`: everything a first conversation needs, each step skipped when it is already done: the
- * account (signed up or in with this Mac's Codex login, else an email), its API key, the Codex login copy and the
- * cloud Claude sign-in.
+ * account (signed up or in with this computer's Codex login, else an email), its API key, the Codex login copy, the
+ * user's T3 Code proxy setup (a CLIProxyAPI on this computer, moved into the account when they say so) and the cloud
+ * Claude sign-in (not needed when Claude Code goes through that proxy with its own token).
  */
-export async function runAcpLogin(ctx) {
+export async function runAcpLogin(ctx, deps = {}) {
     const { HANDLERS } = await import("./handlers.js");
     const home = ctx.io.env.HOME ?? homedir();
     const codex = existsSync(join(home, '.codex', 'auth.json'));
@@ -63,7 +68,7 @@ export async function runAcpLogin(ctx) {
             await setup();
         }
         else if (codex) {
-            say(ctx, 'Signing in with the Codex login on this Mac…\n');
+            say(ctx, `Signing in with the Codex login on ${thisComputer()}…\n`);
             await HANDLERS.signup(quiet, { setup: false }, []);
             await setup();
         }
@@ -95,9 +100,33 @@ export async function runAcpLogin(ctx) {
         say(ctx, 'Already signed in.\n');
     if (codex) {
         await syncAgentCredentials(ctx.cloud(), { home, redact: (value) => ctx.addSecret(value) });
-        say(ctx, 'Codex: connected with the login on this Mac.\n');
+        say(ctx, `Codex: connected with the login on ${thisComputer()}.\n`);
     }
-    if (await cloudClaudeLogin(ctx))
+    // T3 Code's own providers go through CLIProxyAPI on this computer: cloud threads follow once it is in the account.
+    let plan = accountVmProxy(ctx);
+    if (plan.importable.length) {
+        const local = await (deps.detect ?? ((env) => detectLocalCliProxy({ env })))(ctx.io.env).catch(() => null);
+        if (local?.logins.length) {
+            const answer = (await ctx.input.answer('\nYour T3 Code setup uses CLIProxyAPI on this computer. Move it into your Shardflux account so cloud conversations use it too? Your logins and routing come along, and this computer keeps http://127.0.0.1:8317. [Y/n] '))?.trim().toLowerCase() ?? 'n';
+            if (answer === '' || answer.startsWith('y')) {
+                try {
+                    // The answer above is the consent to stop the local copy too.
+                    const moved = await (deps.move ?? ((c) => importCliProxy(c, { values: { yes: true } })))(ctx);
+                    plan = accountVmProxy(ctx);
+                    say(ctx, `CLIProxyAPI: in your account, ${moved.logins.active.length} login${moved.logins.active.length === 1 ? '' : 's'} serving. Cloud conversations use it.\n`);
+                }
+                catch (error) {
+                    say(ctx, `CLIProxyAPI: ${describeError(error).message} Run: shard cli-proxy import\n`);
+                }
+            }
+            else
+                say(ctx, 'CLIProxyAPI: stays on this computer; cloud conversations use your Shardflux sign-ins. Move it any time: shard cli-proxy import\n');
+        }
+    }
+    const claude = readT3ProxySetup({ env: ctx.io.env }).claude;
+    if (plan.claudeCredential && claude)
+        say(ctx, `Claude Code: connected through ${claude.local ? 'your CLIProxyAPI' : new URL(claude.url).host}.\n`);
+    else if (await cloudClaudeLogin(ctx))
         say(ctx, 'Claude Code: connected.\n');
     else {
         const answer = (await ctx.input.answer('\nConnect Claude Code now? It opens a Claude sign-in page. [Y/n] '))?.trim().toLowerCase() ?? 'n';

package/dist/acp-models.d.ts

@@ -24,11 +24,16 @@ export declare class AcpModelCache {
     read(scope: AcpScope): AcpCatalog;
     write(scope: AcpScope, catalog: AcpCatalog): void;
 }
-export declare function discoverAcpCatalog(ctx: Ctx, ws: Workspace, root: string): Promise<AcpCatalog>;
+export declare function discoverAcpCatalog(ctx: Ctx, ws: Workspace, root: string, env?: Record<string, string>): Promise<AcpCatalog>;
 export interface AcpPreparation {
     allocated(conversation: Conversation, workspace: WorkspaceView): void;
     ready(workspace: Workspace): void;
     prepared(): void;
+    /** The user's T3 Code proxy setup (t3-proxy.ts): the adapters' variables, and the VM files they read, placed first. */
+    proxy?: {
+        env: Record<string, string>;
+        ready(workspace: Workspace): Promise<void>;
+    };
 }
 export interface AcpLifecycle {
     prepare(ctx: Ctx, folder: string, name: string, callbacks: AcpPreparation): Promise<AcpCatalog>;

package/dist/acp-models.js

@@ -1,14 +1,13 @@
 import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { join, posix } from 'node:path';
 import { projectIdentity } from "./project-identity.js";
-import { savedMachine } from "./filesystem-state.js";
-import { syncAgentConfig } from "./agent-config-sync.js";
-import { seedAgentRepository } from "./agent-repository.js";
-import { createConversationRecord, conversationWorkspace } from "./conversations.js";
+import { localChanges } from "./agent-repository.js";
+import { createConversationRecord, conversationWorkspace, seedConversation } from "./conversations.js";
+import { seedPhase } from "./seed-phases.js";
 import { AgentStateStore } from "./agent-state.js";
 import { objectValue } from "./acp-rpc.js";
 import { nativeCurrentModel, nativeModelOptions } from "./acp-catalog.js";
-import { recordSeedSnapshot } from "./files-mirror.js";
-import { sendTwinSeed, twinCheckoutArgv } from "./worktree-twin.js";
 /** No prompts, login, logout or credential writes. Every child process group is
  * terminated, including initialization failures and interrupted clients. */
 export const ACP_MODELS_SCRIPT = String.raw `
@@ -116,9 +115,9 @@ export class AcpModelCache {
         });
     }
 }
-export async function discoverAcpCatalog(ctx, ws, root) {
+export async function discoverAcpCatalog(ctx, ws, root, env = {}) {
     const result = await ws.cell().exec.run(['node', '-e', ACP_MODELS_SCRIPT], { cwd: root, timeoutMs: 55_000,
-        signal: ctx.signal, maxOutputBytes: 1 << 20, env: { SF_ACP_MODEL_DISCOVERY: '1' } });
+        signal: ctx.signal, maxOutputBytes: 1 << 20, env: { ...env, SF_ACP_MODEL_DISCOVERY: '1' } });
     if (result.exitCode !== 0)
         throw new Error(`Guest model discovery failed: ${result.stderr.trim()}`);
     const discovered = JSON.parse(result.stdout), catalog = {};
@@ -131,29 +130,40 @@ export async function discoverAcpCatalog(ctx, ws, root) {
         throw new Error('The guest adapters returned no available models. Check your cloud agent sign-ins.');
     return catalog;
 }
+/** The project files the adapters read for their settings and MCP servers. */
+const ACP_INITIAL_FILES = ['.claude/settings.json', '.claude/settings.local.json', '.codex/config.toml', '.mcp.json'];
 export const ACP_LIFECYCLE = { async prepare(ctx, folder, name, callbacks) {
         let allocation;
         const c = await createConversationRecord(ctx, folder, 'claude', 'acp', name, view => { allocation = view; }, `acp-session-${name}`);
         callbacks.allocated(c, allocation);
+        // This computer's changes are read while the VM starts (0.21.1+). Its agent config follows the first prompt (acp.ts).
+        const changes = localChanges(folder, ctx.signal);
+        changes.catch(() => undefined);
         const ws = await conversationWorkspace(ctx, c);
+        seedPhase('vm_running');
         callbacks.ready(ws);
-        if (!(await savedMachine(ctx))?.template)
-            await syncAgentConfig(ctx, ws);
-        await ws.cell().files.mkdir(c.worktree_path, { parents: true });
         let initialReady, initialFailed;
         const initialFiles = new Promise((resolve, reject) => { initialReady = resolve; initialFailed = reject; });
+        // The adapters read the project's own agent settings when it has any: discovery then waits for those files. A
+        // project without them is discovered while it seeds (0.21.1+), beside the worktree rather than in it (a prepared
+        // worktree is moved into place whole): the catalog depends on the account, not the files.
+        const projectSettings = ACP_INITIAL_FILES.some(path => existsSync(join(folder, path)));
+        // The same seed as a terminal start (0.22.0+): the prepared revision, only what the project cache lacks, or the copy
+        // seed. Media land before the reply and those still on their way stay out of the first file reconcile (acp.ts).
         const seeded = (async () => {
-            await seedAgentRepository(ctx, ws, folder, { root: c.worktree_path, populate: true,
-                initialFiles: ['.claude/settings.json', '.claude/settings.local.json', '.codex/config.toml', '.mcp.json'], onInitialFiles: initialReady });
-            await sendTwinSeed(ctx.store.dir, ws.cell(), c, folder, ctx.signal);
-            const result = await ws.cell().exec.run(twinCheckoutArgv(ctx.store.dir, c), { timeoutMs: 30_000, signal: ctx.signal });
-            if (result.exitCode !== 0)
-                throw new Error(`Conversation branch could not be prepared: ${result.stderr.trim()}`);
-            await recordSeedSnapshot(ws, c, ctx.signal);
+            await seedConversation(ctx, c, ws, folder, undefined, changes, undefined, { initialFiles: ACP_INITIAL_FILES, onInitialFiles: initialReady, landNow: true });
             callbacks.prepared();
         })();
         void seeded.catch(initialFailed);
-        const models = (async () => { await initialFiles; return discoverAcpCatalog(ctx, ws, c.worktree_path); })();
+        const proxied = callbacks.proxy?.ready(ws) ?? Promise.resolve();
+        const models = (async () => {
+            await proxied;
+            if (projectSettings) {
+                await initialFiles;
+                return discoverAcpCatalog(ctx, ws, c.worktree_path, callbacks.proxy?.env);
+            }
+            return discoverAcpCatalog(ctx, ws, posix.dirname(c.worktree_path), callbacks.proxy?.env);
+        })();
         // Observe both failures immediately. Never start a second VM, and never delete
         // the user's conversation VM as catalog cleanup.
         const results = await Promise.allSettled([seeded, models]);