@jackwener/opencli 1.7.18 → 1.7.20

package/dist/src/cli.test.js

@@ -168,6 +168,7 @@ describe('createProgram root help descriptions', () => {
             expect(data.site_adapters.sites).toEqual(['bilibili']);
             expect(data.external_clis.count).toBeGreaterThanOrEqual(0);
             expect(Array.isArray(data.external_clis.clis)).toBe(true);
+            expect(Array.isArray(data.external_clis.display)).toBe(true);
             // Adapters must NOT leak into the core commands list
             const commandNames = data.commands.map((cmd) => cmd.name);
             expect(commandNames).not.toContain('bilibili');
@@ -349,20 +350,20 @@ describe('createProgram root help descriptions', () => {
             expect(data.command).toBe('opencli browser');
             expect(data.description).toBe('Browser control — navigate, click, type, extract, wait (no LLM needed)');
             expect(data.command_count).toBeGreaterThan(20);
+            // `--session` is now a hidden internal option; user-facing surface is the
+            // <session> positional declared via `.usage()`. Structured help drops
+            // hidden options, so namespace_options shouldn't expose it.
+            expect(data.namespace_options).not.toEqual(expect.arrayContaining([
+                expect.objectContaining({ name: 'session' }),
+            ]));
             expect(data.namespace_options).toEqual(expect.arrayContaining([
-                expect.objectContaining({
-                    name: 'session',
-                    flags: '--session <name>',
-                    takes_value: 'required',
-                    required: true,
-                    help: expect.stringContaining('required'),
-                }),
                 expect.objectContaining({
                     name: 'window',
                     flags: '--window <mode>',
                     takes_value: 'required',
                 }),
             ]));
+            expect(data.usage).toBe('opencli browser <session> <command> [options]');
             expect(data.global_options).toEqual(expect.arrayContaining([
                 expect.objectContaining({
                     name: 'version',
@@ -375,21 +376,24 @@ describe('createProgram root help descriptions', () => {
                 }),
             ]));
             const click = data.commands.find((cmd) => cmd.name === 'click');
+            // Structured help command/usage paths include the <session> positional so
+            // agents construct the correct full invocation. `name` is the leaf
+            // identifier (placeholder positionals are stripped).
             expect(click).toMatchObject({
-                command: 'opencli browser click',
-                usage: 'opencli browser click [target] [options]',
+                command: 'opencli browser <session> click',
+                usage: 'opencli browser <session> click [target] [options]',
                 positionals: [{ name: 'target' }],
             });
             expect(click.command_options.map((option) => option.name)).toEqual(['role', 'name', 'label', 'text', 'testid', 'nth', 'tab']);
             const tabList = data.commands.find((cmd) => cmd.name === 'tab list');
             expect(tabList).toMatchObject({
-                command: 'opencli browser tab list',
-                usage: 'opencli browser tab list [options]',
+                command: 'opencli browser <session> tab list',
+                usage: 'opencli browser <session> tab list [options]',
                 command_options: [],
             });
             const getText = data.commands.find((cmd) => cmd.name === 'get text');
             expect(getText).toMatchObject({
-                command: 'opencli browser get text',
+                command: 'opencli browser <session> get text',
                 positionals: [{ name: 'target' }],
             });
             expect(data.structured_help).toMatchObject({
@@ -413,8 +417,8 @@ describe('createProgram root help descriptions', () => {
             expect(data).toMatchObject({
                 namespace: 'browser',
                 group: 'tab',
-                command: 'opencli browser tab',
-                usage: 'opencli browser tab <command> [args] [options]',
+                command: 'opencli browser <session> tab',
+                usage: 'opencli browser <session> tab <command> [args] [options]',
                 command_count: 4,
             });
             expect(data.commands.map((cmd) => cmd.name)).toEqual([
@@ -424,13 +428,15 @@ describe('createProgram root help descriptions', () => {
                 'tab select',
             ]);
             expect(data.commands.find((cmd) => cmd.name === 'tab close')).toMatchObject({
-                command: 'opencli browser tab close',
-                usage: 'opencli browser tab close [targetId] [options]',
+                command: 'opencli browser <session> tab close',
+                usage: 'opencli browser <session> tab close [targetId] [options]',
                 positionals: [{ name: 'targetId', help: 'Target tab/page identity returned by "browser open", "browser tab new", or "browser tab list"' }],
             });
-            expect(data.namespace_options.map((option) => option.name)).toEqual(['session', 'window']);
+            // session is now a hidden internal option (consumed from the <session> positional).
+            // namespace_options should only list user-facing options.
+            expect(data.namespace_options.map((option) => option.name)).toEqual(['window']);
             expect(data.structured_help).toMatchObject({
-                usage: 'opencli browser tab --help -f yaml',
+                usage: 'opencli browser <session> tab --help -f yaml',
             });
         }
         finally {
@@ -449,15 +455,16 @@ describe('createProgram root help descriptions', () => {
             expect(data).toMatchObject({
                 namespace: 'browser',
                 name: 'click',
-                command: 'opencli browser click',
-                usage: 'opencli browser click [target] [options]',
+                command: 'opencli browser <session> click',
+                usage: 'opencli browser <session> click [target] [options]',
                 positionals: [{ name: 'target' }],
                 structured_help: {
-                    usage: 'opencli browser click --help -f yaml',
+                    usage: 'opencli browser <session> click --help -f yaml',
                 },
             });
             expect(data.command_options.map((option) => option.name)).toEqual(['role', 'name', 'label', 'text', 'testid', 'nth', 'tab']);
-            expect(data.namespace_options.map((option) => option.name)).toEqual(['session', 'window']);
+            // session is hidden; only `window` surfaces as a namespace option.
+            expect(data.namespace_options.map((option) => option.name)).toEqual(['window']);
             expect(data.global_options.map((option) => option.name)).toContain('profile');
         }
         finally {
@@ -898,13 +905,12 @@ describe('browser tab targeting commands', () => {
     });
     it('requires an explicit session for browser commands', async () => {
         const program = createProgram('', '');
-        program.exitOverride((err) => { throw err; });
-        program.commands.find(cmd => cmd.name() === 'browser')?.exitOverride((err) => { throw err; });
-        await expect(program.parseAsync(['node', 'opencli', 'browser', 'state'])).rejects.toMatchObject({
-            code: 'commander.missingMandatoryOptionValue',
-        });
+        // --session is now a hidden internal flag; commander no longer guards it.
+        // The action body throws via getBrowserSession(), surfacing the
+        // <session> positional in the error message.
+        await program.parseAsync(['node', 'opencli', 'browser', 'state']);
         expect(mockBrowserConnect).not.toHaveBeenCalled();
-        expect(stderrSpy.mock.calls.flat().join('')).toContain("required option '--session <name>' not specified");
+        expect(stderrSpy.mock.calls.flat().join('')).toContain('<session> is a required positional argument');
     });
     it('runs browser commands against an explicit session', async () => {
         const program = createProgram('', '');

package/dist/src/commands/daemon.js

@@ -4,7 +4,6 @@
  *   opencli daemon stop   — graceful shutdown
  *   opencli daemon restart — graceful shutdown, then start a fresh daemon
  */
-import { styleText } from 'node:util';
 import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
 import { restartDaemon } from '../browser/daemon-lifecycle.js';
 import { formatDuration } from '../download/progress.js';
@@ -14,18 +13,18 @@ import { formatDaemonVersion, isDaemonStale } from '../browser/daemon-version.js
 export async function daemonStatus() {
     const status = await fetchDaemonStatus();
     if (!status) {
-        console.log(`Daemon: ${styleText('dim', 'not running')}`);
+        console.log('Daemon: not running');
         return;
     }
     const extensionLabel = !status.extensionConnected
-        ? styleText('yellow', 'disconnected')
+        ? 'disconnected'
         : status.extensionVersion
-            ? `${styleText('green', 'connected')} ${styleText('dim', `(v${status.extensionVersion})`)}`
-            : `${styleText('yellow', 'connected')} ${styleText('dim', '(version unknown)')}`;
+            ? `connected (v${status.extensionVersion})`
+            : 'connected (version unknown)';
     const daemonVersion = formatDaemonVersion(status);
     const stale = isDaemonStale(status, PKG_VERSION);
-    console.log(`Daemon: ${stale ? styleText('yellow', 'stale') : styleText('green', 'running')} (PID ${status.pid})`);
-    console.log(`Version: ${daemonVersion}${stale ? styleText('yellow', ` (CLI v${PKG_VERSION}; run: opencli daemon restart)`) : ''}`);
+    console.log(`Daemon: ${stale ? 'stale' : 'running'} (PID ${status.pid})`);
+    console.log(`Version: ${daemonVersion}${stale ? ` (CLI v${PKG_VERSION}; run: opencli daemon restart)` : ''}`);
     console.log(`Uptime: ${formatDuration(Math.round(status.uptime * 1000))}`);
     console.log(`Extension: ${extensionLabel}`);
     if (status.profiles && status.profiles.length > 0) {

package/dist/src/daemon-utils.d.ts

@@ -0,0 +1,18 @@
+export declare const COMMAND_RESULT_UNKNOWN_CODE = "command_result_unknown";
+export declare const COMMAND_RESULT_UNKNOWN_HINT = "Inspect the browser/session state before retrying. Do not blindly retry write commands such as navigate, click, type, or eval.";
+export declare const PROFILE_DISCONNECTED_HINT = "Open that Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.";
+export type DaemonFailureContract = {
+    message: string;
+    errorCode: string;
+    errorHint: string;
+    status: number;
+    countAsCommandResultUnknown: boolean;
+};
+export declare function commandResultUnknownMessage(action: string): string;
+export declare function buildExtensionDisconnectFailure(input: {
+    contextId: string;
+    action: string;
+    dispatched: boolean;
+}): DaemonFailureContract;
+export declare function buildCommandDispatchFailure(contextId: string): DaemonFailureContract;
+export declare function getResponseCorsHeaders(pathname: string, origin?: string): Record<string, string> | undefined;

package/dist/src/daemon-utils.js

@@ -0,0 +1,37 @@
+export const COMMAND_RESULT_UNKNOWN_CODE = 'command_result_unknown';
+export const COMMAND_RESULT_UNKNOWN_HINT = 'Inspect the browser/session state before retrying. Do not blindly retry write commands such as navigate, click, type, or eval.';
+export const PROFILE_DISCONNECTED_HINT = 'Open that Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.';
+export function commandResultUnknownMessage(action) {
+    return `Browser connection dropped after the ${action} command was dispatched; it may have completed.`;
+}
+export function buildExtensionDisconnectFailure(input) {
+    if (input.dispatched) {
+        return {
+            message: commandResultUnknownMessage(input.action),
+            errorCode: COMMAND_RESULT_UNKNOWN_CODE,
+            errorHint: COMMAND_RESULT_UNKNOWN_HINT,
+            status: 503,
+            countAsCommandResultUnknown: true,
+        };
+    }
+    return buildCommandDispatchFailure(input.contextId);
+}
+export function buildCommandDispatchFailure(contextId) {
+    return {
+        message: `Browser profile "${contextId}" disconnected before command dispatch`,
+        errorCode: 'profile_disconnected',
+        errorHint: PROFILE_DISCONNECTED_HINT,
+        status: 503,
+        countAsCommandResultUnknown: false,
+    };
+}
+export function getResponseCorsHeaders(pathname, origin) {
+    if (pathname !== '/ping')
+        return undefined;
+    if (!origin || !origin.startsWith('chrome-extension://'))
+        return undefined;
+    return {
+        'Access-Control-Allow-Origin': origin,
+        Vary: 'Origin',
+    };
+}

package/dist/src/daemon.d.ts

@@ -19,4 +19,4 @@
  *   - Persistent — stays alive until explicit shutdown, SIGTERM, or uninstall
  *   - Listens on localhost:19825
  */
-export declare function getResponseCorsHeaders(pathname: string, origin?: string): Record<string, string> | undefined;
+export {};

package/dist/src/daemon.js

@@ -27,9 +27,11 @@ import { log } from './logger.js';
 import { PKG_VERSION } from './version.js';
 import { DEFAULT_CONTEXT_ID } from './browser/profile.js';
 import { recordExtensionVersion } from './update-check.js';
+import { buildCommandDispatchFailure, buildExtensionDisconnectFailure, getResponseCorsHeaders, } from './daemon-utils.js';
 const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const extensionProfiles = new Map();
 const pending = new Map();
+let commandResultUnknownCount = 0;
 const LOG_BUFFER_SIZE = 200;
 const logBuffer = [];
 class DaemonCommandFailure extends Error {
@@ -110,7 +112,16 @@ function unregisterExtensionConnection(ws) {
             if (p.contextId !== contextId)
                 continue;
             clearTimeout(p.timer);
-            p.reject(new DaemonCommandFailure(`Browser profile "${contextId}" disconnected`, 'profile_disconnected', 'Open that Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.', 503));
+            const failure = buildExtensionDisconnectFailure({
+                contextId,
+                action: p.action,
+                dispatched: p.dispatched,
+            });
+            if (failure.countAsCommandResultUnknown) {
+                commandResultUnknownCount++;
+                log.warn(`[daemon] Command result unknown after extension disconnect (id=${id}, action=${p.action}, context=${contextId})`);
+            }
+            p.reject(new DaemonCommandFailure(failure.message, failure.errorCode, failure.errorHint, failure.status));
             pending.delete(id);
         }
     }
@@ -142,16 +153,6 @@ function jsonResponse(res, status, data, extraHeaders) {
     res.writeHead(status, { 'Content-Type': 'application/json', ...extraHeaders });
     res.end(JSON.stringify(data));
 }
-export function getResponseCorsHeaders(pathname, origin) {
-    if (pathname !== '/ping')
-        return undefined;
-    if (!origin || !origin.startsWith('chrome-extension://'))
-        return undefined;
-    return {
-        'Access-Control-Allow-Origin': origin,
-        Vary: 'Origin',
-    };
-}
 async function handleRequest(req, res) {
     // ─── Security: Origin & custom-header check ──────────────────────
     // Block browser-based CSRF: browsers always send an Origin header on
@@ -219,6 +220,7 @@ async function handleRequest(req, res) {
             profileDisconnected: route.errorCode === 'profile_disconnected',
             profiles,
             pending: pending.size,
+            commandResultUnknown: commandResultUnknownCount,
             memoryMB: Math.round(mem.rss / 1024 / 1024 * 10) / 10,
             port: PORT,
         });
@@ -277,8 +279,37 @@ async function handleRequest(req, res) {
                     pending.delete(body.id);
                     reject(new Error(`Command timeout (${timeoutMs / 1000}s)`));
                 }, timeoutMs);
-                pending.set(body.id, { contextId: route.connection.contextId, resolve, reject, timer });
-                route.connection.ws.send(JSON.stringify(body));
+                const entry = {
+                    contextId: route.connection.contextId,
+                    action: typeof body.action === 'string' ? body.action : 'unknown',
+                    dispatched: false,
+                    resolve,
+                    reject,
+                    timer,
+                };
+                pending.set(body.id, entry);
+                const failBeforeDispatch = (err) => {
+                    if (pending.get(body.id) !== entry)
+                        return;
+                    const failure = buildCommandDispatchFailure(entry.contextId);
+                    clearTimeout(timer);
+                    pending.delete(body.id);
+                    reject(new DaemonCommandFailure(failure.message, failure.errorCode, failure.errorHint, failure.status));
+                    log.warn(`[daemon] Failed to dispatch command ${body.id}: ${err instanceof Error ? err.message : String(err)}`);
+                };
+                try {
+                    route.connection.ws.send(JSON.stringify(body), (err) => {
+                        if (err && !entry.dispatched)
+                            failBeforeDispatch(err);
+                    });
+                    // Once ws accepts the frame, the command may execute even if the
+                    // result is later lost; do not downgrade later disconnects to a
+                    // pre-dispatch failure just because no result/ack has arrived yet.
+                    entry.dispatched = true;
+                }
+                catch (err) {
+                    failBeforeDispatch(err);
+                }
             });
             jsonResponse(res, 200, result);
         }

package/dist/src/daemon.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { getResponseCorsHeaders } from './daemon.js';
+import { COMMAND_RESULT_UNKNOWN_CODE, COMMAND_RESULT_UNKNOWN_HINT, buildCommandDispatchFailure, buildExtensionDisconnectFailure, commandResultUnknownMessage, getResponseCorsHeaders, } from './daemon-utils.js';
 describe('getResponseCorsHeaders', () => {
     it('allows the Browser Bridge extension origin to read /ping', () => {
         expect(getResponseCorsHeaders('/ping', 'chrome-extension://abc123')).toEqual({
@@ -17,3 +17,44 @@ describe('getResponseCorsHeaders', () => {
         expect(getResponseCorsHeaders('/command', 'chrome-extension://abc123')).toBeUndefined();
     });
 });
+describe('daemon command dispatch', () => {
+    it('uses a distinct command_result_unknown contract for ambiguous dispatched commands', () => {
+        expect(COMMAND_RESULT_UNKNOWN_CODE).toBe('command_result_unknown');
+        expect(commandResultUnknownMessage('navigate')).toContain('navigate command was dispatched');
+        expect(COMMAND_RESULT_UNKNOWN_HINT).toContain('Inspect the browser/session state');
+        expect(COMMAND_RESULT_UNKNOWN_HINT).toContain('Do not blindly retry write commands');
+    });
+    it('classifies dispatched extension disconnects as command_result_unknown', () => {
+        expect(buildExtensionDisconnectFailure({
+            contextId: 'work',
+            action: 'navigate',
+            dispatched: true,
+        })).toEqual({
+            message: 'Browser connection dropped after the navigate command was dispatched; it may have completed.',
+            errorCode: 'command_result_unknown',
+            errorHint: COMMAND_RESULT_UNKNOWN_HINT,
+            status: 503,
+            countAsCommandResultUnknown: true,
+        });
+    });
+    it('classifies pre-dispatch extension disconnects as profile_disconnected', () => {
+        expect(buildExtensionDisconnectFailure({
+            contextId: 'work',
+            action: 'navigate',
+            dispatched: false,
+        })).toMatchObject({
+            message: 'Browser profile "work" disconnected before command dispatch',
+            errorCode: 'profile_disconnected',
+            status: 503,
+            countAsCommandResultUnknown: false,
+        });
+    });
+    it('classifies ws.send dispatch failures as profile_disconnected', () => {
+        expect(buildCommandDispatchFailure('work')).toMatchObject({
+            message: 'Browser profile "work" disconnected before command dispatch',
+            errorCode: 'profile_disconnected',
+            status: 503,
+            countAsCommandResultUnknown: false,
+        });
+    });
+});

package/dist/src/doctor.js

@@ -3,7 +3,6 @@
  *
  * Simplified for the daemon-based architecture.
  */
-import { styleText } from 'node:util';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { BrowserBridge } from './browser/index.js';
 import { getDaemonHealth } from './browser/daemon-client.js';
@@ -168,13 +167,13 @@ export async function runBrowserDoctor(opts = {}) {
     };
 }
 export function renderBrowserDoctorReport(report) {
-    const lines = [styleText('bold', `opencli v${report.cliVersion ?? 'unknown'} doctor`) + styleText('dim', ` (${getRuntimeLabel()})`), ''];
+    const lines = [`opencli v${report.cliVersion ?? 'unknown'} doctor` + ` (${getRuntimeLabel()})`, ''];
     // Daemon status
     const daemonIcon = report.daemonFlaky
-        ? styleText('yellow', '[WARN]')
+        ? '[WARN]'
         : report.daemonStale
-            ? styleText('yellow', '[WARN]')
-            : report.daemonRunning ? styleText('green', '[OK]') : styleText('red', '[MISSING]');
+            ? '[WARN]'
+            : report.daemonRunning ? '[OK]' : '[MISSING]';
     const daemonLabel = report.daemonFlaky
         ? 'unstable (running during live check, then stopped)'
         : report.daemonRunning
@@ -185,47 +184,47 @@ export function renderBrowserDoctorReport(report) {
     lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
     // Extension status
     const extIcon = report.extensionFlaky || (report.extensionConnected && !report.extensionVersion)
-        ? styleText('yellow', '[WARN]')
-        : report.extensionConnected ? styleText('green', '[OK]') : styleText('yellow', '[MISSING]');
+        ? '[WARN]'
+        : report.extensionConnected ? '[OK]' : '[MISSING]';
     const extUpdateHint = report.extensionVersion && report.latestExtensionVersion && isNewerVersion(report.latestExtensionVersion, report.extensionVersion)
-        ? styleText('yellow', ` → v${report.latestExtensionVersion} available`)
+        ? ` → v${report.latestExtensionVersion} available`
         : '';
     const extVersion = !report.extensionConnected
         ? ''
         : report.extensionVersion
-            ? styleText('dim', ` (v${report.extensionVersion})`) + extUpdateHint
-            : styleText('dim', ' (version unknown)');
+            ? ` (v${report.extensionVersion})` + extUpdateHint
+            : ' (version unknown)';
     const extLabel = report.extensionFlaky
         ? 'unstable (connected during live check, then disconnected)'
         : report.extensionConnected ? 'connected' : 'not connected';
     lines.push(`${extIcon} Extension: ${extLabel}${extVersion}`);
     if (report.profiles && report.profiles.length > 0) {
         const config = loadProfileConfig();
-        lines.push('', styleText('bold', 'Profiles:'));
+        lines.push('', 'Profiles:');
         for (const profile of report.profiles) {
             const alias = aliasForContextId(config, profile.contextId);
             const aliasText = alias ? ` (${alias})` : '';
             const defaultText = config.defaultContextId === profile.contextId ? ', default' : '';
             const version = profile.extensionVersion ? `v${profile.extensionVersion}` : 'version unknown';
-            lines.push(styleText('dim', `  • ${profile.contextId}${aliasText}: connected ${version}${defaultText}`));
+            lines.push(`  • ${profile.contextId}${aliasText}: connected ${version}${defaultText}`);
         }
     }
     // Connectivity
     if (report.connectivity) {
-        const connIcon = report.connectivity.ok ? styleText('green', '[OK]') : styleText('red', '[FAIL]');
+        const connIcon = report.connectivity.ok ? '[OK]' : '[FAIL]';
         const detail = report.connectivity.ok
             ? `connected in ${(report.connectivity.durationMs / 1000).toFixed(1)}s`
             : `failed (${report.connectivity.error ?? 'unknown'})`;
         lines.push(`${connIcon} Connectivity: ${detail}`);
     }
     if (report.issues.length) {
-        lines.push('', styleText('yellow', 'Issues:'));
+        lines.push('', 'Issues:');
         for (const issue of report.issues) {
-            lines.push(styleText('dim', `  • ${issue}`));
+            lines.push(`  • ${issue}`);
         }
     }
     else if (report.daemonRunning && report.extensionConnected) {
-        lines.push('', styleText('green', 'Everything looks good!'));
+        lines.push('', 'Everything looks good!');
     }
     return lines.join('\n');
 }

package/dist/src/download/progress.js

@@ -1,7 +1,6 @@
 /**
  * Download progress display: terminal progress bars, status updates.
  */
-import { styleText } from 'node:util';
 /**
  * Format bytes as human-readable string (KB, MB, GB).
  */
@@ -35,33 +34,38 @@ export function formatDuration(ms) {
  * Create a simple progress bar for terminal display.
  */
 export function createProgressBar(filename, index, total) {
-    const prefix = styleText('dim', `[${index + 1}/${total}]`);
+    const prefix = `[${index + 1}/${total}]`;
     const truncatedName = filename.length > 40 ? filename.slice(0, 37) + '...' : filename;
     return {
         update(current, totalBytes, label) {
-            const percent = totalBytes > 0 ? Math.round((current / totalBytes) * 100) : 0;
+            const percent = clampPercent(totalBytes > 0 ? Math.round((current / totalBytes) * 100) : 0);
             const bar = createBar(percent);
             const size = totalBytes > 0 ? formatBytes(totalBytes) : '';
             const extra = label ? ` ${label}` : '';
             process.stderr.write(`\r${prefix} ${truncatedName} ${bar} ${percent}% ${size}${extra}`);
         },
         complete(success, message) {
-            const icon = success ? styleText('green', '✓') : styleText('red', '✗');
-            const msg = message ? ` ${styleText('dim', message)}` : '';
+            const icon = success ? '✓' : '✗';
+            const msg = message ? ` ${message}` : '';
             process.stderr.write(`\r${prefix} ${icon} ${truncatedName}${msg}\n`);
         },
         fail(error) {
-            process.stderr.write(`\r${prefix} ${styleText('red', '✗')} ${truncatedName} ${styleText('red', error)}\n`);
+            process.stderr.write(`\r${prefix} ✗ ${truncatedName} ${error}\n`);
         },
     };
 }
+function clampPercent(percent) {
+    if (!Number.isFinite(percent))
+        return 0;
+    return Math.max(0, Math.min(100, percent));
+}
 /**
  * Create a progress bar string.
  */
 function createBar(percent, width = 20) {
     const filled = Math.round((percent / 100) * width);
     const empty = width - filled;
-    return styleText('cyan', '█'.repeat(filled)) + styleText('dim', '░'.repeat(empty));
+    return '█'.repeat(filled) + '░'.repeat(empty);
 }
 /**
  * Multi-file download progress tracker.
@@ -98,19 +102,19 @@ export class DownloadProgressTracker {
         const elapsed = formatDuration(Date.now() - this.startTime);
         const parts = [];
         if (this.completed > 0) {
-            parts.push(styleText('green', `${this.completed} downloaded`));
+            parts.push(`${this.completed} downloaded`);
         }
         if (this.skipped > 0) {
-            parts.push(styleText('yellow', `${this.skipped} skipped`));
+            parts.push(`${this.skipped} skipped`);
         }
         if (this.failed > 0) {
-            parts.push(styleText('red', `${this.failed} failed`));
+            parts.push(`${this.failed} failed`);
         }
         return `${parts.join(', ')} in ${elapsed}`;
     }
     finish() {
         if (this.verbose) {
-            process.stderr.write(`\n${styleText('bold', 'Download complete:')} ${this.getSummary()}\n`);
+            process.stderr.write(`\nDownload complete: ${this.getSummary()}\n`);
         }
     }
 }

package/dist/src/download/progress.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/download/progress.test.js

@@ -0,0 +1,25 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createProgressBar } from './progress.js';
+describe('download progress display', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('clamps percentages above 100 to keep the progress bar renderable', () => {
+        const write = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const progress = createProgressBar('file.bin', 0, 1);
+        expect(() => progress.update(150, 100)).not.toThrow();
+        expect(write).toHaveBeenCalledWith(expect.stringContaining('100%'));
+    });
+    it('clamps negative percentages to zero', () => {
+        const write = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const progress = createProgressBar('file.bin', 0, 1);
+        expect(() => progress.update(-10, 100)).not.toThrow();
+        expect(write).toHaveBeenCalledWith(expect.stringContaining('0%'));
+    });
+    it('renders zero percent when the total size is unknown', () => {
+        const write = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const progress = createProgressBar('file.bin', 0, 1);
+        expect(() => progress.update(50, 0)).not.toThrow();
+        expect(write).toHaveBeenCalledWith(expect.stringContaining('0%'));
+    });
+});

package/dist/src/electron-apps.js

@@ -12,7 +12,6 @@ export const builtinApps = {
     cursor: { port: 9226, processName: 'Cursor', bundleId: 'com.todesktop.runtime.Cursor', displayName: 'Cursor' },
     codex: { port: 9222, processName: 'Codex', bundleId: 'com.openai.codex', displayName: 'Codex' },
     chatwise: { port: 9228, processName: 'ChatWise', bundleId: 'com.chatwise.app', displayName: 'ChatWise' },
-    notion: { port: 9230, processName: 'Notion', bundleId: 'notion.id', displayName: 'Notion' },
     'discord-app': { port: 9232, processName: 'Discord', bundleId: 'com.discord.app', displayName: 'Discord' },
     'doubao-app': { port: 9225, processName: 'Doubao', bundleId: 'com.volcengine.doubao', displayName: 'Doubao' },
     antigravity: {

package/dist/src/electron-apps.test.js

@@ -23,6 +23,7 @@ describe('electron-apps registry', () => {
     });
     it('isElectronApp returns false for non-Electron sites', () => {
         expect(isElectronApp('bilibili')).toBe(false);
+        expect(isElectronApp('notion')).toBe(false);
         expect(isElectronApp('unknown-app')).toBe(false);
     });
     it('loadApps merges user config additively', () => {

package/dist/src/execution.js

@@ -467,9 +467,7 @@ function normalizeBooleanOption(name, raw) {
 function resolveKeepTab(siteSession, rawOption) {
     if (siteSession === 'persistent')
         return true;
-    return normalizeBooleanOption('--keep-tab', rawOption)
-        ?? normalizeBooleanOption('OPENCLI_KEEP_TAB', process.env.OPENCLI_KEEP_TAB)
-        ?? false;
+    return normalizeBooleanOption('--keep-tab', rawOption) ?? false;
 }
 function normalizeWindowMode(name, raw) {
     if (raw === undefined || raw === '')