amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/tests/project-context.test.js

@@ -394,42 +394,27 @@ test('workspace removal drops the project_context row', () => {
   assert.equal(store.getProjectContext(workspace.path, { reconcile: false }), null);
 });
 
-test('the bounded watcher schedule reconciles a dropped notification and retries the watcher', async () => {
+test('watcher reconciles direct disk edits', async () => {
   const { projectPath, workspace } = makeProject('watch');
-  const originalWatch = fs.watch;
-  let watchAttempts = 0;
-  fs.watch = (...args) => {
-    watchAttempts += 1;
-    if (watchAttempts === 1) {
-      const error = new Error('simulated dropped watcher');
-      error.code = 'EMFILE';
-      throw error;
-    }
-    return originalWatch.apply(fs, args);
-  };
-
-  try {
-    store.ensureProjectContext(workspace);
-    const before = store.getProjectContext(projectPath, { reconcile: false }).contextRevision;
+  store.ensureProjectContext(workspace);
+  const before = store.getProjectContext(projectPath, { reconcile: false }).contextRevision;
 
-    fs.writeFileSync(
-      path.join(projectPath, '.amalgm/context/project-state.md'),
-      '# Project State\n\nWatched edit.\n',
-    );
+  fs.writeFileSync(
+    path.join(projectPath, '.amalgm/context/project-state.md'),
+    '# Project State\n\nWatched edit.\n',
+  );
 
-    const deadline = Date.now() + 7_000;
-    let row = store.getProjectContext(projectPath, { reconcile: false });
-    while (row?.contextRevision === before && Date.now() < deadline) {
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      row = store.getProjectContext(projectPath, { reconcile: false });
-    }
-    assert.ok(row, 'row exists');
-    assert.notEqual(row.contextRevision, before, 'scheduled verification updated the row');
-    assert.ok(row.prompt.projectState.includes('Watched edit.'));
-    assert.ok(watchAttempts >= 2, 'the scheduled pass retried the failed watcher');
-  } finally {
-    fs.watch = originalWatch;
+  // fs.watch + 200ms debounce; poll the row instead of guessing exact timing.
+  const deadline = Date.now() + 3000;
+  let row = null;
+  while (Date.now() < deadline) {
+    row = store.getProjectContext(projectPath, { reconcile: false });
+    if (row && row.contextRevision !== before) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
   }
+  assert.ok(row, 'row exists');
+  assert.notEqual(row.contextRevision, before, 'watcher updated the row');
+  assert.ok(row.prompt.projectState.includes('Watched edit.'));
 });
 
 // ---------------------------------------------------------------------------

package/runtime/scripts/amalgm-mcp/tests/registration.service.test.js

@@ -0,0 +1,256 @@
+'use strict';
+
+/**
+ * The production-owned vertical slice:
+ *
+ *   amalgm add [path] → POST /entities/add → registration.add(path)
+ *                     → Watch + Detect + Record
+ *
+ * The wall already proves detection. What is unproven here is the
+ * WIRING — the parts that only exist because production owns the stack:
+ * which policies are actually injected, where state lands, that the
+ * observer's events genuinely reach the boundary, that identity
+ * survives a process restart over the same directory, and that the
+ * endpoint reports refusal as refusal.
+ *
+ * Everything runs over a temporary AMALGM_DIR, set before config loads,
+ * so the singleton this route uses can never touch a real installation.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const test = require('node:test');
+const assert = require('node:assert');
+
+const tempRoot = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-add-')));
+process.env.AMALGM_DIR = path.join(tempRoot, 'home');
+
+const { classifyFile } = require('../registration/classify');
+const { ENTITIES_DIR, createRegistrationService, registrationService } = require('../registration/service');
+const { handleEntityRoutes } = require('../server/routes/entities');
+const { createLocalServiceRouter } = require('../server/local-service-router');
+
+const services = [];
+
+test.after(() => {
+  for (const service of services) service.stop();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+function makeService(name) {
+  const service = createRegistrationService({ dir: path.join(tempRoot, `state-${name}`) });
+  services.push(service);
+  return service;
+}
+
+/** A directory of real ground, outside the Amalgm home. */
+function makeGround(name) {
+  const dir = path.join(tempRoot, `ground-${name}`);
+  fs.mkdirSync(dir, { recursive: true });
+  return fs.realpathSync(dir);
+}
+
+// --- the injected type policy ---------------------------------------------
+
+test('classify: ordinary bytes are text', () => {
+  const file = path.join(makeGround('classify-text'), 'notes.md');
+  fs.writeFileSync(file, '# hello\nplain words\n');
+  assert.equal(classifyFile(file), 'file.text');
+});
+
+test('classify: a NUL in the opening bytes means bytes, never text', () => {
+  const file = path.join(makeGround('classify-binary'), 'blob.bin');
+  fs.writeFileSync(file, Buffer.from([0x89, 0x50, 0x00, 0x4e, 0x47]));
+  assert.equal(classifyFile(file), 'file.binary');
+});
+
+test('classify: ground that cannot be read supports no structural claim', () => {
+  // The weaker of the two answers, never a throw: the caller is
+  // mid-transaction over a hash it already holds.
+  assert.equal(classifyFile(path.join(tempRoot, 'never-existed')), 'file.binary');
+});
+
+test('classify: a NUL past the sniff window does not retroactively unmake text', () => {
+  // The law is about the OPENING bytes, stated exactly so a huge text
+  // file is never re-read whole to answer a hint.
+  const file = path.join(makeGround('classify-late'), 'long.txt');
+  fs.writeFileSync(file, Buffer.concat([Buffer.alloc(9000, 0x61), Buffer.from([0])]));
+  assert.equal(classifyFile(file), 'file.text');
+});
+
+// --- composition: what production actually builds --------------------------
+
+test('the service composes one observer and one boundary over one directory', () => {
+  const service = makeService('compose');
+  assert.ok(fs.existsSync(path.join(service.dir, 'observer.db')), 'evidence database');
+  assert.ok(fs.existsSync(path.join(service.dir, 'identity.db')), 'identity database');
+  assert.ok(fs.existsSync(path.join(service.dir, 'identity.epoch')), 'the identity sentinel');
+});
+
+test('the singleton lives under the Amalgm home, and is one', () => {
+  assert.equal(ENTITIES_DIR, path.join(process.env.AMALGM_DIR, 'entities'));
+  assert.equal(registrationService(), registrationService(), 'built once, returned forever');
+  services.push(registrationService());
+});
+
+test('add registers the named ground and every file beneath it', () => {
+  const service = makeService('add');
+  const ground = makeGround('add');
+  fs.writeFileSync(path.join(ground, 'a.txt'), 'alpha');
+  fs.mkdirSync(path.join(ground, 'nested'));
+  fs.writeFileSync(path.join(ground, 'nested', 'b.bin'), Buffer.from([0, 1, 2]));
+
+  const { rootPath, record } = service.add(ground);
+  assert.equal(rootPath, ground);
+  assert.ok(record.uuid, 'the tree has a permanent identity');
+  assert.equal(record.parentUUID, null, 'a tree is a parentless record');
+
+  const registry = service.registration.tree(ground).registry;
+  const named = new Map(registry.children(record.uuid).map((row) => [row.name, row]));
+  assert.deepEqual([...named.keys()].sort(), ['a.txt', 'nested']);
+  assert.equal(named.get('a.txt').type, 'file.text', 'the real classifier ran');
+
+  const nested = registry.children(named.get('nested').uuid);
+  assert.equal(nested.length, 1);
+  assert.equal(nested[0].type, 'file.binary', 'and it distinguishes bytes from text');
+});
+
+test('watching is armed: add begins the Watch rail, not just the walk', () => {
+  const service = makeService('watching');
+  const ground = makeGround('watching');
+  fs.writeFileSync(path.join(ground, 'a.txt'), 'alpha');
+  service.add(ground);
+
+  const [root] = service.observer.status();
+  assert.equal(root.path, ground);
+  assert.equal(root.watching, true, 'the doorbell is live');
+  assert.equal(root.degraded, false);
+});
+
+test('the Detect → Record wire is live: a later change reaches the registry', () => {
+  const service = makeService('wire');
+  const ground = makeGround('wire');
+  fs.writeFileSync(path.join(ground, 'a.txt'), 'alpha');
+  const { record } = service.add(ground);
+  const tree = service.registration.tree(ground);
+
+  // Ground that appeared after registration. The scan publishes, the
+  // boundary records — cut the emit wire in service.js and this fails.
+  fs.writeFileSync(path.join(ground, 'later.txt'), 'arrived after');
+  service.observer.scanNow(service.observer.listRoots()[0].rootId);
+  service.registration.flushIfDirty();
+
+  const names = tree.registry.children(record.uuid).map((row) => row.name).sort();
+  assert.deepEqual(names, ['a.txt', 'later.txt']);
+});
+
+test('identity survives a restart over the same directory', () => {
+  const dir = path.join(tempRoot, 'state-restart');
+  const ground = makeGround('restart');
+  fs.writeFileSync(path.join(ground, 'a.txt'), 'alpha');
+
+  const first = createRegistrationService({ dir });
+  const before = first.add(ground).record.uuid;
+  first.stop();
+
+  const second = createRegistrationService({ dir });
+  services.push(second);
+  const after = second.registration.tree(ground).root().uuid;
+  assert.equal(after, before, 'the tree keeps its permanent UUID across processes');
+});
+
+// --- the policies are the real ones ---------------------------------------
+
+test("amalgm's enrollment policy is in force, and refuses loudly", () => {
+  const service = makeService('policy');
+  const excluded = path.join(makeGround('policy'), 'node_modules');
+  fs.mkdirSync(excluded);
+  assert.throws(() => service.add(excluded), /enrollment policy excludes it/);
+});
+
+test('adding ground already inside a registered tree returns that tree', () => {
+  const service = makeService('covered');
+  const ground = makeGround('covered');
+  fs.mkdirSync(path.join(ground, 'inner'));
+  fs.writeFileSync(path.join(ground, 'inner', 'a.txt'), 'alpha');
+
+  const tree = service.add(ground);
+  const inner = service.add(path.join(ground, 'inner'));
+  assert.equal(inner.rootPath, ground, 'one owner per path — no second tree is born');
+  assert.equal(inner.record.uuid, tree.record.uuid);
+});
+
+// --- the endpoint ----------------------------------------------------------
+
+function fakeCtx(pathname, method, body) {
+  const sent = {};
+  return {
+    ctx: {
+      pathname,
+      method,
+      readJsonBody: async () => body,
+      sendJson: (status, payload) => Object.assign(sent, { status, payload }),
+    },
+    sent,
+  };
+}
+
+test('POST /entities/add registers and answers with the tree', async () => {
+  const ground = makeGround('route');
+  fs.writeFileSync(path.join(ground, 'a.txt'), 'alpha');
+
+  const { ctx, sent } = fakeCtx('/entities/add', 'POST', { path: ground });
+  assert.equal(await handleEntityRoutes(ctx), true);
+  assert.equal(sent.status, 200);
+  assert.equal(sent.payload.rootPath, ground);
+  assert.ok(sent.payload.record.uuid);
+});
+
+test('the endpoint reports a refusal as a refusal, with the reason', async () => {
+  const excluded = path.join(makeGround('route-refused'), '.ssh');
+  fs.mkdirSync(excluded);
+
+  const { ctx, sent } = fakeCtx('/entities/add', 'POST', { path: excluded });
+  assert.equal(await handleEntityRoutes(ctx), true);
+  assert.equal(sent.status, 400, 'the request named ground the boundary refuses');
+  assert.match(sent.payload.error, /enrollment policy excludes it/);
+});
+
+test('a missing path is answered, not registered', async () => {
+  const { ctx, sent } = fakeCtx('/entities/add', 'POST', {});
+  assert.equal(await handleEntityRoutes(ctx), true);
+  assert.equal(sent.status, 400);
+  assert.match(sent.payload.error, /path is required/);
+});
+
+test('ground that is not there is a refusal, never a crash', async () => {
+  const { ctx, sent } = fakeCtx('/entities/add', 'POST', { path: path.join(tempRoot, 'no-such-ground') });
+  assert.equal(await handleEntityRoutes(ctx), true);
+  assert.equal(sent.status, 400);
+  assert.ok(sent.payload.error);
+});
+
+test('the route is MOUNTED: the runtime dispatcher reaches it', async () => {
+  // A handler nothing routes to is a handler that does not exist. This
+  // is the local dispatcher production actually serves, unmodified.
+  const ground = makeGround('mounted');
+  fs.writeFileSync(path.join(ground, 'a.txt'), 'alpha');
+
+  const { ctx, sent } = fakeCtx('/entities/add', 'POST', { path: ground });
+  assert.equal(await createLocalServiceRouter().handle(ctx), true);
+  assert.equal(sent.status, 200);
+  assert.equal(sent.payload.rootPath, ground);
+});
+
+test('the route group claims only its own request', async () => {
+  const others = [
+    fakeCtx('/entities/add', 'GET', {}),
+    fakeCtx('/workspace/projects', 'POST', {}),
+    fakeCtx('/entities', 'POST', {}),
+  ];
+  for (const { ctx, sent } of others) {
+    assert.equal(await handleEntityRoutes(ctx), false);
+    assert.equal(sent.status, undefined, 'an unclaimed request is never answered');
+  }
+});