amalgm 0.1.238 → 0.1.240

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

@@ -6,6 +6,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execFile } = require('child_process');
+const { EventEmitter } = require('events');
 const { promisify } = require('util');
 
 const execFileAsync = promisify(execFile);
@@ -23,6 +24,7 @@ const {
   repoCardServiceStats,
   startRepoCardService,
   stopRepoCardService,
+  _private,
 } = require('../workspace/cards');
 
 test.after(() => {
@@ -316,7 +318,7 @@ test('coverage shift and deletion inside a single pass still reads as missing',
   assert.equal(findCard(settled.cards, repo), undefined);
 });
 
-test('the live service hears a commit through the git-dir doorbell', async () => {
+test('the live service hears a commit through the git-dir doorbell', async (t) => {
   const repo = await makeRepo('projects/belled');
   const projects = path.join(tempRoot, 'projects');
   upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
@@ -324,6 +326,13 @@ test('the live service hears a commit through the git-dir doorbell', async () =>
   await refreshRepoCards();
   const before = findCard(listRepoCards(), repo);
   assert.equal(before.health, 'healthy');
+  // fs.watch reports resource exhaustion asynchronously on macOS.
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  if (!_private.watcherComplete(before.replica)) {
+    stopRepoCardService();
+    t.skip('the host refused part or all of the required fs.watch set');
+    return;
+  }
 
   fs.writeFileSync(path.join(repo, 'ding.txt'), 'ding\n');
   await run(repo, 'add', '.');
@@ -341,7 +350,61 @@ test('the live service hears a commit through the git-dir doorbell', async () =>
   assert.ok(repoCardServiceStats().doorbellRings >= 1);
 });
 
-test('the live service hears nested branch creation and deletion', async () => {
+test('a doorbell rebuild releases its old watch set before opening the replacement', async () => {
+  const repo = await makeRepo('projects/bounded-doorbell');
+  const projects = path.join(tempRoot, 'projects');
+  upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
+  stopRepoCardService();
+  await refreshRepoCards();
+
+  const originalWatch = fs.watch;
+  let openHandles = 0;
+  let maximumOpenHandles = 0;
+  let handleLimit = Number.POSITIVE_INFINITY;
+  fs.watch = () => {
+    if (openHandles >= handleLimit) {
+      const error = new Error('simulated watch-handle ceiling');
+      error.code = 'EMFILE';
+      throw error;
+    }
+    openHandles += 1;
+    maximumOpenHandles = Math.max(maximumOpenHandles, openHandles);
+    const watcher = new EventEmitter();
+    let closed = false;
+    watcher.close = () => {
+      if (closed) return;
+      closed = true;
+      openHandles -= 1;
+    };
+    watcher.unref = () => watcher;
+    return watcher;
+  };
+
+  try {
+    startRepoCardService();
+    await refreshRepoCards();
+    const card = findCard(listRepoCards(), repo);
+    const initialHandles = _private.watcherCount(card.replica);
+    const initialTotal = openHandles;
+    assert.ok(initialHandles > 0);
+    assert.equal(_private.watcherComplete(card.replica), true);
+    assert.ok(initialTotal >= initialHandles);
+
+    handleLimit = initialTotal;
+    maximumOpenHandles = openHandles;
+    _private.rebuildDoorbell(card.replica, card);
+
+    assert.equal(_private.watcherComplete(card.replica), true);
+    assert.equal(openHandles, initialTotal);
+    assert.equal(maximumOpenHandles, initialTotal);
+    assert.equal(repoCardServiceStats().incompleteDoorbells, 0);
+  } finally {
+    stopRepoCardService();
+    fs.watch = originalWatch;
+  }
+});
+
+test('the targeted doorbell path hears nested branch creation and deletion', async () => {
   const repo = await makeRepo('projects/belled-refs');
   const projects = path.join(tempRoot, 'projects');
   upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
@@ -351,6 +414,7 @@ test('the live service hears nested branch creation and deletion', async () => {
   const before = findCard(listRepoCards(), repo);
 
   await run(repo, 'branch', branch);
+  _private.ringDoorbell(before.replica);
   let deadline = Date.now() + 5_000;
   let created = findCard(listRepoCards(), repo);
   while (!created.refs.some((ref) => ref.name === branch) && Date.now() < deadline) {
@@ -360,6 +424,7 @@ test('the live service hears nested branch creation and deletion', async () => {
   assert.ok(created.refs.some((ref) => ref.name === branch));
 
   await run(repo, 'branch', '-D', branch);
+  _private.ringDoorbell(before.replica);
   deadline = Date.now() + 5_000;
   let deleted = findCard(listRepoCards(), repo);
   while (deleted.refs.some((ref) => ref.name === branch) && Date.now() < deadline) {
@@ -372,7 +437,7 @@ test('the live service hears nested branch creation and deletion', async () => {
   assert.equal(deleted.generation, before.generation + 2);
 });
 
-test('the live service hears an uncommitted nested edit without a polling pass', async () => {
+test('the targeted doorbell path hears an uncommitted nested edit without a polling pass', async () => {
   const repo = await makeRepo('projects/live-dirty');
   const projects = path.join(tempRoot, 'projects');
   upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
@@ -383,6 +448,8 @@ test('the live service hears an uncommitted nested edit without a polling pass',
   const nested = path.join(repo, 'src', 'nested');
   fs.mkdirSync(nested, { recursive: true });
   fs.writeFileSync(path.join(nested, 'live.txt'), 'live\n');
+  const beforeCard = findCard(listRepoCards(), repo);
+  _private.ringDoorbell(beforeCard.replica);
 
   const deadline = Date.now() + 5_000;
   let card = findCard(listRepoCards(), repo);
@@ -419,6 +486,7 @@ test('editing an already-dirty file rings the checkpoint directly', async () =>
     const card = findCard(listRepoCards(), repo);
     const file = path.join(repo, 'dirty.txt');
     fs.writeFileSync(file, 'first\n');
+    _private.ringDoorbell(card.replica);
 
     let deadline = Date.now() + 5_000;
     while (published.length === 0 && Date.now() < deadline) {
@@ -427,6 +495,7 @@ test('editing an already-dirty file rings the checkpoint directly', async () =>
     published.length = 0;
 
     fs.writeFileSync(file, 'second\n');
+    _private.ringDoorbell(card.replica);
     deadline = Date.now() + 5_000;
     while (published.length === 0 && Date.now() < deadline) {
       await new Promise((resolve) => setTimeout(resolve, 25));

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

@@ -13,6 +13,14 @@ const execFileAsync = promisify(execFile);
 const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-repo-cards-test-'));
 process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
 process.env.AMALGM_COMPUTER_ID = 'computer-test';
+fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
+fs.writeFileSync(
+  path.join(process.env.AMALGM_DIR, 'computer.json'),
+  JSON.stringify({
+    computer_id: 'computer-test',
+    user_id: '11111111-1111-4111-8111-111111111111',
+  }),
+);
 
 const { closeLocalDb, openLocalDb } = require('../state/db');
 const {
@@ -100,7 +108,7 @@ test('a clean repo cards with exact head, clean counts, and full identity', asyn
   await run(dir, 'remote', 'add', 'origin', 'git@github.com:amalgm/clean.git');
 
   const card = await buildRepoCard(dir);
-  assert.equal(card.card, 'repo-card@2');
+  assert.equal(card.card, 'repo-card@3');
   assert.equal(card.machine, 'computer-test');
   assert.match(card.replica, /^rpl_[A-Za-z0-9_-]+$/);
   assert.equal(card.path, await fs.promises.realpath(dir));
@@ -406,12 +414,31 @@ test('unchanged commits reuse their card object source and one new oid is resolv
   await run(dir, 'branch', 'side');
   const local = await buildRepoCard(dir);
   await run(dir, 'remote', 'add', 'origin', 'https://github.com/amalgm/object-source-cache.git');
+  const { resourceId } = require('../workspace/wall').bindProject(
+    '018f0000-0000-7000-8000-00000000cace',
+    '11111111-1111-4111-8111-111111111111',
+    dir,
+  );
+  assert.equal(
+    require('../workspace/wall').projectForPath(dir)?.resourceId,
+    resourceId,
+  );
+  const ready = { kind: 'bundle', resourceId, checksum: 'ready' };
   const previous = {
     ...local,
     repo: { ...local.repo, remote: 'https://github.com/amalgm/object-source-cache' },
-    objects: { kind: 'remote' },
-    refs: local.refs.map((ref) => ({ ...ref, objects: { kind: 'remote' } })),
+    objects: ready,
+    refs: local.refs.map((ref) => ({ ...ref, objects: ready })),
   };
+  const classified = await classifyDirectory(dir);
+  const replica = require('../workspace/identity').replicaForGitDir(
+    await fs.promises.realpath(classified.gitDir),
+  );
+  assert.equal(previous.replica, replica.replicaId);
+  assert.equal(
+    cardTest.reusableObjectSource(local.head.oid, local.head.oid, ready, resourceId),
+    ready,
+  );
   const objects = require('../workspace/objects');
   const original = objects.objectSourceFor;
   let calls = 0;
@@ -422,8 +449,8 @@ test('unchanged commits reuse their card object source and one new oid is resolv
   try {
     const unchanged = await buildRepoCard(dir, previous);
     assert.equal(calls, 0);
-    assert.equal(unchanged.objects.kind, 'remote');
-    assert.ok(unchanged.refs.every((ref) => ref.objects.kind === 'remote'));
+    assert.equal(unchanged.objects.kind, 'bundle');
+    assert.ok(unchanged.refs.every((ref) => ref.objects.kind === 'bundle'));
 
     write(dir, 'next.txt', 'next\n');
     await run(dir, 'add', '.');
@@ -432,7 +459,7 @@ test('unchanged commits reuse their card object source and one new oid is resolv
     assert.equal(calls, 1, 'HEAD and its branch share one content-addressed lookup');
     assert.equal(changed.objects.kind, 'pending');
     assert.equal(changed.refs.find((ref) => ref.name === 'main').objects.kind, 'pending');
-    assert.equal(changed.refs.find((ref) => ref.name === 'side').objects.kind, 'remote');
+    assert.equal(changed.refs.find((ref) => ref.name === 'side').objects.kind, 'bundle');
   } finally {
     objects.objectSourceFor = original;
   }

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

@@ -10,6 +10,8 @@ const { promisify } = require('util');
 
 const execFileAsync = promisify(execFile);
 const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-checkpoint-reducer-'));
+process.env.AMALGM_DIR = path.join(root, '.amalgm');
+process.env.AMALGM_WORKSPACES_DIR = path.join(process.env.AMALGM_DIR, 'workspaces');
 const merge = require('../workspace/merge');
 
 test.after(() => fs.rmSync(root, { recursive: true, force: true }));
@@ -118,3 +120,28 @@ test('an earlier inbound event advances underneath a pending local write', async
   assert.equal(fs.readFileSync(path.join(repo, 'same.txt'), 'utf8'), 'pending local\n');
   assert.equal(await treeText(repo, outcome.heldTree, 'same.txt'), 'inbound\n');
 });
+
+test('an inbound file write cannot overwrite a local write that races its observation', async () => {
+  const { repo, oid, tree: clean } = await makeRepo('pending-local-race');
+  const inboundPatch = await patchFor(repo, { 'same.txt': 'inbound\n' });
+  const inbound = await merge.treeOfPatch(repo, oid, inboundPatch);
+  const transition = require('../workspace/transition');
+  const applyFiles = transition.applyFiles;
+  transition.applyFiles = async (...args) => {
+    fs.writeFileSync(path.join(repo, 'same.txt'), 'local writer won the race\n');
+    return applyFiles(...args);
+  };
+  try {
+    await assert.rejects(
+      merge.advance(repo, clean, inbound),
+      /local file changed before ordered apply/,
+    );
+  } finally {
+    transition.applyFiles = applyFiles;
+  }
+
+  assert.equal(
+    fs.readFileSync(path.join(repo, 'same.txt'), 'utf8'),
+    'local writer won the race\n',
+  );
+});