@jackwener/opencli 1.4.1 → 1.5.0

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 Extension is not connected|Browser Bridge extension.*not connected|Daemon is running but the Browser Extension is not connected/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: {

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

@@ -4,14 +4,19 @@
  */
 
 import { describe, expect, it } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
 import { parseJsonOutput, runCli } from './helpers.js';
 
 function isExpectedChineseSiteRestriction(code: number, stderr: string): boolean {
   if (code === 0) return false;
   // Overseas CI runners may get HTTP errors, geo-blocks, DNS failures,
-  // or receive mangled HTML that fails parsing.
+  // or receive mangled HTML that fails parsing. Some runners also fail
+  // without surfacing a useful stderr payload.
   return /Error \[(FETCH_ERROR|PARSE_ERROR|NOT_FOUND)\]/.test(stderr)
-    || /fetch failed/.test(stderr);
+    || /fetch failed/.test(stderr)
+    || stderr.trim() === '';
 }
 
 function isExpectedApplePodcastsRestriction(code: number, stderr: string): boolean {
@@ -126,6 +131,35 @@ describe('public commands E2E', () => {
     expect(data[0]).toHaveProperty('id');
   }, 30_000);
 
+  it('paperreview submit dry-run validates a local PDF without remote upload', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'opencli-paperreview-'));
+    const pdfPath = path.join(tempDir, 'sample.pdf');
+    await fs.writeFile(pdfPath, Buffer.concat([Buffer.from('%PDF-1.4\n'), Buffer.alloc(256, 1)]));
+
+    const { stdout, code } = await runCli([
+      'paperreview',
+      'submit',
+      pdfPath,
+      '--email',
+      'wang2629651228@gmail.com',
+      '--venue',
+      'RAL',
+      '--dry-run',
+      'true',
+      '-f',
+      'json',
+    ]);
+
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(data).toMatchObject({
+      status: 'dry-run',
+      file: 'sample.pdf',
+      email: 'wang2629651228@gmail.com',
+      venue: 'RAL',
+    });
+  }, 30_000);
+
   // ── hackernews ──
   it('hackernews top returns structured data', async () => {
     const { stdout, code } = await runCli(['hackernews', 'top', '--limit', '3', '-f', 'json']);
@@ -235,7 +269,7 @@ describe('public commands E2E', () => {
 
   it('v2ex topic returns topic detail', async () => {
     // Topic 1000001 is a well-known V2EX topic
-    const { stdout, code } = await runCli(['v2ex', 'topic', '--id', '1000001', '-f', 'json']);
+    const { stdout, code } = await runCli(['v2ex', 'topic', '1000001', '-f', 'json']);
     // May fail if V2EX rate-limits, but should return structured data
     if (code === 0) {
       const data = parseJsonOutput(stdout);

package/tests/smoke/api-health.test.ts

@@ -38,7 +38,7 @@ describe('API health smoke tests', () => {
   }, 30_000);
 
   it('v2ex topic API is responsive', async () => {
-    const { stdout, code } = await runCli(['v2ex', 'topic', '--id', '1000001', '-f', 'json']);
+    const { stdout, code } = await runCli(['v2ex', 'topic', '1000001', '-f', 'json']);
     if (code === 0) {
       const data = parseJsonOutput(stdout);
       expect(data).toBeDefined();

package/vitest.config.ts

@@ -18,8 +18,18 @@ export default defineConfig({
           name: 'adapter',
           include: [
             'src/clis/bilibili/**/*.test.ts',
+            'src/clis/imdb/**/*.test.ts',
+            'src/clis/jd/**/*.test.ts',
+            'src/clis/linux-do/**/*.test.ts',
+            'src/clis/xiaohongshu/**/*.test.ts',
+            'src/clis/twitter/**/*.test.ts',
+            'src/clis/douban/**/*.test.ts',
             'src/clis/zhihu/**/*.test.ts',
             'src/clis/v2ex/**/*.test.ts',
+            'src/clis/weread/**/*.test.ts',
+            'src/clis/36kr/**/*.test.ts',
+            'src/clis/producthunt/**/*.test.ts',
+            'src/clis/paperreview/**/*.test.ts',
           ],
           sequence: { groupOrder: 1 },
         },

package/dist/clis/linux-do/category.yaml

@@ -1,51 +0,0 @@
-site: linux-do
-name: category
-description: linux.do 分类内话题
-domain: linux.do
-browser: true
-
-args:
-  slug:
-    positional: true
-    type: str
-    required: true
-    description: Category slug (use 'categories' command to find)
-  id:
-    positional: true
-    type: int
-    required: true
-    description: Category ID (use 'categories' command to find)
-  limit:
-    type: int
-    default: 20
-    description: Number of topics
-
-pipeline:
-  - navigate: https://linux.do
-
-  - evaluate: |
-      (async () => {
-        const slug = ${{ args.slug | json }};
-        const res = await fetch('/c/' + encodeURIComponent(slug) + '/${{ args.id }}.json', { credentials: 'include' });
-        if (!res.ok) throw new Error('HTTP ' + res.status + ' - 请先登录 linux.do');
-        let data;
-        try { data = await res.json(); } catch { throw new Error('响应不是有效 JSON - 请先登录 linux.do'); }
-        const topics = data?.topic_list?.topics || [];
-        return topics.slice(0, ${{ args.limit }}).map(t => ({
-          title: t.title,
-          replies: (t.posts_count || 1) - 1,
-          views: t.views,
-          likes: t.like_count,
-        }));
-      })()
-
-  - map:
-      rank: ${{ index + 1 }}
-      title: ${{ item.title }}
-      replies: ${{ item.replies }}
-      views: ${{ item.views }}
-      likes: ${{ item.likes }}
-
-  - limit: ${{ args.limit }}
-
-columns: [rank, title, replies, views, likes]