@jackwener/opencli 1.4.1 → 1.5.1

package/src/registry.ts

@@ -46,6 +46,10 @@ export interface CliCommand {
   source?: string;
   footerExtra?: (kwargs: CommandArgs) => string | undefined;
   requiredEnv?: RequiredEnv[];
+  /** Deprecation note shown in help / execution warnings. */
+  deprecated?: boolean | string;
+  /** Preferred replacement command, if any. */
+  replacedBy?: string;
   /**
    * Control pre-navigation for cookie/header context before command execution.
    *
@@ -95,6 +99,8 @@ export function cli(opts: CliOptions): CliCommand {
     timeoutSeconds: opts.timeoutSeconds,
     footerExtra: opts.footerExtra,
     requiredEnv: opts.requiredEnv,
+    deprecated: opts.deprecated,
+    replacedBy: opts.replacedBy,
     navigateBefore: opts.navigateBefore,
   };
 
@@ -118,4 +124,3 @@ export function strategyLabel(cmd: CliCommand): string {
 export function registerCommand(cmd: CliCommand): void {
   _registry.set(fullName(cmd), cmd);
 }
-

package/src/runtime-detect.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { detectRuntime, getRuntimeVersion, getRuntimeLabel } from './runtime-detect.js';
+
+describe('runtime-detect', () => {
+  it('detectRuntime returns a valid runtime string', () => {
+    const rt = detectRuntime();
+    expect(['bun', 'node']).toContain(rt);
+  });
+
+  it('getRuntimeVersion returns a non-empty version string', () => {
+    const ver = getRuntimeVersion();
+    expect(typeof ver).toBe('string');
+    expect(ver.length).toBeGreaterThan(0);
+  });
+
+  it('getRuntimeLabel returns "<runtime> <version>" format', () => {
+    const label = getRuntimeLabel();
+    expect(label).toMatch(/^(bun|node) .+$/);
+  });
+
+  it('detects the current environment correctly', () => {
+    const isBun = typeof (globalThis as any).Bun !== 'undefined';
+    const rt = detectRuntime();
+    if (isBun) {
+      expect(rt).toBe('bun');
+    } else {
+      expect(rt).toBe('node');
+    }
+  });
+});

package/src/runtime-detect.ts

@@ -0,0 +1,36 @@
+/**
+ * Runtime detection — identify whether opencli is running under Node.js or Bun.
+ *
+ * Bun injects `globalThis.Bun` at startup, making detection trivial.
+ * This module centralises the check so other code can adapt behaviour
+ * (e.g. logging, diagnostics) without littering runtime sniffing everywhere.
+ */
+
+export type Runtime = 'bun' | 'node';
+
+/**
+ * Detect the current JavaScript runtime.
+ */
+export function detectRuntime(): Runtime {
+  // Bun always exposes globalThis.Bun (including Bun.version)
+  if (typeof (globalThis as any).Bun !== 'undefined') return 'bun';
+  return 'node';
+}
+
+/**
+ * Return a human-readable version string for the current runtime.
+ * Examples: "v22.13.0" (Node), "1.1.42" (Bun)
+ */
+export function getRuntimeVersion(): string {
+  if (detectRuntime() === 'bun') {
+    return (globalThis as any).Bun.version as string;
+  }
+  return process.version; // e.g. "v22.13.0"
+}
+
+/**
+ * Return a combined label like "node v22.13.0" or "bun 1.1.42".
+ */
+export function getRuntimeLabel(): string {
+  return `${detectRuntime()} ${getRuntimeVersion()}`;
+}

package/src/runtime.ts

@@ -7,7 +7,7 @@ import { TimeoutError } from './errors.js';
  * Uses CDPBridge when OPENCLI_CDP_ENDPOINT is set, otherwise BrowserBridge.
  */
 export function getBrowserFactory(): new () => IBrowserFactory {
-  return (process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge) as unknown as new () => IBrowserFactory;
+  return process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge;
 }
 
 function parseEnvTimeout(envVar: string, fallback: number): number {
@@ -30,11 +30,11 @@ export const DEFAULT_BROWSER_EXPLORE_TIMEOUT = parseEnvTimeout('OPENCLI_BROWSER_
  */
 export async function runWithTimeout<T>(
   promise: Promise<T>,
-  opts: { timeout: number; label?: string },
+  opts: { timeout: number; label?: string; hint?: string },
 ): Promise<T> {
   const label = opts.label ?? 'Operation';
   return withTimeoutMs(promise, opts.timeout * 1000,
-    () => new TimeoutError(label, opts.timeout));
+    () => new TimeoutError(label, opts.timeout, opts.hint));
 }
 
 /**

package/src/serialization.ts

@@ -45,6 +45,8 @@ export function serializeCommand(cmd: CliCommand) {
     args: cmd.args.map(serializeArg),
     columns: cmd.columns ?? [],
     domain: cmd.domain ?? null,
+    deprecated: cmd.deprecated ?? null,
+    replacedBy: cmd.replacedBy ?? null,
   };
 }
 
@@ -73,6 +75,8 @@ export function formatRegistryHelpText(cmd: CliCommand): string {
   meta.push(`Strategy: ${strategyLabel(cmd)}`);
   meta.push(`Browser: ${cmd.browser ? 'yes' : 'no'}`);
   if (cmd.domain) meta.push(`Domain: ${cmd.domain}`);
+  if (cmd.deprecated) meta.push(`Deprecated: ${typeof cmd.deprecated === 'string' ? cmd.deprecated : 'yes'}`);
+  if (cmd.replacedBy) meta.push(`Use instead: ${cmd.replacedBy}`);
   lines.push(meta.join(' | '));
   if (cmd.columns?.length) lines.push(`Output columns: ${cmd.columns.join(', ')}`);
   return '\n' + lines.join('\n') + '\n';

package/src/types.ts

@@ -65,4 +65,7 @@ export interface IPage {
   installInterceptor(pattern: string): Promise<void>;
   getInterceptedRequests(): Promise<any[]>;
   screenshot(options?: ScreenshotOptions): Promise<string>;
+  closeWindow?(): Promise<void>;
+  /** Returns the current page URL, or null if unavailable. */
+  getCurrentUrl?(): Promise<string | null>;
 }

package/src/update-check.ts

@@ -0,0 +1,114 @@
+/**
+ * Non-blocking update checker.
+ *
+ * Pattern: register exit-hook + kick-off-background-fetch
+ * - On startup: kick off background fetch (non-blocking)
+ * - On process exit: read cache, print notice if newer version exists
+ * - Check interval: 24 hours
+ * - Notice appears AFTER command output, not before (same as npm/gh/yarn)
+ * - Never delays or blocks the CLI command
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import chalk from 'chalk';
+import { PKG_VERSION } from './version.js';
+
+const CACHE_DIR = path.join(os.homedir(), '.opencli');
+const CACHE_FILE = path.join(CACHE_DIR, 'update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24h
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@jackwener/opencli/latest';
+
+interface UpdateCache {
+  lastCheck: number;
+  latestVersion: string;
+}
+
+// Read cache once at module load — shared by both exported functions
+const _cache: UpdateCache | null = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8')) as UpdateCache;
+  } catch {
+    return null;
+  }
+})();
+
+function writeCache(latestVersion: string): void {
+  try {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify({ lastCheck: Date.now(), latestVersion }), 'utf-8');
+  } catch {
+    // Best-effort; never fail
+  }
+}
+
+/** Compare semver strings. Returns true if `a` is strictly newer than `b`. */
+function isNewer(a: string, b: string): boolean {
+  const parse = (v: string) => v.replace(/^v/, '').split('-')[0].split('.').map(Number);
+  const pa = parse(a);
+  const pb = parse(b);
+  if (pa.some(isNaN) || pb.some(isNaN)) return false;
+  const [aMaj, aMin, aPat] = pa;
+  const [bMaj, bMin, bPat] = pb;
+  if (aMaj !== bMaj) return aMaj > bMaj;
+  if (aMin !== bMin) return aMin > bMin;
+  return aPat > bPat;
+}
+
+function isCI(): boolean {
+  return !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION);
+}
+
+/**
+ * Register a process exit hook that prints an update notice if a newer
+ * version was found on the last background check.
+ * Notice appears after command output — same pattern as npm/gh/yarn.
+ * Skipped during --get-completions to avoid polluting shell completion output.
+ */
+export function registerUpdateNoticeOnExit(): void {
+  if (isCI()) return;
+  if (process.argv.includes('--get-completions')) return;
+
+  process.on('exit', (code) => {
+    if (code !== 0) return; // Don't show update notice on error exit
+    if (!_cache) return;
+    if (!isNewer(_cache.latestVersion, PKG_VERSION)) return;
+    try {
+      process.stderr.write(
+        chalk.yellow(`\n  Update available: v${PKG_VERSION} → v${_cache.latestVersion}\n`) +
+        chalk.dim(`  Run: npm install -g @jackwener/opencli\n\n`),
+      );
+    } catch {
+      // Ignore broken pipe (stderr closed before process exits)
+    }
+  });
+}
+
+/**
+ * Kick off a background fetch to npm registry. Writes to cache for next run.
+ * Fully non-blocking — never awaited.
+ */
+export function checkForUpdateBackground(): void {
+  if (isCI()) return;
+  if (_cache && Date.now() - _cache.lastCheck < CHECK_INTERVAL_MS) return;
+
+  void (async () => {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 3000);
+      const res = await fetch(NPM_REGISTRY_URL, {
+        signal: controller.signal,
+        headers: { 'User-Agent': `opencli/${PKG_VERSION}` },
+      });
+      clearTimeout(timer);
+      if (!res.ok) return;
+      const data = await res.json() as { version?: string };
+      if (typeof data.version === 'string') {
+        writeCache(data.version);
+      }
+    } catch {
+      // Network error: silently skip, try again next run
+    }
+  })();
+}

package/src/weixin-download.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+
+async function loadModule() {
+  return import('./clis/weixin/download.js');
+}
+
+describe('weixin publish time extraction', () => {
+  it('prefers publish_time text over create_time-like date strings', async () => {
+    const mod = await loadModule();
+
+    expect(mod.extractWechatPublishTime(
+      '2026年3月24日 22:38',
+      'var create_time = "2026年3月24日 22:38";',
+    )).toBe('2026年3月24日 22:38');
+  });
+
+  it('falls back to unix timestamp create_time values', async () => {
+    const mod = await loadModule();
+
+    expect(mod.extractWechatPublishTime(
+      '',
+      'var create_time = "1711291080";',
+    )).toBe('2024-03-24 22:38:00');
+  });
+
+  it('rejects malformed create_time values', async () => {
+    const mod = await loadModule();
+
+    expect(mod.extractWechatPublishTime(
+      '',
+      'var create_time = "2026年3月24日 22:38";',
+    )).toBe('');
+    expect(mod.extractWechatPublishTime(
+      '',
+      'var create_time = "1711291080abc";',
+    )).toBe('');
+    expect(mod.extractWechatPublishTime(
+      '',
+      'var create_time = "17112910800";',
+    )).toBe('');
+  });
+
+  it('builds a self-contained browser helper that matches fallback behavior', async () => {
+    const mod = await loadModule();
+
+    const extractInPage = eval(mod.buildExtractWechatPublishTimeJs()) as (publishTimeText: string, htmlStr: string) => string;
+
+    expect(extractInPage(
+      '',
+      'var create_time = "1711291080";',
+    )).toBe('2024-03-24 22:38:00');
+  });
+
+  it('browser helper still prefers DOM publish_time text', async () => {
+    const mod = await loadModule();
+
+    const extractInPage = eval(mod.buildExtractWechatPublishTimeJs()) as (publishTimeText: string, htmlStr: string) => string;
+
+    expect(extractInPage(
+      '2026年3月24日 22:38',
+      'var create_time = "1711291080";',
+    )).toBe('2026年3月24日 22:38');
+  });
+});

package/src/weread-private-api-regression.test.ts

@@ -0,0 +1,150 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from './registry.js';
+import { fetchPrivateApi } from './clis/weread/utils.js';
+import './clis/weread/shelf.js';
+
+describe('weread private API regression', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('uses browser cookies and Node fetch for private API requests', async () => {
+    const mockPage = {
+      getCookies: vi.fn()
+        .mockResolvedValueOnce([
+          { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
+          { name: 'wr_vid', value: 'vid123', domain: 'i.weread.qq.com' },
+        ]),
+      evaluate: vi.fn(),
+    } as any;
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ title: 'Test Book', errcode: 0 }),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await fetchPrivateApi(mockPage, '/book/info', { bookId: '123' });
+
+    expect(result.title).toBe('Test Book');
+    expect(mockPage.getCookies).toHaveBeenCalledTimes(1);
+    expect(mockPage.getCookies).toHaveBeenCalledWith({ url: 'https://i.weread.qq.com/book/info?bookId=123' });
+    expect(mockPage.evaluate).not.toHaveBeenCalled();
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://i.weread.qq.com/book/info?bookId=123',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Cookie: 'wr_name=alice; wr_vid=vid123',
+        }),
+      }),
+    );
+  });
+
+  it('maps unauthenticated private API responses to AUTH_REQUIRED', async () => {
+    const mockPage = {
+      getCookies: vi.fn().mockResolvedValue([]),
+      evaluate: vi.fn(),
+    } as any;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 401,
+      json: () => Promise.resolve({ errcode: -2010, errmsg: '用户不存在' }),
+    }));
+
+    await expect(fetchPrivateApi(mockPage, '/book/info')).rejects.toThrow('Not logged in');
+  });
+
+  it('maps non-auth API errors to API_ERROR', async () => {
+    const mockPage = {
+      getCookies: vi.fn().mockResolvedValue([]),
+      evaluate: vi.fn(),
+    } as any;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ errcode: -1, errmsg: 'unknown error' }),
+    }));
+
+    await expect(fetchPrivateApi(mockPage, '/book/info')).rejects.toThrow('unknown error');
+  });
+
+  it('maps non-401 HTTP failures to FETCH_ERROR', async () => {
+    const mockPage = {
+      getCookies: vi.fn().mockResolvedValue([]),
+      evaluate: vi.fn(),
+    } as any;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 403,
+      json: () => Promise.resolve({ errmsg: 'forbidden' }),
+    }));
+
+    await expect(fetchPrivateApi(mockPage, '/book/info')).rejects.toThrow('HTTP 403');
+  });
+
+  it('maps invalid JSON to PARSE_ERROR', async () => {
+    const mockPage = {
+      getCookies: vi.fn().mockResolvedValue([]),
+      evaluate: vi.fn(),
+    } as any;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.reject(new SyntaxError('Unexpected token <')),
+    }));
+
+    await expect(fetchPrivateApi(mockPage, '/book/info')).rejects.toThrow('Invalid JSON');
+  });
+
+  it('routes weread shelf through the private API helper path', async () => {
+    const command = getRegistry().get('weread/shelf');
+    expect(command?.func).toBeTypeOf('function');
+
+    const mockPage = {
+      getCookies: vi.fn()
+        .mockResolvedValueOnce([
+          { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
+          { name: 'wr_vid', value: 'vid123', domain: 'i.weread.qq.com' },
+        ]),
+      evaluate: vi.fn(),
+    } as any;
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({
+        books: [{
+          title: 'Deep Work',
+          author: 'Cal Newport',
+          readingProgress: 42,
+          bookId: 'abc123',
+        }],
+      }),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await command!.func!(mockPage, { limit: 1 });
+
+    expect(mockPage.evaluate).not.toHaveBeenCalled();
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://i.weread.qq.com/shelf/sync?synckey=0&lectureSynckey=0',
+      expect.any(Object),
+    );
+    expect(mockPage.getCookies).toHaveBeenCalledWith({
+      url: 'https://i.weread.qq.com/shelf/sync?synckey=0&lectureSynckey=0',
+    });
+    expect(result).toEqual([
+      {
+        title: 'Deep Work',
+        author: 'Cal Newport',
+        progress: '42%',
+        bookId: 'abc123',
+      },
+    ]);
+  });
+});

package/src/yaml-schema.ts

@@ -26,3 +26,23 @@ export interface YamlCliDefinition {
   timeout?: number;
   navigateBefore?: boolean | string;
 }
+
+import type { Arg } from './registry.js';
+
+/** Convert YAML args definition to the internal Arg[] format. */
+export function parseYamlArgs(args: Record<string, YamlArgDefinition> | undefined): Arg[] {
+  if (!args || typeof args !== 'object') return [];
+  const result: Arg[] = [];
+  for (const [argName, argDef] of Object.entries(args)) {
+    result.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,
+    });
+  }
+  return result;
+}

package/tests/e2e/browser-auth.test.ts

@@ -80,30 +80,34 @@ describe('login-required commands — graceful failure', () => {
   }, 60_000);
 
   // ── linux-do (requires login — all endpoints need authentication) ──
-  it('linux-do hot fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['linux-do', 'hot', '--limit', '3', '-f', 'json'], 'linux-do hot');
-  }, 60_000);
-
-  it('linux-do latest fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['linux-do', 'latest', '--limit', '3', '-f', 'json'], 'linux-do latest');
+  it('linux-do feed fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'feed', '--limit', '3', '-f', 'json'], 'linux-do feed');
   }, 60_000);
 
   it('linux-do categories fails gracefully without login', async () => {
     await expectGracefulAuthFailure(['linux-do', 'categories', '--limit', '3', '-f', 'json'], 'linux-do categories');
   }, 60_000);
 
-  it('linux-do category fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['linux-do', 'category', '--slug', 'general', '--id', '1', '--limit', '3', '-f', 'json'], 'linux-do category');
+  it('linux-do tags fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'tags', '--limit', '3', '-f', 'json'], 'linux-do tags');
   }, 60_000);
 
   it('linux-do topic fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['linux-do', 'topic', '--id', '1', '-f', 'json'], 'linux-do topic');
+    await expectGracefulAuthFailure(['linux-do', 'topic', '1', '-f', 'json'], 'linux-do topic');
   }, 60_000);
 
   it('linux-do search fails gracefully without login', async () => {
     await expectGracefulAuthFailure(['linux-do', 'search', 'test', '--limit', '3', '-f', 'json'], 'linux-do search');
   }, 60_000);
 
+  it('linux-do user-topics fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'user-topics', 'test', '--limit', '3', '-f', 'json'], 'linux-do user-topics');
+  }, 60_000);
+
+  it('linux-do user-posts fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['linux-do', 'user-posts', 'test', '--limit', '3', '-f', 'json'], 'linux-do user-posts');
+  }, 60_000);
+
   // ── xiaohongshu (requires login) ──
   it('xiaohongshu feed fails gracefully without login', async () => {
     await expectGracefulAuthFailure(['xiaohongshu', 'feed', '--limit', '3', '-f', 'json'], 'xiaohongshu feed');

package/tests/e2e/browser-public-extended.test.ts

@@ -156,7 +156,7 @@ describe('browser extended public-data commands E2E', () => {
 
   // ── yahoo-finance ──
   it('yahoo-finance quote returns stock data', async () => {
-    const data = await tryBrowserCommand(['yahoo-finance', 'quote', '--symbol', 'AAPL', '-f', 'json']);
+    const data = await tryBrowserCommand(['yahoo-finance', 'quote', 'AAPL', '-f', 'json']);
     expectDataOrSkip(data, 'yahoo-finance quote');
   }, 60_000);
 });

package/tests/e2e/browser-public.test.ts

@@ -1,5 +1,5 @@
 /**
- * E2E tests for core browser commands (bilibili, zhihu, v2ex).
+ * E2E tests for core browser commands (bilibili, zhihu, v2ex, IMDb).
  * These use OPENCLI_HEADLESS=1 to launch a headless Chromium.
  *
  * NOTE: Some sites may block headless browsers with bot detection.
@@ -7,7 +7,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { runCli, parseJsonOutput } from './helpers.js';
+import { runCli, parseJsonOutput, type CliResult } from './helpers.js';
 
 async function tryBrowserCommand(args: string[]): Promise<any[] | null> {
   const { stdout, code } = await runCli(args, { timeout: 60_000 });
@@ -28,13 +28,47 @@ function expectDataOrSkip(data: any[] | null, label: string) {
   expect(data.length).toBeGreaterThanOrEqual(1);
 }
 
+function isImdbChallenge(result: CliResult): boolean {
+  const text = `${result.stderr}\n${result.stdout}`;
+  return /IMDb blocked this request|Robot Check|Are you a robot|verify that you are human|captcha/i.test(text);
+}
+
+function isBrowserBridgeUnavailable(result: CliResult): boolean {
+  const text = `${result.stderr}\n${result.stdout}`;
+  return /Browser Bridge not connected|Extension.*not connected|not connected.*extension/i.test(text);
+}
+
+async function expectImdbDataOrChallengeSkip(args: string[], label: string): Promise<any[] | null> {
+  const result = await runCli(args, { timeout: 60_000 });
+  if (result.code !== 0) {
+    if (isImdbChallenge(result)) {
+      console.warn(`${label}: skipped — IMDb challenge page detected`);
+      return null;
+    }
+    if (isBrowserBridgeUnavailable(result)) {
+      console.warn(`${label}: skipped — Browser Bridge extension is unavailable in this environment`);
+      return null;
+    }
+    throw new Error(`${label} failed:\n${result.stderr || result.stdout}`);
+  }
+
+  const data = parseJsonOutput(result.stdout);
+  if (!Array.isArray(data)) {
+    throw new Error(`${label} returned non-array JSON:\n${result.stdout.slice(0, 500)}`);
+  }
+  if (data.length === 0) {
+    throw new Error(`${label} returned an empty result`);
+  }
+  return data;
+}
+
 describe('browser public-data commands E2E', () => {
 
   // ── bilibili ──
   it('bilibili hot returns trending videos', async () => {
     const data = await tryBrowserCommand(['bilibili', 'hot', '--limit', '5', '-f', 'json']);
     expectDataOrSkip(data, 'bilibili hot');
-    if (data) {
+    if (data?.length) {
       expect(data[0]).toHaveProperty('title');
     }
   }, 60_000);
@@ -53,7 +87,7 @@ describe('browser public-data commands E2E', () => {
   it('zhihu hot returns trending questions', async () => {
     const data = await tryBrowserCommand(['zhihu', 'hot', '--limit', '5', '-f', 'json']);
     expectDataOrSkip(data, 'zhihu hot');
-    if (data) {
+    if (data?.length) {
       expect(data[0]).toHaveProperty('title');
     }
   }, 60_000);
@@ -68,4 +102,28 @@ describe('browser public-data commands E2E', () => {
     const data = await tryBrowserCommand(['v2ex', 'daily', '--limit', '3', '-f', 'json']);
     expectDataOrSkip(data, 'v2ex daily');
   }, 60_000);
+
+  // ── imdb ──
+  it('imdb top returns chart data', async () => {
+    const data = await expectImdbDataOrChallengeSkip(['imdb', 'top', '--limit', '3', '-f', 'json'], 'imdb top');
+    if (data?.length) {
+      expect(data[0]).toHaveProperty('title');
+    }
+  }, 60_000);
+
+  it('imdb search returns results', async () => {
+    const data = await expectImdbDataOrChallengeSkip(['imdb', 'search', 'inception', '--limit', '3', '-f', 'json'], 'imdb search');
+    if (data?.length) {
+      expect(data[0]).toHaveProperty('id');
+      expect(data[0]).toHaveProperty('title');
+    }
+  }, 60_000);
+
+  it('imdb title returns movie details', async () => {
+    const data = await expectImdbDataOrChallengeSkip(['imdb', 'title', 'tt1375666', '-f', 'json'], 'imdb title');
+    if (data?.length) {
+      expect(data[0]).toHaveProperty('field');
+      expect(data[0]).toHaveProperty('value');
+    }
+  }, 60_000);
 });

package/tests/e2e/helpers.ts

@@ -29,7 +29,8 @@ export async function runCli(
 ): Promise<CliResult> {
   const timeout = opts.timeout ?? 30_000;
   try {
-    const { stdout, stderr } = await exec('node', [MAIN, ...args], {
+    const runtime = process.env.OPENCLI_TEST_RUNTIME || 'node';
+    const { stdout, stderr } = await exec(runtime, [MAIN, ...args], {
       cwd: ROOT,
       timeout,
       env: {