@shardflux/cli 0.19.1 → 0.22.0

package/dist/onboarding.js

@@ -6,12 +6,15 @@ import { resolveWorkspace } from "./commands.js";
 import { AgentStateStore } from "./agent-state.js";
 import { describeError } from "./errors.js";
 import { t3PhoneLink } from "./t3-phone.js";
+import { t3NeedsProject, t3SignInProject } from "./account-scope.js";
 import { readAgentCredentials, syncAgentCredentials } from "./agent-credentials.js";
 import { getConversation } from "./conversations.js";
 import { codexHealth, readCodexConnector, restartCodexConnector } from "./codex-cloud.js";
 import { applicationDirs } from "./agent-targets.js";
 import { configureT3Provider } from "./t3-provider.js";
 import { t3Install } from "./t3-mode.js";
+import { inspectMachineRow, rowText } from "./machine-status.js";
+import { launcherShortcut } from "./this-computer.js";
 /**
  * The first-run demo's task: it shows the agent's own computer at work. The user copies it and pastes it into the
  * launcher themselves; Daylight's own CLAUDE.md and AGENTS.md say how to run it and test it in the desktop browser.
@@ -37,7 +40,7 @@ export function installDirs(home) {
     return [join(home, '.local', 'bin'), join(home, '.claude', 'local'), join(home, '.npm-global', 'bin'), join(home, '.bun', 'bin'),
         join(home, '.volta', 'bin'), join(home, 'Library', 'pnpm')];
 }
-/** Claude Code or Codex is on this Mac: its home folder (~/.claude, ~/.codex) or its command on PATH or in an install folder. */
+/** Claude Code or Codex is on this computer: its home folder (~/.claude, ~/.codex) or its command on PATH or in an install folder. */
 export async function foundApps(env) {
     const home = env.HOME ?? homedir();
     const onPath = async (name) => {
@@ -69,7 +72,7 @@ export function parseApps(value) {
  * appears in T3 Code and the T3 app by itself. `startSignIn` (`--t3-connect`) starts that sign-in. Null when T3 Code
  * is not installed.
  */
-export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.io.env), platform = process.platform, startSignIn = false) {
+export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.io.env), platform = process.platform, startSignIn = false, scope = {}) {
     // The same install every T3 command uses (macOS and Linux): a build with ACP providers first.
     const app = t3Install(ctx.io.env, platform, appDirs);
     if (!app)
@@ -90,37 +93,52 @@ export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.
     // Stable T3: one T3 Connect sign-in per person (the API's, per account), then each project appears by itself. `next`
     // is for scripts: a project is set up for T3 Code with it.
     const ssh = { ...base, mode: 'ssh', next: shard(['agents', 'new', '--in', 't3', '--path', '<project>']) };
+    const selection = ['org', 'project'].flatMap(key => typeof scope[key] === 'string' ? [`--${key}`, scope[key]] : []);
     const offer = { ...ssh, state: 'action', fact: 'Your projects appear in T3 Code and the T3 app once connected.',
-        action: { title: 'Connect T3 Code', command: shard(['setup', '--inspect', '--t3-connect', '--json']) } };
+        action: { title: 'Connect T3 Code', command: shard(['setup', '--inspect', '--t3-connect', '--json', ...selection]) } };
     if (!signedIn)
         return offer;
-    const cloud = ctx.cloud();
+    let projectId;
     let status;
     try {
-        status = await cloud.t3.status();
+        // Status and sign-in must use the same person and organization. The key may belong to another organization
+        // (or another member); its connected state cannot decide whether this person's selected sign-in is connected.
+        if (ctx.sessionSource() !== null) {
+            projectId = await t3SignInProject(ctx, scope);
+            status = await ctx.account().t3.status(projectId ? { projectId } : {});
+        }
+        else
+            status = await ctx.cloud().t3.status();
     }
     catch {
         return { ...ssh, state: 'unknown', fact: 'T3 Connect could not be checked just now.', action: { title: 'Retry', retry: true } };
     }
     // Remembered for `agents targets`: with the sign-in, every project can start in T3 Code (t3Status).
-    try {
-        new AgentStateStore(ctx.store.dir).saveT3Connected(ctx.apiUrl, status.connected);
+    // A one-off --org/--project check must not replace the default target's remembered status.
+    if (selection.length === 0) {
+        try {
+            new AgentStateStore(ctx.store.dir).saveT3Connected(ctx.apiUrl, status.connected);
+        }
+        catch { /* the next check writes it */ }
     }
-    catch { /* the next check writes it */ }
     if (!status.connected) {
         if (!startSignIn)
             return offer;
-        const signIn = await startT3SignIn(ctx);
+        const signIn = await startT3SignIn(ctx, projectId);
         if (signIn === 'connected')
-            return t3Connection(ctx, signedIn, appDirs, platform, false);
+            return t3Connection(ctx, signedIn, appDirs, platform, false, scope);
         if (signIn.needs_login)
             return { ...offer, fact: 'Sign in to Shardflux on this computer to connect T3 Code.', t3_link: signIn };
         return { ...offer, fact: 'Confirm the code on the page that opened. This updates on its own.', t3_link: signIn,
             action: { title: 'Connect T3 Code', url: signIn.sign_in.verification_uri } };
     }
     const connected = { ...ssh, state: 'verified', fact: 'Your projects appear in T3 Code and the T3 app.' };
+    // Explicit account selection is a status check, not consent to relink the default computer's last workspace.
+    if (selection.length > 0)
+        return connected;
     // The newest project set up for T3 Code from this computer (agents.json; a targets.json entry from an older CLI still
-    // counts): where it is. One set up before T3 Connect, or whose link failed, is linked now: it is the person's choice.
+    // counts): where it is. One set up before T3 Connect is linked now. An existing error stays visible until the
+    // person explicitly requests another link; a periodic inspection must not restart permanent refusals.
     const recorded = new AgentStateStore(ctx.store.dir).t3Environments(ctx.apiUrl).at(-1);
     const manifest = await jsonFile(join(ctx.store.dir, 'targets.json'));
     const entries = Array.isArray(manifest?.entries) ? manifest.entries : [];
@@ -131,7 +149,9 @@ export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.
     try {
         const ws = await resolveWorkspace(ctx, key);
         const known = status.links.find(l => l.workspace_id === ws.id);
-        const link = !known || known.status === 'error' || known.status === 'needs_sign_in' ? (await t3PhoneLink(ctx, ws.id)).link : known;
+        if (known?.status === 'error')
+            return { ...ssh, state: 'info', fact: known.last_error ?? 'T3 Connect could not link this workspace. Check T3 Connect, then open this project in T3 Code again to retry.' };
+        const link = !known || known.status === 'needs_sign_in' ? (await t3PhoneLink(ctx, ws.id, ws.data.project_id)).link : known;
         // Linked to the person's T3 account: T3 Code and the T3 app list it once they are signed in to that account.
         if (link.status === 'linked')
             return { ...connected, fact: `${link.label} is linked to your T3 account.` };
@@ -149,19 +169,21 @@ export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.
 }
 /**
  * Starts the person's T3 Connect sign-in (a pending one comes back again). It needs this computer's Shardflux session,
- * not only an API key. `connected` when the account already has one (409 `t3_signed_in`).
+ * not only an API key. `connected` when the account already has one (409 `t3_signed_in`). The sign-in is per
+ * organization: it is scoped by --project/--org, else the API key's project, else the saved default (0.20.2+; before,
+ * a person in two organizations got 422 project_id is required).
  */
-async function startT3SignIn(ctx) {
-    if (ctx.store.profile(ctx.apiUrl).session?.state !== 'active')
+async function startT3SignIn(ctx, projectId) {
+    if (ctx.sessionSource() === null)
         return { status: 'needs_sign_in', label: '', needs_login: true };
     try {
-        const flow = await ctx.account().t3.signIn();
+        const flow = await ctx.account().t3.signIn(projectId ? { projectId } : {});
         return { status: 'needs_sign_in', label: '', sign_in: { verification_uri: flow.verification_uri, user_code: flow.user_code, expires_at: flow.expires_at } };
     }
     catch (error) {
         if (error instanceof ShardfluxApiError && describeError(error).code === 't3_signed_in')
             return 'connected';
-        throw error;
+        throw t3NeedsProject(error) ?? error;
     }
 }
 const shard = (words) => ['shard', ...words];
@@ -176,7 +198,7 @@ export function claudeConnection(row) {
         return { state: 'action', fact: 'Claude no longer accepts this sign-in.', action: { ...signIn, title: 'Sign in to Claude again' } };
     return { state: 'verified', fact: 'Signed in. Works in every conversation, on web and phone.' };
 }
-/** Codex: this Mac's Codex login is copied and the account's Codex remote device (one executor) is connected. */
+/** Codex: this computer's Codex login is copied and the account's Codex remote device (one executor) is connected. */
 export function codexConnection(local, synced, connector, health) {
     const enable = { title: 'Connect Codex', command: shard(['agents', 'codex', 'enable']) };
     if (!synced) {
@@ -198,14 +220,14 @@ export function codexConnection(local, synced, connector, health) {
 /**
  * The onboarding report, for an agent setting itself up from chat and for the menu bar app. It verifies every
  * connection live: the Shardflux account, Claude (Claude itself accepts the login) and Codex (the login is copied and
- * the account's Codex remote device is connected), for the apps picked (--apps, else saved, else found on this Mac).
+ * the account's Codex remote device is connected), for the apps picked (--apps, else saved, else found on this computer).
  * With --connect it also does what needs no sign-in: copies the Codex login and enables the Codex remote device.
  */
-export async function onboardingReport(ctx, values) {
+export async function onboardingReport(ctx, values, platform = process.platform) {
     const saved = await jsonFile(resolve(ctx.store.dir, 'onboarding.json'));
     const state = saved?.api_url === ctx.apiUrl ? saved : undefined;
     const found = await foundApps(ctx.io.env);
-    // An empty saved pick means nothing was chosen yet: what is found on this Mac is pre-ticked.
+    // An empty saved pick means nothing was chosen yet: what is found on this computer is pre-ticked.
     const savedApps = Array.isArray(state?.apps) && state.apps.length ? parseApps(state.apps.filter(v => typeof v === 'string')) : undefined;
     const apps = parseApps(values.apps) ?? savedApps ?? found;
     const connect = values.connect === true;
@@ -256,7 +278,7 @@ export async function onboardingReport(ctx, values) {
                 let read = await readCodexConnector(ctx);
                 health = codexHealth(read.connector, read.workspaceState);
                 const synced = credentials.some(row => row.app === 'codex');
-                // One executor per account, enabled as `shard setup` does when this Mac is signed in to Codex. --retry-codex starts
+                // One executor per account, enabled as `shard setup` does when this computer is signed in to Codex. --retry-codex starts
                 // a failed or stuck one again, once.
                 if (connect && synced && (health === 'missing' || health === 'disabled')) {
                     read = { connector: await ctx.cloud().codex.enable({ signal: ctx.signal }), workspaceState: null };
@@ -281,22 +303,29 @@ export async function onboardingReport(ctx, values) {
     const codex = { id: 'codex', picked: apps.includes('codex'), found: found.includes('codex'),
         ...(!connected ? signIn : (credentialError ?? codexError) !== undefined ? failure(credentialError ?? codexError)
             : codexConnection(localCodex, credentials.some(row => row.app === 'codex'), connector, health)) };
-    const t3 = await t3Connection(ctx, connected, undefined, undefined, values['t3-connect'] === true);
+    const t3 = await t3Connection(ctx, connected || ctx.sessionSource() !== null, undefined, undefined, values['t3-connect'] === true, values);
     const connections = [account, claude, codex, ...(t3 ? [t3] : [])];
+    // The cloud machine (0.20.2+), the same row `shard machine setup --status` reports: whether what is installed carries
+    // over to new conversations. It never decides `ready`: conversations start without a saved machine too.
+    const machine = connected ? await inspectMachineRow(ctx) : null;
+    const shortcut = launcherShortcut(ctx.store.dir, platform);
+    const press = (what) => (shortcut ? `Press ${shortcut}, ${what}` : `Open a new conversation, ${what}`);
     // Ready: signed in and at least one agent app connected; the other can be connected later (Settings, or this again).
     const ready = account.state === 'verified' && [claude, codex].some(c => c.state === 'verified');
     const done = (value) => value === true || (typeof value === 'string' && value.length > 0);
     return {
-        version: 3, api_url: ctx.apiUrl, apps, found_apps: found, connections, ready, account_error: accountError,
+        version: 3, api_url: ctx.apiUrl, apps, found_apps: found, connections, ready, connections_ready: ready,
+        machine_ready: machine && !['unknown', 'unavailable'].includes(machine.state) ? machine.state === 'ready' && machine.version !== null && machine.version > 0 : null,
+        account_error: accountError, machine,
         demo: { prompt: DEMO_PROMPT, project: 'Daylight (sample)', prepare: shard(['setup', '--prepare-sample', '--json']) },
         activity: values.activity === true && typeof values.workspace === 'string' ? await liveActivity(ctx, values.workspace) : null,
         steps: [
             { id: 'account', title: 'Sign in to Shardflux', status: connected ? 'complete' : 'available', command: shard(['signup']) },
             { id: 'connect', title: 'Connect Claude, Codex or both', status: ready ? 'complete' : 'available' },
             { id: 'demo', title: 'Try it once: your agent’s own computer', status: done(state?.demo_finished) ? 'complete' : 'available',
-                action: 'Copy the task and press ⌥⇧Space. Paste the task, then Start. The agent installs what it needs, starts it and tests it in its own browser.' },
+                action: `Copy the task. ${press('paste the task, then Start.')} The agent installs what it needs, starts it and tests it in its own browser.` },
             { id: 'own', title: 'Your own project', status: done(state?.own_key) ? 'complete' : 'available',
-                action: 'Press ⌥⇧Space, pick your project and describe what you want.' },
+                action: press('pick your project and describe what you want.') },
         ],
     };
 }
@@ -305,7 +334,10 @@ export function onboardingText(report) {
     const names = { account: 'Shardflux', claude: 'Claude', codex: 'Codex', t3: 'T3 Code' };
     const mark = { verified: '✓', action: '!', pending: '…', unknown: '?', info: '·' };
     const lines = report.connections.filter(c => c.id === 'account' || c.picked || c.id === 't3').map(c => `${mark[c.state]} ${names[c.id]}: ${c.fact}${c.action?.command ? ` (${c.action.command.join(' ')})` : ''}`);
-    return `${lines.join('\n')}\n${report.ready ? `Ready. Try it once: ${report.demo.prompt}` : 'Not ready yet: finish the steps above, then run this again.'}\n`;
+    const machineMark = { ready: '✓', saving: '…', failed: '!', none: '·', unknown: '?', unavailable: '?' };
+    if (report.machine)
+        lines.push(`${machineMark[report.machine.state]} ${rowText(report.machine)}`);
+    return `${lines.join('\n')}\n${report.ready ? `Agent connections ready. Try it once: ${report.demo.prompt}` : 'Connections not ready yet: finish the steps above, then run this again.'}\n`;
 }
 /** What a person recognises, most telling first: installs, then how the app is run, then what it runs. */
 const RANKS = [/^(sudo|apt|apt-get|dpkg)$/, /^(npm|npx|pnpm|yarn|bun)$/, /^(node|python[0-9.]*|uv|vite|next|deno|docker|cargo|go|make)$/, /^(pip[0-9.]*|inotifywait)$/];

package/dist/prepared-repository.d.ts

@@ -0,0 +1,202 @@
+import type { SyncCell } from './project-sync-transfer.js';
+import type { OutsideFile } from './large-media.js';
+/** One upload part. */
+export declare const PART_BYTES: number;
+/** Blobs of S from this size on leave the thin pack: stored when incompressible, compressed apart otherwise. */
+export declare const LARGE_BLOB_BYTES: number;
+/** Large media above this follow the first prompt when the caller allows it. */
+export declare const DEFER_BYTES: number;
+/** Parts in flight at once, and their bytes. */
+export declare const UPLOAD_WINDOW = 4;
+export declare const UPLOAD_BUDGET_BYTES: number;
+/** The history the laptop sends before the cache fetches it from origin instead. */
+export declare const ORIGIN_FIRST_BYTES: number;
+/** The history the laptop sends before the cache takes the VM's own fetch of the branch (its boot prefetch) instead. */
+export declare const PREFETCH_ADOPT_BYTES: number;
+/** The local spool of generated packs (for resuming), pruned past this or a day. */
+export declare const SPOOL_BYTES: number;
+export interface PreparedExtra {
+    path: string;
+    sha256: string;
+    size: number;
+    mode: number;
+    symlink: boolean;
+    link_target: string;
+}
+export interface PreparedFile {
+    path: string;
+    oid: string;
+    size: number;
+    mode: number;
+}
+export interface PreparedManifest {
+    version: 2;
+    format: 'sha1' | 'sha256';
+    head: string;
+    seed: string;
+    /** The user's branch and its upstream, recreated in the VM as on this computer. */
+    branch?: string;
+    upstream?: {
+        ref: string;
+        oid: string;
+    };
+    origin: string | null;
+    repository: string;
+    worktree: string;
+    deps_hash?: string;
+    /** What Git does not hold: .env files (never in a Git object) and files whose filters change their bytes. */
+    extras: PreparedExtra[];
+    extras_key?: string;
+    /** Large untracked media, outside S: Git blobs the VM writes as files its Git ignores. */
+    files: PreparedFile[];
+    /** Deleted files S still names (only when S is HEAD: the twin snapshot was off or paused). */
+    remove: string[];
+    /** A shallow clone's boundary commits: the cache and the worktree take the same boundary. */
+    shallow?: string[];
+}
+export interface PreparedSnapshot {
+    revision: string;
+    manifest: PreparedManifest;
+    directory: string;
+}
+export interface PreparedTransfer {
+    revision: string;
+    /** S, its archive and every media file are in the cache. Otherwise `pending` names the media still to send. */
+    complete: boolean;
+    pending: string[];
+    /** Bytes of the packs generated for this transfer: history and small files; large blobs; media; the archive. */
+    history_bytes: number;
+    large_bytes: number;
+    media_bytes: number;
+    extras_bytes: number;
+    /** Part bytes sent, and bytes the VM already held. */
+    uploaded_bytes: number;
+    reused_bytes: number;
+    puts: number;
+    execs: number;
+    max_in_flight_bytes: number;
+    origin_fetched: boolean;
+    /** Media that changed on this computer after the start captured them: they never arrive as captured. */
+    changed: string[];
+    timings: Record<string, number>;
+    /** The checkout the probe made (options.apply) when the cache already held the revision. */
+    applied?: PreparedApply;
+}
+export interface PreparedGitConfig {
+    origin_url?: string;
+    user?: {
+        name?: string;
+        email?: string;
+    };
+    tracking?: {
+        branch: string;
+        merge: string;
+    };
+    excludes?: string;
+}
+export interface PreparedApply {
+    revision: string;
+    mode: 'fresh' | 'inplace' | 'existing';
+    /** Media not in the cache yet, and media landing right after the reply (Git ignores both). */
+    pending: number;
+    landing: number;
+    dependencies: number;
+    timings: Record<string, number>;
+}
+export declare function preparedCachePath(remote: string): string;
+export declare const preparedDirectory: (stateDir: string, folder: string) => string;
+/** The manifest's identity bytes: sorted keys, no spaces, UTF-8 (prepared-repository.py `canonical`). */
+export declare function canonicalJson(value: unknown): string;
+export declare const manifestRevision: (m: PreparedManifest) => string;
+/** A refusal the VM half reports by reason (missing or corrupt parts, an owned worktree, ...). */
+export declare class PreparedRefusal extends Error {
+    readonly reason: string;
+    readonly chunks: string[];
+    constructor(reason: string, message: string, chunks?: string[]);
+}
+/**
+ * The prepared revision of a worktree's state: S (the twin seed, already made), its large media and its extras. S's
+ * objects stay in the local repository under refs/shard/prepared/<revision> until the start that uses it is done, so a
+ * start accepted before a deadline resumes later with exactly the state it began from, whatever the user edits.
+ */
+export declare function capturePreparedSnapshot(stateDir: string, folder: string, seed: {
+    commit: string;
+    outside?: OutsideFile[];
+}, origin: string | null, signal?: AbortSignal, options?: {
+    reachable?: (url: string) => boolean;
+    depsHash?: string;
+}): Promise<PreparedSnapshot>;
+/** The local pin of a revision's objects, once its start no longer needs them. */
+export declare function releaseLocalSnapshot(folder: string, revision: string): Promise<void>;
+export declare function readPreparedSnapshot(stateDir: string, folder: string, revision: string): Promise<PreparedSnapshot>;
+/** Where a conversation start's parts go: the VM's own disk, indexed there; the cache receives them after the reply. */
+export declare const PARTS_ROOT = "/home/user/.cache/shardflux/prepared-parts";
+/**
+ * Sends the revision, only what the project cache lacks. Without `apply` it goes into the cache (a preparation). With
+ * `apply` (a conversation start) it is checked out at that target: in the probe's own exec when the cache already
+ * holds the revision (a warm start is one exec), otherwise from parts uploaded to the VM's disk and indexed there, with
+ * no Git work on the shared cache before the reply; the cache receives them after it. With `defer`, media beyond
+ * DEFER_BYTES wait for a later call: the result names them in `pending`, and the worktree starts without them.
+ */
+export declare function transferPreparedSnapshot(cell: SyncCell, folder: string, cache: string, snapshot: PreparedSnapshot, options?: {
+    signal?: AbortSignal;
+    defer?: boolean;
+    pin?: string;
+    originFirstBytes?: number;
+    apply?: PreparedApplyTarget;
+    partsDir?: string;
+}): Promise<PreparedTransfer>;
+/** Git settings the VM repository copies from this one: origin, identity, the branch's upstream, exclude rules. */
+export declare function preparedGitConfig(folder: string, manifest: PreparedManifest, signal?: AbortSignal): Promise<PreparedGitConfig>;
+export interface PreparedApplyOptions {
+    signal?: AbortSignal;
+    git?: PreparedGitConfig;
+    preparation?: boolean;
+    replacePreparation?: boolean;
+    dependencySource?: string;
+    /** A new VM: files its image left at the worktree path (outside any repository) are checked out over. */
+    adopt?: boolean;
+    /** false keeps borrowing the cache's objects; 'now' copies them before returning (a template must not borrow). */
+    dissociate?: boolean | 'now';
+    background?: boolean;
+    releasePin?: string;
+    /** A shell script the VM runs, detached, once the worktree is ready (the seed's copy to the project hub). */
+    after?: {
+        script: string;
+        args: string[];
+    };
+    /** The conversation's setup intent (recordSetupIntent), written in the same exec before its repository appears. */
+    setupIntent?: {
+        conversation: string;
+        depsHash: string;
+    };
+    /** The VM's workspace: a checkout another VM's conversation made (and a template image brought) is taken over. */
+    workspace?: string;
+}
+/** Where and how a revision is checked out: the VM half's apply request. */
+export interface PreparedApplyTarget {
+    root: string;
+    branch: string;
+    options?: PreparedApplyOptions;
+}
+/**
+ * Checks out the revision as `branch` at `root`, in one exec. Media not in the cache yet stay pending
+ * (landDeferredFiles). A root holding the same revision is left as it is; one holding another is refused, unless it is
+ * a project template's checkout or `replacePreparation`.
+ */
+export declare function applyPreparedSnapshot(cell: SyncCell, cache: string, revision: string, root: string, branch: string, options?: PreparedApplyOptions): Promise<PreparedApply>;
+/** Lands media that arrived after the start (where nothing is yet: the agent's own file stands); `drop` gives up on blobs that changed. */
+export declare function landDeferredFiles(cell: SyncCell, cache: string, revision: string, root: string, options?: {
+    signal?: AbortSignal;
+    drop?: string[];
+}): Promise<{
+    landed: number;
+    kept: number;
+    pending: number;
+}>;
+export declare function prunePreparedCache(cell: SyncCell, cache: string, signal?: AbortSignal): Promise<void>;
+/**
+ * The local spool stays bounded: a finished transfer's parts go at once; other parts and plans after a day or past
+ * the budget, oldest first; a revision's manifest and files archive (what a pending start resumes from) after a week.
+ */
+export declare function pruneLocalPrepared(stateDir: string, limit?: number, every?: number): Promise<void>;