@turns/dev 0.0.13 → 0.0.15

package/dist/queue-worker.js

@@ -6,11 +6,13 @@ import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { anchorId, connectExistingAgentAnchors, launchAgentAnchor, waitForAgentTurn } from "./agent-anchor-client.js";
 import { createCodexUpdateManager } from "./codex-update.js";
+import { isAsyncQuestionId } from "./codex-async-question-recovery.js";
 import { assertAllowedWorkingDirectory, workingDirectoryIsAllowed } from "./directory-policy.js";
 import { browseMachinePath, streamMachineFileRange } from "./file-browsing.js";
 import { applyFileEdit } from "./file-edits.js";
 import { searchMachinePaths } from "./file-search.js";
 import { readMachineGitBaseBlob, readMachineGitPatch, readMachineGitStatus } from "./git-status.js";
+import { resolveHarnessCommand } from "./harness-registry.js";
 import { createHarnessAuthManager } from "./harness-auth.js";
 import { nativeDescriptorAgentSessionId, nativeDescriptorWorkingDirectory } from "./local-session-sources.js";
 import { compactRuntimeValue } from "./native-record-compaction.js";
@@ -24,6 +26,27 @@ const MACHINE_HEARTBEAT_TIMEOUT_MS = 15_000;
 const RUNTIME_BATCH_SIZE = 100;
 const MAX_RUNTIME_FLUSH_FAILURES = 10;
 const DEFAULT_REDACTOR = createSecretRedactor();
+export async function answerAnchorInteraction(entry, interactionId, response) {
+    if (!entry || entry.connection.closed)
+        throw new Error('The detached harness is offline.');
+    entry.snapshot = await entry.connection.request('snapshot', {}, 5_000).catch(() => entry.snapshot);
+    const pending = entry.snapshot?.pendingInteractions?.some((interaction) => interaction.id === interactionId);
+    // Async questions can be reconstructed from the native transcript without
+    // appearing in the app-server's live/resumed item projection. Let the anchor
+    // verify and recover them instead of declaring the viewer's question stale.
+    if (!pending && !(entry.snapshot?.source === 'codex' && isAsyncQuestionId(interactionId))) {
+        throw new Error('The detached harness is no longer waiting for this interaction.');
+    }
+    try {
+        await entry.connection.request('answer_interaction', { interactionId, response }, 30_000);
+    }
+    catch (error) {
+        if (error?.message === 'The interaction is no longer waiting in this harness.') {
+            throw new Error('The detached harness is no longer waiting for this interaction.');
+        }
+        throw error;
+    }
+}
 function wait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
@@ -316,7 +339,7 @@ export function dispatchErrorIsRetryable(error) {
     // OpenCode emits this only after its provider stream has exhausted its own
     // backoff. Re-queueing the turn starts that entire retry sequence again and
     // also persists another copy of the user's prompt in the native session.
-    return !(/(?:not supported|does not support|no resumable native session|session key.*unavailable|no local transcript descriptor|working directory (?:is (?:unavailable|not a directory|inaccessible)|must be|could not be created)|outside the daemon allowlist|agent executable not found|provider finish_reason:\s*network_error)/iu.test(message) || /attachment .* (?:size mismatch|download failed \(4\d\d\))/iu.test(message));
+    return !(/(?:not supported|does not support|no resumable native session|session key.*unavailable|no local transcript descriptor|working directory (?:is (?:unavailable|not a directory|inaccessible)|must be|could not be created)|outside the daemon allowlist|agent executable not found|backend must be upgraded|agent (?:isolation launch failed|anchor exited before opening)|provider finish_reason:\s*network_error)/iu.test(message) || /attachment .* (?:size mismatch|download failed \(4\d\d\))/iu.test(message));
 }
 export function queueFailureIsRetryable(error, promptStarted) {
     return !promptStarted && dispatchErrorIsRetryable(error);
@@ -657,6 +680,10 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                     : path.dirname(descriptor.file), options.allowedDirectories);
             if (!fs.statSync(cwd).isDirectory())
                 throw new Error(`Working directory is unavailable: ${cwd}`);
+            // Check discovery before the durable delivery boundary, so an absent
+            // Codex installation leaves a recoverable unsent prompt in the queue.
+            if (descriptor.harness === 'codex')
+                resolveHarnessCommand('codex');
             entry = await usableAnchor(sessionId, descriptor.harness, agentSessionId);
         }
         if (!entry)
@@ -727,10 +754,16 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             // boundary before starting this attempt so an earlier turn_error with
             // that ID cannot immediately settle the new turn.
             const eventCursor = entry.connection.eventCursor();
-            // A local request can lose its response after the anchor has accepted
-            // the prompt, so crossing this boundary permanently disables automatic
-            // replay even when the exact delivery outcome is unknown.
+            // Persist before local delivery: either acknowledgement can be lost
+            // after acceptance. Uncertain delivery must never trigger automatic replay.
             queued.promptStarted = true;
+            await request({
+                type: 'queue.renew',
+                sessionId,
+                promptId: claim.prompt.id,
+                claimToken: claim.claimToken,
+                dispatchStarted: true,
+            });
             await entry.connection.request('send_message', {
                 source: descriptor.harness,
                 sessionId,
@@ -771,10 +804,12 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
         claimStarts.add(sessionId);
         let claim;
         try {
-            const response = await request({ type: 'queue.claim', sessionId });
+            const response = await request({ type: 'queue.claim', sessionId, dispatchTracking: true });
             claim = response.claim;
             if (!claim)
                 return;
+            if (!response.dispatchTracking)
+                throw new Error('The backend must be upgraded before dispatching prompts with this daemon.');
             await runClaim(sessionId, claim);
             // A completion can make the next item ready before its unsolicited event
             // crosses the socket. Claim once more immediately for zero-gap draining.
@@ -986,16 +1021,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
         const sessionId = String(message.sessionId || '');
         const entry = anchors.get(sessionId);
         try {
-            if (!entry || entry.connection.closed)
-                throw new Error('The detached harness is offline.');
-            entry.snapshot = await entry.connection.request('snapshot', {}, 5_000).catch(() => entry.snapshot);
-            if (!entry.snapshot?.pendingInteractions?.some((interaction) => interaction.id === message.interactionId)) {
-                throw new Error('The detached harness is no longer waiting for this interaction.');
-            }
-            await entry.connection.request('answer_interaction', {
-                interactionId: String(message.interactionId || ''),
-                response: message.response,
-            }, 30_000);
+            await answerAnchorInteraction(entry, String(message.interactionId || ''), message.response);
             await flushRuntime(sessionId);
             replyRpc.notify({
                 type: 'session.interaction.answer.result',
@@ -1372,7 +1398,13 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 type: 'machine.register',
                 machineId: machine,
                 machineHostname: os.hostname(),
-                capabilities: { fileSearch: true, git: true, fileRanges: true, harnessAuth: true, codexUpdate: true },
+                capabilities: {
+                    fileSearch: true,
+                    git: true,
+                    fileRanges: true,
+                    harnessAuth: true,
+                    ...(codexUpdate.available() ? { codexUpdate: true } : {}),
+                },
                 workerId,
                 workerInstanceId,
                 anchorSessionIds: [...anchors.keys()],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turns/dev",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",