@turns/dev 0.0.11 → 0.0.12

package/dist/agent-anchor.js

@@ -599,14 +599,18 @@ class CodexAppServerTransport extends LineTransport {
             ? await this.request('thread/start', {
                 ...configuration,
                 ...(this.anchor.model && this.anchor.model !== 'auto' ? { model: this.anchor.model } : {}),
-                ...(this.anchor.thinkingLevel ? { effort: this.anchor.thinkingLevel } : {}),
+                ...(this.anchor.thinkingLevel
+                    ? { config: { model_reasoning_effort: this.anchor.thinkingLevel } }
+                    : {}),
                 ...(this.anchor.codexHistoryMode === 'paginated' ? { historyMode: 'paginated' } : {}),
             }, 90_000)
             : await this.request('thread/resume', {
                 threadId: this.threadId,
                 ...configuration,
                 ...(this.anchor.model && this.anchor.model !== 'auto' ? { model: this.anchor.model } : {}),
-                ...(this.anchor.thinkingLevel ? { effort: this.anchor.thinkingLevel } : {}),
+                ...(this.anchor.thinkingLevel
+                    ? { config: { model_reasoning_effort: this.anchor.thinkingLevel } }
+                    : {}),
             }, 90_000);
         const threadId = String(opened?.thread?.id || opened?.threadId || opened?.id || '');
         if (!threadId)

package/dist/codex-update.js

@@ -0,0 +1,93 @@
+/** 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";
+const VERSION_TIMEOUT_MS = 15_000;
+const UPDATE_TIMEOUT_MS = 5 * 60_000;
+const OUTPUT_LIMIT = 64 * 1024;
+/** Run the resolved executable directly—never through a shell—so update
+ * requests cannot become arbitrary command execution. */
+function runCommand(command, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {
+            cwd: os.homedir(),
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let output = '';
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { }
+            settle({ output, exitCode: null, timedOut: true });
+        }, timeoutMs);
+        timer.unref?.();
+        const collect = (chunk) => {
+            if (output.length < OUTPUT_LIMIT)
+                output += String(chunk).slice(0, OUTPUT_LIMIT - output.length);
+        };
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
+        child.on('error', () => settle({ output, exitCode: null, failed: true }));
+        child.on('close', (exitCode) => settle({ output, exitCode }));
+    });
+}
+export function parseCodexVersion(output) {
+    const text = String(output || '').trim();
+    const prefixed = text.match(/codex(?:-cli)?\s+([^\s]+)/iu);
+    return (prefixed?.[1] || text.split(/\s+/u).at(-1) || '').slice(0, 120);
+}
+function commandFailure(result, fallback) {
+    if (result.timedOut)
+        return new Error('The Codex update timed out.');
+    const lines = result.output
+        .replace(/\u001b\[[0-9;?]*[A-Za-z]/gu, '')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return new Error(lines.at(-1) || fallback);
+}
+export function createCodexUpdateManager(dependencies = {}) {
+    const resolveCommand = dependencies.resolveCommand || (() => resolveHarnessCommand('codex'));
+    const run = dependencies.run || runCommand;
+    let active = null;
+    const perform = async () => {
+        const beforeRun = await run(resolveCommand(), ['--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);
+        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);
+        if (afterRun.failed || afterRun.timedOut || afterRun.exitCode !== 0) {
+            throw commandFailure(afterRun, 'Codex updated, but its new version could not be read.');
+        }
+        const currentVersion = parseCodexVersion(afterRun.output);
+        return {
+            ...(previousVersion ? { previousVersion } : {}),
+            ...(currentVersion ? { currentVersion } : {}),
+            updated: Boolean(previousVersion && currentVersion && previousVersion !== currentVersion),
+        };
+    };
+    return {
+        /** Concurrent clicks share one installer process instead of racing writes. */
+        update() {
+            if (!active)
+                active = perform().finally(() => (active = null));
+            return active;
+        },
+    };
+}

package/dist/harness-auth.js

@@ -0,0 +1,289 @@
+/**
+ * Harness sign-in on this machine, steered from the browser.
+ *
+ * Claude Code and Codex each hold their own account credentials, and when a
+ * grant expires every turn fails until someone runs the harness's login
+ * command in a terminal on this machine. The daemon is that terminal: it can
+ * run both CLIs' browserless sign-in flows and relay the two strings a user
+ * actually needs — the approval URL and, for Codex's device flow, the
+ * one-time code — while accepting the single string that may come back, the
+ * authorization code Claude's flow reads on stdin.
+ *
+ * Both flows are driven entirely by scraping the CLI's human-readable
+ * output, because neither CLI offers a machine-readable login mode. The
+ * scraping is deliberately loose — the first https URL is the approval
+ * link, a short hyphenated all-caps token is the device code — so cosmetic
+ * output changes in either CLI degrade to "no URL yet" rather than to a
+ * crash. Auth *status*, by contrast, is read from the commands both CLIs
+ * commit to: `claude auth status --json` and `codex login status`.
+ *
+ * One flow per harness runs at a time. Flow state lives in this process and
+ * dies with it; the credentials themselves live where the harness put them,
+ * so a daemon restart mid-flow only means starting the flow again.
+ */
+import { spawn } from 'node:child_process';
+import os from 'node:os';
+import { resolveHarnessCommand } from "./harness-registry.js";
+/** Harnesses whose sign-in this module can run. Mirrors the shared
+ * HARNESS_AUTH_HARNESSES list; cli/ cannot import cloudflare/shared. */
+export const HARNESS_AUTH_HARNESSES = ['claude', 'codex'];
+const STATUS_TIMEOUT_MS = 30_000;
+const STATUS_CACHE_MS = 10_000;
+const FLOW_TIMEOUT_MS = 15 * 60_000;
+const OUTPUT_TAIL_LIMIT = 4_096;
+const ACTIVE_FLOW_STATUSES = new Set(['starting', 'awaiting_approval', 'awaiting_code']);
+/** Terminal control sequences stripped before any output is interpreted. */
+function stripAnsi(text) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: terminal escapes are control characters by definition
+    return String(text || '').replace(/\u001b\[[0-9;?]*[A-Za-z]/g, '');
+}
+/** The first https URL in a chunk of CLI output, if any. */
+export function extractLoginUrl(text) {
+    const match = stripAnsi(text).match(/https:\/\/[^\s"')\]]+/u);
+    return match ? match[0] : '';
+}
+/** A short hyphenated all-caps token on its own line: Codex's device code. */
+export function extractDeviceCode(text) {
+    for (const line of stripAnsi(text).split('\n')) {
+        const match = line.trim().match(/^([A-Z0-9]{3,8}-[A-Z0-9]{3,8})$/u);
+        if (match)
+            return match[1];
+    }
+    return '';
+}
+/** What `claude auth status --json` reported, from either exit status. The
+ * JSON object is cut out of the surrounding text rather than assumed to be
+ * the whole of it, because warnings can share the stream with the report. */
+export function parseClaudeAuthStatus(output) {
+    try {
+        const text = String(output || '');
+        const status = JSON.parse(text.slice(text.indexOf('{'), text.lastIndexOf('}') + 1));
+        if (typeof status?.loggedIn !== 'boolean')
+            return { authenticated: null };
+        const account = [status.email, status.subscriptionType ? `(${status.subscriptionType})` : '']
+            .filter(Boolean)
+            .join(' ');
+        return { authenticated: status.loggedIn, ...(account ? { account } : {}) };
+    }
+    catch {
+        return { authenticated: null };
+    }
+}
+/** What `codex login status` reported — on stderr, where codex prints it.
+ * The command has no JSON mode, so the two sentences it prints are the
+ * interface: "Logged in using …" and "Not logged in". Anything else is
+ * treated as unreadable rather than guessed. */
+export function parseCodexLoginStatus(output) {
+    const text = stripAnsi(output);
+    const loggedIn = text.match(/Logged in(?: using (.+?))?\s*$/mu);
+    if (loggedIn)
+        return { authenticated: true, ...(loggedIn[1] ? { account: loggedIn[1].trim() } : {}) };
+    if (/Not logged in/u.test(text))
+        return { authenticated: false };
+    return { authenticated: null };
+}
+/** Both streams interleaved: codex reports status on stderr, claude on stdout. */
+function runCommand(command, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {
+            cwd: os.homedir(),
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let output = '';
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { }
+            settle({ output, timedOut: true });
+        }, timeoutMs);
+        timer.unref?.();
+        const collect = (chunk) => {
+            if (output.length < 64 * 1024)
+                output += chunk;
+        };
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
+        child.on('error', () => settle({ output, failed: true }));
+        child.on('close', () => settle({ output }));
+    });
+}
+export function createHarnessAuthManager() {
+    /** One sign-in flow per harness, keyed by harness id. */
+    const flows = new Map();
+    /** Recent status answers, so a polling browser does not spawn a CLI per poll. */
+    const statusCache = new Map();
+    const flowSnapshot = (harness) => {
+        const flow = flows.get(harness);
+        if (!flow)
+            return { status: 'idle' };
+        return {
+            status: flow.status,
+            ...(flow.url ? { url: flow.url } : {}),
+            ...(flow.code ? { code: flow.code } : {}),
+            ...(flow.needsCode ? { needsCode: true } : {}),
+            ...(flow.error ? { error: flow.error } : {}),
+        };
+    };
+    const readStatus = async (harness) => {
+        const cached = statusCache.get(harness);
+        if (cached && Date.now() - cached.at < STATUS_CACHE_MS)
+            return cached.answer;
+        let answer = { authenticated: null };
+        try {
+            const command = resolveHarnessCommand(harness);
+            const args = harness === 'claude' ? ['auth', 'status', '--json'] : ['login', 'status'];
+            const run = await runCommand(command, args, STATUS_TIMEOUT_MS);
+            if (!run.failed && !run.timedOut) {
+                answer = harness === 'claude' ? parseClaudeAuthStatus(run.output) : parseCodexLoginStatus(run.output);
+            }
+        }
+        catch {
+            // An uninstalled harness reads as unknown, and the flow will say why.
+        }
+        statusCache.set(harness, { at: Date.now(), answer });
+        return answer;
+    };
+    const finishFlow = (harness, flow, status, error = '') => {
+        if (!flows.get(harness) || flows.get(harness) !== flow)
+            return;
+        flow.status = status;
+        flow.error = error || '';
+        clearTimeout(flow.timer);
+        // A finished flow changed (or failed to change) the credential store, so
+        // the next status question must ask the CLI rather than the cache.
+        statusCache.delete(harness);
+    };
+    const startFlow = (harness) => {
+        const existing = flows.get(harness);
+        if (existing && ACTIVE_FLOW_STATUSES.has(existing.status))
+            return;
+        const command = resolveHarnessCommand(harness);
+        const args = harness === 'claude' ? ['auth', 'login'] : ['login', '--device-auth'];
+        const flow = {
+            status: 'starting',
+            url: '',
+            code: '',
+            needsCode: false,
+            error: '',
+            tail: '',
+            child: null,
+            canceled: false,
+            timer: null,
+        };
+        flows.set(harness, flow);
+        const child = spawn(command, args, {
+            cwd: os.homedir(),
+            env: process.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        flow.child = child;
+        flow.timer = setTimeout(() => {
+            flow.canceled = true;
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { }
+            finishFlow(harness, flow, 'failed', 'The sign-in flow timed out.');
+        }, FLOW_TIMEOUT_MS);
+        flow.timer.unref?.();
+        const observe = (chunk) => {
+            const text = String(chunk);
+            flow.tail = (flow.tail + text).slice(-OUTPUT_TAIL_LIMIT);
+            if (!flow.url) {
+                const url = extractLoginUrl(text);
+                if (url) {
+                    flow.url = url;
+                    flow.needsCode = harness === 'claude';
+                    flow.status = flow.needsCode ? 'awaiting_code' : 'awaiting_approval';
+                }
+            }
+            if (harness === 'codex' && !flow.code) {
+                const code = extractDeviceCode(flow.tail);
+                if (code)
+                    flow.code = code;
+            }
+        };
+        child.stdout.on('data', observe);
+        child.stderr.on('data', observe);
+        child.on('error', (error) => finishFlow(harness, flow, 'failed', error?.message || 'The sign-in command failed.'));
+        child.on('close', (exitCode) => {
+            if (flow.status === 'failed')
+                return;
+            if (flow.canceled) {
+                flows.delete(harness);
+                return;
+            }
+            if (exitCode === 0)
+                finishFlow(harness, flow, 'succeeded');
+            else {
+                // The last output line is usually the CLI's own explanation. It has
+                // secrets stripped by the caller like every other error string.
+                const lines = stripAnsi(flow.tail).split('\n').map((line) => line.trim()).filter(Boolean);
+                finishFlow(harness, flow, 'failed', lines.at(-1) || 'The sign-in flow ended without succeeding.');
+            }
+        });
+    };
+    const submitCode = (harness, code) => {
+        const flow = flows.get(harness);
+        if (!flow || flow.status !== 'awaiting_code' || !flow.child?.stdin?.writable) {
+            throw new Error('No sign-in flow is waiting for a code.');
+        }
+        const line = String(code || '').trim();
+        if (!line)
+            throw new Error('The pasted code was empty.');
+        flow.child.stdin.write(`${line}\n`);
+        // The harness is now exchanging the code; only its exit says how it went.
+        flow.status = 'awaiting_approval';
+        flow.needsCode = false;
+    };
+    const cancelFlow = (harness) => {
+        const flow = flows.get(harness);
+        if (!flow)
+            return;
+        if (ACTIVE_FLOW_STATUSES.has(flow.status)) {
+            flow.canceled = true;
+            clearTimeout(flow.timer);
+            try {
+                flow.child?.kill('SIGTERM');
+            }
+            catch { }
+        }
+        flows.delete(harness);
+    };
+    /** Answer one action. Throws with a user-readable message on refusal. */
+    const handle = async ({ harness, action, code }) => {
+        if (!HARNESS_AUTH_HARNESSES.includes(harness)) {
+            throw new Error(`Sign-in is not supported for harness "${harness}".`);
+        }
+        if (action === 'login')
+            startFlow(harness);
+        else if (action === 'code')
+            submitCode(harness, code);
+        else if (action === 'cancel')
+            cancelFlow(harness);
+        else if (action !== 'status')
+            throw new Error(`Unknown harness auth action "${action}".`);
+        const flow = flowSnapshot(harness);
+        // While a flow is running its own status is the interesting part, and
+        // racing the CLI's status command against its login command helps no one.
+        const status = ACTIVE_FLOW_STATUSES.has(flow.status)
+            ? (statusCache.get(harness)?.answer ?? { authenticated: null })
+            : await readStatus(harness);
+        return { authenticated: status.authenticated, ...(status.account ? { account: status.account } : {}), flow };
+    };
+    const close = () => {
+        for (const harness of [...flows.keys()])
+            cancelFlow(harness);
+    };
+    return { handle, close };
+}

package/dist/queue-worker.js

@@ -5,11 +5,13 @@ import path from 'node:path';
 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 { 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 { createHarnessAuthManager } from "./harness-auth.js";
 import { nativeDescriptorAgentSessionId, nativeDescriptorWorkingDirectory } from "./local-session-sources.js";
 import { compactRuntimeValue } from "./native-record-compaction.js";
 import { createSecretRedactor } from "./secret-redaction.js";
@@ -742,6 +744,8 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 expectedText: claim.prompt.text,
                 createSession: creating,
                 permissionMode: String(claim.session?.permissionMode || 'bypassPermissions'),
+                model: String(claim.session?.model || ''),
+                thinkingLevel: String(claim.session?.modelEffort || ''),
                 codexHistoryMode: String(claim.session?.codexHistoryMode || ''),
                 timeoutMs: QUEUE_TURN_TIMEOUT_MS,
                 idleTimeoutMs: QUEUE_WARM_MS,
@@ -1206,6 +1210,74 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             });
         }
     };
+    /**
+     * Answer one harness sign-in question or action for this machine.
+     *
+     * Like browsing, sign-in is a property of the machine rather than of a
+     * session: the session only names which machine and harness the viewer
+     * means. The answer's `flow.url` and `flow.code` deliberately skip the
+     * redactor — they exist to be shown to the user, and the redactor would
+     * mangle an OAuth URL's `state` and `code_challenge` parameters — while
+     * error strings stay redacted like every other handler's.
+     */
+    const harnessAuth = createHarnessAuthManager();
+    const handleHarnessAuth = async (message, replyRpc) => {
+        const sessionId = String(message.sessionId || '');
+        const harness = String(message.harness || '');
+        try {
+            const answer = await harnessAuth.handle({
+                harness,
+                action: String(message.action || 'status'),
+                code: String(message.code || ''),
+            });
+            if (answer.flow?.error)
+                answer.flow.error = redactor.redactText(answer.flow.error);
+            replyRpc.notify({
+                type: 'session.harness.auth.result',
+                requestId: message.requestId,
+                sessionId,
+                harness,
+                ok: true,
+                answer,
+            });
+        }
+        catch (error) {
+            replyRpc.notify({
+                type: 'session.harness.auth.result',
+                requestId: message.requestId,
+                sessionId,
+                harness,
+                ok: false,
+                error: redactor.redactText(error?.message || String(error)),
+            });
+        }
+    };
+    /** Upgrade the machine's Codex installation. Only this fixed, resolved
+     * command is exposed; the browser cannot supply a binary, arguments, or
+     * shell input. Errors are redacted before crossing the machine boundary. */
+    const codexUpdate = createCodexUpdateManager();
+    const handleCodexUpdate = async (message, replyRpc) => {
+        const sessionId = String(message.sessionId || '');
+        try {
+            const answer = await codexUpdate.update();
+            replyRpc.notify({
+                type: 'session.codex.update.result',
+                requestId: message.requestId,
+                sessionId,
+                ok: true,
+                answer,
+            });
+        }
+        catch (error) {
+            replyRpc.notify({
+                type: 'session.codex.update.result',
+                requestId: message.requestId,
+                sessionId,
+                ok: false,
+                error: redactor.redactText(error?.message || String(error)),
+            });
+        }
+    };
     /**
      * Apply one queued browser edit, and report how it went.
      *
@@ -1282,6 +1354,10 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             void handleFileSearch(message, rpc);
         if (message.type === 'session.git.read.request')
             void handleGitRead(message, rpc);
+        if (message.type === 'session.harness.auth.request')
+            void handleHarnessAuth(message, rpc);
+        if (message.type === 'session.codex.update.request')
+            void handleCodexUpdate(message, rpc);
         if (message.type === 'session.file.edit.request')
             void handleFileEdit(message, rpc);
     });
@@ -1296,7 +1372,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 type: 'machine.register',
                 machineId: machine,
                 machineHostname: os.hostname(),
-                capabilities: { fileSearch: true, git: true, fileRanges: true },
+                capabilities: { fileSearch: true, git: true, fileRanges: true, harnessAuth: true, codexUpdate: true },
                 workerId,
                 workerInstanceId,
                 anchorSessionIds: [...anchors.keys()],

package/package.json

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