amalgm 0.1.245 → 0.1.246

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

@@ -123,7 +123,7 @@ test('repo object chunks travel through the shared tunnel one at a time', async
   }
 });
 
-test('repo object chunks retry after the tunnel reconnects', async () => {
+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';
@@ -165,25 +165,14 @@ test('repo object chunks retry after the tunnel reconnects', async () => {
     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 === 1,
-      'the original upload',
-    );
-    await new Promise((resolve) => { setTimeout(resolve, 50); });
-    assert.equal(
-      frames.filter((frame) => frame.type === 'repo.object.put').length,
-      1,
-      'a healthy ordered tunnel never duplicates an in-flight upload',
-    );
-    tunnel.stop();
     tunnel.enable(['shared.mutation.v1']);
     await until(
       () => frames.filter((frame) => frame.type === 'repo.object.put').length >= 2,
-      'the upload after reconnect',
+      'the unacknowledged upload retry',
     );
     const puts = frames.filter((frame) => frame.type === 'repo.object.put');
     assert.notEqual(puts[0].request_id, puts[1].request_id);
@@ -200,160 +189,3 @@ test('repo object chunks retry after the tunnel reconnects', async () => {
     server.close();
   }
 });
-
-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: '018f0000-0000-7000-8000-000000000050',
-    authorityEpoch: 1,
-    mutationId: 'mut_one_ordered_request',
-    deviceId: 'machine-a',
-    baseVersion: 0,
-    contract: 'code-project-stream@2',
-    schemaVersion: 2,
-    operationKind: 'code.publish',
-    operation: {
-      kind: 'code.publish',
-      project: '018f0000-0000-7000-8000-000000000050',
-      delta: { kind: 'checkpoint.set' },
-    },
-  };
-  let wakeResponse = null;
-  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');
-        wakeResponse = res;
-      } else if (req.url === '/state/mutations/claim') {
-        res.end(JSON.stringify({ mutations: [{ envelope }] }));
-      } 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: () => {},
-  });
-  const submits = () => frames.filter((frame) => frame.type === 'shared.mutation.submit');
-
-  try {
-    tunnel.enable(['shared.mutation.v1']);
-    await until(() => submits().length === 1 && wakeResponse, 'the original mutation request');
-    for (let index = 0; index < 3; index += 1) {
-      wakeResponse.write('event: state\ndata: {"sharedResourceId":"shr_cp1abcdefghijklmnopqrstuvwx"}\n\n');
-      await new Promise((resolve) => { setTimeout(resolve, 20); });
-    }
-    assert.equal(submits().length, 1, 'wake signals never duplicate an in-flight mutation');
-
-    tunnel.stop();
-    tunnel.enable(['shared.mutation.v1']);
-    await until(() => submits().length === 2, 'the mutation after reconnect');
-    assert.notEqual(submits()[0].request_id, submits()[1].request_id);
-  } finally {
-    tunnel.stop();
-    server.close();
-  }
-});

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

@@ -2,7 +2,6 @@
 
 const test = require('node:test');
 const assert = require('node:assert/strict');
-const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -26,38 +25,16 @@ fs.writeFileSync(
 const { closeLocalDb } = require('../state/db');
 const { hasCommit, headOid } = require('../workspace/git');
 const {
-  _test: { locatorChecksum },
   acknowledgeUpload,
   claimDownload,
   claimUpload,
-  failUpload,
   importFromLocator,
   objectSourceFor,
-  prepareBundleImport,
   publishPayload,
   readPayload,
   receiveDownload,
 } = require('../workspace/objects');
 
-const PROJECT = '018f0000-0000-7000-8000-000000000030';
-const PROJECT_BINDING = require('../workspace/wall').bindProject(
-  PROJECT,
-  '11111111-1111-4111-8111-111111111111',
-  tempRoot,
-);
-const REPO_KEY = PROJECT_BINDING.repoKey;
-
-test('a locator checksum binds the exact ordered chunk list', () => {
-  const first = { sha256: 'a'.repeat(64), bytes: 3 };
-  const second = { sha256: 'b'.repeat(64), bytes: 4 };
-  assert.equal(locatorChecksum([first, second]), locatorChecksum([first, second]));
-  assert.notEqual(locatorChecksum([first, second]), locatorChecksum([second, first]));
-  assert.notEqual(
-    locatorChecksum([first, second]),
-    locatorChecksum([first, { ...second, bytes: 5 }]),
-  );
-});
-
 test.after(() => {
   closeLocalDb();
   fs.rmSync(tempRoot, { recursive: true, force: true });
@@ -72,7 +49,7 @@ async function git(cwd, ...args) {
   return stdout;
 }
 
-test('every committed card travels as project-owned chunks and imports without moving a ref', async () => {
+test('an unpushed commit travels as card-owned chunks and imports without moving a ref', async () => {
   const origin = path.join(tempRoot, 'origin.git');
   await git(tempRoot, 'init', '--bare', '-b', 'main', origin);
   const source = path.join(tempRoot, 'source');
@@ -84,12 +61,12 @@ test('every committed card travels as project-owned chunks and imports without m
 
   const destination = path.join(tempRoot, 'destination');
   await git(tempRoot, 'clone', '-q', origin, destination);
-  assert.equal((await objectSourceFor(source, REPO_KEY, await headOid(source))).kind, 'pending');
+  assert.equal((await objectSourceFor(source, 'repo:test', await headOid(source))).kind, 'remote');
 
   fs.appendFileSync(path.join(source, 'app.js'), 'two\n');
   await git(source, 'commit', '-am', 'two');
   const unpushedOid = await headOid(source);
-  assert.equal((await objectSourceFor(source, REPO_KEY, unpushedOid)).kind, 'pending');
+  assert.equal((await objectSourceFor(source, 'repo:test', unpushedOid)).kind, 'pending');
 
   const uploaded = new Map();
   const deadline = Date.now() + 10_000;
@@ -101,10 +78,10 @@ test('every committed card travels as project-owned chunks and imports without m
     }
     uploaded.set(upload.sha256, upload.dataBase64);
     acknowledgeUpload(upload.resourceId, upload.sha256);
-    const sourceState = await objectSourceFor(source, REPO_KEY, unpushedOid);
+    const sourceState = await objectSourceFor(source, 'repo:test', unpushedOid);
     if (sourceState.kind === 'bundle') break;
   }
-  const locator = await objectSourceFor(source, REPO_KEY, unpushedOid);
+  const locator = await objectSourceFor(source, 'repo:test', unpushedOid);
   assert.equal(locator.kind, 'bundle');
   assert.ok(locator.chunks.length > 0);
 
@@ -126,7 +103,7 @@ test('every committed card travels as project-owned chunks and imports without m
 
 test('a large checkpoint uses the same verified chunk lane', () => {
   const content = Buffer.alloc(1_300_000, 0x61);
-  assert.equal(publishPayload('large-checkpoint', content, REPO_KEY).kind, 'pending');
+  assert.equal(publishPayload('large-checkpoint', content, 'repo:test').kind, 'pending');
 
   const uploaded = new Map();
   while (true) {
@@ -135,7 +112,7 @@ test('a large checkpoint uses the same verified chunk lane', () => {
     uploaded.set(upload.sha256, upload.dataBase64);
     acknowledgeUpload(upload.resourceId, upload.sha256);
   }
-  const locator = publishPayload('large-checkpoint', content, REPO_KEY);
+  const locator = publishPayload('large-checkpoint', content, 'repo:test');
   assert.equal(locator.kind, 'chunks');
   assert.ok(locator.chunks.length >= 3);
 
@@ -152,194 +129,4 @@ test('a large checkpoint uses the same verified chunk lane', () => {
   const received = readPayload(locator);
   assert.equal(received.state, 'ready');
   assert.deepEqual(received.bytes, content);
-  assert.equal(
-    publishPayload('same-content-after-download', content, REPO_KEY).kind,
-    'chunks',
-    'verified downloaded content is immediately reusable by a later checkpoint',
-  );
-  assert.equal(claimUpload(), null);
-});
-
-test('zero-byte chunks are not legal transport work', () => {
-  const chunks = [
-    { sha256: '0'.repeat(64), bytes: 0 },
-    { sha256: '1'.repeat(64), bytes: 1 },
-  ];
-  const common = {
-    resourceId: PROJECT,
-    checksum: locatorChecksum(chunks),
-    bytes: 1,
-    chunks,
-  };
-  assert.throws(
-    () => readPayload({
-      kind: 'chunks',
-      contract: 'opaque-chunks@2',
-      ...common,
-    }),
-    /invalid checkpoint payload locator/,
-  );
-  assert.throws(
-    () => prepareBundleImport({
-      kind: 'bundle',
-      contract: 'git-bundle-chunks@2',
-      oid: 'a'.repeat(40),
-      ref: `refs/amalgm/exports/${'a'.repeat(40)}`,
-      ...common,
-    }),
-    /invalid git bundle locator/,
-  );
-});
-
-test('a corrupt pending upload is retired and rebuilt from the writer', () => {
-  const content = Buffer.from('rebuild this upload');
-  assert.equal(publishPayload('corrupt-upload', content, REPO_KEY).kind, 'pending');
-  const first = claimUpload();
-  assert.ok(first);
-  const chunkFile = path.join(
-    process.env.AMALGM_DIR,
-    'state',
-    'repo-objects',
-    'chunks',
-    `${first.sha256}.bin`,
-  );
-  fs.writeFileSync(chunkFile, 'corrupt');
-  assert.equal(claimUpload(), null, 'the corrupt manifest is retired instead of retrying forever');
-
-  assert.equal(publishPayload('corrupt-upload', content, REPO_KEY).kind, 'pending');
-  const rebuilt = claimUpload();
-  assert.equal(rebuilt.sha256, first.sha256);
-  assert.equal(Buffer.from(rebuilt.dataBase64, 'base64').toString(), content.toString());
-  acknowledgeUpload(rebuilt.resourceId, rebuilt.sha256);
-});
-
-test('one malformed download request cannot block valid requests behind it', () => {
-  const content = Buffer.from('download me');
-  const chunks = [{
-    sha256: require('crypto').createHash('sha256').update(content).digest('hex'),
-    bytes: content.length,
-  }];
-  const locator = {
-    kind: 'chunks',
-    contract: 'opaque-chunks@2',
-    resourceId: PROJECT,
-    checksum: locatorChecksum(chunks),
-    bytes: content.length,
-    chunks,
-  };
-  fs.rmSync(path.join(
-    process.env.AMALGM_DIR,
-    'state',
-    'repo-objects',
-    'chunks',
-    `${chunks[0].sha256}.bin`,
-  ), { force: true });
-  assert.equal(readPayload(locator).state, 'downloading');
-  const requests = path.join(process.env.AMALGM_DIR, 'state', 'repo-objects', 'requests');
-  fs.writeFileSync(path.join(requests, '000-malformed.json'), '{');
-
-  const claimed = claimDownload();
-  assert.equal(claimed.resourceId, PROJECT);
-  assert.equal(claimed.sha256, chunks[0].sha256);
-  assert.equal(fs.existsSync(path.join(requests, '000-malformed.json')), false);
-  receiveDownload(PROJECT, chunks[0].sha256, content.toString('base64'));
-});
-
-test('failed uploads yield the bulk lane to later durable objects', () => {
-  for (const content of ['first queued object', 'second queued object', 'third queued object']) {
-    assert.equal(
-      publishPayload(`fair-${content}`, Buffer.from(content), REPO_KEY).kind,
-      'pending',
-    );
-  }
-
-  const first = claimUpload();
-  assert.ok(first);
-  const retry = failUpload(first.resourceId, first.sha256, {
-    retryable: true,
-    code: 'temporary_object_failure',
-    message: 'try this object later',
-  });
-  assert.equal(retry.changed, true);
-  assert.equal(retry.terminal, false);
-  assert.ok(Date.parse(retry.retryAfter) > Date.now());
-
-  const second = claimUpload();
-  assert.ok(second);
-  assert.notEqual(second.sha256, first.sha256);
-  const terminal = failUpload(second.resourceId, second.sha256, {
-    retryable: false,
-    code: 'invalid_repo_object',
-    message: 'this exact object is invalid',
-  });
-  assert.equal(terminal.changed, true);
-  assert.equal(terminal.terminal, true);
-
-  const third = claimUpload();
-  assert.ok(third);
-  assert.notEqual(third.sha256, first.sha256);
-  assert.notEqual(third.sha256, second.sha256);
-
-  acknowledgeUpload(first.resourceId, first.sha256);
-  acknowledgeUpload(second.resourceId, second.sha256);
-  acknowledgeUpload(third.resourceId, third.sha256);
-  assert.equal(claimUpload(), null);
-});
-
-test('legacy shared-resource uploads can terminate without starving current projects', () => {
-  const legacyResourceId = 'shr_legacyobjectqueue0001';
-  const legacyChunks = [
-    Buffer.from('first stale object chunk from a legacy rail'),
-    Buffer.from('second stale object chunk from a legacy rail'),
-  ].map((bytes) => ({
-    bytes,
-    sha256: crypto.createHash('sha256').update(bytes).digest('hex'),
-  }));
-  const objectRoot = path.join(process.env.AMALGM_DIR, 'state', 'repo-objects');
-  const manifests = path.join(objectRoot, 'manifests');
-  const chunks = path.join(objectRoot, 'chunks');
-  for (const chunk of legacyChunks) {
-    fs.writeFileSync(path.join(chunks, `${chunk.sha256}.bin`), chunk.bytes);
-  }
-  fs.writeFileSync(path.join(manifests, '000-legacy-shared-resource.json'), JSON.stringify({
-    contract: 'git-bundle-chunks@2',
-    resourceId: legacyResourceId,
-    repoKey: 'legacy-repo',
-    oid: '1'.repeat(40),
-    ref: `refs/amalgm/exports/${'1'.repeat(40)}`,
-    checksum: locatorChecksum(legacyChunks.map((chunk) => ({
-      sha256: chunk.sha256,
-      bytes: chunk.bytes.length,
-    }))),
-    bytes: legacyChunks.reduce((total, chunk) => total + chunk.bytes.length, 0),
-    chunks: legacyChunks.map((chunk) => ({
-      sha256: chunk.sha256,
-      bytes: chunk.bytes.length,
-      uploaded: false,
-    })),
-    createdAt: new Date().toISOString(),
-  }));
-
-  assert.equal(
-    publishPayload('current-after-legacy', Buffer.from('current project object'), REPO_KEY).kind,
-    'pending',
-  );
-  const legacy = claimUpload();
-  assert.equal(legacy.resourceId, legacyResourceId);
-  assert.equal(legacy.sha256, legacyChunks[0].sha256);
-  const terminal = failUpload(legacy.resourceId, legacy.sha256, {
-    retryable: false,
-    code: 'shared_resource_read_forbidden',
-    message: 'the legacy rail is no longer readable',
-  });
-  assert.equal(terminal.changed, true);
-  assert.equal(terminal.terminal, true);
-
-  const current = claimUpload();
-  assert.equal(current.resourceId, PROJECT);
-  assert.ok(
-    legacyChunks.every((chunk) => current.sha256 !== chunk.sha256),
-    'a resource-wide rejection skips every remaining chunk from the stale rail',
-  );
-  acknowledgeUpload(current.resourceId, current.sha256);
 });