@shardflux/cli 0.18.0 → 0.19.0

package/dist/conversations.js

@@ -4,11 +4,13 @@ import { AgentStateStore } from "./agent-state.js";
 import { gitRunner } from "./agent-git.js";
 import { projectIdentity } from "./project-identity.js";
 import { ensureProjectGit } from "./project-git.js";
-import { seedAgentRepository } from "./agent-repository.js";
+import { preflightProjectSeed, seedAgentRepository } from "./agent-repository.js";
 import { UsageError } from "./errors.js";
 import { conversationClient } from "./conversation-commands.js";
 import { recordSeedSnapshot } from "./files-mirror.js";
 import { rememberTwinSeed, sendTwinSeed, twinCheckoutArgv, twinSeed } from "./worktree-twin.js";
+import { progress } from "./progress.js";
+import { seedPhase, startProgress } from "./seed-phases.js";
 /**
  * Whether the conversation has ended: its VM was reclaimed, or it was archived or discarded. A finished turn is `done`
  * while its VM still takes the next turn; on Codex Cloud, `done` ends the conversation.
@@ -20,6 +22,37 @@ export const conversationName = (c) => {
         throw new Error('Conversation returned an invalid branch or name');
     return name;
 };
+/** The guest's managed PTY id: `shard-<name>-<app>` (services/guest-agent/internal/agents PtyID). */
+const MANAGED_PTY = /^shard-[a-z0-9][a-z0-9._-]{0,63}-(claude|codex)$/;
+/**
+ * The managed PTY a conversation's harness runs in (0.18.1+). The guest records it per conversation
+ * (sf-agent's conversation runtime record), which also keeps the PTY a fork inherited from its parent; without a
+ * record it is the one the guest names after the conversation, `shard-<name>-<harness>`. Never the VM key's name: a
+ * conversation's VM is `<project>/conv-<name>`.
+ */
+export async function conversationPtyId(cell, c, signal) {
+    const derived = `shard-${conversationName(c)}-${c.harness}`;
+    let stdout;
+    try {
+        const r = await cell.exec.run(['cat', `/home/user/.local/share/shardflux/conversation-runtime/${c.id}.json`], { timeoutMs: 10_000, maxOutputBytes: 4096, ...(signal ? { signal } : {}) });
+        if (r.exitCode !== 0)
+            return derived;
+        stdout = r.stdout;
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        return derived;
+    }
+    let recorded;
+    try {
+        recorded = JSON.parse(stdout)?.pty_id;
+    }
+    catch {
+        return derived;
+    }
+    return typeof recorded === 'string' && MANAGED_PTY.test(recorded) && recorded.endsWith(`-${c.harness}`) ? recorded : derived;
+}
 export function validateConversation(c) {
     if (!c || !/^conv_[a-z0-9]{26}$/.test(c.id) || !c.project_id || !c.workspace_id || !c.worktree_path?.startsWith('/home/user/') || /[\0\r\n]/.test(c.worktree_path) || !['claude', 'codex'].includes(c.harness))
         throw new Error('Conversation response omitted its identity or binding');
@@ -120,10 +153,15 @@ export async function restoreConversationBinding(ctx, c, ws) {
     const result = await cell.exec.run(['sf-agent', 'conversation', 'restore', '--args', '{"start":false}'], { cwd: c.worktree_path, env: { SF_CONVERSATION_ID: c.id }, timeoutMs: 120_000, signal: ctx.signal });
     if (result.exitCode !== 0)
         throw new Error(`Conversation restore failed: ${result.stderr.trim()}`);
+    // A conversation whose VM was removed now runs in a fresh one, from its saved branch and transcript (0.18.1+).
+    if (c.restore.kind === 'resume')
+        progress(ctx, 'Restored');
 }
-export async function createConversationRecord(ctx, folder, harness, route, name, allocated, idempotencyKey = randomUUID(), choice = {}) {
+export async function createConversationRecord(ctx, folder, harness, route, name, allocated, idempotencyKey = randomUUID(), choice = {}, movedIn) {
     const project = projectIdentity(folder);
     await ensureProjectGit(ctx, project.folder);
+    // A start refuses before a VM is allocated, never after (0.19.0+).
+    await preflightProjectSeed(project.folder, ctx.signal);
     // Both the conversation API and its legacy workspace fallback need a usable local HEAD.
     await conversationClient(ctx).conversations.list({ limit: 1 });
     const git = gitRunner(project.folder, { ...process.env, ...ctx.io.env }, ctx.signal);
@@ -131,32 +169,46 @@ export async function createConversationRecord(ctx, folder, harness, route, name
     const branch = await git(['symbolic-ref', '--quiet', '--short', 'HEAD']).catch(() => undefined);
     // Uncommitted edits ride along as the twin snapshot the conversation starts from (worktree-twin.ts).
     const seed = await twinSeed(ctx.store.dir, project.folder, head, ctx.store.profile(ctx.apiUrl).project_id).catch(() => ({ commit: head, snapshot: false }));
+    seedPhase('local_snapshot');
     const commit = seed.commit;
     const response = await conversationClient(ctx).conversations.create({ repoRemote: project.remote ?? `file://${project.folder}`, harness, route, mode: 'new',
-        base: { commit, ...(branch ? { branch } : {}) }, ...(name ? { name } : {}), ...choice, projectId: ctx.store.profile(ctx.apiUrl).project_id }, { idempotencyKey, signal: ctx.signal });
+        base: { commit, ...(branch ? { branch } : {}) }, ...(name ? { name } : {}), ...choice, projectId: ctx.store.profile(ctx.apiUrl).project_id,
+        ...(movedIn ? { harnessSessionId: movedIn.session_id, ...(movedIn.title ? { title: movedIn.title.slice(0, 200) } : {}) } : {}) }, { idempotencyKey, signal: ctx.signal });
     const c = validateConversation({ ...response.conversation, restore: response.restore });
     allocated?.(response.workspace);
     rememberTwinSeed(ctx.store.dir, c.id, project.folder, seed, branch);
     rememberConversation(ctx, c, project.folder, false, branch);
     return c;
 }
-export async function createConversation(ctx, folder, harness, route, name, choice = {}) {
+export async function createConversation(ctx, folder, harness, route, name, choice = {}, movedIn) {
     const project = projectIdentity(folder);
-    const c = await createConversationRecord(ctx, project.folder, harness, route, name, undefined, undefined, choice);
+    seedPhase('start');
+    // The launcher's phase line (SHARDFLUX_PROGRESS_FILE, 0.19.0+): a computer starts, then the seed's own marks move it on.
+    startProgress(harness, ctx.io.env);
+    const c = await createConversationRecord(ctx, project.folder, harness, route, name, undefined, undefined, choice, movedIn);
+    seedPhase('conversation_create');
     try {
         const ws = await conversationWorkspace(ctx, c);
+        seedPhase('vm_running');
+        // A moved-in session's transcript is in place before the repository: its guest resumes it once the seed is done.
+        await movedIn?.beforeSeed(ws, c);
         // This is a one-time seed. A conversation never watches or writes the owner's checkout.
         await seedAgentRepository(ctx, ws, project.folder, { root: c.worktree_path, populate: true });
         const cell = ws.cell();
+        seedPhase('seed_done');
         await sendTwinSeed(ctx.store.dir, cell, c, project.folder, ctx.signal);
+        seedPhase('twin_seed');
         const result = await 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()}`);
+        seedPhase('branch_checkout');
         await recordSeedSnapshot(ws, c, ctx.signal);
+        seedPhase('seed_snapshot');
         return { conversation: c, workspace: ws };
     }
     catch (error) {
-        if (route === 'codex-cloud') {
+        // A failed move leaves nothing behind: its session can move again (the API counts only a live VM's move).
+        if (route === 'codex-cloud' || movedIn) {
             try {
                 await ctx.cloud().workspaces.delete(c.workspace_id);
             }

package/dist/errors.d.ts

@@ -37,7 +37,7 @@ export declare class GitError extends HintedError {
 }
 /**
  * A refusal `shard` detects itself, with a stable code, its facts in `details` and the next step as `hint` (exit 1),
- * e.g. `repository_too_large` (0.13.3+) for Git history over the initial sync limit.
+ * e.g. `t3_not_installed` (0.17.0+) when T3 Code is missing.
  */
 export declare class CodedError extends HintedError {
     name: string;

package/dist/errors.js

@@ -54,7 +54,7 @@ export class GitError extends HintedError {
 }
 /**
  * A refusal `shard` detects itself, with a stable code, its facts in `details` and the next step as `hint` (exit 1),
- * e.g. `repository_too_large` (0.13.3+) for Git history over the initial sync limit.
+ * e.g. `t3_not_installed` (0.17.0+) when T3 Code is missing.
  */
 export class CodedError extends HintedError {
     name = 'CodedError';

package/dist/files-mirror.d.ts

@@ -146,15 +146,7 @@ export declare class FilesMirror {
         already: boolean;
     }>;
 }
-/**
- * The seed snapshot (sh; $1 repository, $2 conversation name, $3 hub): HEAD plus the working tree the conversation was
- * seeded with, committed in the conversation's VM with a temporary index (never on this computer), kept per worktree
- * 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.
- */
-export declare const SEED_SNAPSHOT = "set -eu\ncd \"$1\"\nmain=0; [ \"$(git rev-parse --absolute-git-dir)\" = \"$(git rev-parse --path-format=absolute --git-common-dir)\" ] && main=1\nif git rev-parse -q --verify refs/worktree/shard/seed >/dev/null; then seed=$(git rev-parse refs/worktree/shard/seed)\nelif [ \"$main\" = 1 ] && git rev-parse -q --verify refs/shard/seed >/dev/null; then seed=$(git rev-parse refs/shard/seed); else\nidx=$(mktemp); trap 'rm -f \"$idx\"' EXIT\ncp \"$(git rev-parse --path-format=absolute --git-path index)\" \"$idx\" 2>/dev/null || { rm -f \"$idx\"; GIT_INDEX_FILE=\"$idx\" git read-tree HEAD; }\nGIT_INDEX_FILE=\"$idx\" git add -A\ntree=$(GIT_INDEX_FILE=\"$idx\" git write-tree)\nif [ \"$tree\" = \"$(git rev-parse 'HEAD^{tree}')\" ]; then seed=$(git rev-parse HEAD); else\nseed=$(GIT_AUTHOR_NAME=Shardflux GIT_AUTHOR_EMAIL=seed@shardflux.dev GIT_COMMITTER_NAME=Shardflux GIT_COMMITTER_EMAIL=seed@shardflux.dev git commit-tree \"$tree\" -p HEAD -m \"Shardflux: the working tree this conversation started from\"); fi\ngit update-ref refs/worktree/shard/seed \"$seed\"\nif [ \"$main\" = 1 ]; then git update-ref refs/shard/seed \"$seed\"; fi\nfi\nif [ -d \"$3\" ]; then git -c core.hooksPath=/dev/null push -q \"$3\" \"+$seed:refs/shard/seed/$2\" >/dev/null 2>&1 || true; fi\nprintf '%s\n' \"$seed\"\n";
+export declare const SEED_SNAPSHOT = "set -eu\ncd \"$1\"\nmain=0; [ \"$(git rev-parse --absolute-git-dir)\" = \"$(git rev-parse --path-format=absolute --git-common-dir)\" ] && main=1\nif git rev-parse -q --verify refs/worktree/shard/seed >/dev/null; then seed=$(git rev-parse refs/worktree/shard/seed)\nelif [ \"$main\" = 1 ] && git rev-parse -q --verify refs/shard/seed >/dev/null; then seed=$(git rev-parse refs/shard/seed); else\nidx=$(mktemp); trap 'rm -f \"$idx\"' EXIT\ncp \"$(git rev-parse --path-format=absolute --git-path index)\" \"$idx\" 2>/dev/null || { rm -f \"$idx\"; GIT_INDEX_FILE=\"$idx\" git read-tree HEAD; }\nGIT_INDEX_FILE=\"$idx\" git add -A\ntree=$(GIT_INDEX_FILE=\"$idx\" git write-tree)\nif [ \"$tree\" = \"$(git rev-parse 'HEAD^{tree}')\" ]; then seed=$(git rev-parse HEAD); else\nseed=$(GIT_AUTHOR_NAME=Shardflux GIT_AUTHOR_EMAIL=seed@shardflux.dev GIT_COMMITTER_NAME=Shardflux GIT_COMMITTER_EMAIL=seed@shardflux.dev git commit-tree \"$tree\" -p HEAD -m \"Shardflux: the working tree this conversation started from\"); fi\ngit update-ref refs/worktree/shard/seed \"$seed\"\nif [ \"$main\" = 1 ]; then git update-ref refs/shard/seed \"$seed\"; fi\nfi\npush='set -u\nseed=$1; name=$2; hub=$3; cd \"$4\"\npush=1; if [ \"$(git config --bool remote.origin.promisor 2>/dev/null || true)\" = true ]; then push=0\nfor 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\nif [ -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\n'\nif [ \"${4:-}\" = background ]; then\n  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 &)\n  else (sh -c \"$push\" shard-seed-push \"$seed\" \"$2\" \"$3\" \"$PWD\" >/dev/null 2>&1 </dev/null &); fi\nelse sh -c \"$push\" shard-seed-push \"$seed\" \"$2\" \"$3\" \"$PWD\"; fi\nprintf '%s\n' \"$seed\"\n";
 /** Best effort: without a snapshot the folder also lists the start state's own edits. */
 export declare function recordSeedSnapshot(ws: Pick<Workspace, 'cell'>, c: Pick<Conversation, 'worktree_path' | 'branch'>, signal?: AbortSignal): Promise<string | null>;
 /** A ready VM of the project (never woken), else the project's space reader, woken when needed. */

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/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 {};