@turns/dev 0.0.12 → 0.0.14

package/dist/agent-anchor.js

@@ -595,6 +595,7 @@ class CodexAppServerTransport extends LineTransport {
                     : 'workspace-write',
             approvalPolicy: this.anchor.permissionMode === 'bypassPermissions' ? 'never' : 'on-request',
         };
+        const resumePath = !createSession && fs.existsSync(this.anchor.transcriptPath) ? this.anchor.transcriptPath : '';
         const opened = createSession
             ? await this.request('thread/start', {
                 ...configuration,
@@ -606,6 +607,13 @@ class CodexAppServerTransport extends LineTransport {
             }, 90_000)
             : await this.request('thread/resume', {
                 threadId: this.threadId,
+                // Codex's thread registry may not include a still-existing rollout
+                // after an upgrade. Supplying the descriptor path lets Codex resume
+                // the exact on-disk history instead of rejecting every later
+                // queued turn as "thread not found". Do not send Turns' temporary
+                // placeholder for a newly bound session: a non-empty path takes
+                // precedence over a valid thread id in the app-server protocol.
+                ...(resumePath ? { path: resumePath } : {}),
                 ...configuration,
                 ...(this.anchor.model && this.anchor.model !== 'auto' ? { model: this.anchor.model } : {}),
                 ...(this.anchor.thinkingLevel

package/dist/codex-update.js

@@ -1,7 +1,7 @@
 /** Machine-local Codex CLI self-update, callable by the Turns daemon. */
 import { spawn } from 'node:child_process';
 import os from 'node:os';
-import { resolveHarnessCommand } from "./harness-registry.js";
+import { codexCommandIsAppManaged, resolveHarnessCommand } from "./harness-registry.js";
 const VERSION_TIMEOUT_MS = 15_000;
 const UPDATE_TIMEOUT_MS = 5 * 60_000;
 const OUTPUT_LIMIT = 64 * 1024;
@@ -58,20 +58,28 @@ function commandFailure(result, fallback) {
 }
 export function createCodexUpdateManager(dependencies = {}) {
     const resolveCommand = dependencies.resolveCommand || (() => resolveHarnessCommand('codex'));
+    const isAppManaged = dependencies.isAppManaged || codexCommandIsAppManaged;
     const run = dependencies.run || runCommand;
     let active = null;
+    const updateCommand = () => {
+        const command = resolveCommand();
+        if (isAppManaged(command)) {
+            throw new Error('Codex is managed by the macOS app. Update the Codex app to update its bundled CLI.');
+        }
+        return command;
+    };
     const perform = async () => {
-        const beforeRun = await run(resolveCommand(), ['--version'], VERSION_TIMEOUT_MS);
+        const beforeRun = await run(updateCommand(), ['--version'], VERSION_TIMEOUT_MS);
         if (beforeRun.failed || beforeRun.timedOut || beforeRun.exitCode !== 0) {
             throw commandFailure(beforeRun, 'Codex is not installed or its version could not be read.');
         }
         const previousVersion = parseCodexVersion(beforeRun.output);
-        const updateRun = await run(resolveCommand(), ['update'], UPDATE_TIMEOUT_MS);
+        const updateRun = await run(updateCommand(), ['update'], UPDATE_TIMEOUT_MS);
         if (updateRun.failed || updateRun.timedOut || updateRun.exitCode !== 0) {
             throw commandFailure(updateRun, 'Codex could not update itself. Run `codex update` in a terminal on the machine.');
         }
         // Resolve again because the updater may replace a shim or install path.
-        const afterRun = await run(resolveCommand(), ['--version'], VERSION_TIMEOUT_MS);
+        const afterRun = await run(updateCommand(), ['--version'], VERSION_TIMEOUT_MS);
         if (afterRun.failed || afterRun.timedOut || afterRun.exitCode !== 0) {
             throw commandFailure(afterRun, 'Codex updated, but its new version could not be read.');
         }
@@ -83,6 +91,15 @@ export function createCodexUpdateManager(dependencies = {}) {
         };
     };
     return {
+        /** App-bundled Codex is updated with the app, not by its CLI command. */
+        available() {
+            try {
+                return !isAppManaged(resolveCommand());
+            }
+            catch {
+                return false;
+            }
+        },
         /** Concurrent clicks share one installer process instead of racing writes. */
         update() {
             if (!active)

package/dist/harness-registry.js

@@ -269,30 +269,55 @@ function executable(candidate) {
         return '';
     }
 }
-export function resolveHarnessCommand(harness, profile = {}) {
+export const MACOS_BUNDLED_CODEX_PATH = '/Applications/Codex.app/Contents/Resources/codex';
+/** The app owns this executable and updates it as part of the app bundle. */
+export function codexCommandIsAppManaged(command) {
+    let candidate = path.resolve(command);
+    try {
+        candidate = fs.realpathSync(candidate);
+    }
+    catch { }
+    return /\/Codex\.app\/Contents\/Resources\/codex$/u.test(candidate.replaceAll('\\', '/'));
+}
+export function resolveHarnessCommand(harness, profile = {}, dependencies = {}) {
+    const env = dependencies.env || process.env;
+    const home = dependencies.home || HOME;
     const envName = `TURNS_${String(harness).toUpperCase().replaceAll('-', '_')}_BIN`;
-    const configured = String(process.env[envName] || '').trim();
+    const configured = String(env[envName] || '').trim();
     if (configured) {
         const found = executable(path.resolve(configured));
         if (found)
             return found;
         throw new Error(`${envName} is not executable: ${configured}`);
     }
+    // The desktop app and its bundled CLI are released together. On macOS,
+    // prefer that known-compatible binary over independently installed npm or
+    // Homebrew copies while preserving TURNS_CODEX_BIN as the explicit escape
+    // hatch above.
+    if (harness === 'codex' && (dependencies.platform || process.platform) === 'darwin') {
+        const candidates = dependencies.bundledCodexPaths ||
+            [MACOS_BUNDLED_CODEX_PATH, path.join(home, 'Applications', 'Codex.app', 'Contents', 'Resources', 'codex')];
+        for (const candidate of candidates) {
+            const found = executable(candidate);
+            if (found)
+                return found;
+        }
+    }
     const command = profile.command || ({ cursor: 'cursor-agent', antigravity: 'agy' }[harness] ?? harness);
-    for (const directory of String(process.env.PATH || '').split(path.delimiter)) {
+    for (const directory of String(env.PATH || '').split(path.delimiter)) {
         const found = executable(path.join(directory, command));
         if (found)
             return found;
     }
     for (const segments of profile.homePaths || []) {
-        const found = executable(path.join(HOME, ...segments));
+        const found = executable(path.join(home, ...segments));
         if (found)
             return found;
     }
     if (harness === 'cursor') {
         for (const candidate of [
-            path.join(HOME, '.local', 'bin', 'cursor-agent'),
-            path.join(HOME, '.local', 'bin', 'agent'),
+            path.join(home, '.local', 'bin', 'cursor-agent'),
+            path.join(home, '.local', 'bin', 'agent'),
         ]) {
             const found = executable(candidate);
             if (found)

package/dist/queue-worker.js

@@ -1372,7 +1372,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.12",
+  "version": "0.0.14",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",