@turns/dev 0.0.20 → 0.0.22

package/dist/agent-anchor.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import net from 'node:net';
 import os from 'node:os';
@@ -598,7 +599,12 @@ class CodexAppServerTransport extends LineTransport {
     asyncQuestionsSeen = new Set();
     constructor(anchor) {
         const profile = { command: 'codex' };
-        const mcp = `mcp_servers.turns={command=${JSON.stringify(process.execPath)},args=[${JSON.stringify(questionMcpPath)}],env={TURNS_AGENT_ANCHOR_SOCKET=${JSON.stringify(socketPath)}}}`;
+        // Codex deep-merges CLI overrides with configured MCP servers. Reusing
+        // "turns" mixes our stdio command with a user's HTTP URL and prevents even
+        // thread/start from loading its config. Keep the helper stable per anchor,
+        // but outside user-configured names, without rewriting their config.
+        const mcpName = `turns_anchor_${createHash('sha256').update(socketPath).digest('hex').slice(0, 12)}`;
+        const mcp = `mcp_servers.${mcpName}={command=${JSON.stringify(process.execPath)},args=[${JSON.stringify(questionMcpPath)}],env={TURNS_AGENT_ANCHOR_SOCKET=${JSON.stringify(socketPath)}}}`;
         super(anchor, 'app-server', resolveHarnessCommand('codex', profile), ['-c', mcp, 'app-server', '--listen', 'stdio://'], anchor.cwd);
         this.threadId = anchor.agentSessionId;
         this.permissionMode = anchor.permissionMode;

package/dist/upload-sessions.js

@@ -24,6 +24,11 @@ const MAX_BATCH_ROWS = 100;
 const MAX_RUNTIME_EVENT_BATCH = 250;
 const RPC_TIMEOUT_MS = 5 * 60_000;
 const MAX_SOCKET_RETRIES = 8;
+/** Deadline for an uploader socket to finish its TCP, TLS, and upgrade
+ * handshake and receive the server's `ready` acknowledgement. A stalled
+ * handshake emits neither `error` nor `close`, so without this the daemon
+ * would wait in CONNECTING forever and silently stop uploading. */
+const READY_TIMEOUT_MS = 30_000;
 const MAX_NATIVE_SETTLE_PASSES = 4;
 const MAX_EXTERNAL_STATUS_BATCH = 1_000;
 const NATIVE_STATE_VERSION = 1;
@@ -548,28 +553,43 @@ export class RpcSocket {
     resolveClosed;
     ready;
     socket;
-    constructor(url, token, devUser = '') {
+    constructor(url, token, devUser = '', { readyTimeoutMs = READY_TIMEOUT_MS } = {}) {
         this.pending = new Map();
         this.listeners = new Set();
         this.closed = new Promise((resolve) => {
             this.resolveClosed = resolve;
         });
         this.ready = new Promise((resolve, reject) => {
+            // Settle exactly once so the deadline, the socket's own events, and the
+            // abort error that `terminate()` raises afterwards cannot race.
+            let settled = false;
+            let readyTimer = null;
+            const settle = (complete, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(readyTimer);
+                complete(value);
+            };
+            readyTimer = setTimeout(() => {
+                settle(reject, socketError(`Turns did not acknowledge the uploader within ${readyTimeoutMs / 1000} seconds.`));
+                this.socket.terminate();
+            }, readyTimeoutMs);
             const headers = devUser
                 ? { 'x-turns-dev-user': devUser, 'x-turns-dev-role': 'uploader' }
                 : { Authorization: `Bearer ${token}` };
-            this.socket = new WebSocket(url, { headers });
+            this.socket = new WebSocket(url, { headers, handshakeTimeout: readyTimeoutMs });
             this.socket.once('unexpected-response', (_request, response) => {
                 response.resume?.();
                 if (response.statusCode === 401 || response.statusCode === 403) {
-                    reject(authenticationError(`Turns rejected uploader authentication (HTTP ${response.statusCode}).`));
+                    settle(reject, authenticationError(`Turns rejected uploader authentication (HTTP ${response.statusCode}).`));
                 }
                 else {
-                    reject(socketError(`Unexpected WebSocket response (HTTP ${response.statusCode}).`));
+                    settle(reject, socketError(`Unexpected WebSocket response (HTTP ${response.statusCode}).`));
                 }
             });
-            this.socket.once('error', (error) => reject(socketError(`WebSocket connection failed: ${error.message}`, error)));
-            this.socket.on('message', (data) => this.onMessage(String(data), resolve, reject));
+            this.socket.once('error', (error) => settle(reject, socketError(`WebSocket connection failed: ${error.message}`, error)));
+            this.socket.on('message', (data) => this.onMessage(String(data), (ready) => settle(resolve, ready), (error) => settle(reject, error)));
             this.socket.on('close', (code, reason) => {
                 const error = socketError(`WebSocket closed (${code}): ${String(reason)}`);
                 for (const request of this.pending.values()) {
@@ -665,7 +685,9 @@ export async function connectUploader(options, machine, reconnect = false) {
             const credentials = await options.credentialProvider.refreshIfDue();
             options.token = credentials.accessToken;
         }
-        const rpc = new RpcSocket(options.url, options.token, options.devUser);
+        const rpc = new RpcSocket(options.url, options.token, options.devUser, {
+            readyTimeoutMs: options.readyTimeoutMs,
+        });
         try {
             const ready = await rpc.ready;
             process.stdout.write(`${reconnect ? 'Reconnected' : 'Connected'} to ${options.url} as @${ready.user.login} ` +

package/package.json

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