opera-devtools-mcp 0.6.1 → 0.8.0

package/build/src/opera/profile.js

@@ -0,0 +1,270 @@
+/**
+ * @license
+ * Copyright 2026 Opera Norway AS. All rights reserved.
+ *
+ * This file is an original work developed by Opera.
+ */
+/**
+ * Browser profile inspection — where a build keeps its profile, whether that
+ * profile is in use, and whether the browser holding it can be talked to.
+ *
+ * Ported from opera-browser-cli's `src/profile.ts` (Phase 1b brought only
+ * `defaultProfileDir`; Phase 2 adds the inspection half, which `doctor`'s
+ * profile check needs).
+ *
+ * Chromium refuses to start a second instance on a user-data-dir that is
+ * already open: it hands its command line to the running instance through a
+ * singleton socket and exits. Launching into a live profile therefore does not
+ * fail loudly, it fails as "the browser we asked for never appeared" — which is
+ * why this has to be detected before launch rather than diagnosed after it.
+ *
+ * Two files in the user-data-dir root tell us what we need:
+ *
+ *   SingletonLock       a symlink whose target is "<hostname>-<pid>" (POSIX),
+ *                       or "Mac-<pid>" (Chromium's macOS singleton variant).
+ *                       Present and live => the profile is in use.
+ *   DevToolsActivePort  written whenever the browser was started with
+ *                       --remote-debugging-port. Line 1 is the port.
+ *
+ * Neither file is authoritative on its own: SingletonLock outlives a crash, and
+ * DevToolsActivePort outlives a clean exit. Both are confirmed against the live
+ * system before being acted on.
+ */
+import childProcess from 'node:child_process';
+import { existsSync, lstatSync, readFileSync, readlinkSync } from 'node:fs';
+import { request } from 'node:http';
+import { hostname } from 'node:os';
+import { join } from 'node:path';
+import { browserDisplayName } from './detect.js';
+/** macOS bundle id that owns the profile of each build. */
+const MAC_BUNDLE_ID = {
+    'Opera Neon Developer': 'com.operasoftware.OperaNeonDeveloper',
+    'Opera Neon': 'com.operasoftware.OperaNeon',
+    'Opera GX': 'com.operasoftware.OperaGX',
+    Opera: 'com.operasoftware.Opera',
+};
+/**
+ * Where the given Opera build keeps its real profile, if we can find it.
+ * `platform` and `env` are test seams; production callers use the defaults.
+ */
+export function defaultProfileDir(browserPath, home, platform = process.platform, env = process.env) {
+    // The build name decides both paths: it is the Windows profile folder
+    // verbatim, and the key of the macOS bundle id.
+    const build = browserDisplayName(browserPath ?? '');
+    let candidate;
+    if (platform === 'darwin') {
+        // Joined, not interpolated: the returned path is compared and printed, and
+        // a caller on the same machine builds the same location with `path.join`.
+        candidate = join(home, 'Library', 'Application Support', MAC_BUNDLE_ID[build]);
+    }
+    else if (platform === 'win32') {
+        const appData = env.APPDATA ?? `${home}\\AppData\\Roaming`;
+        candidate = `${appData}\\Opera Software\\${build}`;
+    }
+    else {
+        return null;
+    }
+    return existsSync(candidate) ? candidate : null;
+}
+/**
+ * Split a SingletonLock target into hostname and pid.
+ *
+ * The hostname routinely contains dashes ("Someones-MacBook-Pro-24601"), so the
+ * split has to come from the right.
+ */
+export function parseSingletonTarget(target) {
+    const split = target.lastIndexOf('-');
+    if (split <= 0) {
+        return null;
+    }
+    const pid = Number.parseInt(target.slice(split + 1), 10);
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return null;
+    }
+    return { hostname: target.slice(0, split), pid };
+}
+/**
+ * The names this machine's Chromium may have written into a `SingletonLock`.
+ *
+ * `os.hostname()` is `gethostname()`, and on macOS that is the short,
+ * ComputerName-derived name — "Mac", on a laptop that has been renamed — while
+ * Chromium's POSIX singleton asks `[[NSHost currentHost] name]`, the Bonjour
+ * name built from the LocalHostName ("opera-users-MacBook-Pro-2.local"). The
+ * two disagree on any renamed Mac, and a lock that names the other spelling is
+ * still this machine's. Treating it as foreign discards the pid, and the pid is
+ * the only thing that can restart the browser holding the profile: the user is
+ * told to quit Opera themselves for a browser we could have identified.
+ *
+ * `scutil` is asked per call rather than cached, so a test can stub the process
+ * seam and see its own answer; it costs a few milliseconds on a path that runs
+ * once per command, and a failure (no `scutil`, or a sandbox that blocks it)
+ * simply leaves the name out — the old behaviour.
+ */
+export function localHostNames(platform = process.platform) {
+    const names = [hostname()];
+    if (platform === 'darwin') {
+        const local = readMacLocalHostName();
+        if (local !== null) {
+            names.push(local, `${local}.local`);
+        }
+        // Chromium's macOS singleton has also been seen writing this marker in
+        // place of a hostname; it means this machine either way.
+        names.push('Mac');
+    }
+    return [...new Set(names)];
+}
+function readMacLocalHostName() {
+    try {
+        const name = childProcess
+            .execFileSync('scutil', ['--get', 'LocalHostName'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })
+            .trim();
+        return name && name !== 'not set' ? name : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Whether a pid belongs to a running process on this machine.
+ *
+ * `EPERM` means it exists but belongs to another user, which still counts as
+ * alive; anything else means it is gone. Exported because the pid is polled
+ * while waiting for a signalled browser to exit (`browserTarget.ts`), and that
+ * poll has to agree with this one about the EPERM case.
+ */
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+/**
+ * Determine whether a user-data-dir is currently held by a running browser.
+ *
+ * A dangling lock reads as "free": Chromium cleans those up itself on the next
+ * launch, so treating one as a conflict would block a launch that would in fact
+ * succeed.
+ */
+export function inspectProfileLock(userDataDir, aliveCheck = isProcessAlive, platform = process.platform, localNames = localHostNames(platform)) {
+    const lockPath = join(userDataDir, 'SingletonLock');
+    let target;
+    try {
+        // lstat, not stat: the link is expected to dangle after a crash, and a
+        // dangling symlink is exactly the case we want to report as free.
+        if (!lstatSync(lockPath).isSymbolicLink()) {
+            // Windows writes a regular file instead of a symlink. We can see that the
+            // profile is claimed but not by whom.
+            return { state: 'unknown', pid: null, hostname: null };
+        }
+        target = readlinkSync(lockPath);
+    }
+    catch {
+        return { state: 'free', pid: null, hostname: null };
+    }
+    const parsed = parseSingletonTarget(target);
+    if (parsed === null) {
+        return { state: 'unknown', pid: null, hostname: null };
+    }
+    // Another machine (a synced profile) or a local name we do not know: never
+    // signal its pid.
+    if (!localNames.includes(parsed.hostname)) {
+        return { state: 'unknown', pid: null, hostname: parsed.hostname };
+    }
+    if (!aliveCheck(parsed.pid)) {
+        return { state: 'free', pid: null, hostname: parsed.hostname };
+    }
+    return { state: 'locked', pid: parsed.pid, hostname: parsed.hostname };
+}
+// ---------------------------------------------------------------------------
+// DevTools endpoint
+// ---------------------------------------------------------------------------
+/** First line of DevToolsActivePort is the port; the second is a ws path. */
+export function parseDevToolsActivePort(contents) {
+    const first = contents.split('\n')[0]?.trim() ?? '';
+    const port = Number.parseInt(first, 10);
+    if (!Number.isInteger(port) || port <= 0 || port > 65_535) {
+        return null;
+    }
+    return port;
+}
+/** The debug port a running browser advertised, if it was given one. */
+export function readDevToolsPort(userDataDir) {
+    const portFile = join(userDataDir, 'DevToolsActivePort');
+    try {
+        if (!existsSync(portFile)) {
+            return null;
+        }
+        return parseDevToolsActivePort(readFileSync(portFile, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Confirm a debug port is live and find out what is on the other end.
+ *
+ * DevToolsActivePort survives a clean exit, so a recorded port proves nothing
+ * until something answers on it.
+ */
+export function probeDevToolsEndpoint(port, timeoutMs = 1500) {
+    const { promise, resolve } = Promise.withResolvers();
+    const req = request({
+        hostname: '127.0.0.1',
+        port,
+        path: '/json/version',
+        method: 'GET',
+        timeout: timeoutMs,
+    }, res => {
+        let body = '';
+        res.on('data', chunk => (body += chunk));
+        res.on('end', () => {
+            try {
+                const parsed = JSON.parse(body);
+                if (typeof parsed.Browser !== 'string') {
+                    resolve(null);
+                    return;
+                }
+                resolve({
+                    browser: parsed.Browser,
+                    isOpera: /opera|opr\//i.test(parsed.Browser),
+                });
+            }
+            catch {
+                resolve(null);
+            }
+        });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => {
+        req.destroy();
+        resolve(null);
+    });
+    req.end();
+    return promise;
+}
+/**
+ * The browser URL to attach to for this profile, or null when there is nothing
+ * live to attach to.
+ *
+ * This is the one signal that makes driving the user's own browser automatic:
+ * a browser started with `--remote-debugging-port` records its port in the
+ * profile, so every later command finds it without any configuration.
+ */
+export async function findAttachableEndpoint(userDataDir) {
+    const port = readDevToolsPort(userDataDir);
+    if (port === null) {
+        return null;
+    }
+    const identity = await probeDevToolsEndpoint(port);
+    if (identity === null) {
+        return null;
+    }
+    return { url: `http://127.0.0.1:${port}`, identity };
+}
+//# sourceMappingURL=profile.js.map

package/build/src/opera/refArgs.js

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2026 Opera Norway AS. All rights reserved.
+ *
+ * This file is an original work developed by Opera.
+ */
+import { refToMcp } from './compactSnapshot.js';
+/**
+ * One command's ref-valued argument names, in table order: `uid` (click, fill,
+ * hover, take_screenshot, upload_file) plus `from_uid` and `to_uid` (drag).
+ *
+ * The naming rule is the whole contract — the descriptions upstream writes for
+ * these arguments all open with `The uid of `, and
+ * `tests/opera/refArgs.test.ts` pins the two derivations against each other, so
+ * an intake merge that renames or adds one fails there instead of quietly
+ * shipping a ref the CLI cannot translate.
+ */
+export function refArgNames(args) {
+    return Object.keys(args).filter(name => name === 'uid' || name.endsWith('_uid'));
+}
+/**
+ * The command's arguments with every ref value in MCP wire form, so `@4.11` —
+ * the form the snapshot printed — reaches the daemon as `4_11`. A value that is
+ * not a string, or an argument that is not a ref, is passed through untouched.
+ */
+export function normalizeRefArgs(args, values) {
+    const normalized = { ...values };
+    for (const name of refArgNames(args)) {
+        const value = normalized[name];
+        if (typeof value === 'string') {
+            normalized[name] = refToMcp(value);
+        }
+    }
+    return normalized;
+}
+//# sourceMappingURL=refArgs.js.map

package/build/src/opera/serviceWorkerRetry.js

@@ -4,9 +4,12 @@
  *
  * This file is an original work developed by Opera.
  */
+import { ConnectionClosedError, TargetCloseError } from '../third_party/index.js';
+import { logger } from '../utils/logger.js';
 /**
  * Opera's AI service worker may not be running yet when the first CDP command
- * arrives, so dispatches are retried with a fixed backoff.
+ * arrives, so a dispatch that failed *before reaching it* is retried with a
+ * fixed backoff.
  *
  * Exposed as a mutable object so tests can drive the retry loop without waiting
  * on real time. Faking timers is not a workable alternative here: sinon's fake
@@ -17,7 +20,42 @@ export const serviceWorkerRetryPolicy = {
     maxAttempts: 5,
     delayMs: 2500,
 };
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+function sleep(ms) {
+    const { promise, resolve } = Promise.withResolvers();
+    setTimeout(resolve, ms);
+    return promise;
+}
+/**
+ * The one failure a replay is allowed after: Opera's dispatcher had nothing to
+ * dispatch to, which is what a service worker that is still coming up reports.
+ * `opera/cdpErrors.ts` recognises the same wording to tell the user a browser
+ * without Opera AI apart from one that is merely not ready yet.
+ */
+const NOT_DISPATCHED = /dispatcher was not able to dispatch|no target/i;
+/**
+ * Whether a replay of this failure is safe.
+ *
+ * A dispatch is not idempotent — `chat`, `do`, `make` and `research` each open
+ * the tab they run in, and the AI run behind them may already be under way — so
+ * a retry is only defensible when the error proves the action never reached
+ * Opera's AI at all. Retrying every other failure multiplied real side effects:
+ * a chat that kept failing on a browser-side storage error was sent five times
+ * and left five tabs, and the last four failures were logged only as "attempt
+ * N/5", with the actual error buried.
+ *
+ * Connection-closed errors are permanent for a different reason (the CDP
+ * session is gone for good) and are matched by class rather than by `error.name`
+ * — the names are Puppeteer's to change, and a rename would silently turn every
+ * permanent failure back into five retries. The classes come through
+ * `third_party/index.ts`.
+ */
+function isRetryableError(error) {
+    if (error instanceof TargetCloseError ||
+        error instanceof ConnectionClosedError) {
+        return false;
+    }
+    return NOT_DISPATCHED.test(error.message);
+}
 export async function withServiceWorkerRetry(fn) {
     const { maxAttempts, delayMs } = serviceWorkerRetryPolicy;
     let lastError;
@@ -27,9 +65,13 @@ export async function withServiceWorkerRetry(fn) {
         }
         catch (e) {
             lastError = e;
-            if (attempt < maxAttempts - 1) {
-                await sleep(delayMs);
+            if (attempt >= maxAttempts - 1 || !isRetryableError(lastError)) {
+                break;
             }
+            // The line is what makes a replay visible in `opera-browser-cli logs`:
+            // the extra tab it may leave is the only other trace of it.
+            logger?.(`Opera dispatch attempt ${attempt + 1}/${maxAttempts} failed, retrying in ${delayMs}ms: ${lastError.message}`);
+            await sleep(delayMs);
         }
     }
     throw lastError;

package/build/src/opera/setup.js

@@ -0,0 +1,290 @@
+/**
+ * @license
+ * Copyright 2026 Opera Norway AS. All rights reserved.
+ *
+ * This file is an original work developed by Opera.
+ */
+/**
+ * `setup` — interactive and non-interactive configuration.
+ *
+ * Ported from opera-browser-cli's `src/cli.ts`. The three settings it writes
+ * are the three the fork reads (`OPERA_CLI_EXECUTABLE_PATH`, `OPERA_CLI_HEADED`,
+ * `OPERA_CLI_USER_DATA_DIR`); hooks are not ported, so nothing here installs
+ * them.
+ *
+ * Two shape changes from the source:
+ *
+ * - The skill files are installed to `~/.claude/skills/opera-browser-cli/` and
+ *   `~/.agents/skills/opera-browser-cli/`, from the `SKILL.md` kept at
+ *   `src/opera/skills/` (copied to `build/src/opera/skills/` by
+ *   `scripts/post-build.ts`, so it publishes with the rest of `build/src`).
+ * - A non-TTY falls back to the non-interactive path rather than refusing: the
+ *   callers that most need `setup` are agents, provisioning scripts and
+ *   containers, and none of them have a terminal.
+ */
+import { copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { CLI_BIN_NAME } from './branding.js';
+import { encode, renderHelp, renderOutput } from './cliOutput.js';
+import { writeConfigFile } from './config.js';
+import { browserDisplayName, detectBrowsers, neonCandidatePaths, operaCandidatePaths, } from './detect.js';
+import { getConfigFile, getStateDir, readConfigFile } from './envConfig.js';
+import { defaultProfileDir } from './profile.js';
+/** `--executable`, `--profile`, `--headed`/`--headless` each imply non-interactive. */
+export function parseSetupArgs(args) {
+    let interactive = true;
+    let executable;
+    let profile;
+    let headed;
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case '--non-interactive':
+            case '--yes':
+            case '-y':
+                interactive = false;
+                break;
+            case '--executable':
+                if (i + 1 < args.length) {
+                    executable = args[++i];
+                    interactive = false;
+                }
+                break;
+            case '--profile':
+                if (i + 1 < args.length) {
+                    profile = args[++i];
+                    interactive = false;
+                }
+                break;
+            case '--headed':
+                headed = true;
+                interactive = false;
+                break;
+            case '--headless':
+                headed = false;
+                interactive = false;
+                break;
+        }
+    }
+    return { interactive, executable, profile, headed };
+}
+/**
+ * Where `SKILL.md` lives: the `skills/` directory beside this module.
+ *
+ * The layout is the same in the source tree (`src/opera/skills/`) and in the
+ * build output (`build/src/opera/skills/`, written by `scripts/post-build.ts`),
+ * so one candidate covers both.
+ */
+function findSkillSource() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidate = join(here, 'skills', 'SKILL.md');
+    return existsSync(candidate) ? candidate : null;
+}
+/** Install SKILL.md for Claude Code and the generic cross-agent path. */
+export function installSkillFiles(report, home = homedir()) {
+    const skillSrc = findSkillSource();
+    if (skillSrc === null) {
+        report('SKILL.md not found in src/opera/skills — skipping skill install');
+        return;
+    }
+    for (const { agent, dir } of [
+        { agent: 'Claude', dir: join(home, '.claude', 'skills') },
+        { agent: 'generic', dir: join(home, '.agents', 'skills') },
+    ]) {
+        // The skill directory name is the skill's own identity (see the
+        // `name:` frontmatter in SKILL.md), not the binary name.
+        const skillDst = join(dir, 'opera-browser-cli', 'SKILL.md');
+        mkdirSync(dirname(skillDst), { recursive: true });
+        copyFileSync(skillSrc, skillDst);
+        report(`Installed ${agent} skill -> ${skillDst}`);
+    }
+}
+/**
+ * Configure without prompting: detection plus whatever the flags override.
+ *
+ * `home` and `platform` are test seams; production callers use the defaults.
+ * Detection, the executable it finds and the profile that follows from it must
+ * all agree on one platform, so the seam is threaded rather than read again.
+ */
+export async function setupNonInteractive(parsed, home = homedir(), platform = process.platform) {
+    const config = readConfigFile(getConfigFile(home));
+    const executable = parsed.executable ??
+        config.OPERA_CLI_EXECUTABLE_PATH ??
+        detectBrowsers(platform, home)[0]?.path;
+    if (executable) {
+        config.OPERA_CLI_EXECUTABLE_PATH = executable;
+    }
+    const headed = parsed.headed ?? (config.OPERA_CLI_HEADED === '1' || Boolean(executable));
+    if (headed) {
+        config.OPERA_CLI_HEADED = '1';
+    }
+    else {
+        delete config.OPERA_CLI_HEADED;
+    }
+    if (parsed.profile === 'skip') {
+        delete config.OPERA_CLI_USER_DATA_DIR;
+    }
+    else {
+        const profile = parsed.profile ??
+            config.OPERA_CLI_USER_DATA_DIR ??
+            defaultProfileDir(executable, home, platform) ??
+            join(getStateDir(home), 'profile');
+        config.OPERA_CLI_USER_DATA_DIR = profile;
+    }
+    writeConfigFile(config, home);
+    const notes = [];
+    installSkillFiles(line => notes.push(line), home);
+    const help = [
+        `Run \`${CLI_BIN_NAME} new_page https://example.com\` to start browsing`,
+    ];
+    if (!executable) {
+        help.unshift('No Opera installation found — set OPERA_CLI_EXECUTABLE_PATH or pass --executable <path>');
+    }
+    return renderOutput([
+        await encode({ config: getConfigFile(home), settings: config }),
+        notes.join('\n'),
+        renderHelp(help),
+    ]);
+}
+/**
+ * The interactive wizard. `home` and `platform` are test seams: the prompts are
+ * per-platform (which installs exist, and where each build keeps its profile),
+ * so callers that simulate a machine pin both rather than reading the host.
+ */
+export async function handleSetup(args, home = homedir(), platform = process.platform) {
+    const parsed = parseSetupArgs(args);
+    // No terminal to prompt in is a reason to fall back, not to fail.
+    if (!parsed.interactive || !process.stdin.isTTY) {
+        return setupNonInteractive(parsed, home, platform);
+    }
+    const stateDir = getStateDir(home);
+    const configFile = getConfigFile(home);
+    const existing = readConfigFile(configFile);
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (question) => new Promise(resolve => rl.question(question, resolve));
+    const config = { ...existing };
+    try {
+        process.stdout.write(`${CLI_BIN_NAME} setup\n\n`);
+        // 1. Browser executable path
+        const detectedNeons = neonCandidatePaths(platform, home).filter(path => existsSync(path));
+        const detectedOpera = operaCandidatePaths(platform, home).find(path => existsSync(path));
+        const currentExec = existing['OPERA_CLI_EXECUTABLE_PATH'];
+        if (detectedNeons.length > 0) {
+            // Always show the full list so the user can switch between versions.
+            // Mark whichever entry matches the current config (if any).
+            const currentIdx = detectedNeons.indexOf(currentExec ?? '');
+            process.stdout.write('Opera Neon installations found:\n');
+            detectedNeons.forEach((path, i) => {
+                const marker = i === currentIdx ? ' (current)' : '';
+                process.stdout.write(`  [${i + 1}] ${browserDisplayName(path)}${marker}\n      ${path}\n`);
+            });
+            const defaultIdx = currentIdx >= 0 ? currentIdx + 1 : 1;
+            const ans = (await ask(`Select [1-${detectedNeons.length}], enter a custom path, or "clear" to unset [${defaultIdx}]: `)).trim();
+            if (ans.toLowerCase() === 'clear') {
+                delete config['OPERA_CLI_EXECUTABLE_PATH'];
+            }
+            else if (!ans) {
+                config['OPERA_CLI_EXECUTABLE_PATH'] = detectedNeons[defaultIdx - 1];
+            }
+            else {
+                const idx = Number.parseInt(ans, 10);
+                if (Number.isFinite(idx) && idx >= 1 && idx <= detectedNeons.length) {
+                    config['OPERA_CLI_EXECUTABLE_PATH'] = detectedNeons[idx - 1];
+                }
+                else {
+                    config['OPERA_CLI_EXECUTABLE_PATH'] = ans; // custom path
+                }
+            }
+        }
+        else if (currentExec) {
+            // No auto-detected Neons but something is already configured.
+            process.stdout.write(`Browser binary: ${currentExec}\n`);
+            const ans = (await ask('Enter a new path, "clear" to remove, or press Enter to keep: ')).trim();
+            if (ans.toLowerCase() === 'clear') {
+                delete config['OPERA_CLI_EXECUTABLE_PATH'];
+            }
+            else if (ans) {
+                config['OPERA_CLI_EXECUTABLE_PATH'] = ans;
+            }
+        }
+        else {
+            // Nothing detected or configured.
+            process.stdout.write('Opera Neon not found. Install it from https://www.operaneon.com to enable the full Opera AI tool set.\n');
+            if (detectedOpera) {
+                const operaName = browserDisplayName(detectedOpera);
+                process.stdout.write(`\nFound ${operaName} at:\n  ${detectedOpera}\n`);
+                const ans = (await ask(`Use ${operaName} as the browser? (invoke-do/make/research require Opera Neon) [Y/n]: `))
+                    .trim()
+                    .toLowerCase();
+                if (ans === '' || ans === 'y') {
+                    config['OPERA_CLI_EXECUTABLE_PATH'] = detectedOpera;
+                }
+            }
+        }
+        // 2. Headed mode (defaults to Y so users see the browser they're driving)
+        const headedAns = (await ask('Run in headed (visible) mode? [Y/n]: '))
+            .trim()
+            .toLowerCase();
+        if (headedAns === 'n') {
+            delete config['OPERA_CLI_HEADED'];
+        }
+        else {
+            config['OPERA_CLI_HEADED'] = '1';
+        }
+        // 3. Persistent profile directory
+        const currentProfile = existing['OPERA_CLI_USER_DATA_DIR'] ?? '';
+        const detectedProfile = defaultProfileDir(config['OPERA_CLI_EXECUTABLE_PATH'], home, platform);
+        let profilePrompt;
+        let profileDefault;
+        let profileListShown = false;
+        if (currentProfile &&
+            detectedProfile &&
+            currentProfile !== detectedProfile) {
+            profileListShown = true;
+            process.stdout.write('Persistent profile directory:\n');
+            process.stdout.write(`  [1] ${currentProfile}  (current)\n`);
+            process.stdout.write(`  [2] ${detectedProfile}  (detected)\n`);
+            profilePrompt =
+                'Select [1/2], enter a custom path, or "skip" to omit [1]: ';
+            profileDefault = currentProfile;
+        }
+        else {
+            profileDefault =
+                currentProfile || detectedProfile || join(stateDir, 'profile');
+            profilePrompt = `Persistent profile directory (blank to use default, "skip" to omit):\n  [${profileDefault}]: `;
+        }
+        const profileAns = (await ask(profilePrompt)).trim();
+        if (profileAns.toLowerCase() === 'skip') {
+            delete config['OPERA_CLI_USER_DATA_DIR'];
+        }
+        else if (profileListShown && profileAns === '2' && detectedProfile) {
+            config['OPERA_CLI_USER_DATA_DIR'] = detectedProfile;
+        }
+        else if (profileListShown && (profileAns === '1' || !profileAns)) {
+            config['OPERA_CLI_USER_DATA_DIR'] = currentProfile;
+        }
+        else if (profileAns) {
+            config['OPERA_CLI_USER_DATA_DIR'] = profileAns;
+        }
+        else {
+            config['OPERA_CLI_USER_DATA_DIR'] = profileDefault;
+        }
+    }
+    finally {
+        rl.close();
+    }
+    writeConfigFile(config, home);
+    process.stdout.write(`\nSaved to ${configFile}\n`);
+    installSkillFiles(line => process.stdout.write(line + '\n'), home);
+    return renderOutput([
+        await encode({ config: configFile, settings: config }),
+        renderHelp([
+            `Run \`${CLI_BIN_NAME} --help\` to see all commands`,
+            `Run \`${CLI_BIN_NAME} setup\` again to reconfigure`,
+            `Run \`${CLI_BIN_NAME} new_page https://example.com\` to start browsing`,
+        ]),
+    ]);
+}
+//# sourceMappingURL=setup.js.map