amalgm 0.1.175 → 0.1.176

package/runtime/scripts/amalgm-mcp/workspace/merge.js

@@ -27,6 +27,7 @@
  * goes through transition.applyMergedFiles so it lands in the journal.
  */
 
+const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -102,6 +103,21 @@ async function treeOfPatch(worktreeRoot, baseOid, diff) {
   });
 }
 
+/** The exact binary patch that turns a commit into a tree. */
+async function diffOfTree(worktreeRoot, baseOid, treeOid) {
+  const { stdout } = await run(
+    ['-c', 'core.quotepath=false', 'diff', '--binary', '--full-index', baseOid, treeOid],
+    worktreeRoot,
+  );
+  return stdout;
+}
+
+/** The exact tree currently represented by Git's index. */
+async function indexTree(worktreeRoot) {
+  const { stdout } = await run(['write-tree'], worktreeRoot);
+  return stdout.trim();
+}
+
 /** Paths that differ between two trees, no rename detection — exact adds/deletes. */
 async function changedPaths(worktreeRoot, treeA, treeB) {
   const { stdout } = await run(
@@ -158,7 +174,7 @@ function isText(buffer) {
 }
 
 /** Content-level three-way merge; { ok, content } — never writes markers to disk. */
-async function mergeFileContents(ours, base, theirs) {
+async function mergeFileContents(ours, base, theirs, labels = {}) {
   return withScratch(async (dir) => {
     const oursFile = path.join(dir, 'ours');
     const baseFile = path.join(dir, 'base');
@@ -168,7 +184,13 @@ async function mergeFileContents(ours, base, theirs) {
     await fs.promises.writeFile(theirsFile, theirs);
     const conflictCodes = Array.from({ length: 127 }, (_, i) => i + 1);
     const result = await run(
-      ['merge-file', '-p', '-L', 'local', '-L', 'base', '-L', 'peer', oursFile, baseFile, theirsFile],
+      [
+        'merge-file', '-p',
+        '-L', labels.ours || 'current',
+        '-L', labels.base || 'base',
+        '-L', labels.theirs || 'incoming',
+        oursFile, baseFile, theirsFile,
+      ],
       dir,
       { okCodes: conflictCodes, binary: true },
     );
@@ -176,6 +198,98 @@ async function mergeFileContents(ours, base, theirs) {
   });
 }
 
+function sameEntry(left, right) {
+  return left === null
+    ? right === null
+    : right !== null && left.mode === right.mode && left.type === right.type && left.oid === right.oid;
+}
+
+async function storedBlob(worktreeRoot, content, scratchDir, name) {
+  const file = path.join(scratchDir, name);
+  await fs.promises.writeFile(file, content);
+  const { stdout } = await run(['hash-object', '-w', file], worktreeRoot);
+  return stdout.trim();
+}
+
+function conflictCopyPath(relPath, label) {
+  const digest = crypto.createHash('sha256').update(`${label}\0${relPath}`).digest('hex').slice(0, 16);
+  return `.amalgm-conflicts/${digest}/${relPath}`;
+}
+
+/**
+ * Pure checkpoint reduction. Apply one published transition
+ * (`baseTree → targetTree`) to the currently reduced tree. No working file
+ * is read or written. Disjoint changes combine, identical changes fold, and
+ * overlaps produce the same conflict bytes and paths on every machine.
+ */
+async function reduceTree(worktreeRoot, currentTree, baseTree, targetTree, { label = 'rail' } = {}) {
+  const updates = [];
+  const conflicts = [];
+
+  await withScratch(async (dir) => {
+    let stored = 0;
+    for (const relPath of await changedPaths(worktreeRoot, baseTree, targetTree)) {
+      if (unsafePath(relPath)) {
+        conflicts.push({ path: relPath, kind: 'unsafe-path', label });
+        continue;
+      }
+      const base = await entryAt(worktreeRoot, baseTree, relPath);
+      const current = await entryAt(worktreeRoot, currentTree, relPath);
+      const target = await entryAt(worktreeRoot, targetTree, relPath);
+
+      if (sameEntry(current, target) || sameEntry(base, target)) continue;
+      if (sameEntry(current, base)) {
+        updates.push({ path: relPath, entry: target });
+        continue;
+      }
+
+      const baseBytes = base?.type === 'blob' ? await readBlob(worktreeRoot, base.oid) : null;
+      const currentBytes = current?.type === 'blob' ? await readBlob(worktreeRoot, current.oid) : null;
+      const targetBytes = target?.type === 'blob' ? await readBlob(worktreeRoot, target.oid) : null;
+      const mergeable = base && current && target
+        && base.type === 'blob' && current.type === 'blob' && target.type === 'blob'
+        && base.mode !== '120000' && current.mode !== '120000' && target.mode !== '120000'
+        && isText(baseBytes) && isText(currentBytes) && isText(targetBytes);
+
+      if (mergeable) {
+        const merged = await mergeFileContents(currentBytes, baseBytes, targetBytes, {
+          ours: 'current',
+          base: 'shared-base',
+          theirs: `rail-${label}`,
+        });
+        const oid = await storedBlob(worktreeRoot, merged.content, dir, `merged-${stored++}`);
+        updates.push({ path: relPath, entry: { mode: current.mode, type: 'blob', oid } });
+        if (!merged.ok) conflicts.push({ path: relPath, kind: 'content-overlap', label });
+        continue;
+      }
+
+      // Binary/delete/add conflicts retain the current path and, when the
+      // incoming side has bytes, preserve those bytes at one deterministic
+      // conflict path. The reducer's conflict record preserves delete intent.
+      const kind = !target
+        ? 'delete-vs-change'
+        : !current
+          ? 'change-vs-delete'
+          : !base
+            ? 'add-add'
+            : 'binary-overlap';
+      const conflict = { path: relPath, kind, label };
+      if (targetBytes) {
+        const copyPath = conflictCopyPath(relPath, label);
+        const oid = await storedBlob(worktreeRoot, targetBytes, dir, `conflict-${stored++}`);
+        updates.push({ path: copyPath, entry: { mode: '100644', type: 'blob', oid } });
+        conflict.copyPath = copyPath;
+      }
+      conflicts.push(conflict);
+    }
+  });
+
+  return {
+    tree: updates.length ? await updateHeldTree(worktreeRoot, currentTree, updates) : currentTree,
+    conflicts,
+  };
+}
+
 /** heldTree with the given entries replaced/removed — via a scratch index. */
 async function updateHeldTree(worktreeRoot, heldTree, applied) {
   return withScratch(async (dir) => {
@@ -284,7 +398,10 @@ async function advance(worktreeRoot, heldTree, targetTree, { label } = {}) {
 
 module.exports = {
   advance,
+  diffOfTree,
   hasTree,
+  indexTree,
+  reduceTree,
   treeOf,
   treeOfPatch,
 };

package/runtime/scripts/amalgm-mcp/workspace/objects.js

@@ -5,7 +5,7 @@
  *
  * A card names one content-addressed bundle when origin cannot supply its
  * commit. The bundle is split into fixed-size opaque chunks; the tunnel
- * stores and retrieves those chunks under the authenticated user. Chunking
+ * stores and retrieves those chunks under the authorized code project. Chunking
  * changes transport size, never the two-value repo model.
  */
 
@@ -63,6 +63,7 @@ function writeJson(file, value) {
 function publicLocator(manifest) {
   return {
     contract: CONTRACT,
+    resourceId: manifest.resourceId,
     oid: manifest.oid,
     ref: manifest.ref,
     checksum: manifest.checksum,
@@ -75,6 +76,7 @@ function publicPayloadLocator(manifest) {
   return {
     kind: 'chunks',
     contract: PAYLOAD_CONTRACT,
+    resourceId: manifest.resourceId,
     checksum: manifest.checksum,
     bytes: manifest.bytes,
     chunks: manifest.chunks.map(({ sha256: digest, bytes }) => ({ sha256: digest, bytes })),
@@ -97,7 +99,7 @@ function wake(op, id) {
   appendStateEvent({ resource: 'repo-objects', op, id, source: 'repo-objects' });
 }
 
-async function prepareBundle(worktreeRoot, repoKey, oid, file) {
+async function prepareBundle(worktreeRoot, repoKey, resourceId, oid, file) {
   ensureDirs();
   const bundleFile = path.join(ROOT, `${crypto.randomBytes(12).toString('hex')}.bundle`);
   const ref = `refs/amalgm/exports/${oid}`;
@@ -107,6 +109,7 @@ async function prepareBundle(worktreeRoot, repoKey, oid, file) {
     const chunks = writeChunks(bundle);
     writeJson(file, {
       contract: CONTRACT,
+      resourceId,
       repoKey,
       oid,
       ref,
@@ -121,15 +124,21 @@ async function prepareBundle(worktreeRoot, repoKey, oid, file) {
   }
 }
 
-function publishPayload(key, bytesInput) {
+function publishPayload(key, bytesInput, repoKey) {
   ensureDirs();
   const bytes = Buffer.isBuffer(bytesInput) ? bytesInput : Buffer.from(bytesInput);
   const file = payloadFile(key);
   let manifest = readJson(file);
   const checksum = sha256(bytes);
   if (!manifest || manifest.checksum !== checksum) {
+    const project = require('./wall').projectForRepo(repoKey);
+    if (!project?.resourceId) {
+      return { kind: 'pending', contract: PAYLOAD_CONTRACT, checksum };
+    }
     manifest = {
       contract: PAYLOAD_CONTRACT,
+      resourceId: project.resourceId,
+      repoKey,
       checksum,
       bytes: bytes.length,
       chunks: writeChunks(bytes),
@@ -143,10 +152,8 @@ function publishPayload(key, bytesInput) {
     : { kind: 'pending', contract: PAYLOAD_CONTRACT, checksum };
 }
 
-async function objectSourceFor(worktreeRoot, repoKey, oid) {
+async function bundleSourceFor(worktreeRoot, repoKey, oid) {
   if (!oid || !repoKey) return null;
-  if (await originContains(worktreeRoot, oid)) return { kind: 'remote' };
-
   const file = manifestFile(repoKey, oid);
   const manifest = readJson(file);
   if (manifest?.contract === CONTRACT && manifest.oid === oid) {
@@ -155,8 +162,10 @@ async function objectSourceFor(worktreeRoot, repoKey, oid) {
       : { kind: 'pending' };
   }
 
+  const project = require('./wall').projectForRepo(repoKey);
+  if (!project?.resourceId) return { kind: 'pending' };
   if (!preparing.has(file)) {
-    const promise = prepareBundle(worktreeRoot, repoKey, oid, file)
+    const promise = prepareBundle(worktreeRoot, repoKey, project.resourceId, oid, file)
       .catch((error) => console.warn(`[RepoObjects] bundle ${oid} failed:`, error.message))
       .finally(() => {
         preparing.delete(file);
@@ -168,6 +177,12 @@ async function objectSourceFor(worktreeRoot, repoKey, oid) {
   return { kind: 'pending' };
 }
 
+async function objectSourceFor(worktreeRoot, repoKey, oid) {
+  if (!oid || !repoKey) return null;
+  if (await originContains(worktreeRoot, oid)) return { kind: 'remote' };
+  return bundleSourceFor(worktreeRoot, repoKey, oid);
+}
+
 function claimUpload() {
   ensureDirs();
   for (const directory of [MANIFESTS, PAYLOADS]) {
@@ -176,13 +191,18 @@ function claimUpload() {
       const chunk = manifest?.chunks?.find((entry) => !entry.uploaded);
       if (!chunk) continue;
       const bytes = fs.readFileSync(path.join(CHUNKS, `${chunk.sha256}.bin`));
-      return { sha256: chunk.sha256, bytes: bytes.length, dataBase64: bytes.toString('base64') };
+      return {
+        resourceId: manifest.resourceId,
+        sha256: chunk.sha256,
+        bytes: bytes.length,
+        dataBase64: bytes.toString('base64'),
+      };
     }
   }
   return null;
 }
 
-function acknowledgeUpload(digest) {
+function acknowledgeUpload(resourceId, digest) {
   if (!/^[0-9a-f]{64}$/.test(String(digest || ''))) return { changed: false };
   ensureDirs();
   let changed = false;
@@ -191,7 +211,7 @@ function acknowledgeUpload(digest) {
     for (const name of fs.readdirSync(directory)) {
       const file = path.join(directory, name);
       const manifest = readJson(file);
-      if (!manifest?.chunks) continue;
+      if (manifest?.resourceId !== resourceId || !manifest?.chunks) continue;
       let touched = false;
       for (const chunk of manifest.chunks) {
         if (chunk.sha256 === digest && !chunk.uploaded) {
@@ -220,6 +240,7 @@ function validatePayloadLocator(locator) {
   if (
     locator?.kind !== 'chunks'
     || locator?.contract !== PAYLOAD_CONTRACT
+    || !/^shr_[A-Za-z0-9_-]{16,128}$/.test(String(locator.resourceId || ''))
     || !/^[0-9a-f]{64}$/.test(String(locator.checksum || ''))
     || !Number.isSafeInteger(locator.bytes)
     || locator.bytes < 0
@@ -240,7 +261,10 @@ function readPayload(locator) {
   for (const chunk of locator.chunks) {
     const file = path.join(CHUNKS, `${chunk.sha256}.bin`);
     if (fs.existsSync(file) && fs.statSync(file).size === chunk.bytes) continue;
-    writeJson(requestFile(chunk.sha256), { sha256: chunk.sha256 });
+    writeJson(requestFile(locator.resourceId, chunk.sha256), {
+      resourceId: locator.resourceId,
+      sha256: chunk.sha256,
+    });
     waiting = true;
   }
   if (waiting) {
@@ -261,8 +285,8 @@ function readPayload(locator) {
   return { state: 'ready', bytes };
 }
 
-function requestFile(digest) {
-  return path.join(REQUESTS, `${digest}.json`);
+function requestFile(resourceId, digest) {
+  return path.join(REQUESTS, `${sha256(Buffer.from(`${resourceId}\n${digest}`))}.json`);
 }
 
 function claimDownload() {
@@ -273,21 +297,25 @@ function claimDownload() {
   return request?.sha256 ? request : null;
 }
 
-function receiveDownload(digest, dataBase64) {
+function receiveDownload(resourceId, digest, dataBase64) {
+  if (!/^shr_[A-Za-z0-9_-]{16,128}$/.test(String(resourceId || ''))) {
+    throw new Error('invalid repo object project');
+  }
   if (!/^[0-9a-f]{64}$/.test(String(digest || ''))) throw new Error('invalid repo object checksum');
   ensureDirs();
   const bytes = Buffer.from(String(dataBase64 || ''), 'base64');
   if (sha256(bytes) !== digest) throw new Error('repo object checksum mismatch');
   fs.writeFileSync(path.join(CHUNKS, `${digest}.bin`), bytes, { mode: 0o600 });
-  fs.rmSync(requestFile(digest), { force: true });
+  fs.rmSync(requestFile(resourceId, digest), { force: true });
   wake('update', digest);
-  require('./reconcile').reconcileNow().catch(() => {});
+  require('./reducer').reduceNow().catch(() => {});
   return { stored: true, sha256: digest, bytes: bytes.length };
 }
 
 function validateLocator(locator) {
   if (
     locator?.contract !== CONTRACT
+    || !/^shr_[A-Za-z0-9_-]{16,128}$/.test(String(locator.resourceId || ''))
     || !/^[0-9a-f]{40,64}$/.test(String(locator.oid || ''))
     || !/^[0-9a-f]{64}$/.test(String(locator.checksum || ''))
     || !Array.isArray(locator.chunks)
@@ -307,7 +335,10 @@ async function importFromLocator(worktreeRoot, locator) {
   for (const chunk of locator.chunks) {
     const file = path.join(CHUNKS, `${chunk.sha256}.bin`);
     if (fs.existsSync(file) && fs.statSync(file).size === chunk.bytes) continue;
-    writeJson(requestFile(chunk.sha256), { sha256: chunk.sha256 });
+    writeJson(requestFile(locator.resourceId, chunk.sha256), {
+      resourceId: locator.resourceId,
+      sha256: chunk.sha256,
+    });
     waiting = true;
   }
   if (waiting) {
@@ -339,6 +370,7 @@ module.exports = {
   CONTRACT,
   PAYLOAD_CONTRACT,
   acknowledgeUpload,
+  bundleSourceFor,
   claimDownload,
   claimUpload,
   importFromLocator,