opera-devtools-mcp 0.7.0 → 0.8.0

package/build/src/opera/cliCommands.js

@@ -0,0 +1,378 @@
+/**
+ * @license
+ * Copyright 2026 Opera Norway AS. All rights reserved.
+ *
+ * This file is an original work developed by Opera.
+ */
+/**
+ * The fork's half of the CLI's command surface.
+ *
+ * `src/bin/chrome-devtools.ts` is upstream-owned, and the four commands this
+ * fork adds to it — `setup`, `doctor`, `logs`, `url` — plus the wrapper that
+ * turns one generated tool definition into a runnable yargs command used to be
+ * written inline there. Registering them from here instead leaves upstream's
+ * file with one call per group, so upstream churn in that area conflicts on a
+ * line rather than on a hundred and fifty of them. See `docs/UPSTREAM.md`,
+ * design rule 2.
+ *
+ * Everything moved here is what the fork owns: the flags the extra commands
+ * take, the re-expansion of parsed argv into the ported `parse*Args` parsers,
+ * and the exit-code / streaming plumbing around a tool call — which is where
+ * that plumbing belongs, next to `cdpErrors.ts` and `cliOutput.ts`. `start` is
+ * not ours (it prepends `--viaCli` and prints the disclaimers), so it is
+ * injected rather than reimplemented.
+ */
+import process from 'node:process';
+import { mcpOptions } from '../config/mcp-options.js';
+import { handleResponse, sendCommand, verifyDaemonVersion, } from '../daemon/client.js';
+import { isDaemonRunning, serializeArgs } from '../daemon/utils.js';
+import { VERSION } from '../version.js';
+import { CLI_BIN_NAME, MCP_BIN_NAME } from './branding.js';
+import { classifyBrowserFailure } from './browserErrors.js';
+import { settleBrowserConflict } from './browserTarget.js';
+import { CdpError, EXIT_CODES, describeToolFailure, wrapAiToolError, } from './cdpErrors.js';
+import { formatError, formatToolResult, parseSnapshotFromResponse, renderError, } from './cliOutput.js';
+import { handleDoctor } from './doctor.js';
+import { handleLogs } from './logs.js';
+import { withoutRoutingPageId } from './pageIdRouting.js';
+import { normalizeRefArgs } from './refArgs.js';
+import { handleSetup } from './setup.js';
+import { isOperaAiTool, operaAiTimeoutMs } from './streamingTools.js';
+import { handleUrl } from './urlResolver.js';
+/**
+ * The failure text a daemon reply carries, or undefined when the call was fine.
+ *
+ * A tool error arrives as `isError` on a successful reply, and is read here the
+ * same way the renderer reads it: one text, checked for the one condition the
+ * CLI can do something about.
+ */
+async function toolFailureText(response) {
+    if (!response.success) {
+        return String(response.error);
+    }
+    const result = JSON.parse(response.result);
+    if (result.isError !== true) {
+        return undefined;
+    }
+    return await handleResponse(result, 'md');
+}
+/**
+ * Settle the failure a browser reported: the profile is known to be in use (so
+ * the lock file is not asked) or the browser the daemon drives is gone, and
+ * `--takeover` — read here rather than passed down because the command parser
+ * never saw it (`bin/opera-browser-cli.ts` consumes it) — decides whether a
+ * browser may be restarted.
+ */
+function settleKnownConflict(reason) {
+    return sessionId => settleBrowserConflict(sessionId, {
+        takeover: process.env.OPERA_CLI_TAKEOVER === '1',
+        reason,
+    });
+}
+/**
+ * Register the commands the fork adds over upstream's `start`/`status`/`stop`
+ * and the generated tool table.
+ *
+ * The flags are declared here so `--help` documents them and `strict` accepts
+ * them; the ported `parse*Args` functions then read the re-expanded argv, which
+ * keeps one parser per command instead of two.
+ */
+export function registerOperaCommands(y, deps) {
+    y.command('setup', `Configure the browser ${CLI_BIN_NAME} drives (interactive unless a flag is passed)`, y => y
+        .option('non-interactive', {
+        type: 'boolean',
+        description: 'Configure from detection and flags, without prompting',
+    })
+        .option('yes', {
+        type: 'boolean',
+        alias: 'y',
+        description: 'Same as --non-interactive',
+    })
+        .option('executable', {
+        type: 'string',
+        description: 'Path to the Opera binary to drive',
+    })
+        .option('profile', {
+        type: 'string',
+        description: 'Persistent profile directory, or "skip" to use an isolated one',
+    })
+        .option('headed', { type: 'boolean', description: 'Run in headed mode' })
+        .option('headless', {
+        type: 'boolean',
+        description: 'Run in headless mode',
+    })
+        .strict(), async (argv) => {
+        console.log(await handleSetup(reExpandArgs(argv, {
+            'non-interactive': 'boolean',
+            yes: 'boolean',
+            executable: 'string',
+            profile: 'string',
+            headed: 'boolean',
+            headless: 'boolean',
+        })));
+    });
+    y.command('doctor', 'Inspect the configuration, browser, daemon, and log', y => y
+        .option('fix', {
+        type: 'boolean',
+        description: 'Repair what can be repaired without asking',
+    })
+        .strict(), async (argv) => {
+        console.log(await handleDoctor(argv.fix ? ['--fix'] : [], argv.sessionId));
+    });
+    y.command('logs', `Show the ${MCP_BIN_NAME} daemon log`, y => y
+        .option('lines', {
+        type: 'number',
+        alias: 'n',
+        description: 'Number of lines to show (default 50)',
+    })
+        .option('follow', {
+        type: 'boolean',
+        alias: 'f',
+        description: 'Stream new output until interrupted',
+    })
+        .option('errors', {
+        type: 'boolean',
+        description: 'Show only lines that look like failures',
+    })
+        .strict(), async (argv) => {
+        const output = await handleLogs(reExpandArgs(argv, {
+            lines: 'number',
+            follow: 'boolean',
+            errors: 'boolean',
+        }), argv.sessionId);
+        // `--follow` prints as it goes and returns nothing.
+        if (output) {
+            console.log(output);
+        }
+    });
+    y.command('url <target>', 'Resolve a $uN URL token or an @ref element to its full URL', y => y.positional('target', {
+        type: 'string',
+        describe: 'A $uN token from the urls: trailer, or an @ref like @2.4',
+    }), async (argv) => {
+        const sessionId = argv.sessionId;
+        const { output, exitCode } = await handleUrl([argv.target], () => fetchSnapshotSection(sessionId, argv, deps), sessionId);
+        if (exitCode === 0) {
+            console.log(output);
+        }
+        else {
+            console.error(output);
+            process.exitCode = exitCode;
+        }
+    });
+}
+/**
+ * Register one generated tool as a yargs command.
+ *
+ * The argument surface comes from the generated `commands` table; the handler
+ * brings the daemon up if it is not running, sends the call, and maps the
+ * result (or the failure) onto the fork's exit-code contract.
+ */
+export function registerToolCommand(y, commandName, commandDef, deps) {
+    // The CLI never routes by pageId: drop the routing positional that
+    // chrome-devtools-mcp injects onto page-scoped commands
+    // (src/opera/pageIdRouting.ts).
+    const args = withoutRoutingPageId(commandDef.args);
+    const requiredArgNames = Object.keys(args).filter(name => args[name].required);
+    const optionalArgNames = Object.keys(args).filter(name => !args[name].required);
+    let commandStr = commandName;
+    for (const arg of requiredArgNames) {
+        commandStr += ` <${arg}>`;
+    }
+    for (const arg of optionalArgNames) {
+        commandStr += ` [--${arg}]`;
+    }
+    y.command(commandStr, commandDef.description, y => {
+        y.option('output-format', {
+            choices: ['md', 'json', 'toon'],
+            default: 'md',
+        });
+        // The two snapshot flags opera-browser-cli documents on every
+        // snapshot-returning command. `--raw` is the whole escape hatch: it
+        // disables compaction and the URL lookup table together.
+        y.option('full', {
+            type: 'boolean',
+            description: 'Show the complete snapshot, without truncation',
+            default: false,
+        });
+        y.option('raw', {
+            type: 'boolean',
+            description: 'Show the unprocessed MCP output (disables compact format and URL lookup table)',
+            default: false,
+        });
+        for (const [argName, opt] of Object.entries(args)) {
+            const type = opt.type === 'integer' || opt.type === 'number'
+                ? 'number'
+                : opt.type === 'boolean'
+                    ? 'boolean'
+                    : opt.type === 'array'
+                        ? 'array'
+                        : 'string';
+            if (opt.required) {
+                const options = {
+                    describe: opt.description,
+                    type: type,
+                };
+                if (opt.default !== undefined) {
+                    options.default = opt.default;
+                }
+                if (opt.enum) {
+                    options.choices = opt.enum;
+                }
+                y.positional(argName, options);
+            }
+            else {
+                const options = {
+                    describe: opt.description,
+                    type: type,
+                };
+                if (opt.default !== undefined) {
+                    options.default = opt.default;
+                }
+                if (opt.enum) {
+                    options.choices = opt.enum;
+                }
+                y.option(argName, options);
+            }
+        }
+    }, async (argv) => {
+        const sessionId = argv.sessionId;
+        // Streaming is per-tool, not per-request: only the Opera AI tools produce
+        // partial output, and only they get the long timeout — the same timeout
+        // the daemon applies around the same call (`operaAiTimeoutMs`).
+        const streaming = isOperaAiTool(commandName);
+        try {
+            const versionWarningPromise = isDaemonRunning(sessionId)
+                ? verifyDaemonVersion(sessionId, VERSION)
+                : Promise.resolve(undefined);
+            if (!isDaemonRunning(sessionId)) {
+                await deps.start(serializeArgs(mcpOptions, argv), sessionId);
+            }
+            const rawArgs = {};
+            for (const argName of Object.keys(args)) {
+                if (argName in argv) {
+                    rawArgs[argName] = argv[argName];
+                }
+            }
+            // The snapshot prints refs as `@4.11`; the MCP tools take `4_11`
+            // (src/opera/refArgs.ts).
+            const commandArgs = normalizeRefArgs(args, rawArgs);
+            const invoke = () => sendCommand({
+                method: 'invoke_tool',
+                tool: commandName,
+                args: commandArgs,
+            }, sessionId, operaAiTimeoutMs(commandName), streaming
+                ? (chunk) => process.stderr.write(chunk + '\n')
+                : undefined);
+            let response = await invoke();
+            let failureText = await toolFailureText(response);
+            // A browser failure the CLI can settle never reached the tool — the
+            // daemon could not get a browser to run it on — so the only thing to do
+            // is settle it and try once more. This is the case a preflight cannot
+            // see: a daemon pinned to a profile that a browser now holds, or to an
+            // attach URL whose browser is gone, and only the failure says so.
+            const browserFailure = failureText === undefined
+                ? undefined
+                : classifyBrowserFailure(failureText);
+            if (browserFailure !== undefined) {
+                await (deps.settleConflict ?? settleKnownConflict(browserFailure))(sessionId);
+                if (!isDaemonRunning(sessionId)) {
+                    await deps.start(serializeArgs(mcpOptions, argv), sessionId);
+                }
+                response = await invoke();
+                failureText = await toolFailureText(response);
+            }
+            if (response.success) {
+                const result = JSON.parse(response.result);
+                const format = argv['output-format'];
+                if (result.isError === true && format !== 'json') {
+                    // A tool error is a failure like any other: the same `error`/`code`
+                    // document, the same suggestions, and the same stderr the daemon's
+                    // own failures get — not the raw MCP text on stdout with an exit
+                    // code and nothing structured to branch on. `json` stays the raw
+                    // passthrough, because the MCP result *is* the machine-readable
+                    // form of the failure.
+                    const failure = describeToolFailure(commandName, failureText ?? (await handleResponse(result, 'md')));
+                    console.error(await renderError(failure.message, failure.code, failure.suggestions));
+                    process.exitCode = EXIT_CODES[failure.code];
+                }
+                else {
+                    const output = await formatToolResult(result, format, {
+                        command: commandName,
+                        sessionId,
+                        url: typeof commandArgs.url === 'string'
+                            ? commandArgs.url
+                            : undefined,
+                        full: argv.full === true,
+                        raw: argv.raw === true,
+                    }, handleResponse);
+                    console.log(output);
+                    if (result.isError === true) {
+                        process.exitCode =
+                            EXIT_CODES[describeToolFailure(commandName, output).code];
+                    }
+                }
+            }
+            else {
+                const failure = describeToolFailure(commandName, failureText ?? String(response.error));
+                console.error(await renderError(failure.message, failure.code, failure.suggestions));
+                process.exitCode = EXIT_CODES[failure.code];
+            }
+            const versionWarning = await versionWarningPromise;
+            if (versionWarning) {
+                console.warn(versionWarning);
+            }
+        }
+        catch (error) {
+            const { output, exitCode } = await formatError(wrapAiToolError(commandName, error));
+            console.error(output);
+            process.exitCode = exitCode;
+        }
+    });
+}
+/**
+ * The `--flag value` argv the ported command parsers read. yargs consumes
+ * flags, so a command whose parser is the source's own has to see them again.
+ */
+function reExpandArgs(argv, spec, positionals = []) {
+    const args = [];
+    for (const name of positionals) {
+        const value = argv[name];
+        if (value !== undefined) {
+            args.push(String(value));
+        }
+    }
+    for (const [name, type] of Object.entries(spec)) {
+        const value = argv[name];
+        if (value === undefined || value === false) {
+            continue;
+        }
+        if (type === 'boolean') {
+            args.push(`--${name}`);
+        }
+        else {
+            args.push(`--${name}`, String(value));
+        }
+    }
+    return args;
+}
+/**
+ * A fresh `take_snapshot` section, for a command that needs the tree but was
+ * not itself a snapshot command. Injected into `handleUrl` so the resolver does
+ * not have to know how to bring a daemon up.
+ */
+async function fetchSnapshotSection(sessionId, argv, deps) {
+    if (!isDaemonRunning(sessionId)) {
+        await deps.start(serializeArgs(mcpOptions, argv), sessionId);
+    }
+    const response = await sendCommand({ method: 'invoke_tool', tool: 'take_snapshot', args: {} }, sessionId);
+    if (!response.success) {
+        throw new CdpError(String(response.error), 'BROWSER_ERROR');
+    }
+    const result = JSON.parse(response.result);
+    const section = parseSnapshotFromResponse(await handleResponse(result, 'md'));
+    if (section === null) {
+        throw new CdpError('No page snapshot available — launch a page first', 'BROWSER_ERROR', [`Run \`${CLI_BIN_NAME} new_page https://example.com\` first`]);
+    }
+    return section;
+}
+//# sourceMappingURL=cliCommands.js.map

package/build/src/opera/cliOutput.js

@@ -0,0 +1,284 @@
+/**
+ * @license
+ * Copyright 2026 Opera Norway AS. All rights reserved.
+ *
+ * This file is an original work developed by Opera.
+ */
+/**
+ * The CLI's output path: compaction, the URL lookup table, suggestions, and the
+ * TOON-structured blocks they are delivered in.
+ *
+ * Ported from opera-browser-cli's `src/cli.ts` (`renderHelp`, `renderOutput`,
+ * `renderError`, `formatPageOutput`, `parseSnapshotFromResponse`,
+ * `stripSnapshotHeader`). The source compacted in the CLI, not in the bridge,
+ * and this keeps that split: the MCP server's response is unchanged and the
+ * trick (a third of the tokens, and refs an agent can copy straight into the
+ * next command) is applied on the way out.
+ *
+ * Everything here is Opera-owned, so the literal binary name is the branding
+ * constant rather than a copy of the source string.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getToonEncode } from '../third_party/index.js';
+import { assertValidSessionId } from '../daemon/utils.js';
+import { CLI_BIN_NAME } from './branding.js';
+import { applyUrlLut, compactSnapshot, countRefs, extractPageOrigin, extractPageUrl, extractTitle, truncateSnapshot, } from './compactSnapshot.js';
+import { CdpError, checkAiResultForCdpError, exitCodeFor } from './cdpErrors.js';
+import { getStateDir } from './envConfig.js';
+import { getSuggestions } from './suggestions.js';
+import { isOperaAiTool } from './streamingTools.js';
+// ---------------------------------------------------------------------------
+// TOON
+// ---------------------------------------------------------------------------
+/**
+ * `@toon-format/toon` is an optional peer dependency, so it is loaded on first
+ * use rather than at module load: a user who never asks for structured output
+ * never needs it installed. Mirrors `McpResponse.ts`'s `getToonEncode` call.
+ */
+export async function encode(value) {
+    try {
+        const toonEncode = await getToonEncode();
+        return toonEncode(value);
+    }
+    catch {
+        throw new CdpError('The `@toon-format/toon` package is required for TOON output. ' +
+            'Install the peer dependency: npm install @toon-format/toon (add -g if installed globally).', 'BRIDGE_NOT_READY');
+    }
+}
+// ---------------------------------------------------------------------------
+// Blocks
+// ---------------------------------------------------------------------------
+/** `help[N]:` followed by two-space-indented lines — the source's shape. */
+export function renderHelp(lines) {
+    if (lines.length === 0) {
+        return '';
+    }
+    const indented = lines.map(line => `  ${line}`).join('\n');
+    return `help[${lines.length}]:\n${indented}`;
+}
+/** Joins non-empty blocks with a newline. */
+export function renderOutput(blocks) {
+    return blocks.filter(Boolean).join('\n');
+}
+/** `encode({error, code})` plus a help block, so a failure is still structured. */
+export async function renderError(message, code, suggestions = []) {
+    const blocks = [await encode({ error: message, code })];
+    if (suggestions.length > 0) {
+        blocks.push(renderHelp(suggestions));
+    }
+    return blocks.join('\n');
+}
+/**
+ * The output and exit code for a failure, so a caller can branch on *why*
+ * without parsing the message.
+ */
+export async function formatError(error) {
+    const code = error instanceof CdpError ? error.code : 'UNKNOWN';
+    const message = error instanceof Error ? error.message : String(error);
+    const suggestions = error instanceof CdpError ? error.suggestions : [];
+    return {
+        output: await renderError(message, code, suggestions),
+        exitCode: exitCodeFor(error),
+    };
+}
+/**
+ * Where `url $uN` finds the token assignments the agent actually saw.
+ *
+ * Written on every rendered snapshot: the map is derived from the *truncated*
+ * body, so re-deriving it from a fresh full snapshot would hand out different
+ * token IDs than the ones in the output the user is quoting.
+ *
+ * Scoped per session, like every other piece of daemon state (pid file, socket,
+ * log). Two invocations with different `--sessionId` values drive two browsers,
+ * and one shared file let `url $u3` in one shell answer with the URL the other
+ * shell's page had assigned to `$u3`. The default session (`''`) has exactly one
+ * daemon, so it keeps one file.
+ */
+function getUrlMapFile(sessionId) {
+    assertValidSessionId(sessionId);
+    const suffix = sessionId ? `-${sessionId}` : '';
+    return join(getStateDir(), `last-url-map${suffix}.json`);
+}
+export function writeUrlMapSidecar(urlMap, sessionId, origin) {
+    try {
+        // The state dir is normally created by autoconfiguration, but a machine
+        // configured entirely through `OPERA_CLI_*` in the environment never runs
+        // it — and a missing dir here must not cost the user `url`.
+        mkdirSync(getStateDir(), { recursive: true, mode: 0o700 });
+        writeFileSync(getUrlMapFile(sessionId), JSON.stringify({ origin, tokens: Object.fromEntries(urlMap) }));
+    }
+    catch {
+        // Non-fatal: `url` falls back to re-deriving the map if the write fails.
+    }
+}
+export function loadUrlMapSidecar(sessionId) {
+    try {
+        // The wire shape, not `UrlMapSidecar`: `tokens` is a plain object on disk.
+        const stored = JSON.parse(readFileSync(getUrlMapFile(sessionId), 'utf-8'));
+        if (stored === null || typeof stored !== 'object') {
+            return null;
+        }
+        // A file written before the origin was recorded is a flat token map; read
+        // it as tokens-only so an upgrade does not break a token mid-session.
+        if (!('tokens' in stored)) {
+            return {
+                origin: null,
+                tokens: new Map(Object.entries(stored)),
+            };
+        }
+        return {
+            origin: typeof stored.origin === 'string' ? stored.origin : null,
+            tokens: new Map(Object.entries((stored.tokens ?? {}))),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Snapshot extraction
+// ---------------------------------------------------------------------------
+const SNAPSHOT_MARKER = '## Latest page snapshot';
+/**
+ * Slice the `## Latest page snapshot` section out of an MCP response. Returns
+ * null when the response carries no snapshot — most tools do not.
+ */
+export function parseSnapshotFromResponse(response) {
+    const idx = response.indexOf(SNAPSHOT_MARKER);
+    if (idx === -1) {
+        return null;
+    }
+    const after = response.slice(idx + SNAPSHOT_MARKER.length);
+    // The snapshot follows the header line, possibly after a blank line.
+    const trimmed = after.replace(/^\s*\n/, '');
+    // It ends at the next `## ` heading.
+    const nextHeading = trimmed.indexOf('\n## ');
+    return nextHeading === -1
+        ? trimmed.trimEnd()
+        : trimmed.slice(0, nextHeading).trimEnd();
+}
+/**
+ * Everything before the actual accessibility tree, stripped: the MCP preamble
+ * and headers a caller may have wrapped the tree in.
+ */
+export function stripSnapshotHeader(text) {
+    const lines = text.split('\n');
+    const treeStart = lines.findIndex(line => /\bRootWebArea\b|\buid=/.test(line));
+    const result = treeStart > 0
+        ? lines.slice(treeStart).join('\n')
+        : text.replace(/^[\s\S]*?##\s+Latest page snapshot\s*\n/, '');
+    // Name the command users actually run, not the internal tool.
+    return result.replace(/Call list_pages\b/g, `Run \`${CLI_BIN_NAME} list_pages\``);
+}
+/**
+ * Whether a section is the accessibility-tree grammar `compactSnapshot` was
+ * written against. A `--experimentalDataFormat=toon` (or gcf) snapshot is a
+ * different language entirely, and compacting it would corrupt it, so it is
+ * passed through untouched.
+ */
+function isAccessibilityTree(section) {
+    return /^\s*(?:uid=\S+|@\S+)\s+\S/m.test(section);
+}
+/**
+ * Compact, truncate, then apply the URL LUT — in that order, because the LUT
+ * trailer must only reference URLs still visible in the truncated body.
+ */
+function buildPageOutput(snapshot, context) {
+    const { command, url, full = false, raw = false, sessionId } = context;
+    const tree = raw ? snapshot : compactSnapshot(snapshot);
+    const page = {};
+    const title = extractTitle(tree);
+    if (title) {
+        page.title = title;
+    }
+    // A command that navigated knows the URL it went to; every other command takes
+    // the page's own, read from the *raw* tree (compaction has already replaced
+    // the root node's url= with the origin-relative `/`).
+    const pageUrl = url ?? extractPageUrl(snapshot);
+    if (pageUrl) {
+        page.url = pageUrl;
+    }
+    page.refs = countRefs(tree);
+    const truncation = truncateSnapshot(tree, full, raw ? 16000 : 12000);
+    const lut = raw
+        ? { body: truncation.text, trailer: '', urlMap: new Map() }
+        : applyUrlLut(truncation.text);
+    // The origin comes from the *raw* tree: a later `compactSnapshot`-shaped tree
+    // (and so the body the map is derived from) has the root node's url= already
+    // shortened to `/`.
+    writeUrlMapSidecar(lut.urlMap, sessionId, extractPageOrigin(snapshot));
+    const suggestions = getSuggestions({ command, url, snapshot: tree });
+    if (truncation.truncated) {
+        suggestions.push(`Run \`${CLI_BIN_NAME} ${command}${url ? ' ' + url : ''} --full\` to see complete snapshot`);
+    }
+    return {
+        page,
+        snapshot: {
+            body: lut.body,
+            trailer: lut.trailer,
+            truncated: truncation.truncated,
+            totalLength: truncation.totalLength,
+        },
+        suggestions,
+    };
+}
+/** `page` metadata block, the `snapshot:` block, then the suggestions. */
+async function renderPageOutput(out) {
+    let snapshotBlock = `snapshot:\n${out.snapshot.body.trimEnd()}`;
+    if (out.snapshot.trailer) {
+        snapshotBlock += `\n${out.snapshot.trailer}`;
+    }
+    if (out.snapshot.truncated) {
+        snapshotBlock += `\n    ... (truncated, ${out.snapshot.totalLength} chars total)`;
+    }
+    return renderOutput([
+        await encode({ page: out.page }),
+        snapshotBlock,
+        renderHelp(out.suggestions),
+    ]);
+}
+/** The same content as one structured document, for `--output-format toon`. */
+async function renderPageToon(out) {
+    return encode({
+        page: out.page,
+        snapshot: {
+            body: out.snapshot.body.trimEnd(),
+            ...(out.snapshot.trailer ? { urls: out.snapshot.trailer } : {}),
+            ...(out.snapshot.truncated
+                ? { truncated: true, totalLength: out.snapshot.totalLength }
+                : {}),
+        },
+        ...(out.suggestions.length > 0 ? { help: out.suggestions } : {}),
+    });
+}
+/**
+ * The text of a tool result, formatted for a terminal or for a machine.
+ *
+ * `json` is delegated to the daemon client's own `handleResponse` unchanged.
+ * For `md` and `toon` the response is flattened to text exactly once — so an
+ * image result is spilled to a file once, not twice — and only a response that
+ * carries an accessibility tree gets the compaction treatment.
+ *
+ * The flattening is also where Opera's "successful" error results are caught:
+ * the browser extension reports an unsigned user, or a browser with no Opera AI
+ * extension, as ordinary text on a successful call, and `checkAiResultForCdpError`
+ * is the only thing that can turn that into an exit code the caller can branch
+ * on. It throws, so the caller's error path handles it like any other failure.
+ */
+export async function formatToolResult(result, format, context, handleResponse) {
+    if (format === 'json') {
+        return handleResponse(result, 'json');
+    }
+    const text = await handleResponse(result, 'md');
+    if (result.isError !== true && isOperaAiTool(context.command)) {
+        checkAiResultForCdpError(context.command, text);
+    }
+    const section = result.isError === true ? null : parseSnapshotFromResponse(text);
+    if (section === null || !isAccessibilityTree(section)) {
+        return format === 'toon' ? encode({ result: text }) : text;
+    }
+    const out = buildPageOutput(section, context);
+    return format === 'toon' ? renderPageToon(out) : renderPageOutput(out);
+}
+//# sourceMappingURL=cliOutput.js.map