handmux 0.27.2 → 0.29.0

package/dist/src/codexAppServer.js

@@ -460,13 +460,22 @@ function turnPrompt(turn) {
     }
     return '';
 }
+function currentTurnId(state, remembered = state?.activeTurnId) {
+    // Native history can retain unfinished internal turns after the thread is idle (for example /review).
+    // Historical turn records must never override the authoritative current thread lifecycle.
+    if ((state?.status || state?.thread?.status)?.type === 'idle')
+        return null;
+    return remembered || [...(state?.thread?.turns || [])].reverse()
+        .find((turn) => turn.status === 'inProgress')?.id || null;
+}
 function activeTurnPrompt(state) {
+    if ((state?.status || state?.thread?.status)?.type === 'idle')
+        return '';
+    const turnId = currentTurnId(state);
     if (state?.activePrompt)
         return state.activePrompt;
     const turns = Array.isArray(state?.thread?.turns) ? state.thread.turns : [];
-    const active = state?.activeTurnId
-        ? turns.find((turn) => turn.id === state.activeTurnId)
-        : [...turns].reverse().find((turn) => turn.status === 'inProgress');
+    const active = turns.find((turn) => turn.id === turnId);
     return turnPrompt(active);
 }
 function activeKind(status) {
@@ -867,6 +876,10 @@ class CodexAppConnection {
         else if (message.method === 'thread/status/changed') {
             const state = this.state(params.threadId);
             state.status = params.status ?? null;
+            if (state.status?.type === 'idle') {
+                state.activeTurnId = null;
+                state.activePrompt = '';
+            }
             const kind = activeKind(params.status);
             if (!this.isCurrentThread(params.threadId)) {
                 /* retain the state for that thread, but never let a late background event rebind this pane */
@@ -931,11 +944,10 @@ class CodexAppConnection {
             // Native Goal notifications do not consistently carry turnId. Bind every live lifecycle transition
             // to the turn that is currently producing it so an active Goal set before the first item event cannot
             // later mistake that same turn for its next durable injection opportunity.
-            const state = this.state(params.threadId);
             const notifiedGoal = parseCodexGoal(params.goal);
             const pendingTurnId = this.pendingGoalTurn(params.threadId);
             const turnId = params.turnId
-                || (pendingTurnId !== undefined ? pendingTurnId : state.activeTurnId)
+                || (pendingTurnId !== undefined ? pendingTurnId : this.activeTurn(params.threadId))
                 || null;
             this.applyGoalSnapshot(params.threadId, notifiedGoal, turnId, { emitClear: true });
         }
@@ -1349,9 +1361,7 @@ class CodexAppConnection {
     }
     activeTurn(threadId) {
         const state = this.state(threadId);
-        return state.activeTurnId
-            || [...(state.thread?.turns || [])].reverse().find((turn) => turn.status === 'inProgress')?.id
-            || null;
+        return currentTurnId(state);
     }
     beginGoalMutation(threadId) {
         const mutation = { token: Symbol('goal-mutation'), turnId: this.activeTurn(threadId) };
@@ -2356,8 +2366,7 @@ class CodexAppConnection {
                 state.status = resumedThread?.status || state.status;
                 const previousActiveTurnId = state.activeTurnId;
                 const previousActivePrompt = state.activePrompt;
-                state.activeTurnId = [...(resumedThread?.turns || [])].reverse()
-                    .find((turn) => turn.status === 'inProgress')?.id || null;
+                state.activeTurnId = currentTurnId(state, null);
                 const resumedPrompt = state.activeTurnId
                     ? turnPrompt((resumedThread?.turns || []).find((turn) => turn.id === state.activeTurnId))
                     : '';
@@ -2439,7 +2448,8 @@ class CodexAppConnection {
         // base snapshot still applies, and the cache now represents that current combined projection.
         state.readRevision = state.revision;
         state.status = fresh?.status || state.status;
-        const active = [...(state.thread?.turns || [])].reverse().find((turn) => turn.status === 'inProgress');
+        const activeId = currentTurnId(state, null);
+        const active = state.thread?.turns?.find((turn) => turn.id === activeId);
         const previousActiveTurnId = state.activeTurnId;
         const previousActivePrompt = state.activePrompt;
         state.activeTurnId = active?.id || null;
@@ -3418,12 +3428,12 @@ export function createCodexAppServer({ home, connect = connectUnixWebSocket, exi
             if (!client)
                 throw new Error('Codex session is not managed by Handmux');
             await client.assertCurrentThread(threadId);
-            const state = await client.ensureThread(threadId);
-            let turnId = state.activeTurnId;
+            await client.ensureThread(threadId);
+            let turnId = client.activeTurn(threadId);
             if (!turnId) {
-                const thread = await client.readThread(threadId);
+                await client.readThread(threadId);
                 client.requireCurrentThread(threadId);
-                turnId = [...(thread?.turns || [])].reverse().find((turn) => turn.status === 'inProgress')?.id || null;
+                turnId = client.activeTurn(threadId);
             }
             if (!turnId)
                 return { interrupted: false };

package/dist/src/codexTranscriptParse.js

@@ -376,6 +376,36 @@ function applyPatchCalls(patch) {
         };
     });
 }
+const isImageViewTool = (name) => name === 'view_image' || name === 'functions.view_image';
+// Only literal path/cwd fields are evidence of a file location. The generic source parser deliberately
+// keeps unknown JavaScript expressions as strings, which must never become download paths.
+function imageToolInput(script, raw, before) {
+    const input = asRecord(parseToolInput(script, raw, before));
+    delete input.path;
+    delete input.cwd;
+    const value = raw.trim();
+    if (!value.startsWith('{') || !value.endsWith('}'))
+        return input;
+    for (const field of splitTopLevel(value.slice(1, -1), ',')) {
+        if (/^(\.\.\.|\[|get\s|set\s)/.test(field.trim())) {
+            delete input.path;
+            delete input.cwd;
+            continue;
+        }
+        const pieces = splitTopLevel(field, ':');
+        const key = pieces.shift()?.trim() || '';
+        const name = decodeJsString(key) ?? key;
+        if (name !== 'path' && name !== 'cwd')
+            continue;
+        const expression = pieces.join(':').trim();
+        const literal = stringTokenAt(expression, 0) === expression ? decodeJsString(expression) : null;
+        if (literal !== null)
+            input[name] = literal;
+        else
+            delete input[name];
+    }
+    return input;
+}
 function extractCustomCalls(script) {
     const calls = [];
     const re = /tools\.([A-Za-z][\w]*)\s*\(/g;
@@ -394,7 +424,8 @@ function extractCustomCalls(script) {
                 : applyPatchCalls(decoded)));
         }
         else {
-            calls.push({ name, input: parseToolInput(script, arg.text, match.index) });
+            calls.push({ name, input: isImageViewTool(name)
+                    ? imageToolInput(script, arg.text, match.index) : parseToolInput(script, arg.text, match.index) });
         }
         re.lastIndex = arg.end;
     }
@@ -595,6 +626,14 @@ export function createCodexTranscriptParser() {
                 const ts = typeof row.timestamp === 'string' ? row.timestamp : undefined;
                 if (row.type === 'event_msg') {
                     const payload = asRecord(row.payload);
+                    const payloadError = asRecord(payload.error);
+                    if (payload.type === 'task_complete' && typeof payloadError.message === 'string'
+                        && payloadError.message.trim()) {
+                        messages.push({
+                            i, type: 'notice', noticeLevel: 'warning', text: payloadError.message.trim(), ts,
+                            ...(typeof payload.turn_id === 'string' && payload.turn_id ? { turnId: payload.turn_id } : {}),
+                        });
+                    }
                     adjacentUserClientId = payload.type === 'user_message'
                         && typeof payload.client_id === 'string' && payload.client_id
                         ? payload.client_id : undefined;

package/dist/src/codexUsageSnapshot.js

@@ -45,7 +45,7 @@ function normalize(record) {
     const rawLimits = isRecord(payload.rate_limits) ? payload.rate_limits : {};
     // A rollout may carry a model-specific limit (for example GPT-5.3-Codex-Spark's
     // `codex_bengalfox`) instead of the account's main Codex limit. Keep its token/context data, but never
-    // project that independent percentage as the generic Codex quota shown by HandMux.
+    // project that independent percentage as the generic Codex quota shown by handmux.
     const limitId = typeof rawLimits.limit_id === 'string' ? rawLimits.limit_id : null;
     const limits = limitId === null || limitId === 'codex' ? rawLimits : {};
     return {

package/dist/src/deviceAccess.js

@@ -0,0 +1,134 @@
+import { networkInterfaces } from 'node:os';
+import { originPatternMatches } from './deviceAuth/service.js';
+import { readSessionSecret } from './deviceAuth/service.js';
+import { setSessionCookie } from './deviceAuth/http.js';
+import { withRequestAuthority } from './requestAuthority.js';
+import { bearerFrom } from './auth.js';
+import { requestOrigin } from './requestOrigin.js';
+/** Host and forwarded headers select a known entry point; they never create a trusted origin. */
+export function createAuthOriginResolver({ port, host, publicUrl, previewDomain, trustedOrigins = () => [], runtimePublicUrl = () => null, trustedOriginEnabled = () => true, }) {
+    const local = new Set();
+    const add = (hostname) => {
+        if (!hostname || hostname === '0.0.0.0' || hostname === '::')
+            return;
+        try {
+            local.add(new URL(`http://${hostname.includes(':') ? `[${hostname}]` : hostname}:${port}`).origin);
+        }
+        catch { }
+    };
+    for (const hostname of ['localhost', '127.0.0.1', '::1', host])
+        add(hostname);
+    const configuredPatterns = [];
+    if (previewDomain) {
+        try {
+            const url = new URL(/^https?:\/\//i.test(previewDomain) ? previewDomain : `https://${previewDomain}`);
+            if (url.hostname && !url.hostname.includes('*'))
+                configuredPatterns.push(`https://*.${url.hostname}`);
+        }
+        catch { /* an invalid preview domain is rejected by its own setup validation */ }
+    }
+    for (const entries of Object.values(networkInterfaces())) {
+        for (const entry of entries ?? [])
+            if (!entry.address.includes('%'))
+                add(entry.address);
+    }
+    return (req) => {
+        const origin = requestOrigin(req);
+        if (!origin)
+            return null;
+        // Origin restriction is an independent policy. Even when disabled, return the
+        // syntactically valid request origin so authentication can proceed with Token
+        // (and, when enabled, a trusted-device cookie).
+        if (!trustedOriginEnabled())
+            return origin;
+        if (local.has(origin))
+            return origin;
+        for (const known of [publicUrl, runtimePublicUrl()]) {
+            if (!known)
+                continue;
+            try {
+                const url = new URL(known);
+                if (!url.username && !url.password && ['http:', 'https:'].includes(url.protocol) && url.origin === origin)
+                    return origin;
+            }
+            catch { }
+        }
+        for (const pattern of [...configuredPatterns, ...trustedOrigins()]) {
+            if (!pattern)
+                continue;
+            if (originPatternMatches(pattern, origin))
+                return origin;
+        }
+        return null;
+    };
+}
+export function createDeviceAccess({ service, resolveOrigin }) {
+    const responses = new Map();
+    const stop = service.onRevoke((deviceId) => {
+        for (const res of responses.get(deviceId) ?? [])
+            res.destroy();
+        responses.delete(deviceId);
+    });
+    const authenticate = (req) => {
+        const origin = resolveOrigin(req);
+        if (!origin)
+            return null;
+        const device = service.authenticateRequest(req, origin);
+        const token = service.authenticateToken?.(bearerFrom(typeof req.headers.authorization === 'string' ? req.headers.authorization : undefined)
+            ?? req.headers['x-handmux-token'], origin) ?? null;
+        if (!token)
+            return null;
+        return service.trustedDeviceEnabled === false ? token : device && token ? device : null;
+    };
+    const middleware = (req, res, next) => {
+        res.setHeader('Cache-Control', 'no-store');
+        if (service.available === false) {
+            res.status(503).json({ error: 'authentication service unavailable', code: 'auth_unavailable' });
+            return;
+        }
+        const origin = resolveOrigin(req);
+        if (!origin || (req.headers.origin !== undefined && req.headers.origin !== origin)) {
+            res.status(403).json({ error: 'untrusted request origin', code: 'origin_rejected' });
+            return;
+        }
+        let principal;
+        try {
+            principal = authenticate(req);
+        }
+        catch {
+            res.status(503).json({ error: 'authentication storage unavailable', code: 'auth_unavailable' });
+            return;
+        }
+        if (!principal) {
+            res.status(401).json({ error: 'unauthorized', code: 'auth_required' });
+            return;
+        }
+        res.locals.deviceAuth = principal;
+        let accepted = false;
+        const assertActive = () => {
+            if (!accepted && !service.isActive(principal)) {
+                throw Object.assign(new Error('Device authorization is no longer active'), { status: 401, code: 'auth_required' });
+            }
+        };
+        // Accepted Agent/background jobs may continue after logout; not-yet-issued HTTP work may not.
+        // Destroy/abort never marks a request accepted.
+        res.once('finish', () => { if (res.statusCode >= 200 && res.statusCode < 300)
+            accepted = true; });
+        res.locals.assertDeviceActive = assertActive;
+        const secret = readSessionSecret(req, origin);
+        if (secret && !principal.deviceId.startsWith('token_'))
+            setSessionCookie(res, origin, secret, principal.expiresAt);
+        const group = responses.get(principal.deviceId) ?? new Set();
+        group.add(res);
+        responses.set(principal.deviceId, group);
+        const cleanup = () => {
+            group.delete(res);
+            if (group.size === 0)
+                responses.delete(principal.deviceId);
+        };
+        res.once('finish', cleanup);
+        res.once('close', cleanup);
+        withRequestAuthority(assertActive, next);
+    };
+    return { middleware, authenticate, close: stop };
+}

package/dist/src/deviceAuth/control.js

@@ -0,0 +1,154 @@
+import net from 'node:net';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { DeviceAuthError } from './service.js';
+export const authSocketPath = (home) => path.join(home, '.handmux', 'auth.sock');
+export class AuthControlError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'AuthControlError';
+    }
+}
+export async function startDeviceAuthControl({ service, home, handlePush, handleShortcuts }) {
+    const socketPath = authSocketPath(home);
+    await fs.mkdir(path.dirname(socketPath), { recursive: true, mode: 0o700 });
+    await fs.chmod(path.dirname(socketPath), 0o700);
+    try {
+        const existing = await fs.lstat(socketPath);
+        if (!existing.isSocket())
+            throw new Error('Auth control path is not a socket; refusing to replace it');
+        // The shared DB single-instance lock must already be acquired by the caller.
+        await fs.unlink(socketPath);
+    }
+    catch (error) {
+        if (!(error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT'))
+            throw error;
+    }
+    const sockets = new Set();
+    const server = net.createServer(socket => {
+        const owner = randomUUID();
+        let buffer = '';
+        let chain = Promise.resolve();
+        sockets.add(socket);
+        socket.setTimeout(360_000, () => socket.destroy());
+        socket.on('close', () => { sockets.delete(socket); service.cancelOwner(owner); });
+        socket.on('error', () => { });
+        socket.on('data', bytes => {
+            buffer += bytes.toString('utf8');
+            if (Buffer.byteLength(buffer) > 16_384) {
+                socket.destroy();
+                return;
+            }
+            let newline;
+            while ((newline = buffer.indexOf('\n')) >= 0) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                chain = chain.then(async () => {
+                    if (socket.destroyed)
+                        return;
+                    try {
+                        const input = JSON.parse(line);
+                        if (!input || typeof input !== 'object')
+                            throw new DeviceAuthError('INVALID_COMMAND', 'Invalid control command');
+                        const args = input;
+                        let result;
+                        if (args.op === 'claim')
+                            result = service.claim(args.code, owner);
+                        else if (args.op === 'authorize')
+                            result = service.authorize(String(args.id ?? ''), owner, { name: args.name, expire: args.expire });
+                        else if (args.op === 'cancel') {
+                            service.cancelOwner(owner);
+                            result = { ok: true };
+                        }
+                        else if (args.op === 'device-status')
+                            result = { enabled: service.trustedDeviceEnabled, devices: service.list() };
+                        else if (args.op === 'device-policy') {
+                            service.setTrustedDeviceEnabled(args.enabled === true);
+                            result = { enabled: service.trustedDeviceEnabled };
+                        }
+                        else if (args.op === 'device-list')
+                            result = service.list();
+                        else if (args.op === 'device-edit')
+                            result = service.edit(String(args.id ?? ''), { name: args.name, expire: args.expire });
+                        else if (args.op === 'device-revoke')
+                            result = service.revoke(String(args.id ?? ''));
+                        else if (args.op === 'address-status')
+                            result = { enabled: service.trustedOriginEnabled, origins: service.trustedOrigins };
+                        else if (args.op === 'address-policy') {
+                            service.setTrustedOriginEnabled(args.enabled === true);
+                            result = { enabled: service.trustedOriginEnabled };
+                        }
+                        else if (args.op === 'address-add')
+                            result = { origins: service.addTrustedOrigin(args.origin) };
+                        else if (args.op === 'address-remove')
+                            result = { origins: service.removeTrustedOrigin(args.origin) };
+                        else if (args.op === 'push' && handlePush)
+                            result = await handlePush(args.body);
+                        else if (args.op === 'shortcuts' && handleShortcuts)
+                            result = await handleShortcuts(args.body);
+                        else
+                            throw new DeviceAuthError('INVALID_COMMAND', 'Unknown control command');
+                        if (!socket.destroyed)
+                            socket.write(`${JSON.stringify({ ok: true, result })}\n`);
+                    }
+                    catch (error) {
+                        if (!socket.destroyed)
+                            socket.write(`${JSON.stringify({ ok: false, error: error instanceof DeviceAuthError ? error.code : 'AUTH_UNAVAILABLE', message: error instanceof DeviceAuthError ? error.message : 'Authentication operation unavailable; retry or restart handmux' })}\n`);
+                    }
+                });
+            }
+        });
+    });
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(socketPath, () => { server.off('error', reject); resolve(); }); });
+    await fs.chmod(socketPath, 0o600);
+    return { close: async () => { for (const socket of sockets)
+            socket.destroy(); await new Promise(resolve => server.close(() => resolve())); await fs.unlink(socketPath).catch(() => { }); } };
+}
+export async function connectAuthControl(home) {
+    const socket = net.createConnection(authSocketPath(home));
+    let buffer = '';
+    let terminalError;
+    let pending;
+    const fail = (error) => { terminalError = error; pending?.reject(error); pending = undefined; };
+    socket.on('error', fail);
+    socket.on('close', () => fail(new Error('handmux control connection closed; start handmux and retry')));
+    socket.setTimeout(360_000, () => socket.destroy(new Error('Device setup timed out; pair again')));
+    socket.on('data', bytes => {
+        buffer += bytes.toString('utf8');
+        if (buffer.length > 4_000_000) {
+            socket.destroy(new Error('Control response exceeds limit'));
+            return;
+        }
+        const newline = buffer.indexOf('\n');
+        if (newline < 0)
+            return;
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        try {
+            const out = JSON.parse(line);
+            const p = pending;
+            pending = undefined;
+            if (out.ok)
+                p?.resolve(out.result);
+            else
+                p?.reject(new AuthControlError(out.error ?? 'AUTH_UNAVAILABLE', out.message ?? 'Authentication command unavailable; retry or restart handmux'));
+        }
+        catch {
+            fail(new Error('Invalid handmux control response'));
+        }
+    });
+    await new Promise((resolve, reject) => { socket.once('connect', resolve); socket.once('error', reject); });
+    return {
+        request(args) {
+            if (terminalError || socket.destroyed || !socket.writable)
+                return Promise.reject(terminalError ?? new Error('handmux control connection closed; start handmux and pair again'));
+            if (pending)
+                return Promise.reject(new Error('Control command already pending'));
+            return new Promise((resolve, reject) => { pending = { resolve, reject }; socket.write(`${JSON.stringify(args)}\n`); });
+        },
+        close() { socket.destroy(); },
+    };
+}