agent-life-bridge 0.1.1

package/dist/agents/cli-runner.js

@@ -0,0 +1,861 @@
+import { randomUUID } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { CLI_FRESH_WATCHDOG_DEFAULTS, CLI_RESUME_WATCHDOG_DEFAULTS, CLI_WATCHDOG_MIN_TIMEOUT_MS, normalizeProviderId, resolveCliBackendConfig, } from './cli-backends.js';
+import { createCliOutputProbe, isSessionExpiredError, parseCliOutput, parseCliStreamChunk, } from './cli-output.js';
+import { CodexAppServerRuntime, } from './codex-app-server-runtime.js';
+import { CliSessionStore, parseAgentSessionKey } from './cli-session-store.js';
+import { buildCodexFchConfigArgs, buildFchEnv, makeFchContextKey, } from './fch-runtime-context.js';
+const CLI_RUN_QUEUES = new Map();
+const DEFAULT_TIMEOUT_MS = 15 * 60 * 1_000;
+class CliExecutionError extends Error {
+    reason;
+    stdout;
+    stderr;
+    exitCode;
+    constructor(message, reason, stdout, stderr, exitCode) {
+        super(message);
+        this.reason = reason;
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.exitCode = exitCode;
+        this.name = 'CliExecutionError';
+    }
+}
+export class LocalCliTurnExecutor {
+    options;
+    activeCodexRuntime = null;
+    drainingCodexRuntimes = new Set();
+    constructor(options) {
+        this.options = options;
+    }
+    async run(params) {
+        const callbacks = params.callbacks ?? {};
+        const providerId = normalizeProviderId(params.provider);
+        const backendResolved = resolveCliBackendConfig(providerId, this.options.config, params.cliBackends);
+        if (!backendResolved) {
+            throw new Error(`Unknown CLI backend: ${params.provider}`);
+        }
+        const sessionStore = this.options.sessionStore ?? new CliSessionStore();
+        const envelope = params.envelope;
+        let existingSessionEntry = await sessionStore.get(envelope.sessionId);
+        const parsedAgentSession = parseAgentSessionKey(envelope.sessionId);
+        if (!existingSessionEntry && parsedAgentSession) {
+            existingSessionEntry = await sessionStore.getWithLegacyFallback(envelope.sessionId, parsedAgentSession.originalKey);
+        }
+        const sessionEntry = await sessionStore.ensureSession(envelope.sessionId, {
+            provider: providerId,
+            model: params.model,
+        });
+        const existingCliSessionId = await sessionStore.getCliSessionId(envelope.sessionId, providerId);
+        if (providerId === 'codex-cli' && !existingCliSessionId && existingSessionEntry?.provider === providerId) {
+            this.options.logger.warn({
+                provider: providerId,
+                sessionId: envelope.sessionId,
+                runtimeSessionId: sessionEntry.runtimeSessionId,
+            }, 'No persisted Codex thread id found for existing agent-life session; next turn will start fresh');
+        }
+        await this.emitProcessing(callbacks);
+        const queueKey = backendResolved.config.serialize === false
+            ? `${backendResolved.id}:${randomUUID()}`
+            : `${backendResolved.id}:${envelope.sessionId}`;
+        return enqueueCliRun(queueKey, async ({ queueWaitMs }) => {
+            try {
+                const result = await this.executeTurn({
+                    envelope,
+                    providerId,
+                    model: params.model,
+                    workspaceDir: params.workspaceDir,
+                    timeoutMs: params.timeoutMs || this.options.defaultTimeoutMs || DEFAULT_TIMEOUT_MS,
+                    systemPrompt: params.systemPrompt,
+                    backend: backendResolved.config,
+                    cliSessionId: existingCliSessionId,
+                    queueWaitMs,
+                    runtimeSessionId: sessionEntry.runtimeSessionId,
+                    agentEnv: params.agentEnv,
+                    agentClearEnv: params.agentClearEnv,
+                    fchContext: params.fchContext,
+                    callbacks,
+                });
+                if (result.cliSessionId) {
+                    await sessionStore.setCliSessionId(envelope.sessionId, providerId, result.cliSessionId, {
+                        model: params.model,
+                    });
+                }
+                else if (providerId === 'codex-cli') {
+                    this.options.logger.warn({
+                        provider: providerId,
+                        sessionId: envelope.sessionId,
+                        runtimeSessionId: sessionEntry.runtimeSessionId,
+                        isResume: result.isResume,
+                        diagnostics: result.diagnostics,
+                    }, 'Codex turn completed without a persisted thread id; future turns will remain fresh');
+                }
+                else {
+                    await sessionStore.ensureSession(envelope.sessionId, {
+                        provider: providerId,
+                        model: params.model,
+                    });
+                }
+                return result;
+            }
+            catch (error) {
+                if (existingCliSessionId &&
+                    isSessionExpiredError(error) &&
+                    (providerId === 'codex-cli' ||
+                        Boolean(backendResolved.config.resumeArgs && backendResolved.config.resumeArgs.length > 0))) {
+                    this.options.logger.warn({ provider: providerId, sessionId: envelope.sessionId }, 'CLI session expired, clearing provider mapping and retrying fresh turn');
+                    await sessionStore.clearCliSessionId(envelope.sessionId, providerId, { model: params.model });
+                    const retried = await this.executeTurn({
+                        envelope,
+                        providerId,
+                        model: params.model,
+                        workspaceDir: params.workspaceDir,
+                        timeoutMs: params.timeoutMs || this.options.defaultTimeoutMs || DEFAULT_TIMEOUT_MS,
+                        systemPrompt: params.systemPrompt,
+                        backend: backendResolved.config,
+                        cliSessionId: undefined,
+                        queueWaitMs,
+                        runtimeSessionId: sessionEntry.runtimeSessionId,
+                        agentEnv: params.agentEnv,
+                        agentClearEnv: params.agentClearEnv,
+                        fchContext: params.fchContext,
+                        callbacks,
+                    });
+                    if (retried.cliSessionId) {
+                        await sessionStore.setCliSessionId(envelope.sessionId, providerId, retried.cliSessionId, {
+                            model: params.model,
+                        });
+                    }
+                    return retried;
+                }
+                throw error;
+            }
+        });
+    }
+    async emitProcessing(callbacks) {
+        await callbacks.onProcessing?.();
+    }
+    async executeTurn(params) {
+        if (params.providerId === 'codex-cli' && params.backend.runtimeMode === 'app-server') {
+            return this.executeCodexAppServerTurn(params);
+        }
+        return this.executeCliExecTurn(params);
+    }
+    async teardown() {
+        const slots = [
+            ...(this.activeCodexRuntime ? [this.activeCodexRuntime] : []),
+            ...this.drainingCodexRuntimes,
+        ];
+        this.activeCodexRuntime = null;
+        this.drainingCodexRuntimes.clear();
+        await Promise.all(slots.map(async (slot) => {
+            await slot.runtime.teardown().catch(() => undefined);
+        }));
+    }
+    async rotateCodexRuntime() {
+        const slot = this.activeCodexRuntime;
+        if (!slot) {
+            return;
+        }
+        this.activeCodexRuntime = null;
+        if (slot.refCount > 0) {
+            this.drainingCodexRuntimes.add(slot);
+            return;
+        }
+        await slot.runtime.teardown().catch(() => undefined);
+    }
+    async acquireCodexRuntime(backend, fchContext) {
+        const fchContextKey = makeFchContextKey(fchContext);
+        if (this.activeCodexRuntime && this.activeCodexRuntime.fchContextKey !== fchContextKey) {
+            await this.rotateCodexRuntime();
+        }
+        if (!this.activeCodexRuntime) {
+            this.activeCodexRuntime = {
+                runtime: this.options.createCodexRuntime?.(backend, fchContext) ?? new CodexAppServerRuntime({
+                    backend,
+                    logger: this.options.logger,
+                    fchContext,
+                }),
+                refCount: 0,
+                fchContextKey,
+            };
+        }
+        return this.activeCodexRuntime;
+    }
+    async releaseCodexRuntime(slot) {
+        slot.refCount = Math.max(0, slot.refCount - 1);
+        if (!this.drainingCodexRuntimes.has(slot) || slot.refCount > 0) {
+            return;
+        }
+        this.drainingCodexRuntimes.delete(slot);
+        await slot.runtime.teardown().catch(() => undefined);
+    }
+    async executeCodexAppServerTurn(params) {
+        const normalizedModel = normalizeCliModel(params.model, params.backend);
+        const existingCliSessionId = params.cliSessionId?.trim() || undefined;
+        const isResume = Boolean(existingCliSessionId);
+        const promptPayload = buildPromptPayload(params.envelope, params.backend, true);
+        this.options.logger.info({
+            provider: params.providerId,
+            model: normalizedModel,
+            sessionId: params.envelope.sessionId,
+            cliSessionId: existingCliSessionId,
+            runtimeSessionId: params.runtimeSessionId,
+            isResume,
+            runtimeMode: 'app-server',
+        }, 'Starting Codex app-server turn');
+        const slot = await this.acquireCodexRuntime(params.backend, params.fchContext);
+        slot.refCount += 1;
+        try {
+            const result = await slot.runtime.run({
+                sessionId: params.envelope.sessionId,
+                runtimeSessionId: params.runtimeSessionId,
+                existingThreadId: existingCliSessionId,
+                model: normalizedModel,
+                workspaceDir: params.workspaceDir,
+                timeoutMs: params.timeoutMs,
+                noProgressTimeoutMs: resolveCliNoOutputTimeoutMs(params.backend, params.timeoutMs, isResume),
+                systemPrompt: resolveAppServerSystemPrompt(params.backend, params.systemPrompt, !existingCliSessionId),
+                prompt: promptPayload.prompt,
+                imagePaths: promptPayload.imagePaths,
+                onProgress: async (text) => {
+                    await params.callbacks?.onProgress?.(text);
+                },
+                onAssistantMessage: async (text) => {
+                    await params.callbacks?.onAssistantMessage?.(text);
+                },
+            });
+            return {
+                text: result.text,
+                messages: result.messages,
+                provider: params.providerId,
+                model: params.model,
+                cliSessionId: result.cliSessionId,
+                isResume: result.isResume,
+                usage: result.usage,
+                diagnostics: {
+                    ...result.diagnostics,
+                    queueWaitMs: params.queueWaitMs,
+                    totalElapsedMs: result.diagnostics.totalElapsedMs + params.queueWaitMs,
+                },
+            };
+        }
+        finally {
+            await this.releaseCodexRuntime(slot);
+        }
+    }
+    async executeCliExecTurn(params) {
+        const normalizedModel = normalizeCliModel(params.model, params.backend);
+        const existingCliSessionId = params.cliSessionId?.trim() || undefined;
+        const useResume = Boolean(existingCliSessionId &&
+            params.backend.resumeArgs &&
+            params.backend.resumeArgs.length > 0);
+        const sessionIdToSend = resolveSessionIdToSend({
+            backend: params.backend,
+            cliSessionId: existingCliSessionId,
+        });
+        const promptPayload = buildPromptPayload(params.envelope, params.backend, Boolean(params.backend.imageArg));
+        const promptInput = resolvePromptInput({
+            backend: params.backend,
+            prompt: promptPayload.prompt,
+        });
+        const outputMode = useResume
+            ? (params.backend.resumeOutput ?? params.backend.output ?? 'json')
+            : (params.backend.output ?? 'json');
+        const baseArgs = useResume
+            ? (params.backend.resumeArgs ?? params.backend.args ?? [])
+            : (params.backend.args ?? []);
+        const resolvedBaseArgs = useResume
+            ? baseArgs.map((entry) => entry.replaceAll('{sessionId}', existingCliSessionId ?? ''))
+            : baseArgs;
+        const codexFchConfigArgs = params.providerId === 'codex-cli'
+            ? buildCodexFchConfigArgs(params.fchContext)
+            : [];
+        const args = buildCliArgs({
+            backend: params.backend,
+            baseArgs: [...codexFchConfigArgs, ...resolvedBaseArgs],
+            modelId: normalizedModel,
+            sessionId: sessionIdToSend.sessionId,
+            systemPrompt: resolveSystemPrompt(params.backend, params.systemPrompt, sessionIdToSend.isNew, useResume),
+            imagePaths: promptPayload.imagePaths,
+            promptArg: promptInput.promptArg,
+            useResume,
+        });
+        this.options.logger.info({
+            provider: params.providerId,
+            model: normalizedModel,
+            sessionId: params.envelope.sessionId,
+            cliSessionId: existingCliSessionId,
+            runtimeSessionId: params.runtimeSessionId,
+            isResume: useResume,
+        }, 'Starting CLI turn');
+        // Build env per design: process.env → backend.env → agent.env → clear
+        const env = {
+            ...process.env,
+            ...params.backend.env,
+            ...(params.agentEnv ?? {}),
+            ...(params.fchContext ? buildFchEnv(params.fchContext) : {}),
+        };
+        for (const key of params.backend.clearEnv ?? []) {
+            delete env[key];
+        }
+        for (const key of params.agentClearEnv ?? []) {
+            delete env[key];
+        }
+        const probe = createCliOutputProbe({
+            backend: params.backend,
+            mode: outputMode,
+        });
+        let stdoutLineBuffer = '';
+        let lastProgressText = '';
+        let assistantStreamText = '';
+        const output = await executeCliCommand({
+            command: params.backend.command,
+            args,
+            cwd: params.workspaceDir,
+            env,
+            stdin: promptInput.stdin,
+            timeoutMs: params.timeoutMs,
+            noOutputTimeoutMs: resolveCliNoOutputTimeoutMs(params.backend, params.timeoutMs, useResume),
+            outputMode,
+            backend: params.backend,
+            onStdoutChunk(chunk, atMs) {
+                probe.onStdout(chunk, atMs);
+                if (outputMode !== 'jsonl') {
+                    return;
+                }
+                stdoutLineBuffer += chunk;
+                const lines = stdoutLineBuffer.split(/\r?\n/g);
+                stdoutLineBuffer = lines.pop() ?? '';
+                for (const rawLine of lines) {
+                    const parsedChunk = parseCliStreamChunk(rawLine, outputMode, params.backend);
+                    const rawText = parsedChunk?.text;
+                    const nextText = rawText?.trim();
+                    if (parsedChunk?.kind === 'assistant') {
+                        if (parsedChunk.incremental) {
+                            if (rawText === undefined) {
+                                continue;
+                            }
+                            assistantStreamText = `${assistantStreamText}${rawText}`;
+                            if (!assistantStreamText.trim()) {
+                                continue;
+                            }
+                            void Promise.resolve(params.callbacks?.onAssistantMessage?.(assistantStreamText)).catch(() => undefined);
+                            continue;
+                        }
+                        if (!nextText) {
+                            continue;
+                        }
+                        const assistantText = nextText;
+                        assistantStreamText = assistantText;
+                        void Promise.resolve(params.callbacks?.onAssistantMessage?.(assistantText)).catch(() => undefined);
+                        continue;
+                    }
+                    if (!nextText) {
+                        continue;
+                    }
+                    if (nextText === lastProgressText) {
+                        continue;
+                    }
+                    lastProgressText = nextText;
+                    void Promise.resolve(params.callbacks?.onProgress?.(nextText)).catch(() => undefined);
+                }
+            },
+            onStderrChunk(chunk, atMs) {
+                probe.onStderr(chunk, atMs);
+            },
+        });
+        const probeSnapshot = probe.snapshot();
+        if (outputMode === 'jsonl' && stdoutLineBuffer.trim()) {
+            const parsedChunk = parseCliStreamChunk(stdoutLineBuffer, outputMode, params.backend);
+            const rawText = parsedChunk?.text;
+            const nextText = rawText?.trim();
+            if (parsedChunk?.kind === 'assistant') {
+                if (parsedChunk.incremental) {
+                    if (rawText !== undefined) {
+                        assistantStreamText = `${assistantStreamText}${rawText}`;
+                        if (assistantStreamText.trim()) {
+                            await params.callbacks?.onAssistantMessage?.(assistantStreamText);
+                        }
+                    }
+                }
+                else if (nextText) {
+                    assistantStreamText = nextText;
+                    await params.callbacks?.onAssistantMessage?.(nextText);
+                }
+            }
+            else if (nextText && nextText !== lastProgressText) {
+                lastProgressText = nextText;
+                await params.callbacks?.onProgress?.(nextText);
+            }
+        }
+        const parsed = parseCliOutput(output.stdout.trim(), outputMode, params.backend) ?? {
+            text: probeSnapshot.lastText ?? output.stdout.trim(),
+            cliSessionId: probeSnapshot.cliSessionId,
+            usage: probeSnapshot.usage,
+        };
+        const cliSessionId = parsed.cliSessionId ?? probeSnapshot.cliSessionId ?? existingCliSessionId ?? sessionIdToSend.sessionId;
+        const diagnostics = buildRunDiagnostics({
+            queueWaitMs: params.queueWaitMs,
+            commandElapsedMs: output.elapsedMs,
+            outputMode,
+            stdout: output.stdout,
+            stderr: output.stderr,
+            cliSessionId,
+            existingCliSessionId,
+            runtimeSessionId: sessionIdToSend.sessionId,
+            probe: probeSnapshot,
+        });
+        if (params.providerId === 'codex-cli' && !cliSessionId) {
+            this.options.logger.warn({
+                provider: params.providerId,
+                sessionId: params.envelope.sessionId,
+                runtimeSessionId: params.runtimeSessionId,
+                isResume: useResume,
+                diagnostics,
+                stdoutPreview: trimOutputPreview(output.stdout),
+                stderrPreview: trimOutputPreview(output.stderr),
+            }, 'Unable to extract Codex thread id from CLI output');
+        }
+        const text = parsed.text.trim() || probeSnapshot.lastText?.trim() || output.stdout.trim();
+        return {
+            text,
+            provider: params.providerId,
+            model: params.model,
+            cliSessionId,
+            isResume: useResume,
+            usage: parsed.usage,
+            diagnostics,
+        };
+    }
+}
+async function enqueueCliRun(key, task) {
+    const queuedAt = Date.now();
+    const previous = CLI_RUN_QUEUES.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    const tail = previous.catch(() => undefined).then(() => current);
+    CLI_RUN_QUEUES.set(key, tail);
+    await previous.catch(() => undefined);
+    try {
+        return await task({
+            queueWaitMs: Date.now() - queuedAt,
+        });
+    }
+    finally {
+        release();
+        if (CLI_RUN_QUEUES.get(key) === tail) {
+            CLI_RUN_QUEUES.delete(key);
+        }
+    }
+}
+function normalizeCliModel(model, backend) {
+    const trimmed = model.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    const lower = trimmed.toLowerCase();
+    return backend.modelAliases?.[trimmed] ?? backend.modelAliases?.[lower] ?? trimmed;
+}
+function resolveSystemPrompt(backend, systemPrompt, isNewSession, useResume) {
+    const trimmed = systemPrompt?.trim();
+    if (!trimmed || !backend.systemPromptArg || useResume) {
+        return undefined;
+    }
+    const when = backend.systemPromptWhen ?? 'first';
+    if (when === 'never') {
+        return undefined;
+    }
+    if (when === 'first' && !isNewSession) {
+        return undefined;
+    }
+    return trimmed;
+}
+function resolveAppServerSystemPrompt(backend, systemPrompt, isNewThread) {
+    const trimmed = systemPrompt?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const when = backend.systemPromptWhen ?? 'first';
+    if (when === 'never') {
+        return undefined;
+    }
+    if (when === 'first' && !isNewThread) {
+        return undefined;
+    }
+    return trimmed;
+}
+function resolveSessionIdToSend(params) {
+    const mode = params.backend.sessionMode ?? 'always';
+    const existing = params.cliSessionId?.trim();
+    if (mode === 'none') {
+        return { sessionId: undefined, isNew: !existing };
+    }
+    if (mode === 'existing') {
+        return { sessionId: existing, isNew: !existing };
+    }
+    if (existing) {
+        return { sessionId: existing, isNew: false };
+    }
+    return { sessionId: randomUUID(), isNew: true };
+}
+function resolvePromptInput(params) {
+    const inputMode = params.backend.input ?? 'arg';
+    if (inputMode === 'stdin') {
+        return { stdin: params.prompt };
+    }
+    if (params.backend.maxPromptArgChars && params.prompt.length > params.backend.maxPromptArgChars) {
+        return { stdin: params.prompt };
+    }
+    return { promptArg: params.prompt };
+}
+export function buildGroupSenderContext(envelope) {
+    if (envelope.source.chatType === 'private') {
+        return undefined;
+    }
+    const senderName = envelope.source.senderName?.trim();
+    const senderUsername = envelope.source.username?.trim();
+    const payload = {
+        chat_type: envelope.source.chatType,
+        sender_id: String(envelope.source.userId),
+        sender_name: senderName || undefined,
+        sender_username: senderUsername || undefined,
+    };
+    if (!payload.sender_name && !payload.sender_username && !payload.sender_id) {
+        return undefined;
+    }
+    return [
+        'Conversation info (untrusted metadata):',
+        '```json',
+        JSON.stringify(payload, null, 2),
+        '```',
+    ].join('\n');
+}
+export function buildPromptPayload(envelope, backend, useSeparateImageInputs = Boolean(backend.imageArg)) {
+    const imagePaths = envelope.content.attachments
+        .filter((attachment) => attachment.type === 'photo' && attachment.localPath)
+        .map((attachment) => attachment.localPath);
+    const fileLines = envelope.content.attachments.map((attachment) => {
+        const name = attachment.fileName ? ` (${attachment.fileName})` : '';
+        return `Attachment: ${attachment.localPath}${name}`;
+    });
+    const promptParts = envelope.content.promptMode === 'cli_passthrough'
+        ? [envelope.content.text.trim()]
+        : [buildGroupSenderContext(envelope), envelope.content.text.trim()];
+    if (!useSeparateImageInputs && imagePaths.length > 0) {
+        promptParts.push(...imagePaths.map((imagePath) => `Image: ${imagePath}`));
+    }
+    const nonImageFiles = fileLines.filter((line) => !imagePaths.some((imagePath) => line.includes(imagePath)));
+    promptParts.push(...nonImageFiles);
+    return {
+        prompt: promptParts.filter(Boolean).join('\n\n').trim(),
+        imagePaths: useSeparateImageInputs && imagePaths.length > 0 ? imagePaths : undefined,
+    };
+}
+function buildCliArgs(params) {
+    const args = [...params.baseArgs];
+    if (!params.useResume && params.backend.modelArg && params.modelId) {
+        args.push(params.backend.modelArg, params.modelId);
+    }
+    if (!params.useResume && params.systemPrompt && params.backend.systemPromptArg) {
+        args.push(params.backend.systemPromptArg, params.systemPrompt);
+    }
+    if (!params.useResume && params.sessionId) {
+        if (params.backend.sessionArgs && params.backend.sessionArgs.length > 0) {
+            for (const entry of params.backend.sessionArgs) {
+                args.push(entry.replaceAll('{sessionId}', params.sessionId));
+            }
+        }
+        else if (params.backend.sessionArg) {
+            args.push(params.backend.sessionArg, params.sessionId);
+        }
+    }
+    if (params.imagePaths && params.imagePaths.length > 0 && params.backend.imageArg) {
+        const imageMode = params.backend.imageMode ?? 'repeat';
+        if (imageMode === 'list') {
+            args.push(params.backend.imageArg, params.imagePaths.join(','));
+        }
+        else {
+            for (const imagePath of params.imagePaths) {
+                args.push(params.backend.imageArg, imagePath);
+            }
+        }
+    }
+    if (params.promptArg !== undefined) {
+        args.push(params.promptArg);
+    }
+    return args;
+}
+function resolveCliNoOutputTimeoutMs(backend, timeoutMs, useResume) {
+    const defaults = useResume ? CLI_RESUME_WATCHDOG_DEFAULTS : CLI_FRESH_WATCHDOG_DEFAULTS;
+    const configured = useResume
+        ? backend.reliability?.watchdog?.resume
+        : backend.reliability?.watchdog?.fresh;
+    if (configured?.noOutputTimeoutMs) {
+        return Math.max(configured.noOutputTimeoutMs, CLI_WATCHDOG_MIN_TIMEOUT_MS);
+    }
+    const ratio = configured?.noOutputTimeoutRatio ?? defaults.noOutputTimeoutRatio;
+    const minMs = configured?.minMs ?? defaults.minMs;
+    const maxMs = configured?.maxMs ?? defaults.maxMs;
+    const computed = Math.round(timeoutMs * ratio);
+    return Math.max(Math.min(computed, maxMs), Math.max(minMs, CLI_WATCHDOG_MIN_TIMEOUT_MS));
+}
+async function executeCliCommand(params) {
+    return new Promise((resolve, reject) => {
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let settled = false;
+        let timedOutReason = null;
+        const startedAt = Date.now();
+        const child = spawn(params.command, params.args, {
+            cwd: params.cwd,
+            env: params.env,
+            stdio: 'pipe',
+            shell: process.platform === 'win32',
+            windowsHide: true,
+        });
+        const finish = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(overallTimer);
+            clearTimeout(noOutputTimer);
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(result ?? {
+                stdout: decodeCliOutput(Buffer.concat(stdoutChunks)),
+                stderr: decodeCliOutput(Buffer.concat(stderrChunks)),
+                elapsedMs: Date.now() - startedAt,
+            });
+        };
+        const armNoOutputTimer = () => {
+            clearTimeout(noOutputTimer);
+            noOutputTimer = setTimeout(() => {
+                timedOutReason = 'no-output-timeout';
+                child.kill();
+            }, params.noOutputTimeoutMs);
+        };
+        const overallTimer = setTimeout(() => {
+            timedOutReason = 'overall-timeout';
+            child.kill();
+        }, params.timeoutMs);
+        let noOutputTimer = setTimeout(() => undefined, params.noOutputTimeoutMs);
+        armNoOutputTimer();
+        child.on('error', (error) => {
+            finish(new CliExecutionError(error.message, 'spawn-error', decodeCliOutput(Buffer.concat(stdoutChunks)), decodeCliOutput(Buffer.concat(stderrChunks))));
+        });
+        child.stdout?.on('data', (chunk) => {
+            const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            stdoutChunks.push(buffer);
+            params.onStdoutChunk?.(decodeCliOutput(buffer), Date.now() - startedAt);
+            armNoOutputTimer();
+        });
+        child.stderr?.on('data', (chunk) => {
+            const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            stderrChunks.push(buffer);
+            params.onStderrChunk?.(decodeCliOutput(buffer), Date.now() - startedAt);
+            armNoOutputTimer();
+        });
+        child.on('close', (code) => {
+            const stdout = decodeCliOutput(Buffer.concat(stdoutChunks));
+            const stderr = decodeCliOutput(Buffer.concat(stderrChunks));
+            const trimmedStdout = stdout.trim();
+            const trimmedStderr = stderr.trim();
+            const elapsedMs = Date.now() - startedAt;
+            if (timedOutReason) {
+                const timeoutMessage = timedOutReason === 'overall-timeout'
+                    ? `CLI exceeded timeout (${Math.round(params.timeoutMs / 1000)}s) and was terminated.`
+                    : `CLI produced no output for ${Math.round(params.noOutputTimeoutMs / 1000)}s and was terminated.`;
+                finish(new CliExecutionError(timeoutMessage, timedOutReason, trimmedStdout, trimmedStderr, code));
+                return;
+            }
+            if (code !== 0) {
+                finish(new CliExecutionError(buildCliFailureMessage({
+                    stdout: trimmedStdout,
+                    stderr: trimmedStderr,
+                    exitCode: code,
+                    outputMode: params.outputMode,
+                    backend: params.backend,
+                }), 'exit', trimmedStdout, trimmedStderr, code));
+                return;
+            }
+            finish(undefined, { stdout: trimmedStdout, stderr: trimmedStderr, elapsedMs });
+        });
+        if (params.stdin !== undefined && child.stdin) {
+            child.stdin.write(params.stdin);
+        }
+        child.stdin?.end();
+    });
+}
+function decodeCliOutput(buffer) {
+    if (buffer.length === 0) {
+        return '';
+    }
+    const utf8 = buffer.toString('utf8');
+    if (!shouldTryWindowsLegacyDecode(utf8)) {
+        return utf8;
+    }
+    for (const encoding of ['gb18030', 'gbk']) {
+        const decoded = tryDecodeWithEncoding(buffer, encoding);
+        if (decoded && decoded !== utf8) {
+            return decoded;
+        }
+    }
+    return utf8;
+}
+function buildCliFailureMessage(params) {
+    const parsed = parseStructuredCliFailure(params.stdout, params.outputMode, params.backend)
+        ?? parseStructuredCliFailure(params.stderr, params.outputMode, params.backend);
+    if (parsed) {
+        return parsed;
+    }
+    return params.stderr
+        || params.stdout
+        || `CLI failed with exit code ${params.exitCode ?? 'unknown'}.`;
+}
+function parseStructuredCliFailure(raw, outputMode, backend) {
+    const trimmed = raw.trim();
+    if (!trimmed || outputMode === 'text') {
+        return undefined;
+    }
+    if (outputMode === 'jsonl') {
+        const messages = [];
+        for (const line of trimmed.split(/\r?\n/g)) {
+            const message = extractCliFailureMessageFromJson(line, backend);
+            if (message) {
+                messages.push(message);
+            }
+        }
+        return messages.at(-1);
+    }
+    return extractCliFailureMessageFromJson(trimmed, backend);
+}
+function extractCliFailureMessageFromJson(raw, backend) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isPlainRecord(parsed)) {
+            return undefined;
+        }
+        const eventType = getPlainString(parsed.type)?.toLowerCase();
+        const subtype = getPlainString(parsed.subtype) ?? getPlainString(parsed.error_type);
+        const isError = parsed.is_error === true || eventType === 'error' || Boolean(subtype?.toLowerCase().includes('error'));
+        if (!isError) {
+            return undefined;
+        }
+        const message = pickCliFailureText(parsed);
+        if (!message) {
+            return subtype ? `CLI failed: ${subtype}` : undefined;
+        }
+        const providerName = backend?.command ? path.basename(backend.command) : 'CLI';
+        return `${providerName} failed${subtype ? ` (${subtype})` : ''}: ${message}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+function pickCliFailureText(parsed) {
+    const candidates = [
+        parsed.message,
+        parsed.error,
+        parsed.result,
+        parsed.data,
+        parsed.payload,
+    ];
+    for (const candidate of candidates) {
+        const text = collectFailureText(candidate);
+        if (text) {
+            return text;
+        }
+    }
+    return undefined;
+}
+function collectFailureText(value) {
+    if (typeof value === 'string') {
+        return value.trim() || undefined;
+    }
+    if (!isPlainRecord(value)) {
+        return undefined;
+    }
+    return getPlainString(value.message)
+        ?? getPlainString(value.text)
+        ?? getPlainString(value.details)
+        ?? getPlainString(value.description);
+}
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function getPlainString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function shouldTryWindowsLegacyDecode(decoded) {
+    if (process.platform !== 'win32') {
+        return false;
+    }
+    const replacementCount = (decoded.match(/\uFFFD/g) ?? []).length;
+    if (replacementCount > 0) {
+        return true;
+    }
+    // Common mojibake markers when UTF-8/Chinese text is decoded with the wrong code page.
+    return ['鈥', '銆', '锛', '鏈', '鍦', '浠', '闂'].some((marker) => decoded.includes(marker));
+}
+function tryDecodeWithEncoding(buffer, encoding) {
+    try {
+        // TextDecoder coverage depends on the Node/ICU build; guard runtime support.
+        return new TextDecoder(encoding, { fatal: false }).decode(buffer);
+    }
+    catch {
+        return null;
+    }
+}
+function buildRunDiagnostics(params) {
+    let cliSessionIdSource;
+    if (params.cliSessionId) {
+        if (params.probe.cliSessionId && params.cliSessionId === params.probe.cliSessionId) {
+            cliSessionIdSource = 'stream';
+        }
+        else if (params.existingCliSessionId && params.cliSessionId === params.existingCliSessionId) {
+            cliSessionIdSource = 'existing';
+        }
+        else if (params.runtimeSessionId && params.cliSessionId === params.runtimeSessionId) {
+            cliSessionIdSource = 'runtime';
+        }
+        else {
+            cliSessionIdSource = 'parsed';
+        }
+    }
+    return {
+        queueWaitMs: params.queueWaitMs,
+        commandElapsedMs: params.commandElapsedMs,
+        totalElapsedMs: params.queueWaitMs + params.commandElapsedMs,
+        outputMode: params.outputMode,
+        runtimeMode: 'exec',
+        hadStdout: Boolean(params.stdout),
+        hadStderr: Boolean(params.stderr),
+        firstStdoutMs: params.probe.firstStdoutMs,
+        firstStderrMs: params.probe.firstStderrMs,
+        threadStartedMs: params.probe.threadStartedMs,
+        firstAgentMessageMs: params.probe.firstAgentMessageMs,
+        turnCompletedMs: params.probe.turnCompletedMs,
+        reconnectCount: params.probe.reconnectCount,
+        fellBackToHttps: params.probe.fellBackToHttps,
+        threadOperation: params.existingCliSessionId ? 'resume' : 'start',
+        threadOperationElapsedMs: params.probe.threadStartedMs,
+        cliSessionIdSource,
+    };
+}
+function trimOutputPreview(raw, limit = 1200) {
+    const normalized = raw.trim();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized.length <= limit) {
+        return normalized;
+    }
+    return `${normalized.slice(0, limit)}...`;
+}
+//# sourceMappingURL=cli-runner.js.map