@canonmsg/codex-plugin 0.11.12 → 0.12.0

package/dist/adapter.d.ts

@@ -8,6 +8,12 @@ export type CodexEvent = {
 } | {
     type: 'message';
     text: string;
+} | {
+    type: 'plan.updated';
+    text: string;
+} | {
+    type: 'waiting';
+    reason: string;
 } | {
     type: 'command.started';
     command: string;
@@ -24,6 +30,15 @@ export type CodexEvent = {
         output_tokens?: number;
     };
 };
+export interface CodexServerRequest {
+    id: string | number;
+    method: string;
+    params: Record<string, unknown>;
+}
+export interface CodexRunTurnOptions {
+    planMode?: boolean;
+    onServerRequest?: (request: CodexServerRequest) => Promise<unknown>;
+}
 export interface CodexTurnResult {
     threadId: string | null;
     finalMessage: string | null;
@@ -64,7 +79,7 @@ export declare class CodexConversationAdapter {
     setModel(model: string | null): void;
     isRunning(): boolean;
     interrupt(): Promise<void>;
-    runTurn(prompt: string, onEvent: (event: CodexEvent) => void, onLog?: (line: string) => void, imagePaths?: readonly string[], extraAddDirs?: readonly string[]): Promise<CodexTurnResult>;
+    runTurn(prompt: string, onEvent: (event: CodexEvent) => void, onLog?: (line: string) => void, imagePaths?: readonly string[], extraAddDirs?: readonly string[], _options?: CodexRunTurnOptions): Promise<CodexTurnResult>;
     private buildAddDirs;
     private buildArgs;
     private canResumeWithCurrentPolicy;

package/dist/adapter.js

@@ -51,7 +51,7 @@ export class CodexConversationAdapter {
                 this.child.kill('SIGKILL');
         }, 5_000);
     }
-    async runTurn(prompt, onEvent, onLog, imagePaths = [], extraAddDirs = []) {
+    async runTurn(prompt, onEvent, onLog, imagePaths = [], extraAddDirs = [], _options = {}) {
         if (this.child) {
             throw new Error('A Codex turn is already in progress for this conversation');
         }

package/dist/app-server-adapter.d.ts

@@ -0,0 +1,62 @@
+import type { CodexApprovalPolicy, CodexEvent, CodexRunTurnOptions, CodexSandboxMode, CodexTurnResult } from './adapter.js';
+export declare class CodexAppServerAdapter {
+    private readonly cwd;
+    private readonly codexBin;
+    private model;
+    private readonly sandbox;
+    private readonly legacyApprovalPolicy;
+    private readonly addDirs;
+    private readonly configOverrides;
+    private readonly fullAuto;
+    private readonly bypassApprovalsAndSandbox;
+    private child;
+    private threadId;
+    private loadedThreadId;
+    private resolvedModel;
+    private currentTurnId;
+    private requestSeq;
+    private pending;
+    private currentOnEvent;
+    private currentOnLog;
+    private currentRequestHandler;
+    private currentTurnResolve;
+    private currentTurnReject;
+    private currentFinalMessage;
+    private currentErrorText;
+    private interrupted;
+    private initialized;
+    private messageTextByItem;
+    private planText;
+    constructor(opts: {
+        cwd: string;
+        threadId?: string | null;
+        codexBin?: string;
+        model?: string | null;
+        sandbox?: CodexSandboxMode | null;
+        approvalPolicy?: CodexApprovalPolicy | null;
+        addDirs?: string[];
+        configOverrides?: string[];
+        fullAuto?: boolean;
+        bypassApprovalsAndSandbox?: boolean;
+    });
+    getThreadId(): string | null;
+    clearThreadId(): void;
+    setModel(model: string | null): void;
+    isRunning(): boolean;
+    interrupt(): Promise<void>;
+    close(): void;
+    runTurn(prompt: string, onEvent: (event: CodexEvent) => void, onLog?: (line: string) => void, imagePaths?: readonly string[], _extraAddDirs?: readonly string[], options?: CodexRunTurnOptions): Promise<CodexTurnResult>;
+    private resolveApprovalPolicy;
+    private configPayload;
+    private rememberResolvedModel;
+    private sandboxPolicyPayload;
+    private buildWritableRoots;
+    private ensureStarted;
+    private handleLine;
+    private handleServerRequest;
+    private handleNotification;
+    private resolveCurrentTurn;
+    private clearActiveTurn;
+    private sendRequest;
+    private write;
+}

package/dist/app-server-adapter.js

@@ -0,0 +1,502 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+export class CodexAppServerAdapter {
+    cwd;
+    codexBin;
+    model;
+    sandbox;
+    legacyApprovalPolicy;
+    addDirs;
+    configOverrides;
+    fullAuto;
+    bypassApprovalsAndSandbox;
+    child = null;
+    threadId;
+    loadedThreadId = null;
+    resolvedModel = null;
+    currentTurnId = null;
+    requestSeq = 1;
+    pending = new Map();
+    currentOnEvent = null;
+    currentOnLog = null;
+    currentRequestHandler = null;
+    currentTurnResolve = null;
+    currentTurnReject = null;
+    currentFinalMessage = null;
+    currentErrorText = null;
+    interrupted = false;
+    initialized = false;
+    messageTextByItem = new Map();
+    planText = '';
+    constructor(opts) {
+        this.cwd = opts.cwd;
+        this.threadId = opts.threadId ?? null;
+        this.codexBin = opts.codexBin ?? 'codex';
+        this.model = opts.model ?? null;
+        this.sandbox = opts.sandbox ?? null;
+        this.legacyApprovalPolicy = opts.approvalPolicy ?? null;
+        this.addDirs = opts.addDirs ?? [];
+        this.configOverrides = opts.configOverrides ?? [];
+        this.fullAuto = opts.fullAuto ?? false;
+        this.bypassApprovalsAndSandbox = opts.bypassApprovalsAndSandbox ?? false;
+    }
+    getThreadId() {
+        return this.threadId;
+    }
+    clearThreadId() {
+        this.threadId = null;
+        this.loadedThreadId = null;
+        this.resolvedModel = null;
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    isRunning() {
+        return this.currentTurnId !== null || this.currentTurnResolve !== null;
+    }
+    async interrupt() {
+        if (!this.threadId || !this.currentTurnId)
+            return;
+        this.interrupted = true;
+        await this.sendRequest('turn/interrupt', {
+            threadId: this.threadId,
+            turnId: this.currentTurnId,
+        }).catch(() => { });
+    }
+    close() {
+        this.child?.kill('SIGTERM');
+        this.child = null;
+        this.initialized = false;
+        this.clearActiveTurn();
+    }
+    async runTurn(prompt, onEvent, onLog, imagePaths = [], _extraAddDirs = [], options = {}) {
+        if (this.currentTurnId || this.currentTurnResolve) {
+            throw new Error('A Codex turn is already in progress for this conversation');
+        }
+        await this.ensureStarted();
+        this.currentOnEvent = onEvent;
+        this.currentOnLog = onLog ?? null;
+        this.currentRequestHandler = options.onServerRequest ?? null;
+        this.currentFinalMessage = null;
+        this.currentErrorText = null;
+        this.interrupted = false;
+        this.messageTextByItem.clear();
+        this.planText = '';
+        try {
+            if (this.threadId && this.loadedThreadId !== this.threadId) {
+                const resumed = await this.sendRequest('thread/resume', {
+                    threadId: this.threadId,
+                    cwd: this.cwd,
+                    ...(this.model ? { model: this.model } : {}),
+                    ...(this.sandbox ? { sandbox: this.sandbox } : {}),
+                    ...this.configPayload(),
+                    approvalPolicy: this.resolveApprovalPolicy(),
+                    excludeTurns: true,
+                    persistExtendedHistory: true,
+                });
+                this.loadedThreadId = this.threadId;
+                this.rememberResolvedModel(resumed);
+            }
+            if (!this.threadId) {
+                const started = await this.sendRequest('thread/start', {
+                    cwd: this.cwd,
+                    ...(this.model ? { model: this.model } : {}),
+                    ...(this.sandbox ? { sandbox: this.sandbox } : {}),
+                    ...this.configPayload(),
+                    approvalPolicy: this.resolveApprovalPolicy(),
+                    experimentalRawEvents: false,
+                    persistExtendedHistory: true,
+                });
+                const threadId = readString(started.thread, 'id');
+                if (!threadId)
+                    throw new Error('Codex app-server did not return a thread id');
+                this.threadId = threadId;
+                this.loadedThreadId = threadId;
+                this.rememberResolvedModel(started);
+                onEvent({ type: 'thread.started', threadId });
+            }
+            const planModel = this.model ?? this.resolvedModel;
+            const turnPromise = new Promise((resolve, reject) => {
+                this.currentTurnResolve = resolve;
+                this.currentTurnReject = reject;
+            });
+            turnPromise.catch(() => { });
+            const turnStarted = await this.sendRequest('turn/start', {
+                threadId: this.threadId,
+                input: [
+                    { type: 'text', text: prompt, text_elements: [] },
+                    ...imagePaths.map((path) => ({ type: 'localImage', path })),
+                ],
+                ...(this.model ? { model: this.model } : {}),
+                ...this.sandboxPolicyPayload(_extraAddDirs),
+                ...(options.planMode
+                    ? {
+                        collaborationMode: {
+                            mode: 'plan',
+                            settings: {
+                                ...(planModel ? { model: planModel } : {}),
+                                reasoning_effort: null,
+                                developer_instructions: null,
+                            },
+                        },
+                    }
+                    : {}),
+            });
+            const turn = turnStarted.turn;
+            if (this.currentTurnResolve) {
+                this.currentTurnId = readString(turn, 'id') ?? null;
+                onEvent({ type: 'turn.started' });
+            }
+            return await turnPromise;
+        }
+        catch (error) {
+            this.clearActiveTurn();
+            throw error;
+        }
+    }
+    resolveApprovalPolicy() {
+        if (this.bypassApprovalsAndSandbox || this.fullAuto)
+            return 'never';
+        return this.legacyApprovalPolicy;
+    }
+    configPayload() {
+        const config = {};
+        for (const raw of this.configOverrides) {
+            const separator = raw.indexOf('=');
+            if (separator <= 0)
+                continue;
+            const key = raw.slice(0, separator).trim();
+            if (!key)
+                continue;
+            config[key] = parseConfigValue(raw.slice(separator + 1));
+        }
+        return Object.keys(config).length > 0 ? { config } : {};
+    }
+    rememberResolvedModel(result) {
+        const thread = result.thread;
+        this.resolvedModel = readString(thread, 'model') ?? readString(result, 'model') ?? this.resolvedModel;
+    }
+    sandboxPolicyPayload(extraAddDirs) {
+        if (this.bypassApprovalsAndSandbox || this.sandbox === 'danger-full-access') {
+            return { sandboxPolicy: { type: 'dangerFullAccess' } };
+        }
+        if (this.sandbox === 'read-only') {
+            return { sandboxPolicy: { type: 'readOnly', networkAccess: true } };
+        }
+        if (this.sandbox !== 'workspace-write')
+            return {};
+        const writableRoots = this.buildWritableRoots(extraAddDirs);
+        return {
+            sandboxPolicy: {
+                type: 'workspaceWrite',
+                writableRoots,
+                networkAccess: true,
+                excludeTmpdirEnvVar: false,
+                excludeSlashTmp: false,
+            },
+        };
+    }
+    buildWritableRoots(extraAddDirs) {
+        const seen = new Set();
+        const roots = [];
+        for (const raw of [this.cwd, ...this.addDirs, ...extraAddDirs]) {
+            const value = raw.trim();
+            if (!value || seen.has(value))
+                continue;
+            seen.add(value);
+            roots.push(value);
+        }
+        return roots;
+    }
+    async ensureStarted() {
+        if (this.child && this.initialized)
+            return;
+        const child = spawn(this.codexBin, ['app-server', '--listen', 'stdio://'], {
+            cwd: this.cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        const stdout = createInterface({ input: child.stdout });
+        const stderr = createInterface({ input: child.stderr });
+        stdout.on('line', (line) => this.handleLine(line));
+        stderr.on('line', (line) => {
+            const trimmed = line.trim();
+            if (trimmed)
+                this.currentOnLog?.(trimmed);
+        });
+        child.on('close', (code) => {
+            const message = `Codex app-server exited${code === null ? '' : ` with code ${code}`}`;
+            this.initialized = false;
+            this.child = null;
+            for (const pending of this.pending.values()) {
+                pending.reject(new Error(message));
+            }
+            this.pending.clear();
+            if (this.currentTurnReject)
+                this.currentTurnReject(new Error(message));
+            this.clearActiveTurn();
+        });
+        child.on('error', (error) => {
+            if (this.currentTurnReject)
+                this.currentTurnReject(error);
+        });
+        await this.sendRequest('initialize', {
+            clientInfo: { name: 'canon-codex', version: '0.0.0' },
+            capabilities: { experimentalApi: true, supportsServerRequests: true },
+        });
+        this.initialized = true;
+    }
+    handleLine(line) {
+        const message = parseJson(line);
+        if (!message)
+            return;
+        if ('id' in message && ('result' in message || 'error' in message) && !('method' in message)) {
+            const id = Number(message.id);
+            const pending = this.pending.get(id);
+            if (!pending)
+                return;
+            this.pending.delete(id);
+            if (message.error) {
+                pending.reject(new Error(stringifyPreview(message.error)));
+            }
+            else {
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if ('id' in message && typeof message.method === 'string') {
+            void this.handleServerRequest(message);
+            return;
+        }
+        if (typeof message.method === 'string') {
+            this.handleNotification(message.method, (message.params ?? {}));
+        }
+    }
+    async handleServerRequest(request) {
+        try {
+            const result = this.currentRequestHandler
+                ? await this.currentRequestHandler({
+                    id: request.id,
+                    method: request.method,
+                    params: isRecord(request.params) ? request.params : {},
+                })
+                : defaultServerRequestResult(request.method);
+            this.write({ id: request.id, result });
+        }
+        catch (error) {
+            this.write({
+                id: request.id,
+                error: {
+                    code: -32000,
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    handleNotification(method, params) {
+        if (method === 'turn/started') {
+            this.currentTurnId = readString(params.turn, 'id') ?? this.currentTurnId;
+            this.currentOnEvent?.({ type: 'turn.started' });
+            return;
+        }
+        if (method === 'thread/status/changed') {
+            const status = params.status;
+            if (status?.type === 'active' && Array.isArray(status.activeFlags)) {
+                const flags = status.activeFlags.map(String);
+                if (flags.includes('waitingOnApproval') || flags.includes('waitingOnUserInput')) {
+                    this.currentOnEvent?.({ type: 'waiting', reason: flags.join(', ') });
+                }
+            }
+            return;
+        }
+        if (method === 'item/agentMessage/delta') {
+            const itemId = readString(params, 'itemId') ?? 'agent-message';
+            const delta = readString(params, 'delta') ?? '';
+            const next = `${this.messageTextByItem.get(itemId) ?? ''}${delta}`;
+            this.messageTextByItem.set(itemId, next);
+            this.currentFinalMessage = next.trim() || this.currentFinalMessage;
+            if (next.trim())
+                this.currentOnEvent?.({ type: 'message', text: next });
+            return;
+        }
+        if (method === 'turn/plan/updated') {
+            this.planText = renderPlan(params);
+            this.currentFinalMessage = this.planText || this.currentFinalMessage;
+            if (this.planText)
+                this.currentOnEvent?.({ type: 'plan.updated', text: this.planText });
+            return;
+        }
+        if (method === 'item/plan/delta') {
+            const delta = readString(params, 'delta') ?? '';
+            this.planText = `${this.planText}${delta}`;
+            this.currentFinalMessage = this.planText.trim() || this.currentFinalMessage;
+            if (this.planText.trim())
+                this.currentOnEvent?.({ type: 'plan.updated', text: this.planText });
+            return;
+        }
+        if (method === 'item/started') {
+            const item = params.item;
+            const summary = summarizeItem(item);
+            if (summary)
+                this.currentOnEvent?.({ type: 'command.started', command: summary });
+            return;
+        }
+        if (method === 'item/completed') {
+            const item = params.item;
+            if (item?.type === 'agentMessage') {
+                const text = readString(item, 'text');
+                if (text) {
+                    this.currentFinalMessage = text;
+                    this.currentOnEvent?.({ type: 'message', text });
+                }
+            }
+            else if (item?.type === 'commandExecution') {
+                this.currentOnEvent?.({
+                    type: 'command.completed',
+                    command: readString(item, 'command') ?? 'Command',
+                    output: readString(item, 'aggregatedOutput') ?? '',
+                    exitCode: typeof item.exitCode === 'number' ? item.exitCode : null,
+                });
+            }
+            return;
+        }
+        if (method === 'turn/completed') {
+            const turn = params.turn;
+            const status = turn?.status;
+            if (isRecord(status) && status.type === 'failed') {
+                this.currentErrorText = stringifyPreview(turn?.error);
+            }
+            this.currentOnEvent?.({ type: 'turn.completed' });
+            this.resolveCurrentTurn();
+            return;
+        }
+        if (method === 'error') {
+            this.currentErrorText = stringifyPreview(params);
+        }
+    }
+    resolveCurrentTurn() {
+        const result = {
+            threadId: this.threadId,
+            finalMessage: this.currentFinalMessage,
+            exitCode: this.currentErrorText ? 1 : 0,
+            interrupted: this.interrupted,
+            errorText: this.interrupted ? null : this.currentErrorText,
+        };
+        this.currentTurnResolve?.(result);
+        this.clearActiveTurn();
+    }
+    clearActiveTurn() {
+        this.currentTurnId = null;
+        this.currentOnEvent = null;
+        this.currentOnLog = null;
+        this.currentRequestHandler = null;
+        this.currentTurnResolve = null;
+        this.currentTurnReject = null;
+        this.currentFinalMessage = null;
+        this.currentErrorText = null;
+        this.messageTextByItem.clear();
+        this.planText = '';
+    }
+    sendRequest(method, params) {
+        const id = this.requestSeq++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            try {
+                this.write({ id, method, params });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    write(message) {
+        if (!this.child)
+            throw new Error('Codex app-server is not running');
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+}
+function parseJson(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function readString(record, key) {
+    const value = record?.[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function stringifyPreview(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return String(value);
+    }
+}
+function parseConfigValue(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return '';
+    if (trimmed === 'true')
+        return true;
+    if (trimmed === 'false')
+        return false;
+    if (trimmed === 'null')
+        return null;
+    const parsedNumber = Number(trimmed);
+    if (Number.isFinite(parsedNumber) && String(parsedNumber) === trimmed)
+        return parsedNumber;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function summarizeItem(item) {
+    if (!item)
+        return null;
+    if (item.type === 'commandExecution')
+        return readString(item, 'command') ?? 'Running a command';
+    if (item.type === 'fileChange')
+        return 'Applying file changes';
+    if (item.type === 'mcpToolCall')
+        return `Calling ${readString(item, 'tool') ?? 'MCP tool'}`;
+    if (item.type === 'webSearch')
+        return 'Searching the web';
+    return null;
+}
+function renderPlan(params) {
+    const explanation = readString(params, 'explanation');
+    const plan = Array.isArray(params.plan) ? params.plan : [];
+    const lines = [
+        explanation ? `**Plan**\n${explanation}` : '**Plan**',
+        ...plan.flatMap((entry, index) => {
+            if (!isRecord(entry))
+                return [];
+            const step = readString(entry, 'step');
+            if (!step)
+                return [];
+            const status = readString(entry, 'status') ?? 'pending';
+            const marker = status === 'completed' ? '[x]' : status === 'inProgress' ? '[~]' : '[ ]';
+            return [`${index + 1}. ${marker} ${step}`];
+        }),
+    ];
+    return lines.join('\n');
+}
+function defaultServerRequestResult(method) {
+    if (method.includes('requestApproval'))
+        return { decision: 'decline' };
+    if (method === 'item/tool/requestUserInput')
+        return { answers: {} };
+    return {};
+}