@jackwener/opencli 1.1.1 → 1.2.0

package/src/clis/xueqiu/earnings-date.yaml

@@ -0,0 +1,69 @@
+site: xueqiu
+name: earnings-date
+description: 获取股票预计财报发布日期（公司大事）
+domain: xueqiu.com
+browser: true
+
+args:
+  symbol:
+    positional: true
+    type: str
+    required: true
+    description: 股票代码，如 SH600519、SZ000858、00700
+  next:
+    type: bool
+    default: false
+    description: 仅返回最近一次未发布的财报日期
+  limit:
+    type: int
+    default: 10
+    description: 返回数量，默认 10
+
+pipeline:
+  - navigate: https://xueqiu.com
+  - evaluate: |
+      (async () => {
+        const symbol = (${{ args.symbol | json }} || '').toUpperCase();
+        const onlyNext = ${{ args.next }};
+        if (!symbol) throw new Error('Missing argument: symbol');
+        const resp = await fetch(
+          `https://stock.xueqiu.com/v5/stock/screener/event/list.json?symbol=${encodeURIComponent(symbol)}&page=1&size=100`,
+          { credentials: 'include' }
+        );
+        if (!resp.ok) throw new Error('HTTP ' + resp.status + ' Hint: Not logged in?');
+        const d = await resp.json();
+        if (!d.data || !d.data.items) throw new Error('获取失败: ' + JSON.stringify(d));
+
+        // subtype 2 = 预计财报发布
+        let items = d.data.items.filter(item => item.subtype === 2);
+
+        const now = Date.now();
+        let results = items.map(item => {
+          const ts = item.timestamp;
+          const dateStr = ts ? new Date(ts).toISOString().split('T')[0] : null;
+          const isFuture = ts && ts > now;
+          return {
+            date: dateStr,
+            report: item.message,
+            status: isFuture ? '⏳ 未发布' : '✅ 已发布',
+            _ts: ts,
+            _future: isFuture
+          };
+        });
+
+        if (onlyNext) {
+          const future = results.filter(r => r._future).sort((a, b) => a._ts - b._ts);
+          results = future.length ? [future[0]] : [];
+        }
+
+        return results;
+      })()
+
+  - map:
+      date: ${{ item.date }}
+      report: ${{ item.report }}
+      status: ${{ item.status }}
+
+  - limit: ${{ args.limit }}
+
+columns: [date, report, status]

package/src/clis/xueqiu/search.yaml

@@ -6,7 +6,9 @@ browser: true
 
 args:
   query:
+    positional: true
     type: str
+    required: true
     description: 搜索关键词，如 茅台、AAPL、腾讯
   limit:
     type: int
@@ -19,7 +21,6 @@ pipeline:
       (async () => {
         const query = ${{ args.query | json }};
         const count = ${{ args.limit }};
-        if (!query) throw new Error('Missing argument: query');
         const resp = await fetch(`https://xueqiu.com/stock/search.json?code=${encodeURIComponent(query)}&size=${count}`, {credentials: 'include'});
         if (!resp.ok) throw new Error('HTTP ' + resp.status + ' Hint: Not logged in?');
         const d = await resp.json();

package/src/clis/xueqiu/stock.yaml

@@ -6,7 +6,9 @@ browser: true
 
 args:
   symbol:
+    positional: true
     type: str
+    required: true
     description: 股票代码，如 SH600519、SZ000858、AAPL、00700
 
 pipeline:

package/src/clis/yahoo-finance/quote.ts

@@ -11,7 +11,7 @@ cli({
   domain: 'finance.yahoo.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'symbol', required: true, help: 'Stock ticker (e.g. AAPL, MSFT, TSLA)' },
+    { name: 'symbol', required: true, positional: true, help: 'Stock ticker (e.g. AAPL, MSFT, TSLA)' },
   ],
   columns: ['symbol', 'name', 'price', 'change', 'changePercent', 'open', 'high', 'low', 'volume', 'marketCap'],
   func: async (page, kwargs) => {

package/src/commanderAdapter.ts

@@ -18,6 +18,10 @@ import { render as renderOutput } from './output.js';
 import { executeCommand } from './execution.js';
 import { CliError } from './errors.js';
 
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 /**
  * Register a single CliCommand as a Commander subcommand.
  */
@@ -46,12 +50,13 @@ export function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): voi
 
   subCmd.addHelpText('after', formatRegistryHelpText(cmd));
 
-  subCmd.action(async (...actionArgs: any[]) => {
+  subCmd.action(async (...actionArgs: unknown[]) => {
     const actionOpts = actionArgs[positionalArgs.length] ?? {};
+    const optionsRecord = typeof actionOpts === 'object' && actionOpts !== null ? actionOpts as Record<string, unknown> : {};
     const startTime = Date.now();
 
     // ── Collect kwargs ──────────────────────────────────────────────────
-    const kwargs: Record<string, any> = {};
+    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;
@@ -59,36 +64,38 @@ export function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): voi
     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 = actionOpts[arg.name] ?? actionOpts[camelName];
+      const v = optionsRecord[arg.name] ?? optionsRecord[camelName];
       if (v !== undefined) kwargs[arg.name] = v;
     }
 
     // ── Execute + render ────────────────────────────────────────────────
     try {
-      if (actionOpts.verbose) process.env.OPENCLI_VERBOSE = '1';
+      const verbose = optionsRecord.verbose === true;
+      const format = typeof optionsRecord.format === 'string' ? optionsRecord.format : 'table';
+      if (verbose) process.env.OPENCLI_VERBOSE = '1';
 
-      const result = await executeCommand(cmd, kwargs, actionOpts.verbose);
+      const result = await executeCommand(cmd, kwargs, verbose);
 
-      if (actionOpts.verbose && (!result || (Array.isArray(result) && result.length === 0))) {
+      if (verbose && (!result || (Array.isArray(result) && result.length === 0))) {
         console.error(chalk.yellow('[Verbose] Warning: Command returned an empty result.'));
       }
       const resolved = getRegistry().get(fullName(cmd)) ?? cmd;
       renderOutput(result, {
-        fmt: actionOpts.format,
+        fmt: format,
         columns: resolved.columns,
         title: `${resolved.site}/${resolved.name}`,
         elapsed: (Date.now() - startTime) / 1000,
         source: fullName(resolved),
         footerExtra: resolved.footerExtra?.(kwargs),
       });
-    } catch (err: any) {
+    } catch (err) {
       if (err instanceof CliError) {
         console.error(chalk.red(`Error [${err.code}]: ${err.message}`));
         if (err.hint) console.error(chalk.yellow(`Hint: ${err.hint}`));
-      } else if (actionOpts.verbose && err.stack) {
+      } else if (optionsRecord.verbose === true && err instanceof Error && err.stack) {
         console.error(chalk.red(err.stack));
       } else {
-        console.error(chalk.red(`Error: ${err.message ?? err}`));
+        console.error(chalk.red(`Error: ${getErrorMessage(err)}`));
       }
       process.exitCode = 1;
     }

package/src/discovery.ts

@@ -9,10 +9,55 @@
  */
 
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import yaml from 'js-yaml';
 import { type CliCommand, type InternalCliCommand, type Arg, Strategy, registerCommand } from './registry.js';
 import { log } from './logger.js';
+import type { ManifestEntry } from './build-manifest.js';
+
+/** Plugins directory: ~/.opencli/plugins/ */
+export const PLUGINS_DIR = path.join(os.homedir(), '.opencli', 'plugins');
+const CLI_MODULE_PATTERN = /\bcli\s*\(/;
+
+interface YamlArgDefinition {
+  type?: string;
+  default?: unknown;
+  required?: boolean;
+  positional?: boolean;
+  description?: string;
+  help?: string;
+  choices?: string[];
+}
+
+interface YamlCliDefinition {
+  site?: string;
+  name?: string;
+  description?: string;
+  domain?: string;
+  strategy?: string;
+  browser?: boolean;
+  args?: Record<string, YamlArgDefinition>;
+  columns?: string[];
+  pipeline?: Record<string, unknown>[];
+  timeout?: number;
+  navigateBefore?: boolean | string;
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function parseStrategy(rawStrategy: string | undefined, fallback: Strategy = Strategy.COOKIE): Strategy {
+  if (!rawStrategy) return fallback;
+  const key = rawStrategy.toUpperCase() as keyof typeof Strategy;
+  return Strategy[key] ?? fallback;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 
 /**
  * Discover and register CLI commands.
@@ -41,11 +86,11 @@ export async function discoverClis(...dirs: string[]): Promise<void> {
 async function loadFromManifest(manifestPath: string, clisDir: string): Promise<void> {
   try {
     const raw = await fs.promises.readFile(manifestPath, 'utf-8');
-    const manifest = JSON.parse(raw) as any[];
+    const manifest = JSON.parse(raw) as ManifestEntry[];
     for (const entry of manifest) {
       if (entry.type === 'yaml') {
         // YAML pipelines fully inlined in manifest — register directly
-        const strategy = (Strategy as any)[entry.strategy.toUpperCase()] ?? Strategy.COOKIE;
+        const strategy = parseStrategy(entry.strategy);
         const cmd: CliCommand = {
           site: entry.site,
           name: entry.name,
@@ -58,12 +103,13 @@ async function loadFromManifest(manifestPath: string, clisDir: string): Promise<
           pipeline: entry.pipeline,
           timeoutSeconds: entry.timeout,
           source: `manifest:${entry.site}/${entry.name}`,
+          navigateBefore: entry.navigateBefore,
         };
         registerCommand(cmd);
       } else if (entry.type === 'ts' && entry.modulePath) {
         // TS adapters: register a lightweight stub.
         // The actual module is loaded lazily on first executeCommand().
-        const strategy = (Strategy as any)[(entry.strategy ?? 'cookie').toUpperCase()] ?? Strategy.COOKIE;
+        const strategy = parseStrategy(entry.strategy ?? 'cookie');
         const modulePath = path.resolve(clisDir, entry.modulePath);
         const cmd: InternalCliCommand = {
           site: entry.site,
@@ -76,14 +122,15 @@ async function loadFromManifest(manifestPath: string, clisDir: string): Promise<
           columns: entry.columns,
           timeoutSeconds: entry.timeout,
           source: modulePath,
+          navigateBefore: entry.navigateBefore,
           _lazy: true,
           _modulePath: modulePath,
         };
         registerCommand(cmd);
       }
     }
-  } catch (err: any) {
-    log.warn(`Failed to load manifest ${manifestPath}: ${err.message}`);
+  } catch (err) {
+    log.warn(`Failed to load manifest ${manifestPath}: ${getErrorMessage(err)}`);
   }
 }
 
@@ -92,7 +139,7 @@ async function loadFromManifest(manifestPath: string, clisDir: string): Promise<
  */
 async function discoverClisFromFs(dir: string): Promise<void> {
   try { await fs.promises.access(dir); } catch { return; }
-  const promises: Promise<any>[] = [];
+  const promises: Promise<unknown>[] = [];
   const entries = await fs.promises.readdir(dir, { withFileTypes: true });
   
   for (const entry of entries) {
@@ -108,9 +155,10 @@ async function discoverClisFromFs(dir: string): Promise<void> {
         (file.endsWith('.js') && !file.endsWith('.d.js')) ||
         (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts'))
       ) {
+        if (!(await isCliModule(filePath))) continue;
         promises.push(
-          import(`file://${filePath}`).catch((err: any) => {
-            log.warn(`Failed to load module ${filePath}: ${err.message}`);
+          import(pathToFileURL(filePath).href).catch((err) => {
+            log.warn(`Failed to load module ${filePath}: ${getErrorMessage(err)}`);
           })
         );
       }
@@ -122,18 +170,19 @@ async function discoverClisFromFs(dir: string): Promise<void> {
 async function registerYamlCli(filePath: string, defaultSite: string): Promise<void> {
   try {
     const raw = await fs.promises.readFile(filePath, 'utf-8');
-    const def = yaml.load(raw) as any;
-    if (!def || typeof def !== 'object') return;
+    const def = yaml.load(raw) as YamlCliDefinition | null;
+    if (!isRecord(def)) return;
+    const cliDef = def as YamlCliDefinition;
 
-    const site = def.site ?? defaultSite;
-    const name = def.name ?? path.basename(filePath, path.extname(filePath));
-    const strategyStr = def.strategy ?? (def.browser === false ? 'public' : 'cookie');
-    const strategy = (Strategy as any)[strategyStr.toUpperCase()] ?? Strategy.COOKIE;
-    const browser = def.browser ?? (strategy !== Strategy.PUBLIC);
+    const site = cliDef.site ?? defaultSite;
+    const name = cliDef.name ?? path.basename(filePath, path.extname(filePath));
+    const strategyStr = cliDef.strategy ?? (cliDef.browser === false ? 'public' : 'cookie');
+    const strategy = parseStrategy(strategyStr);
+    const browser = cliDef.browser ?? (strategy !== Strategy.PUBLIC);
 
     const args: Arg[] = [];
-    if (def.args && typeof def.args === 'object') {
-      for (const [argName, argDef] of Object.entries(def.args as Record<string, any>)) {
+    if (cliDef.args && typeof cliDef.args === 'object') {
+      for (const [argName, argDef] of Object.entries(cliDef.args)) {
         args.push({
           name: argName,
           type: argDef?.type ?? 'str',
@@ -149,19 +198,80 @@ async function registerYamlCli(filePath: string, defaultSite: string): Promise<v
     const cmd: CliCommand = {
       site,
       name,
-      description: def.description ?? '',
-      domain: def.domain,
+      description: cliDef.description ?? '',
+      domain: cliDef.domain,
       strategy,
       browser,
       args,
-      columns: def.columns,
-      pipeline: def.pipeline,
-      timeoutSeconds: def.timeout,
+      columns: cliDef.columns,
+      pipeline: cliDef.pipeline,
+      timeoutSeconds: cliDef.timeout,
       source: filePath,
+      navigateBefore: cliDef.navigateBefore,
     };
 
     registerCommand(cmd);
-  } catch (err: any) {
-    log.warn(`Failed to load ${filePath}: ${err.message}`);
+  } catch (err) {
+    log.warn(`Failed to load ${filePath}: ${getErrorMessage(err)}`);
+  }
+}
+
+/**
+ * Discover and register plugins from ~/.opencli/plugins/.
+ * Each subdirectory is treated as a plugin (site = directory name).
+ * Files inside are scanned flat (no nested site subdirs).
+ */
+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);
+  }
+}
+
+/**
+ * Flat scan: read yaml/ts files directly in a plugin directory.
+ * Unlike discoverClisFromFs, this does NOT expect nested site subdirectories.
+ */
+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) {
+    const filePath = path.join(dir, file);
+    if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+      promises.push(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)}`);
+        })
+      );
+    } 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)}`);
+        })
+      );
+    }
+  }
+  await Promise.all(promises);
+}
+
+async function isCliModule(filePath: string): Promise<boolean> {
+  try {
+    const source = await fs.promises.readFile(filePath, 'utf-8');
+    return CLI_MODULE_PATTERN.test(source);
+  } catch (err) {
+    log.warn(`Failed to inspect module ${filePath}: ${getErrorMessage(err)}`);
+    return false;
   }
 }

package/src/doctor.test.ts

@@ -1,9 +1,36 @@
-import { describe, expect, it } from 'vitest';
-import { renderBrowserDoctorReport } from './doctor.js';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockCheckDaemonStatus, mockListSessions, mockConnect, mockClose } = vi.hoisted(() => ({
+  mockCheckDaemonStatus: vi.fn(),
+  mockListSessions: vi.fn(),
+  mockConnect: vi.fn(),
+  mockClose: vi.fn(),
+}));
+
+vi.mock('./browser/discover.js', () => ({
+  checkDaemonStatus: mockCheckDaemonStatus,
+}));
+
+vi.mock('./browser/daemon-client.js', () => ({
+  listSessions: mockListSessions,
+}));
+
+vi.mock('./browser/index.js', () => ({
+  BrowserBridge: class {
+    connect = mockConnect;
+    close = mockClose;
+  },
+}));
+
+import { renderBrowserDoctorReport, runBrowserDoctor } from './doctor.js';
 
 describe('doctor report rendering', () => {
   const strip = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, '');
 
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
   it('renders OK-style report when daemon and extension connected', () => {
     const text = strip(renderBrowserDoctorReport({
       daemonRunning: true,
@@ -59,4 +86,34 @@ describe('doctor report rendering', () => {
 
     expect(text).toContain('[SKIP] Connectivity: not tested (use --live)');
   });
+
+  it('reports consistent status when live check auto-starts the daemon', async () => {
+    // With the reordered flow, checkDaemonStatus is called only ONCE — after
+    // the connectivity check that may auto-start the daemon.
+    mockCheckDaemonStatus.mockResolvedValueOnce({ running: true, extensionConnected: false });
+    mockConnect.mockRejectedValueOnce(new Error(
+      'Daemon is running but the Browser Extension is not connected.\n' +
+      'Please install and enable the opencli Browser Bridge extension in Chrome.',
+    ));
+
+    const report = await runBrowserDoctor({ live: true });
+
+    // Status reflects the post-connectivity state (daemon running)
+    expect(report.daemonRunning).toBe(true);
+    expect(report.extensionConnected).toBe(false);
+    // checkDaemonStatus should only be called once
+    expect(mockCheckDaemonStatus).toHaveBeenCalledTimes(1);
+    // Should NOT report "daemon not running" since it IS running after live check
+    expect(report.issues).not.toContain(
+      expect.stringContaining('Daemon is not running'),
+    );
+    // Should report extension not connected
+    expect(report.issues).toEqual(expect.arrayContaining([
+      expect.stringContaining('Chrome extension is not connected'),
+    ]));
+    // Should report connectivity failure
+    expect(report.issues).toEqual(expect.arrayContaining([
+      expect.stringContaining('Browser connectivity test failed'),
+    ]));
+  });
 });

package/src/doctor.ts

@@ -51,12 +51,14 @@ export async function checkConnectivity(opts?: { timeout?: number }): Promise<Co
 }
 
 export async function runBrowserDoctor(opts: DoctorOptions = {}): Promise<DoctorReport> {
-  const status = await checkDaemonStatus();
-
+  // Run the live connectivity check first — it may auto-start the daemon as a
+  // side-effect, so we read daemon status only *after* all side-effects settle.
   let connectivity: ConnectivityResult | undefined;
   if (opts.live) {
     connectivity = await checkConnectivity();
   }
+
+  const status = await checkDaemonStatus();
   const sessions = opts.sessions && status.running && status.extensionConnected
     ? await listSessions() as Array<{ workspace: string; windowId: number; tabCount: number; idleMsRemaining: number }>
     : undefined;

package/src/engine.test.ts

@@ -1,17 +1,90 @@
-/**
- * Tests for discovery and execution modules.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { discoverClis } from './discovery.js';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { discoverClis, discoverPlugins, PLUGINS_DIR } from './discovery.js';
 import { executeCommand } from './execution.js';
 import { getRegistry, cli, Strategy } from './registry.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
 describe('discoverClis', () => {
   it('handles non-existent directories gracefully', async () => {
     // Should not throw for missing directories
     await expect(discoverClis('/tmp/nonexistent-opencli-test-dir')).resolves.not.toThrow();
   });
+
+  it('imports only CLI command modules during filesystem discovery', async () => {
+    const tempRoot = await fs.promises.mkdtemp(path.join('/tmp', 'opencli-discovery-'));
+    const siteDir = path.join(tempRoot, 'temp-site');
+    const helperPath = path.join(siteDir, 'helper.ts');
+    const commandPath = path.join(siteDir, 'hello.ts');
+
+    try {
+      await fs.promises.mkdir(siteDir, { recursive: true });
+      await fs.promises.writeFile(helperPath, `
+globalThis.__opencli_helper_loaded__ = true;
+export const helper = true;
+`);
+      await fs.promises.writeFile(commandPath, `
+import { cli, Strategy } from '${path.join(process.cwd(), 'src', 'registry.ts')}';
+cli({
+  site: 'temp-site',
+  name: 'hello',
+  description: 'hello command',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  func: async () => [{ ok: true }],
+});
+`);
+
+      delete (globalThis as any).__opencli_helper_loaded__;
+      await discoverClis(tempRoot);
+
+      expect((globalThis as any).__opencli_helper_loaded__).toBeUndefined();
+      expect(getRegistry().get('temp-site/hello')).toBeDefined();
+    } finally {
+      delete (globalThis as any).__opencli_helper_loaded__;
+      await fs.promises.rm(tempRoot, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('discoverPlugins', () => {
+  const testPluginDir = path.join(PLUGINS_DIR, '__test-plugin__');
+  const yamlPath = path.join(testPluginDir, 'greeting.yaml');
+
+  afterEach(async () => {
+    try { await fs.promises.rm(testPluginDir, { recursive: true }); } catch {}
+  });
+
+  it('discovers YAML plugins from ~/.opencli/plugins/', async () => {
+    // Create a simple YAML adapter in the plugins directory
+    await fs.promises.mkdir(testPluginDir, { recursive: true });
+    await fs.promises.writeFile(yamlPath, `
+site: __test-plugin__
+name: greeting
+description: Test plugin greeting
+strategy: public
+browser: false
+
+pipeline:
+  - evaluate: "() => [{ message: 'hello from plugin' }]"
+
+columns: [message]
+`);
+
+    await discoverPlugins();
+
+    const registry = getRegistry();
+    const cmd = registry.get('__test-plugin__/greeting');
+    expect(cmd).toBeDefined();
+    expect(cmd!.site).toBe('__test-plugin__');
+    expect(cmd!.name).toBe('greeting');
+    expect(cmd!.description).toBe('Test plugin greeting');
+  });
+
+  it('handles non-existent plugins directory gracefully', async () => {
+    // discoverPlugins should not throw if ~/.opencli/plugins/ does not exist
+    await expect(discoverPlugins()).resolves.not.toThrow();
+  });
 });
 
 describe('executeCommand', () => {