amalgm 0.1.206 → 0.1.208

package/lib/shared-realtime-tunnel.js

@@ -17,6 +17,7 @@ const CLAIM_LIMIT = 16;
 const CLAIM_LEASE_MS = 30_000;
 const RETRY_MS = 1_000;
 const REAUTHORIZE_MS = 30_000;
+const REPO_OBJECT_REQUEST_TIMEOUT_MS = 2_000;
 
 function createSharedRealtimeTunnel({
   send,
@@ -24,6 +25,7 @@ function createSharedRealtimeTunnel({
   localPort,
   localHeaders,
   warn,
+  repoObjectRequestTimeoutMs = REPO_OBJECT_REQUEST_TIMEOUT_MS,
 }) {
   const mutationInflight = new Map();
   const promotionInflight = new Map();
@@ -277,8 +279,17 @@ function createSharedRealtimeTunnel({
     repoObjectTimer.unref?.();
   }
 
+  function expireRepoObjectRequests(now = Date.now()) {
+    for (const inflight of [repoUploadInflight, repoDownloadInflight]) {
+      for (const [requestId, object] of inflight) {
+        if (now - object.sentAt >= repoObjectRequestTimeoutMs) inflight.delete(requestId);
+      }
+    }
+  }
+
   async function drainRepoObjects() {
     if (!enabled) return;
+    expireRepoObjectRequests();
     if (repoUploadInflight.size === 0) {
       const result = await localStateJson('POST', '/state/repo-objects/uploads/claim', {});
       const upload = result?.upload;
@@ -295,6 +306,7 @@ function createSharedRealtimeTunnel({
           repoUploadInflight.set(requestId, {
             resourceId: upload.resourceId,
             sha256: upload.sha256,
+            sentAt: Date.now(),
           });
         }
       }
@@ -313,6 +325,7 @@ function createSharedRealtimeTunnel({
           repoDownloadInflight.set(requestId, {
             resourceId: download.resourceId,
             sha256: download.sha256,
+            sentAt: Date.now(),
           });
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.206",
+  "version": "0.1.208",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/state/docs.js

@@ -120,9 +120,11 @@ function hashText(text) {
 function isInternalStateDoc(filePath) {
   const resolved = path.resolve(filePath);
   const parent = path.dirname(resolved);
+  const collection = path.basename(parent);
+  const isStateCollection = path.basename(path.dirname(parent)) === 'state';
   return (
-    path.basename(parent) === 'repo-checkpoints'
-    && path.basename(path.dirname(parent)) === 'state'
+    isStateCollection
+    && (collection === 'repo-checkpoints' || collection === 'code-projects')
   ) || /^machine-cards-v\d+\.jsonl$/.test(path.basename(resolved));
 }
 
@@ -221,7 +223,7 @@ function resolveDocPath(pathInput) {
   }
   const stats = fs.statSync(resolved);
   if (!stats.isFile()) throw invalid('path is not a file');
-  if (stats.size > MAX_DOC_BYTES) {
+  if (stats.size > MAX_DOC_BYTES && !isInternalStateDoc(resolved)) {
     throw invalid(`file exceeds the ${MAX_DOC_BYTES}-byte live document limit`, 413);
   }
   return resolved;

package/runtime/scripts/amalgm-mcp/tests/state-docs.test.js

@@ -135,19 +135,29 @@ test('external disk edits reconcile into the live doc via the watcher', async ()
 });
 
 test('internal protocol documents never treat their own disk flush as another writer', async () => {
-  const stateDir = path.join(process.env.AMALGM_DIR, 'state', 'repo-checkpoints');
-  fs.mkdirSync(stateDir, { recursive: true });
-  const target = path.join(stateDir, 'protocol.json');
+  const checkpointDir = path.join(process.env.AMALGM_DIR, 'state', 'repo-checkpoints');
+  const projectDir = path.join(process.env.AMALGM_DIR, 'state', 'code-projects');
+  fs.mkdirSync(checkpointDir, { recursive: true });
+  fs.mkdirSync(projectDir, { recursive: true });
+  const target = path.join(checkpointDir, 'protocol.json');
+  const project = path.join(projectDir, 'project.jsonl');
   fs.writeFileSync(target, '{"value":1}\n', 'utf8');
+  fs.writeFileSync(project, '{"value":1}\n', 'utf8');
   const opened = docs.openDoc(target);
+  const openedProject = docs.openDoc(project);
   const before = currentSeq();
 
   assert.equal(docs._private.isInternalStateDoc(target), true);
+  assert.equal(docs._private.isInternalStateDoc(project), true);
   fs.writeFileSync(target, '{"value":2}\n', 'utf8');
+  fs.writeFileSync(project, '{"value":2}\n', 'utf8');
   await sleep(700);
 
   assert.equal(docs.getDocText(target), '{"value":1}\n');
-  const events = listEventsAfter(before).filter((event) => event.resource === opened.resource);
+  assert.equal(docs.getDocText(project), '{"value":1}\n');
+  const events = listEventsAfter(before).filter((event) => (
+    event.resource === opened.resource || event.resource === openedProject.resource
+  ));
   assert.equal(events.length, 0);
 });
 
@@ -203,6 +213,11 @@ test('guards: binary, missing, oversized, and malformed inputs are rejected', ()
 
   const big = writeDoc('big.md', 'x'.repeat(2 * 1024 * 1024 + 1));
   assert.throws(() => docs.openDoc(big), /live document limit/);
+  const projectDir = path.join(process.env.AMALGM_DIR, 'state', 'code-projects');
+  fs.mkdirSync(projectDir, { recursive: true });
+  const largeProtocol = path.join(projectDir, 'large-project.jsonl');
+  fs.writeFileSync(largeProtocol, 'x'.repeat(2 * 1024 * 1024 + 1));
+  assert.doesNotThrow(() => docs.openDoc(largeProtocol));
 
   const target = writeDoc('guarded.md', 'ok\n');
   assert.throws(() => docs.applyDocUpdates(target, [123]), /base64-encoded/);

package/runtime/scripts/amalgm-mcp/tests/workspace-object-tunnel.test.js

@@ -122,3 +122,59 @@ test('repo object chunks travel through the shared tunnel one at a time', async
     server.close();
   }
 });
+
+test('repo object chunks retry when an acknowledgement is lost', async () => {
+  const uploadBytes = Buffer.from('retry this content-addressed chunk');
+  const uploadSha = crypto.createHash('sha256').update(uploadBytes).digest('hex');
+  const resourceId = 'shr_cp1abcdefghijklmnopqrstuvwx';
+  const server = http.createServer((req, res) => {
+    req.resume();
+    req.on('end', () => {
+      res.setHeader('content-type', 'application/json');
+      if (req.url === '/state/shared/replicas') {
+        res.end('{"replicas":[]}');
+      } else if (req.url.startsWith('/state/stream')) {
+        res.writeHead(200, { 'content-type': 'text/event-stream' });
+        res.write('\n');
+      } else if (req.url === '/state/repo-objects/uploads/claim') {
+        res.end(JSON.stringify({
+          upload: {
+            resourceId,
+            sha256: uploadSha,
+            bytes: uploadBytes.length,
+            dataBase64: uploadBytes.toString('base64'),
+          },
+        }));
+      } else if (req.url === '/state/repo-objects/downloads/claim') {
+        res.end('{"download":null}');
+      } else {
+        res.end('{}');
+      }
+    });
+  });
+  await new Promise((resolve) => { server.listen(0, '127.0.0.1', resolve); });
+
+  const frames = [];
+  const tunnel = createSharedRealtimeTunnel({
+    send: (frame) => { frames.push(frame); return true; },
+    sendLarge: (frame) => { frames.push(frame); return true; },
+    localPort: () => server.address().port,
+    localHeaders: (headers) => headers,
+    warn: () => {},
+    repoObjectRequestTimeoutMs: 25,
+  });
+
+  try {
+    tunnel.enable(['shared.mutation.v1']);
+    await until(
+      () => frames.filter((frame) => frame.type === 'repo.object.put').length >= 2,
+      'the unacknowledged upload retry',
+    );
+    const puts = frames.filter((frame) => frame.type === 'repo.object.put');
+    assert.notEqual(puts[0].request_id, puts[1].request_id);
+    assert.equal(puts[0].sha256, puts[1].sha256);
+  } finally {
+    tunnel.stop();
+    server.close();
+  }
+});

package/runtime/scripts/amalgm-mcp/tests/workspace-wall.test.js

@@ -120,6 +120,39 @@ test('only a value different from both the materialized baseline and the rail is
     branches: [{ name: 'main', oid: oidC }],
   };
   assert.equal(hasLocalContribution(local, remoteAdvance, baseline), false);
+  assert.equal(hasLocalContribution(
+    {
+      head: { branch: 'main', oid: oidB, detached: false },
+      refs: [{ name: 'main', oid: oidB }],
+    },
+    remoteAdvance,
+    {
+      branch: 'main',
+      baseOid: oidB,
+      branches: [{ name: 'main', oid: oidB }],
+    },
+    null,
+    {
+      head: { branch: 'main', oid: oidA, detached: false },
+      branches: [{ name: 'main', oid: oidA }],
+    },
+  ), false);
+  assert.equal(hasLocalContribution(
+    local,
+    plan,
+    {
+      ...baseline,
+      branches: [...baseline.branches, { name: 'feature', oid: null }],
+    },
+    null,
+    {
+      head: { branch: 'main', oid: oidA, detached: false },
+      branches: [
+        { name: 'main', oid: oidA },
+        { name: 'feature', oid: oidB },
+      ],
+    },
+  ), true);
   assert.equal(hasLocalContribution(local, plan, baseline, {
     checkpoint: 'repo-checkpoint@7',
     machine: 'machine-a',
@@ -478,6 +511,30 @@ test('an unordered legacy record cannot pin wall compaction', () => {
   );
 });
 
+test('retired machine values stay represented without pinning obsolete active history', () => {
+  const line = (machine, value) => JSON.stringify({
+    wall: 'code-project@3',
+    project: repoKey,
+    machine,
+    mutationId: `mut_project_${machine}_${value}`,
+    cards: [{ value }],
+  });
+  const retiredA = line('retired-a', 'latest-retired-a');
+  const retiredB = line('retired-b', 'latest-retired-b');
+  const oldA = line('machine-a', 'old-a');
+  const oldB = line('machine-b', 'old-b');
+  const latestA = line('machine-a', 'latest-a');
+  const latestB = line('machine-b', 'latest-b');
+
+  assert.equal(
+    compactWallText(
+      `${retiredA}\n${retiredB}\n${oldA}\n${oldB}\n${latestA}\n${latestB}\n`,
+      repoKey,
+    ),
+    `${retiredA}\n${retiredB}\n${latestA}\n${latestB}\n`,
+  );
+});
+
 test('a concurrent deletion-only compaction and append commute in Yjs', () => {
   const Y = require('yjs');
   const line = (machine, value) => JSON.stringify({

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

@@ -245,11 +245,13 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null, previousC
     const current = currentRefs.get(name) ?? null;
     const shared = railRefs.get(name) ?? null;
     const previous = baselineRefs.get(name) ?? null;
-    const changedFromPublished = previousRefs.has(name)
-      && current !== (previousRefs.get(name) ?? null);
+    const published = previousRefs.get(name) ?? null;
+    const reversesPublishedSharedValue = previousRefs.has(name)
+      && published === shared
+      && current !== published;
     if (
       current !== shared
-      && (!baselineRefs.has(name) || current !== previous || changedFromPublished)
+      && (!baselineRefs.has(name) || current !== previous || reversesPublishedSharedValue)
     ) return true;
   }
 
@@ -456,12 +458,10 @@ function withoutPublishedAt(line) {
 }
 
 /**
- * Keep the newest complete record for every machine, plus anything after
- * the earliest of those records. Everything before that point is obsolete:
- * every machine represented there has a newer complete value later.
- *
- * Compaction is deletion-only. Concurrent deletions and appends commute in
- * Yjs, so this bounds the wall without bringing back whole-document races.
+ * Keep every machine's newest complete record and delete the largest span
+ * containing none of them. Repeating this as the wall grows removes all
+ * obsolete history, even when a retired machine's last record is near the
+ * beginning. Each pass is one deletion, so concurrent appends commute in Yjs.
  */
 function compactWallText(current, repoKey) {
   const latest = new Map();
@@ -470,12 +470,21 @@ function compactWallText(current, repoKey) {
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index];
     const entry = line ? parseWallLine(line) : null;
-    if (entry?.project === repoKey) latest.set(entry.machine, offset);
-    offset += line.length + (index < lines.length - 1 ? 1 : 0);
+    const end = offset + line.length + (index < lines.length - 1 ? 1 : 0);
+    if (entry?.project === repoKey) latest.set(entry.machine, { start: offset, end });
+    offset = end;
   }
   if (latest.size === 0) return current;
-  const cutoff = Math.min(...latest.values());
-  return cutoff > 0 ? current.slice(cutoff) : current;
+  const records = [...latest.values()].sort((left, right) => left.start - right.start);
+  const gaps = [{ start: 0, end: records[0].start }];
+  for (let index = 0; index < records.length - 1; index += 1) {
+    gaps.push({ start: records[index].end, end: records[index + 1].start });
+  }
+  const gap = gaps.reduce((largest, candidate) => (
+    candidate.end - candidate.start > largest.end - largest.start ? candidate : largest
+  ));
+  if (gap.end <= gap.start) return current;
+  return `${current.slice(0, gap.start)}${current.slice(gap.end)}`;
 }
 
 function publishProject(project, rawCards) {