@ours.network/fleet 1.1.0-nightly.9 → 1.1.1

package/dist/session/codex-app-server-transport.js

@@ -0,0 +1,184 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { SessionControlError, classifyChildExit } from './types.js';
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function responseError(value) {
+    if (!isObject(value))
+        return new Error('Codex app-server returned an unknown error');
+    const message = typeof value.message === 'string' ? value.message : JSON.stringify(value);
+    const error = new Error(message);
+    error.name = 'CodexAppServerError';
+    return error;
+}
+/** Minimal, version-tolerant JSONL client for Codex app-server's stdio transport. */
+export class CodexAppServerTransport {
+    options;
+    child;
+    pid;
+    nextId = 1;
+    pending = new Map();
+    requestTimeoutMs;
+    exited;
+    resolveExited;
+    closed = false;
+    exit = null;
+    constructor(options, child) {
+        this.options = options;
+        this.child = child;
+        this.pid = child.pid ?? -1;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? 90_000;
+        this.exited = new Promise(resolve => { this.resolveExited = resolve; });
+        child.stderr.on('data', chunk => {
+            const text = String(chunk).trimEnd();
+            if (text)
+                options.log(`[${options.name}] codex app-server: ${text}`);
+        });
+        child.once('error', error => {
+            this.options.log(`[${options.name}] codex app-server process error: ${error.message}`);
+        });
+        const lines = createInterface({ input: child.stdout });
+        lines.on('line', line => this.receive(line));
+        child.once('exit', (code, signal) => {
+            this.exit = classifyChildExit(code, signal);
+            const error = new SessionControlError('offline', `Codex app-server ${this.exit.detail}`);
+            for (const pending of this.pending.values()) {
+                clearTimeout(pending.timer);
+                pending.reject(error);
+            }
+            this.pending.clear();
+            options.onExit?.(this.exit);
+            this.resolveExited();
+        });
+    }
+    static async start(options) {
+        if (!options.argv.length)
+            throw new Error('Codex app-server command is empty');
+        const child = spawn(options.argv[0], options.argv.slice(1), {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // `pid` is assigned synchronously on a successful local spawn. Checking it
+        // first avoids missing an exceptionally fast `spawn` event before the
+        // listeners below are attached (observable with tiny test/app-server shims).
+        if (child.pid === undefined)
+            await new Promise((resolve, reject) => {
+                let settled = false;
+                const finish = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    child.off('spawn', spawned);
+                    child.off('error', failed);
+                    error ? reject(error) : resolve();
+                };
+                const spawned = () => finish();
+                const failed = (error) => finish(error);
+                child.once('spawn', spawned);
+                child.once('error', failed);
+                setImmediate(() => { if (child.pid !== undefined)
+                    finish(); });
+            });
+        return new CodexAppServerTransport(options, child);
+    }
+    isAlive() {
+        return this.child.exitCode === null && (this.child.signalCode ?? null) === null;
+    }
+    exitResult() { return this.exit; }
+    request(method, params = {}, timeoutMs) {
+        if (this.closed || !this.isAlive())
+            return Promise.reject(new SessionControlError('offline', 'Codex app-server is offline'));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new SessionControlError('timeout', `Codex app-server ${method} timed out after ${timeoutMs ?? this.requestTimeoutMs}ms`));
+            }, timeoutMs ?? this.requestTimeoutMs);
+            timer.unref?.();
+            this.pending.set(id, {
+                method, timer,
+                resolve: value => resolve(value), reject,
+            });
+            try {
+                this.write({ id, method, params });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    notify(method, params) {
+        this.write(params === undefined ? { method } : { method, params });
+    }
+    respond(id, result) { this.write({ id, result }); }
+    respondError(id, code, message) {
+        this.write({ id, error: { code, message } });
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (!this.isAlive())
+            return;
+        this.child.kill('SIGTERM');
+        if (await this.waitForExit(2_500))
+            return;
+        this.child.kill('SIGKILL');
+        await this.waitForExit(2_500);
+    }
+    async waitForExit(timeoutMs) {
+        let timer;
+        const timedOut = new Promise(resolve => {
+            timer = setTimeout(() => resolve(false), timeoutMs);
+            timer.unref?.();
+        });
+        const exited = await Promise.race([this.exited.then(() => true), timedOut]);
+        if (timer)
+            clearTimeout(timer);
+        return exited;
+    }
+    write(value) {
+        if (this.closed || this.child.stdin.destroyed)
+            throw new SessionControlError('offline', 'Codex app-server input is closed');
+        this.child.stdin.write(JSON.stringify(value) + '\n', error => {
+            if (error)
+                this.options.log(`[${this.options.name}] codex app-server write failed: ${error.message}`);
+        });
+    }
+    receive(line) {
+        let value;
+        try {
+            const parsed = JSON.parse(line);
+            if (!isObject(parsed))
+                throw new Error('message is not an object');
+            value = parsed;
+        }
+        catch (error) {
+            this.options.log(`[${this.options.name}] codex app-server: ignored malformed JSONL (${error.message})`);
+            return;
+        }
+        const method = typeof value.method === 'string' ? value.method : undefined;
+        const hasId = typeof value.id === 'string' || typeof value.id === 'number';
+        if (method && hasId) {
+            this.options.onRequest?.(method, value.id, isObject(value.params) ? value.params : {});
+            return;
+        }
+        if (method) {
+            this.options.onNotification?.(method, isObject(value.params) ? value.params : {});
+            return;
+        }
+        if (!hasId)
+            return;
+        const pending = this.pending.get(value.id);
+        if (!pending)
+            return;
+        this.pending.delete(value.id);
+        clearTimeout(pending.timer);
+        if (value.error !== undefined)
+            pending.reject(responseError(value.error));
+        else
+            pending.resolve(value.result);
+    }
+}

package/dist/session/codex-app-server.d.ts

@@ -0,0 +1,122 @@
+import type { CommonPermissions } from '../config.js';
+import type { ConversationEventV1, ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
+import type { CodexAppServerTransportFactory } from './codex-app-server-transport.js';
+import type { AgentSession, ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
+type JsonObject = Record<string, unknown>;
+export interface CodexAppServerSessionOptions {
+    name: string;
+    argv: string[];
+    cwd: string;
+    env: Record<string, string>;
+    stateDir: string;
+    mode: 'fresh' | 'resume';
+    permissions: CommonPermissions;
+    permissionMode: NonNullable<SessionSnapshot['permissionMode']>;
+    model?: string | null;
+    effort?: string;
+    approvalPolicy: string;
+    sandbox: string;
+    config?: Record<string, unknown>;
+    addDirs?: string[];
+    log(line: string): void;
+    permissionTimeoutMs?: number;
+    controllerGraceMs?: number;
+    interruptSettleMs?: number;
+    interruptTerminateGraceMs?: number;
+    terminalReconcileQuietMs?: number;
+    terminalReconcileRequestTimeoutMs?: number;
+}
+/** Server-generated application provenance for authenticated browser prompts only. */
+export declare function nativePromptAdditionalContext(origin: PromptOrigin | undefined): JsonObject | undefined;
+/** Native Codex session implementing Fleet's provider-neutral live-session contract. */
+export declare class CodexAppServerSession implements AgentSession {
+    private readonly options;
+    readonly backend: "codex-app-server";
+    readonly capabilities: import("./types.js").AgentSessionCapabilities;
+    readonly pid: number;
+    private readonly events;
+    private readonly conversation;
+    private readonly conversationStartCursor?;
+    private readonly sessionGeneration;
+    private readonly threadFile;
+    private readonly pendingPermissions;
+    private readonly activeTools;
+    private readonly activeItems;
+    private readonly itemPhases;
+    private readonly itemText;
+    private transport;
+    private threadId?;
+    private readiness;
+    private runtimeModel?;
+    private reasoningEffort?;
+    private lastUpdateAt?;
+    private lastError?;
+    private exit;
+    private queueDepth;
+    private promptTail;
+    private activeTurn?;
+    private controllerCount;
+    private controllerGrace?;
+    private interruptForceKill?;
+    private terminalReconcile?;
+    private terminalReconcileInFlight;
+    private finalAnswerObserved;
+    private closing;
+    private constructor();
+    static start(options: CodexAppServerSessionOptions, transportFactory?: CodexAppServerTransportFactory): Promise<CodexAppServerSession>;
+    isAlive(): boolean;
+    snapshot(): SessionSnapshot;
+    queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
+    submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
+    interrupt(source?: TurnCancellationSource): Promise<InterruptOutcome>;
+    respondPermission(permissionId: string, optionId: string): boolean;
+    respondPermissionV2(permissionId: string, optionId: string, sessionGeneration: string): 'accepted' | 'stale';
+    eventsSince(seq: number): SessionEvent[];
+    subscribe(listener: (event: SessionEvent) => void): () => void;
+    setControllerAttached(attached: boolean): void;
+    exitResult(): ExitRecord | null;
+    close(): Promise<void>;
+    conversationPage(request?: {
+        after?: string;
+        limit?: number;
+    }): ConversationHandlePage;
+    conversationSnapshot(): ConversationSnapshot;
+    subscribeConversation(listener: (event: ConversationEventV1) => void): () => void;
+    submitPromptBrowser(command: SubmitPromptCommand): Promise<PromptReceipt>;
+    private initialize;
+    private recoverOpenPrompts;
+    private admit;
+    private runPrompt;
+    private steer;
+    private notification;
+    private itemStarted;
+    private itemCompleted;
+    private messageDelta;
+    private emitMessage;
+    private thoughtDelta;
+    private planUpdated;
+    private recordTool;
+    private finishTurn;
+    /**
+     * Some supported Codex versions can persist a completed turn without
+     * emitting `turn/completed`. Reconcile only an exact, quiescent final-answer
+     * candidate against the app-server's authoritative thread snapshot.
+     */
+    private scheduleTerminalReconciliation;
+    private terminalCandidate;
+    private reconcileTerminal;
+    private cancelTerminalReconciliation;
+    private clearInterruptForceKill;
+    private terminateFailedTransport;
+    private serverRequest;
+    private requestPermission;
+    private serverRequestResolved;
+    private autoResolvePermission;
+    private resolvePermission;
+    private currentEvent;
+    private isActiveNotification;
+    private permissionResponse;
+    private transportExited;
+    private fail;
+}
+export {};