@shardflux/cli 0.19.1 → 0.22.0

package/dist/agent-config-sync.d.ts

@@ -53,14 +53,22 @@ export declare function applyConfigFiles(cell: CellClient, home: string, files:
     copied: string[];
     removed: string[];
 }>;
-export declare function syncAgentConfig(ctx: Ctx, ws: Workspace): Promise<ConfigSyncResult>;
+/**
+ * `memoryOnly` (0.20.0+): just the project memory, for an account whose saved machine carries the rest. A conversation
+ * VM gets this computer's memory for its project, under the VM project folder's name (Claude keys memory by path).
+ */
+export declare function syncAgentConfig(ctx: Ctx, ws: Workspace, opts?: {
+    memoryOnly?: boolean;
+}): Promise<ConfigSyncResult>;
 /**
  * Copies the laptop's agent config into a new conversation's VM after its agent started (0.19.0+): the first prompt
  * never waits for it. From an installed shard it runs as its own detached process (`shard agents config-sync`, its
  * output in agent-config-sync.log of the config directory), so the command that started the conversation reports the
  * start at once; without a runtime (tests, an embedding) it runs here and the returned promise settles when it ends.
  */
-export declare function syncAgentConfigAfterStart(ctx: Ctx, ws: Workspace): Promise<void> | undefined;
+export declare function syncAgentConfigAfterStart(ctx: Ctx, ws: Workspace, opts?: {
+    memoryOnly?: boolean;
+}): Promise<void> | undefined;
 /** Tunnels are owned by the attachment, and close even if the terminal fails or the user detaches. */
 export declare function startAgentConfigTunnels(ctx: Ctx, ws: Workspace): Promise<{
     stop(): Promise<void>;

package/dist/agent-config-sync.js

@@ -7,7 +7,8 @@ import { parse, stringify } from 'smol-toml';
 import { ShardfluxApiError, tarEnd, tarHeader, tarPadding } from '@shardflux/sdk';
 import { AgentStateStore } from "./agent-state.js";
 import { UsageError } from "./errors.js";
-import { collectPlugins, collectUserFiles, object, readObject, readOptional, rewritePaths } from "./agent-config-files.js";
+import { collectMemory, collectPlugins, collectUserFiles, object, readObject, readOptional, rewritePaths, vmMemoryPath } from "./agent-config-files.js";
+import { localConversations } from "./conversations.js";
 import { digest, prepareMcp } from "./agent-config-mcp.js";
 import { configIssueLines } from "./agent-config-report.js";
 const missing = (e) => e instanceof ShardfluxApiError && e.status === 404;
@@ -15,7 +16,8 @@ const parseFailure = (e) => e instanceof SyntaxError || (e instanceof Error && /
 const markerPath = '.config/shardflux/agent-config.json';
 const safePath = (path) => !path.split('/').some(p => !p || p === '.' || p === '..') &&
     (/^(?:\.claude\/(?:settings\.json|CLAUDE\.md)|\.codex\/(?:config\.toml|AGENTS\.md))$/.test(path) ||
-        /^\.claude\/(?:skills|commands|agents|output-styles|plugins)\/.+/.test(path) || /^\.codex\/(?:prompts|skills)\/.+/.test(path));
+        /^\.claude\/(?:skills|commands|agents|output-styles|plugins)\/.+/.test(path) || /^\.codex\/(?:prompts|skills)\/.+/.test(path) ||
+        /^\.claude\/projects\/[^/]+\/memory\/.+/.test(path));
 const key = (ctx, id) => `${ctx.apiUrl}:${id}`;
 export function configManifests(ctx) {
     const value = object(new AgentStateStore(ctx.store.dir).read().agent_config);
@@ -285,33 +287,51 @@ async function installPlugins(cell, plan, issues, signal) {
         if (line.startsWith('failed '))
             issues.push({ item: `plugin:${line.slice(7)}`, reason: 'could not be installed in the VM' });
 }
-export async function syncAgentConfig(ctx, ws) {
+/**
+ * `memoryOnly` (0.20.0+): just the project memory, for an account whose saved machine carries the rest. A conversation
+ * VM gets this computer's memory for its project, under the VM project folder's name (Claude keys memory by path).
+ */
+export async function syncAgentConfig(ctx, ws, opts = {}) {
     const home = ctx.io.env.HOME || homedir();
     const store = new AgentStateStore(ctx.store.dir);
     const previous = configManifests(ctx)[key(ctx, ws.id)];
     const issues = [];
-    const files = await collectUserFiles(home, issues);
-    const codexBytes = await readOptional(join(home, '.codex/config.toml'));
+    const files = opts.memoryOnly ? new Map() : await collectUserFiles(home, issues);
+    const codexBytes = opts.memoryOnly ? undefined : await readOptional(join(home, '.codex/config.toml'));
     // One file that does not parse is skipped with a reason; it never stops the rest of the sync.
     let claude;
-    try {
-        claude = await readObject(join(home, '.claude.json'));
-    }
-    catch (error) {
-        if (!parseFailure(error))
-            throw error;
-        issues.push({ item: '.claude.json', reason: 'not valid JSON; its MCP servers were not copied' });
+    if (!opts.memoryOnly) {
+        try {
+            claude = await readObject(join(home, '.claude.json'));
+        }
+        catch (error) {
+            if (!parseFailure(error))
+                throw error;
+            issues.push({ item: '.claude.json', reason: 'not valid JSON; its MCP servers were not copied' });
+        }
     }
-    const plugins = await collectPlugins(home, issues);
+    const plugins = opts.memoryOnly ? { marketplaces: [], plugins: [] } : await collectPlugins(home, issues);
     const hasPlugins = plugins.marketplaces.length > 0 || plugins.plugins.length > 0;
+    const records = Object.values(localConversations(ctx));
+    const conversation = records.find(r => r.conversation.id === ws.labels.shard_conversation) ?? records.find(r => r.conversation.workspace_id === ws.id);
+    const memory = conversation ? await collectMemory(home, conversation.folder, issues) : undefined;
     const empty = { workspace_id: ws.id, workspace_key: ws.key, copied: [], removed: [], skipped: issues, mcp: [], synced_at: null };
-    if (!files.size && !codexBytes && !hasPlugins && !Object.keys(object(claude?.mcpServers)).length && !previous)
+    if (!files.size && !memory?.files.size && !codexBytes && !hasPlugins && !Object.keys(object(claude?.mcpServers)).length && !previous)
         return empty;
     const cell = ws.cell({ agentLabel: ctx.agentLabel, transitionTimeoutMs: ctx.wakeTimeoutMs });
-    const run = await cell.exec.run(['sh', '-c', 'printf "%s\\n" "$HOME"'], { signal: ctx.signal, timeoutMs: 5000, maxOutputBytes: 4096 });
-    const remoteHome = run.stdout.trim();
+    // The VM home, and the project folder its Claude keys memory by (the main checkout of the conversation's worktree).
+    const run = await cell.exec.run(['sh', '-c', 'printf "%s\\n" "$HOME"; [ -n "$1" ] && git -C "$1" rev-parse --path-format=absolute --git-common-dir 2>/dev/null || true', 'shard-config', conversation?.conversation.worktree_path ?? ''], { signal: ctx.signal, timeoutMs: 5000, maxOutputBytes: 4096 });
+    const [remoteHome = '', common = ''] = run.stdout.trim().split('\n').map(line => line.trim());
     if (run.exitCode !== 0 || !/^\/(?:[a-zA-Z0-9._-]+\/)*[a-zA-Z0-9._-]+$/.test(remoteHome) || remoteHome.split('/').some(p => p === '..' || p === '.'))
         throw new Error('agent config could not resolve the VM user home');
+    if (memory && conversation) {
+        const vmRoot = common.endsWith('/.git') ? common.slice(0, -5) : conversation.conversation.worktree_path;
+        for (const [path, file] of memory.files) {
+            const dest = vmMemoryPath(path, memory.root, vmRoot);
+            if (dest)
+                files.set(dest, file);
+        }
+    }
     // Claude settings stay the user's. sf-agent hooks are in /etc/claude-code/managed-settings.json.
     const secrets = { ...previous?.secrets, ...object(object(store.read().agent_config_secrets)[key(ctx, ws.id)]) };
     const commandCache = new Map();
@@ -432,8 +452,10 @@ export async function syncAgentConfig(ctx, ws) {
         sync_state: 'synced', synced_at, files: applied.files, claude_mcp: Object.keys(claudeMcp), claude_mcp_owned: partial.claude_mcp_owned, secrets, skipped: issues, mcp, tunnels,
         ...(pluginsHash ? { plugins_hash: pluginsHash } : {}) };
     manifest.remote_hash = digest(JSON.stringify({ files: applied.files, claude_mcp: claudeMcp, mcp, tunnels }));
-    if (marker?.workspace_id !== ws.id || marker.manifest_hash !== manifest.remote_hash)
-        await cell.files.write(`${remoteHome}/${markerPath}`, JSON.stringify({ workspace_id: ws.id, manifest_hash: manifest.remote_hash }) + '\n', { createParents: true, mode: '0600' });
+    // The marker names each file's hash (0.20.0+): the guest tells this copy's writes from the agent's own changes.
+    if (marker?.workspace_id !== ws.id || marker.manifest_hash !== manifest.remote_hash || !marker.files)
+        await cell.files.write(`${remoteHome}/${markerPath}`, JSON.stringify({ workspace_id: ws.id, manifest_hash: manifest.remote_hash,
+            files: Object.fromEntries(Object.entries(applied.files).map(([path, file]) => [path, file.hash])) }) + '\n', { createParents: true, mode: '0600' });
     store.update(doc => { const all = object(doc.agent_config); all[key(ctx, ws.id)] = manifest; doc.agent_config = all; });
     const result = { ...empty, copied: applied.copied, removed: applied.removed, skipped: issues, mcp, synced_at };
     if (!ctx.json) {
@@ -451,13 +473,13 @@ export async function syncAgentConfig(ctx, ws) {
  * output in agent-config-sync.log of the config directory), so the command that started the conversation reports the
  * start at once; without a runtime (tests, an embedding) it runs here and the returned promise settles when it ends.
  */
-export function syncAgentConfigAfterStart(ctx, ws) {
+export function syncAgentConfigAfterStart(ctx, ws, opts = {}) {
     if (ctx.runtime?.script) {
         try {
             mkdirSync(ctx.store.dir, { recursive: true, mode: 0o700 });
             const log = openSync(join(ctx.store.dir, 'agent-config-sync.log'), 'a', 0o600);
             try {
-                const child = spawn(ctx.runtime.node, [ctx.runtime.script, 'agents', 'config-sync', ws.id], {
+                const child = spawn(ctx.runtime.node, [ctx.runtime.script, 'agents', 'config-sync', ws.id, ...(opts.memoryOnly ? ['--memory-only'] : [])], {
                     detached: true, stdio: ['ignore', log, log],
                     env: { ...process.env, ...ctx.io.env, SHARDFLUX_CONFIG_DIR: ctx.store.dir, SHARDFLUX_API_URL: ctx.apiUrl, SHARDFLUX_NO_UPDATE_CHECK: '1' }
                 });
@@ -471,7 +493,7 @@ export function syncAgentConfigAfterStart(ctx, ws) {
         }
         catch { /* runs in this process below */ }
     }
-    return syncAgentConfig(ctx, ws).then(() => undefined, (error) => {
+    return syncAgentConfig(ctx, ws, opts).then(() => undefined, (error) => {
         ctx.io.stderr.write(`Agent config not copied to ${ws.key}: ${error instanceof Error ? error.message : String(error)}\n`);
     });
 }
@@ -501,41 +523,13 @@ export async function startAgentConfigTunnels(ctx, ws) {
 }
 export const AGENT_CONFIG_HANDLERS = {
     /** The detached copy syncAgentConfigAfterStart starts; one line per run in agent-config-sync.log. */
-    async 'agents config-sync'(ctx, _values, [id]) {
+    async 'agents config-sync'(ctx, values, [id]) {
         const ws = await ctx.cloud().workspaces.get(id);
         const started = Date.now();
-        const result = await syncAgentConfig({ ...ctx, json: true }, ws);
+        const result = await syncAgentConfig({ ...ctx, json: true }, ws, { memoryOnly: values['memory-only'] === true });
         ctx.io.stderr.write(`${new Date().toISOString()} ${ws.key}: ${result.copied.length} copied, ${result.removed.length} removed, ${result.skipped.length} skipped in ${Date.now() - started} ms\n`);
         for (const line of configIssueLines(result.skipped))
             ctx.io.stderr.write(`  ${line}\n`);
         return 0;
     },
-    'agents config status'(ctx, values) {
-        const workspace = typeof values.workspace === 'string' ? values.workspace : undefined;
-        const manifests = Object.values(configManifests(ctx)).filter(m => m.api_url === ctx.apiUrl && (!workspace || m.workspace_id === workspace || m.workspace_key === workspace));
-        const report = { observation: 'last sync on this machine', workspaces: manifests };
-        ctx.io.stdout.write(ctx.json ? JSON.stringify(report, null, 2) + '\n' : manifests.length ? manifests.map(m => `${m.workspace_key}: ${Object.keys(m.files).length} files; ${m.sync_state === 'synced' ? `last sync ${m.synced_at}` : 'sync interrupted; run config sync again'}\n` +
-            m.skipped.map(s => `  skipped ${s.item}: ${s.reason}\n`).join('') +
-            m.mcp.map(s => `  MCP ${s.app}/${s.name}: ${s.status}${s.reason ? ` (${s.reason})` : ''}\n`).join('')).join('') : 'No agent config has been synced on this machine.\n');
-        return Promise.resolve(0);
-    },
-    async 'agents config sync'(ctx, values) {
-        const workspace = typeof values.workspace === 'string' ? values.workspace : undefined;
-        const cloud = ctx.cloud();
-        const targets = [];
-        if (workspace) {
-            const ws = await cloud.workspaces.findByKey(workspace, { includeDeleted: false, signal: ctx.signal });
-            targets.push(ws ?? await cloud.workspaces.get(workspace));
-        }
-        else
-            for await (const ws of cloud.workspaces.listAll()) {
-                if (ws.labels.shard_project && ws.mode === 'processful')
-                    targets.push(ws);
-            }
-        const results = [];
-        for (const ws of targets)
-            results.push(await syncAgentConfig(ctx, ws));
-        ctx.io.stdout.write(ctx.json ? JSON.stringify({ workspaces: results }, null, 2) + '\n' : results.length ? results.map(r => r.synced_at === null ? `${r.workspace_key}: no local agent config found\n` : `${r.workspace_key}: ${r.copied.length} files copied, ${r.removed.length} removed\n`).join('') : 'No agent workspaces found.\n');
-        return 0;
-    },
 };

package/dist/agent-credentials.js

@@ -3,7 +3,8 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { json } from "./format.js";
 import { UsageError } from "./errors.js";
-import { loginClaudeInWorkspace, requireClaudeTerminal, cloudClaudeLogin } from "./claude-cloud-login.js";
+import { claudeTerminal, cloudClaudeLogin, loginClaudeInWorkspace } from "./claude-cloud-login.js";
+import { askTimeout } from "./secret-ask.js";
 import { resolveWorkspace } from "./commands.js";
 import { projectIdentity, projectLabels } from "./project-identity.js";
 async function optionalFile(file) {
@@ -74,7 +75,10 @@ export const AGENT_CREDENTIAL_HANDLERS = {
             output(ctx, existing);
             return 0;
         }
-        requireClaudeTerminal(ctx);
+        // In a coding agent's shell, with --json, without a terminal or with --ask (0.20.1+): the claude.ai sign-in and a
+        // page for its code open in the browser. On a terminal the sign-in attaches to it.
+        const headless = values.ask === true || !claudeTerminal(ctx);
+        const timeoutMs = askTimeout(values);
         const project = projectIdentity('./');
         let ws;
         if (typeof values.workspace === 'string')
@@ -85,7 +89,7 @@ export const AGENT_CREDENTIAL_HANDLERS = {
             const current = await cloud.workspaces.findByKey(key, { includeDeleted: false, signal: ctx.signal });
             ws = await cloud.workspaces.open({ key, template: 'coding', labels: { ...current?.labels, ...projectLabels(project, 'main', 'claude') }, wait: { signal: ctx.signal, timeoutMs: ctx.wakeTimeoutMs } });
         }
-        output(ctx, await loginClaudeInWorkspace(ctx, ws));
+        output(ctx, await loginClaudeInWorkspace(ctx, ws, headless ? { headless: { timeoutMs } } : {}));
         return 0;
     },
     'agents credentials sync': async (ctx) => { output(ctx, await syncAgentCredentials(ctx.cloud(), { home: ctx.io.env.HOME ?? ctx.io.env.USERPROFILE, redact: (value) => ctx.addSecret(value) })); return 0; },

package/dist/agent-repository.d.ts

@@ -22,12 +22,21 @@ export declare function seedAgentRepository(ctx: Ctx, ws: Workspace, folder: str
     populate?: boolean;
     initialFiles?: readonly string[];
     onInitialFiles?: () => void;
+    changes?: Promise<LocalChanges>;
+    background?: (started: Promise<unknown>) => void;
+    beforeHistory?: Promise<unknown>;
 }): Promise<void>;
 /**
  * Above this (an estimate: the repository's packed and loose objects) the workspace fetches the history from origin as a
  * blobless partial clone, and receives only the commits origin lacks (0.19.0+). Below it, one small bundle is faster.
  */
 export declare const ORIGIN_FIRST_BYTES: number;
+/**
+ * A Git step of the seed that writes the workspace repository's index, refs or config: run again, for up to ~5 s,
+ * while another Git process in the VM holds the lock (a conversation's agent starts as soon as its repository appears,
+ * and its own `git status` takes the index lock). Every step passed here is safe to repeat.
+ */
+export declare function runGitStep(cell: Pick<SyncCell, 'exec'>, argv: string[], options: Parameters<SyncCell['exec']['run']>[1] & object, attempts?: number): Promise<Awaited<ReturnType<SyncCell['exec']['run']>>>;
 /** The repository's object store size, an upper bound of any one branch's history bundle. Reads sizes only. */
 export declare function historyEstimate(folder: string, signal?: AbortSignal): Promise<number>;
 export declare const FETCH_ORIGIN: string;
@@ -39,7 +48,10 @@ export declare const CHECKOUT_HEAD: string;
  * from origin as a blobless partial clone (the workspace's own Git credentials), plus a bundle of the commits origin
  * lacks. Without a reachable origin the whole bundle is streamed in chunks: no history size refuses (0.19.0+).
  */
-export declare function importProjectHistory(cell: SyncCell, folder: string, root: string, head: string, branch: string, origin: string | null, signal?: AbortSignal, originFirst?: number, report?: (message: string) => void): Promise<{
+export declare function importProjectHistory(cell: SyncCell, folder: string, root: string, head: string, branch: string, origin: string | null, signal?: AbortSignal, originFirst?: number, report?: (message: string) => void, configure?: {
+    settings: string[];
+    excludes: string;
+}): Promise<{
     partial: string | null;
 }>;
 /**
@@ -47,11 +59,12 @@ export declare function importProjectHistory(cell: SyncCell, folder: string, roo
  * untracked files Git does not ignore, the .env files we always carry, Git LFS files (their content lives outside Git),
  * and deletions. Ignored files, nested repositories and submodule contents stay out.
  */
-export declare function localChanges(folder: string, signal?: AbortSignal): Promise<{
+export type LocalChanges = {
     copy: string[];
     remove: string[];
     skipped: {
         path: string;
         reason: string;
     }[];
-}>;
+};
+export declare function localChanges(folder: string, signal?: AbortSignal): Promise<LocalChanges>;