@shardflux/cli 0.16.0 → 0.18.0-next.4

package/dist/worktree-twin.js

@@ -516,19 +516,23 @@ export async function landingRound(cell, input) {
         await cell.exec.run(['rm', '-rf', '--', dir], { timeoutMs: 60_000 }).catch(() => undefined);
     }
 }
-async function landingRoundIn(cell, input) {
-    const now = input.now ?? Date.now, t0 = now(), timings = {};
-    const mark = (name) => { timings[name] = now() - t0; };
-    const c = input.conversation, branch = `refs/heads/${input.into}`, hub = input.hub ?? HUB_PATH, vmTmp = input.vmTmp ?? '/tmp';
+/** The twin of the checkout where the branch is checked out (or of the branch itself), or why not now. */
+async function takeSnapshot(input) {
+    const branch = `refs/heads/${input.into}`;
     if (input.worktree) {
         const reason = pauseReason(input.worktree);
         if (reason)
-            return { state: 'paused', reason, timings };
+            return { state: 'paused', reason };
     }
     const snap = input.worktree ? await snapshotWorktree(input.worktree, { device: input.device, stateDir: input.stateDir, signal: input.signal }) : await refTwin(input.repo, branch, input.device);
     if (input.worktree && snap.base !== await verifyCommit(input.repo, branch))
-        return { state: 'moved', reason: 'branch_switched', timings };
-    mark('snapshot');
+        return { state: 'moved', reason: 'branch_switched' };
+    return snap;
+}
+const landRefs = (name) => ({ tip: `refs/shard/land/${name}/tip`, result: `refs/shard/land/${name}/result` });
+/** The landing script in the conversation's VM against the twin; a ready landing's tip and result are fetched here. */
+async function mergeInVm(cell, input, snap, mark) {
+    const c = input.conversation, hub = input.hub ?? HUB_PATH, vmTmp = input.vmTmp ?? '/tmp';
     const out = `${vmTmp}/shard-land-${randomUUID()}.bundle`;
     const send = async (known) => {
         // The VM has the conversation's base and what earlier landings made there; the bundle carries the rest.
@@ -582,9 +586,8 @@ async function landingRoundIn(cell, input) {
         await runLandingScript(cell, { op: 'confirm', repo: c.worktree_path, hub, name: c.name, upto: land.upto, into: input.into }, input.signal).catch(() => undefined);
     }
     if (land.state !== 'ready')
-        return { state: land.state === 'error' ? 'error' : land.state, land, timings };
-    const fetched = join(tmpdir(), `shard-land-${randomUUID()}.bundle`);
-    const tipRef = `refs/shard/land/${c.name}/tip`, resultRef = `refs/shard/land/${c.name}/result`;
+        return land;
+    const fetched = join(tmpdir(), `shard-land-${randomUUID()}.bundle`), refs = landRefs(c.name);
     try {
         let bytes;
         if (land.bundle_b64)
@@ -598,8 +601,8 @@ async function landingRoundIn(cell, input) {
                 throw new Error('the landing bundle changed while it was read');
         }
         await writeFile(fetched, bytes, { mode: 0o600 });
-        await git(input.repo, ['fetch', '-q', '--no-tags', fetched, `+refs/shard/land/tip:${tipRef}`, `+refs/shard/land/result:${resultRef}`]);
-        if (await verifyCommit(input.repo, tipRef) !== land.tip || await verifyCommit(input.repo, resultRef) !== land.result)
+        await git(input.repo, ['fetch', '-q', '--no-tags', fetched, `+refs/shard/land/tip:${refs.tip}`, `+refs/shard/land/result:${refs.result}`]);
+        if (await verifyCommit(input.repo, refs.tip) !== land.tip || await verifyCommit(input.repo, refs.result) !== land.result)
             throw new Error('the landing bundle does not match the landing');
     }
     finally {
@@ -608,22 +611,144 @@ async function landingRoundIn(cell, input) {
             await cell.files.remove(out).catch(() => undefined);
     }
     mark('download');
-    const outcome = await applyLanding({ worktree: input.worktree, repo: input.repo, branch, base: land.base, twin: land.twin, tip: land.tip, result: land.result }, { backupRoot: input.backupRoot, quietMs: input.quietMs, now, label: { conversation_id: c.id, name: c.name, title: c.title } });
-    mark('apply');
-    await git(input.repo, ['update-ref', '-d', resultRef], { ok: [0, 1] });
-    await git(input.repo, ['update-ref', '-d', tipRef], { ok: [0, 1] });
-    if (outcome.state !== 'applied')
-        return { ...outcome, reason: 'reason' in outcome ? outcome.reason : 'busy', land, timings };
-    // The files are on disk. Recording the landing in the VM and copying it to the project hub (shared storage, seconds)
-    // runs after, without holding up the next landing.
+    return land;
+}
+async function dropLandRefs(repo, name) {
+    const refs = landRefs(name);
+    await git(repo, ['update-ref', '-d', refs.result], { ok: [0, 1] });
+    await git(repo, ['update-ref', '-d', refs.tip], { ok: [0, 1] });
+}
+/**
+ * The files are on disk. Recording the landing in the VM and copying it to the project hub (shared storage, seconds)
+ * runs after, without holding up the next landing.
+ */
+function confirmInVm(cell, input, snap, land, timings, since, now) {
+    const c = input.conversation, hub = input.hub ?? HUB_PATH;
     const confirmed = runLandingScript(cell, { op: 'confirm', repo: c.worktree_path, hub, name: c.name, upto: land.upto, into: input.into,
         twin: land.twin, hub_twin_ref: hubTwinRef(input.device, snap.id), tip: land.tip, result: land.result }, input.signal).then(r => {
         if (r.state === 'error')
             throw new Error(`landing confirmation failed: ${r.message ?? r.reason}`);
-        timings.confirm = now() - t0;
+        timings.confirm = now() - since;
     });
     confirmed.catch(() => undefined);
-    return { state: 'landed', land, applied: outcome, timings, confirmed };
+    return confirmed;
+}
+async function landingRoundIn(cell, input) {
+    const now = input.now ?? Date.now, t0 = now(), timings = {};
+    const mark = (name) => { timings[name] = now() - t0; };
+    const c = input.conversation, branch = `refs/heads/${input.into}`;
+    const snap = await takeSnapshot(input);
+    if ('state' in snap)
+        return { ...snap, timings };
+    mark('snapshot');
+    const land = await mergeInVm(cell, input, snap, mark);
+    if (land.state !== 'ready')
+        return { state: land.state === 'error' ? 'error' : land.state, land, timings };
+    const outcome = await applyLanding({ worktree: input.worktree, repo: input.repo, branch, base: land.base, twin: land.twin, tip: land.tip, result: land.result }, { backupRoot: input.backupRoot, quietMs: input.quietMs, now, label: { conversation_id: c.id, name: c.name, title: c.title } });
+    mark('apply');
+    await dropLandRefs(input.repo, c.name);
+    if (outcome.state !== 'applied')
+        return { ...outcome, reason: 'reason' in outcome ? outcome.reason : 'busy', land, timings };
+    return { state: 'landed', land, applied: outcome, timings, confirmed: confirmInVm(cell, input, snap, land, timings, t0, now) };
+}
+async function mergeTree(repo, base, ours, theirs, strategy) {
+    const r = await git(repo, ['merge-tree', '--write-tree', '--name-only', '--no-messages', '-z', `--merge-base=${base}`, ...(strategy ? ['-X', strategy] : []), ours, theirs], { ok: [0, 1] });
+    const parts = r.stdout.toString('utf8').split('\0');
+    return { tree: parts[0].trim(), conflicts: r.code === 1 ? [...new Set(parts.slice(1).filter(Boolean))].sort() : [] };
+}
+/** cur with each first-parent commit of base..tip replayed on it (author and message kept), or null on a conflict. */
+async function replayOnto(repo, cur, base, tip) {
+    const commits = (await gitText(repo, ['rev-list', '--reverse', '--first-parent', tip, `^${base}`])).split('\n').filter(Boolean);
+    for (const x of commits) {
+        const parent = await verifyCommit(repo, `${x}^1`);
+        if (!parent)
+            return null;
+        const { tree, conflicts } = await mergeTree(repo, parent, cur, x);
+        if (conflicts.length)
+            return null;
+        if (tree === await gitText(repo, ['rev-parse', `${cur}^{tree}`]))
+            continue;
+        const [name, email, date] = (await gitText(repo, ['log', '-1', '--format=%an%x00%ae%x00%ad', '--date=raw', x])).split('\0');
+        const raw = (await git(repo, ['cat-file', 'commit', x])).stdout, message = raw.subarray(raw.indexOf('\n\n') + 2);
+        cur = await gitText(repo, ['commit-tree', tree, '-p', cur, '-F', '-'], { input: message, env: { GIT_AUTHOR_NAME: name, GIT_AUTHOR_EMAIL: email, GIT_AUTHOR_DATE: date } });
+    }
+    return cur;
+}
+/** The user's working state with the branch's new commits merged in; where both changed the same lines, the user's text. */
+async function resultCommit(repo, base, twin, tip) {
+    let { tree, conflicts } = await mergeTree(repo, base, twin, tip);
+    const shadowed = conflicts;
+    if (conflicts.length) {
+        ({ tree, conflicts } = await mergeTree(repo, base, twin, tip, 'ours'));
+        if (conflicts.length) {
+            const dir = join(tmpdir(), `shard-index-${randomUUID()}`), env = { GIT_INDEX_FILE: dir };
+            try {
+                await git(repo, ['read-tree', tree], { env });
+                await git(repo, ['rm', '-r', '-q', '--cached', '--ignore-unmatch', '--', ...conflicts], { env });
+                const listing = (await git(repo, ['ls-tree', '-r', '-z', '--full-tree', twin, '--', ...conflicts])).stdout.toString('utf8').split('\0').filter(Boolean)
+                    .map(l => l.replace(/ (blob|commit) /, ' '));
+                if (listing.length)
+                    await git(repo, ['update-index', '-z', '--index-info'], { env, input: listing.join('\0') + '\0' });
+                tree = await gitText(repo, ['write-tree'], { env });
+            }
+            finally {
+                rmSync(dir, { force: true });
+            }
+        }
+    }
+    const commit = await gitText(repo, ['commit-tree', tree, '-p', tip, '-F', '-'], { input: 'Shardflux landing result\n', env: { GIT_AUTHOR_NAME: 'Shardflux', GIT_AUTHOR_EMAIL: 'landing@shardflux.dev', GIT_COMMITTER_NAME: 'Shardflux', GIT_COMMITTER_EMAIL: 'landing@shardflux.dev' } });
+    return { commit, shadowed };
+}
+/**
+ * Lands several finished conversations into one branch with one apply: one twin, the merges in their VMs in parallel,
+ * then their new commits stacked here in the given (finish) order and the files written once. A conversation whose
+ * commits do not stack cleanly on the earlier ones is 'deferred' (it lands next, against the new state).
+ */
+export async function landingBatch(items, shared) {
+    const now = shared.now ?? Date.now, t0 = now(), timings = {};
+    const mark = (name) => { timings[name] = now() - t0; };
+    const snap = await takeSnapshot(shared);
+    if ('state' in snap)
+        return items.map(() => ({ ...snap, timings }));
+    mark('snapshot');
+    const inputs = items.map(it => ({ ...shared, mode: 'auto', conversation: it.conversation, upto: it.upto, known: it.known }));
+    const lands = await Promise.all(items.map((it, i) => mergeInVm(it.cell, inputs[i], snap, () => undefined)
+        .catch((error) => ({ state: 'error', reason: 'exception', message: error instanceof Error ? error.message : String(error) }))));
+    mark('merge');
+    const outcomes = lands.map(land => land.state === 'ready' ? undefined : { state: land.state === 'error' ? 'error' : land.state, land, timings });
+    const branch = `refs/heads/${shared.into}`, base = snap.base, included = [];
+    let cur = base;
+    for (const [i, land] of lands.entries()) {
+        if (land.state !== 'ready')
+            continue;
+        const next = cur === base ? land.tip : await replayOnto(shared.repo, cur, base, land.tip);
+        if (next) {
+            cur = next;
+            included.push(i);
+        }
+        else
+            outcomes[i] = { state: 'deferred', reason: 'stacked', land, timings };
+    }
+    try {
+        if (!included.length)
+            return outcomes.map(o => o);
+        const result = included.length === 1 ? { commit: lands[included[0]].result, shadowed: lands[included[0]].shadowed ?? [] } : await resultCommit(shared.repo, base, snap.commit, cur);
+        mark('stack');
+        const first = items[included[0]].conversation;
+        const applied = await applyLanding({ worktree: shared.worktree, repo: shared.repo, branch, base, twin: snap.commit, tip: cur, result: result.commit }, { backupRoot: shared.backupRoot, quietMs: shared.quietMs, now, label: { conversation_id: first.id, name: included.map(i => items[i].conversation.name).join('+'), title: first.title } });
+        mark('apply');
+        for (const i of included) {
+            const land = { ...lands[i], shadowed: result.shadowed };
+            outcomes[i] = applied.state === 'applied'
+                ? { state: 'landed', land, applied, timings, confirmed: confirmInVm(items[i].cell, inputs[i], snap, land, timings, t0, now) }
+                : { ...applied, reason: 'reason' in applied ? applied.reason : 'busy', land, timings };
+        }
+        return outcomes.map(o => o);
+    }
+    finally {
+        for (const it of items)
+            await dropLandRefs(shared.repo, it.conversation.name);
+    }
 }
 export class TwinLedger {
     store;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardflux/cli",
-  "version": "0.16.0",
+  "version": "0.18.0-next.4",
   "type": "module",
   "description": "shard: the Shardflux command line. Create an account, sign in, set up keys and billing, then open, run commands in, move files to, suspend, resume and fork serverless agent workspaces.",
   "license": "Apache-2.0",
@@ -43,29 +43,17 @@
     "access": "public"
   },
   "dependencies": {
+    "@shardflux/sdk": "0.24.0-next.4",
     "classic-level": "3.0.0",
     "smol-toml": "1.9.0",
     "snappyjs": "0.7.0",
-    "yaml": "2.9.1",
-    "@shardflux/sdk": "^0.22.0"
-  },
-  "devDependencies": {
-    "@eslint/js": "10.0.1",
-    "@types/node": "24.13.6",
-    "eslint": "10.11.0",
-    "playwright": "1.62.1",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.70.1"
+    "yaml": "2.9.1"
   },
   "optionalDependencies": {
-    "@shardflux/menubar-darwin": "^0.4.0"
-  },
-  "scripts": {
-    "build": "node scripts/build.mjs",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "lint": "eslint .",
-    "test": "node --test test/*.test.ts"
+    "@shardflux/menubar-darwin": "^0.5.0",
+    "@shardflux/desktop-linux-x64": "0.1.0-next.4",
+    "@shardflux/desktop-linux-arm64": "0.1.0-next.4"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts"
-}
+}