@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.1

package/lib/types/backends/codex/rpc/transport.js

@@ -0,0 +1,212 @@
+/**
+ * The `codex app-server` child process as a line transport
+ * (docs/codex-backend-design.md §5.1): spawn, newline framing of stdout,
+ * a write queue that honours back-pressure, stderr by line, one exit report.
+ *
+ * - stdout is split on `\n` by hand: a single line may be large (a whole
+ *   thread page), but one longer than {@link MAX_LINE_BYTES} is dropped (and
+ *   reported once through `onStderr`) instead of growing without bound.
+ * - stderr never reaches the terminal: each line goes to `onStderr` (the
+ *   host's debug log and deduplicated notices).
+ * - `app-server proxy` carries the local daemon's WebSocket stream over
+ *   stdio. Its HTTP upgrade and bounded frames use the same child pipes;
+ *   closing this child disconnects our client and leaves the daemon running.
+ * - `close()` ends stdin (the app-server exits on EOF, C0 V1), then escalates
+ *   to SIGTERM and SIGKILL if the child lingers; it resolves once the child
+ *   is gone. Safe to call twice.
+ *
+ * The hub only sees the {@link Transport} interface, so regressions inject an
+ * in-process fake (scripts/lib/codex-fake-app-server.ts).
+ */
+import { spawn } from 'node:child_process';
+import { Duplex, Readable, Writable } from 'node:stream';
+import WebSocket from 'ws';
+/** 96 Mi code units: covers the declared 50 MiB image payload after base64. */
+export const MAX_LINE_BYTES = 96 * 1024 * 1024;
+/** Grace periods of {@link Transport.close}: EOF → SIGTERM → SIGKILL. */
+export const CLOSE_GRACE_MS = 2000;
+/** A line splitter with the size bound (shared with the fake transport). */
+export function createLineSplitter(onLine, onOversize, maxLine = MAX_LINE_BYTES) {
+    let partial = '';
+    let skipping = false;
+    return {
+        push(chunk) {
+            let start = 0;
+            for (let index = chunk.indexOf('\n'); index !== -1; index = chunk.indexOf('\n', start)) {
+                const piece = chunk.slice(start, index);
+                start = index + 1;
+                if (skipping) {
+                    skipping = false;
+                    partial = '';
+                    continue;
+                }
+                const line = partial + piece;
+                partial = '';
+                const trimmed = line.endsWith('\r') ? line.slice(0, -1) : line;
+                if (line.length > maxLine)
+                    onOversize(line.length);
+                else if (trimmed !== '')
+                    onLine(trimmed);
+            }
+            if (skipping)
+                return;
+            partial += chunk.slice(start);
+            if (partial.length > maxLine) {
+                onOversize(partial.length);
+                partial = '';
+                skipping = true;
+            }
+        },
+        end() {
+            if (!skipping && partial.trim() !== '')
+                onLine(partial);
+            partial = '';
+            skipping = false;
+        },
+    };
+}
+/** Windows runs a `.cmd`/`.bat` shim through `cmd.exe` (Node refuses to
+ *  spawn one directly). */
+function command(executable, args) {
+    if (process.platform === 'win32' && /\.(?:cmd|bat)$/iu.test(executable)) {
+        const quote = (value) => /[\s"&|<>^]/u.test(value) ? `"${value.replace(/"/gu, '""')}"` : value;
+        return { file: process.env.ComSpec ?? 'cmd.exe', args: ['/d', '/s', '/c', [executable, ...args].map(quote).join(' ')] };
+    }
+    return { file: executable, args: [...args] };
+}
+/** Spawn the app-server child. Never throws: a spawn failure is reported
+ *  through `onExit` with `error` set. */
+export function spawnTransport(options) {
+    const { file, args } = command(options.executable, options.args);
+    let child;
+    let exited = false;
+    let closing;
+    let websocket;
+    const queue = [];
+    let exitResolve;
+    const exitPromise = new Promise(resolve => { exitResolve = resolve; });
+    const reportExit = (info) => {
+        if (exited)
+            return;
+        exited = true;
+        queue.length = 0;
+        websocket?.terminate();
+        exitResolve?.();
+        options.onExit(info);
+    };
+    try {
+        child = spawn(file, args, {
+            cwd: options.cwd,
+            env: { ...options.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        queueMicrotask(() => reportExit({ code: null, signal: null, error: error instanceof Error ? error : new Error(String(error)) }));
+        return { write: () => undefined, close: () => Promise.resolve(), pid: undefined };
+    }
+    const stderr = createLineSplitter(line => options.onStderr(line), () => undefined);
+    child.stderr?.setEncoding('utf8');
+    child.stderr?.on('data', (chunk) => stderr.push(chunk));
+    child.stderr?.on('end', () => stderr.end());
+    // A broken pipe while writing is the child dying; its exit reports it.
+    child.stdin?.on('error', () => undefined);
+    child.on('error', error => reportExit({ code: null, signal: null, error }));
+    child.on('exit', (code, signal) => reportExit({ code, signal }));
+    let draining = false;
+    const flush = () => {
+        if (exited || closing !== undefined || draining)
+            return;
+        if (websocket !== undefined) {
+            if (websocket.readyState !== WebSocket.OPEN || queue.length === 0)
+                return;
+            draining = true;
+            websocket.send(queue.shift(), error => {
+                draining = false;
+                if (error)
+                    child.stdin?.end();
+                else
+                    flush();
+            });
+            return;
+        }
+        while (queue.length > 0 && !draining) {
+            const line = queue.shift();
+            if (child.stdin?.write(line) === false)
+                draining = true;
+        }
+    };
+    if (options.args[0] === 'app-server' && options.args[1] === 'proxy' && child.stdout !== null && child.stdin !== null) {
+        const pipes = Duplex.fromWeb({ readable: Readable.toWeb(child.stdout), writable: Writable.toWeb(child.stdin) });
+        // The URL supplies HTTP headers only: createConnection connects the
+        // official proxy's pipes, never a TCP endpoint.
+        websocket = new WebSocket('ws://localhost/', {
+            createConnection: () => pipes,
+            perMessageDeflate: false,
+            maxPayload: MAX_LINE_BYTES,
+        });
+        websocket.on('open', flush);
+        websocket.on('message', data => {
+            const bytes = Buffer.isBuffer(data) ? data : Array.isArray(data) ? Buffer.concat(data) : Buffer.from(data);
+            options.onLine(bytes.toString('utf8'));
+        });
+        websocket.on('error', () => {
+            if (!exited && closing === undefined)
+                options.onStderr('dsh-tui: Codex daemon proxy connection failed');
+            child.stdin?.end();
+        });
+        websocket.on('close', () => { child.stdin?.end(); });
+    }
+    else {
+        const stdout = createLineSplitter(options.onLine, bytes => options.onStderr(`dsh-tui: dropped an app-server line of ${bytes} bytes`));
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => stdout.push(chunk));
+        child.stdout?.on('end', () => stdout.end());
+        child.stdin?.on('drain', () => { draining = false; flush(); });
+    }
+    return {
+        get pid() { return child.pid; },
+        write(line) {
+            if (exited || closing !== undefined || child.stdin === null || child.stdin.destroyed)
+                return;
+            queue.push(websocket === undefined ? `${line}\n` : line);
+            flush();
+        },
+        close() {
+            if (closing !== undefined)
+                return closing;
+            closing = (async () => {
+                if (exited)
+                    return;
+                queue.length = 0;
+                if (websocket?.readyState === WebSocket.OPEN)
+                    websocket.close();
+                else
+                    websocket?.terminate();
+                try {
+                    child.stdin?.end();
+                }
+                catch { /* already closed */ }
+                const waited = (ms) => Promise.race([
+                    exitPromise.then(() => true),
+                    new Promise(resolve => { setTimeout(() => resolve(false), ms).unref(); }),
+                ]);
+                if (await waited(CLOSE_GRACE_MS))
+                    return;
+                try {
+                    child.kill('SIGTERM');
+                }
+                catch { /* gone */ }
+                if (await waited(CLOSE_GRACE_MS))
+                    return;
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { /* gone */ }
+                await waited(CLOSE_GRACE_MS);
+            })();
+            return closing;
+        },
+    };
+}

package/lib/types/backends/codex/session/activity.d.ts

@@ -0,0 +1,18 @@
+/** A compact working line driven by native thread notifications, not every token. */
+import type { WorkingActivityView } from '../../../adapter/ports/channel-view.js';
+import type { AgentEvent } from '../../../agent/events.js';
+import { type Rec } from '../narrow.js';
+import type { RpcClock } from '../rpc/client.js';
+export declare function createCodexActivity(deps: {
+    readonly clock: RpcClock;
+    now(): number;
+    emit(events: readonly AgentEvent[]): void;
+}): {
+    capability: {
+        subscribe(listener: (value: WorkingActivityView) => void): () => void;
+    };
+    notification(method: string, params: Rec): void;
+    reset(): void;
+    close(): void;
+};
+//# sourceMappingURL=activity.d.ts.map

package/lib/types/backends/codex/session/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/activity.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,OAAO,EAAiB,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAEtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGhD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,GAAG,IAAI,MAAM,CAAC;IAAC,IAAI,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAAA;CAAE;;4BA2B1F,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,GAAG,MAAM,IAAI;;yBAC9D,MAAM,UAAU,GAAG,GAAG,IAAI;aA8CtC,IAAI;aACJ,IAAI;EAEhB"}

package/lib/types/backends/codex/session/activity.js

@@ -0,0 +1,108 @@
+import { getLang, t } from '../../../i18n.js';
+import { arr, rec, str } from '../narrow.js';
+import { NOTIFY } from '../protocol/index.js';
+import { commandTitle, unwrapCommand } from '../translate/commands.js';
+export function createCodexActivity(deps) {
+    const listeners = new Set();
+    let view = { phase: 'idle', line: '', live: false, toolCount: 0, phaseStartedAt: 0, turnStartedAt: 0, updatedAt: 0, lang: getLang() };
+    let active = false;
+    let blocked = false;
+    let waiting;
+    let stalled;
+    let closed = false;
+    const set = (phase, line) => {
+        if (closed || (view.phase === phase && view.line === line && view.lang === getLang()))
+            return;
+        const now = deps.now();
+        view = { ...view, phase, line, phaseStartedAt: phase === view.phase ? view.phaseStartedAt : now, updatedAt: now, lang: getLang() };
+        for (const listener of listeners)
+            listener(view);
+    };
+    const clearWait = () => {
+        if (waiting !== undefined)
+            deps.clock.clearTimeout(waiting);
+        if (stalled !== undefined)
+            deps.clock.clearTimeout(stalled);
+        waiting = undefined;
+        stalled = undefined;
+    };
+    const wait = () => {
+        clearWait();
+        if (!active || blocked || view.phase === 'tool')
+            return;
+        waiting = deps.clock.setTimeout(() => set('waiting', t('codex-model-waiting')), 30_000);
+        stalled = deps.clock.setTimeout(() => deps.emit([{ type: 'notice', level: 'warning', key: 'codex-model-stalled', text: t('codex-model-stalled') }]), 120_000);
+    };
+    return {
+        capability: { subscribe(listener) { listeners.add(listener); listener(view); return () => { listeners.delete(listener); }; } },
+        notification(method, params) {
+            if (closed)
+                return;
+            const now = deps.now();
+            if (method === NOTIFY.turnStarted) {
+                active = true;
+                blocked = false;
+                view = { ...view, toolCount: 0, turnStartedAt: now };
+                set('waiting', t('codex-working-thinking'));
+            }
+            else if (method === NOTIFY.turnCompleted) {
+                active = false;
+                blocked = false;
+                set('idle', '');
+            }
+            else if (method === NOTIFY.threadStatusChanged) {
+                const status = rec(params.status);
+                const flags = arr(status?.activeFlags);
+                blocked = flags.includes('waitingOnApproval') || flags.includes('waitingOnUserInput');
+                if (str(status?.type) === 'idle') {
+                    active = false;
+                    set('idle', '');
+                }
+            }
+            else if (method === NOTIFY.itemStarted) {
+                const item = rec(params.item);
+                switch (str(item?.type)) {
+                    case 'commandExecution':
+                        set('tool', t('codex-working-command', { command: commandTitle(unwrapCommand(str(item?.command) ?? '', item?.commandActions)) }));
+                        break;
+                    case 'fileChange':
+                        set('tool', t('codex-working-files', { files: arr(item?.changes).map(raw => str(rec(raw)?.path) ?? '').join(', ') }));
+                        break;
+                    case 'collabAgentToolCall':
+                        set('tool', t('codex-working-subagents'));
+                        break;
+                    case 'mcpToolCall':
+                        set('tool', `${str(item?.server) ?? 'MCP'}.${str(item?.tool) ?? ''}`);
+                        break;
+                    case 'webSearch':
+                        set('tool', str(item?.query) ?? '');
+                        break;
+                    case 'agentMessage':
+                    case 'reasoning':
+                    case 'plan':
+                        set('thinking', t('codex-working-thinking'));
+                        break;
+                }
+            }
+            else if (method === NOTIFY.itemCompleted) {
+                const item = rec(params.item);
+                // A completed commentary settles into the transcript as an assistant
+                // message (translate §7.3): the working line must NOT keep narrating
+                // its text — the same sentence would show twice at once, once under
+                // the ⏵ spinner and once as the reply's first message. Claude's
+                // narrated line differs there: it is a `⏵` line STRIPPED from the
+                // transcript, so its working line never duplicates anything.
+                if (str(item?.type) === 'agentMessage' && str(item?.phase) === 'commentary') {
+                    set('thinking', t('codex-working-thinking'));
+                }
+                else if (['commandExecution', 'fileChange', 'mcpToolCall', 'collabAgentToolCall', 'webSearch'].includes(str(item?.type) ?? '')) {
+                    view = { ...view, toolCount: view.toolCount + 1 };
+                    set('thinking', t('codex-working-thinking'));
+                }
+            }
+            wait();
+        },
+        reset() { active = false; blocked = false; clearWait(); set('idle', ''); },
+        close() { active = false; clearWait(); set('idle', ''); closed = true; listeners.clear(); },
+    };
+}

package/lib/types/backends/codex/session/approvals.d.ts

@@ -0,0 +1,39 @@
+import type { PermissionDecision, QuestionAnswers } from '../../../agent/capabilities.js';
+import type { AgentEvent, PermissionRequestView } from '../../../agent/events.js';
+import { type RpcClock } from '../rpc/client.js';
+import type { HubServerRequest } from '../rpc/hub.js';
+export interface ApprovalBridgeDeps {
+    readonly cwd: string;
+    /** The session's own thread: a request from another thread (a subagent
+     *  routed here) is shown with that thread as its agent. */
+    readonly threadId?: string;
+    emit(events: readonly AgentEvent[]): void;
+    debug(message: string): void;
+    /** Run a rejection's reason as the next turn. */
+    enqueueFollowup(id: string, text: string): void;
+    /** Interrupt the running turn (a cancelled question). */
+    interruptTurn(): void;
+    readonly clock?: RpcClock;
+}
+/** An execpolicy prefix as the official client renders it (`bash -lc`
+ *  stripped, tokens space-joined); undefined when it spans lines. */
+export declare function prefixLabel(amendment: readonly string[]): string | undefined;
+export declare function createApprovalBridge(deps: ApprovalBridgeDeps): {
+    onRequest: (request: HubServerRequest) => void;
+    respond: (requestId: string, decision: PermissionDecision) => void;
+    respondQuestion: (requestId: string, answers: QuestionAnswers) => void;
+    cancelQuestion: (requestId: string) => void;
+    withdrawAll: () => void;
+    /** `serverRequest/resolved`: the server is done with a request. */
+    resolved(requestId: unknown): void;
+    /** An item finished: an answered prompt about it is over. */
+    itemCompleted(itemId: string): void;
+    /** A turn ended: no prompt OF THIS THREAD can still be answered. A
+     *  subagent's background request parked here outlives it (the server still
+     *  awaits that answer; it settles via resolved/itemCompleted/dispose). */
+    turnEnded(): void;
+    pendingViews(): readonly PermissionRequestView[];
+    readonly size: number;
+};
+export type ApprovalBridge = ReturnType<typeof createApprovalBridge>;
+//# sourceMappingURL=approvals.d.ts.map

package/lib/types/backends/codex/session/approvals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approvals.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/approvals.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AACzF,OAAO,KAAK,EAAE,UAAU,EAA2C,qBAAqB,EAAoB,MAAM,0BAA0B,CAAA;AAM5I,OAAO,EAAyB,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AA+BrD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB;+DAC2D;IAC3D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,IAAI,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAAA;IACzC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,iDAAiD;IACjD,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/C,yDAAyD;IACzD,aAAa,IAAI,IAAI,CAAA;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAA;CAC1B;AAUD;qEACqE;AACrE,wBAAgB,WAAW,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAM5E;AAkFD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB;yBA6B/B,gBAAgB,KAAG,IAAI;yBAoKvB,MAAM,YAAY,kBAAkB,KAAG,IAAI;iCA+CnC,MAAM,WAAW,eAAe,KAAG,IAAI;gCAiBxC,MAAM,KAAG,IAAI;uBAgBxB,IAAI;IAsB1B,mEAAmE;wBAC/C,OAAO,GAAG,IAAI;IAKlC,6DAA6D;0BACvC,MAAM,GAAG,IAAI;IAKnC;;8EAE0E;iBAC7D,IAAI;oBAMD,SAAS,qBAAqB,EAAE;mBAGpC,MAAM;EAErB;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA"}