@gemus/mcp-proxy 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gemus/mcp-proxy",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Local stdio<->HTTP MCP proxy for Codex desktop: transparent passthrough + execute tap + imagegen backfill (Issue #1751, P1).",
   "type": "module",
   "bin": {

package/src/__tests__/backfill.test.ts

@@ -213,6 +213,38 @@ describe('backfillTurn — idempotency + guards', () => {
     expect(r2.delivered).toBe(1)
   })
 
+  it('serializes concurrent passes so a racing salvage does not double-place an in-flight claim (#1751)', async () => {
+    // Real-machine bug (dev.log 1400–1544): a claim pass (Stop hook) and a salvage pass (idle timer)
+    // ran concurrently over the same session rollout. Because `seen` is only marked AFTER each slow
+    // awaited deliver, the salvage pass read the still-in-flight images as "fresh" and orphaned them —
+    // the same image landed BOTH on its planned gen node AND as a duplicate image-upload node.
+    const bf = makeBackfiller()
+    observeExecuteAnchor(bf, 1, 't1', 's1', 'wf_real', 'nodeA')
+    observeExecuteAnchor(bf, 2, 't1', 's1', 'wf_real', 'nodeB')
+    mocks.readRollout.mockReturnValue(rollout([IMG_A, IMG_B]))
+
+    // deliver resolves only when released — models the 6-20s awaited media job seen in the logs.
+    let releaseDeliver!: () => void
+    const gate = new Promise<void>((res) => {
+      releaseDeliver = res
+    })
+    mocks.deliverImageToNode.mockImplementation(async () => {
+      await gate
+      return { ok: true, status: 'processing' }
+    })
+
+    // Fire the claim pass (parks on the deliver gate), then a racing salvage pass — do NOT await between.
+    const claimPass = bf.backfillTurn({ turnKey: 't1', sessionId: 's1', rolloutPath: '/x', salvageOnly: false })
+    const salvagePass = bf.backfillTurn({ turnKey: 't1', rolloutPath: null, salvageOnly: true })
+    releaseDeliver()
+    const [claimResult, salvageResult] = await Promise.all([claimPass, salvagePass])
+
+    // Both images delivered to their planned nodes; the racing salvage placed NO duplicate orphans.
+    expect(claimResult).toEqual({ delivered: 2, orphaned: 0, dropped: 0 })
+    expect(salvageResult).toEqual({ delivered: 0, orphaned: 0, dropped: 0 })
+    expect(mocks.addImageToCanvas).not.toHaveBeenCalled()
+  })
+
   it('does nothing (no placement) when no workflowId was ever captured', async () => {
     const bf = makeBackfiller()
     // No tool call carried a workflowId this turn.

package/src/backfill.mjs

@@ -140,7 +140,7 @@ export function createBackfiller({ server, apiKey, codexHome, log = () => {} })
    * timer 在生成中途误触发、或 session-cap 交付失败）绝不能烧掉图 —— 否则真正的 Stop hook 认领时
    * fresh 为空。seen 只在成功交付后加入；turn 状态保留供后续 authoritative Stop hook 认领。
    */
-  async function backfillTurn({ turnKey, sessionId, rolloutPath, salvageOnly }) {
+  async function backfillTurnInner({ turnKey, sessionId, rolloutPath, salvageOnly }) {
     const t = turns.get(turnKey)
     const sid = sessionId || t?.sessionId
     const path = rolloutPath || core.findRolloutFile(codexHome, sid)
@@ -191,5 +191,20 @@ export function createBackfiller({ server, apiKey, codexHome, log = () => {} })
     return { delivered, orphaned, dropped }
   }
 
+  // Serialize backfillTurn. The Stop-hook claim pass and the idle-timer salvage pass can fire
+  // concurrently over the same session rollout; `seen` is only marked AFTER each slow awaited deliver,
+  // so a racing pass would read still-in-flight images as "fresh" and orphan them — the same image
+  // then lands BOTH on its planned gen node AND as a duplicate image-upload node (#1751 real-machine
+  // bug, dev.log 1400–1544). Running passes one-at-a-time makes `seen` authoritative for the next pass
+  // WITHOUT weakening the seen-on-success invariant (a failed deliver stays fresh, so a later hook still
+  // retries it). Passes are meant to be idempotent alternatives, not parallel work — serializing costs
+  // nothing but the (already-awaited) wait for the winner.
+  let tail = Promise.resolve()
+  function backfillTurn(opts) {
+    const result = tail.then(() => backfillTurnInner(opts))
+    tail = result.catch(() => {}) // advance the chain even if a pass throws; callers still see the rejection
+    return result
+  }
+
   return { observeCall, observeResult, backfillTurn, _turns: turns, _seen: seen }
 }