@jackwener/opencli 1.1.1 → 1.2.0

package/src/browser/index.ts

@@ -9,6 +9,8 @@ export { Page } from './page.js';
 export { BrowserBridge, BrowserBridge as PlaywrightMCP } from './mcp.js';
 export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
+export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
+export type { SnapshotOptions } from './dom-snapshot.js';
 
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
 import { __test__ as cdpTest } from './cdp.js';

package/src/browser/page.ts

@@ -11,9 +11,10 @@
  */
 
 import { formatSnapshot } from '../snapshotFormatter.js';
-import type { IPage } from '../types.js';
+import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
 import { sendCommand } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
+import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 import {
   clickJs,
   typeTextJs,
@@ -69,17 +70,40 @@ export class Page implements IPage {
     }
   }
 
-  async evaluate(js: string): Promise<any> {
+  async evaluate(js: string): Promise<unknown> {
     const code = wrapForEval(js);
     return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
   }
 
-  async getCookies(opts: { domain?: string; url?: string } = {}): Promise<any[]> {
+  async getCookies(opts: { domain?: string; url?: string } = {}): Promise<BrowserCookie[]> {
     const result = await sendCommand('cookies', { ...this._workspaceOpt(), ...opts });
     return Array.isArray(result) ? result : [];
   }
 
-  async snapshot(opts: { interactive?: boolean; compact?: boolean; maxDepth?: number; raw?: boolean } = {}): Promise<any> {
+  async snapshot(opts: SnapshotOptions = {}): Promise<unknown> {
+    // Primary: use the advanced DOM snapshot engine with multi-layer pruning
+    const snapshotJs = generateSnapshotJs({
+      viewportExpand: opts.viewportExpand ?? 800,
+      maxDepth: Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200)),
+      interactiveOnly: opts.interactive ?? false,
+      maxTextLength: opts.maxTextLength ?? 120,
+      includeScrollInfo: true,
+      bboxDedup: true,
+    });
+
+    try {
+      const result = await sendCommand('exec', { code: snapshotJs, ...this._workspaceOpt(), ...this._tabOpt() });
+      // The advanced engine already produces a clean, pruned, LLM-friendly output.
+      // Do NOT pass through formatSnapshot — its format is incompatible.
+      return result;
+    } catch {
+      // Fallback: basic DOM snapshot (original implementation)
+      return this._basicSnapshot(opts);
+    }
+  }
+
+  /** Fallback basic snapshot — original buildTree approach */
+  private async _basicSnapshot(opts: Pick<SnapshotOptions, 'interactive' | 'compact' | 'maxDepth' | 'raw'> = {}): Promise<unknown> {
     const maxDepth = Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200));
     const code = `
       (async () => {
@@ -93,7 +117,7 @@ export class Page implements IPage {
 
           let indent = '  '.repeat(depth);
           let line = indent + role;
-          if (name) line += ' "' + name.replace(/"/g, '\\\\"') + '"';
+          if (name) line += ' "' + name.replace(/"/g, '\\\\\\"') + '"';
           if (node.tagName?.toLowerCase() === 'a' && node.href) line += ' [' + node.href + ']';
           if (node.tagName?.toLowerCase() === 'input') line += ' [' + (node.type || 'text') + ']';
 
@@ -129,7 +153,17 @@ export class Page implements IPage {
     await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
   }
 
-  async wait(options: number | { text?: string; time?: number; timeout?: number }): Promise<void> {
+  async scrollTo(ref: string): Promise<unknown> {
+    const code = scrollToRefJs(ref);
+    return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+  }
+
+  async getFormState(): Promise<Record<string, unknown>> {
+    const code = getFormStateJs();
+    return (await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() })) as Record<string, unknown>;
+  }
+
+  async wait(options: number | WaitOptions): Promise<void> {
     if (typeof options === 'number') {
       await new Promise(resolve => setTimeout(resolve, options * 1000));
       return;
@@ -145,8 +179,9 @@ export class Page implements IPage {
     }
   }
 
-  async tabs(): Promise<any> {
-    return sendCommand('tabs', { op: 'list', ...this._workspaceOpt() });
+  async tabs(): Promise<unknown[]> {
+    const result = await sendCommand('tabs', { op: 'list', ...this._workspaceOpt() });
+    return Array.isArray(result) ? result : [];
   }
 
   async closeTab(index?: number): Promise<void> {
@@ -161,9 +196,10 @@ export class Page implements IPage {
     await sendCommand('tabs', { op: 'select', index, ...this._workspaceOpt() });
   }
 
-  async networkRequests(includeStatic: boolean = false): Promise<any> {
+  async networkRequests(includeStatic: boolean = false): Promise<unknown[]> {
     const code = networkRequestsJs(includeStatic);
-    return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+    const result = await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+    return Array.isArray(result) ? result : [];
   }
 
   /**
@@ -171,7 +207,7 @@ export class Page implements IPage {
    * Would require CDP Runtime.consoleAPICalled event listener.
    * @returns Always returns empty array.
    */
-  async consoleMessages(_level: string = 'info'): Promise<any> {
+  async consoleMessages(_level: string = 'info'): Promise<unknown[]> {
     return [];
   }
 
@@ -182,12 +218,7 @@ export class Page implements IPage {
    * @param options.fullPage - capture full scrollable page
    * @param options.path - save to file path (returns base64 if omitted)
    */
-  async screenshot(options: {
-    format?: 'png' | 'jpeg';
-    quality?: number;
-    fullPage?: boolean;
-    path?: string;
-  } = {}): Promise<string> {
+  async screenshot(options: ScreenshotOptions = {}): Promise<string> {
     const base64 = await sendCommand('screenshot', {
       ...this._workspaceOpt(),
       format: options.format,
@@ -229,11 +260,11 @@ export class Page implements IPage {
     }));
   }
 
-  async getInterceptedRequests(): Promise<any[]> {
+  async getInterceptedRequests(): Promise<unknown[]> {
     const { generateReadInterceptedJs } = await import('../interceptor.js');
     // Same as installInterceptor: must go through evaluate() for IIFE wrapping
     const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
-    return (result as any[]) || [];
+    return Array.isArray(result) ? result : [];
   }
 }
 

package/src/build-manifest.test.ts

@@ -1,5 +1,8 @@
-import { describe, expect, it } from 'vitest';
-import { parseTsArgsBlock } from './build-manifest.js';
+import { afterEach, describe, expect, it } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { parseTsArgsBlock, scanTs, shouldReplaceManifestEntry } from './build-manifest.js';
 
 describe('parseTsArgsBlock', () => {
   it('keeps args with nested choices arrays', () => {
@@ -62,3 +65,68 @@ describe('parseTsArgsBlock', () => {
     ]);
   });
 });
+
+describe('manifest helper rules', () => {
+  const tempDirs: string[] = [];
+
+  afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('prefers TS adapters over duplicate YAML adapters', () => {
+    expect(shouldReplaceManifestEntry(
+      {
+        site: 'demo',
+        name: 'search',
+        description: 'yaml',
+        strategy: 'public',
+        browser: false,
+        args: [],
+        type: 'yaml',
+      },
+      {
+        site: 'demo',
+        name: 'search',
+        description: 'ts',
+        strategy: 'public',
+        browser: false,
+        args: [],
+        type: 'ts',
+        modulePath: 'demo/search.js',
+      },
+    )).toBe(true);
+
+    expect(shouldReplaceManifestEntry(
+      {
+        site: 'demo',
+        name: 'search',
+        description: 'ts',
+        strategy: 'public',
+        browser: false,
+        args: [],
+        type: 'ts',
+        modulePath: 'demo/search.js',
+      },
+      {
+        site: 'demo',
+        name: 'search',
+        description: 'yaml',
+        strategy: 'public',
+        browser: false,
+        args: [],
+        type: 'yaml',
+      },
+    )).toBe(false);
+  });
+
+  it('skips TS files that do not register a cli', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-manifest-'));
+    tempDirs.push(dir);
+    const file = path.join(dir, 'utils.ts');
+    fs.writeFileSync(file, `export function helper() { return 'noop'; }`);
+
+    expect(scanTs(file, 'demo')).toBeNull();
+  });
+});

package/src/build-manifest.ts

@@ -18,7 +18,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CLIS_DIR = path.resolve(__dirname, 'clis');
 const OUTPUT = path.resolve(__dirname, '..', 'dist', 'cli-manifest.json');
 
-interface ManifestEntry {
+export interface ManifestEntry {
   site: string;
   name: string;
   description: string;
@@ -28,19 +28,53 @@ interface ManifestEntry {
   args: Array<{
     name: string;
     type?: string;
-    default?: any;
+    default?: unknown;
     required?: boolean;
     positional?: boolean;
     help?: string;
     choices?: string[];
   }>;
   columns?: string[];
-  pipeline?: any[];
+  pipeline?: Record<string, unknown>[];
   timeout?: number;
   /** 'yaml' or 'ts' — determines how executeCommand loads the handler */
   type: 'yaml' | 'ts';
   /** Relative path from clis/ dir, e.g. 'bilibili/hot.yaml' or 'bilibili/search.js' */
   modulePath?: string;
+  /** Pre-navigation control — see CliCommand.navigateBefore */
+  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;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
 }
 
 function extractBalancedBlock(
@@ -127,7 +161,7 @@ export function parseTsArgsBlock(argsBlock: string): ManifestEntry['args'] {
     const helpMatch = body.match(/help\s*:\s*['"`]([^'"`]*)['"`]/);
     const positionalMatch = body.match(/positional\s*:\s*(true|false)/);
 
-    let defaultVal: any = undefined;
+    let defaultVal: unknown = undefined;
     if (defaultMatch) {
       const raw = defaultMatch[1].trim();
       if (raw === 'true') defaultVal = true;
@@ -156,21 +190,23 @@ export function parseTsArgsBlock(argsBlock: string): ManifestEntry['args'] {
 function scanYaml(filePath: string, site: string): ManifestEntry | null {
   try {
     const raw = fs.readFileSync(filePath, 'utf-8');
-    const def = yaml.load(raw) as any;
-    if (!def || typeof def !== 'object') return null;
+    const def = yaml.load(raw) as YamlCliDefinition | null;
+    if (!isRecord(def)) return null;
+    const cliDef = def as YamlCliDefinition;
 
-    const strategyStr = def.strategy ?? (def.browser === false ? 'public' : 'cookie');
+    const strategyStr = cliDef.strategy ?? (cliDef.browser === false ? 'public' : 'cookie');
     const strategy = strategyStr.toUpperCase();
-    const browser = def.browser ?? (strategy !== 'PUBLIC');
+    const browser = cliDef.browser ?? (strategy !== 'PUBLIC');
 
     const args: ManifestEntry['args'] = [];
-    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',
           default: argDef?.default,
           required: argDef?.required ?? false,
+          positional: argDef?.positional === true || undefined,
           help: argDef?.description ?? argDef?.help ?? '',
           choices: argDef?.choices,
         });
@@ -178,25 +214,26 @@ function scanYaml(filePath: string, site: string): ManifestEntry | null {
     }
 
     return {
-      site: def.site ?? site,
-      name: def.name ?? path.basename(filePath, path.extname(filePath)),
-      description: def.description ?? '',
-      domain: def.domain,
+      site: cliDef.site ?? site,
+      name: cliDef.name ?? path.basename(filePath, path.extname(filePath)),
+      description: cliDef.description ?? '',
+      domain: cliDef.domain,
       strategy: strategy.toLowerCase(),
       browser,
       args,
-      columns: def.columns,
-      pipeline: def.pipeline,
-      timeout: def.timeout,
+      columns: cliDef.columns,
+      pipeline: cliDef.pipeline,
+      timeout: cliDef.timeout,
       type: 'yaml',
+      navigateBefore: cliDef.navigateBefore,
     };
-  } catch (err: any) {
-    process.stderr.write(`Warning: failed to parse ${filePath}: ${err.message}\n`);
+  } catch (err) {
+    process.stderr.write(`Warning: failed to parse ${filePath}: ${getErrorMessage(err)}\n`);
     return null;
   }
 }
 
-function scanTs(filePath: string, site: string): ManifestEntry | null {
+export function scanTs(filePath: string, site: string): ManifestEntry | null {
   // TS adapters self-register via cli() at import time.
   // We statically parse the source to extract metadata for the manifest stub.
   const baseName = path.basename(filePath, path.extname(filePath));
@@ -248,16 +285,29 @@ 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;
+
     return entry;
-  } catch (err: any) {
+  } catch (err) {
     // If parsing fails, log a warning (matching scanYaml behaviour) and skip the entry.
-    process.stderr.write(`Warning: failed to scan ${filePath}: ${err.message}\n`);
+    process.stderr.write(`Warning: failed to scan ${filePath}: ${getErrorMessage(err)}\n`);
     return null;
   }
 }
 
+/**
+ * When both YAML and TS adapters exist for the same site/name,
+ * 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;
+  return current.type === 'yaml' && next.type === 'ts';
+}
+
 export function buildManifest(): ManifestEntry[] {
-  const manifest: ManifestEntry[] = [];
+  const manifest = new Map<string, ManifestEntry>();
 
   if (fs.existsSync(CLIS_DIR)) {
     for (const site of fs.readdirSync(CLIS_DIR)) {
@@ -267,19 +317,37 @@ export function buildManifest(): ManifestEntry[] {
         const filePath = path.join(siteDir, file);
         if (file.endsWith('.yaml') || file.endsWith('.yml')) {
           const entry = scanYaml(filePath, site);
-          if (entry) manifest.push(entry);
+          if (entry) {
+            const key = `${entry.site}/${entry.name}`;
+            const existing = manifest.get(key);
+            if (!existing || shouldReplaceManifestEntry(existing, entry)) {
+              if (existing && existing.type !== entry.type) {
+                process.stderr.write(`⚠️  Duplicate adapter ${key}: ${existing.type} superseded by ${entry.type}\n`);
+              }
+              manifest.set(key, entry);
+            }
+          }
         } else if (
           (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts') && file !== 'index.ts') ||
           (file.endsWith('.js') && !file.endsWith('.d.js') && !file.endsWith('.test.js') && file !== 'index.js')
         ) {
           const entry = scanTs(filePath, site);
-          if (entry) manifest.push(entry);
+          if (entry) {
+            const key = `${entry.site}/${entry.name}`;
+            const existing = manifest.get(key);
+            if (!existing || shouldReplaceManifestEntry(existing, entry)) {
+              if (existing && existing.type !== entry.type) {
+                process.stderr.write(`⚠️  Duplicate adapter ${key}: ${existing.type} superseded by ${entry.type}\n`);
+              }
+              manifest.set(key, entry);
+            }
+          }
         }
       }
     }
   }
 
-  return manifest;
+  return [...manifest.values()];
 }
 
 function main(): void {

package/src/cli.ts

@@ -140,7 +140,7 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
         : undefined;
       const workspace = `explore:${inferHost(url, opts.site)}`;
       const result = await exploreUrl(url, {
-        BrowserFactory: getBrowserFactory() as any,
+        BrowserFactory: getBrowserFactory(),
         site: opts.site,
         goal: opts.goal,
         waitSeconds: parseFloat(opts.wait),
@@ -172,7 +172,7 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       const workspace = `generate:${inferHost(url, opts.site)}`;
       const r = await generateCliFromUrl({
         url,
-        BrowserFactory: getBrowserFactory() as any,
+        BrowserFactory: getBrowserFactory(),
         builtinClis: BUILTIN_CLIS,
         userClis: USER_CLIS,
         goal: opts.goal,
@@ -231,6 +231,75 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       printCompletionScript(shell);
     });
 
+  // ── Plugin management ──────────────────────────────────────────────────────
+
+  const pluginCmd = program.command('plugin').description('Manage opencli plugins');
+
+  pluginCmd
+    .command('install')
+    .description('Install a plugin from GitHub')
+    .argument('<source>', 'Plugin source (e.g. github:user/repo)')
+    .action(async (source: string) => {
+      const { installPlugin } = await import('./plugin.js');
+      try {
+        const name = installPlugin(source);
+        console.log(chalk.green(`✅ Plugin "${name}" installed successfully.`));
+        console.log(chalk.dim(`   Restart opencli to use the new commands.`));
+      } catch (err: any) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  pluginCmd
+    .command('uninstall')
+    .description('Uninstall a plugin')
+    .argument('<name>', 'Plugin name')
+    .action(async (name: string) => {
+      const { uninstallPlugin } = await import('./plugin.js');
+      try {
+        uninstallPlugin(name);
+        console.log(chalk.green(`✅ Plugin "${name}" uninstalled.`));
+      } catch (err: any) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  pluginCmd
+    .command('list')
+    .description('List installed plugins')
+    .option('-f, --format <fmt>', 'Output format: table, json', 'table')
+    .action(async (opts) => {
+      const { listPlugins } = await import('./plugin.js');
+      const plugins = listPlugins();
+      if (plugins.length === 0) {
+        console.log(chalk.dim('  No plugins installed.'));
+        console.log(chalk.dim(`  Install one with: opencli plugin install github:user/repo`));
+        return;
+      }
+      if (opts.format === 'json') {
+        renderOutput(plugins, {
+          fmt: 'json',
+          columns: ['name', 'commands', 'source'],
+          title: 'opencli/plugins',
+          source: 'opencli plugin list',
+        });
+        return;
+      }
+      console.log();
+      console.log(chalk.bold('  Installed plugins'));
+      console.log();
+      for (const p of plugins) {
+        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();
+      console.log(chalk.dim(`  ${plugins.length} plugin(s) installed`));
+      console.log();
+    });
+
   // ── External CLIs ─────────────────────────────────────────────────────────
 
   const externalClis = loadExternalClis();

package/src/clis/barchart/greeks.ts

@@ -12,7 +12,7 @@ cli({
   domain: 'www.barchart.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'symbol', required: true, help: 'Stock ticker (e.g. AAPL)' },
+    { name: 'symbol', required: true, positional: true, help: 'Stock ticker (e.g. AAPL)' },
     { name: 'expiration', type: 'str', help: 'Expiration date (YYYY-MM-DD). Defaults to the nearest available expiration.' },
     { name: 'limit', type: 'int', default: 10, help: 'Number of near-the-money strikes per type' },
   ],

package/src/clis/barchart/options.ts

@@ -11,7 +11,7 @@ cli({
   domain: 'www.barchart.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'symbol', required: true, help: 'Stock ticker (e.g. AAPL)' },
+    { name: 'symbol', required: true, positional: true, help: 'Stock ticker (e.g. AAPL)' },
     { name: 'type', type: 'str', default: 'Call', help: 'Option type: Call or Put', choices: ['Call', 'Put'] },
     { name: 'limit', type: 'int', default: 20, help: 'Max number of strikes to return' },
   ],

package/src/clis/barchart/quote.ts

@@ -11,7 +11,7 @@ cli({
   domain: 'www.barchart.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', 'changePct',

package/src/clis/bilibili/download.ts

@@ -28,7 +28,7 @@ cli({
   domain: 'www.bilibili.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'bvid', required: true, help: 'Video BV ID (e.g., BV1xxx)' },
+    { name: 'bvid', required: true, positional: true, help: 'Video BV ID (e.g., BV1xxx)' },
     { name: 'output', default: './bilibili-downloads', help: 'Output directory' },
     { name: 'quality', default: 'best', help: 'Video quality (best, 1080p, 720p, 480p)' },
   ],

package/src/clis/bilibili/following.ts

@@ -8,7 +8,7 @@ cli({
   description: '获取 Bilibili 用户的关注列表',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'uid', required: false, help: '目标用户 ID（默认为当前登录用户）' },
+    { name: 'uid', positional: true, required: false, help: '目标用户 ID（默认为当前登录用户）' },
     { name: 'page', type: 'int', required: false, default: 1, help: '页码' },
     { name: 'limit', type: 'int', required: false, default: 50, help: '每页数量 (最大 50)' },
   ],

package/src/clis/bilibili/subtitle.ts

@@ -8,7 +8,7 @@ cli({
   description: '获取 Bilibili 视频的字幕',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'bvid', required: true },
+    { name: 'bvid', required: true, positional: true },
     { name: 'lang', required: false, help: '字幕语言代码 (如 zh-CN, en-US, ai-zh)，默认取第一个' },
   ],
   columns: ['index', 'from', 'to', 'content'],

package/src/clis/bilibili/user-videos.ts

@@ -8,7 +8,7 @@ cli({
   domain: 'www.bilibili.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'uid', required: true, help: 'User UID or username' },
+    { name: 'uid', required: true, positional: true, help: 'User UID or username' },
     { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
     { name: 'order', default: 'pubdate', help: 'Sort: pubdate, click, stow' },
     { name: 'page', type: 'int', default: 1, help: 'Page number' },