@atolis-hq/wake 0.2.97 → 0.3.1

package/dist/src/adapters/codex/codex-runner.js

@@ -1,503 +0,0 @@
-import { buildStagePrompt } from '../runner/stage-prompt.js';
-import { runAgentCliCommand } from '../runner/cli-command.js';
-import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
-import { writeRunnerTranscript } from '../runner/transcripts.js';
-import { createAgentExecution } from '../../core/live-execution.js';
-import { parseRunnerResult } from '../../domain/schema.js';
-const CODEX_CLI_NAME = 'Codex';
-function buildCodexExecPrefixArgs(input) {
-    return [
-        '--ask-for-approval',
-        'never',
-        ...(input.reasoningEffort === undefined
-            ? []
-            : ['-c', `model_reasoning_effort="${input.reasoningEffort}"`]),
-        'exec',
-        '--json',
-        '--skip-git-repo-check',
-        '--sandbox',
-        input.sandboxMode,
-        '--cd',
-        input.cwd,
-        '--model',
-        input.model,
-    ];
-}
-export function buildCodexExecArgs(input) {
-    const prompt = buildCodexPromptText(input);
-    return [...buildCodexExecPrefixArgs(input), prompt];
-}
-export function buildCodexPromptText(input) {
-    return input.harnessPrompt === undefined
-        ? input.prompt
-        : `${input.harnessPrompt}\n\n${input.prompt}`;
-}
-export function buildCodexResumeArgs(input) {
-    const prompt = buildCodexPromptText(input);
-    return [...buildCodexExecPrefixArgs(input), 'resume', input.sessionId, prompt];
-}
-function compactLogValue(value) {
-    return value.replace(/\s+/g, ' ').trim();
-}
-export function formatCodexRunLogLine(input) {
-    const parts = [
-        '[codex-run]',
-        `phase=${input.phase}`,
-        `runId=${input.runId}`,
-        `cli=Codex`,
-        ...(input.model === undefined ? [] : [`model=${input.model}`]),
-        `repo=${input.repo}`,
-        `issueNumber=${input.issueNumber}`,
-        `action=${input.action}`,
-        `recentEventIds=${input.recentEventIds.length > 0 ? input.recentEventIds.join(',') : '(none)'}`,
-        ...(input.workspacePath === undefined
-            ? []
-            : [`workspacePath=${compactLogValue(input.workspacePath)}`]),
-        ...(input.sessionId === undefined ? [] : [`sessionId=${input.sessionId}`]),
-        ...(input.exitCode === undefined ? [] : [`exitCode=${input.exitCode}`]),
-    ];
-    return parts.join(' ');
-}
-export function extractCodexExecResult(stdout) {
-    let result;
-    let sessionId;
-    let turns = 0;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let cachedInputTokens = 0;
-    let sawUsage = false;
-    for (const line of stdout.split(/\r?\n/).filter((entry) => entry.trim().length > 0)) {
-        const event = JSON.parse(line);
-        if (event.type === 'thread.started' && typeof event.thread_id === 'string') {
-            sessionId = event.thread_id;
-            continue;
-        }
-        if (event.type === 'item.completed') {
-            const item = event.item;
-            if (item?.type === 'agent_message' && typeof item.text === 'string') {
-                result = item.text;
-            }
-            continue;
-        }
-        if (event.type === 'turn.completed') {
-            const usage = event.usage;
-            if (usage !== undefined) {
-                sawUsage = true;
-                turns += 1;
-                // Each `turn.completed` reports that turn's own usage (an exec run can
-                // make several model turns via tool calls), so accumulate across turns
-                // rather than keeping only the last one - otherwise a multi-turn run's
-                // reported usage undercounts the actual spend (#135).
-                inputTokens += typeof usage.input_tokens === 'number' ? usage.input_tokens : 0;
-                outputTokens += typeof usage.output_tokens === 'number' ? usage.output_tokens : 0;
-                // OpenAI's Responses API reports cached prompt tokens nested under
-                // input_tokens_details.cached_tokens; unverified against a live Codex
-                // success response (this environment's Codex quota was exhausted while
-                // this adapter was written), so it is read defensively and simply
-                // omitted if absent rather than assumed to exist.
-                const inputTokensDetails = usage.input_tokens_details;
-                if (typeof inputTokensDetails?.cached_tokens === 'number') {
-                    cachedInputTokens += inputTokensDetails.cached_tokens;
-                }
-            }
-        }
-    }
-    if (result === undefined) {
-        throw new Error('Codex exec JSONL stream did not include a final agent message.');
-    }
-    const tokenUsage = sawUsage
-        ? {
-            inputTokens,
-            outputTokens,
-            turns,
-            ...(cachedInputTokens > 0 ? { cacheReadInputTokens: cachedInputTokens } : {}),
-        }
-        : undefined;
-    return {
-        result,
-        ...(sessionId === undefined ? {} : { sessionId }),
-        ...(tokenUsage === undefined ? {} : { tokenUsage }),
-    };
-}
-// Codex exec emits a JSONL stream even on failure (unlike a bare CLI crash,
-// which produces no JSON at all). Reading the structured `message` field off
-// `error`/`turn.failed` events is more reliable than grepping the raw stdout
-// blob, and it is also the string that carries the actual reset-time hint
-// (e.g. "...or try again at 2:29 PM") that quota-backoff needs.
-export function extractCodexErrorMessage(stdout) {
-    for (const line of stdout.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (trimmed.length === 0) {
-            continue;
-        }
-        let event;
-        try {
-            event = JSON.parse(trimmed);
-        }
-        catch {
-            continue;
-        }
-        if (event.type === 'error' && typeof event.message === 'string') {
-            return event.message;
-        }
-        if (event.type === 'turn.failed') {
-            const error = event.error;
-            if (typeof error?.message === 'string') {
-                return error.message;
-            }
-        }
-    }
-    return undefined;
-}
-export function classifyCodexCliFailure(input) {
-    if (input.timedOut) {
-        return 'infra';
-    }
-    const structuredMessage = extractCodexErrorMessage(input.stdout);
-    const text = (structuredMessage ?? `${input.stderr}\n${input.stdout}`).toLowerCase();
-    if (text.includes('missing bearer or basic authentication')) {
-        return 'infra';
-    }
-    if (text.includes('usage limit') ||
-        text.includes('rate limit') ||
-        text.includes('quota') ||
-        text.includes('billing') ||
-        text.includes('credit') ||
-        text.includes('too many requests') ||
-        text.includes('unauthorized') ||
-        text.includes('authentication') ||
-        text.includes('not logged in') ||
-        text.includes('login required')) {
-        return 'quota';
-    }
-    return 'infra';
-}
-function resolveModel(input) {
-    return input.settings.model;
-}
-function readSandboxLogBreadcrumb() {
-    const containerName = process.env.WAKE_SANDBOX_CONTAINER_NAME;
-    if (containerName === undefined || containerName.length === 0) {
-        return null;
-    }
-    return {
-        text: `Sandbox logs: docker logs --tail 200 ${containerName}`,
-        metadata: {
-            sandboxContainerName: containerName,
-        },
-    };
-}
-function resolveSandboxMode(input) {
-    return input.workspaceMode === 'branch' ? 'danger-full-access' : 'workspace-write';
-}
-// Codex uses shell execution rather than Claude Code's named tools (Read/Glob/Grep).
-// For read-only stages, override the tool capability note so the agent is told what it
-// can actually use instead of Claude-specific tool names it does not have.
-export function buildCodexToolCapabilityNote(input) {
-    if (input.workspaceMode !== 'read-only') {
-        return undefined;
-    }
-    const note = 'You may read the repository using standard shell commands (cat, ls, find, grep, head, tail) and git status. ' +
-        'The workspace-write sandbox prevents write and edit operations — do not attempt to modify files.';
-    return input.mode === 'resume' ? `Reminder: this is still a planning-only stage. ${note}` : note;
-}
-export function createCodexRunner(options) {
-    const runner = {
-        async start(input) {
-            return createAgentExecution(input, (liveInput) => runner.run(liveInput));
-        },
-        async run(input) {
-            const priorSessionId = input.projection.wake.sessionId;
-            const priorSessionCli = input.projection.wake.sessionCli;
-            const isResume = priorSessionId !== undefined && priorSessionCli === CODEX_CLI_NAME;
-            const runMode = isResume ? 'resume' : 'start';
-            const toolCapabilityNote = buildCodexToolCapabilityNote({
-                ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
-                mode: runMode,
-            });
-            const stagePrompt = await buildStagePrompt({
-                action: input.action,
-                projection: input.projection,
-                mode: runMode,
-                config: input.config,
-                ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
-                ...(input.mergeConflictDetected === true ? { mergeConflictDetected: true } : {}),
-                ...(input.upstreamChanges === undefined ? {} : { upstreamChanges: input.upstreamChanges }),
-                ...(input.preExistingUncommittedChanges === true
-                    ? { preExistingUncommittedChanges: true }
-                    : {}),
-                ...(toolCapabilityNote !== undefined || input.promptContextOverrides !== undefined
-                    ? {
-                        contextOverrides: {
-                            ...input.promptContextOverrides,
-                            ...(toolCapabilityNote === undefined ? {} : { toolCapabilityNote }),
-                        },
-                    }
-                    : {}),
-            });
-            const model = resolveModel({
-                action: input.action,
-                settings: options.settings,
-            });
-            const cwd = input.workspacePath ?? options.cwd;
-            const sandboxMode = resolveSandboxMode({
-                ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
-            });
-            const promptText = buildCodexPromptText({
-                prompt: stagePrompt.prompt,
-                harnessPrompt: stagePrompt.harnessPrompt,
-            });
-            const promptTranscriptPath = await writeRunnerTranscript({
-                config: input.config,
-                projection: input.projection,
-                runId: input.runId,
-                action: input.action,
-                cli: CODEX_CLI_NAME,
-                kind: 'prompt',
-                text: promptText,
-            });
-            console.log(formatCodexRunLogLine({
-                phase: 'start',
-                runId: input.runId,
-                action: input.action,
-                issueNumber: input.projection.issue.number,
-                repo: input.projection.issue.repo,
-                recentEventIds: input.recentEvents.map((event) => event.eventId),
-                model,
-                ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-                ...(isResume ? { sessionId: priorSessionId } : {}),
-            }));
-            const result = await runAgentCliCommand({
-                command: options.command,
-                args: isResume
-                    ? buildCodexResumeArgs({
-                        model,
-                        prompt: promptText,
-                        cwd,
-                        sandboxMode,
-                        sessionId: priorSessionId,
-                        ...(options.settings.reasoningEffort === undefined
-                            ? {}
-                            : { reasoningEffort: options.settings.reasoningEffort }),
-                    })
-                    : buildCodexExecArgs({
-                        model,
-                        prompt: promptText,
-                        cwd,
-                        sandboxMode,
-                        ...(options.settings.reasoningEffort === undefined
-                            ? {}
-                            : { reasoningEffort: options.settings.reasoningEffort }),
-                    }),
-                cwd,
-                timeoutMs: options.settings.timeoutMs,
-                ...(input.cancellationSignal === undefined
-                    ? {}
-                    : { cancellationSignal: input.cancellationSignal }),
-                onProcessStart: async (identity) => {
-                    await input.onProcessStart?.(identity);
-                    await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                        type: 'agent.process.started',
-                        runId: input.runId,
-                        projection: input.projection,
-                        routing: input.routing,
-                        cli: CODEX_CLI_NAME,
-                        model,
-                        payload: { pid: identity.pid, processStartedAt: identity.processStartedAt },
-                    }));
-                },
-            });
-            const responseTranscriptPath = await writeRunnerTranscript({
-                config: input.config,
-                projection: input.projection,
-                runId: input.runId,
-                action: input.action,
-                cli: CODEX_CLI_NAME,
-                kind: 'response',
-                text: result.stdout,
-            });
-            if (result.exitCode !== 0 || result.timedOut || result.stdout.trim().length === 0) {
-                const sandboxLog = readSandboxLogBreadcrumb();
-                const failureClass = classifyCodexCliFailure({
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                    timedOut: result.timedOut,
-                });
-                const structuredMessage = result.timedOut
-                    ? undefined
-                    : extractCodexErrorMessage(result.stdout);
-                console.error(formatCodexRunLogLine({
-                    phase: 'failure',
-                    runId: input.runId,
-                    action: input.action,
-                    issueNumber: input.projection.issue.number,
-                    repo: input.projection.issue.repo,
-                    recentEventIds: input.recentEvents.map((event) => event.eventId),
-                    model,
-                    ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-                    exitCode: result.exitCode,
-                }));
-                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                    type: 'agent.process.exited',
-                    runId: input.runId,
-                    projection: input.projection,
-                    routing: input.routing,
-                    cli: CODEX_CLI_NAME,
-                    model,
-                    payload: { exitCode: result.exitCode, timedOut: result.timedOut },
-                }));
-                return {
-                    result: [
-                        result.timedOut
-                            ? `Codex runner timed out after ${options.settings.timeoutMs}ms and was killed`
-                            : structuredMessage !== undefined
-                                ? `Codex runner failed: ${structuredMessage}`
-                                : result.stdout.trim().length === 0
-                                    ? 'Codex runner produced no output'
-                                    : 'Codex runner failed',
-                        result.stderr,
-                        sandboxLog?.text,
-                        'FAILED',
-                    ]
-                        .filter((part) => part !== undefined && part.length > 0)
-                        .join('\n'),
-                    model,
-                    cli: CODEX_CLI_NAME,
-                    failureClass,
-                    metadata: {
-                        stdout: result.stdout,
-                        stderr: result.stderr,
-                        exitCode: result.exitCode,
-                        failureClass,
-                        ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
-                        ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
-                        ...(sandboxLog?.metadata ?? {}),
-                    },
-                };
-            }
-            const parsed = extractCodexExecResult(result.stdout);
-            const sandboxLog = readSandboxLogBreadcrumb();
-            const rawEvents = result.stdout
-                .split(/\r?\n/)
-                .filter((line) => line.trim().length > 0)
-                .map((line) => JSON.parse(line));
-            for (const raw of rawEvents) {
-                if (raw.type === 'thread.started' && typeof raw.thread_id === 'string') {
-                    await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                        type: 'agent.session.started',
-                        runId: input.runId,
-                        projection: input.projection,
-                        routing: input.routing,
-                        cli: CODEX_CLI_NAME,
-                        model,
-                        sessionId: raw.thread_id,
-                        payload: { raw },
-                    }));
-                }
-                else if (raw.type === 'turn.completed') {
-                    await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                        type: 'agent.turn.completed',
-                        runId: input.runId,
-                        projection: input.projection,
-                        routing: input.routing,
-                        cli: CODEX_CLI_NAME,
-                        model,
-                        ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-                        payload: { raw },
-                    }));
-                }
-                else if (raw.type === 'item.completed') {
-                    await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                        type: 'agent.progress',
-                        runId: input.runId,
-                        projection: input.projection,
-                        routing: input.routing,
-                        cli: CODEX_CLI_NAME,
-                        model,
-                        ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-                        payload: { raw },
-                    }));
-                }
-            }
-            if (parsed.tokenUsage !== undefined) {
-                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                    type: 'agent.usage.updated',
-                    runId: input.runId,
-                    projection: input.projection,
-                    routing: input.routing,
-                    cli: CODEX_CLI_NAME,
-                    model,
-                    ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-                    payload: { tokenUsage: parsed.tokenUsage },
-                }));
-            }
-            console.log(formatCodexRunLogLine({
-                phase: 'success',
-                runId: input.runId,
-                action: input.action,
-                issueNumber: input.projection.issue.number,
-                repo: input.projection.issue.repo,
-                recentEventIds: input.recentEvents.map((event) => event.eventId),
-                model,
-                ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-                ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-            }));
-            await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                type: 'agent.process.exited',
-                runId: input.runId,
-                projection: input.projection,
-                routing: input.routing,
-                cli: CODEX_CLI_NAME,
-                model,
-                ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-                payload: { exitCode: result.exitCode, timedOut: result.timedOut },
-            }));
-            return {
-                result: parsed.result,
-                model,
-                cli: CODEX_CLI_NAME,
-                ...(parseRunnerResult(parsed.result).status === 'FAILED'
-                    ? { failureClass: 'task' }
-                    : {}),
-                ...(parsed.sessionId === undefined ? {} : { session_id: parsed.sessionId }),
-                ...(parsed.tokenUsage === undefined ? {} : { tokenUsage: parsed.tokenUsage }),
-                metadata: {
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                    raw: rawEvents,
-                    skipApproval: stagePrompt.skipApproval,
-                    allowAutoApproval: stagePrompt.allowAutoApproval,
-                    ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
-                    ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
-                    ...(sandboxLog?.metadata ?? {}),
-                },
-            };
-        },
-        async smoke() {
-            const result = await runAgentCliCommand({
-                command: options.command,
-                args: buildCodexExecArgs({
-                    model: options.settings.smokeModel,
-                    prompt: options.settings.smokePrompt,
-                    cwd: options.cwd,
-                    sandboxMode: 'danger-full-access',
-                    ...(options.settings.reasoningEffort === undefined
-                        ? {}
-                        : { reasoningEffort: options.settings.reasoningEffort }),
-                }),
-                cwd: options.cwd,
-            });
-            const parsed = result.exitCode === 0 && result.stdout.trim().length > 0
-                ? extractCodexExecResult(result.stdout)
-                : undefined;
-            return {
-                text: parsed?.result ?? '',
-                ...(parsed?.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-                stdout: result.stdout,
-                stderr: result.stderr,
-                exitCode: result.exitCode,
-            };
-        },
-    };
-    return runner;
-}