@shardflux/cli 0.18.1 → 0.19.1

package/dist/files-mirror.js

@@ -675,8 +675,19 @@ export class FilesMirror {
  * as refs/worktree/shard/seed and in the hub as refs/shard/seed/<name>. Mirrors leave out what it already contains,
  * so the user's own uncommitted edits never show as the conversation's change. Threads on one computer are worktrees
  * of one repository (0.16.0+), so the seed is per worktree; the shared refs/shard/seed of earlier seeds is read, and
- * still written, only in the repository's main worktree.
+ * still written, only in the repository's main worktree. With $4 = background (0.19.1+) the hub push runs detached
+ * in the VM and the script returns once the seed is recorded: the hub is on the project's network volume, where the
+ * push took 6-10 s on every start (staging, coding 37), on the way to the first prompt.
  */
+// It is embedded in single quotes below: never a single quote in it. A blobless partial clone (0.19.0+) pushes only
+// when the hub already has the seed history; otherwise the push would fetch every historic blob first. Its background
+// backfill completes the repository for later pushes.
+const SEED_PUSH = `set -u
+seed=$1; name=$2; hub=$3; cd "$4"
+push=1; if [ "$(git config --bool remote.origin.promisor 2>/dev/null || true)" = true ]; then push=0
+for c in "$seed" "$seed^1"; do o=$(git rev-parse -q --verify "$c^{commit}" 2>/dev/null) && git --git-dir="$hub" cat-file -e "$o^{commit}" 2>/dev/null && push=1 && break; done; fi
+if [ -d "$hub" ] && [ "$push" = 1 ]; then git -c core.hooksPath=/dev/null push -q "$hub" "+$seed:refs/shard/seed/$name" >/dev/null 2>&1 || true; fi
+`;
 export const SEED_SNAPSHOT = `set -eu
 cd "$1"
 main=0; [ "$(git rev-parse --absolute-git-dir)" = "$(git rev-parse --path-format=absolute --git-common-dir)" ] && main=1
@@ -691,13 +702,18 @@ seed=$(GIT_AUTHOR_NAME=Shardflux GIT_AUTHOR_EMAIL=seed@shardflux.dev GIT_COMMITT
 git update-ref refs/worktree/shard/seed "$seed"
 if [ "$main" = 1 ]; then git update-ref refs/shard/seed "$seed"; fi
 fi
-if [ -d "$3" ]; then git -c core.hooksPath=/dev/null push -q "$3" "+$seed:refs/shard/seed/$2" >/dev/null 2>&1 || true; fi
+push='${SEED_PUSH}'
+if [ "\${4:-}" = background ]; then
+  if command -v setsid >/dev/null 2>&1; then (setsid sh -c "$push" shard-seed-push "$seed" "$2" "$3" "$PWD" >/dev/null 2>&1 </dev/null &)
+  else (sh -c "$push" shard-seed-push "$seed" "$2" "$3" "$PWD" >/dev/null 2>&1 </dev/null &); fi
+else sh -c "$push" shard-seed-push "$seed" "$2" "$3" "$PWD"; fi
 printf '%s\n' "$seed"
 `;
 /** Best effort: without a snapshot the folder also lists the start state's own edits. */
 export async function recordSeedSnapshot(ws, c, signal) {
     try {
-        const r = await ws.cell().exec.run(['sh', '-c', SEED_SNAPSHOT, 'shard-seed', c.worktree_path, c.branch.replace(/^shard\//, ''), HUB_PATH], { timeoutMs: 120_000, maxOutputBytes: 4096, ...(signal ? { signal } : {}) });
+        // The hub push runs detached in the VM: it is on the project volume and never on the way to the first prompt.
+        const r = await ws.cell().exec.run(['sh', '-c', SEED_SNAPSHOT, 'shard-seed', c.worktree_path, c.branch.replace(/^shard\//, ''), HUB_PATH, 'background'], { timeoutMs: 120_000, maxOutputBytes: 4096, ...(signal ? { signal } : {}) });
         return r.exitCode === 0 ? r.stdout.trim() : null;
     }
     catch (error) {

package/dist/format.js

@@ -376,7 +376,7 @@ function objectTable(rows, columns) {
     const cols = columns.filter(([k]) => objs.some((o) => k in o));
     return table(cols.map(([, h]) => h), objs.map((o) => cols.map(([k]) => (k === 'percent_used' && typeof o[k] === 'number' ? `${o[k]}%` : scalar(o[k])))));
 }
-const USAGE_KNOWN = new Set(['plan', 'period', 'measurement', 'allowance_exhausted', 'exhausted_reason', 'egress_override', 'meters', 'allowances', 'exhausted', 'alert_thresholds', 'spend_cap']);
+const USAGE_KNOWN = new Set(['plan', 'period', 'measurement', 'allowance_exhausted', 'exhausted_reason', 'egress_override', 'meters', 'allowances', 'exhausted', 'alert_thresholds', 'spend_cap', 'gpu']);
 /** Minor units as money (the overage block): `$3.00` for usd, else `3.00 EUR`. A fractional minor amount (a sub-cent rate) keeps its digits. */
 export function capMoney(minor, currency) {
     if (typeof minor !== 'number')
@@ -432,6 +432,39 @@ function spendCapText(cap) {
     }
     return out;
 }
+/** Hours for people: at most two decimals (`25`, `3.25`, `0.2`). */
+const hoursText = (h) => String(Math.round(h * 100) / 100);
+/**
+ * The GPU-hours lines of the summary (0.19.0; `gpu`, SDK 0.25.0): used of included with the overage past them, then,
+ * while the GPU is stopped (cap_state gpu_blocked), why and what brings it back. Workspaces keep running meanwhile.
+ * Nothing without `gpu` (plans without GPU-hours).
+ */
+function gpuLines(gpu, resetsAt) {
+    if (!isObject(gpu) || typeof gpu.used_hours !== 'number')
+        return [];
+    const included = typeof gpu.included_hours === 'number' ? gpu.included_hours : null;
+    let used = included === null ? `${hoursText(gpu.used_hours)} used (the plan includes none)` : `${hoursText(gpu.used_hours)} of ${hoursText(included)} used`;
+    const over = typeof gpu.overage_hours === 'number' ? gpu.overage_hours : 0;
+    if (included !== null && over > 0) {
+        const billed = typeof gpu.billed_overage_hours === 'number' ? gpu.billed_overage_hours : 0;
+        used += `, ${hoursText(over)} past the allowance${billed > 0 ? ` (${hoursText(billed)} billed as overage)` : ''}`;
+    }
+    const rows = [['GPU-hours', used]];
+    if (gpu.cap_state !== 'gpu_blocked')
+        return rows;
+    const resets = resetsAt ? ` (the period resets ${time(resetsAt)})` : '';
+    switch (gpu.blocked_reason) {
+        case 'overage_paused':
+            rows.push(['GPU', 'stopped (overage_paused): workspaces keep running; pay the past-due invoice (shard billing portal --open) and the GPU renders again']);
+            break;
+        case 'spend_cap_reached':
+            rows.push(['GPU', `stopped (spend_cap_reached): workspaces keep running; raise the spend cap (shard billing overage cap <dollars>), or wait for the reset${resets}`]);
+            break;
+        default:
+            rows.push(['GPU', `stopped (allowance_used): workspaces keep running; turn on overage (shard billing overage on --cap <dollars>), upgrade (shard billing plans), or wait for the reset${resets}`]);
+    }
+    return rows;
+}
 /**
  * The usage summary (GET /v1/organizations/{id}/usage/summary): plan, period, measurement
  * freshness, then meters and allowances as tables (cap state `overage` past an allowance while opt-in overage is on),
@@ -464,6 +497,8 @@ export function usageText(summary) {
     if (Array.isArray(s.allowances) && s.allowances.some((a) => isObject(a) && a.cap_state === 'storage_blocked')) {
         head.push(['retained state', 'used up: new workspaces and forks are refused (delete workspaces you no longer need, or upgrade)']);
     }
+    const resetsAt = isObject(s.period) ? [s.period.resets_at, s.period.end].find((t) => typeof t === 'string') : undefined;
+    head.push(...gpuLines(s.gpu, resetsAt));
     for (const [k, v] of Object.entries(s))
         if (!USAGE_KNOWN.has(k) && (typeof v !== 'object' || v === null))
             head.push([k.replace(/_/g, ' '), scalar(v)]);
@@ -1019,7 +1054,7 @@ export function egressVersionTable(rows) {
     return table(['VERSION', 'KIND', 'POLICY', 'BY', 'CREATED'], rows.map((v) => [String(v.version), v.kind, v.kind === 'cleared' ? '-' : egressPolicyLine({ mode: v.mode ?? 'allow_all', rules: v.rules, cidrs: v.cidrs }), `${v.created_by.type}:${v.created_by.id}`, time(v.created_at)]));
 }
 // ---- Overage settings (0.5.1; shard billing overage) -----------------------------------------------------------
-const RATE_UNITS = { ram_gib_hours: 'RAM GiB-hour', cpu_hours: 'CPU-hour' };
+const RATE_UNITS = { ram_gib_hours: 'RAM GiB-hour', cpu_hours: 'CPU-hour', gpu_hours: 'GPU-hour' };
 /**
  * The spend policy's overage settings for people (GET/PUT /v1/organizations/{id}/spend-policy): the state, the spend
  * cap and its bounds, the rates, and the next step. `saved` adds the version the change was saved as.

package/dist/handlers.js

@@ -21,4 +21,6 @@ import { CODEX_CLOUD_HANDLERS } from "./codex-cloud.js";
 import { THREAD_HANDLERS } from "./thread-on-computer.js";
 import { CLI_PROXY_HANDLERS } from "./cli-proxy.js";
 import { ACCOUNT_POOL_HANDLERS } from "./account-pool.js";
-export const HANDLERS = { ...DEVICE_HANDLERS, ...CODEX_CLOUD_HANDLERS, ...CLI_PROXY_HANDLERS, ...THREAD_HANDLERS, ...CONVERSATION_HANDLERS, ...LOCAL_CONVERSATION_HANDLERS, ...TWIN_HANDLERS, ...CREDENTIAL_HANDLERS, ...AGENT_CREDENTIAL_HANDLERS, ...ACCOUNT_POOL_HANDLERS, ...KEY_HANDLERS, ...ACCOUNT_HANDLERS, ...AGENT_HANDLERS, ...CENTER_HANDLERS, ...TARGET_HANDLERS, ...AGENT_GIT_HANDLERS, ...MENUBAR_HANDLERS, ...FILESYSTEM_HANDLERS, ...UPDATE_HANDLERS };
+import { MOVE_HANDLERS } from "./move.js";
+import { AGENT_CONFIG_HANDLERS } from "./agent-config-sync.js";
+export const HANDLERS = { ...MOVE_HANDLERS, ...DEVICE_HANDLERS, ...CODEX_CLOUD_HANDLERS, ...CLI_PROXY_HANDLERS, ...THREAD_HANDLERS, ...CONVERSATION_HANDLERS, ...LOCAL_CONVERSATION_HANDLERS, ...TWIN_HANDLERS, ...CREDENTIAL_HANDLERS, ...AGENT_CREDENTIAL_HANDLERS, ...ACCOUNT_POOL_HANDLERS, ...KEY_HANDLERS, ...ACCOUNT_HANDLERS, ...AGENT_HANDLERS, ...CENTER_HANDLERS, ...TARGET_HANDLERS, ...AGENT_GIT_HANDLERS, ...MENUBAR_HANDLERS, ...FILESYSTEM_HANDLERS, ...UPDATE_HANDLERS, 'agents config-sync': AGENT_CONFIG_HANDLERS['agents config-sync'] };

package/dist/initial-prompt.d.ts

@@ -22,5 +22,18 @@ export declare function readInitialImages(ctx: Ctx, values: Values, prompt: stri
 export declare function promptWithImages(prompt: string, images: readonly InitialImage[]): string;
 /** Writes the images into the conversation VM before the first message refers to them. */
 export declare function uploadInitialImages(cell: Pick<CellClient, 'files'>, images: readonly InitialImage[], signal?: AbortSignal): Promise<void>;
-/** Wait for the native terminal to enable paste before submitting one first turn. No blind timing or input replay. */
-export declare function submitInitialPrompt(connect: (signal: AbortSignal) => Promise<TerminalConnection>, prompt: string, workspaceKey: string, signal: AbortSignal, app?: 'claude' | 'codex', write?: (bytes: Uint8Array) => Promise<unknown>): Promise<void>;
+/** The conversation inbox takes a message of at most this many characters (the API's text limit). */
+export declare const INBOX_MAX_CHARS = 65536;
+/**
+ * The harness's input box is the last thing that drew its prompt glyph (0.19.1+). Claude Code and Codex draw the same
+ * glyph as the selection cursor of their dialogs ("❯ 1. Yes, I trust this folder"); a prompt pasted there would pick
+ * options. The guest's own first-message delivery reads the screen the same way (coding 39+).
+ */
+export declare function inputBoxReady(tail: string, glyph: string): boolean;
+/**
+ * Wait for the native terminal to enable paste before submitting one first turn. No blind timing or input replay.
+ * When nothing was typed yet and the terminal never became ready, `queue` hands the prompt to the conversation's guest
+ * (its inbox, which waits for the harness and retries Enter) and the result is `queued` (0.19.1+): a first prompt is
+ * never lost to a slow start.
+ */
+export declare function submitInitialPrompt(connect: (signal: AbortSignal) => Promise<TerminalConnection>, prompt: string, workspaceKey: string, signal: AbortSignal, app?: 'claude' | 'codex', write?: (bytes: Uint8Array) => Promise<unknown>, queue?: () => Promise<unknown>): Promise<'submitted' | 'queued'>;

package/dist/initial-prompt.js

@@ -137,8 +137,26 @@ export async function uploadInitialImages(cell, images, signal) {
         await cell.files.write(image.path, image.data, { mode: '0600', createParents: true });
     }
 }
-/** Wait for the native terminal to enable paste before submitting one first turn. No blind timing or input replay. */
-export async function submitInitialPrompt(connect, prompt, workspaceKey, signal, app = 'claude', write) {
+/** The conversation inbox takes a message of at most this many characters (the API's text limit). */
+export const INBOX_MAX_CHARS = 65536;
+/**
+ * The harness's input box is the last thing that drew its prompt glyph (0.19.1+). Claude Code and Codex draw the same
+ * glyph as the selection cursor of their dialogs ("❯ 1. Yes, I trust this folder"); a prompt pasted there would pick
+ * options. The guest's own first-message delivery reads the screen the same way (coding 39+).
+ */
+export function inputBoxReady(tail, glyph) {
+    // eslint-disable-next-line no-control-regex -- Native terminal escapes are removed before reading the screen text.
+    const plain = tail.replace(/\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, ' ');
+    const at = plain.lastIndexOf(glyph);
+    return at >= 0 && !/^[\s\u00a0]*\d+\./.test(plain.slice(at + glyph.length));
+}
+/**
+ * Wait for the native terminal to enable paste before submitting one first turn. No blind timing or input replay.
+ * When nothing was typed yet and the terminal never became ready, `queue` hands the prompt to the conversation's guest
+ * (its inbox, which waits for the harness and retries Enter) and the result is `queued` (0.19.1+): a first prompt is
+ * never lost to a slow start.
+ */
+export async function submitInitialPrompt(connect, prompt, workspaceKey, signal, app = 'claude', write, queue) {
     const bounded = AbortSignal.any([signal, AbortSignal.timeout(20000)]);
     let connection;
     let sent = false, pasted = false;
@@ -159,7 +177,7 @@ export async function submitInitialPrompt(connect, prompt, workspaceKey, signal,
             // eslint-disable-next-line no-control-regex -- Strip native terminal ANSI before matching prompt echo.
             const plain = tail.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').replace(/\s/g, '');
             if (sent && bytes.length)
-                return;
+                return 'submitted';
             if (pasted) {
                 // A long prompt overflows the input box: a 24-row terminal shows only its end, so either end confirms the paste.
                 const compact = prompt.replace(/\s/g, '');
@@ -174,7 +192,7 @@ export async function submitInitialPrompt(connect, prompt, workspaceKey, signal,
                 tail = '';
                 continue;
             }
-            const ready = app === 'claude' ? tail.includes('❯') : tail.includes('›');
+            const ready = inputBoxReady(tail, app === 'claude' ? '❯' : '›');
             if (!ready || !pasteEnabled)
                 continue;
             const paste = Buffer.from(`\x1b[200~${prompt}\x1b[201~`);
@@ -188,6 +206,13 @@ export async function submitInitialPrompt(connect, prompt, workspaceKey, signal,
         throw new Error('The agent terminal closed before accepting a prompt.');
     }
     catch {
+        if (!pasted && queue && !signal.aborted && prompt.length <= INBOX_MAX_CHARS) {
+            try {
+                await queue();
+                return 'queued';
+            }
+            catch { /* reported as not submitted below */ }
+        }
         throw new CodedError('initial_prompt_failed', `Created ${workspaceKey}, but the initial prompt ${sent ? 'could not be confirmed' : 'was not submitted'}. Open that conversation before starting another.`, undefined, { workspace_key: workspaceKey, submitted: sent });
     }
     finally {

package/dist/local-sessions.d.ts

@@ -0,0 +1,60 @@
+export type SessionHarness = 'claude' | 'codex';
+export interface LocalSession {
+    harness: SessionHarness;
+    session_id: string;
+    /** The transcript (Claude) or rollout (Codex) file. */
+    file: string;
+    /** The session's working directory, as its transcript records it. */
+    cwd: string;
+    title: string;
+    updated_at: string;
+    bytes: number;
+    /** Where it was started: Claude's entrypoint (cli, claude-desktop, sdk-cli…) or Codex's originator (codex-tui…). */
+    source: string;
+}
+export interface SessionState {
+    /** A process has the session open right now. */
+    running: boolean;
+    /** working: a turn is in progress (never cut off); idle: between turns, or no process is running it. */
+    turn: 'working' | 'idle';
+    pid?: number;
+}
+type Env = Record<string, string | undefined>;
+type Rec = Record<string, unknown>;
+export declare const isSessionId: (id: string) => boolean;
+export declare const claudeConfigDir: (env: Env) => string;
+export declare const codexHome: (env: Env) => string;
+/** Claude Code's folder name under projects/ for a working directory (measured: a 268-character path → 200 + "-1qkjv5"). */
+export declare function claudeProjectName(cwd: string): string;
+/** Records appended after `offset` (whole lines only). */
+export declare function recordsAfter(file: string, offset: number): Rec[];
+/** Whether the transcript's last turn is still running, from its records (see the module comment). */
+export declare function claudeTurnFromRecords(records: Rec[]): 'working' | 'idle';
+export declare function codexTurnFromRecords(records: Rec[]): 'working' | 'idle';
+/** A project's sessions on this computer, newest first: those started in the folder or below it. */
+export declare function listLocalSessions(folder: string, env: Env, options?: {
+    harness?: SessionHarness;
+    limit?: number;
+}): LocalSession[];
+/** One session by id, wherever it was started. */
+export declare function findLocalSession(id: string, env: Env): LocalSession | null;
+/** Whether a turn is running now. A session no process has open is between turns, whatever its last record says. */
+export declare function sessionState(s: Pick<LocalSession, 'harness' | 'session_id' | 'file'>, env: Env, now?: number): SessionState;
+/** Whether someone typed in the local copy after it moved: a new prompt or turn after `offset`. */
+export declare function continuedAfter(s: Pick<LocalSession, 'harness' | 'file'>, offset: number): boolean;
+/**
+ * The transcript as whole lines, cut after its last complete record: a harness may be appending a record while a
+ * move reads it (between turns that is metadata, never part of a turn).
+ */
+export declare function completeRecords(bytes: Buffer): Buffer;
+/**
+ * The session's records with its working directory moved from `from` to `to`: Claude's and Codex's `cwd` fields (and
+ * Codex's workdir and workspace roots). Lines that do not mention `from` keep their exact bytes; message text,
+ * tool output and signed thinking are never changed.
+ */
+export declare function rewriteSessionPaths(bytes: Buffer, from: string, to: string): Buffer;
+/** Where the session's transcript lives under a home folder, relative to it (the VM's and the project space's layout). */
+export declare function homeRelativeTranscript(s: Pick<LocalSession, 'harness' | 'session_id' | 'file'>, cwd: string): string;
+/** The transcript file is a regular file: never follow a link out of the harness's store. */
+export declare function readTranscript(file: string): Buffer;
+export {};