amalgm 0.1.240 → 0.1.242

package/lib/shared-realtime-tunnel.js

@@ -618,9 +618,18 @@ function createSharedRealtimeTunnel({
   }
 
   function handleError(frame) {
-    if (repoUploadInflight.has(frame.request_id)) {
-      repoUploadInflight.delete(frame.request_id);
-      scheduleRepoObjects(RETRY_MS);
+    const failedUpload = repoUploadInflight.get(frame.request_id);
+    if (failedUpload) {
+      void localStateJson('POST', '/state/repo-objects/uploads/fail', {
+        resourceId: failedUpload.resourceId,
+        sha256: failedUpload.sha256,
+        retryable: frame.retryable !== false,
+        code: frame.code,
+        message: frame.message,
+      }).finally(() => {
+        repoUploadInflight.delete(frame.request_id);
+        scheduleRepoObjects();
+      });
       return;
     }
     if (repoDownloadInflight.has(frame.request_id)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.240",
+  "version": "0.1.242",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/server/routes/state.js

@@ -59,6 +59,19 @@ async function handleStateRoutes(ctx) {
       ));
       return true;
     }
+    if (ctx.pathname === '/state/repo-objects/uploads/fail') {
+      const body = await ctx.readJsonBody();
+      ctx.sendJson(200, require('../../workspace/objects').failUpload(
+        body?.resourceId,
+        body?.sha256,
+        {
+          retryable: body?.retryable,
+          code: body?.code,
+          message: body?.message,
+        },
+      ));
+      return true;
+    }
     if (ctx.pathname === '/state/repo-objects/downloads/claim') {
       ctx.sendJson(200, { download: require('../../workspace/objects').claimDownload() });
       return true;

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

@@ -201,6 +201,96 @@ 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: '018f0000-0000-7000-8000-000000000050',

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

@@ -2,6 +2,7 @@
 
 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');
@@ -29,6 +30,7 @@ const {
   acknowledgeUpload,
   claimDownload,
   claimUpload,
+  failUpload,
   importFromLocator,
   objectSourceFor,
   prepareBundleImport,
@@ -242,3 +244,85 @@ test('one malformed download request cannot block valid requests behind it', ()
   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: 'shared_resource_read_forbidden',
+    message: 'the stale rail is no longer readable',
+  });
+  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 legacyBytes = Buffer.from('stale object from a legacy rail');
+  const legacyDigest = crypto.createHash('sha256').update(legacyBytes).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');
+  fs.writeFileSync(path.join(chunks, `${legacyDigest}.bin`), legacyBytes);
+  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([{ sha256: legacyDigest, bytes: legacyBytes.length }]),
+    bytes: legacyBytes.length,
+    chunks: [{ sha256: legacyDigest, bytes: legacyBytes.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, legacyDigest);
+  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.notEqual(current.sha256, legacy.sha256);
+  acknowledgeUpload(current.resourceId, current.sha256);
+});

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

@@ -13,6 +13,7 @@ const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const { AMALGM_DIR } = require('../config');
+const { isSharedResourceId } = require('../state/cloud-resource-id');
 const { appendStateEvent } = require('../state/events');
 const durable = require('./durable');
 const transition = require('./transition');
@@ -31,6 +32,8 @@ const PAYLOADS = path.join(ROOT, 'payloads');
 const CHUNKS = path.join(ROOT, 'chunks');
 const REQUESTS = path.join(ROOT, 'requests');
 const preparing = new Map();
+const UPLOAD_RETRY_BASE_MS = 1_000;
+const UPLOAD_RETRY_MAX_MS = 60_000;
 
 function isProjectId(value) {
   return require('./tree/identity').isUuid(String(value || ''));
@@ -209,11 +212,20 @@ async function objectSourceFor(worktreeRoot, repoKey, oid) {
 
 function claimUpload() {
   ensureDirs();
+  const now = Date.now();
   for (const directory of [MANIFESTS, PAYLOADS]) {
     for (const name of fs.readdirSync(directory).sort()) {
       const file = path.join(directory, name);
       const manifest = readJson(file);
-      const chunk = manifest?.chunks?.find((entry) => !entry.uploaded);
+      const chunk = manifest?.chunks?.find((entry) => (
+        !entry.uploaded
+        && !entry.uploadTerminal
+        && (
+          !entry.uploadRetryAfter
+          || !Number.isFinite(Date.parse(entry.uploadRetryAfter))
+          || Date.parse(entry.uploadRetryAfter) <= now
+        )
+      ));
       if (!chunk) continue;
       const chunkFile = path.join(CHUNKS, `${chunk.sha256}.bin`);
       const bytes = fs.existsSync(chunkFile) ? fs.readFileSync(chunkFile) : null;
@@ -252,6 +264,10 @@ function acknowledgeUpload(resourceId, digest) {
       for (const chunk of manifest.chunks) {
         if (chunk.sha256 === digest && !chunk.uploaded) {
           chunk.uploaded = true;
+          delete chunk.uploadAttempts;
+          delete chunk.uploadLastError;
+          delete chunk.uploadRetryAfter;
+          delete chunk.uploadTerminal;
           touched = true;
           changed = true;
         }
@@ -272,6 +288,59 @@ function acknowledgeUpload(resourceId, digest) {
   return { changed, completed };
 }
 
+function failUpload(resourceId, digest, failure = {}) {
+  // Upload work is durable across protocol generations. Match the exact
+  // identity that was accepted when the work was queued, including legacy
+  // `shr_` rails, so stale historical work can reach a terminal state instead
+  // of monopolizing every newer code project behind it.
+  if (!isSharedResourceId(resourceId) || !/^[0-9a-f]{64}$/.test(String(digest || ''))) {
+    return { changed: false, terminal: false };
+  }
+  ensureDirs();
+  const failedAt = new Date().toISOString();
+  const retryable = failure?.retryable !== false;
+  let changed = false;
+  let terminal = false;
+  let retryAfter = null;
+  let attempts = 0;
+  for (const directory of [MANIFESTS, PAYLOADS]) {
+    for (const name of fs.readdirSync(directory)) {
+      const file = path.join(directory, name);
+      const manifest = readJson(file);
+      if (manifest?.resourceId !== resourceId || !manifest?.chunks) continue;
+      const chunk = manifest.chunks.find((entry) => (
+        entry.sha256 === digest && !entry.uploaded
+      ));
+      if (!chunk) continue;
+      attempts = Math.max(attempts, Number(chunk.uploadAttempts || 0) + 1);
+      chunk.uploadAttempts = attempts;
+      chunk.uploadLastError = {
+        code: typeof failure?.code === 'string' ? failure.code : 'repo_object_upload_failed',
+        message: typeof failure?.message === 'string' ? failure.message : 'repo object upload failed',
+        retryable,
+        at: failedAt,
+      };
+      if (retryable) {
+        const delayMs = Math.min(
+          UPLOAD_RETRY_MAX_MS,
+          UPLOAD_RETRY_BASE_MS * (2 ** Math.min(attempts - 1, 16)),
+        );
+        retryAfter = new Date(Date.now() + delayMs).toISOString();
+        chunk.uploadRetryAfter = retryAfter;
+        delete chunk.uploadTerminal;
+      } else {
+        chunk.uploadTerminal = { ...chunk.uploadLastError };
+        delete chunk.uploadRetryAfter;
+        terminal = true;
+      }
+      writeJson(file, manifest);
+      changed = true;
+    }
+  }
+  if (changed) wake('update', digest);
+  return { changed, terminal, retryAfter, attempts };
+}
+
 function validatePayloadLocator(locator) {
   if (
     locator?.kind !== 'chunks'
@@ -456,6 +525,7 @@ module.exports = {
   bundleSourceFor,
   claimDownload,
   claimUpload,
+  failUpload,
   importFromLocator,
   objectSourceFor,
   prepareBundleImport,