amalgm 0.1.158 → 0.1.159

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

@@ -0,0 +1,86 @@
+'use strict';
+
+// One owner per file (workspace-sync.md §1): a git-tracked file syncs
+// through git, and the doc rail must refuse to promote it. Untracked
+// files inside a repo and files outside any repo have no git owner and
+// promote as before.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-promotion-ownership-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+process.env.AMALGM_WORKSPACES_DIR = path.join(process.env.AMALGM_DIR, 'workspaces');
+process.env.AMALGM_COMPUTER_ID = 'machine-test';
+process.env.AMALGM_DEVICE_ID = 'device-machine-test';
+
+fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
+fs.writeFileSync(
+  path.join(process.env.AMALGM_DIR, 'computer.json'),
+  JSON.stringify({ computer_id: 'machine-test', user_id: '11111111-1111-4111-8111-111111111111' }),
+);
+
+const { closeLocalDb } = require('../state/db');
+const { handlePromotionStart } = require('../state/shared-rest');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+async function run(cwd, ...args) {
+  await execFileAsync(
+    'git',
+    ['-c', 'user.email=test@amalgm.test', '-c', 'user.name=Amalgm Test', '-c', 'commit.gpgsign=false', ...args],
+    { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' } },
+  );
+}
+
+/** Run the handler, capture what it would send over the wire. */
+async function promote(filePath) {
+  let sent;
+  await handlePromotionStart({ path: filePath }, (statusCode, payload) => {
+    sent = { statusCode, payload };
+  });
+  return sent;
+}
+
+test('a git-tracked file is refused: git owns it', async () => {
+  const repo = path.join(tempRoot, 'repo');
+  fs.mkdirSync(repo, { recursive: true });
+  await run(repo, 'init', '-b', 'main');
+  const tracked = path.join(repo, 'README.md');
+  fs.writeFileSync(tracked, '# tracked\n');
+  await run(repo, 'add', '.');
+  await run(repo, 'commit', '-m', 'initial');
+
+  const { statusCode, payload } = await promote(tracked);
+  assert.equal(statusCode, 409);
+  assert.equal(payload.code, 'file_git_owned');
+  assert.match(payload.error, /tracked by the repository at /);
+  assert.ok(payload.error.includes(fs.realpathSync(repo)), 'the error names the owning repo');
+});
+
+test('an untracked file inside a repo has no git owner and promotes', async () => {
+  const repo = path.join(tempRoot, 'repo');
+  const untracked = path.join(repo, 'scratch-notes.md');
+  fs.writeFileSync(untracked, '# scratch\n');
+
+  const { statusCode, payload } = await promote(untracked);
+  assert.equal(statusCode, 202, JSON.stringify(payload));
+});
+
+test('a file outside any repository promotes', async () => {
+  const loose = path.join(tempRoot, 'loose.md');
+  fs.writeFileSync(loose, '# loose\n');
+
+  const { statusCode, payload } = await promote(loose);
+  assert.equal(statusCode, 202, JSON.stringify(payload));
+});

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

@@ -0,0 +1,326 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-cards-store-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+process.env.AMALGM_WORKSPACES_DIR = path.join(process.env.AMALGM_DIR, 'workspaces');
+process.env.AMALGM_COMPUTER_ID = 'computer-test';
+
+const { closeLocalDb, openLocalDb } = require('../state/db');
+const { upsertWorkspace, removeWorkspace } = require('../workspace/store');
+const {
+  listRepoCards,
+  refreshRepoCards,
+  repoCardServiceStats,
+  startRepoCardService,
+  stopRepoCardService,
+} = require('../workspace/cards');
+
+test.after(() => {
+  stopRepoCardService();
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+async function run(cwd, ...args) {
+  await execFileAsync(
+    'git',
+    ['-c', 'user.email=test@amalgm.test', '-c', 'user.name=Amalgm Test', '-c', 'commit.gpgsign=false', ...args],
+    { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' } },
+  );
+}
+
+async function makeRepo(name) {
+  const dir = path.join(tempRoot, name);
+  fs.mkdirSync(dir, { recursive: true });
+  await run(dir, 'init', '-b', 'main');
+  fs.writeFileSync(path.join(dir, 'README.md'), `# ${name}\n`);
+  await run(dir, 'add', '.');
+  await run(dir, 'commit', '-m', 'initial');
+  return dir;
+}
+
+function cardEvents() {
+  return openLocalDb()
+    .prepare(`SELECT * FROM event_log WHERE resource = 'repo-cards' ORDER BY seq`)
+    .all();
+}
+
+function findCard(cards, dir) {
+  const suffix = path.sep + path.basename(dir);
+  return cards.find((card) => card.path.endsWith(suffix));
+}
+
+test('refresh cards the tracked world once, and a no-change refresh writes nothing', async () => {
+  const projects = path.join(tempRoot, 'projects');
+  fs.mkdirSync(projects, { recursive: true });
+  const repo = await makeRepo('projects/app');
+  upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
+
+  const first = await refreshRepoCards();
+  assert.equal(first.stats.changed, 1);
+  assert.equal(first.rootErrors.length, 0);
+  assert.equal(first.cards.length, 1);
+  assert.equal(first.cards[0].path, await fs.promises.realpath(repo));
+  assert.equal(first.cards[0].health, 'healthy');
+  assert.equal(first.cards[0].machine, 'computer-test');
+  assert.equal(first.cards[0].generation, 1);
+  const eventsAfterFirst = cardEvents();
+  assert.equal(eventsAfterFirst.length, 1);
+  assert.match(eventsAfterFirst[0].id, /^rpl_/);
+
+  const second = await refreshRepoCards();
+  assert.equal(second.stats.changed, 0);
+  assert.equal(second.cards[0].generation, 1);
+  assert.equal(second.cards[0].updatedAt, first.cards[0].updatedAt);
+  assert.equal(cardEvents().length, eventsAfterFirst.length);
+});
+
+test('a 4,000-file branch switch is exactly one generation bump and one event', async () => {
+  const repo = path.join(tempRoot, 'projects/big');
+  fs.mkdirSync(repo, { recursive: true });
+  await run(repo, 'init', '-b', 'main');
+  fs.writeFileSync(path.join(repo, 'README.md'), '# big\n');
+  await run(repo, 'add', '.');
+  await run(repo, 'commit', '-m', 'initial');
+  await run(repo, 'checkout', '-b', 'heavy');
+  for (let i = 0; i < 4000; i++) {
+    const dir = path.join(repo, 'gen', String(i % 40));
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `file-${i}.txt`), `${i}\n`);
+  }
+  await run(repo, 'add', '.');
+  await run(repo, 'commit', '-m', 'four thousand files');
+
+  const before = await refreshRepoCards();
+  const bigBefore = findCard(before.cards, repo);
+  const eventsBefore = cardEvents().length;
+
+  await run(repo, 'checkout', 'main');
+  const after = await refreshRepoCards();
+  const bigAfter = findCard(after.cards, repo);
+
+  assert.equal(bigAfter.replica, bigBefore.replica);
+  assert.equal(bigAfter.generation, bigBefore.generation + 1);
+  assert.equal(after.stats.changed, 1);
+  assert.equal(cardEvents().length, eventsBefore + 1);
+  assert.equal(bigAfter.head.branch, 'main');
+  assert.ok(JSON.stringify(bigAfter).length < 2048, 'a card stays small no matter the checkout size');
+});
+
+test('two workspaces reaching the same repo still mean one card', async () => {
+  const repo = path.join(tempRoot, 'projects/app');
+  upsertWorkspace({ path: repo, name: 'App direct', source: 'computer' });
+
+  const { cards } = await refreshRepoCards();
+  assert.equal(cards.filter((card) => card.path === fs.realpathSync(repo)).length, 1);
+  removeWorkspace(repo);
+  await refreshRepoCards();
+});
+
+test('a vanished repo goes missing — the card survives to say so, and returns healthy', async () => {
+  const repo = await makeRepo('projects/vanishing');
+  const parked = path.join(tempRoot, 'parked-vanishing');
+  const { cards } = await refreshRepoCards();
+  const card = findCard(cards, repo);
+  assert.equal(card.health, 'healthy');
+
+  fs.renameSync(repo, parked);
+  const gone = await refreshRepoCards();
+  const missing = findCard(gone.cards, repo);
+  assert.equal(missing.health, 'missing');
+  assert.equal(missing.replica, card.replica);
+  assert.equal(missing.generation, card.generation + 1);
+  assert.equal(missing.head.branch, 'main', 'the last good observation rides with the health');
+  assert.equal(gone.stats.healthChanged, 1);
+  assert.equal(gone.stats.removed, 0);
+
+  fs.renameSync(parked, repo);
+  const back = await refreshRepoCards();
+  const healthy = findCard(back.cards, repo);
+  assert.equal(healthy.health, 'healthy');
+  assert.equal(healthy.replica, card.replica, 'the same checkout at the same git dir is the same replica');
+});
+
+test('a de-gitted repo goes broken and heals when its .git returns', async () => {
+  const repo = await makeRepo('projects/degit');
+  await refreshRepoCards();
+
+  const gitDir = path.join(repo, '.git');
+  const parked = path.join(tempRoot, 'parked-degit');
+  fs.renameSync(gitDir, parked);
+  const brokenPass = await refreshRepoCards();
+  const broken = findCard(brokenPass.cards, repo);
+  assert.equal(broken.health, 'broken');
+
+  fs.renameSync(parked, gitDir);
+  const healed = await refreshRepoCards();
+  assert.equal(findCard(healed.cards, repo).health, 'healthy');
+});
+
+test('untracking is the only human act that removes cards', async () => {
+  const repo = await makeRepo('solo-tracked');
+  upsertWorkspace({ path: repo, name: 'Solo', source: 'computer' });
+  const { cards } = await refreshRepoCards();
+  const card = findCard(cards, repo);
+  assert.equal(card.health, 'healthy');
+
+  removeWorkspace(repo);
+  const eventsBefore = cardEvents().length;
+  const after = await refreshRepoCards();
+  assert.equal(findCard(after.cards, repo), undefined);
+  assert.equal(after.stats.removed, 1);
+  const deleteEvent = cardEvents().at(-1);
+  assert.equal(deleteEvent.op, 'delete');
+  assert.equal(deleteEvent.id, card.replica);
+  assert.equal(cardEvents().length, eventsBefore + 1);
+});
+
+test('git settling a worktree removal removes its card — the primary stays', async () => {
+  const repo = await makeRepo('projects/wt-owner');
+  const worktreePath = path.join(tempRoot, 'outside-wt');
+  await run(repo, 'worktree', 'add', worktreePath, '-b', 'ride-along');
+
+  const { cards } = await refreshRepoCards();
+  const linked = cards.find((card) => card.path === fs.realpathSync(worktreePath));
+  assert.equal(linked.kind, 'linked-worktree');
+
+  await run(repo, 'worktree', 'remove', worktreePath);
+  const after = await refreshRepoCards();
+  assert.equal(after.cards.some((card) => card.replica === linked.replica), false);
+  assert.equal(after.stats.removed, 1);
+  assert.equal(findCard(after.cards, repo).health, 'healthy');
+});
+
+test('one unreadable root cannot blind the map or settle deletions', async () => {
+  const rootA = path.join(tempRoot, 'root-a');
+  const rootB = path.join(tempRoot, 'root-b');
+  fs.mkdirSync(rootA, { recursive: true });
+  fs.mkdirSync(rootB, { recursive: true });
+  const repoA = await makeRepo('root-a/alpha');
+  const repoB = await makeRepo('root-b/beta');
+  upsertWorkspace({ path: rootA, name: 'Root A', source: 'computer' });
+  upsertWorkspace({ path: rootB, name: 'Root B', source: 'computer' });
+  const seeded = await refreshRepoCards();
+  assert.ok(findCard(seeded.cards, repoA));
+  assert.ok(findCard(seeded.cards, repoB));
+
+  fs.rmSync(rootA, { recursive: true, force: true });
+  const blinded = await refreshRepoCards();
+  assert.equal(blinded.rootErrors.length, 1);
+  assert.equal(blinded.stats.removed, 0, 'a blind pass never settles an untrack');
+  assert.equal(findCard(blinded.cards, repoA).health, 'missing');
+  assert.equal(findCard(blinded.cards, repoB).health, 'healthy');
+
+  removeWorkspace(rootA);
+  removeWorkspace(rootB);
+  const cleaned = await refreshRepoCards();
+  assert.equal(findCard(cleaned.cards, repoA), undefined, 'untracking settles even a missing card');
+  assert.equal(findCard(cleaned.cards, repoB), undefined);
+});
+
+test('concurrent refresh calls coalesce: one pass runs, one follow-up settles everyone', async () => {
+  const before = repoCardServiceStats().refreshes;
+  const results = await Promise.all([
+    refreshRepoCards(),
+    refreshRepoCards(),
+    refreshRepoCards(),
+    refreshRepoCards(),
+    refreshRepoCards(),
+  ]);
+  const after = repoCardServiceStats().refreshes;
+  assert.ok(after - before <= 2, `five concurrent calls ran ${after - before} passes`);
+  for (const result of results) assert.ok(Array.isArray(result.cards));
+});
+
+test('losing one of two coverings never turns a vanished repo into an erasure', async () => {
+  // A repo registered directly AND through its parent folder stays covered
+  // when the direct registration goes away. Deleting the repo after that
+  // must read as `missing` — the surviving covering still tracks it.
+  const garage = path.join(tempRoot, 'garage');
+  fs.mkdirSync(garage, { recursive: true });
+  const repo = await makeRepo('garage/coupe');
+  upsertWorkspace({ path: repo, name: 'Coupe direct', source: 'computer' });
+  upsertWorkspace({ path: garage, name: 'Garage', source: 'computer' });
+  const seeded = await refreshRepoCards();
+  const card = findCard(seeded.cards, repo);
+  assert.equal(card.health, 'healthy');
+
+  removeWorkspace(repo);
+  await refreshRepoCards();
+  const recordedRoot = openLocalDb()
+    .prepare('SELECT root FROM repo_cards WHERE replica_id = ?')
+    .get(card.replica).root;
+  assert.equal(recordedRoot, garage, 'coverage bookkeeping follows the surviving registration');
+
+  fs.rmSync(repo, { recursive: true, force: true });
+  const gone = await refreshRepoCards();
+  assert.equal(gone.rootErrors.length, 0);
+  assert.equal(gone.stats.removed, 0, 'a covered repo must never be deleted for vanishing');
+  assert.equal(findCard(gone.cards, repo).health, 'missing');
+
+  removeWorkspace(garage);
+  const settled = await refreshRepoCards();
+  assert.equal(findCard(settled.cards, repo), undefined, 'untracking still settles the card');
+});
+
+test('coverage shift and deletion inside a single pass still reads as missing', async () => {
+  // Same story, but the registration change and the deletion both land
+  // between two refreshes — no intermediate pass ever repaired the
+  // bookkeeping. The absence decision must judge coverage against the
+  // registrations of today, not against what was recorded at write time.
+  const depot = path.join(tempRoot, 'depot');
+  fs.mkdirSync(depot, { recursive: true });
+  const repo = await makeRepo('depot/wagon');
+  // Named to sort ahead of 'Depot' (roots scan in name order), so the
+  // direct registration is the one recorded as the card's covering root.
+  upsertWorkspace({ path: repo, name: 'A wagon, directly', source: 'computer' });
+  upsertWorkspace({ path: depot, name: 'Depot', source: 'computer' });
+  const seeded = await refreshRepoCards();
+  assert.equal(findCard(seeded.cards, repo).health, 'healthy');
+
+  removeWorkspace(repo);
+  fs.rmSync(repo, { recursive: true, force: true });
+  const gone = await refreshRepoCards();
+  assert.equal(gone.rootErrors.length, 0);
+  assert.equal(gone.stats.removed, 0);
+  assert.equal(findCard(gone.cards, repo).health, 'missing');
+
+  removeWorkspace(depot);
+  const settled = await refreshRepoCards();
+  assert.equal(findCard(settled.cards, repo), undefined);
+});
+
+test('the live service hears a commit through the git-dir doorbell', async () => {
+  const repo = await makeRepo('projects/belled');
+  const projects = path.join(tempRoot, 'projects');
+  upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
+  startRepoCardService();
+  await refreshRepoCards();
+  const before = findCard(listRepoCards(), repo);
+  assert.equal(before.health, 'healthy');
+
+  fs.writeFileSync(path.join(repo, 'ding.txt'), 'ding\n');
+  await run(repo, 'add', '.');
+  await run(repo, 'commit', '-m', 'ring the bell');
+
+  const deadline = Date.now() + 5_000;
+  let after = findCard(listRepoCards(), repo);
+  while (after.head.oid === before.head.oid && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    after = findCard(listRepoCards(), repo);
+  }
+  stopRepoCardService();
+
+  assert.notEqual(after.head.oid, before.head.oid, 'the commit must surface without anyone calling refresh');
+  assert.ok(repoCardServiceStats().doorbellRings >= 1);
+});