@jackwener/opencli 1.4.1 → 1.5.1

package/src/commanderAdapter.ts

@@ -16,7 +16,32 @@ import { type CliCommand, 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: string | undefined, value: unknown, name: string): unknown {
+  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.
@@ -24,7 +49,8 @@ import { CliError, ERROR_ICONS, getErrorMessage } from './errors.js';
 export function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): void {
   if (siteCmd.commands.some((c: Command) => 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: typeof cmd.args = [];
@@ -51,24 +77,29 @@ export function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): voi
     const optionsRecord = typeof actionOpts === 'object' && actionOpts !== null ? actionOpts as Record<string, unknown> : {};
     const startTime = Date.now();
 
-    // ── Collect kwargs ──────────────────────────────────────────────────
-    const kwargs: Record<string, unknown> = {};
-    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: string) => ch.toUpperCase());
-      const v = optionsRecord[arg.name] ?? optionsRecord[camelName];
-      if (v !== undefined) kwargs[arg.name] = v;
-    }
-
     // ── Execute + render ────────────────────────────────────────────────
     try {
+      // ── Collect kwargs ────────────────────────────────────────────────
+      const kwargs: Record<string, unknown> = {};
+      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: string) => 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);
 
@@ -85,20 +116,153 @@ export function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): voi
         footerExtra: resolved.footerExtra?.(kwargs),
       });
     } 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: string): 'auth' | 'http' | 'not-found' | 'other' {
+  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: boolean, extensionConnected: boolean): void {
+  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: unknown, cmdName: string, verbose: boolean): Promise<void> {
+  // ── 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/src/daemon.ts

@@ -29,6 +29,7 @@ const IDLE_TIMEOUT = 5 * 60 * 1000; // 5 minutes
 // ─── State ───────────────────────────────────────────────────────────
 
 let extensionWs: WebSocket | null = null;
+let extensionVersion: string | null = null;
 const pending = new Map<string, {
   resolve: (data: unknown) => void;
   reject: (error: Error) => void;
@@ -117,6 +118,7 @@ async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise
     jsonResponse(res, 200, {
       ok: true,
       extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
+      extensionVersion,
       pending: pending.size,
     });
     return;
@@ -222,6 +224,12 @@ wss.on('connection', (ws: WebSocket) => {
     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' ? '⚠️' : '📋';
@@ -247,6 +255,7 @@ wss.on('connection', (ws: WebSocket) => {
     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);
@@ -258,7 +267,16 @@ wss.on('connection', (ws: WebSocket) => {
 
   ws.on('error', () => {
     clearInterval(heartbeatInterval);
-    if (extensionWs === ws) extensionWs = null;
+    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();
+    }
   });
 });
 

package/src/discovery.ts

@@ -23,7 +23,7 @@ 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 type { YamlCliDefinition } from './yaml-schema.js';
+import { type YamlCliDefinition, parseYamlArgs } from './yaml-schema.js';
 
 function parseStrategy(rawStrategy: string | undefined, fallback: Strategy = Strategy.COOKIE): Strategy {
   if (!rawStrategy) return fallback;
@@ -77,6 +77,8 @@ async function loadFromManifest(manifestPath: string, clisDir: string): Promise<
           pipeline: entry.pipeline,
           timeoutSeconds: entry.timeout,
           source: `manifest:${entry.site}/${entry.name}`,
+          deprecated: entry.deprecated,
+          replacedBy: entry.replacedBy,
           navigateBefore: entry.navigateBefore,
         };
         registerCommand(cmd);
@@ -96,6 +98,8 @@ async function loadFromManifest(manifestPath: string, clisDir: string): Promise<
           columns: entry.columns,
           timeoutSeconds: entry.timeout,
           source: modulePath,
+          deprecated: entry.deprecated,
+          replacedBy: entry.replacedBy,
           navigateBefore: entry.navigateBefore,
           _lazy: true,
           _modulePath: modulePath,
@@ -123,24 +127,20 @@ async function discoverClisFromFs(dir: string): Promise<void> {
       const site = entry.name;
       const siteDir = path.join(dir, site);
       const files = await fs.promises.readdir(siteDir);
-      const filePromises: Promise<unknown>[] = [];
-      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) => {
-              log.warn(`Failed to load module ${filePath}: ${getErrorMessage(err)}`);
-            })
-          );
+          if (!(await isCliModule(filePath))) 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);
 }
@@ -158,20 +158,7 @@ async function registerYamlCli(filePath: string, defaultSite: string): Promise<v
     const strategy = parseStrategy(strategyStr);
     const browser = cliDef.browser ?? (strategy !== Strategy.PUBLIC);
 
-    const args: Arg[] = [];
-    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: CliCommand = {
       site,
@@ -185,6 +172,8 @@ async function registerYamlCli(filePath: string, defaultSite: string): Promise<v
       pipeline: cliDef.pipeline,
       timeoutSeconds: cliDef.timeout,
       source: filePath,
+      deprecated: (cliDef as Record<string, unknown>).deprecated as boolean | string | undefined,
+      replacedBy: (cliDef as Record<string, unknown>).replacedBy as string | undefined,
       navigateBefore: cliDef.navigateBefore,
     };
 
@@ -202,10 +191,11 @@ async function registerYamlCli(filePath: string, defaultSite: string): Promise<v
 export async function discoverPlugins(): Promise<void> {
   try { await fs.promises.access(PLUGINS_DIR); } catch { 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);
+  }));
 }
 
 /**
@@ -215,33 +205,29 @@ export async function discoverPlugins(): Promise<void> {
 async function discoverPluginDir(dir: string, site: string): Promise<void> {
   const files = await fs.promises.readdir(dir);
   const fileSet = new Set(files);
-  const promises: Promise<unknown>[] = [];
-  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) => {
-          log.warn(`Plugin ${site}/${file}: ${getErrorMessage(err)}`);
-        })
-      );
+      if (!(await isCliModule(filePath))) 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');
-      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)}`);
-        })
+      // Prefer compiled .js — skip the .ts source file
+      if (fileSet.has(jsFile)) 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: string): Promise<boolean> {
@@ -253,3 +239,18 @@ async function isCliModule(filePath: string): Promise<boolean> {
     return false;
   }
 }
+
+async function isDiscoverablePluginDir(entry: fs.Dirent, pluginDir: string): Promise<boolean> {
+  if (entry.isDirectory()) return true;
+  if (!entry.isSymbolicLink()) return false;
+
+  try {
+    return (await fs.promises.stat(pluginDir)).isDirectory();
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+      log.warn(`Failed to inspect plugin link ${pluginDir}: ${getErrorMessage(err)}`);
+    }
+    return false;
+  }
+}

package/src/doctor.ts

@@ -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.
@@ -11,9 +11,9 @@ 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';
 
 export type DoctorOptions = {
-  fix?: boolean;
   yes?: boolean;
   live?: boolean;
   sessions?: boolean;
@@ -30,6 +30,7 @@ export type DoctorReport = {
   cliVersion?: string;
   daemonRunning: boolean;
   extensionConnected: boolean;
+  extensionVersion?: string;
   connectivity?: ConnectivityResult;
   sessions?: Array<{ workspace: string; windowId: number; tabCount: number; idleMsRemaining: number }>;
   issues: string[];
@@ -85,7 +86,7 @@ export async function runBrowserDoctor(opts: DoctorOptions = {}): Promise<Doctor
     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',
     );
@@ -94,10 +95,18 @@ export async function runBrowserDoctor(opts: DoctorOptions = {}): Promise<Doctor
     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,
@@ -105,7 +114,7 @@ export async function runBrowserDoctor(opts: DoctorOptions = {}): Promise<Doctor
 }
 
 export function renderBrowserDoctorReport(report: DoctorReport): string {
-  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]');
@@ -113,7 +122,8 @@ export function renderBrowserDoctorReport(report: DoctorReport): string {
 
   // 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) {

package/src/download/index.test.ts

@@ -6,12 +6,17 @@ import { afterEach, describe, expect, it } from 'vitest';
 import { formatCookieHeader, httpDownload, resolveRedirectUrl } from './index.js';
 
 const servers: http.Server[] = [];
+const tempDirs: string[] = [];
 
 afterEach(async () => {
   await Promise.all(servers.map((server) => new Promise<void>((resolve, reject) => {
     server.close((err) => (err ? reject(err) : resolve()));
   })));
   servers.length = 0;
+  for (const dir of tempDirs) {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+  }
+  tempDirs.length = 0;
 });
 
 async function startServer(handler: http.RequestListener, hostname = '127.0.0.1'): Promise<string> {
@@ -25,7 +30,9 @@ async function startServer(handler: http.RequestListener, hostname = '127.0.0.1'
   return `http://${hostname}:${address.port}`;
 }
 
-describe('download helpers', () => {
+// Windows Defender can briefly lock newly-written .tmp files, causing EPERM.
+// Retry once to handle this flakiness.
+describe('download helpers', { retry: process.platform === 'win32' ? 2 : 0 }, () => {
   it('resolves relative redirects against the original URL', () => {
     expect(resolveRedirectUrl('https://example.com/a/file', '/cdn/file.bin')).toBe('https://example.com/cdn/file.bin');
     expect(resolveRedirectUrl('https://example.com/a/file', '../next')).toBe('https://example.com/next');
@@ -45,7 +52,8 @@ describe('download helpers', () => {
       res.end();
     });
 
-    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-download-'));
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+    tempDirs.push(tempDir);
     const destPath = path.join(tempDir, 'file.txt');
     const result = await httpDownload(`${baseUrl}/loop`, destPath, { maxRedirects: 2 });
 
@@ -71,7 +79,8 @@ describe('download helpers', () => {
       res.end();
     });
 
-    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-download-'));
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+    tempDirs.push(tempDir);
     const destPath = path.join(tempDir, 'redirect.txt');
     const result = await httpDownload(`${redirectUrl}/start`, destPath, { cookies: 'sid=abc' });
 
@@ -94,7 +103,8 @@ describe('download helpers', () => {
       res.end();
     });
 
-    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-download-'));
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+    tempDirs.push(tempDir);
     const destPath = path.join(tempDir, 'redirect-header.txt');
     const result = await httpDownload(`${redirectUrl}/start`, destPath, {
       headers: { Cookie: 'sid=header-cookie' },