amalgm 0.1.239 → 0.1.241

package/runtime/scripts/amalgm-mcp/tests/workspace-native-file-transaction.test.js

@@ -0,0 +1,364 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFile, execFileSync, spawn } = require('node:child_process');
+const { promisify } = require('node:util');
+
+const execFileAsync = promisify(execFile);
+
+test('checked-in descriptor-relative transaction binaries match their exact source', async () => {
+  const verifier = path.join(
+    __dirname,
+    '..',
+    'workspace',
+    'native-file-transaction',
+    'verify.mjs',
+  );
+  const { stdout } = await execFileAsync(process.execPath, [verifier]);
+  assert.match(stdout, /verified source [a-f0-9]{64} and 2 binaries/);
+});
+
+test('native process lifetime distinguishes live owners from exited PIDs', () => {
+  const platform = process.platform === 'darwin' && process.arch === 'arm64'
+    ? 'darwin-arm64'
+    : process.platform === 'linux' && process.arch === 'x64'
+      ? 'linux-x64'
+      : null;
+  if (platform === null) return;
+  const executable = path.join(
+    __dirname,
+    '..',
+    'workspace',
+    'native-file-transaction',
+    'bin',
+    platform,
+    'amalgm-file-transaction',
+  );
+  const identity = (pid) => JSON.parse(execFileSync(executable, [], {
+    input: JSON.stringify({
+      action: 'identity',
+      backend: 'process-identity',
+      pid,
+    }),
+    encoding: 'utf8',
+  }));
+
+  const current = identity(process.pid);
+  assert.equal(current.status, 'identified');
+  assert.match(current.identity, /.+/);
+  assert.equal(identity(1).status, 'identified');
+  assert.deepEqual(identity(2_147_483_647), { status: 'exited' });
+});
+
+test('same bytes on a replacement inode do not satisfy an exact document predecessor', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-file-cas-test-'));
+  const file = path.join(root, 'document.md');
+  fs.writeFileSync(file, 'same bytes\n', 'utf8');
+  const docDisk = require('../state/doc-disk');
+  const native = require('../workspace/native-file-transaction/client');
+  const expected = docDisk.observe(file);
+
+  const replacement = path.join(root, 'replacement.md');
+  fs.writeFileSync(replacement, 'same bytes\n', 'utf8');
+  fs.renameSync(replacement, file);
+
+  const targetContent = Buffer.from('new target\n', 'utf8');
+  const transaction = {
+    root: expected.root,
+    rootDev: expected.rootDev,
+    rootIno: expected.rootIno,
+    path: expected.relativePath,
+    id: crypto.createHash('sha256').update('same-byte-inode-cas').digest('hex'),
+    operation: 'same-byte-inode-cas',
+    expected: expected.identity,
+    target: docDisk.byteIdentity(targetContent),
+  };
+  try {
+    const result = native.run(transaction, 'apply', targetContent);
+    assert.equal(result.status, 'changed');
+    assert.equal(fs.readFileSync(file, 'utf8'), 'same bytes\n');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('document observation stays with one physical parent across rename and replacement', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-file-observe-test-'));
+  const parent = path.join(root, 'registered-parent');
+  const renamed = path.join(root, 'uuid-owned-parent');
+  const file = path.join(parent, 'document.md');
+  fs.mkdirSync(parent);
+  fs.writeFileSync(file, 'owned bytes\n', 'utf8');
+  const originalParent = fs.statSync(parent, { bigint: true });
+  const child = spawn(process.execPath, [
+    '-e',
+    'const fs=require("fs");'
+      + `setTimeout(()=>{fs.renameSync(${JSON.stringify(parent)},${JSON.stringify(renamed)});`
+      + `fs.mkdirSync(${JSON.stringify(parent)});`
+      + `fs.writeFileSync(${JSON.stringify(file)},"unrelated bytes\\n","utf8");},75);`,
+  ], { stdio: 'ignore' });
+
+  try {
+    const observed = require('../state/doc-disk').observe(file, {
+      pauseAfterParentOpen: 350,
+    });
+    assert.equal(observed.text, 'owned bytes\n');
+    assert.equal(observed.rootDev, originalParent.dev.toString());
+    assert.equal(observed.rootIno, originalParent.ino.toString());
+    assert.notEqual(observed.text, fs.readFileSync(file, 'utf8'));
+  } finally {
+    child.unref();
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('receipt release keeps proof when its physical parent moved', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-receipt-move-test-'));
+  const parent = path.join(root, 'original-parent');
+  const movedParent = path.join(root, 'moved-parent');
+  const file = path.join(parent, 'document.md');
+  fs.mkdirSync(parent);
+  fs.writeFileSync(file, 'before\n', 'utf8');
+  const docDisk = require('../state/doc-disk');
+  const native = require('../workspace/native-file-transaction/client');
+  const expected = docDisk.observe(file);
+  const targetContent = Buffer.from('after\n', 'utf8');
+  const transaction = {
+    root: expected.root,
+    rootDev: expected.rootDev,
+    rootIno: expected.rootIno,
+    path: expected.relativePath,
+    id: crypto.createHash('sha256').update('moved-receipt-parent').digest('hex'),
+    operation: 'moved-receipt-parent',
+    expected: expected.identity,
+    target: docDisk.byteIdentity(targetContent),
+  };
+
+  try {
+    assert.equal(
+      native.run(transaction, 'apply', targetContent).status,
+      'applied',
+    );
+    fs.renameSync(parent, movedParent);
+
+    const retained = native.run(transaction, 'release');
+    assert.equal(retained.status, 'pending');
+    assert.match(retained.reason, /receipt parent is unavailable/);
+    assert.equal(
+      fs.existsSync(path.join(
+        movedParent,
+        `.amalgm-apply-${transaction.id}`,
+      )),
+      true,
+    );
+
+    const rebound = native.run({
+      ...transaction,
+      root: fs.realpathSync(movedParent),
+    }, 'release');
+    assert.equal(rebound.status, 'released');
+    assert.equal(
+      fs.existsSync(path.join(
+        movedParent,
+        `.amalgm-apply-${transaction.id}`,
+      )),
+      false,
+    );
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('exclusive tree moves preserve a destination created during the rename window', () => {
+  const native = require('../workspace/native-file-transaction/client');
+  for (const kind of ['file', 'directory']) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), `amalgm-tree-cas-${kind}-`));
+    const source = path.join(root, `source-${kind}`);
+    const destination = path.join(root, `destination-${kind}`);
+    if (kind === 'directory') {
+      fs.mkdirSync(source);
+      fs.writeFileSync(path.join(source, 'value.txt'), 'source directory\n', 'utf8');
+    } else {
+      fs.writeFileSync(source, 'source file\n', 'utf8');
+    }
+    const rootStats = fs.lstatSync(root, { bigint: true });
+    const sourceStats = fs.lstatSync(source, { bigint: true });
+    const child = spawn(process.execPath, [
+      '-e',
+      'const fs=require("fs");'
+        + `setTimeout(()=>{`
+        + (kind === 'directory'
+          ? `fs.mkdirSync(${JSON.stringify(destination)});`
+            + `fs.writeFileSync(${JSON.stringify(path.join(destination, 'value.txt'))},"racing directory\\n","utf8");`
+          : `fs.writeFileSync(${JSON.stringify(destination)},"racing file\\n","utf8");`)
+        + '},75);',
+    ], { stdio: 'ignore' });
+
+    try {
+      const result = native.moveNoReplace({
+        root: fs.realpathSync(root),
+        rootDev: rootStats.dev.toString(),
+        rootIno: rootStats.ino.toString(),
+        source: path.basename(source),
+        sourceIdentity: {
+          kind: kind === 'directory' ? 'folder' : kind,
+          dev: sourceStats.dev.toString(),
+          ino: sourceStats.ino.toString(),
+        },
+        sourceParentIdentity: {
+          kind: 'folder',
+          dev: rootStats.dev.toString(),
+          ino: rootStats.ino.toString(),
+        },
+        targetParentIdentity: {
+          kind: 'folder',
+          dev: rootStats.dev.toString(),
+          ino: rootStats.ino.toString(),
+        },
+        path: path.basename(destination),
+        id: crypto.createHash('sha256').update(`tree-cas-${kind}`).digest('hex'),
+        operation: `tree-cas-${kind}`,
+      }, {
+        pauseBeforeInstall: 300,
+      });
+      assert.equal(result.status, 'changed');
+      assert.match(result.reason, /destination changed/);
+      if (kind === 'directory') {
+        assert.equal(
+          fs.readFileSync(path.join(source, 'value.txt'), 'utf8'),
+          'source directory\n',
+        );
+        assert.equal(
+          fs.readFileSync(path.join(destination, 'value.txt'), 'utf8'),
+          'racing directory\n',
+        );
+      } else {
+        assert.equal(fs.readFileSync(source, 'utf8'), 'source file\n');
+        assert.equal(fs.readFileSync(destination, 'utf8'), 'racing file\n');
+      }
+    } finally {
+      child.unref();
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  }
+});
+
+test('exclusive tree moves restore a source name swapped during the rename window', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-tree-source-cas-'));
+  const source = path.join(root, 'source.txt');
+  const movedOriginal = path.join(root, 'moved-original.txt');
+  const destination = path.join(root, 'destination.txt');
+  fs.writeFileSync(source, 'original source\n', 'utf8');
+  const rootStats = fs.lstatSync(root, { bigint: true });
+  const sourceStats = fs.lstatSync(source, { bigint: true });
+  const child = spawn(process.execPath, [
+    '-e',
+    'const fs=require("fs");'
+      + `setTimeout(()=>{`
+      + `fs.renameSync(${JSON.stringify(source)},${JSON.stringify(movedOriginal)});`
+      + `fs.writeFileSync(${JSON.stringify(source)},"replacement source\\n","utf8");`
+      + '},75);',
+  ], { stdio: 'ignore' });
+
+  try {
+    const result = require('../workspace/native-file-transaction/client')
+      .moveNoReplace({
+        root: fs.realpathSync(root),
+        rootDev: rootStats.dev.toString(),
+        rootIno: rootStats.ino.toString(),
+        source: path.basename(source),
+        sourceIdentity: {
+          kind: 'file',
+          dev: sourceStats.dev.toString(),
+          ino: sourceStats.ino.toString(),
+        },
+        sourceParentIdentity: {
+          kind: 'folder',
+          dev: rootStats.dev.toString(),
+          ino: rootStats.ino.toString(),
+        },
+        targetParentIdentity: {
+          kind: 'folder',
+          dev: rootStats.dev.toString(),
+          ino: rootStats.ino.toString(),
+        },
+        path: path.basename(destination),
+        id: crypto.createHash('sha256').update('tree-source-cas').digest('hex'),
+        operation: 'tree-source-cas',
+      }, {
+        pauseBeforeInstall: 300,
+      });
+    assert.equal(result.status, 'changed');
+    assert.match(result.reason, /source changed during exclusive move and was restored/);
+    assert.equal(fs.existsSync(destination), false);
+    assert.equal(fs.readFileSync(source, 'utf8'), 'replacement source\n');
+    assert.equal(fs.readFileSync(movedOriginal, 'utf8'), 'original source\n');
+  } finally {
+    child.unref();
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('exclusive tree moves retain both names when a second source wins the undo race', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-tree-source-both-'));
+  const source = path.join(root, 'source.txt');
+  const movedOriginal = path.join(root, 'moved-original.txt');
+  const destination = path.join(root, 'destination.txt');
+  fs.writeFileSync(source, 'original source\n', 'utf8');
+  const rootStats = fs.lstatSync(root, { bigint: true });
+  const sourceStats = fs.lstatSync(source, { bigint: true });
+  const child = spawn(process.execPath, [
+    '-e',
+    'const fs=require("fs");'
+      + `setTimeout(()=>{`
+      + `fs.renameSync(${JSON.stringify(source)},${JSON.stringify(movedOriginal)});`
+      + `fs.writeFileSync(${JSON.stringify(source)},"first replacement\\n","utf8");`
+      + '},250);'
+      + `setTimeout(()=>{`
+      + `fs.writeFileSync(${JSON.stringify(source)},"second replacement\\n","utf8");`
+      + '},900);',
+  ], { stdio: 'ignore' });
+  try {
+    const result = require('../workspace/native-file-transaction/client')
+      .moveNoReplace({
+        root: fs.realpathSync(root),
+        rootDev: rootStats.dev.toString(),
+        rootIno: rootStats.ino.toString(),
+        source: path.basename(source),
+        sourceIdentity: {
+          kind: 'file',
+          dev: sourceStats.dev.toString(),
+          ino: sourceStats.ino.toString(),
+        },
+        sourceParentIdentity: {
+          kind: 'folder',
+          dev: rootStats.dev.toString(),
+          ino: rootStats.ino.toString(),
+        },
+        targetParentIdentity: {
+          kind: 'folder',
+          dev: rootStats.dev.toString(),
+          ino: rootStats.ino.toString(),
+        },
+        path: path.basename(destination),
+        id: crypto.createHash('sha256').update('tree-source-both').digest('hex'),
+        operation: 'tree-source-both',
+      }, {
+        pauseBeforeInstall: 600,
+        pauseAfterTreeMove: 600,
+      });
+    assert.equal(result.status, 'changed');
+    assert.match(result.reason, /both entries were retained/);
+    assert.equal(fs.readFileSync(movedOriginal, 'utf8'), 'original source\n');
+    assert.equal(fs.readFileSync(destination, 'utf8'), 'first replacement\n');
+    assert.equal(fs.readFileSync(source, 'utf8'), 'second replacement\n');
+  } finally {
+    child.unref();
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

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

@@ -201,17 +201,111 @@ test('repo object chunks retry after the tunnel reconnects', async () => {
   }
 });
 
+test('a rejected stale object yields the tunnel to the next upload', async () => {
+  const staleBytes = Buffer.from('stale denied object');
+  const staleSha = crypto.createHash('sha256').update(staleBytes).digest('hex');
+  const currentBytes = Buffer.from('current allowed object');
+  const currentSha = crypto.createHash('sha256').update(currentBytes).digest('hex');
+  const resourceId = 'shr_cp1abcdefghijklmnopqrstuvwx';
+  let failed = false;
+  const calls = [];
+  const server = http.createServer((req, res) => {
+    let raw = '';
+    req.on('data', (chunk) => { raw += chunk; });
+    req.on('end', () => {
+      const body = raw ? JSON.parse(raw) : null;
+      calls.push({ path: req.url, body });
+      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') {
+        const bytes = failed ? currentBytes : staleBytes;
+        const sha256 = failed ? currentSha : staleSha;
+        res.end(JSON.stringify({
+          upload: {
+            resourceId,
+            sha256,
+            bytes: bytes.length,
+            dataBase64: bytes.toString('base64'),
+          },
+        }));
+      } else if (req.url === '/state/repo-objects/uploads/fail') {
+        failed = true;
+        res.end('{"changed":true,"terminal":true}');
+      } else if (req.url.endsWith('/claim')) {
+        res.end('{}');
+      } 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: () => {},
+  });
+
+  try {
+    tunnel.enable(['shared.mutation.v1']);
+    await until(
+      () => frames.some((frame) => frame.type === 'repo.object.put'),
+      'the stale upload',
+    );
+    const stale = frames.find((frame) => frame.type === 'repo.object.put');
+    assert.equal(stale.sha256, staleSha);
+    tunnel.handleFrame({
+      type: 'shared.error',
+      request_id: stale.request_id,
+      resource_id: resourceId,
+      code: 'shared_resource_read_forbidden',
+      message: 'stale rail is no longer readable',
+      retryable: false,
+    });
+    await until(
+      () => frames.some((frame) => (
+        frame.type === 'repo.object.put' && frame.sha256 === currentSha
+      )),
+      'the current upload behind the stale one',
+    );
+    assert.deepEqual(
+      calls.find((call) => call.path === '/state/repo-objects/uploads/fail').body,
+      {
+        resourceId,
+        sha256: staleSha,
+        retryable: false,
+        code: 'shared_resource_read_forbidden',
+        message: 'stale rail is no longer readable',
+      },
+    );
+  } finally {
+    tunnel.stop();
+    server.close();
+  }
+});
+
 test('a healthy tunnel sends one request for one durable mutation', async () => {
   const envelope = {
-    resourceId: 'shr_cp1abcdefghijklmnopqrstuvwx',
+    resourceId: '018f0000-0000-7000-8000-000000000050',
     authorityEpoch: 1,
     mutationId: 'mut_one_ordered_request',
     deviceId: 'machine-a',
     baseVersion: 0,
-    contract: 'code-project-stream@1',
-    schemaVersion: 1,
+    contract: 'code-project-stream@2',
+    schemaVersion: 2,
     operationKind: 'code.publish',
-    operation: { kind: 'code.publish', record: { value: 'one change' } },
+    operation: {
+      kind: 'code.publish',
+      project: '018f0000-0000-7000-8000-000000000050',
+      delta: { kind: 'checkpoint.set' },
+    },
   };
   let wakeResponse = null;
   const server = http.createServer((req, res) => {