amalgm 0.1.238 → 0.1.239

package/lib/shared-realtime-tunnel.js

@@ -17,7 +17,6 @@ const CLAIM_LIMIT = 16;
 const CLAIM_LEASE_MS = 30_000;
 const RETRY_MS = 1_000;
 const REAUTHORIZE_MS = 30_000;
-const REPO_OBJECT_REQUEST_TIMEOUT_MS = 15_000;
 
 function createSharedRealtimeTunnel({
   send,
@@ -25,7 +24,6 @@ function createSharedRealtimeTunnel({
   localPort,
   localHeaders,
   warn,
-  repoObjectRequestTimeoutMs = REPO_OBJECT_REQUEST_TIMEOUT_MS,
 }) {
   const mutationInflight = new Map();
   const promotionInflight = new Map();
@@ -144,6 +142,10 @@ function createSharedRealtimeTunnel({
     attachmentRetryTimer.unref?.();
   }
 
+  function alreadyInflight(inflight, matches) {
+    return [...inflight.values()].some(matches);
+  }
+
   async function drainMutations() {
     if (!enabled || mutationDrain) return;
     mutationDrain = (async () => {
@@ -154,6 +156,10 @@ function createSharedRealtimeTunnel({
       for (const claim of Array.isArray(result?.mutations) ? result.mutations : []) {
         const envelope = claim?.envelope;
         if (!envelope?.resourceId || !envelope?.mutationId) continue;
+        if (alreadyInflight(mutationInflight, (entry) => (
+          entry.resourceId === envelope.resourceId
+          && entry.mutationId === envelope.mutationId
+        ))) continue;
         const requestId = `shared_${crypto.randomBytes(12).toString('hex')}`;
         if (!sendLarge({ type: 'shared.mutation.submit', request_id: requestId, envelope })) {
           await failMutationClaim(claim, 'shared tunnel backpressure: mutation was not queued');
@@ -201,6 +207,9 @@ function createSharedRealtimeTunnel({
       for (const claim of Array.isArray(result?.promotions) ? result.promotions : []) {
         const promotion = claim?.frame;
         if (!promotion?.promotionId || !promotion?.resourceId) continue;
+        if (alreadyInflight(promotionInflight, (entry) => (
+          entry.promotionId === promotion.promotionId
+        ))) continue;
         const requestId = `promote_${crypto.randomBytes(12).toString('hex')}`;
         const queued = sendLarge({
           type: 'shared.resource.promote',
@@ -247,6 +256,9 @@ function createSharedRealtimeTunnel({
       });
       for (const attachment of Array.isArray(result?.attachments) ? result.attachments : []) {
         if (!attachment?.attachmentId || !attachment?.resourceId) continue;
+        if (alreadyInflight(attachmentInflight, (entry) => (
+          entry.attachmentId === attachment.attachmentId
+        ))) continue;
         const requestId = `attach_${crypto.randomBytes(12).toString('hex')}`;
         if (!send({
           type: 'shared.resource.attach',
@@ -279,17 +291,10 @@ function createSharedRealtimeTunnel({
     repoObjectTimer.unref?.();
   }
 
-  function expireRepoObjectRequests(now = Date.now()) {
-    for (const inflight of [repoUploadInflight, repoDownloadInflight]) {
-      for (const [requestId, object] of inflight) {
-        if (now - object.sentAt >= repoObjectRequestTimeoutMs) inflight.delete(requestId);
-      }
-    }
-  }
-
   async function drainRepoObjects() {
     if (!enabled) return;
-    expireRepoObjectRequests();
+    // One ordered WebSocket carries one request until its reply. A disconnect
+    // clears this map and the durable local queue resends after reconnect.
     if (repoUploadInflight.size === 0) {
       const result = await localStateJson('POST', '/state/repo-objects/uploads/claim', {});
       const upload = result?.upload;
@@ -306,7 +311,6 @@ function createSharedRealtimeTunnel({
           repoUploadInflight.set(requestId, {
             resourceId: upload.resourceId,
             sha256: upload.sha256,
-            sentAt: Date.now(),
           });
         }
       }
@@ -325,7 +329,6 @@ function createSharedRealtimeTunnel({
           repoDownloadInflight.set(requestId, {
             resourceId: download.resourceId,
             sha256: download.sha256,
-            sentAt: Date.now(),
           });
         }
       }

package/package.json

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

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 when an acknowledgement is lost', async () => {
+test('repo object chunks retry after the tunnel reconnects', async () => {
   const uploadBytes = Buffer.from('retry this content-addressed chunk');
   const uploadSha = crypto.createHash('sha256').update(uploadBytes).digest('hex');
   const resourceId = 'shr_cp1abcdefghijklmnopqrstuvwx';
@@ -165,14 +165,25 @@ test('repo object chunks retry when an acknowledgement is lost', 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 unacknowledged upload retry',
+      'the upload after reconnect',
     );
     const puts = frames.filter((frame) => frame.type === 'repo.object.put');
     assert.notEqual(puts[0].request_id, puts[1].request_id);
@@ -189,3 +200,66 @@ test('repo object chunks retry when an acknowledgement is lost', async () => {
     server.close();
   }
 });
+
+test('a healthy tunnel sends one request for one durable mutation', async () => {
+  const envelope = {
+    resourceId: 'shr_cp1abcdefghijklmnopqrstuvwx',
+    authorityEpoch: 1,
+    mutationId: 'mut_one_ordered_request',
+    deviceId: 'machine-a',
+    baseVersion: 0,
+    contract: 'code-project-stream@1',
+    schemaVersion: 1,
+    operationKind: 'code.publish',
+    operation: { kind: 'code.publish', record: { value: 'one change' } },
+  };
+  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();
+  }
+});