@jackwener/opencli 1.4.0 → 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/weread-search-regression.test.ts

@@ -0,0 +1,44 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from './registry.js';
+import './clis/weread/search.js';
+
+describe('weread/search regression', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('uses the query argument for the search API and returns urls', async () => {
+    const command = getRegistry().get('weread/search');
+    expect(command?.func).toBeTypeOf('function');
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({
+        books: [
+          {
+            bookInfo: {
+              title: 'Deep Work',
+              author: 'Cal Newport',
+              bookId: 'abc123',
+            },
+          },
+        ],
+      }),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await command!.func!(null as any, { query: 'deep work', limit: 5 });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(String(fetchMock.mock.calls[0][0])).toContain('keyword=deep+work');
+    expect(result).toEqual([
+      {
+        rank: 1,
+        title: 'Deep Work',
+        author: 'Cal Newport',
+        bookId: 'abc123',
+        url: 'https://weread.qq.com/web/bookDetail/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

@@ -0,0 +1,162 @@
+/**
+ * Extended E2E tests for all other browser commands.
+ * Opt-in only: OPENCLI_E2E=1 npx vitest run
+ */
+
+import { describe, it, expect } from 'vitest';
+import { runCli, parseJsonOutput } from './helpers.js';
+
+async function tryBrowserCommand(args: string[]): Promise<any[] | null> {
+  const { stdout, code } = await runCli(args, { timeout: 60_000 });
+  if (code !== 0) return null;
+  try {
+    const data = parseJsonOutput(stdout);
+    return Array.isArray(data) ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+function expectDataOrSkip(data: any[] | null, label: string) {
+  if (data === null || data.length === 0) {
+    console.warn(`${label}: skipped — no data returned (likely bot detection or geo-blocking)`);
+    return;
+  }
+  expect(data.length).toBeGreaterThanOrEqual(1);
+}
+
+describe('browser extended public-data commands E2E', () => {
+
+  // ── bbc ──
+  it('bbc news returns headlines', async () => {
+    const data = await tryBrowserCommand(['bbc', 'news', '--limit', '3', '-f', 'json']);
+    expectDataOrSkip(data, 'bbc news');
+    if (data) {
+      expect(data[0]).toHaveProperty('title');
+    }
+  }, 60_000);
+
+  // ── bloomberg ──
+  it('bloomberg news returns article detail when the article page is accessible', async () => {
+    const feedResult = await runCli(['bloomberg', 'tech', '--limit', '1', '-f', 'json']);
+    if (feedResult.code !== 0) {
+      console.warn('bloomberg news: skipped — could not load Bloomberg tech feed');
+      return;
+    }
+
+    const feedItems = parseJsonOutput(feedResult.stdout);
+    const link = Array.isArray(feedItems) ? feedItems[0]?.link : null;
+    if (!link) {
+      console.warn('bloomberg news: skipped — tech feed returned no link');
+      return;
+    }
+
+    const data = await tryBrowserCommand(['bloomberg', 'news', link, '-f', 'json']);
+    expectDataOrSkip(data, 'bloomberg news');
+    if (data) {
+      expect(data[0]).toHaveProperty('title');
+      expect(data[0]).toHaveProperty('summary');
+      expect(data[0]).toHaveProperty('link');
+      expect(data[0]).toHaveProperty('mediaLinks');
+      expect(data[0]).toHaveProperty('content');
+    }
+  }, 60_000);
+
+  // ── weibo ──
+  it('weibo hot returns trending topics', async () => {
+    const data = await tryBrowserCommand(['weibo', 'hot', '--limit', '5', '-f', 'json']);
+    expectDataOrSkip(data, 'weibo hot');
+  }, 60_000);
+
+  it('weibo search returns results', async () => {
+    const data = await tryBrowserCommand(['weibo', 'search', 'openai', '--limit', '3', '-f', 'json']);
+    expectDataOrSkip(data, 'weibo search');
+  }, 60_000);
+
+  // ── reddit ──
+  it('reddit hot returns posts', async () => {
+    const data = await tryBrowserCommand(['reddit', 'hot', '--limit', '5', '-f', 'json']);
+    expectDataOrSkip(data, 'reddit hot');
+  }, 60_000);
+
+  it('reddit frontpage returns posts', async () => {
+    const data = await tryBrowserCommand(['reddit', 'frontpage', '--limit', '5', '-f', 'json']);
+    expectDataOrSkip(data, 'reddit frontpage');
+  }, 60_000);
+
+  // ── twitter ──
+  it('twitter trending returns trends', async () => {
+    const data = await tryBrowserCommand(['twitter', 'trending', '--limit', '5', '-f', 'json']);
+    expectDataOrSkip(data, 'twitter trending');
+  }, 60_000);
+
+  // ── xueqiu ──
+  it('xueqiu hot returns hot posts', async () => {
+    const data = await tryBrowserCommand(['xueqiu', 'hot', '--limit', '5', '-f', 'json']);
+    expectDataOrSkip(data, 'xueqiu hot');
+  }, 60_000);
+
+  it('xueqiu hot-stock returns stocks', async () => {
+    const data = await tryBrowserCommand(['xueqiu', 'hot-stock', '--limit', '5', '-f', 'json']);
+    expectDataOrSkip(data, 'xueqiu hot-stock');
+  }, 60_000);
+
+  // ── reuters ──
+  it('reuters search returns articles', async () => {
+    const data = await tryBrowserCommand(['reuters', 'search', 'technology', '--limit', '3', '-f', 'json']);
+    expectDataOrSkip(data, 'reuters search');
+  }, 60_000);
+
+  // ── youtube ──
+  it('youtube search returns videos', async () => {
+    const data = await tryBrowserCommand(['youtube', 'search', 'typescript tutorial', '--limit', '3', '-f', 'json']);
+    expectDataOrSkip(data, 'youtube search');
+  }, 60_000);
+
+  // ── smzdm ──
+  it('smzdm search returns deals', async () => {
+    const data = await tryBrowserCommand(['smzdm', 'search', '键盘', '--limit', '3', '-f', 'json']);
+    expectDataOrSkip(data, 'smzdm search');
+  }, 60_000);
+
+  // ── boss ──
+  it('boss search returns jobs', async () => {
+    const data = await tryBrowserCommand(['boss', 'search', 'golang', '--limit', '3', '-f', 'json']);
+    expectDataOrSkip(data, 'boss search');
+  }, 60_000);
+
+  // ── ctrip ──
+  it('ctrip search returns flights', async () => {
+    const data = await tryBrowserCommand(['ctrip', 'search', '-f', 'json']);
+    expectDataOrSkip(data, 'ctrip search');
+  }, 60_000);
+
+  // ── coupang ──
+  it('coupang search returns products', async () => {
+    const data = await tryBrowserCommand(['coupang', 'search', 'laptop', '--limit', '3', '-f', 'json']);
+    expectDataOrSkip(data, 'coupang search');
+  }, 60_000);
+
+  // ── xiaohongshu ──
+  it('xiaohongshu search returns notes', async () => {
+    const data = await tryBrowserCommand(['xiaohongshu', 'search', '美食', '--limit', '3', '-f', 'json']);
+    expectDataOrSkip(data, 'xiaohongshu search');
+  }, 60_000);
+
+  // ── google ──
+  it('google search returns results', async () => {
+    const data = await tryBrowserCommand(['google', 'search', 'typescript', '--limit', '5', '-f', 'json']);
+    expectDataOrSkip(data, 'google search');
+    if (data) {
+      expect(data[0]).toHaveProperty('type');
+      expect(data[0]).toHaveProperty('title');
+      expect(data[0]).toHaveProperty('url');
+    }
+  }, 60_000);
+
+  // ── yahoo-finance ──
+  it('yahoo-finance quote returns stock data', async () => {
+    const data = await tryBrowserCommand(['yahoo-finance', 'quote', 'AAPL', '-f', 'json']);
+    expectDataOrSkip(data, 'yahoo-finance quote');
+  }, 60_000);
+});