ultracode-for-codex 0.2.0

package/dist/codex/subagent-backend.js

@@ -0,0 +1,685 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { join } from 'node:path';
+import readline from 'node:readline';
+import { codexDefaultReasoningEffort, codexDefaultVerbosity, } from '../settings.js';
+import { estimateTokens } from '../runtime/types.js';
+import { codexChildProcessEnv } from './env.js';
+const USAGE_NOTIFICATION_GRACE_MS = 100;
+const BUFFERED_TURN_STATE_TTL_MS = 30_000;
+const FALLBACK_CODEX_MODEL = 'gpt-5.5';
+const DISABLED_CODEX_CONTEXT_FEATURES = [
+    'apps',
+    'browser_use',
+    'computer_use',
+    'goals',
+    'hooks',
+    'image_generation',
+    'multi_agent',
+    'plugins',
+    'shell_tool',
+    'workspace_dependencies',
+];
+export class CodexSubagentBackend {
+    name = 'codex-subagent';
+    model;
+    command;
+    cwd;
+    configuredModel;
+    timeoutMs;
+    reasoningEffort;
+    verbosity;
+    child = null;
+    lineReader = null;
+    nextId = 1;
+    initialized = null;
+    stderr = '';
+    pending = new Map();
+    turnWaiters = new Map();
+    bufferedTurnStates = new Map();
+    isolation = null;
+    constructor(options) {
+        this.command = options.command ?? 'codex';
+        this.cwd = options.cwd;
+        this.model = options.model ?? 'codex-subagent';
+        this.configuredModel = options.model;
+        this.timeoutMs = options.timeoutMs;
+        this.reasoningEffort = options.reasoningEffort ?? codexDefaultReasoningEffort();
+        this.verbosity = options.verbosity ?? codexDefaultVerbosity();
+    }
+    async generate(request, signal) {
+        const startedAt = Date.now();
+        await this.ensureStarted();
+        const reasoningEffort = request.reasoningEffort ?? this.reasoningEffort;
+        const structuredTool = structuredOutputToolFor(request);
+        const prompt = workflowAgentPrompt(request, structuredTool);
+        let threadId = null;
+        let turnId = null;
+        const interruptTurn = async () => {
+            if (!threadId || !turnId)
+                return;
+            await this.send('turn/interrupt', { threadId, turnId }).catch(() => undefined);
+        };
+        const onAbort = () => {
+            void interruptTurn();
+        };
+        if (signal?.aborted)
+            throw new Error('request aborted');
+        if (signal)
+            signal.addEventListener('abort', onAbort, { once: true });
+        try {
+            const cwd = request.worktreePath ?? this.isolation?.workDir ?? this.cwd;
+            threadId = await this.startThread(reasoningEffort, this.verbosity, Boolean(structuredTool), cwd, Boolean(request.worktreePath));
+            const turn = await this.send('turn/start', {
+                threadId,
+                cwd,
+                runtimeWorkspaceRoots: [cwd],
+                environments: [],
+                input: [{ type: 'text', text: prompt, text_elements: [] }],
+                model: this.modelOverrideFor(request.model),
+                effort: reasoningEffort,
+                summary: 'none',
+                personality: 'none',
+                ...(structuredTool ? { outputSchema: structuredTool.inputSchema } : {}),
+            });
+            turnId = readPath(turn, ['result', 'turn', 'id']);
+            if (!turnId)
+                throw new Error('codex app-server did not return a turn id');
+            const result = await this.waitForTurn(threadId, turnId, signal);
+            const text = result.text.trim();
+            const usage = result.usage ?? estimatedUsage(prompt, text);
+            return {
+                id: `subagent_${randomUUID()}`,
+                model: request.model,
+                text: structuredTool ? '' : text,
+                toolCalls: structuredTool ? [{
+                        id: `call_${randomUUID()}`,
+                        name: structuredTool.name,
+                        arguments: text,
+                    }] : [],
+                usage,
+                latencyMs: Date.now() - startedAt,
+            };
+        }
+        finally {
+            if (signal)
+                signal.removeEventListener('abort', onAbort);
+            if (threadId)
+                this.archiveThread(threadId);
+        }
+    }
+    async close() {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('codex subagent backend closed'));
+        }
+        this.pending.clear();
+        for (const waiter of this.turnWaiters.values()) {
+            waiter.reject(new Error('codex subagent backend closed'));
+        }
+        this.turnWaiters.clear();
+        this.clearBufferedTurnStates();
+        this.lineReader?.close();
+        this.child?.kill('SIGTERM');
+        this.child = null;
+        this.lineReader = null;
+        this.initialized = null;
+        await this.cleanupIsolation();
+    }
+    async ensureStarted() {
+        if (this.initialized)
+            return this.initialized;
+        this.initialized = this.start();
+        return this.initialized;
+    }
+    async start() {
+        const isolation = await createCodexIsolation({
+            configuredModel: this.configuredModel,
+            reasoningEffort: this.reasoningEffort,
+            verbosity: this.verbosity,
+        });
+        this.isolation = isolation;
+        const appServerArgs = [
+            'app-server',
+            ...codexContextIsolationArgs({
+                model: this.configuredModel ?? isolation.defaultModel ?? FALLBACK_CODEX_MODEL,
+                reasoningEffort: this.reasoningEffort,
+                verbosity: this.verbosity,
+            }),
+            '--listen',
+            'stdio://',
+        ];
+        this.child = spawn(this.command, appServerArgs, {
+            cwd: isolation.workDir,
+            shell: false,
+            env: codexChildProcessEnv({ CODEX_HOME: isolation.homeDir }),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child.stderr.setEncoding('utf8');
+        this.child.stderr.on('data', (chunk) => {
+            this.stderr = `${this.stderr}${chunk}`.slice(-12_000);
+        });
+        this.child.on('error', (err) => this.failAll(err));
+        this.child.on('close', (code, signal) => {
+            this.failAll(new Error(`codex app-server exited: code=${code ?? 'null'} signal=${signal ?? 'null'}`));
+            this.child = null;
+            this.lineReader = null;
+            this.initialized = null;
+            void this.cleanupIsolation();
+        });
+        this.lineReader = readline.createInterface({ input: this.child.stdout });
+        this.lineReader.on('line', (line) => this.handleLine(line));
+        await this.send('initialize', {
+            clientInfo: {
+                name: 'ultracode_for_codex',
+                title: 'Ultracode for Codex',
+                version: '0.2.0',
+            },
+            capabilities: {
+                experimentalApi: true,
+                requestAttestation: false,
+                optOutNotificationMethods: [],
+            },
+        });
+        this.notify('initialized', {});
+    }
+    async startThread(reasoningEffort, verbosity, structured, cwd, workspaceWrite) {
+        const thread = await this.send('thread/start', {
+            cwd,
+            runtimeWorkspaceRoots: [cwd],
+            approvalPolicy: 'never',
+            sandbox: workspaceWrite ? 'workspace-write' : 'read-only',
+            environments: [],
+            dynamicTools: [],
+            ephemeral: true,
+            baseInstructions: 'Ultracode workflow subagent. Produce only the workflow agent return value.',
+            developerInstructions: structured
+                ? 'Return exactly one JSON value matching the provided outputSchema.'
+                : 'Return exactly the raw result text for the workflow script.',
+            personality: 'none',
+            experimentalRawEvents: false,
+            persistExtendedHistory: false,
+            config: {
+                model_reasoning_effort: reasoningEffort,
+                model_reasoning_summary: 'none',
+                model_verbosity: verbosity,
+                web_search: 'disabled',
+            },
+        });
+        const threadId = readPath(thread, ['result', 'thread', 'id']);
+        if (!threadId)
+            throw new Error('codex app-server did not return a thread id');
+        return threadId;
+    }
+    archiveThread(threadId) {
+        void this.send('thread/archive', { threadId }).catch(() => undefined);
+    }
+    async cleanupIsolation() {
+        const isolation = this.isolation;
+        this.isolation = null;
+        if (isolation) {
+            await rm(isolation.rootDir, {
+                recursive: true,
+                force: true,
+                maxRetries: 3,
+                retryDelay: 100,
+            });
+        }
+    }
+    send(method, params) {
+        if (!this.child)
+            return Promise.reject(new Error('codex app-server is not running'));
+        const id = this.nextId;
+        this.nextId += 1;
+        this.child.stdin.write(`${JSON.stringify({ method, id, params })}\n`);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`${method} timed out after ${this.timeoutMs}ms`));
+            }, this.timeoutMs);
+            this.pending.set(id, { method, resolve, reject, timer });
+        });
+    }
+    notify(method, params) {
+        this.child?.stdin.write(`${JSON.stringify({ method, params })}\n`);
+    }
+    handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const id = typeof message.id === 'number' ? message.id : null;
+        if (id !== null && this.pending.has(id)) {
+            const pending = this.pending.get(id);
+            if (!pending)
+                return;
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            if (message.error)
+                pending.reject(new Error(`${pending.method} failed: ${JSON.stringify(message.error)}`));
+            else
+                pending.resolve(message);
+            return;
+        }
+        if (id !== null && typeof message.method === 'string') {
+            this.respondToServerRequest(id, message.method);
+            return;
+        }
+        if (typeof message.method === 'string')
+            this.handleNotification(message.method, message.params);
+    }
+    respondToServerRequest(id, method) {
+        const result = method.includes('requestApproval') ? { decision: 'decline' } : undefined;
+        this.child?.stdin.write(`${JSON.stringify({
+            id,
+            ...(result
+                ? { result }
+                : { error: { code: -32601, message: `Unsupported server request: ${method}` } }),
+        })}\n`);
+    }
+    handleNotification(method, params) {
+        const data = asRecord(params);
+        if (!data)
+            return;
+        if (method === 'item/agentMessage/delta') {
+            const key = turnStateKey(data.threadId, data.turnId);
+            if (!key || typeof data.delta !== 'string')
+                return;
+            const waiter = this.turnWaiters.get(key);
+            if (waiter)
+                waiter.text += data.delta;
+            else
+                this.bufferTurnState(key, (state) => state.textDeltas.push(data.delta));
+            return;
+        }
+        if (method === 'item/completed') {
+            const key = turnStateKey(data.threadId, data.turnId);
+            const item = asRecord(data.item);
+            if (!key || item?.type !== 'agentMessage' || typeof item.text !== 'string')
+                return;
+            const waiter = this.turnWaiters.get(key);
+            if (waiter)
+                waiter.text = item.text;
+            else
+                this.bufferTurnState(key, (state) => {
+                    state.finalText = item.text;
+                });
+            return;
+        }
+        if (method === 'thread/tokenUsage/updated') {
+            const threadId = typeof data.threadId === 'string' ? data.threadId : null;
+            const turnId = typeof data.turnId === 'string' ? data.turnId : null;
+            if (!threadId || !turnId)
+                return;
+            const usage = usageFromCodexTokenUsage(data.tokenUsage);
+            if (!usage)
+                return;
+            const key = `${threadId}:${turnId}`;
+            const waiter = this.turnWaiters.get(key);
+            if (waiter) {
+                waiter.usage = usage;
+                waiter.usageUpdatedAt = Date.now();
+                if (waiter.completed)
+                    this.resolveTurnWaiter(threadId, turnId);
+            }
+            else {
+                this.bufferTurnState(key, (state) => {
+                    state.usage = usage;
+                    state.usageUpdatedAt = Date.now();
+                });
+            }
+            return;
+        }
+        if (method === 'turn/completed') {
+            const threadId = typeof data.threadId === 'string' ? data.threadId : null;
+            const turn = asRecord(data.turn);
+            const turnId = typeof turn?.id === 'string' ? turn.id : null;
+            if (!threadId || !turnId)
+                return;
+            const key = `${threadId}:${turnId}`;
+            const waiter = this.turnWaiters.get(key);
+            if (!waiter) {
+                this.bufferTurnState(key, (state) => {
+                    if (turn?.status === 'failed')
+                        state.error = new Error(JSON.stringify(turn.error ?? 'turn failed'));
+                    else {
+                        state.completed = true;
+                        state.completedAt = Date.now();
+                    }
+                });
+                return;
+            }
+            if (turn?.status === 'failed') {
+                this.turnWaiters.delete(key);
+                waiter.reject(new Error(JSON.stringify(turn.error ?? 'turn failed')));
+            }
+            else {
+                this.markWaiterCompleted(threadId, turnId, waiter, Date.now());
+            }
+        }
+    }
+    waitForTurn(threadId, turnId, signal) {
+        const key = `${threadId}:${turnId}`;
+        return new Promise((resolve, reject) => {
+            let waiter;
+            const timer = setTimeout(() => {
+                this.turnWaiters.delete(key);
+                cleanup();
+                reject(new Error(`turn timed out after ${this.timeoutMs}ms`));
+            }, this.timeoutMs);
+            const cleanup = () => {
+                clearTimeout(timer);
+                if (waiter?.usageGraceTimer) {
+                    clearTimeout(waiter.usageGraceTimer);
+                    waiter.usageGraceTimer = undefined;
+                }
+                if (signal)
+                    signal.removeEventListener('abort', abortFromSignal);
+            };
+            const abortFromSignal = () => {
+                this.turnWaiters.delete(key);
+                cleanup();
+                reject(new Error('request aborted'));
+            };
+            waiter = {
+                threadId,
+                turnId,
+                text: '',
+                completed: false,
+                resolve: (value) => {
+                    cleanup();
+                    resolve(value);
+                },
+                reject: (err) => {
+                    cleanup();
+                    reject(err);
+                },
+            };
+            this.turnWaiters.set(key, waiter);
+            if (signal) {
+                if (signal.aborted) {
+                    abortFromSignal();
+                    return;
+                }
+                signal.addEventListener('abort', abortFromSignal, { once: true });
+            }
+            const buffered = this.takeBufferedTurnState(key);
+            if (!buffered)
+                return;
+            waiter.text = buffered.finalText ?? buffered.textDeltas.join('');
+            waiter.usage = buffered.usage;
+            waiter.usageUpdatedAt = buffered.usageUpdatedAt;
+            if (buffered.error) {
+                this.turnWaiters.delete(key);
+                cleanup();
+                reject(buffered.error);
+                return;
+            }
+            if (buffered.completed) {
+                this.markWaiterCompleted(threadId, turnId, waiter, buffered.completedAt ?? Date.now());
+            }
+        });
+    }
+    markWaiterCompleted(threadId, turnId, waiter, completedAt) {
+        waiter.completed = true;
+        waiter.completedAt = completedAt;
+        if (waiter.usage)
+            this.resolveTurnWaiter(threadId, turnId);
+        else {
+            waiter.usageGraceTimer = setTimeout(() => this.resolveTurnWaiter(threadId, turnId), USAGE_NOTIFICATION_GRACE_MS);
+        }
+    }
+    resolveTurnWaiter(threadId, turnId) {
+        const key = `${threadId}:${turnId}`;
+        const waiter = this.turnWaiters.get(key);
+        if (!waiter)
+            return;
+        this.turnWaiters.delete(key);
+        if (waiter.usageGraceTimer) {
+            clearTimeout(waiter.usageGraceTimer);
+            waiter.usageGraceTimer = undefined;
+        }
+        waiter.resolve({
+            text: waiter.text.trim(),
+            usage: waiter.usage,
+            usageWaitMs: waiter.completedAt
+                ? Math.max(0, (waiter.usageUpdatedAt ?? Date.now()) - waiter.completedAt)
+                : 0,
+        });
+    }
+    failAll(err) {
+        const detail = this.stderr ? `\n${this.stderr.slice(-2000)}` : '';
+        const wrapped = new Error(`${err.message}${detail}`);
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(wrapped);
+        }
+        this.pending.clear();
+        for (const waiter of this.turnWaiters.values())
+            waiter.reject(wrapped);
+        this.turnWaiters.clear();
+        this.clearBufferedTurnStates();
+    }
+    modelOverrideFor(requestModel) {
+        if (this.configuredModel)
+            return this.configuredModel;
+        if (!requestModel || requestModel === this.model || requestModel === 'codex-subagent')
+            return undefined;
+        return requestModel;
+    }
+    bufferTurnState(key, apply) {
+        const state = this.bufferedTurnStates.get(key) ?? {
+            textDeltas: [],
+            completed: false,
+        };
+        if (state.cleanupTimer)
+            clearTimeout(state.cleanupTimer);
+        apply(state);
+        state.cleanupTimer = setTimeout(() => {
+            this.bufferedTurnStates.delete(key);
+        }, BUFFERED_TURN_STATE_TTL_MS);
+        this.bufferedTurnStates.set(key, state);
+    }
+    takeBufferedTurnState(key) {
+        const state = this.bufferedTurnStates.get(key);
+        if (!state)
+            return undefined;
+        this.bufferedTurnStates.delete(key);
+        if (state.cleanupTimer) {
+            clearTimeout(state.cleanupTimer);
+            state.cleanupTimer = undefined;
+        }
+        return state;
+    }
+    clearBufferedTurnStates() {
+        for (const state of this.bufferedTurnStates.values()) {
+            if (state.cleanupTimer)
+                clearTimeout(state.cleanupTimer);
+        }
+        this.bufferedTurnStates.clear();
+    }
+}
+function structuredOutputToolFor(request) {
+    if (request.toolChoice.type !== 'required')
+        return null;
+    return request.tools.length === 1 ? request.tools[0] ?? null : null;
+}
+function workflowAgentPrompt(request, structuredTool) {
+    const prompt = request.messages.map((message) => message.content).join('\n\n').trim();
+    if (!structuredTool)
+        return prompt;
+    return [
+        prompt,
+        '',
+        'Return only the JSON value for StructuredOutput. No Markdown, code fence, or prose.',
+    ].join('\n');
+}
+function estimatedUsage(prompt, text) {
+    const inputTokens = estimateTokens(prompt);
+    const outputTokens = estimateTokens(text);
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        source: 'estimated',
+    };
+}
+function turnStateKey(threadId, turnId) {
+    return typeof threadId === 'string' && typeof turnId === 'string'
+        ? `${threadId}:${turnId}`
+        : null;
+}
+function readPath(value, path) {
+    let current = value;
+    for (const part of path) {
+        const obj = asRecord(current);
+        if (!obj)
+            return null;
+        current = obj[part];
+    }
+    return current;
+}
+export function usageFromCodexTokenUsage(value) {
+    const usage = asRecord(value);
+    const last = asRecord(usage?.last);
+    if (!last)
+        return null;
+    const totalTokens = readNumber(last.totalTokens);
+    const inputTokens = readNumber(last.inputTokens);
+    const outputTokens = readNumber(last.outputTokens);
+    const cachedInputTokens = readNumber(last.cachedInputTokens);
+    const reasoningOutputTokens = readNumber(last.reasoningOutputTokens);
+    if (totalTokens === 0
+        && inputTokens === 0
+        && outputTokens === 0
+        && cachedInputTokens === 0
+        && reasoningOutputTokens === 0) {
+        return null;
+    }
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        cachedInputTokens,
+        reasoningOutputTokens,
+        source: 'provider',
+        raw: value,
+    };
+}
+export function codexContextIsolationArgs(options) {
+    return [
+        '-c',
+        `model=${tomlString(options.model)}`,
+        '-c',
+        `model_reasoning_effort=${tomlString(options.reasoningEffort)}`,
+        '-c',
+        'model_reasoning_summary="none"',
+        '-c',
+        `model_verbosity=${tomlString(options.verbosity)}`,
+        '-c',
+        'web_search="disabled"',
+        '-c',
+        'approval_policy="never"',
+        '-c',
+        'sandbox_mode="read-only"',
+        '-c',
+        'shell_environment_policy.inherit="none"',
+        ...DISABLED_CODEX_CONTEXT_FEATURES.flatMap((feature) => [
+            '-c',
+            `features.${feature}=false`,
+        ]),
+        '-c',
+        'notify=[]',
+        '-c',
+        'analytics.enabled=false',
+    ];
+}
+export async function createCodexIsolation(options) {
+    const rootDir = await mkdtemp(join(tmpdir(), 'ultracode-for-codex-codex-'));
+    const homeDir = join(rootDir, 'codex-home');
+    const workDir = join(rootDir, 'workspace');
+    await Promise.all([
+        mkdir(homeDir, { recursive: true }),
+        mkdir(workDir, { recursive: true }),
+    ]);
+    const sourceHome = sourceCodexHome();
+    const defaultModel = options.configuredModel ?? await readTopLevelStringConfig(sourceHome, 'model');
+    await copyCodexAuth(sourceHome, homeDir);
+    await writeFile(join(homeDir, 'config.toml'), minimalCodexConfigToml({
+        model: defaultModel ?? FALLBACK_CODEX_MODEL,
+        reasoningEffort: options.reasoningEffort,
+        verbosity: options.verbosity,
+    }), { mode: 0o600 });
+    return {
+        rootDir,
+        homeDir,
+        workDir,
+        defaultModel,
+    };
+}
+export function minimalCodexConfigToml(options) {
+    return [
+        `model = ${tomlString(options.model)}`,
+        `model_reasoning_effort = ${tomlString(options.reasoningEffort)}`,
+        'model_reasoning_summary = "none"',
+        `model_verbosity = ${tomlString(options.verbosity)}`,
+        'web_search = "disabled"',
+        'approval_policy = "never"',
+        'sandbox_mode = "read-only"',
+        '',
+        '[analytics]',
+        'enabled = false',
+        '',
+        '[features]',
+        ...DISABLED_CODEX_CONTEXT_FEATURES.map((feature) => `${feature} = false`),
+        '',
+        '[shell_environment_policy]',
+        'inherit = "none"',
+        '',
+    ].join('\n');
+}
+function sourceCodexHome() {
+    return process.env.CODEX_HOME && process.env.CODEX_HOME.trim()
+        ? process.env.CODEX_HOME
+        : join(homedir(), '.codex');
+}
+async function copyCodexAuth(sourceHome, targetHome) {
+    try {
+        await copyFile(join(sourceHome, 'auth.json'), join(targetHome, 'auth.json'));
+    }
+    catch {
+        // Let Codex surface its normal auth error if the user has no local auth state.
+    }
+}
+async function readTopLevelStringConfig(sourceHome, key) {
+    let text;
+    try {
+        text = await readFile(join(sourceHome, 'config.toml'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    const match = new RegExp(`^${escapeRegExp(key)}\\s*=\\s*"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"\\s*$`, 'm').exec(text);
+    if (!match?.[1])
+        return undefined;
+    return match[1].replace(/\\(["\\])/g, '$1');
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    return value;
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}

package/dist/runtime/async-queue.d.ts

@@ -0,0 +1,10 @@
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private readonly values;
+    private readonly resolvers;
+    private error;
+    private closed;
+    push(value: T): void;
+    fail(err: Error): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}