crewx-agent-cli 0.2.0

package/dist/adapters.js

@@ -0,0 +1,1085 @@
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { chmod, mkdtemp, realpath, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { AgentAdapterSchema } from 'crewx-agent-protocol';
+import { CLI_VERSION, DEFAULT_RUN_TIMEOUT_MS, MAX_AGENT_OUTPUT_BYTES } from './constants.js';
+import { CliError } from './errors.js';
+function terminateChild(child, signal) {
+    if (process.platform !== 'win32' && child.pid) {
+        try {
+            process.kill(-child.pid, signal);
+            return;
+        }
+        catch {
+            // Fall back to signalling the direct child when the process group is gone.
+        }
+    }
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // The child may have exited between the state check and the signal.
+    }
+}
+function observeChild(child) {
+    let closed = false;
+    return {
+        close: new Promise((resolve) => {
+            child.once('close', (exitCode, signal) => {
+                closed = true;
+                resolve([exitCode, signal]);
+            });
+        }),
+        isClosed: () => closed,
+    };
+}
+function destroyChildPipes(child) {
+    child.stdin.destroy();
+    child.stdout.destroy();
+    child.stderr.destroy();
+}
+async function terminateAndWait(child, lifecycle, graceMs) {
+    if (lifecycle.isClosed() || child.exitCode !== null)
+        return;
+    terminateChild(child, 'SIGTERM');
+    let graceTimer;
+    await Promise.race([
+        lifecycle.close,
+        new Promise((resolve) => {
+            graceTimer = setTimeout(resolve, graceMs);
+        }),
+    ]);
+    if (graceTimer)
+        clearTimeout(graceTimer);
+    if (lifecycle.isClosed() || child.exitCode !== null)
+        return;
+    terminateChild(child, 'SIGKILL');
+    let killTimer;
+    await Promise.race([
+        lifecycle.close,
+        new Promise((resolve) => {
+            killTimer = setTimeout(resolve, 1_000);
+        }),
+    ]);
+    if (killTimer)
+        clearTimeout(killTimer);
+    if (!lifecycle.isClosed())
+        destroyChildPipes(child);
+}
+export function parseAdapter(value) {
+    const result = AgentAdapterSchema.safeParse(value);
+    if (!result.success) {
+        throw new CliError(`Unknown adapter "${value}". Choose codex, claude, pi, hermes, or openclaw.`);
+    }
+    return result.data;
+}
+/** Adapter commands are represented as argv and are never evaluated by a shell. */
+export function buildAdapterInvocation(adapter, profile = {}, codingCommand) {
+    if (codingCommand?.trim())
+        return buildCustomInvocation(codingCommand);
+    const modelArgs = profile.model ? ['--model', profile.model] : [];
+    const restricted = profile.chatOnly === true || profile.permissionPreset === 'read_only';
+    const codexPermissionArgs = profile.permissionPreset === 'full_access'
+        ? ['--dangerously-bypass-approvals-and-sandbox']
+        : [
+            '-c',
+            'approval_policy="never"',
+            '--sandbox',
+            restricted ? 'read-only' : 'workspace-write',
+        ];
+    switch (adapter) {
+        case 'codex':
+            return {
+                command: 'codex',
+                args: [
+                    'exec',
+                    '--json',
+                    '--color',
+                    'never',
+                    '--skip-git-repo-check',
+                    '--ephemeral',
+                    ...modelArgs,
+                    ...codexPermissionArgs,
+                    '-',
+                ],
+                output: 'jsonl',
+                prompt: { type: 'stdin' },
+            };
+        case 'claude':
+            return {
+                command: 'claude',
+                args: [
+                    '--print',
+                    '--output-format',
+                    'stream-json',
+                    '--verbose',
+                    '--no-session-persistence',
+                    ...modelArgs,
+                    ...(restricted
+                        ? ['--permission-mode', 'plan']
+                        : profile.permissionPreset === 'full_access'
+                            ? ['--dangerously-skip-permissions']
+                            : ['--permission-mode', 'acceptEdits']),
+                ],
+                output: 'jsonl',
+                prompt: { type: 'stdin' },
+            };
+        case 'pi':
+            return {
+                command: 'pi',
+                args: [
+                    '--mode',
+                    'json',
+                    '--print',
+                    '--no-approve',
+                    '--no-session',
+                    ...modelArgs,
+                    ...(restricted ? ['--tools', 'read,grep,find,ls'] : []),
+                ],
+                output: 'jsonl',
+                prompt: { type: 'stdin' },
+            };
+        case 'hermes':
+            return {
+                command: 'hermes',
+                args: ['acp'],
+                output: 'jsonl',
+                prompt: { type: 'stdin' },
+            };
+        case 'openclaw':
+            if (!profile.runtimeAgentId?.trim()) {
+                throw new CliError('OpenClaw requires an explicit configured agent ID.');
+            }
+            return {
+                command: 'openclaw',
+                args: [
+                    'agent',
+                    '--local',
+                    '--agent',
+                    profile.runtimeAgentId.trim(),
+                    '--session-key',
+                    profile.sessionKey ?? 'main',
+                    '--json',
+                    '--timeout',
+                    '0',
+                    ...modelArgs,
+                ],
+                output: 'json',
+                prompt: { type: 'file', flag: '--message-file' },
+            };
+    }
+}
+export function parseCodingCommand(value) {
+    const tokens = [];
+    let token = '';
+    let quote;
+    let escaped = false;
+    let started = false;
+    for (const character of value.trim()) {
+        if (escaped) {
+            token += character;
+            escaped = false;
+            started = true;
+            continue;
+        }
+        if (character === '\\' && quote !== 'single') {
+            escaped = true;
+            started = true;
+            continue;
+        }
+        if (character === "'" && quote !== 'double') {
+            quote = quote === 'single' ? undefined : 'single';
+            started = true;
+            continue;
+        }
+        if (character === '"' && quote !== 'single') {
+            quote = quote === 'double' ? undefined : 'double';
+            started = true;
+            continue;
+        }
+        if (/\s/.test(character) && !quote) {
+            if (started) {
+                tokens.push(token);
+                token = '';
+                started = false;
+            }
+            continue;
+        }
+        token += character;
+        started = true;
+    }
+    if (escaped || quote)
+        throw new CliError('The coding command contains an unfinished quote or escape.');
+    if (started)
+        tokens.push(token);
+    if (tokens.length === 0 || !tokens[0])
+        throw new CliError('The coding command cannot be empty.');
+    return tokens;
+}
+function buildCustomInvocation(value) {
+    const tokens = parseCodingCommand(value);
+    const command = tokens[0];
+    const args = tokens.slice(1);
+    const promptIndexes = args.flatMap((argument, index) => (argument === '{prompt}' ? [index] : []));
+    if (promptIndexes.length > 1)
+        throw new CliError('Use {prompt} at most once in the coding command.');
+    const index = promptIndexes[0] ?? args.length;
+    if (promptIndexes.length === 1)
+        args.splice(index, 1);
+    return {
+        command,
+        args,
+        output: 'text',
+        prompt: { type: 'argument', index },
+    };
+}
+function contentText(value) {
+    if (typeof value === 'string' && value.trim())
+        return value;
+    if (!Array.isArray(value))
+        return undefined;
+    const parts = [];
+    for (const part of value) {
+        if (typeof part === 'string') {
+            parts.push(part);
+        }
+        else if (typeof part === 'object' && part !== null) {
+            const record = part;
+            if ((record.type === 'text' || record.type === 'output_text') && typeof record.text === 'string') {
+                parts.push(record.text);
+            }
+        }
+    }
+    return parts.length > 0 ? parts.join('') : undefined;
+}
+function finalPiAssistantMessage(event) {
+    // Pi's message_start/message_update/message_end events all carry the current,
+    // cumulative assistant snapshot. Publishing those snapshots produces a new
+    // CrewX message for every token. agent_end is Pi's single terminal event for
+    // a run, and its messages array contains the completed agent turns.
+    if (event.type !== 'agent_end' || event.willRetry === true || !Array.isArray(event.messages)) {
+        return undefined;
+    }
+    for (let index = event.messages.length - 1; index >= 0; index -= 1) {
+        const candidate = event.messages[index];
+        if (typeof candidate !== 'object' || candidate === null)
+            continue;
+        const message = candidate;
+        if (message.role !== 'assistant')
+            continue;
+        const text = contentText(message.content);
+        if (text)
+            return text;
+    }
+    return undefined;
+}
+export function parseAdapterLine(adapter, line) {
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        return { raw: line };
+    }
+    if (typeof raw !== 'object' || raw === null)
+        return { raw };
+    const event = raw;
+    const eventType = typeof event.type === 'string' ? event.type : undefined;
+    let message;
+    let role;
+    if (adapter === 'codex') {
+        const item = typeof event.item === 'object' && event.item !== null ? event.item : undefined;
+        if (item?.type === 'agent_message') {
+            message = contentText(item.text) ?? contentText(item.content);
+            role = 'assistant';
+        }
+        else if (eventType === 'agent_message') {
+            message = contentText(event.message) ?? contentText(event.text);
+            role = 'assistant';
+        }
+    }
+    else if (adapter === 'claude') {
+        const messageObject = typeof event.message === 'object' && event.message !== null
+            ? event.message
+            : undefined;
+        if (eventType === 'result' && event.is_error !== true) {
+            message = contentText(event.result);
+            role = 'assistant';
+        }
+        else if (eventType === 'assistant' || messageObject?.role === 'assistant') {
+            message = contentText(messageObject?.content ?? event.content);
+            role = 'assistant';
+        }
+        else if (eventType === 'content_block_delta') {
+            const delta = typeof event.delta === 'object' && event.delta !== null ? event.delta : undefined;
+            message = contentText(delta?.text);
+            role = 'assistant';
+        }
+    }
+    else if (adapter === 'pi') {
+        message = finalPiAssistantMessage(event);
+        if (message) {
+            role = 'assistant';
+        }
+    }
+    return {
+        raw,
+        ...(message ? { message } : {}),
+        ...(role ? { role } : {}),
+        ...(eventType ? { eventType } : {}),
+    };
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+async function resolvedPath(value, label) {
+    try {
+        return await realpath(value);
+    }
+    catch (error) {
+        throw new CliError(`${label} does not resolve to an accessible local directory: ${value}`, 1, { cause: error });
+    }
+}
+async function openClawJsonProbe(args, options) {
+    const spawnProcess = options.spawnProcess ?? spawn;
+    let child;
+    try {
+        child = spawnProcess('openclaw', args, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.environment },
+            shell: false,
+            detached: process.platform !== 'win32',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (error) {
+        throw new CliError('Unable to start openclaw. Is it installed and on PATH?', 1, { cause: error });
+    }
+    let stdout = '';
+    let stderr = '';
+    let bytes = 0;
+    let exceeded = false;
+    let forceKill;
+    const stopProbe = () => {
+        if (child.exitCode !== null)
+            return;
+        terminateChild(child, 'SIGTERM');
+        forceKill ??= setTimeout(() => terminateChild(child, 'SIGKILL'), 5_000);
+        forceKill.unref();
+    };
+    const consume = (stream, chunk) => {
+        if (exceeded)
+            return;
+        bytes += Buffer.byteLength(chunk);
+        if (bytes > 1024 * 1024) {
+            exceeded = true;
+            stopProbe();
+            return;
+        }
+        if (stream === 'stdout')
+            stdout += chunk.toString();
+        else
+            stderr += chunk.toString();
+    };
+    child.stdout.on('data', (chunk) => consume('stdout', chunk));
+    child.stderr.on('data', (chunk) => consume('stderr', chunk));
+    child.stdin.on('error', () => undefined);
+    child.stdin.end();
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+        timedOut = true;
+        stopProbe();
+    }, 15_000);
+    timeout.unref();
+    try {
+        const [code] = (await Promise.race([
+            once(child, 'close'),
+            once(child, 'error').then(([error]) => {
+                throw error;
+            }),
+        ]));
+        if (timedOut)
+            throw new CliError(`OpenClaw preflight timed out: openclaw ${args.join(' ')}`);
+        if (exceeded)
+            throw new CliError('OpenClaw preflight exceeded its 1048576 byte output limit.');
+        if (code !== 0) {
+            throw new CliError(`OpenClaw preflight failed: ${stderr.trim() || `exit ${String(code)}`}`);
+        }
+        try {
+            return JSON.parse(stdout);
+        }
+        catch (error) {
+            throw new CliError('OpenClaw preflight returned invalid JSON.', 1, { cause: error });
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+        if (forceKill)
+            clearTimeout(forceKill);
+        if (child.exitCode === null && !child.killed)
+            stopProbe();
+    }
+}
+export async function verifyOpenClawRuntime(options) {
+    const agentId = options.profile.runtimeAgentId?.trim();
+    if (!agentId)
+        throw new CliError('OpenClaw requires an explicit configured agent ID.');
+    const desiredWorkspace = await resolvedPath(options.cwd, 'CrewX assignment directory');
+    const agents = await openClawJsonProbe(['agents', 'list', '--json'], options);
+    if (!Array.isArray(agents))
+        throw new CliError('OpenClaw returned an invalid agent list.');
+    const selected = agents.map(record).find((agent) => agent?.id === agentId);
+    if (!selected) {
+        throw new CliError(`OpenClaw agent "${agentId}" is not configured. Run \`openclaw agents list --json\` to choose one.`);
+    }
+    if (typeof selected.workspace !== 'string' || !selected.workspace.trim()) {
+        throw new CliError(`OpenClaw agent "${agentId}" does not report a workspace.`);
+    }
+    const configuredWorkspace = await resolvedPath(selected.workspace, `OpenClaw agent "${agentId}" workspace`);
+    if (configuredWorkspace !== desiredWorkspace) {
+        throw new CliError(`OpenClaw agent "${agentId}" uses workspace "${configuredWorkspace}", but this CrewX assignment requires "${desiredWorkspace}". OpenClaw has no per-run --cwd. Create a dedicated agent with: openclaw agents add <name> --workspace "${desiredWorkspace}" --non-interactive --json`);
+    }
+    const sessionLeaf = options.profile.sessionKey ?? 'main';
+    const fullSessionKey = `agent:${agentId}:${sessionLeaf}`;
+    const explanation = record(await openClawJsonProbe(['sandbox', 'explain', '--session', fullSessionKey, '--json'], options));
+    const sandbox = record(explanation?.sandbox);
+    if (explanation?.agentId !== agentId || explanation?.sessionKey !== fullSessionKey || !sandbox) {
+        throw new CliError('OpenClaw sandbox preflight did not describe the requested agent session.');
+    }
+    const effectiveHostRoot = typeof sandbox.effectiveHostWorkspaceRoot === 'string'
+        ? await resolvedPath(sandbox.effectiveHostWorkspaceRoot, 'OpenClaw effective workspace')
+        : undefined;
+    if (effectiveHostRoot !== desiredWorkspace) {
+        throw new CliError('OpenClaw sandbox policy does not expose the exact CrewX assignment directory.');
+    }
+    if (sandbox.sessionIsSandboxed === true) {
+        if (sandbox.backend !== 'docker' ||
+            sandbox.workspaceAccess !== 'rw' ||
+            typeof sandbox.runtimeWorkdir !== 'string') {
+            throw new CliError('OpenClaw must grant rw workspace access for CrewX coding assignments.');
+        }
+        const mounts = Array.isArray(sandbox.workspaceMounts) ? sandbox.workspaceMounts.map(record) : [];
+        let writableWorkspaceMount = false;
+        for (const mount of mounts) {
+            if (typeof mount?.hostRoot === 'string' &&
+                typeof mount.containerRoot === 'string' &&
+                mount.containerRoot === sandbox.runtimeWorkdir &&
+                mount.writable === true &&
+                (await resolvedPath(mount.hostRoot, 'OpenClaw sandbox mount')) === desiredWorkspace) {
+                writableWorkspaceMount = true;
+                break;
+            }
+        }
+        if (!writableWorkspaceMount) {
+            throw new CliError('OpenClaw sandbox policy does not mount the CrewX assignment directory read-write at its runtime workdir.');
+        }
+    }
+    else {
+        if (typeof sandbox.runtimeWorkdir !== 'string') {
+            throw new CliError('OpenClaw did not report its direct runtime working directory.');
+        }
+        const runtimeWorkdir = await resolvedPath(sandbox.runtimeWorkdir, 'OpenClaw runtime working directory');
+        if (runtimeWorkdir !== desiredWorkspace) {
+            throw new CliError('OpenClaw direct runtime workdir does not match the CrewX assignment directory.');
+        }
+    }
+}
+function openClawMessages(value) {
+    const payloads = record(value)?.payloads;
+    if (!Array.isArray(payloads))
+        return [];
+    return payloads.flatMap((payload) => {
+        const text = record(payload)?.text;
+        return typeof text === 'string' && text.trim() ? [text] : [];
+    });
+}
+function createLineConsumer(callback) {
+    let pending = '';
+    return {
+        write(chunk) {
+            pending += chunk.toString();
+            while (true) {
+                const newline = pending.indexOf('\n');
+                if (newline < 0)
+                    break;
+                const line = pending.slice(0, newline).replace(/\r$/, '');
+                pending = pending.slice(newline + 1);
+                if (line.length > 0)
+                    callback(line);
+            }
+        },
+        end() {
+            const line = pending.replace(/\r$/, '');
+            if (line.length > 0)
+                callback(line);
+            pending = '';
+        },
+    };
+}
+async function materializeInvocation(invocation, prompt) {
+    if (invocation.prompt.type === 'stdin') {
+        return { args: invocation.args, stdin: prompt, cleanup: async () => undefined };
+    }
+    if (invocation.prompt.type === 'argument') {
+        const args = [...invocation.args];
+        args.splice(invocation.prompt.index, 0, prompt);
+        return { args, stdin: '', cleanup: async () => undefined };
+    }
+    const directory = await mkdtemp(join(tmpdir(), 'crewx-prompt-'));
+    try {
+        await chmod(directory, 0o700);
+        const path = join(directory, 'prompt.txt');
+        await writeFile(path, prompt, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+        await chmod(path, 0o600);
+        return {
+            args: [...invocation.args, invocation.prompt.flag, path],
+            stdin: '',
+            cleanup: async () => rm(directory, { recursive: true, force: true }),
+        };
+    }
+    catch (error) {
+        await rm(directory, { recursive: true, force: true });
+        throw error;
+    }
+}
+function emitMessage(options, messages, message, role = 'assistant') {
+    if (!message.trim())
+        return;
+    messages.push(message);
+    options.onMessage?.(message, role);
+}
+async function runSpawnAdapter(options) {
+    if (!options.prompt.trim())
+        throw new CliError('Agent prompt cannot be empty.');
+    const invocation = buildAdapterInvocation(options.adapter, options.profile, options.codingCommand);
+    if (options.adapter === 'openclaw' && !options.codingCommand) {
+        await verifyOpenClawRuntime({
+            cwd: options.cwd,
+            profile: options.profile ?? {},
+            ...(options.environment ? { environment: options.environment } : {}),
+            ...(options.spawnProcess ? { spawnProcess: options.spawnProcess } : {}),
+        });
+    }
+    const materialized = await materializeInvocation(invocation, options.prompt);
+    const spawnProcess = options.spawnProcess ?? spawn;
+    let child;
+    try {
+        child = spawnProcess(invocation.command, materialized.args, {
+            cwd: options.cwd,
+            env: {
+                ...process.env,
+                ...options.environment,
+            },
+            shell: false,
+            detached: process.platform !== 'win32',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (error) {
+        await materialized.cleanup();
+        throw new CliError(`Unable to start ${invocation.command}. Is it installed and on PATH?`, 1, { cause: error });
+    }
+    const lifecycle = observeChild(child);
+    const stdout = [];
+    const stderr = [];
+    const messages = [];
+    const finalMessageOnly = !options.codingCommand &&
+        (options.adapter === 'codex' || options.adapter === 'claude' || options.adapter === 'pi');
+    let pendingFinalMessage;
+    const maxOutputBytes = options.maxOutputBytes ?? MAX_AGENT_OUTPUT_BYTES;
+    let outputBytes = 0;
+    let outputLimitExceeded = false;
+    const stdoutLines = createLineConsumer((line) => {
+        stdout.push(line);
+        const parsed = parseAdapterLine(options.adapter, line);
+        options.onStdout?.(line, parsed);
+        if (parsed.message) {
+            if (finalMessageOnly) {
+                pendingFinalMessage = { message: parsed.message, role: parsed.role ?? 'assistant' };
+            }
+            else {
+                emitMessage(options, messages, parsed.message, parsed.role);
+            }
+        }
+    });
+    const stderrLines = createLineConsumer((line) => {
+        stderr.push(line);
+        options.onStderr?.(line);
+    });
+    let forceKill;
+    let hardStop;
+    let forcedClosed = false;
+    let rejectTermination;
+    const terminationFailure = new Promise((_resolve, reject) => {
+        rejectTermination = reject;
+    });
+    let timedOut = false;
+    let terminating = false;
+    const terminationGraceMs = options.adapter === 'openclaw' ? 60_000 : 5_000;
+    const abort = () => {
+        if (lifecycle.isClosed() || child.exitCode !== null || terminating)
+            return;
+        terminating = true;
+        terminateChild(child, 'SIGTERM');
+        forceKill = setTimeout(() => {
+            if (!lifecycle.isClosed())
+                terminateChild(child, 'SIGKILL');
+        }, terminationGraceMs);
+        hardStop = setTimeout(() => {
+            if (lifecycle.isClosed())
+                return;
+            forcedClosed = true;
+            terminateChild(child, 'SIGKILL');
+            destroyChildPipes(child);
+            rejectTermination?.(new CliError(`${invocation.command} did not close after forced termination.`));
+        }, terminationGraceMs + 1_000);
+    };
+    const consumeOutput = (consumer, chunk) => {
+        if (outputLimitExceeded)
+            return;
+        outputBytes += Buffer.byteLength(chunk);
+        if (outputBytes > maxOutputBytes) {
+            outputLimitExceeded = true;
+            abort();
+            return;
+        }
+        consumer(chunk);
+    };
+    child.stdout.on('data', (chunk) => consumeOutput(stdoutLines.write, chunk));
+    child.stderr.on('data', (chunk) => consumeOutput(stderrLines.write, chunk));
+    if (options.signal?.aborted)
+        abort();
+    options.signal?.addEventListener('abort', abort, { once: true });
+    const runTimeout = setTimeout(() => {
+        timedOut = true;
+        abort();
+    }, options.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS);
+    const spawnError = new Promise((_resolve, reject) => {
+        child.once('error', (error) => {
+            reject(new CliError(`Unable to start ${invocation.command}. Is it installed and on PATH?`, 1, { cause: error }));
+        });
+    });
+    const stdinError = new Promise((_resolve, reject) => {
+        child.stdin.once('error', (error) => {
+            reject(new CliError(`${invocation.command} closed its input before receiving the prompt.`, 1, { cause: error }));
+        });
+    });
+    try {
+        child.stdin.end(materialized.stdin, 'utf8');
+        const [exitCode, signal] = (await Promise.race([
+            lifecycle.close,
+            spawnError,
+            stdinError,
+            terminationFailure,
+        ]));
+        stdoutLines.end();
+        stderrLines.end();
+        if (timedOut)
+            throw new CliError(`${invocation.command} exceeded the CrewX run timeout.`);
+        if (outputLimitExceeded) {
+            throw new CliError(`${invocation.command} exceeded the ${String(maxOutputBytes)} byte CrewX output limit.`);
+        }
+        if (exitCode === 0 && !options.signal?.aborted && pendingFinalMessage) {
+            emitMessage(options, messages, pendingFinalMessage.message, pendingFinalMessage.role);
+        }
+        const completeOutput = stdout.join('\n').trim();
+        if (exitCode === 0 && messages.length === 0 && completeOutput) {
+            if (invocation.output === 'json') {
+                let parsed;
+                try {
+                    parsed = JSON.parse(completeOutput);
+                }
+                catch (error) {
+                    throw new CliError(`${invocation.command} returned invalid JSON output.`, 1, { cause: error });
+                }
+                for (const message of openClawMessages(parsed))
+                    emitMessage(options, messages, message);
+            }
+            else if (invocation.output === 'text') {
+                emitMessage(options, messages, completeOutput);
+            }
+        }
+        if (exitCode === 0 && !options.signal?.aborted && options.adapter === 'openclaw' && messages.length === 0) {
+            throw new CliError('OpenClaw completed without a visible assistant response.');
+        }
+        if (exitCode === 0 && !options.signal?.aborted && finalMessageOnly && messages.length === 0) {
+            throw new CliError(`${invocation.command} completed without a visible assistant response.`);
+        }
+        return { exitCode, signal, messages, stdout, stderr };
+    }
+    finally {
+        options.signal?.removeEventListener('abort', abort);
+        clearTimeout(runTimeout);
+        if (forceKill)
+            clearTimeout(forceKill);
+        if (hardStop)
+            clearTimeout(hardStop);
+        if (!forcedClosed && !lifecycle.isClosed() && child.exitCode === null) {
+            await terminateAndWait(child, lifecycle, terminationGraceMs);
+        }
+        await materialized.cleanup();
+    }
+}
+async function runHermesAcp(options) {
+    const restricted = options.profile?.chatOnly === true || options.profile?.permissionPreset === 'read_only';
+    if (restricted) {
+        throw new CliError('Hermes does not expose a trustworthy read-only ACP mode. Use a sandboxed custom command or choose standard/full access.');
+    }
+    const spawnProcess = options.spawnProcess ?? spawn;
+    let child;
+    try {
+        child = spawnProcess('hermes', ['acp'], {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.environment },
+            shell: false,
+            detached: process.platform !== 'win32',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (error) {
+        throw new CliError('Unable to start hermes. Is it installed and on PATH?', 1, { cause: error });
+    }
+    const lifecycle = observeChild(child);
+    const stdout = [];
+    const stderr = [];
+    const messages = [];
+    const pending = new Map();
+    let nextId = 1;
+    let sessionId;
+    let finalText = '';
+    let forceKill;
+    let hardStop;
+    let forcedClosed = false;
+    let timedOut = false;
+    const maxOutputBytes = options.maxOutputBytes ?? MAX_AGENT_OUTPUT_BYTES;
+    let outputBytes = 0;
+    let outputLimitExceeded = false;
+    let abortRuntime = () => undefined;
+    let terminating = false;
+    const write = (value) => {
+        child.stdin.write(`${JSON.stringify(value)}\n`, 'utf8');
+    };
+    const request = (method, params) => {
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+            write({ jsonrpc: '2.0', id, method, params });
+        });
+    };
+    const resultOf = async (method, params) => {
+        const response = await request(method, params);
+        if (response.error)
+            throw new CliError(`Hermes ACP ${method} failed: ${response.error.message ?? 'unknown error'}`);
+        return response.result;
+    };
+    const stdoutLines = createLineConsumer((line) => {
+        stdout.push(line);
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            options.onStdout?.(line, { raw: line });
+            return;
+        }
+        const message = record(value);
+        const method = typeof message?.method === 'string' ? message.method : undefined;
+        options.onStdout?.(line, { raw: value, ...(method ? { eventType: method } : {}) });
+        if (typeof message?.id === 'number' && !method) {
+            const waiter = pending.get(message.id);
+            if (waiter) {
+                pending.delete(message.id);
+                const response = {};
+                if (Object.hasOwn(message, 'result'))
+                    response.result = message.result;
+                const rpcError = record(message.error);
+                if (rpcError)
+                    response.error = rpcError;
+                waiter.resolve(response);
+            }
+            return;
+        }
+        if (method === 'session/update') {
+            const update = record(record(message?.params)?.update);
+            const content = record(update?.content);
+            if (update?.sessionUpdate === 'agent_message_chunk' && content?.type === 'text' && typeof content.text === 'string') {
+                finalText += content.text;
+            }
+            return;
+        }
+        if (method === 'session/request_permission' && (typeof message?.id === 'number' || typeof message?.id === 'string')) {
+            const offered = record(message.params)?.options;
+            const allowed = Array.isArray(offered)
+                ? ['allow_once', 'allow_session'].find((optionId) => offered.some((option) => record(option)?.optionId === optionId))
+                : undefined;
+            const fullAccess = options.profile?.permissionPreset === 'full_access';
+            write({
+                jsonrpc: '2.0',
+                id: message.id,
+                result: {
+                    outcome: fullAccess && allowed
+                        ? { outcome: 'selected', optionId: allowed }
+                        : { outcome: 'cancelled' },
+                },
+            });
+        }
+    });
+    const stderrLines = createLineConsumer((line) => {
+        stderr.push(line);
+        options.onStderr?.(line);
+    });
+    const consumeOutput = (consumer, chunk) => {
+        if (outputLimitExceeded)
+            return;
+        outputBytes += Buffer.byteLength(chunk);
+        if (outputBytes > maxOutputBytes) {
+            outputLimitExceeded = true;
+            abortRuntime();
+            return;
+        }
+        consumer(chunk);
+    };
+    child.stdout.on('data', (chunk) => consumeOutput(stdoutLines.write, chunk));
+    child.stderr.on('data', (chunk) => consumeOutput(stderrLines.write, chunk));
+    const failPending = (error) => {
+        for (const waiter of pending.values())
+            waiter.reject(error);
+        pending.clear();
+    };
+    child.once('error', (error) => failPending(new CliError('Hermes ACP process failed.', 1, { cause: error })));
+    child.stdin.once('error', (error) => failPending(new CliError('Hermes closed its ACP input unexpectedly.', 1, { cause: error })));
+    child.once('close', () => failPending(new CliError('Hermes ACP process closed before the request completed.')));
+    const abort = () => {
+        if (sessionId)
+            write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } });
+        if (lifecycle.isClosed() || child.exitCode !== null || terminating)
+            return;
+        terminating = true;
+        terminateChild(child, 'SIGTERM');
+        forceKill = setTimeout(() => {
+            if (!lifecycle.isClosed())
+                terminateChild(child, 'SIGKILL');
+        }, 5_000);
+        forceKill.unref();
+        hardStop = setTimeout(() => {
+            if (lifecycle.isClosed())
+                return;
+            forcedClosed = true;
+            terminateChild(child, 'SIGKILL');
+            destroyChildPipes(child);
+            failPending(new CliError('Hermes did not close after forced termination.'));
+        }, 6_000);
+    };
+    abortRuntime = abort;
+    if (options.signal?.aborted)
+        abort();
+    options.signal?.addEventListener('abort', abort, { once: true });
+    const runTimeout = setTimeout(() => {
+        timedOut = true;
+        abort();
+    }, options.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS);
+    try {
+        const initialized = record(await resultOf('initialize', {
+            protocolVersion: 1,
+            clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+            clientInfo: { name: 'crewx', version: CLI_VERSION },
+        }));
+        if (initialized?.protocolVersion !== 1)
+            throw new CliError('Hermes returned an unsupported ACP protocol version.');
+        const created = record(await resultOf('session/new', { cwd: options.cwd, mcpServers: [] }));
+        if (typeof created?.sessionId !== 'string' || !created.sessionId) {
+            throw new CliError('Hermes did not return an ACP session id.');
+        }
+        sessionId = created.sessionId;
+        await resultOf('session/set_mode', {
+            sessionId,
+            modeId: options.profile?.permissionPreset === 'full_access' ? 'dont_ask' : 'accept_edits',
+        });
+        if (options.profile?.model) {
+            await resultOf('session/set_model', { sessionId, modelId: options.profile.model });
+        }
+        await resultOf('session/prompt', {
+            sessionId,
+            prompt: [{ type: 'text', text: options.prompt }],
+        });
+        if (timedOut)
+            throw new CliError('Hermes exceeded the CrewX run timeout.');
+        if (outputLimitExceeded) {
+            throw new CliError(`hermes exceeded the ${String(maxOutputBytes)} byte CrewX output limit.`);
+        }
+        if (!finalText.trim())
+            throw new CliError('Hermes completed without a visible assistant response.');
+        emitMessage(options, messages, finalText);
+        child.stdin.end();
+        const terminateTimer = setTimeout(() => terminateChild(child, 'SIGTERM'), 2_000);
+        const killTimer = setTimeout(() => terminateChild(child, 'SIGKILL'), 7_000);
+        let shutdownTimer;
+        terminateTimer.unref();
+        killTimer.unref();
+        const [exitCode, signal] = await Promise.race([
+            lifecycle.close,
+            new Promise((resolve) => {
+                shutdownTimer = setTimeout(() => {
+                    forcedClosed = true;
+                    terminateChild(child, 'SIGKILL');
+                    destroyChildPipes(child);
+                    resolve([child.exitCode, null]);
+                }, 8_000);
+            }),
+        ]);
+        clearTimeout(terminateTimer);
+        clearTimeout(killTimer);
+        if (shutdownTimer)
+            clearTimeout(shutdownTimer);
+        stdoutLines.end();
+        stderrLines.end();
+        return {
+            exitCode: options.signal?.aborted ? exitCode : 0,
+            signal: options.signal?.aborted ? signal : null,
+            messages,
+            stdout,
+            stderr,
+        };
+    }
+    finally {
+        options.signal?.removeEventListener('abort', abort);
+        clearTimeout(runTimeout);
+        if (forceKill)
+            clearTimeout(forceKill);
+        if (hardStop)
+            clearTimeout(hardStop);
+        if (!forcedClosed && !lifecycle.isClosed() && child.exitCode === null) {
+            await terminateAndWait(child, lifecycle, 5_000);
+        }
+    }
+}
+export async function runAdapter(options) {
+    if (!options.prompt.trim())
+        throw new CliError('Agent prompt cannot be empty.');
+    if (options.codingCommand &&
+        (options.profile?.chatOnly === true || options.profile?.permissionPreset === 'read_only')) {
+        throw new CliError('A custom coding command cannot prove read-only or chat-only enforcement.');
+    }
+    if (options.adapter === 'openclaw' &&
+        (options.profile?.chatOnly === true || options.profile?.permissionPreset === 'read_only')) {
+        throw new CliError('OpenClaw read-only and chat-only policy cannot be verified per run.');
+    }
+    if (options.adapter === 'hermes' && !options.codingCommand)
+        return runHermesAcp(options);
+    return runSpawnAdapter(options);
+}
+export async function probeAdapter(adapter, spawnProcess = spawn, timeoutMs = 5_000) {
+    const command = adapter;
+    const probeArgs = adapter === 'hermes'
+        ? ['acp', '--check']
+        : adapter === 'openclaw'
+            ? ['agents', 'list', '--json']
+            : ['--version'];
+    let child;
+    try {
+        child = spawnProcess(command, probeArgs, {
+            env: process.env,
+            shell: false,
+            detached: process.platform !== 'win32',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (error) {
+        return { available: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    const lifecycle = observeChild(child);
+    let output = '';
+    let outputBytes = 0;
+    let outputLimitExceeded = false;
+    let forceKill;
+    let hardStop;
+    let forcedClosed = false;
+    let rejectTermination;
+    const terminationFailure = new Promise((_resolve, reject) => {
+        rejectTermination = reject;
+    });
+    let timedOut = false;
+    let terminating = false;
+    const terminationGraceMs = Math.min(1_000, Math.max(25, timeoutMs));
+    const abort = () => {
+        if (lifecycle.isClosed() || child.exitCode !== null || terminating)
+            return;
+        terminating = true;
+        terminateChild(child, 'SIGTERM');
+        forceKill = setTimeout(() => {
+            if (!lifecycle.isClosed())
+                terminateChild(child, 'SIGKILL');
+        }, terminationGraceMs);
+        hardStop = setTimeout(() => {
+            if (lifecycle.isClosed())
+                return;
+            forcedClosed = true;
+            terminateChild(child, 'SIGKILL');
+            destroyChildPipes(child);
+            const message = outputLimitExceeded
+                ? 'probe output exceeded 1048576 bytes'
+                : `probe timed out after ${String(timeoutMs)}ms`;
+            rejectTermination?.(new CliError(message));
+        }, terminationGraceMs + 100);
+    };
+    const consume = (chunk) => {
+        if (outputLimitExceeded)
+            return;
+        outputBytes += Buffer.byteLength(chunk);
+        if (outputBytes > 1024 * 1024) {
+            outputLimitExceeded = true;
+            abort();
+            return;
+        }
+        output += chunk.toString();
+    };
+    child.stdout.on('data', (chunk) => {
+        consume(chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+        consume(chunk);
+    });
+    child.stdin.on('error', () => undefined);
+    child.stdin.end();
+    const timeout = setTimeout(() => {
+        timedOut = true;
+        abort();
+    }, timeoutMs);
+    try {
+        const [code] = (await Promise.race([
+            lifecycle.close,
+            terminationFailure,
+            once(child, 'error').then(([error]) => {
+                throw error;
+            }),
+        ]));
+        if (timedOut)
+            return { available: false, error: `probe timed out after ${String(timeoutMs)}ms` };
+        if (outputLimitExceeded)
+            return { available: false, error: 'probe output exceeded 1048576 bytes' };
+        const version = adapter === 'hermes' || adapter === 'openclaw'
+            ? 'ready'
+            : output.trim().split(/\r?\n/, 1)[0];
+        return code === 0
+            ? { available: true, ...(version ? { version } : {}) }
+            : { available: false, error: version || `exited with code ${String(code)}` };
+    }
+    catch (error) {
+        return { available: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        clearTimeout(timeout);
+        if (forceKill)
+            clearTimeout(forceKill);
+        if (hardStop)
+            clearTimeout(hardStop);
+        if (!forcedClosed && !lifecycle.isClosed() && child.exitCode === null) {
+            await terminateAndWait(child, lifecycle, terminationGraceMs);
+        }
+    }
+}
+//# sourceMappingURL=adapters.js.map