@jackwener/opencli 1.4.1 → 1.5.1

package/dist/commanderAdapter.js

@@ -14,14 +14,30 @@ import { fullName, getRegistry } from './registry.js';
 import { formatRegistryHelpText } from './serialization.js';
 import { render as renderOutput } from './output.js';
 import { executeCommand } from './execution.js';
-import { CliError, ERROR_ICONS, getErrorMessage } from './errors.js';
+import { CliError, ERROR_ICONS, getErrorMessage, BrowserConnectError, AuthRequiredError, TimeoutError, SelectorError, EmptyResultError, ArgumentError, AdapterLoadError, CommandExecutionError, } from './errors.js';
+import { checkDaemonStatus } from './browser/discover.js';
+export function normalizeArgValue(argType, value, name) {
+    if (argType !== 'bool')
+        return value;
+    if (typeof value === 'boolean')
+        return value;
+    if (value == null || value === '')
+        return false;
+    const normalized = String(value).trim().toLowerCase();
+    if (normalized === 'true')
+        return true;
+    if (normalized === 'false')
+        return false;
+    throw new CliError('ARGUMENT', `"${name}" must be either "true" or "false".`);
+}
 /**
  * Register a single CliCommand as a Commander subcommand.
  */
 export function registerCommandToProgram(siteCmd, cmd) {
     if (siteCmd.commands.some((c) => c.name() === cmd.name))
         return;
-    const subCmd = siteCmd.command(cmd.name).description(cmd.description);
+    const deprecatedSuffix = cmd.deprecated ? ' [deprecated]' : '';
+    const subCmd = siteCmd.command(cmd.name).description(`${cmd.description}${deprecatedSuffix}`);
     // Register positional args first, then named options
     const positionalArgs = [];
     for (const arg of cmd.args) {
@@ -48,27 +64,32 @@ export function registerCommandToProgram(siteCmd, cmd) {
         const actionOpts = actionArgs[positionalArgs.length] ?? {};
         const optionsRecord = typeof actionOpts === 'object' && actionOpts !== null ? actionOpts : {};
         const startTime = Date.now();
-        // ── Collect kwargs ──────────────────────────────────────────────────
-        const kwargs = {};
-        for (let i = 0; i < positionalArgs.length; i++) {
-            const v = actionArgs[i];
-            if (v !== undefined)
-                kwargs[positionalArgs[i].name] = v;
-        }
-        for (const arg of cmd.args) {
-            if (arg.positional)
-                continue;
-            const camelName = arg.name.replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
-            const v = optionsRecord[arg.name] ?? optionsRecord[camelName];
-            if (v !== undefined)
-                kwargs[arg.name] = v;
-        }
         // ── Execute + render ────────────────────────────────────────────────
         try {
+            // ── Collect kwargs ────────────────────────────────────────────────
+            const kwargs = {};
+            for (let i = 0; i < positionalArgs.length; i++) {
+                const v = actionArgs[i];
+                if (v !== undefined)
+                    kwargs[positionalArgs[i].name] = v;
+            }
+            for (const arg of cmd.args) {
+                if (arg.positional)
+                    continue;
+                const camelName = arg.name.replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
+                const v = optionsRecord[arg.name] ?? optionsRecord[camelName];
+                if (v !== undefined)
+                    kwargs[arg.name] = normalizeArgValue(arg.type, v, arg.name);
+            }
             const verbose = optionsRecord.verbose === true;
             const format = typeof optionsRecord.format === 'string' ? optionsRecord.format : 'table';
             if (verbose)
                 process.env.OPENCLI_VERBOSE = '1';
+            if (cmd.deprecated) {
+                const message = typeof cmd.deprecated === 'string' ? cmd.deprecated : `${fullName(cmd)} is deprecated.`;
+                const replacement = cmd.replacedBy ? ` Use ${cmd.replacedBy} instead.` : '';
+                console.error(chalk.yellow(`Deprecated: ${message}${replacement}`));
+            }
             const result = await executeCommand(cmd, kwargs, verbose);
             if (verbose && (!result || (Array.isArray(result) && result.length === 0))) {
                 console.error(chalk.yellow('[Verbose] Warning: Command returned an empty result.'));
@@ -84,22 +105,148 @@ export function registerCommandToProgram(siteCmd, cmd) {
             });
         }
         catch (err) {
-            if (err instanceof CliError) {
-                const icon = ERROR_ICONS[err.code] ?? '⚠️';
-                console.error(chalk.red(`${icon} ${err.message}`));
-                if (err.hint)
-                    console.error(chalk.yellow(`→ ${err.hint}`));
-            }
-            else if (optionsRecord.verbose === true && err instanceof Error && err.stack) {
-                console.error(chalk.red(err.stack));
-            }
-            else {
-                console.error(chalk.red(`Error: ${getErrorMessage(err)}`));
-            }
+            await renderError(err, fullName(cmd), optionsRecord.verbose === true);
             process.exitCode = 1;
         }
     });
 }
+// ── Error rendering ──────────────────────────────────────────────────────────
+const ISSUES_URL = 'https://github.com/jackwener/opencli/issues';
+/** Pattern-based classifier for untyped errors thrown by adapters. */
+function classifyGenericError(msg) {
+    const m = msg.toLowerCase();
+    if (/not logged in|login required|please log in|未登录|请先登录|authentication required|cookie expired/.test(m))
+        return 'auth';
+    // Match "HTTP 404", "status: 500", "status 403", bare "404 Not Found", etc.
+    if (/\b(status[: ]+)?[45]\d{2}\b|http[/ ][45]\d{2}/.test(m))
+        return 'http';
+    if (/not found|未找到|could not find|no .+ found/.test(m))
+        return 'not-found';
+    return 'other';
+}
+/** Render a status line for BrowserConnectError based on real-time or kind-derived state. */
+function renderBridgeStatus(running, extensionConnected) {
+    const ok = chalk.green('✓');
+    const fail = chalk.red('✗');
+    console.error(`  Daemon    ${running ? ok : fail} ${running ? 'running' : 'not running'}`);
+    console.error(`  Extension ${extensionConnected ? ok : fail} ${extensionConnected ? 'connected' : 'not connected'}`);
+    console.error();
+    if (!running) {
+        console.error(chalk.yellow('  Run the command again — daemon should auto-start.'));
+        console.error(chalk.dim('  Still failing? Run: opencli doctor'));
+    }
+    else if (!extensionConnected) {
+        console.error(chalk.yellow('  Install the Browser Bridge extension to continue:'));
+        console.error(chalk.dim('    1. Download from github.com/jackwener/opencli/releases'));
+        console.error(chalk.dim('    2. chrome://extensions → Enable Developer Mode → Load unpacked'));
+    }
+    else {
+        console.error(chalk.yellow('  Connection failed despite extension being active.'));
+        console.error(chalk.dim('  Try reloading the extension, or run: opencli doctor'));
+    }
+}
+async function renderError(err, cmdName, verbose) {
+    // ── BrowserConnectError: real-time diagnosis, kind as fallback ────────
+    if (err instanceof BrowserConnectError) {
+        console.error(chalk.red('🔌 Browser Bridge not connected'));
+        console.error();
+        try {
+            // 300ms matches execution.ts — localhost responds in <50ms when running.
+            const status = await checkDaemonStatus({ timeout: 300 });
+            renderBridgeStatus(status.running, status.extensionConnected);
+        }
+        catch (_statusErr) {
+            // checkDaemonStatus itself failed — derive best-guess state from kind.
+            const running = err.kind !== 'daemon-not-running';
+            const extensionConnected = err.kind === 'command-failed';
+            renderBridgeStatus(running, extensionConnected);
+        }
+        return;
+    }
+    // ── AuthRequiredError ─────────────────────────────────────────────────
+    if (err instanceof AuthRequiredError) {
+        console.error(chalk.red(`🔒 Not logged in to ${err.domain}`));
+        // Respect custom hints set by the adapter; fall back to generic guidance.
+        console.error(chalk.yellow(`→ ${err.hint ?? `Open Chrome and log in to https://${err.domain}, then retry.`}`));
+        return;
+    }
+    // ── TimeoutError ──────────────────────────────────────────────────────
+    if (err instanceof TimeoutError) {
+        console.error(chalk.red(`⏱  ${err.message}`));
+        console.error(chalk.yellow('→ Try again, or raise the limit:'));
+        console.error(chalk.dim(`    OPENCLI_BROWSER_COMMAND_TIMEOUT=60 ${cmdName}`));
+        return;
+    }
+    // ── SelectorError / EmptyResultError: likely outdated adapter ─────────
+    if (err instanceof SelectorError || err instanceof EmptyResultError) {
+        const icon = ERROR_ICONS[err.code] ?? '⚠️';
+        console.error(chalk.red(`${icon} ${err.message}`));
+        console.error(chalk.yellow('→ The page structure may have changed — this adapter may be outdated.'));
+        console.error(chalk.dim(`  Debug:  ${cmdName} --verbose`));
+        console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        return;
+    }
+    // ── ArgumentError ─────────────────────────────────────────────────────
+    if (err instanceof ArgumentError) {
+        console.error(chalk.red(`❌ ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        return;
+    }
+    // ── AdapterLoadError ──────────────────────────────────────────────────
+    if (err instanceof AdapterLoadError) {
+        console.error(chalk.red(`📦 ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        return;
+    }
+    // ── CommandExecutionError ─────────────────────────────────────────────
+    if (err instanceof CommandExecutionError) {
+        console.error(chalk.red(`💥 ${err.message}`));
+        if (err.hint) {
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        }
+        else {
+            console.error(chalk.dim(`  Add --verbose for details, or report: ${ISSUES_URL}`));
+        }
+        return;
+    }
+    // ── Other typed CliError (fallback for future codes) ──────────────────
+    if (err instanceof CliError) {
+        const icon = ERROR_ICONS[err.code] ?? '⚠️';
+        console.error(chalk.red(`${icon} ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        return;
+    }
+    // ── Generic Error from adapters: classify by message pattern ──────────
+    const msg = getErrorMessage(err);
+    const kind = classifyGenericError(msg);
+    if (kind === 'auth') {
+        console.error(chalk.red(`🔒 ${msg}`));
+        console.error(chalk.yellow('→ Open Chrome, log in to the target site, then retry.'));
+        return;
+    }
+    if (kind === 'http') {
+        console.error(chalk.red(`🌐 ${msg}`));
+        console.error(chalk.yellow('→ Check your login status, or the site may be temporarily unavailable.'));
+        return;
+    }
+    if (kind === 'not-found') {
+        console.error(chalk.red(`📭 ${msg}`));
+        console.error(chalk.yellow('→ The resource was not found. The adapter or page structure may have changed.'));
+        console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        return;
+    }
+    // ── Unknown error: show stack in verbose mode ─────────────────────────
+    if (verbose && err instanceof Error && err.stack) {
+        console.error(chalk.red(err.stack));
+    }
+    else {
+        console.error(chalk.red(`💥 Unexpected error: ${msg}`));
+        console.error(chalk.dim(`  Run with --verbose for details, or report: ${ISSUES_URL}`));
+    }
+}
 /**
  * Register all commands from the registry onto a Commander program.
  */

package/dist/commanderAdapter.test.d.ts

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

package/dist/commanderAdapter.test.js

@@ -0,0 +1,62 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+const { mockExecuteCommand, mockRenderOutput } = vi.hoisted(() => ({
+    mockExecuteCommand: vi.fn(),
+    mockRenderOutput: vi.fn(),
+}));
+vi.mock('./execution.js', () => ({
+    executeCommand: mockExecuteCommand,
+}));
+vi.mock('./output.js', () => ({
+    render: mockRenderOutput,
+}));
+import { registerCommandToProgram } from './commanderAdapter.js';
+describe('commanderAdapter arg passing', () => {
+    const cmd = {
+        site: 'paperreview',
+        name: 'submit',
+        description: 'Submit a PDF',
+        browser: false,
+        args: [
+            { name: 'pdf', positional: true, required: true, help: 'Path to the paper PDF' },
+            { name: 'dry-run', type: 'bool', default: false, help: 'Validate only' },
+            { name: 'prepare-only', type: 'bool', default: false, help: 'Prepare only' },
+        ],
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('passes bool flag values through to executeCommand for coercion', async () => {
+        const program = new Command();
+        const siteCmd = program.command('paperreview');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'false']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs.pdf).toBe('./paper.pdf');
+        expect(kwargs).toHaveProperty('dry-run');
+    });
+    it('passes valueless bool flags as true to executeCommand', async () => {
+        const program = new Command();
+        const siteCmd = program.command('paperreview');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--prepare-only']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs.pdf).toBe('./paper.pdf');
+        expect(kwargs['prepare-only']).toBe(true);
+    });
+    it('rejects invalid bool values before calling executeCommand', async () => {
+        const program = new Command();
+        const siteCmd = program.command('paperreview');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'maybe']);
+        // normalizeArgValue validates bools eagerly; executeCommand should not be reached
+        expect(mockExecuteCommand).not.toHaveBeenCalled();
+    });
+});

package/dist/daemon.js

@@ -25,6 +25,7 @@ const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_P
 const IDLE_TIMEOUT = 5 * 60 * 1000; // 5 minutes
 // ─── State ───────────────────────────────────────────────────────────
 let extensionWs = null;
+let extensionVersion = null;
 const pending = new Map();
 let idleTimer = null;
 const LOG_BUFFER_SIZE = 200;
@@ -103,6 +104,7 @@ async function handleRequest(req, res) {
         jsonResponse(res, 200, {
             ok: true,
             extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
+            extensionVersion,
             pending: pending.size,
         });
         return;
@@ -195,6 +197,11 @@ wss.on('connection', (ws) => {
     ws.on('message', (data) => {
         try {
             const msg = JSON.parse(data.toString());
+            // Handle hello message from extension (version handshake)
+            if (msg.type === 'hello') {
+                extensionVersion = typeof msg.version === 'string' ? msg.version : null;
+                return;
+            }
             // Handle log messages from extension
             if (msg.type === 'log') {
                 const prefix = msg.level === 'error' ? '❌' : msg.level === 'warn' ? '⚠️' : '📋';
@@ -219,6 +226,7 @@ wss.on('connection', (ws) => {
         clearInterval(heartbeatInterval);
         if (extensionWs === ws) {
             extensionWs = null;
+            extensionVersion = null;
             // Reject all pending requests since the extension is gone
             for (const [id, p] of pending) {
                 clearTimeout(p.timer);
@@ -229,8 +237,16 @@ wss.on('connection', (ws) => {
     });
     ws.on('error', () => {
         clearInterval(heartbeatInterval);
-        if (extensionWs === ws)
+        if (extensionWs === ws) {
             extensionWs = null;
+            extensionVersion = null;
+            // Reject pending requests in case 'close' does not follow this 'error'
+            for (const [, p] of pending) {
+                clearTimeout(p.timer);
+                p.reject(new Error('Extension disconnected'));
+            }
+            pending.clear();
+        }
     });
 });
 // ─── Start ───────────────────────────────────────────────────────────

package/dist/discovery.js

@@ -19,6 +19,7 @@ import { log } from './logger.js';
 export const PLUGINS_DIR = path.join(os.homedir(), '.opencli', 'plugins');
 /** Matches files that register commands via cli() or lifecycle hooks */
 const PLUGIN_MODULE_PATTERN = /\b(?:cli|onStartup|onBeforeExecute|onAfterExecute)\s*\(/;
+import { parseYamlArgs } from './yaml-schema.js';
 function parseStrategy(rawStrategy, fallback = Strategy.COOKIE) {
     if (!rawStrategy)
         return fallback;
@@ -71,6 +72,8 @@ async function loadFromManifest(manifestPath, clisDir) {
                     pipeline: entry.pipeline,
                     timeoutSeconds: entry.timeout,
                     source: `manifest:${entry.site}/${entry.name}`,
+                    deprecated: entry.deprecated,
+                    replacedBy: entry.replacedBy,
                     navigateBefore: entry.navigateBefore,
                 };
                 registerCommand(cmd);
@@ -91,6 +94,8 @@ async function loadFromManifest(manifestPath, clisDir) {
                     columns: entry.columns,
                     timeoutSeconds: entry.timeout,
                     source: modulePath,
+                    deprecated: entry.deprecated,
+                    replacedBy: entry.replacedBy,
                     navigateBefore: entry.navigateBefore,
                     _lazy: true,
                     _modulePath: modulePath,
@@ -122,22 +127,20 @@ async function discoverClisFromFs(dir) {
         const site = entry.name;
         const siteDir = path.join(dir, site);
         const files = await fs.promises.readdir(siteDir);
-        const filePromises = [];
-        for (const file of files) {
+        await Promise.all(files.map(async (file) => {
             const filePath = path.join(siteDir, file);
             if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                filePromises.push(registerYamlCli(filePath, site));
+                await registerYamlCli(filePath, site);
             }
             else if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
                 (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts'))) {
                 if (!(await isCliModule(filePath)))
-                    continue;
-                filePromises.push(import(pathToFileURL(filePath).href).catch((err) => {
+                    return;
+                await import(pathToFileURL(filePath).href).catch((err) => {
                     log.warn(`Failed to load module ${filePath}: ${getErrorMessage(err)}`);
-                }));
+                });
             }
-        }
-        await Promise.all(filePromises);
+        }));
     });
     await Promise.all(sitePromises);
 }
@@ -153,20 +156,7 @@ async function registerYamlCli(filePath, defaultSite) {
         const strategyStr = cliDef.strategy ?? (cliDef.browser === false ? 'public' : 'cookie');
         const strategy = parseStrategy(strategyStr);
         const browser = cliDef.browser ?? (strategy !== Strategy.PUBLIC);
-        const args = [];
-        if (cliDef.args && typeof cliDef.args === 'object') {
-            for (const [argName, argDef] of Object.entries(cliDef.args)) {
-                args.push({
-                    name: argName,
-                    type: argDef?.type ?? 'str',
-                    default: argDef?.default,
-                    required: argDef?.required ?? false,
-                    positional: argDef?.positional ?? false,
-                    help: argDef?.description ?? argDef?.help ?? '',
-                    choices: argDef?.choices,
-                });
-            }
-        }
+        const args = parseYamlArgs(cliDef.args);
         const cmd = {
             site,
             name,
@@ -179,6 +169,8 @@ async function registerYamlCli(filePath, defaultSite) {
             pipeline: cliDef.pipeline,
             timeoutSeconds: cliDef.timeout,
             source: filePath,
+            deprecated: cliDef.deprecated,
+            replacedBy: cliDef.replacedBy,
             navigateBefore: cliDef.navigateBefore,
         };
         registerCommand(cmd);
@@ -200,11 +192,12 @@ export async function discoverPlugins() {
         return;
     }
     const entries = await fs.promises.readdir(PLUGINS_DIR, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        await discoverPluginDir(path.join(PLUGINS_DIR, entry.name), entry.name);
-    }
+    await Promise.all(entries.map(async (entry) => {
+        const pluginDir = path.join(PLUGINS_DIR, entry.name);
+        if (!(await isDiscoverablePluginDir(entry, pluginDir)))
+            return;
+        await discoverPluginDir(pluginDir, entry.name);
+    }));
 }
 /**
  * Flat scan: read yaml/ts files directly in a plugin directory.
@@ -213,32 +206,29 @@ export async function discoverPlugins() {
 async function discoverPluginDir(dir, site) {
     const files = await fs.promises.readdir(dir);
     const fileSet = new Set(files);
-    const promises = [];
-    for (const file of files) {
+    await Promise.all(files.map(async (file) => {
         const filePath = path.join(dir, file);
         if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-            promises.push(registerYamlCli(filePath, site));
+            await registerYamlCli(filePath, site);
         }
         else if (file.endsWith('.js') && !file.endsWith('.d.js')) {
             if (!(await isCliModule(filePath)))
-                continue;
-            promises.push(import(pathToFileURL(filePath).href).catch((err) => {
+                return;
+            await import(pathToFileURL(filePath).href).catch((err) => {
                 log.warn(`Plugin ${site}/${file}: ${getErrorMessage(err)}`);
-            }));
+            });
         }
         else if (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts')) {
-            // Skip .ts if a compiled .js sibling exists (production mode can't load .ts)
             const jsFile = file.replace(/\.ts$/, '.js');
+            // Prefer compiled .js — skip the .ts source file
             if (fileSet.has(jsFile))
-                continue;
-            if (!(await isCliModule(filePath)))
-                continue;
-            promises.push(import(pathToFileURL(filePath).href).catch((err) => {
-                log.warn(`Plugin ${site}/${file}: ${getErrorMessage(err)}`);
-            }));
+                return;
+            // No compiled .js found — cannot import raw .ts in production Node.js.
+            // This typically means esbuild transpilation failed during plugin install.
+            log.warn(`Plugin ${site}/${file}: no compiled .js found. ` +
+                `Run "opencli plugin update ${site}" to re-transpile, or install esbuild.`);
         }
-    }
-    await Promise.all(promises);
+    }));
 }
 async function isCliModule(filePath) {
     try {
@@ -250,3 +240,19 @@ async function isCliModule(filePath) {
         return false;
     }
 }
+async function isDiscoverablePluginDir(entry, pluginDir) {
+    if (entry.isDirectory())
+        return true;
+    if (!entry.isSymbolicLink())
+        return false;
+    try {
+        return (await fs.promises.stat(pluginDir)).isDirectory();
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+            log.warn(`Failed to inspect plugin link ${pluginDir}: ${getErrorMessage(err)}`);
+        }
+        return false;
+    }
+}

package/dist/doctor.d.ts

@@ -1,11 +1,10 @@
 /**
- * opencli doctor — diagnose and fix browser connectivity.
+ * opencli doctor — diagnose browser connectivity.
  *
  * Simplified for the daemon-based architecture. No more token management,
  * MCP path discovery, or config file scanning.
  */
 export type DoctorOptions = {
-    fix?: boolean;
     yes?: boolean;
     live?: boolean;
     sessions?: boolean;
@@ -20,6 +19,7 @@ export type DoctorReport = {
     cliVersion?: string;
     daemonRunning: boolean;
     extensionConnected: boolean;
+    extensionVersion?: string;
     connectivity?: ConnectivityResult;
     sessions?: Array<{
         workspace: string;

package/dist/doctor.js

@@ -1,5 +1,5 @@
 /**
- * opencli doctor — diagnose and fix browser connectivity.
+ * opencli doctor — diagnose browser connectivity.
  *
  * Simplified for the daemon-based architecture. No more token management,
  * MCP path discovery, or config file scanning.
@@ -10,6 +10,7 @@ import { checkDaemonStatus } from './browser/discover.js';
 import { BrowserBridge } from './browser/index.js';
 import { listSessions } from './browser/daemon-client.js';
 import { getErrorMessage } from './errors.js';
+import { getRuntimeLabel } from './runtime-detect.js';
 /**
  * Test connectivity by attempting a real browser command.
  */
@@ -57,30 +58,36 @@ export async function runBrowserDoctor(opts = {}) {
     if (status.running && !status.extensionConnected) {
         issues.push('Daemon is running but the Chrome extension is not connected.\n' +
             'Please install the opencli Browser Bridge extension:\n' +
-            '  1. Download from GitHub Releases\n' +
+            '  1. Download from https://github.com/jackwener/opencli/releases\n' +
             '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
             '  3. Click "Load unpacked" → select the extension folder');
     }
     if (connectivity && !connectivity.ok) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
+    if (status.extensionVersion && opts.cliVersion && status.extensionVersion !== opts.cliVersion) {
+        issues.push(`Extension version mismatch: extension v${status.extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
+            '  Download the latest extension from: https://github.com/jackwener/opencli/releases');
+    }
     return {
         cliVersion: opts.cliVersion,
         daemonRunning: status.running,
         extensionConnected: status.extensionConnected,
+        extensionVersion: status.extensionVersion,
         connectivity,
         sessions,
         issues,
     };
 }
 export function renderBrowserDoctorReport(report) {
-    const lines = [chalk.bold(`opencli v${report.cliVersion ?? 'unknown'} doctor`), ''];
+    const lines = [chalk.bold(`opencli v${report.cliVersion ?? 'unknown'} doctor`) + chalk.dim(` (${getRuntimeLabel()})`), ''];
     // Daemon status
     const daemonIcon = report.daemonRunning ? chalk.green('[OK]') : chalk.red('[MISSING]');
     lines.push(`${daemonIcon} Daemon: ${report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` : 'not running'}`);
     // Extension status
     const extIcon = report.extensionConnected ? chalk.green('[OK]') : chalk.yellow('[MISSING]');
-    lines.push(`${extIcon} Extension: ${report.extensionConnected ? 'connected' : 'not connected'}`);
+    const extVersion = report.extensionVersion ? chalk.dim(` (v${report.extensionVersion})`) : '';
+    lines.push(`${extIcon} Extension: ${report.extensionConnected ? 'connected' : 'not connected'}${extVersion}`);
     // Connectivity
     if (report.connectivity) {
         const connIcon = report.connectivity.ok ? chalk.green('[OK]') : chalk.red('[FAIL]');