@jackwener/opencli 1.3.3 → 1.4.0

package/src/browser/stealth.ts

@@ -9,9 +9,6 @@
  * Inspired by puppeteer-extra-plugin-stealth.
  */
 
-/** Guard flag set on `window` to prevent double-injection. */
-export const STEALTH_GUARD = '__opencli_stealth_applied';
-
 /**
  * Return a self-contained JS string that, when evaluated in a page context,
  * applies all stealth patches. Safe to call multiple times — the guard flag
@@ -20,16 +17,25 @@ export const STEALTH_GUARD = '__opencli_stealth_applied';
 export function generateStealthJs(): string {
   return `
     (() => {
-      // Guard: skip if already applied
-      if (window.${STEALTH_GUARD}) return 'skipped';
-      // Use defineProperty so the guard flag is non-enumerable (not a detection vector).
-      Object.defineProperty(window, '${STEALTH_GUARD}', { value: true, configurable: true });
+      // Guard: prevent double-injection across separate CDP evaluations.
+      // We cannot use a closure variable (each eval is a fresh scope), and
+      // window properties / Symbols are discoverable by anti-bot scripts.
+      // Instead, stash the flag in a non-enumerable getter on a built-in
+      // prototype that fingerprinters are unlikely to scan.
+      const _gProto = EventTarget.prototype;
+      const _gKey = '__lsn';  // looks like an internal listener cache
+      if (_gProto[_gKey]) return 'skipped';
+      try {
+        Object.defineProperty(_gProto, _gKey, { value: true, enumerable: false, configurable: true });
+      } catch {}
 
-      // 1. navigator.webdriver → undefined
+      // 1. navigator.webdriver → false
       //    Most common check; Playwright/Puppeteer/CDP set this to true.
+      //    Real Chrome returns false (not undefined) — returning undefined is
+      //    itself a detection signal for advanced fingerprinters.
       try {
         Object.defineProperty(navigator, 'webdriver', {
-          get: () => undefined,
+          get: () => false,
           configurable: true,
         });
       } catch {}
@@ -119,9 +125,17 @@ export function generateStealthJs(): string {
       //    We override the stack property getter on Error.prototype to filter them.
       //    Note: Error.prepareStackTrace is V8/Node-only and not available in
       //    browser page context, so we use a property descriptor approach instead.
+      //    We use generic protocol patterns instead of product-specific names to
+      //    also catch our own injected code frames without leaking identifiers.
       try {
         const _origDescriptor = Object.getOwnPropertyDescriptor(Error.prototype, 'stack');
-        const _cdpPatterns = ['puppeteer_evaluation_script', 'pptr:', 'debugger://', '__opencli'];
+        const _cdpPatterns = [
+          'puppeteer_evaluation_script',
+          'pptr:',
+          'debugger://',
+          '__playwright',
+          '__puppeteer',
+        ];
         if (_origDescriptor && _origDescriptor.get) {
           Object.defineProperty(Error.prototype, 'stack', {
             get: function () {

package/src/browser.test.ts

@@ -1,6 +1,5 @@
 import { afterEach, describe, it, expect, vi } from 'vitest';
 import { BrowserBridge, __test__, generateStealthJs } from './browser/index.js';
-import { STEALTH_GUARD } from './browser/stealth.js';
 import * as daemonClient from './browser/daemon-client.js';
 
 describe('browser helpers', () => {
@@ -170,7 +169,8 @@ describe('stealth anti-detection', () => {
 
   it('includes guard flag to prevent double-injection', () => {
     const js = generateStealthJs();
-    expect(js).toContain(STEALTH_GUARD);
+    // Guard uses a non-enumerable property on a built-in prototype
+    expect(js).toContain("EventTarget.prototype");
     // Guard should check early and return 'skipped'
     expect(js).toContain("return 'skipped'");
     // Normal path returns 'applied'

package/src/build-manifest.test.ts

@@ -129,4 +129,18 @@ describe('manifest helper rules', () => {
 
     expect(scanTs(file, 'demo')).toBeNull();
   });
+
+  it('keeps literal domain and navigateBefore for TS adapters', () => {
+    const file = path.join(process.cwd(), 'src', 'clis', 'xueqiu', 'fund-holdings.ts');
+    const entry = scanTs(file, 'xueqiu');
+
+    expect(entry).toMatchObject({
+      site: 'xueqiu',
+      name: 'fund-holdings',
+      domain: 'danjuanfunds.com',
+      navigateBefore: 'https://danjuanfunds.com/my-money',
+      type: 'ts',
+      modulePath: 'xueqiu/fund-holdings.js',
+    });
+  });
 });

package/src/build-manifest.ts

@@ -46,33 +46,9 @@ export interface ManifestEntry {
   navigateBefore?: boolean | string;
 }
 
-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;
-}
+import type { YamlCliDefinition } from './yaml-schema.js';
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+import { isRecord } from './utils.js';
 
 
 function extractBalancedBlock(
@@ -179,7 +155,8 @@ export function parseTsArgsBlock(argsBlock: string): ManifestEntry['args'] {
       choices: parseInlineChoices(body),
     });
 
-    cursor = objectStart + body.length + 2;
+    cursor = objectStart + body.length;
+    if (cursor <= objectStart) break; // safety: prevent infinite loop
   }
 
   return args;
@@ -283,9 +260,14 @@ export function scanTs(filePath: string, site: string): ManifestEntry | null {
       entry.args = parseTsArgsBlock(argsBlock);
     }
 
-    // Extract navigateBefore: false
-    const navMatch = src.match(/navigateBefore\s*:\s*(true|false)/);
-    if (navMatch) entry.navigateBefore = navMatch[1] === 'true' ? true : false;
+    // Extract navigateBefore: false / true / 'https://...'
+    const navBoolMatch = src.match(/navigateBefore\s*:\s*(true|false)/);
+    if (navBoolMatch) {
+      entry.navigateBefore = navBoolMatch[1] === 'true';
+    } else {
+      const navStringMatch = src.match(/navigateBefore\s*:\s*['"`]([^'"`]+)['"`]/);
+      if (navStringMatch) entry.navigateBefore = navStringMatch[1];
+    }
 
     return entry;
   } catch (err) {
@@ -300,7 +282,7 @@ export function scanTs(filePath: string, site: string): ManifestEntry | null {
  * prefer the TS version (it self-registers and typically has richer logic).
  */
 export function shouldReplaceManifestEntry(current: ManifestEntry, next: ManifestEntry): boolean {
-  if (current.type === next.type) return true;
+  if (current.type === next.type) return false;
   return current.type === 'yaml' && next.type === 'ts';
 }
 

package/src/cascade.ts

@@ -12,6 +12,7 @@
 
 import { Strategy } from './registry.js';
 import type { IPage } from './types.js';
+import { getErrorMessage } from './errors.js';
 
 /** Strategy cascade order (simplest → most complex) */
 const CASCADE_ORDER: Strategy[] = [
@@ -128,9 +129,9 @@ export async function probeEndpoint(
         result.error = `Strategy ${strategy} requires site-specific implementation`;
         break;
     }
-  } catch (err: any) {
+  } catch (err) {
     result.success = false;
-    result.error = err.message ?? String(err);
+    result.error = getErrorMessage(err);
   }
 
   return result;
@@ -145,9 +146,10 @@ export async function cascadeProbe(
   url: string,
   opts: { maxStrategy?: Strategy; timeout?: number } = {},
 ): Promise<CascadeResult> {
-  const maxIdx = opts.maxStrategy
+  const rawIdx = opts.maxStrategy
     ? CASCADE_ORDER.indexOf(opts.maxStrategy)
     : CASCADE_ORDER.indexOf(Strategy.HEADER); // Don't auto-try INTERCEPT/UI
+  const maxIdx = rawIdx === -1 ? CASCADE_ORDER.indexOf(Strategy.HEADER) : rawIdx;
 
   const probes: ProbeResult[] = [];
 

package/src/cli.ts

@@ -15,6 +15,7 @@ import { PKG_VERSION } from './version.js';
 import { printCompletionScript } from './completion.js';
 import { loadExternalClis, executeExternalCli, installExternalCli, registerExternalCli, isBinaryInstalled } from './external.js';
 import { registerAllCommands } from './commanderAdapter.js';
+import { getErrorMessage } from './errors.js';
 
 export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
   const program = new Command();
@@ -173,8 +174,6 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       const r = await generateCliFromUrl({
         url,
         BrowserFactory: getBrowserFactory(),
-        builtinClis: BUILTIN_CLIS,
-        userClis: USER_CLIS,
         goal: opts.goal,
         site: opts.site,
         workspace,
@@ -262,8 +261,8 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
         const name = installPlugin(source);
         await discoverPlugins();
         console.log(chalk.green(`✅ Plugin "${name}" installed successfully. Commands are ready to use.`));
-      } catch (err: any) {
-        console.error(chalk.red(`Error: ${err.message}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${getErrorMessage(err)}`));
         process.exitCode = 1;
       }
     });
@@ -277,25 +276,69 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       try {
         uninstallPlugin(name);
         console.log(chalk.green(`✅ Plugin "${name}" uninstalled.`));
-      } catch (err: any) {
-        console.error(chalk.red(`Error: ${err.message}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${getErrorMessage(err)}`));
         process.exitCode = 1;
       }
     });
 
   pluginCmd
     .command('update')
-    .description('Update a plugin to the latest version')
-    .argument('<name>', 'Plugin name')
-    .action(async (name: string) => {
-      const { updatePlugin } = await import('./plugin.js');
+    .description('Update a plugin (or all plugins) to the latest version')
+    .argument('[name]', 'Plugin name (required unless --all is passed)')
+    .option('--all', 'Update all installed plugins')
+    .action(async (name: string | undefined, opts: { all?: boolean }) => {
+      if (!name && !opts.all) {
+        console.error(chalk.red('Error: Please specify a plugin name or use the --all flag.'));
+        process.exitCode = 1;
+        return;
+      }
+      if (name && opts.all) {
+        console.error(chalk.red('Error: Cannot specify both a plugin name and --all.'));
+        process.exitCode = 1;
+        return;
+      }
+
+      const { updatePlugin, updateAllPlugins } = await import('./plugin.js');
       const { discoverPlugins } = await import('./discovery.js');
+      if (opts.all) {
+        const results = updateAllPlugins();
+        if (results.length > 0) {
+          await discoverPlugins();
+        }
+
+        let hasErrors = false;
+        console.log(chalk.bold('  Update Results:'));
+        for (const result of results) {
+          if (result.success) {
+            console.log(`  ${chalk.green('✓')} ${result.name}`);
+            continue;
+          }
+          hasErrors = true;
+          console.log(`  ${chalk.red('✗')} ${result.name} — ${chalk.dim(result.error)}`);
+        }
+
+        if (results.length === 0) {
+          console.log(chalk.dim('  No plugins installed.'));
+          return;
+        }
+
+        console.log();
+        if (hasErrors) {
+          console.error(chalk.red('Completed with some errors.'));
+          process.exitCode = 1;
+        } else {
+          console.log(chalk.green('✅ All plugins updated successfully.'));
+        }
+        return;
+      }
+
       try {
-        updatePlugin(name);
+        updatePlugin(name!);
         await discoverPlugins();
         console.log(chalk.green(`✅ Plugin "${name}" updated successfully.`));
-      } catch (err: any) {
-        console.error(chalk.red(`Error: ${err.message}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${getErrorMessage(err)}`));
         process.exitCode = 1;
       }
     });
@@ -326,9 +369,10 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       console.log(chalk.bold('  Installed plugins'));
       console.log();
       for (const p of plugins) {
+        const version = p.version ? chalk.green(` @${p.version}`) : '';
         const cmds = p.commands.length > 0 ? chalk.dim(` (${p.commands.join(', ')})`) : '';
         const src = p.source ? chalk.dim(` ← ${p.source}`) : '';
-        console.log(`  ${chalk.cyan(p.name)}${cmds}${src}`);
+        console.log(`  ${chalk.cyan(p.name)}${version}${cmds}${src}`);
       }
       console.log();
       console.log(chalk.dim(`  ${plugins.length} plugin(s) installed`));
@@ -371,8 +415,8 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
     })();
     try {
       executeExternalCli(name, args, externalClis);
-    } catch (err: any) {
-      console.error(chalk.red(`Error: ${err.message}`));
+    } catch (err) {
+      console.error(chalk.red(`Error: ${getErrorMessage(err)}`));
       process.exitCode = 1;
     }
   }
@@ -408,29 +452,17 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
   registerAllCommands(program, siteGroups);
 
   // ── Unknown command fallback ──────────────────────────────────────────────
-
-  const DENY_LIST = new Set([
-    'rm', 'sudo', 'dd', 'mkfs', 'fdisk', 'shutdown', 'reboot',
-    'kill', 'killall', 'chmod', 'chown', 'passwd', 'su', 'mount',
-    'umount', 'format', 'diskutil',
-  ]);
+  // Security: do NOT auto-discover and register arbitrary system binaries.
+  // Only explicitly registered external CLIs (via `opencli register`) are allowed.
 
   program.on('command:*', (operands: string[]) => {
     const binary = operands[0];
-    if (DENY_LIST.has(binary)) {
-      console.error(chalk.red(`Refusing to register system command '${binary}'.`));
-      process.exitCode = 1;
-      return;
-    }
+    console.error(chalk.red(`error: unknown command '${binary}'`));
     if (isBinaryInstalled(binary)) {
-      console.log(chalk.cyan(`🔹 Auto-discovered local CLI '${binary}'. Registering...`));
-      registerExternalCli(binary);
-      passthroughExternal(binary);
-    } else {
-      console.error(chalk.red(`error: unknown command '${binary}'`));
-      program.outputHelp();
-      process.exitCode = 1;
+      console.error(chalk.dim(`  Tip: '${binary}' exists on your PATH. Use 'opencli register ${binary}' to add it as an external CLI.`));
     }
+    program.outputHelp();
+    process.exitCode = 1;
   });
 
   program.parse();

package/src/clis/_shared/desktop-commands.ts

@@ -0,0 +1,121 @@
+/**
+ * Shared command factories for Electron/desktop app adapters.
+ * Eliminates duplicate screenshot/status/new/dump implementations
+ * across cursor, codex, chatwise, etc.
+ */
+
+import * as fs from 'node:fs';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import type { CliOptions } from '../../registry.js';
+
+/**
+ * Factory: capture DOM HTML + accessibility snapshot.
+ */
+export function makeScreenshotCommand(site: string, displayName?: string, extra: Partial<CliOptions> = {}) {
+  const label = displayName ?? site;
+  return cli({
+    ...extra,
+    site,
+    name: 'screenshot',
+    description: `Capture a snapshot of the current ${label} window (DOM + Accessibility tree)`,
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+      { name: 'output', required: false, help: `Output file path (default: /tmp/${site}-snapshot.txt)` },
+    ],
+    columns: ['Status', 'File'],
+    func: async (page: IPage, kwargs: any) => {
+      const outputPath = (kwargs.output as string) || `/tmp/${site}-snapshot.txt`;
+
+      const snap = await page.snapshot({ compact: true });
+      const html = await page.evaluate('document.documentElement.outerHTML');
+
+      const htmlPath = outputPath.replace(/\.\w+$/, '') + '-dom.html';
+      const snapPath = outputPath.replace(/\.\w+$/, '') + '-a11y.txt';
+
+      fs.writeFileSync(htmlPath, html);
+      fs.writeFileSync(snapPath, typeof snap === 'string' ? snap : JSON.stringify(snap, null, 2));
+
+      return [
+        { Status: 'Success', File: htmlPath },
+        { Status: 'Success', File: snapPath },
+      ];
+    },
+  });
+}
+
+/**
+ * Factory: check CDP connection status.
+ */
+export function makeStatusCommand(site: string, displayName?: string, extra: Partial<CliOptions> = {}) {
+  const label = displayName ?? site;
+  return cli({
+    ...extra,
+    site,
+    name: 'status',
+    description: `Check active CDP connection to ${label}`,
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    columns: ['Status', 'Url', 'Title'],
+    func: async (page: IPage) => {
+      const url = await page.evaluate('window.location.href');
+      const title = await page.evaluate('document.title');
+      return [{ Status: 'Connected', Url: url, Title: title }];
+    },
+  });
+}
+
+/**
+ * Factory: start a new session via Cmd/Ctrl+N.
+ */
+export function makeNewCommand(site: string, displayName?: string, extra: Partial<CliOptions> = {}) {
+  const label = displayName ?? site;
+  return cli({
+    ...extra,
+    site,
+    name: 'new',
+    description: `Start a new ${label} session`,
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    columns: ['Status'],
+    func: async (page: IPage) => {
+      const isMac = process.platform === 'darwin';
+      await page.pressKey(isMac ? 'Meta+N' : 'Control+N');
+      await page.wait(1);
+      return [{ Status: 'Success' }];
+    },
+  });
+}
+
+/**
+ * Factory: dump DOM + snapshot for reverse-engineering.
+ */
+export function makeDumpCommand(site: string) {
+  return cli({
+    site,
+    name: 'dump',
+    description: `Dump the DOM and Accessibility tree of ${site} for reverse-engineering`,
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    columns: ['action', 'files'],
+    func: async (page: IPage) => {
+      const dom = await page.evaluate('document.body.innerHTML');
+      fs.writeFileSync(`/tmp/${site}-dom.html`, dom);
+
+      const snap = await page.snapshot({ interactive: false });
+      fs.writeFileSync(`/tmp/${site}-snapshot.json`, JSON.stringify(snap, null, 2));
+
+      return [
+        {
+          action: 'Dom extraction finished',
+          files: `/tmp/${site}-dom.html, /tmp/${site}-snapshot.json`,
+        },
+      ];
+    },
+  });
+}

package/src/clis/antigravity/serve.ts

@@ -13,6 +13,7 @@
 import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
 import { CDPBridge } from '../../browser/cdp.js';
 import type { IPage } from '../../types.js';
+import { getErrorMessage } from '../../errors.js';
 
 // ─── Types ───────────────────────────────────────────────────────────
 
@@ -461,15 +462,17 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
     cdp = new CDPBridge();
     try {
       page = await cdp.connect({ timeout: 15_000 });
-    } catch (err: any) {
+    } catch (err: unknown) {
       cdp = null;
-      const isRefused = err?.cause?.code === 'ECONNREFUSED' || err?.message?.includes('ECONNREFUSED');
+      const errMsg = getErrorMessage(err);
+      const cause = err instanceof Error ? (err.cause as Record<string, unknown> | undefined) : undefined;
+      const isRefused = cause?.code === 'ECONNREFUSED' || errMsg.includes('ECONNREFUSED');
       throw new Error(
         isRefused
           ? `Cannot connect to Antigravity at ${endpoint}.\n` +
             '  1. Make sure Antigravity is running\n' +
             '  2. Launch with: --remote-debugging-port=9224'
-          : `CDP connection failed: ${err.message}`
+          : `CDP connection failed: ${errMsg}`
       );
     }
 

package/src/clis/arxiv/search.ts

@@ -15,7 +15,7 @@ cli({
   columns: ['id', 'title', 'authors', 'published'],
   func: async (_page, args) => {
     const limit = Math.max(1, Math.min(Number(args.limit), 25));
-    const query = encodeURIComponent(`all:${args.keyword}`);
+    const query = encodeURIComponent(`all:${args.query}`);
     const xml = await arxivFetch(`search_query=${query}&max_results=${limit}&sortBy=relevance`);
     const entries = parseEntries(xml);
     if (!entries.length) throw new CliError('NOT_FOUND', 'No papers found', 'Try a different keyword');

package/src/clis/bilibili/dynamic.test.ts

@@ -0,0 +1,79 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockApiGet } = vi.hoisted(() => ({
+  mockApiGet: vi.fn(),
+}));
+
+vi.mock('./utils.js', () => ({
+  apiGet: mockApiGet,
+}));
+
+import { getRegistry } from '../../registry.js';
+import './dynamic.js';
+
+describe('bilibili dynamic adapter', () => {
+  const command = getRegistry().get('bilibili/dynamic');
+
+  beforeEach(() => {
+    mockApiGet.mockReset();
+  });
+
+  it('maps desc text rows from the dynamic feed payload', async () => {
+    mockApiGet.mockResolvedValue({
+      data: {
+        items: [
+          {
+            id_str: '123',
+            modules: {
+              module_author: { name: 'Alice' },
+              module_dynamic: { desc: { text: 'hello world' } },
+              module_stat: { like: { count: 9 } },
+            },
+          },
+        ],
+      },
+    });
+
+    const result = await command!.func!({} as any, { limit: 5 });
+
+    expect(mockApiGet).toHaveBeenCalledWith({}, '/x/polymer/web-dynamic/v1/feed/all', { params: {}, signed: false });
+    expect(result).toEqual([
+      {
+        id: '123',
+        author: 'Alice',
+        text: 'hello world',
+        likes: 9,
+        url: 'https://t.bilibili.com/123',
+      },
+    ]);
+  });
+
+  it('falls back to archive title when desc text is absent', async () => {
+    mockApiGet.mockResolvedValue({
+      data: {
+        items: [
+          {
+            id_str: '456',
+            modules: {
+              module_author: { name: 'Bob' },
+              module_dynamic: { major: { archive: { title: 'Video title' } } },
+              module_stat: { like: { count: 3 } },
+            },
+          },
+        ],
+      },
+    });
+
+    const result = await command!.func!({} as any, { limit: 5 });
+
+    expect(result).toEqual([
+      {
+        id: '456',
+        author: 'Bob',
+        text: 'Video title',
+        likes: 3,
+        url: 'https://t.bilibili.com/456',
+      },
+    ]);
+  });
+});

package/src/clis/bilibili/favorite.ts

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { apiGet, payloadData } from './utils.js';
+import { apiGet, payloadData, getSelfUid } from './utils.js';
 
 cli({
   site: 'bilibili',
@@ -15,9 +15,12 @@ cli({
   func: async (page, kwargs) => {
     const { limit = 20, page: pageNum = 1 } = kwargs;
 
+    // Get current user's UID
+    const uid = await getSelfUid(page);
+
     // Get default favorite folder ID
     const foldersPayload = await apiGet(page, '/x/v3/fav/folder/created/list-all', {
-      params: { up_mid: 0 },
+      params: { up_mid: uid },
       signed: true,
     });
     const folders = payloadData(foldersPayload)?.list ?? [];

package/src/clis/bilibili/following.ts

@@ -1,4 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
 import type { IPage } from '../../types.js';
 import { fetchJson, getSelfUid, resolveUid } from './utils.js';
 
@@ -14,7 +15,7 @@ cli({
   ],
   columns: ['mid', 'name', 'sign', 'following', 'fans'],
   func: async (page: IPage | null, kwargs: any) => {
-    if (!page) throw new Error('Requires browser');
+    if (!page) throw new CommandExecutionError('Browser session required for bilibili following');
 
     // 1. Resolve UID (default to self)
     const uid = kwargs.uid
@@ -30,7 +31,7 @@ cli({
     );
 
     if (payload.code !== 0) {
-      throw new Error(`获取关注列表失败: ${payload.message} (${payload.code})`);
+      throw new CommandExecutionError(`获取关注列表失败: ${payload.message} (${payload.code})`);
     }
 
     const list = payload.data?.list || [];