@tiny-fish/cli 0.39.1-next.309 → 0.40.0

package/dist/commands/connect.d.ts

@@ -23,20 +23,8 @@ export interface NativeConnectOptions {
     /** Targeted connects only: --all keeps its per-harness failed row. */
     fallbackWhenMissing?: boolean;
 }
-export declare function connectOpenClaw(options: {
-    apiKey?: string;
-    mcpUrl: string;
-    launch: boolean;
-    cliInstall?: boolean;
-    attemptId?: string;
-    /** Set by `--all`: the CLI install already ran once, upfront. */
-    hoistedCliInstall?: TakeHoistedCliInstall;
-    verbose?: boolean;
-    /** Set by `--all`: repeated outro lines print once, after the summary. */
-    deferOutro?: (line: string) => void;
-    /** Targeted connects only: --all keeps its per-harness failed row. */
-    fallbackWhenMissing?: boolean;
-}): Promise<void>;
+/** Skill install only: no key handoff, sign-in wait, or post-install callback to honour. */
+export declare function connectOpenClaw(options: Omit<NativeConnectOptions, 'keyAuthOnly' | 'authTimeoutMs' | 'onPostInstallFailed'>): Promise<void>;
 /** Writes mcp.json directly — no `cursor mcp add` exists. */
 export declare function connectCursor(options: {
     apiKey?: string;

package/dist/commands/connect.js

@@ -1,14 +1,15 @@
 import spawn from 'cross-spawn';
 import { CONNECT_SOURCE, persistApiKeyToEnvironment, saveConnectContext, validateKeyFormat, validatedApiKey, } from '../lib/auth.js';
-import { CURSOR_SKILL_TARGET, OPENCLAW, openclawSkillInstallArgs, NATIVE_BY_HARNESS, launchNativeMcpClient, launchOmpWalkthrough, launchOpenClawWalkthrough, openExternalUrl, } from '../lib/connect-clients.js';
-import { captureStdio, capturedOutput, HoistedFailureReportedError, installTinyFishCli, replay, SKILL_INSTALL_TIMEOUT_MS, STEP_MAX_BUFFER, } from '../lib/cli-install.js';
+import { CURSOR_SKILL_TARGET, OPENCLAW, openclawSkillInstallArgs, NATIVE_BY_HARNESS, launchNativeMcpClient, launchOmpWalkthrough, launchPiWalkthrough, launchOpenClawWalkthrough, openExternalUrl, } from '../lib/connect-clients.js';
+import { captureStdio, capturedOutput, installTinyFishCli, replay, SKILL_INSTALL_TIMEOUT_MS, STEP_MAX_BUFFER, } from '../lib/cli-install.js';
 import { ensureCliAuthenticated } from '../lib/connect-auth.js';
 import { createStdinPrompt, runCliFallback } from '../lib/connect-fallback.js';
 import { installWebSkill } from '../lib/skill-install.js';
-import { ConnectInterruptedError, ConnectStepError, createConnectTelemetry, finishSetupCommand, requireCommandSupport, runGuarded, settle, SignInTimeoutError, spawnStepError, stageDurationOf, withStageDuration, spawnRemoval, } from '../lib/connect-runtime.js';
+import { ConnectInterruptedError, ConnectStepError, HoistedFailureReportedError, createConnectTelemetry, finishSetupCommand, requireCommandSupport, runGuarded, settle, SignInTimeoutError, spawnStepError, stageDurationOf, withStageDuration, spawnRemoval, } from '../lib/connect-runtime.js';
 import { cursorInstallDeeplink, cursorMcpPath, readCursorTinyfishEntry, writeCursorMcpConfig, } from '../lib/cursor-config.js';
 import { runConnectAll } from '../lib/connect-all.js';
 import { ompMcpPath, readOmpTinyfishEntry, writeOmpMcpConfig } from '../lib/omp-config.js';
+import { PI_ADAPTER_INSTALL_COMMAND, piMcpAdapterState, piSkillDirMismatch, piMcpPath, readPiTinyfishEntry, writePiMcpConfig, } from '../lib/pi-config.js';
 import { ALL_HARNESSES, AuthMode, HARNESS_DISPLAY_NAMES, RELOAD_ACTION, } from '../lib/harness-detect.js';
 import { detectHumanInitiated } from '../lib/harness.js';
 import { TINYFISH_API_KEY_VAR } from '../lib/constants.js';
@@ -62,14 +63,16 @@ function resolveKeyedAdd(client, storedKey, keyAuthSupported, deferOutro) {
     return keyed;
 }
 /** No sign-in to degrade to, so the install stops. */
-function refuseKeylessInstall(client, keyAuthSupported) {
-    const noSignIn = `TinyFish does not sign in to ${client.displayName} any other way`;
+function refuseKeylessInstall(client, keyAuthSupported, headless = false) {
+    const noSignIn = headless
+        ? 'signing in needs a terminal'
+        : `TinyFish does not sign in to ${client.displayName} any other way`;
     const rerun = `re-run: tinyfish connect ${client.connectClient}`;
     if (!client.keyAuth) {
         throw new ConnectStepError(`${client.displayName} cannot take a TinyFish API key, and ${noSignIn}. ` +
             `Run: tinyfish connect ${client.connectClient}`, 'key_auth_unsupported');
     }
-    if (!keyAuthSupported) {
+    if (!keyAuthSupported || headless) {
         throw new ConnectStepError(`This ${client.displayName} install cannot take a TinyFish API key, and ${noSignIn}. ` +
             `Update it, then ${rerun}`, 'harness_too_old');
     }
@@ -159,21 +162,30 @@ async function prepareInstallAuth(client, options, keyAuthSupported) {
     const buildAddArgs = keyedAdd
         ? (mcpUrl) => keyedAdd.spec.addArgs(mcpUrl, keyedAdd.key)
         : keylessAddArgs(client, keyAuthSupported);
-    if (options.keyAuthOnly && !keyedAdd) {
-        // All native clients have keyAuth; missing flags mean an old install.
-        if (client.keyAuth) {
-            throw new ConnectStepError(`This ${client.displayName} install cannot take a TinyFish API key, and signing in ` +
-                `needs a terminal. Update it, then re-run: tinyfish connect ${client.connectClient}`, 'harness_too_old');
-        }
-        throw new ConnectStepError(`${client.displayName} cannot take a TinyFish API key, and signing in needs a ` +
-            `terminal. Run: tinyfish connect ${client.connectClient}`, 'key_auth_unsupported');
-    }
+    if (options.keyAuthOnly && !keyedAdd)
+        refuseKeylessInstall(client, keyAuthSupported, true);
     // Verify first: a revoked key in a foreign .env is unrecoverable.
     if (keyedAdd?.spec.seedKey) {
         await verifyKeyBeforeSeeding(keyedAdd.key, client.displayName, options.mcpUrl);
     }
     return { keyedAdd, buildAddArgs };
 }
+/** Inherit for an inline-OAuth add; capture otherwise, piping prompts when seeded. */
+function addSpawnOptions(options, interactiveAdd, seeded) {
+    if (interactiveAdd)
+        return { stdio: 'inherit', timeout: options.authTimeoutMs };
+    if (!seeded)
+        return captureStdio(options.verbose ?? false);
+    return {
+        encoding: 'utf8',
+        // Without it, the 1 MiB default overflows into a misread Ctrl+C.
+        maxBuffer: STEP_MAX_BUFFER,
+        // The unattended path had no bound at all before; captureStdio's is the floor.
+        timeout: options.authTimeoutMs ?? SKILL_INSTALL_TIMEOUT_MS,
+        input: seeded.stdinInput,
+        env: seeded.env,
+    };
+}
 /** Returns the seeded-credential note when a key was written into a user-owned file. */
 function performMcpAdd(client, options, plan, attemptId) {
     const { keyedAdd, buildAddArgs } = plan;
@@ -188,20 +200,11 @@ function performMcpAdd(client, options, plan, attemptId) {
     const interactiveAdd = !(client.nonInteractiveAdd || keyedAdd);
     // After the removals: an interrupt there leaves no key behind.
     const seeded = keyedAdd?.spec.seedKey?.(keyedAdd.key);
-    const addOptions = interactiveAdd
-        ? { stdio: 'inherit', timeout: options.authTimeoutMs }
-        : seeded
-            ? {
-                encoding: 'utf8',
-                // Without it, the 1 MiB default overflows into a misread Ctrl+C.
-                maxBuffer: STEP_MAX_BUFFER,
-                // The unattended path had no bound at all before; captureStdio's is the floor.
-                timeout: options.authTimeoutMs ?? SKILL_INSTALL_TIMEOUT_MS,
-                input: seeded.stdinInput,
-                env: seeded.env,
-            }
-            : captureStdio(options.verbose ?? false);
-    const addResult = spawn.sync(client.command, addArgs, addOptions);
+    // Writing the entry ourselves skips the harness probe that saves it disabled.
+    if (seeded?.register(mcpUrl.toString())) {
+        return { note: seeded.note, seededHome: seeded.home };
+    }
+    const addResult = spawn.sync(client.command, addArgs, addSpawnOptions(options, interactiveAdd, seeded));
     // Rolls back first: signInStepError throws on a Ctrl+C.
     const failAdd = (build) => {
         seeded?.rollback();
@@ -219,7 +222,7 @@ function performMcpAdd(client, options, plan, attemptId) {
         // The tag keeps the path-bearing prose out of telemetry.
         { failureDetail: registration.tag }));
     }
-    return seeded?.note;
+    return { note: seeded?.note, seededHome: seeded?.home };
 }
 function performLoginStep(client, pendingLogin, options) {
     errLine('Signing in to TinyFish...');
@@ -294,7 +297,7 @@ async function connectNativeMcpClient(client, options) {
         // A probed client authenticates inside `mcp add` too, so a failure there is either.
         state.stage =
             loginArgs && !probeAuthenticated ? 'registration' : 'registration_or_authentication';
-        const seededNote = performMcpAdd(client, options, plan, telemetry.attemptId);
+        const { note: seededNote, seededHome } = performMcpAdd(client, options, plan, telemetry.attemptId);
         telemetry.track('checkpoint', { phase: 'registered' });
         const { authMode, signInDeferred } = completeAuthFlow(client, options, state, telemetry, {
             useKeyAuth,
@@ -306,7 +309,7 @@ async function connectNativeMcpClient(client, options) {
         state.authMode = authMode;
         // Registration/OAuth make MCP work; later steps are cosmetic and must not fail the attempt.
         settle(state, telemetry, 'completed', { authMode });
-        await runPostInstallSteps(client, options, state, telemetry, signInDeferred);
+        await runPostInstallSteps(client, options, state, telemetry, signInDeferred, seededHome);
     });
     return state.authMode;
 }
@@ -322,7 +325,7 @@ function connectedLine(client, signInDeferred) {
         `${RELOAD_ACTION[client.connectClient]} to pick up the tools.`);
 }
 // Runs after `completed` settled: steps fail alone, the rest still run.
-async function runPostInstallSteps(client, options, state, telemetry, signInDeferred) {
+async function runPostInstallSteps(client, options, state, telemetry, signInDeferred, seededHome) {
     let failed = false;
     // Modelled on upgrade's attempt(); interrupts rethrow and abandon remaining steps.
     const attempt = async (stage, run) => {
@@ -353,6 +356,7 @@ async function runPostInstallSteps(client, options, state, telemetry, signInDefe
                 extraPostInstall({
                     apiKey: validatedApiKey(options.apiKey),
                     verbose: options.verbose ?? false,
+                    seededHome,
                 });
                 telemetry.track('checkpoint', {
                     phase: 'plugin_installed',
@@ -447,6 +451,7 @@ function trackPostInstallFailure(displayName, state, telemetry, error) {
     errLine(`The ${displayName} MCP connection succeeded, but a finishing step ` +
         `(${state.stage}) failed: ${error instanceof Error ? error.message : String(error)}`);
 }
+/** Skill install only: no key handoff, sign-in wait, or post-install callback to honour. */
 export async function connectOpenClaw(options) {
     const telemetry = createConnectTelemetry(options.mcpUrl, 'openclaw', options);
     // Skill install, no MCP server — never degraded, and false keeps it inside a `= false` filter.
@@ -462,15 +467,9 @@ export async function connectOpenClaw(options) {
             return;
         telemetry.setHarnessVersion(support.harnessVersion);
         telemetry.track('checkpoint', { phase: 'prerequisite_ok' });
-        if (options.hoistedCliInstall) {
-            state.stage = 'cli_install';
-            // A carried first-take failure fails openclaw like the inline install.
-            takeHoistedCliInstall(options.hoistedCliInstall, telemetry);
-        }
-        else if (options.cliInstall !== false) {
+        if (options.cliInstall !== false) {
             state.stage = 'cli_install';
-            installTinyFishCli({ verbose: options.verbose ?? false, announce: true });
-            telemetry.track('checkpoint', { phase: 'cli_installed' });
+            runCliInstallStep(options, telemetry);
         }
         state.stage = 'skill_install';
         errLine('Installing the TinyFish skill in OpenClaw...');
@@ -511,6 +510,31 @@ export async function connectOpenClaw(options) {
         }
     });
 }
+const PI_RELOAD_COPY = 'TinyFish is configured in pi. Restart pi, then run `/mcp-auth tinyfish` there if it asks you ' +
+    'to sign in.';
+// The skill is the working path either way, so the note must not read as a failure.
+const PI_ADAPTER_DORMANT_NOTE = 'Note: pi has no built-in MCP support, so the entry in its mcp.json stays dormant until you ' +
+    `run \`${PI_ADAPTER_INSTALL_COMMAND}\`. The TinyFish skill works without it.`;
+// Only the dormant case was spoken for, leaving a working MCP install silent.
+const PI_ADAPTER_LIVE_NOTE = 'pi-mcp-adapter is installed, so pi loads the TinyFish MCP tools as well as the skill once ' +
+    'you restart it.';
+function piAdapterNote() {
+    const state = piMcpAdapterState();
+    if (state === 'installed')
+        return PI_ADAPTER_LIVE_NOTE;
+    return state === 'absent' ? PI_ADAPTER_DORMANT_NOTE : undefined;
+}
+// The `skills` CLI writes to the default dir even when pi reads another one.
+function piPostConnectNotes() {
+    const notes = [piAdapterNote()];
+    const skills = piSkillDirMismatch();
+    if (skills) {
+        notes.push(`Note: PI_CODING_AGENT_DIR points pi at ${skills.readFrom}, but the TinyFish skill ` +
+            `installed to ${skills.installedTo}. Copy or symlink it across for pi to load it.`);
+    }
+    const printable = notes.filter(Boolean);
+    return printable.length > 0 ? printable.join('\n') : undefined;
+}
 // Only interactive omp wires the OAuth handler; headless cannot sign in.
 const OMP_KEYLESS_COPY = 'TinyFish is configured in omp. Open omp and sign in to TinyFish when prompted, or run ' +
     '`/mcp reauth tinyfish` there.';
@@ -545,6 +569,22 @@ const CONFIG_FILE_HARNESSES = {
             reload: OMP_KEYLESS_COPY,
         },
     },
+    pi: {
+        skillTarget: { skillAgent: 'pi', displayName: HARNESS_DISPLAY_NAMES.pi },
+        registeredUrl: () => readPiTinyfishEntry().url,
+        write: writePiMcpConfig,
+        configPath: piMcpPath,
+        // No install deeplink exists; the copy carries the restart instead.
+        tryLaunch: () => false,
+        postConnectNote: piPostConnectNotes,
+        copy: {
+            verified: "TinyFish is connected and verified (health+auth). Restart pi and it's live.",
+            authFailed: (reason) => `TinyFish is configured, but the authenticated check failed (${reason}). ` +
+                'Fix: rotate/re-enter your key with `tinyfish auth login`, then re-run: tinyfish connect pi',
+            launched: PI_RELOAD_COPY,
+            reload: PI_RELOAD_COPY,
+        },
+    },
 };
 /** Writes the harness's MCP config file itself; no `mcp add` exists. */
 async function connectConfigFileHarness(harness, options) {
@@ -638,6 +678,9 @@ async function connectConfigFileHarness(harness, options) {
         else {
             errLine(spec.copy.reload);
         }
+        const note = spec.postConnectNote?.();
+        if (note)
+            errLine(note);
         settle(state, telemetry, 'completed', { authMode: resolvedKey ? AuthMode.ApiKey : 'deferred' });
     });
 }
@@ -653,6 +696,7 @@ function launchCursorDeeplink(mcpUrl) {
 /** Total over the non-native harnesses: a new one fails to compile until wired here. */
 const LAUNCH_OVERRIDES = {
     omp: launchOmpWalkthrough,
+    pi: launchPiWalkthrough,
     openclaw: launchOpenClawWalkthrough,
     // Cursor has no chat CLI to launch.
     cursor: () => {
@@ -693,6 +737,19 @@ const CONNECTOR_OVERRIDES = {
         }
         return undefined;
     },
+    pi: async (options) => {
+        await connectConfigFileHarness('pi', options);
+        if (options.launch) {
+            try {
+                await launchPiWalkthrough();
+            }
+            catch (error) {
+                errLine(error instanceof Error ? error.message : String(error));
+                errLine(finishSetupHint('pi'));
+            }
+        }
+        return undefined;
+    },
 };
 function requireNative(harness) {
     const client = NATIVE_BY_HARNESS.get(harness);
@@ -707,17 +764,8 @@ export async function connectHarness(harness, options) {
 }
 function parseMcpUrlOption(options) {
     let mcpUrl = options.url ?? DEFAULT_MCP_URL;
-    if (mcpUrl.startsWith('-')) {
-        throw new Error(`Invalid --url value: ${mcpUrl}`);
-    }
-    let parsedUrl;
-    try {
-        parsedUrl = new URL(mcpUrl);
-    }
-    catch {
-        throw new Error(`Invalid --url value: ${mcpUrl}`);
-    }
-    if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+    const parsedUrl = URL.parse(mcpUrl);
+    if (mcpUrl.startsWith('-') || !parsedUrl || !['http:', 'https:'].includes(parsedUrl.protocol)) {
         throw new Error(`Invalid --url value: ${mcpUrl}`);
     }
     // Page-minted attempt id rides in on --url. Strip before the URL becomes the MCP
@@ -732,10 +780,16 @@ function parseMcpUrlOption(options) {
     }
     return { mcpUrl, attemptId };
 }
-async function connectAllPath(options, mcpUrl, attemptId) {
+/** Bare `connect` offers the picker; `--all` takes the dry-run/uninstall/skip-launch flags. */
+async function connectManyPath(options, mcpUrl, attemptId) {
     if (options.launch) {
         throw new Error('--launch is not supported with --all. Connect a single client to launch it.');
     }
+    const pick = !options.all;
+    const humanInitiated = pick && detectHumanInitiated();
+    if (pick && !humanInitiated) {
+        errLine('No terminal detected: connecting every detected harness (same as tinyfish connect --all).');
+    }
     const exitCode = await runConnectAll({
         apiKey: options.apiKey,
         mcpUrl,
@@ -743,26 +797,6 @@ async function connectAllPath(options, mcpUrl, attemptId) {
         dryRun: options.dryRun ?? false,
         uninstall: options.uninstall ?? false,
         noLaunch: options.skipLaunch === true,
-        verbose: options.verbose ?? false,
-    });
-    // Preserve the 130 runGuarded set on Ctrl+C.
-    if (!process.exitCode)
-        process.exitCode = exitCode;
-}
-async function connectPickPath(options, mcpUrl, attemptId) {
-    if (options.launch) {
-        throw new Error('--launch is not supported with --all. Connect a single client to launch it.');
-    }
-    const humanInitiated = detectHumanInitiated();
-    if (!humanInitiated) {
-        errLine('No terminal detected: connecting every detected harness (same as tinyfish connect --all).');
-    }
-    const exitCode = await runConnectAll({
-        apiKey: options.apiKey,
-        mcpUrl,
-        attemptId,
-        dryRun: false,
-        uninstall: false,
         pick: humanInitiated,
         verbose: options.verbose ?? false,
     });
@@ -820,14 +854,14 @@ export function registerConnect(program) {
             if (client) {
                 throw new Error('Pass either a client or --all, not both.');
             }
-            await connectAllPath(options, mcpUrl, attemptId);
+            await connectManyPath(options, mcpUrl, attemptId);
             return;
         }
         if (options.dryRun || options.uninstall || options.skipLaunch) {
             throw new Error('--dry-run, --uninstall and --skip-launch are only supported with --all.');
         }
         if (!client) {
-            await connectPickPath(options, mcpUrl, attemptId);
+            await connectManyPath(options, mcpUrl, attemptId);
             return;
         }
         await connectSingleClient(client, options, mcpUrl, attemptId);

package/dist/commands/doctor.js

@@ -1,5 +1,5 @@
 import { CLI_VERSION } from '../lib/constants.js';
-import { checkAuthCall, checkCliVersion, checkConnectivity, checkCredential, checkHermesPlugin, checkRegistration, provesHarnessReach, verifyHarnessKey, } from '../lib/doctor-checks.js';
+import { checkAuthCall, checkCliVersion, checkConnectivity, checkCredential, checkHermesPlugin, checkPiAdapter, checkRegistration, provesHarnessReach, verifyHarnessKey, } from '../lib/doctor-checks.js';
 import { DOCTOR_COULD_NOT_RUN, DOCTOR_INVALID_INPUT, DOCTOR_SCHEMA_VERSION, doctorReportSchema, exitCodeFor, renderPretty, verdictFor, } from '../lib/doctor-report.js';
 import { applyRepairs, repairsFor } from '../lib/doctor-repairs.js';
 import { couldNotRunPayload, telemetryKey, telemetryPayload } from '../lib/doctor-telemetry.js';
@@ -30,11 +30,13 @@ export async function runDoctor(options) {
     ]);
     const hermesStatus = statuses.find((status) => status.harness === 'hermes');
     const hermesPlugin = hermesStatus ? checkHermesPlugin(hermesStatus) : undefined;
+    const piStatus = statuses.find((status) => status.harness === 'pi');
     const checks = [
         checkCliVersion(),
         connectivity,
         ...statuses.map((status, i) => checkRegistration(status, options.mcpUrl, keyAuths[i], !credential.key)),
         ...(hermesPlugin ? [hermesPlugin.check] : []),
+        ...(piStatus ? [checkPiAdapter(piStatus)] : []),
         credential.check,
         checkAuthCall(cliAuthResult),
     ];

package/dist/commands/profile.d.ts

@@ -1,8 +1,5 @@
 import { Command } from 'commander';
-import { type DecryptStats } from '../lib/chrome-cookies.js';
 import type { CookieRecord, ProfileUploadResponse } from '../lib/types.js';
-export declare function extractChromeCookies(domain: string, stats?: DecryptStats): CookieRecord[];
-export declare function extractAllChromeCookies(stats?: DecryptStats): CookieRecord[];
 type TldtsParse = (host: string, opts: {
     allowPrivateDomains: boolean;
 }) => {

package/dist/commands/profile.js

@@ -6,15 +6,6 @@ import { getApiKey } from '../lib/auth.js';
 import { deriveChromeKey, listAuthRelevantHostKeys, openCookiesDb, readCookiesForHost, } from '../lib/chrome-cookies.js';
 import { profileCreate, profileUpload } from '../lib/client.js';
 import { err, errLine, handleApiError, out, outLine } from '../lib/output.js';
-// ── UserFacingError ───────────────────────────────────────────────────────────
-// Thrown by helpers to signal a terminal error that should be printed and exit 1
-// without going through handleApiError (which would print a second error line).
-class UserFacingError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'UserFacingError';
-    }
-}
 // ── Helpers ───────────────────────────────────────────────────────────────────
 function getChromeCookiesPath() {
     const platform = process.platform;
@@ -36,11 +27,11 @@ function validateDomain(domain) {
 // Opens a private copy of Chrome's cookie DB, derives the decryption key, and calls fn.
 function withCookiesDb(fn) {
     if (process.platform === 'win32') {
-        throw new UserFacingError('Cookie extraction is not supported on Windows yet');
+        throw new Error('Cookie extraction is not supported on Windows yet');
     }
     const cookiesPath = getChromeCookiesPath();
     if (!fs.existsSync(cookiesPath)) {
-        throw new UserFacingError(`Chrome cookies file not found at ${cookiesPath}. Is Google Chrome installed?`);
+        throw new Error(`Chrome cookies file not found at ${cookiesPath}. Is Google Chrome installed?`);
     }
     // Copy the DB out of the profile directory so we avoid the Chrome file lock.
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tinyfish-chrome-cookies-'));
@@ -57,7 +48,7 @@ function withCookiesDb(fn) {
             db = openCookiesDb(dbPath);
         }
         catch (e) {
-            throw new UserFacingError(`Failed to read Chrome cookies database: ${e instanceof Error ? e.message : String(e)}`);
+            throw new Error(`Failed to read Chrome cookies database: ${e instanceof Error ? e.message : String(e)}`);
         }
         return fn(db, deriveChromeKey());
     }
@@ -76,19 +67,17 @@ function withCookiesDb(fn) {
         }
     }
 }
-// Exported for testing
-export function extractChromeCookies(domain, stats) {
+function extractChromeCookies(domain, stats) {
     return withCookiesDb((db, key) => readCookiesForHost(db, key, domain, stats));
 }
-// Exported for testing
-export function extractAllChromeCookies(stats) {
+function extractAllChromeCookies(stats) {
     return withCookiesDb((db, key) => {
         let hostKeys;
         try {
             hostKeys = listAuthRelevantHostKeys(db);
         }
         catch (e) {
-            throw new UserFacingError(`Failed to read Chrome cookies database: ${e instanceof Error ? e.message : String(e)}`);
+            throw new Error(`Failed to read Chrome cookies database: ${e instanceof Error ? e.message : String(e)}`);
         }
         // Canonicalize host_keys → registrable domains (mirrors frontend/app/lib/services/domain-utils.ts)
         const require = createRequire(import.meta.url);
@@ -181,7 +170,7 @@ function extractCookiesOrThrow(opts) {
         errLine(`Skipped ${stats.keyringSkipped} keyring-encrypted cookies (not supported on Linux yet).`);
     }
     if (cookies.length === 0) {
-        throw new UserFacingError(stats.keyringSkipped > 0
+        throw new Error(stats.keyringSkipped > 0
             ? 'Chrome on Linux encrypts cookies with the system keyring, which is not supported yet.'
             : opts.allDomains
                 ? 'No Chrome cookies found. Is Google Chrome installed and have you logged in to any sites?'
@@ -281,10 +270,6 @@ export function registerProfile(program) {
             }
         }
         catch (error) {
-            if (error instanceof UserFacingError) {
-                err({ error: error.message });
-                process.exit(1);
-            }
             handleApiError(error);
         }
     });

package/dist/commands/run.js

@@ -172,34 +172,26 @@ function buildAgentConfig(opts) {
     const cursorStyle = parseChoice(opts.cursorStyle, VALID_CURSOR_STYLES, '--cursor-style');
     const maxSteps = parsePositiveInteger(opts.maxSteps, '--max-steps', MAX_STEPS_LIMIT);
     const maxDurationSeconds = parsePositiveInteger(opts.maxDurationSeconds, '--max-duration-seconds');
-    if (mode === undefined &&
-        cursorStyle === undefined &&
-        maxSteps === undefined &&
-        maxDurationSeconds === undefined) {
-        return undefined;
-    }
-    return {
-        ...(mode !== undefined ? { mode } : {}),
-        ...(cursorStyle !== undefined ? { cursor_style: cursorStyle } : {}),
-        ...(maxSteps !== undefined ? { max_steps: maxSteps } : {}),
-        ...(maxDurationSeconds !== undefined ? { max_duration_seconds: maxDurationSeconds } : {}),
-    };
+    return compact({
+        mode,
+        cursor_style: cursorStyle,
+        max_steps: maxSteps,
+        max_duration_seconds: maxDurationSeconds,
+    });
+}
+/** Drops undefined fields; undefined when nothing is left. */
+function compact(obj) {
+    const kept = Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+    return Object.keys(kept).length ? kept : undefined;
 }
 function buildCaptureConfig(opts) {
-    if (opts.captureElements === undefined &&
-        opts.captureSnapshots === undefined &&
-        opts.captureScreenshots === undefined &&
-        opts.captureRecording === undefined &&
-        opts.captureHtml === undefined) {
-        return undefined;
-    }
-    return {
-        ...(opts.captureElements !== undefined ? { elements: opts.captureElements } : {}),
-        ...(opts.captureSnapshots !== undefined ? { snapshots: opts.captureSnapshots } : {}),
-        ...(opts.captureScreenshots !== undefined ? { screenshots: opts.captureScreenshots } : {}),
-        ...(opts.captureRecording !== undefined ? { recording: opts.captureRecording } : {}),
-        ...(opts.captureHtml !== undefined ? { html: opts.captureHtml } : {}),
-    };
+    return compact({
+        elements: opts.captureElements,
+        snapshots: opts.captureSnapshots,
+        screenshots: opts.captureScreenshots,
+        recording: opts.captureRecording,
+        html: opts.captureHtml,
+    });
 }
 async function buildRunRequest(goal, normalizedUrl, opts) {
     const outputSchema = await loadOutputSchema(opts);
@@ -224,13 +216,7 @@ async function buildRunRequest(goal, normalizedUrl, opts) {
     };
 }
 async function runAsyncPath(req, apiKey, pretty) {
-    let result;
-    try {
-        result = await runAsync(req, apiKey);
-    }
-    catch (e) {
-        handleApiError(e);
-    }
+    const result = await runAsync(req, apiKey).catch(handleApiError);
     checkRunResult(result, false); // async = PENDING is expected
     const asyncResultWithUrl = {
         ...result,
@@ -246,13 +232,7 @@ async function runAsyncPath(req, apiKey, pretty) {
 }
 async function runSyncPath(req, apiKey, pretty) {
     errLine('Waiting for result...');
-    let result;
-    try {
-        result = await runSync(req, apiKey);
-    }
-    catch (e) {
-        handleApiError(e);
-    }
+    const result = await runSync(req, apiKey).catch(handleApiError);
     checkRunResult(result);
     const syncResultWithUrl = {
         ...result,