amalgm 0.1.241 → 0.1.243

package/package.json

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

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');
@@ -268,8 +269,8 @@ test('failed uploads yield the bulk lane to later durable objects', () => {
   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',
+    code: 'invalid_repo_object',
+    message: 'this exact object is invalid',
   });
   assert.equal(terminal.changed, true);
   assert.equal(terminal.terminal, true);
@@ -284,3 +285,61 @@ test('failed uploads yield the bulk lane to later durable objects', () => {
   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);
+});

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');
@@ -33,6 +34,12 @@ const REQUESTS = path.join(ROOT, 'requests');
 const preparing = new Map();
 const UPLOAD_RETRY_BASE_MS = 1_000;
 const UPLOAD_RETRY_MAX_MS = 60_000;
+const RESOURCE_WIDE_UPLOAD_FAILURES = new Set([
+  'invalid_repo_project',
+  'private_resource_forbidden',
+  'shared_resource_read_forbidden',
+  'shared_resource_write_forbidden',
+]);
 
 function isProjectId(value) {
   return require('./tree/identity').isUuid(String(value || ''));
@@ -288,12 +295,20 @@ function acknowledgeUpload(resourceId, digest) {
 }
 
 function failUpload(resourceId, digest, failure = {}) {
-  if (!isProjectId(resourceId) || !/^[0-9a-f]{64}$/.test(String(digest || ''))) {
+  // 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;
+  const failureCode = typeof failure?.code === 'string'
+    ? failure.code
+    : 'repo_object_upload_failed';
+  const resourceWide = RESOURCE_WIDE_UPLOAD_FAILURES.has(failureCode);
   let changed = false;
   let terminal = false;
   let retryAfter = null;
@@ -303,30 +318,38 @@ function failUpload(resourceId, digest, failure = {}) {
       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
+      const failedChunks = manifest.chunks.filter((entry) => (
+        !entry.uploaded && (resourceWide || entry.sha256 === digest)
       ));
-      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;
+      if (failedChunks.length < 1) continue;
+      for (const chunk of failedChunks) {
+        const chunkAttempts = Number(chunk.uploadAttempts || 0) + 1;
+        attempts = Math.max(attempts, chunkAttempts);
+        chunk.uploadAttempts = chunkAttempts;
+        chunk.uploadLastError = {
+          code: failureCode,
+          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(chunkAttempts - 1, 16)),
+          );
+          const chunkRetryAfter = new Date(Date.now() + delayMs).toISOString();
+          retryAfter = retryAfter && Date.parse(retryAfter) > Date.parse(chunkRetryAfter)
+            ? retryAfter
+            : chunkRetryAfter;
+          chunk.uploadRetryAfter = chunkRetryAfter;
+          delete chunk.uploadTerminal;
+        } else {
+          chunk.uploadTerminal = { ...chunk.uploadLastError };
+          delete chunk.uploadRetryAfter;
+          terminal = true;
+        }
       }
       writeJson(file, manifest);
       changed = true;