@steipete/oracle 0.8.4 → 0.8.5

package/dist/src/browser/detect.js

@@ -0,0 +1,164 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Launcher } from 'chrome-launcher';
+export async function detectChromeBinary() {
+    const envPath = (process.env.CHROME_PATH ?? '').trim();
+    if (envPath) {
+        const ok = await isExecutable(envPath);
+        if (ok) {
+            return { path: envPath };
+        }
+    }
+    const launcherDetected = Launcher.getFirstInstallation();
+    if (launcherDetected) {
+        return { path: launcherDetected };
+    }
+    const candidates = platformChromeCandidates();
+    for (const candidate of candidates.absolutePaths) {
+        if (await isExecutable(candidate)) {
+            return { path: candidate };
+        }
+    }
+    const fromPath = await findOnPath(candidates.binaryNames);
+    if (fromPath) {
+        return { path: fromPath };
+    }
+    return { path: null };
+}
+export async function detectChromeCookieDb({ profile }) {
+    const profileName = profile?.trim() ? profile.trim() : 'Default';
+    if (process.platform === 'win32') {
+        return null;
+    }
+    const roots = platformProfileRoots();
+    for (const root of roots) {
+        const dir = path.join(root, profileName);
+        const direct = path.join(dir, 'Cookies');
+        if (await isFile(direct))
+            return direct;
+        const network = path.join(dir, 'Network', 'Cookies');
+        if (await isFile(network))
+            return network;
+    }
+    return null;
+}
+function platformChromeCandidates() {
+    if (process.platform === 'linux') {
+        return {
+            binaryNames: [
+                'google-chrome',
+                'google-chrome-stable',
+                'chromium',
+                'chromium-browser',
+                'brave-browser',
+                'microsoft-edge',
+                'microsoft-edge-stable',
+            ],
+            absolutePaths: [
+                '/usr/bin/google-chrome',
+                '/usr/bin/google-chrome-stable',
+                '/usr/bin/google-chrome-beta',
+                '/usr/bin/google-chrome-unstable',
+                '/usr/bin/chromium',
+                '/usr/bin/chromium-browser',
+                '/usr/bin/brave-browser',
+                '/usr/bin/microsoft-edge',
+                '/usr/bin/microsoft-edge-stable',
+                '/snap/bin/chromium',
+                '/snap/bin/brave',
+                '/snap/bin/brave-browser',
+                '/snap/bin/microsoft-edge',
+                '/opt/google/chrome/chrome',
+            ],
+        };
+    }
+    if (process.platform === 'darwin') {
+        return {
+            binaryNames: [],
+            absolutePaths: [
+                '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+                '/Applications/Chromium.app/Contents/MacOS/Chromium',
+                '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+                '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+            ],
+        };
+    }
+    if (process.platform === 'win32') {
+        const programFiles = process.env.ProgramFiles ?? 'C:\\Program Files';
+        const programFilesX86 = process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)';
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+        return {
+            binaryNames: [],
+            absolutePaths: [
+                path.join(programFiles, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+                path.join(programFilesX86, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+                path.join(localAppData, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+                path.join(programFiles, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+                path.join(programFilesX86, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+            ],
+        };
+    }
+    return { binaryNames: [], absolutePaths: [] };
+}
+function platformProfileRoots() {
+    const home = os.homedir();
+    if (process.platform === 'darwin') {
+        return [
+            path.join(home, 'Library', 'Application Support', 'Google', 'Chrome'),
+            path.join(home, 'Library', 'Application Support', 'Chromium'),
+            path.join(home, 'Library', 'Application Support', 'Microsoft Edge'),
+            path.join(home, 'Library', 'Application Support', 'BraveSoftware', 'Brave-Browser'),
+        ];
+    }
+    if (process.platform === 'linux') {
+        return [
+            path.join(home, '.config', 'google-chrome'),
+            path.join(home, '.config', 'google-chrome-beta'),
+            path.join(home, '.config', 'google-chrome-unstable'),
+            path.join(home, '.config', 'chromium'),
+            path.join(home, '.config', 'microsoft-edge'),
+            path.join(home, '.config', 'BraveSoftware', 'Brave-Browser'),
+            // Snap Chromium profiles
+            path.join(home, 'snap', 'chromium', 'common', 'chromium'),
+            path.join(home, 'snap', 'chromium', 'current', 'chromium'),
+        ];
+    }
+    return [];
+}
+async function isExecutable(candidate) {
+    try {
+        const stat = await fs.stat(candidate);
+        if (!stat.isFile())
+            return false;
+        if (process.platform === 'win32')
+            return true;
+        // eslint-disable-next-line no-bitwise
+        return (stat.mode & 0o111) !== 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function isFile(candidate) {
+    try {
+        const stat = await fs.stat(candidate);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function findOnPath(names) {
+    const rawPath = process.env.PATH ?? '';
+    const dirs = rawPath.split(path.delimiter).filter(Boolean);
+    for (const name of names) {
+        for (const dir of dirs) {
+            const candidate = path.join(dir, name);
+            if (await isExecutable(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}

package/dist/src/browser/index.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import os from 'node:os';
 import net from 'node:net';
 import { resolveBrowserConfig } from './config.js';
-import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChrome, connectToRemoteChrome, closeRemoteChromeTarget, } from './chromeLifecycle.js';
+import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, closeRemoteChromeTarget, connectWithNewTab, closeTab, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
 import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
@@ -122,6 +122,7 @@ export async function runBrowserMode(options) {
         // ignore failure; cleanup still happens below
     }
     let client = null;
+    let isolatedTargetId = null;
     const startedAt = Date.now();
     let answerText = '';
     let answerMarkdown = '';
@@ -133,7 +134,9 @@ export async function runBrowserMode(options) {
     let appliedCookies = 0;
     try {
         try {
-            client = await connectToChrome(chrome.port, logger, chromeHost);
+            const connection = await connectWithNewTab(chrome.port, logger, undefined, chromeHost);
+            client = connection.client;
+            isolatedTargetId = connection.targetId ?? null;
         }
         catch (error) {
             const hint = describeDevtoolsFirewallHint(chromeHost, chrome.port);
@@ -503,6 +506,14 @@ export async function runBrowserMode(options) {
         })).catch(() => null);
         answerMarkdown = copiedMarkdown ?? answerText;
         const promptEchoMatcher = buildPromptEchoMatcher(promptText);
+        ({ answerText, answerMarkdown } = await maybeRecoverLongAssistantResponse({
+            runtime: Runtime,
+            baselineTurns,
+            answerText,
+            answerMarkdown,
+            logger,
+            allowMarkdownUpdate: !copiedMarkdown,
+        }));
         // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
         const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
         const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
@@ -647,6 +658,9 @@ export async function runBrowserMode(options) {
         catch {
             // ignore
         }
+        if (!effectiveKeepBrowser && isolatedTargetId && chrome?.port) {
+            await closeTab(chrome.port, isolatedTargetId, logger, chromeHost).catch(() => undefined);
+        }
         removeDialogHandler?.();
         removeTerminationHooks?.();
         if (!effectiveKeepBrowser) {
@@ -752,6 +766,37 @@ async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, time
     }
     throw new Error('Manual login mode timed out waiting for ChatGPT session; please sign in and retry.');
 }
+async function maybeRecoverLongAssistantResponse({ runtime, baselineTurns, answerText, answerMarkdown, logger, allowMarkdownUpdate, }) {
+    // Learned: long streaming responses can still be rendering after initial capture.
+    // Add a brief delay and re-poll to catch any additional content (#71).
+    const capturedLength = answerText.trim().length;
+    if (capturedLength <= 500) {
+        return { answerText, answerMarkdown };
+    }
+    await delay(1500);
+    let bestLength = capturedLength;
+    let bestText = answerText;
+    for (let i = 0; i < 5; i++) {
+        const laterSnapshot = await readAssistantSnapshot(runtime, baselineTurns ?? undefined).catch(() => null);
+        const laterText = typeof laterSnapshot?.text === 'string' ? laterSnapshot.text.trim() : '';
+        if (laterText.length > bestLength) {
+            bestLength = laterText.length;
+            bestText = laterText;
+            await delay(800); // More content appeared, keep waiting
+        }
+        else {
+            break; // Stable, stop polling
+        }
+    }
+    if (bestLength > capturedLength) {
+        logger(`Recovered ${bestLength - capturedLength} additional chars via delayed re-read`);
+        return {
+            answerText: bestText,
+            answerMarkdown: allowMarkdownUpdate ? bestText : answerMarkdown,
+        };
+    }
+    return { answerText, answerMarkdown };
+}
 async function _assertNavigatedToHttp(runtime, _logger, timeoutMs = 10_000) {
     const deadline = Date.now() + timeoutMs;
     let lastUrl = '';
@@ -1013,6 +1058,14 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             },
         }).catch(() => null);
         answerMarkdown = copiedMarkdown ?? answerText;
+        ({ answerText, answerMarkdown } = await maybeRecoverLongAssistantResponse({
+            runtime: Runtime,
+            baselineTurns,
+            answerText,
+            answerMarkdown,
+            logger,
+            allowMarkdownUpdate: !copiedMarkdown,
+        }));
         // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
         const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
         const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';

package/dist/src/cli/bridge/claudeConfig.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import os from 'node:os';
+import path from 'node:path';
+import { loadUserConfig } from '../../config.js';
+import { resolveRemoteServiceConfig } from '../../remote/remoteServiceConfig.js';
+export async function runBridgeClaudeConfig(options) {
+    const { config: userConfig } = await loadUserConfig();
+    const resolved = resolveRemoteServiceConfig({
+        cliHost: undefined,
+        cliToken: undefined,
+        userConfig,
+        env: process.env,
+    });
+    const snippet = formatClaudeMcpConfig({
+        oracleHomeDir: process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle-local'),
+        browserProfileDir: process.env.ORACLE_BROWSER_PROFILE_DIR ??
+            path.join(os.homedir(), '.oracle-local', 'browser-profile'),
+        remoteHost: resolved.host,
+        remoteToken: resolved.token,
+        includeToken: Boolean(options.printToken),
+    });
+    console.log(snippet);
+    if (!options.printToken) {
+        console.log('');
+        console.log(chalk.dim('Tip: rerun with --print-token to include ORACLE_REMOTE_TOKEN in the snippet.'));
+    }
+}
+export function formatClaudeMcpConfig({ oracleHomeDir, browserProfileDir, remoteHost, remoteToken, includeToken, }) {
+    const env = {};
+    // biome-ignore lint/complexity/useLiteralKeys: env vars are uppercase and include underscores.
+    env['ORACLE_ENGINE'] = 'browser';
+    // biome-ignore lint/complexity/useLiteralKeys: env vars are uppercase and include underscores.
+    env['ORACLE_HOME_DIR'] = oracleHomeDir;
+    // biome-ignore lint/complexity/useLiteralKeys: env vars are uppercase and include underscores.
+    env['ORACLE_BROWSER_PROFILE_DIR'] = browserProfileDir;
+    if (remoteHost) {
+        // biome-ignore lint/complexity/useLiteralKeys: env vars are uppercase and include underscores.
+        env['ORACLE_REMOTE_HOST'] = remoteHost;
+        // biome-ignore lint/complexity/useLiteralKeys: env vars are uppercase and include underscores.
+        env['ORACLE_REMOTE_TOKEN'] = includeToken ? remoteToken ?? '<YOUR_TOKEN>' : '<YOUR_TOKEN>';
+    }
+    // Claude Code supports project-scoped `.mcp.json` config files:
+    // https://docs.anthropic.com/en/docs/claude-code/mcp
+    return JSON.stringify({
+        mcpServers: {
+            oracle: {
+                type: 'stdio',
+                command: 'oracle-mcp',
+                args: [],
+                env,
+            },
+        },
+    }, null, 2);
+}

package/dist/src/cli/bridge/client.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+import { configPath as defaultConfigPath } from '../../config.js';
+import { parseBridgeConnectionString, readBridgeConnectionArtifact, looksLikePath, } from '../../bridge/connection.js';
+import { readUserConfigFile, writeUserConfigFile } from '../../bridge/userConfigFile.js';
+import { checkRemoteHealth } from '../../remote/health.js';
+export async function runBridgeClient(options) {
+    const connectRaw = options.connect?.trim();
+    if (!connectRaw) {
+        throw new Error('Missing --connect. Provide a connection string or a bridge-connection.json path.');
+    }
+    const { remoteHost, remoteToken, tunnel } = await resolveConnection(connectRaw);
+    if (options.test !== false) {
+        const health = await checkRemoteHealth({ host: remoteHost, token: remoteToken, timeoutMs: 5000 });
+        if (!health.ok) {
+            const suffix = health.statusCode ? ` (HTTP ${health.statusCode})` : '';
+            throw new Error(`Remote service health check failed: ${health.error ?? 'unknown error'}${suffix}`);
+        }
+        console.log(chalk.green(`Remote service OK (${remoteHost})${health.version ? ` — oracle ${health.version}` : ''}`));
+    }
+    const configFilePath = options.config?.trim() || defaultConfigPath();
+    if (options.writeConfig !== false) {
+        const { config } = await readUserConfigFile(configFilePath);
+        const next = { ...config, browser: { ...(config.browser ?? {}) } };
+        next.browser = { ...(next.browser ?? {}) };
+        next.browser.remoteHost = remoteHost;
+        next.browser.remoteToken = remoteToken;
+        if (tunnel) {
+            next.browser.remoteViaSshReverseTunnel = {
+                ssh: tunnel.ssh,
+                remotePort: tunnel.remotePort,
+                localPort: tunnel.localPort,
+                identity: tunnel.identity,
+                extraArgs: tunnel.extraArgs,
+            };
+        }
+        await writeUserConfigFile(configFilePath, next);
+        console.log(chalk.green(`Wrote remote config to ${configFilePath}`));
+    }
+    console.log('');
+    console.log('Next:');
+    console.log(chalk.dim(`- oracle --engine browser -p "hello" --file README.md`));
+    if (options.printEnv) {
+        console.log('');
+        console.log('# Optional env overrides (paste into your shell):');
+        console.log(`export ORACLE_ENGINE=browser`);
+        console.log(`export ORACLE_REMOTE_HOST=${shellQuote(remoteHost)}`);
+        console.log(`export ORACLE_REMOTE_TOKEN=${shellQuote(remoteToken)}`);
+    }
+}
+async function resolveConnection(input) {
+    if (input.includes('://')) {
+        return { ...parseBridgeConnectionString(input) };
+    }
+    const resolvedPath = looksLikePath(input) ? path.resolve(process.cwd(), input) : null;
+    if (resolvedPath) {
+        const stat = await fs.stat(resolvedPath).catch(() => null);
+        if (stat?.isFile()) {
+            const artifact = await readBridgeConnectionArtifact(resolvedPath);
+            return { remoteHost: artifact.remoteHost, remoteToken: artifact.remoteToken, tunnel: artifact.tunnel };
+        }
+        if (stat) {
+            throw new Error(`--connect points to ${resolvedPath}, but it is not a file.`);
+        }
+        throw new Error(`Connection artifact not found at ${resolvedPath}`);
+    }
+    return { ...parseBridgeConnectionString(input) };
+}
+function shellQuote(value) {
+    // Single-quote for POSIX shells; safe for tokens/host strings.
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}

package/dist/src/cli/bridge/codexConfig.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { loadUserConfig } from '../../config.js';
+import { resolveRemoteServiceConfig } from '../../remote/remoteServiceConfig.js';
+export async function runBridgeCodexConfig(options) {
+    const { config: userConfig } = await loadUserConfig();
+    const resolved = resolveRemoteServiceConfig({
+        cliHost: undefined,
+        cliToken: undefined,
+        userConfig,
+        env: process.env,
+    });
+    const snippet = formatCodexMcpSnippet({
+        remoteHost: resolved.host,
+        remoteToken: resolved.token,
+        includeToken: Boolean(options.printToken),
+    });
+    console.log(snippet);
+    if (!options.printToken) {
+        console.log('');
+        console.log(chalk.dim('Tip: rerun with --print-token to include ORACLE_REMOTE_TOKEN in the snippet.'));
+    }
+}
+export function formatCodexMcpSnippet({ remoteHost, remoteToken, includeToken, }) {
+    const hostValue = remoteHost ?? '127.0.0.1:9473';
+    const tokenValue = includeToken ? remoteToken ?? '<YOUR_TOKEN>' : '<YOUR_TOKEN>';
+    return [
+        '# ~/.codex/config.toml',
+        '',
+        '[mcp.servers.oracle]',
+        'command = "oracle-mcp"',
+        'args = []',
+        `env = { ORACLE_ENGINE = "browser", ORACLE_REMOTE_HOST = "${escapeTomlString(hostValue)}", ORACLE_REMOTE_TOKEN = "${escapeTomlString(tokenValue)}" }`,
+        '',
+        '# If you prefer npx:',
+        '# [mcp.servers.oracle]',
+        '# command = "npx"',
+        '# args = ["-y", "@steipete/oracle", "oracle-mcp"]',
+        `# env = { ORACLE_ENGINE = "browser", ORACLE_REMOTE_HOST = "${escapeTomlString(hostValue)}", ORACLE_REMOTE_TOKEN = "${escapeTomlString(tokenValue)}" }`,
+    ].join('\n');
+}
+function escapeTomlString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}

package/dist/src/cli/bridge/doctor.js

@@ -0,0 +1,107 @@
+import os from 'node:os';
+import chalk from 'chalk';
+import { getCliVersion } from '../../version.js';
+import { loadUserConfig } from '../../config.js';
+import { resolveRemoteServiceConfig } from '../../remote/remoteServiceConfig.js';
+import { checkTcpConnection, checkRemoteHealth } from '../../remote/health.js';
+import { detectChromeBinary, detectChromeCookieDb } from '../../browser/detect.js';
+import { formatCodexMcpSnippet } from './codexConfig.js';
+export async function runBridgeDoctor(_options) {
+    const { config: userConfig, path: configPath, loaded } = await loadUserConfig();
+    const version = getCliVersion();
+    const resolvedRemote = resolveRemoteServiceConfig({
+        cliHost: undefined,
+        cliToken: undefined,
+        userConfig,
+        env: process.env,
+    });
+    const lines = [];
+    const fail = [];
+    const warn = [];
+    lines.push(chalk.bold('Bridge doctor'));
+    lines.push(chalk.dim(`OS: ${process.platform} ${os.release()} (${process.arch})`));
+    lines.push(chalk.dim(`Node: ${process.version}`));
+    lines.push(chalk.dim(`Oracle: ${version}`));
+    lines.push(chalk.dim(`Config: ${loaded ? configPath : '(missing)'}`));
+    if (userConfig.engine) {
+        lines.push(chalk.dim(`Default engine: ${userConfig.engine}`));
+    }
+    if (userConfig.model) {
+        lines.push(chalk.dim(`Default model: ${userConfig.model}`));
+    }
+    lines.push('');
+    lines.push(chalk.bold('Browser mode'));
+    if (resolvedRemote.host) {
+        lines.push(`Remote service: ${chalk.green('configured')}`);
+        lines.push(chalk.dim(`remoteHost: ${resolvedRemote.host} (${resolvedRemote.sources.host})`));
+        lines.push(chalk.dim(`remoteToken: ${resolvedRemote.token ? 'set' : 'missing'} (${resolvedRemote.sources.token})`));
+        const tcp = await checkTcpConnection(resolvedRemote.host, 2000);
+        if (tcp.ok) {
+            lines.push(chalk.dim(`TCP connect: ${chalk.green('ok')}`));
+        }
+        else {
+            fail.push(`Cannot reach ${resolvedRemote.host} (${tcp.error ?? 'unknown error'}).`);
+            lines.push(chalk.dim(`TCP connect: ${chalk.red(`failed (${tcp.error ?? 'unknown error'})`)}`));
+        }
+        if (!resolvedRemote.token) {
+            fail.push('Remote token is missing. Run `oracle bridge client --connect <...> --write-config` or set ORACLE_REMOTE_TOKEN.');
+        }
+        else if (tcp.ok) {
+            const health = await checkRemoteHealth({ host: resolvedRemote.host, token: resolvedRemote.token, timeoutMs: 5000 });
+            if (health.ok) {
+                const meta = health.version ? `oracle ${health.version}` : 'ok';
+                lines.push(chalk.dim(`Auth (/health): ${chalk.green(meta)}`));
+            }
+            else {
+                const detail = health.error ?? 'unknown error';
+                fail.push(`Remote auth failed: ${detail}`);
+                const suffix = health.statusCode ? `HTTP ${health.statusCode}` : 'network';
+                lines.push(chalk.dim(`Auth (/health): ${chalk.red(`${suffix} (${detail})`)}`));
+            }
+        }
+    }
+    else {
+        lines.push(`Remote service: ${chalk.yellow('not configured')}`);
+        const chrome = await detectChromeBinary();
+        if (chrome.path) {
+            lines.push(chalk.dim(`Chrome: ${chalk.green(chrome.path)}`));
+        }
+        else {
+            fail.push('No Chrome installation detected. Install Chrome/Chromium or set --browser-chrome-path.');
+            lines.push(chalk.dim(`Chrome: ${chalk.red('not found')}`));
+        }
+        if (process.platform === 'win32') {
+            warn.push('Cookie sync is disabled on Windows; use --browser-manual-login or run browser automation on another host.');
+            lines.push(chalk.dim('Cookies: (cookie sync disabled on Windows)'));
+        }
+        else {
+            const cookieDb = await detectChromeCookieDb({ profile: 'Default' });
+            if (cookieDb) {
+                lines.push(chalk.dim(`Cookies DB: ${chalk.green(cookieDb)}`));
+            }
+            else {
+                warn.push('Chrome cookies DB not detected. You may need --browser-cookie-path or --browser-manual-login.');
+                lines.push(chalk.dim(`Cookies DB: ${chalk.yellow('not found')}`));
+            }
+        }
+    }
+    lines.push('');
+    lines.push(chalk.bold('Codex MCP'));
+    lines.push(formatCodexMcpSnippet({ remoteHost: resolvedRemote.host, remoteToken: resolvedRemote.token, includeToken: false }));
+    if (warn.length) {
+        lines.push('');
+        lines.push(chalk.yellowBright('Warnings:'));
+        for (const message of warn) {
+            lines.push(chalk.yellow(`- ${message}`));
+        }
+    }
+    if (fail.length) {
+        lines.push('');
+        lines.push(chalk.redBright('Problems:'));
+        for (const message of fail) {
+            lines.push(chalk.red(`- ${message}`));
+        }
+    }
+    console.log(lines.join('\n'));
+    process.exitCode = fail.length ? 1 : 0;
+}