@turns/dev 0.0.10 → 0.0.12

package/README.md

@@ -73,10 +73,17 @@ bounds a deliberately broad matcher: prose that merely looks like a path
 resolves to nothing and is never mentioned to the server, and no directory is
 ever scanned.
 
-An explicit file browse may upload up to 199 MB to the same private R2 prefix.
+An explicit file browse may upload up to 2 GiB to the same private R2 prefix.
+Files over 100 MiB use retryable 32 MiB multipart requests and report upload
+progress to the requesting browser over the control WebSocket.
 The daemon streams the file from disk and the Worker hands that request stream
 straight to R2, so neither process retains the complete file in memory.
 
+Range-based viewers can bypass that upload. A capable daemon advertises live
+file ranges, validates the path through the same allowlist, and streams a
+bounded window as ordered 32 KiB WebSocket chunks. The browser hex view pages
+64 KiB viewport windows, including arbitrary offset jumps.
+
 The systemd unit uses `KillMode=process`, and the macOS LaunchAgent uses
 `AbandonProcessGroup`: restarting the uploader leaves its detached agent-anchor
 processes running so in-flight harness turns continue.

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/file-browsing.js

@@ -17,10 +17,19 @@ import { uploadFileStream } from "./path-resolution.js";
  */
 /** Kept in step with `MAX_DIRECTORY_ENTRIES` in the Worker's shared listing. */
 export const MAX_DIRECTORY_ENTRIES = 2_000;
-/** One MB below the Worker request-body ceiling, matching the R2 endpoint. */
-export const MAX_BROWSE_FILE_BYTES = 199 * 1024 * 1024;
+/** Kept in step with `MAX_FILE_BYTES` on the server. Multipart transport keeps
+ * each individual Worker request below the platform request-body ceiling. */
+export const MAX_BROWSE_FILE_BYTES = 2 * 1024 * 1024 * 1024;
 /** The derived label used in reader-facing errors. */
-export const BROWSE_FILE_LIMIT_LABEL = `${Math.round(MAX_BROWSE_FILE_BYTES / (1024 * 1024))} MB`;
+export const BROWSE_FILE_LIMIT_LABEL = `${MAX_BROWSE_FILE_BYTES / (1024 * 1024 * 1024)} GB`;
+/** Frequent filesystem chunks are useful for accurate accounting but noisy on
+ * a control socket. Four frames per second plus phase boundaries stays smooth. */
+export const BROWSE_PROGRESS_INTERVAL_MS = 250;
+/** One browser range request is deliberately small enough to remain cheap to
+ * retry or abandon when a reader scrolls quickly through a large file. */
+export const MAX_BROWSE_RANGE_BYTES = 256 * 1024;
+/** Raw bytes per WebSocket payload. Base64 expands this to roughly 43 KiB. */
+export const BROWSE_RANGE_CHUNK_BYTES = 32 * 1024;
 /** Enough data to distinguish source and prose from arbitrary binary bytes
  * without reading a large artifact into the daemon's memory. */
 export const FILE_TYPE_SAMPLE_BYTES = 64 * 1024;
@@ -173,7 +182,50 @@ export function readDirectory(directory) {
     // clock inside the body would make every read produce different bytes.
     return { path: directory, entries, truncated: names.length > MAX_DIRECTORY_ENTRIES };
 }
-export async function browseMachinePath({ requested, machine, baseUrl, options, workingDirectory = '', contentEtag = '', fetchImpl = fetch, }) {
+/** Stream one bounded file window without creating or updating its R2 object. */
+export async function streamMachineFileRange({ requested, offset, length, workingDirectory = '', allowedDirectories = [], onReady, onChunk, }) {
+    if (!Number.isSafeInteger(offset) || offset < 0)
+        throw new Error('Invalid file range offset.');
+    if (!Number.isSafeInteger(length) || length <= 0 || length > MAX_BROWSE_RANGE_BYTES) {
+        throw new Error('Invalid file range length.');
+    }
+    const resolved = resolveBrowsePath(requested, { workingDirectory, allowedDirectories });
+    if (!resolved.stat.isFile())
+        throw new Error(`Not a readable file: ${resolved.path}`);
+    if (resolved.stat.size > MAX_BROWSE_FILE_BYTES) {
+        throw new Error(`File is larger than the ${BROWSE_FILE_LIMIT_LABEL} browse limit.`);
+    }
+    if (offset > resolved.stat.size)
+        throw new Error('File range starts beyond the end of the file.');
+    const boundedLength = Math.min(length, resolved.stat.size - offset);
+    const sample = readFileTypeSample(resolved.path, resolved.stat.size);
+    const range = {
+        path: resolved.path,
+        offset,
+        length: boundedLength,
+        totalBytes: resolved.stat.size,
+        contentType: browseContentType(resolved.path, sample, sample.byteLength === resolved.stat.size),
+        modifiedAt: isoTime(resolved.stat.mtimeMs),
+    };
+    onReady(range);
+    if (!boundedLength)
+        return range;
+    const stream = fs.createReadStream(resolved.path, {
+        start: offset,
+        end: offset + boundedLength - 1,
+        highWaterMark: BROWSE_RANGE_CHUNK_BYTES,
+    });
+    let chunkOffset = offset;
+    for await (const value of stream) {
+        const chunk = value;
+        onChunk(chunkOffset, chunk);
+        chunkOffset += chunk.byteLength;
+    }
+    if (chunkOffset !== offset + boundedLength)
+        throw new Error('The file changed while its byte range was being read.');
+    return range;
+}
+export async function browseMachinePath({ requested, machine, baseUrl, options, workingDirectory = '', contentEtag = '', onUploadProgress, fetchImpl = fetch, }) {
     const resolved = resolveBrowsePath(requested, {
         workingDirectory,
         allowedDirectories: options.allowedDirectories || [],
@@ -201,6 +253,20 @@ export async function browseMachinePath({ requested, machine, baseUrl, options,
     const modifiedAt = isoTime(resolved.stat.mtimeMs);
     if (resolved.stat.size === 0)
         return { path: resolved.path, kind: 'file', bytes: 0, contentType, modifiedAt };
+    let lastProgressAt = 0;
+    let lastUploadedBytes = -1;
+    const reportProgress = (phase, uploadedBytes, force = false) => {
+        if (!onUploadProgress)
+            return;
+        const bounded = Math.max(lastUploadedBytes, Math.min(resolved.stat.size, Math.max(0, uploadedBytes)));
+        const now = Date.now();
+        if (!force && now - lastProgressAt < BROWSE_PROGRESS_INTERVAL_MS && bounded < resolved.stat.size)
+            return;
+        lastProgressAt = now;
+        lastUploadedBytes = bounded;
+        onUploadProgress({ path: resolved.path, phase, uploadedBytes: bounded, totalBytes: resolved.stat.size });
+    };
+    reportProgress('starting', 0, true);
     await uploadFileStream({
         baseUrl,
         options,
@@ -210,6 +276,8 @@ export async function browseMachinePath({ requested, machine, baseUrl, options,
         bytes: resolved.stat.size,
         modifiedAt,
         ...(contentEtag ? { contentEtag } : {}),
+        onProgress: (uploadedBytes) => reportProgress('uploading', uploadedBytes),
+        onFinalizing: () => reportProgress('finalizing', resolved.stat.size, true),
         fetchImpl,
     });
     return { path: resolved.path, kind: 'file', bytes: resolved.stat.size, contentType, modifiedAt };

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/path-resolution.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { Transform } from 'node:stream';
 /**
  * Turning the paths an agent writes into things a reader can open.
  *
@@ -180,6 +181,178 @@ function fileUploadUrl(baseUrl, machine, absolutePath) {
             : encoded;
     return new URL(`/api/file/${encodeURIComponent(machine)}/${encodedPath}`, String(baseUrl));
 }
+/** Kept in step with the explicit-browse transport constants in shared/files.ts. */
+export const MAX_SINGLE_BROWSE_UPLOAD_BYTES = 100 * 1024 * 1024;
+export const BROWSE_MULTIPART_PART_BYTES = 32 * 1024 * 1024;
+export const MAX_BROWSE_MULTIPART_PARTS = 64;
+export function filePartRanges(bytes, partSize = BROWSE_MULTIPART_PART_BYTES) {
+    if (!Number.isSafeInteger(bytes) || bytes <= 0 || !Number.isSafeInteger(partSize) || partSize <= 0)
+        return [];
+    const ranges = [];
+    for (let start = 0, partNumber = 1; start < bytes; start += partSize, partNumber += 1) {
+        ranges.push({ partNumber, start, end: Math.min(bytes, start + partSize) });
+    }
+    return ranges;
+}
+function fileMultipartUrl(baseUrl, machine, absolutePath, suffix = '') {
+    const url = new URL(`/api/file-multipart/${encodeURIComponent(machine)}${suffix}`, String(baseUrl));
+    url.searchParams.set('path', absolutePath);
+    return url;
+}
+function progressStream(absolutePath, start, end, onProgress) {
+    const source = fs.createReadStream(absolutePath, { start, end: end - 1 });
+    let loaded = 0;
+    const body = new Transform({
+        transform(chunk, _encoding, callback) {
+            loaded += chunk.byteLength;
+            onProgress?.(loaded);
+            callback(null, chunk);
+        },
+    });
+    source.pipe(body);
+    return {
+        body,
+        destroy() {
+            source.destroy();
+            body.destroy();
+        },
+    };
+}
+async function uploadFailure(response, label) {
+    const detail = (await response.text().catch(() => '')).trim();
+    return new Error(`${label} (${response.status})${detail ? `: ${detail.slice(0, 500)}` : '.'}`);
+}
+function retryDelay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function uploadMultipartFile({ baseUrl, options, machine, absolutePath, contentType, bytes, modifiedAt, contentEtag, onProgress, onFinalizing, fetchImpl, }) {
+    const createUrl = fileMultipartUrl(baseUrl, machine, absolutePath);
+    const createBody = JSON.stringify({
+        size: bytes,
+        contentType,
+        ...(modifiedAt ? { modifiedAt } : {}),
+        ...(contentEtag ? { contentEtag } : {}),
+    });
+    const created = await fetchImpl(createUrl, {
+        method: 'POST',
+        headers: {
+            ...uploadHeaders(options),
+            'content-type': 'application/json',
+            'content-length': String(Buffer.byteLength(createBody)),
+        },
+        body: createBody,
+    });
+    if (!created.ok)
+        throw await uploadFailure(created, 'Multipart file upload could not start');
+    const payload = (await created.json().catch(() => ({})));
+    const uploadId = String(payload.upload?.uploadId || '');
+    const partSize = Number(payload.upload?.partSize);
+    const receiptToken = String(payload.upload?.receiptToken || '');
+    if (!uploadId ||
+        !receiptToken ||
+        !Number.isSafeInteger(partSize) ||
+        partSize <= 0 ||
+        partSize > BROWSE_MULTIPART_PART_BYTES) {
+        throw new Error('Multipart file upload returned an invalid session.');
+    }
+    const ranges = filePartRanges(bytes, partSize);
+    if (!ranges.length || ranges.length > MAX_BROWSE_MULTIPART_PARTS) {
+        throw new Error('Multipart file upload returned an invalid part size.');
+    }
+    const parts = [];
+    let completed = 0;
+    try {
+        for (const range of ranges) {
+            const length = range.end - range.start;
+            let receipt = null;
+            let greatestLoaded = 0;
+            let lastError = null;
+            for (let attempt = 0; attempt < 3 && !receipt; attempt += 1) {
+                const stream = progressStream(absolutePath, range.start, range.end, (loaded) => {
+                    greatestLoaded = Math.max(greatestLoaded, loaded);
+                    onProgress?.(Math.min(bytes, completed + greatestLoaded));
+                });
+                try {
+                    const partUrl = fileMultipartUrl(baseUrl, machine, absolutePath, `/parts/${range.partNumber}`);
+                    partUrl.searchParams.set('upload_id', uploadId);
+                    const response = await fetchImpl(partUrl, {
+                        method: 'PUT',
+                        headers: {
+                            ...uploadHeaders(options),
+                            'content-type': 'application/octet-stream',
+                            'content-length': String(length),
+                        },
+                        body: stream.body,
+                        duplex: 'half',
+                    });
+                    if (!response.ok)
+                        throw await uploadFailure(response, `Multipart file part ${range.partNumber} failed`);
+                    const answer = (await response.json().catch(() => ({})));
+                    if (answer.part?.partNumber !== range.partNumber || !answer.part.etag) {
+                        throw new Error(`Multipart file part ${range.partNumber} returned no receipt.`);
+                    }
+                    receipt = { partNumber: range.partNumber, etag: String(answer.part.etag) };
+                }
+                catch (error) {
+                    lastError = error;
+                    if (attempt < 2)
+                        await retryDelay(250 * 2 ** attempt);
+                }
+                finally {
+                    stream.destroy();
+                }
+            }
+            if (!receipt)
+                throw lastError instanceof Error ? lastError : new Error(String(lastError || 'File part failed.'));
+            parts.push(receipt);
+            completed += length;
+            onProgress?.(completed);
+        }
+        const completeUrl = fileMultipartUrl(baseUrl, machine, absolutePath, '/complete');
+        completeUrl.searchParams.set('upload_id', uploadId);
+        const completeBody = JSON.stringify({ parts, size: bytes, receiptToken });
+        onFinalizing?.();
+        let completedUpload = false;
+        let completionError = null;
+        for (let attempt = 0; attempt < 3 && !completedUpload; attempt += 1) {
+            try {
+                const response = await fetchImpl(completeUrl, {
+                    method: 'POST',
+                    headers: {
+                        ...uploadHeaders(options),
+                        'content-type': 'application/json',
+                        'content-length': String(Buffer.byteLength(completeBody)),
+                    },
+                    body: completeBody,
+                });
+                if (!response.ok) {
+                    const failure = await uploadFailure(response, 'Multipart file upload could not finish');
+                    if (response.status < 500 && response.status !== 408 && response.status !== 429)
+                        throw failure;
+                    completionError = failure;
+                }
+                else {
+                    completedUpload = true;
+                }
+            }
+            catch (error) {
+                completionError = error;
+            }
+            if (!completedUpload && attempt < 2)
+                await retryDelay(250 * 2 ** attempt);
+        }
+        if (!completedUpload) {
+            throw completionError instanceof Error ? completionError : new Error('Multipart file upload could not finish.');
+        }
+        return true;
+    }
+    catch (error) {
+        const abortUrl = fileMultipartUrl(baseUrl, machine, absolutePath);
+        abortUrl.searchParams.set('upload_id', uploadId);
+        await fetchImpl(abortUrl, { method: 'DELETE', headers: uploadHeaders(options) }).catch(() => { });
+        throw error;
+    }
+}
 /**
  * Put bytes in the account's private prefix, under the path they came from.
  *
@@ -204,9 +377,31 @@ export async function uploadFileBytes({ baseUrl, options, machine, absolutePath,
     return true;
 }
 /** Stream one on-disk file to R2 without retaining its body in the daemon. */
-export async function uploadFileStream({ baseUrl, options, machine, absolutePath, contentType, bytes, modifiedAt, contentEtag, fetchImpl = fetch, }) {
+export async function uploadFileStream({ baseUrl, options, machine, absolutePath, contentType, bytes, modifiedAt, contentEtag, onProgress, onFinalizing, fetchImpl = fetch, }) {
+    if (bytes > MAX_SINGLE_BROWSE_UPLOAD_BYTES) {
+        return uploadMultipartFile({
+            baseUrl,
+            options,
+            machine,
+            absolutePath,
+            contentType,
+            bytes,
+            modifiedAt,
+            contentEtag,
+            onProgress,
+            onFinalizing,
+            fetchImpl,
+        });
+    }
     const url = fileUploadUrl(baseUrl, machine, absolutePath);
-    const body = fs.createReadStream(absolutePath);
+    let finalizing = false;
+    const stream = progressStream(absolutePath, 0, bytes, (uploadedBytes) => {
+        onProgress?.(uploadedBytes);
+        if (!finalizing && uploadedBytes >= bytes) {
+            finalizing = true;
+            onFinalizing?.();
+        }
+    });
     try {
         const response = await fetchImpl(url, {
             method: 'PUT',
@@ -217,7 +412,7 @@ export async function uploadFileStream({ baseUrl, options, machine, absolutePath
                 ...(modifiedAt ? { 'x-turns-file-modified-at': modifiedAt } : {}),
                 ...(contentEtag ? { 'x-turns-content-etag': contentEtag } : {}),
             },
-            body,
+            body: stream.body,
             // Node requires this opt-in for a streaming request body.
             duplex: 'half',
         });
@@ -226,7 +421,7 @@ export async function uploadFileStream({ baseUrl, options, machine, absolutePath
         return true;
     }
     finally {
-        body.destroy();
+        stream.destroy();
     }
 }
 /** Send one resolved file to the account's private prefix. */

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 } from "./file-browsing.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,
@@ -1052,6 +1056,14 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 baseUrl,
                 options,
                 workingDirectory: await browseWorkingDirectory(sessionId),
+                onUploadProgress: (progress) => {
+                    replyRpc.notify({
+                        type: 'session.file.browse.progress',
+                        requestId: message.requestId,
+                        sessionId,
+                        ...progress,
+                    });
+                },
             });
             replyRpc.notify({
                 type: 'session.file.browse.result',
@@ -1071,6 +1083,57 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             });
         }
     };
+    /** Stream a small file window over the control socket. This never writes R2;
+     * range-based viewers can therefore paint before a multi-gigabyte upload. */
+    const handleFileRange = async (message, replyRpc) => {
+        const sessionId = String(message.sessionId || '');
+        let canonicalPath = '';
+        try {
+            await streamMachineFileRange({
+                requested: String(message.path || ''),
+                offset: Number(message.offset),
+                length: Number(message.length),
+                workingDirectory: await browseWorkingDirectory(sessionId),
+                allowedDirectories: options.allowedDirectories || [],
+                onReady: (range) => {
+                    canonicalPath = range.path;
+                    replyRpc.notify({
+                        type: 'session.file.range.ready',
+                        requestId: message.requestId,
+                        sessionId,
+                        ...range,
+                    });
+                },
+                onChunk: (offset, bytes) => {
+                    replyRpc.notify({
+                        type: 'session.file.range.chunk',
+                        requestId: message.requestId,
+                        sessionId,
+                        path: canonicalPath,
+                        offset,
+                        data: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64'),
+                    });
+                },
+            });
+            replyRpc.notify({
+                type: 'session.file.range.result',
+                requestId: message.requestId,
+                sessionId,
+                path: canonicalPath,
+                ok: true,
+            });
+        }
+        catch (error) {
+            replyRpc.notify({
+                type: 'session.file.range.result',
+                requestId: message.requestId,
+                sessionId,
+                ...(canonicalPath ? { path: canonicalPath } : {}),
+                ok: false,
+                error: redactor.redactText(error?.message || String(error)),
+            });
+        }
+    };
     /** Refresh recursive path-name matches for directory typeahead.
      *
      * Like browsing, this is a machine filesystem operation rather than a
@@ -1147,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.
      *
@@ -1217,10 +1348,16 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             void handleInteractionAnswer(message, rpc);
         if (message.type === 'session.file.browse.request')
             void handleFileBrowse(message, rpc);
+        if (message.type === 'session.file.range.request')
+            void handleFileRange(message, rpc);
         if (message.type === 'session.file.search.request')
             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);
     });
@@ -1235,7 +1372,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 type: 'machine.register',
                 machineId: machine,
                 machineHostname: os.hostname(),
-                capabilities: { fileSearch: true, git: true },
+                capabilities: { fileSearch: true, git: true, fileRanges: true, harnessAuth: true, codexUpdate: true },
                 workerId,
                 workerInstanceId,
                 anchorSessionIds: [...anchors.keys()],

package/dist/upload-sessions.js

@@ -946,8 +946,9 @@ function gitAssociationForSession(cwd, redactor) {
  * @param {number} [options.maxBatches]
  * @param {() => boolean} [options.shouldYield]
  * @param {boolean} [options.recoverRemoteAhead]
+ * @param {boolean} [options.forceReset]
  */
-export async function uploadNativeSession(rpc, machine, descriptor, cursor = {}, onProgress = () => { }, redactor = DEFAULT_REDACTOR, { maxBatches = Number.POSITIVE_INFINITY, shouldYield = () => false, recoverRemoteAhead = true, onPathCandidates = (_sessionId, _workingDirectory, _candidates) => { }, } = {}) {
+export async function uploadNativeSession(rpc, machine, descriptor, cursor = {}, onProgress = () => { }, redactor = DEFAULT_REDACTOR, { maxBatches = Number.POSITIVE_INFINITY, shouldYield = () => false, recoverRemoteAhead = true, forceReset = false, onPathCandidates = (_sessionId, _workingDirectory, _candidates) => { }, } = {}) {
     const workingDirectory = await nativeDescriptorWorkingDirectory(descriptor);
     const agentSessionId = await nativeDescriptorAgentSessionId(descriptor);
     const git = gitAssociationForSession(workingDirectory, redactor);
@@ -976,7 +977,14 @@ export async function uploadNativeSession(rpc, machine, descriptor, cursor = {},
     const uploadSessionId = String(opened.sessionId || sessionId);
     let nextRow = Number(opened.nextRow) || 0;
     let initialUpload = nextRow === 0 || cursor.initialUpload === true;
-    if (Number(opened.redactionVersion || 0) !== REDACTION_VERSION) {
+    if (forceReset && nextRow > 0) {
+        await rpc.request({ type: 'session.reset', sessionId: uploadSessionId, redactionVersion: REDACTION_VERSION });
+        nextRow = 0;
+        for (const key of Object.keys(cursor))
+            delete cursor[key];
+        initialUpload = true;
+    }
+    else if (Number(opened.redactionVersion || 0) !== REDACTION_VERSION) {
         await rpc.request({ type: 'session.reset', sessionId: uploadSessionId, redactionVersion: REDACTION_VERSION });
         nextRow = 0;
         for (const key of Object.keys(cursor))

package/package.json

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