@jackwener/opencli 1.5.5 → 1.5.6

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

@@ -38,6 +38,201 @@ function isBrowserBridgeUnavailable(result: CliResult): boolean {
   return /Browser Bridge.*not connected|Extension.*not connected/i.test(text);
 }
 
+function isBaiduChallengeText(text: string): boolean {
+  return /百度安全验证|安全验证|请完成验证|captcha/i.test(text);
+}
+
+function isBaiduChallenge(result: CliResult): boolean {
+  const text = `${result.stderr}\n${result.stdout}`;
+  return isBaiduChallengeText(text);
+}
+
+function isTransientBrowserDetach(result: CliResult): boolean {
+  const text = `${result.stderr}\n${result.stdout}`;
+  return /Detached while handling command|No tab with id|Debugger is not attached to the tab/i.test(text);
+}
+
+async function runCliWithTransientRetry(args: string[], timeout: number): Promise<CliResult> {
+  let result = await runCli(args, { timeout });
+  if (result.code !== 0 && isTransientBrowserDetach(result)) {
+    result = await runCli(args, { timeout });
+  }
+  return result;
+}
+
+async function runJsonCliOrThrow(args: string[], label: string, timeout: number, opts: { retryTransient?: boolean } = {}): Promise<any[] | null> {
+  const result = opts.retryTransient
+    ? await runCliWithTransientRetry(args, timeout)
+    : await runCli(args, { timeout });
+  if (result.code !== 0) {
+    if (isBrowserBridgeUnavailable(result)) {
+      console.warn(`${label}: skipped — Browser Bridge extension is unavailable in this environment`);
+      return null;
+    }
+    if (isBaiduChallenge(result)) {
+      console.warn(`${label}: skipped — Baidu challenge page detected`);
+      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)}`);
+  }
+  return data;
+}
+
+function normalizeTiebaTitle(value: string): string {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+function hasTiebaMainPost(data: any[] | null): boolean {
+  return Array.isArray(data) && data.some((item: any) => Number(item.floor) === 1);
+}
+
+function expectNonEmptyDataOrSkipEnv(data: any[] | null, label: string): data is any[] {
+  if (data === null) {
+    console.warn(`${label}: skipped — environment is unavailable for browser assertions`);
+    return false;
+  }
+  expect(data.length).toBeGreaterThanOrEqual(1);
+  return true;
+}
+
+function countTiebaReplies(data: any[] | null): number {
+  if (!Array.isArray(data)) return 0;
+  return data.filter((item: any) => Number(item.floor) > 1).length;
+}
+
+function maxTiebaFloor(data: any[] | null): number {
+  if (!Array.isArray(data) || !data.length) return 0;
+  return Math.max(...data.map((item: any) => Number(item.floor) || 0));
+}
+
+function getTiebaReplyFloors(data: any[] | null): number[] {
+  if (!Array.isArray(data)) return [];
+  return data
+    .map((item: any) => Number(item.floor) || 0)
+    .filter((floor) => floor > 1);
+}
+
+function countTiebaReplyFloorOverlap(left: any[] | null, right: any[] | null): number {
+  const rightFloors = new Set(getTiebaReplyFloors(right));
+  return getTiebaReplyFloors(left).filter((floor) => rightFloors.has(floor)).length;
+}
+
+function pickTiebaReadCandidates(
+  posts: any[] | null,
+  minReplies: number,
+): Array<{ threadId: string; title: string; replies: number }> {
+  if (!Array.isArray(posts) || !posts.length) return [];
+
+  return [...posts]
+    .filter((item: any) => item?.id)
+    .map((item: any) => ({
+      threadId: String(item.id || '').trim(),
+      title: normalizeTiebaTitle(String(item.title || '')),
+      replies: Number(item.replies) || 0,
+    }))
+    .filter((item) => item.threadId && item.title && item.replies >= minReplies)
+    .sort((left, right) => right.replies - left.replies);
+}
+
+/**
+ * Pick a live thread that actually exposes enough visible replies for the read assertions.
+ */
+async function getTiebaReadCandidateOrSkip(
+  label: string,
+  options: { minRepliesOnPage1?: number; requirePage2?: boolean } = {},
+): Promise<{ threadId: string; title: string; replies: number } | null> {
+  const minRepliesOnPage1 = Math.max(1, Number(options.minRepliesOnPage1 || 1));
+  const requirePage2 = options.requirePage2 === true;
+  const posts = await runJsonCliOrThrow(['tieba', 'posts', '李毅', '--limit', '10', '-f', 'json'], `${label} setup`, 90_000, {
+    retryTransient: true,
+  });
+  if (posts === null) {
+    return null;
+  }
+  if (!Array.isArray(posts) || !posts.length) {
+    console.warn(`${label}: skipped — could not resolve Tieba posts for setup`);
+    return null;
+  }
+
+  const minReplies = requirePage2 ? Math.max(minRepliesOnPage1, 50) : minRepliesOnPage1;
+  const candidates = pickTiebaReadCandidates(posts, minReplies).slice(0, 5);
+  if (!candidates.length) {
+    console.warn(`${label}: skipped — could not find a Tieba thread with enough replies from posts metadata`);
+    return null;
+  }
+
+  for (const candidate of candidates) {
+    const page1Preview = await runJsonCliOrThrow(
+      ['tieba', 'read', candidate.threadId, '--page', '1', '--limit', String(Math.max(minRepliesOnPage1, 2)), '-f', 'json'],
+      `${label} preview page 1`,
+      90_000,
+      { retryTransient: true },
+    );
+    if (page1Preview === null) {
+      return null;
+    }
+    if (!hasTiebaMainPost(page1Preview) || countTiebaReplies(page1Preview) < minRepliesOnPage1) {
+      continue;
+    }
+
+    if (requirePage2) {
+      const page2Preview = await runJsonCliOrThrow(
+        ['tieba', 'read', candidate.threadId, '--page', '2', '--limit', '1', '-f', 'json'],
+        `${label} preview page 2`,
+        90_000,
+        { retryTransient: true },
+      );
+      if (page2Preview === null) {
+        return null;
+      }
+      if (hasTiebaMainPost(page2Preview) || countTiebaReplies(page2Preview) < 1) {
+        continue;
+      }
+    }
+
+    return candidate;
+  }
+
+  console.warn(`${label}: skipped — could not find a Tieba thread with enough visible replies`);
+  return null;
+}
+
+describe('tieba e2e helper guards', () => {
+  it('does not treat generic empty-result errors as a Baidu challenge', () => {
+    expect(isBaiduChallengeText('tieba posts returned no data\n→ The page structure may have changed — this adapter may be outdated.')).toBe(false);
+  });
+
+  it('still recognizes actual Baidu challenge text', () => {
+    expect(isBaiduChallengeText('百度安全验证，请完成验证后继续')).toBe(true);
+  });
+
+  it('counts partial overlap between read pages', () => {
+    expect(countTiebaReplyFloorOverlap(
+      [{ floor: 1 }, { floor: 23 }, { floor: 27 }, { floor: 28 }, { floor: 29 }, { floor: 30 }],
+      [{ floor: 27 }, { floor: 28 }, { floor: 31 }],
+    )).toBe(2);
+  });
+
+  it('picks read fixtures from posts metadata in descending reply order', () => {
+    expect(pickTiebaReadCandidates([
+      { id: '1', title: '普通帖', replies: 2 },
+      { id: '2', title: '大帖', replies: 120 },
+      { id: '', title: '无效帖', replies: 999 },
+    ], 50)).toEqual([{
+      threadId: '2',
+      title: '大帖',
+      replies: 120,
+    }]);
+
+    expect(pickTiebaReadCandidates([{ id: '1', title: '普通帖', replies: 2 }], 50)).toEqual([]);
+  });
+});
+
 async function expectImdbDataOrChallengeSkip(args: string[], label: string): Promise<any[] | null> {
   const result = await runCli(args, { timeout: 60_000 });
   if (result.code !== 0) {
@@ -103,6 +298,99 @@ describe('browser public-data commands E2E', () => {
     expectDataOrSkip(data, 'v2ex daily');
   }, 60_000);
 
+  // ── tieba ──
+  it('tieba hot returns trending topics', async () => {
+    const data = await runJsonCliOrThrow(['tieba', 'hot', '--limit', '5', '-f', 'json'], 'tieba hot', 60_000, { retryTransient: true });
+    if (expectNonEmptyDataOrSkipEnv(data, 'tieba hot')) {
+      expect(data[0]).toHaveProperty('title');
+      expect(data[0]).toHaveProperty('discussions');
+    }
+  }, 60_000);
+
+  it('tieba posts returns forum threads', async () => {
+    const data = await runJsonCliOrThrow(['tieba', 'posts', '李毅', '--limit', '20', '-f', 'json'], 'tieba posts', 90_000, { retryTransient: true });
+    if (expectNonEmptyDataOrSkipEnv(data, 'tieba posts')) {
+      expect(data[0]).toHaveProperty('title');
+      expect(String(data[0].id || '')).toMatch(/^\d+$/);
+      expect(String(data[0].url || '')).toContain('/p/');
+      expect(Number.isFinite(Number(data[0].replies))).toBe(true);
+      expect(data.length).toBeLessThanOrEqual(20);
+    }
+  }, 90_000);
+
+  it('tieba posts page 2 returns a different forum slice', async () => {
+    const data1 = await runJsonCliOrThrow(['tieba', 'posts', '李毅', '--page', '1', '--limit', '5', '-f', 'json'], 'tieba posts page 1', 60_000, { retryTransient: true });
+    const data2 = await runJsonCliOrThrow(['tieba', 'posts', '李毅', '--page', '2', '--limit', '5', '-f', 'json'], 'tieba posts page 2', 60_000, { retryTransient: true });
+    if (expectNonEmptyDataOrSkipEnv(data1, 'tieba posts page 1') && expectNonEmptyDataOrSkipEnv(data2, 'tieba posts page 2')) {
+      const ids1 = data1.map((item: any) => String(item.id || '')).filter(Boolean);
+      const ids2 = data2.map((item: any) => String(item.id || '')).filter(Boolean);
+      const newIds = ids2.filter((id) => !ids1.includes(id));
+      expect(newIds.length).toBeGreaterThan(0);
+    }
+  }, 90_000);
+
+  it('tieba search returns results', async () => {
+    const data = await runJsonCliOrThrow(['tieba', 'search', '编程', '--limit', '20', '-f', 'json'], 'tieba search', 90_000, { retryTransient: true });
+    if (expectNonEmptyDataOrSkipEnv(data, 'tieba search')) {
+      expect(data[0]).toHaveProperty('title');
+      expect(String(data[0].id || '')).toMatch(/^\d+$/);
+      expect(String(data[0].url || '')).toContain('/p/');
+      expect(data.length).toBeLessThanOrEqual(20);
+    }
+  }, 90_000);
+
+  it('tieba search rejects unsupported pages above 1', async () => {
+    const result = await runCli(['tieba', 'search', '编程', '--page', '2', '--limit', '3', '-f', 'json'], {
+      timeout: 60_000,
+    });
+    expect(result.code).toBe(2);
+    expect(`${result.stderr}\n${result.stdout}`).toContain('Argument "page" must be one of: 1');
+  }, 60_000);
+
+  it('tieba read returns thread content', async () => {
+    const fixture = await getTiebaReadCandidateOrSkip('tieba read');
+    if (!fixture) {
+      return;
+    }
+    const data = await runJsonCliOrThrow(['tieba', 'read', fixture.threadId, '--limit', '5', '-f', 'json'], 'tieba read', 90_000, { retryTransient: true });
+    if (expectNonEmptyDataOrSkipEnv(data, 'tieba read')) {
+      expect(data[0]).toHaveProperty('floor');
+      expect(data[0]).toHaveProperty('content');
+      expect(data.some((item: any) => Number(item.floor) === 1)).toBe(true);
+      expect(normalizeTiebaTitle(String(data[0].content || ''))).toContain(fixture.title);
+    }
+  }, 90_000);
+
+  it('tieba read page 2 omits the main post', async () => {
+    const fixture = await getTiebaReadCandidateOrSkip('tieba read page', { requirePage2: true });
+    if (!fixture) {
+      return;
+    }
+    const data1 = await runJsonCliOrThrow(['tieba', 'read', fixture.threadId, '--page', '1', '--limit', '5', '-f', 'json'], 'tieba read page 1', 90_000, { retryTransient: true });
+    const data2 = await runJsonCliOrThrow(['tieba', 'read', fixture.threadId, '--page', '2', '--limit', '5', '-f', 'json'], 'tieba read page 2', 90_000, { retryTransient: true });
+    if (expectNonEmptyDataOrSkipEnv(data1, 'tieba read page 1') && expectNonEmptyDataOrSkipEnv(data2, 'tieba read page 2')) {
+      const overlap = countTiebaReplyFloorOverlap(data1, data2);
+      expect(normalizeTiebaTitle(String(data1[0].content || ''))).toContain(fixture.title);
+      expect(hasTiebaMainPost(data1)).toBe(true);
+      expect(hasTiebaMainPost(data2)).toBe(false);
+      expect(overlap).toBe(0);
+      expect(maxTiebaFloor(data2)).toBeGreaterThan(maxTiebaFloor(data1));
+    }
+  }, 90_000);
+
+  it('tieba read limit counts replies instead of consuming the main post slot', async () => {
+    const fixture = await getTiebaReadCandidateOrSkip('tieba read limit semantics', { minRepliesOnPage1: 2 });
+    if (!fixture) {
+      return;
+    }
+    const data = await runJsonCliOrThrow(['tieba', 'read', fixture.threadId, '--page', '1', '--limit', '2', '-f', 'json'], 'tieba read limit semantics', 90_000, { retryTransient: true });
+    if (expectNonEmptyDataOrSkipEnv(data, 'tieba read limit semantics')) {
+      expect(normalizeTiebaTitle(String(data[0].content || ''))).toContain(fixture.title);
+      expect(hasTiebaMainPost(data)).toBe(true);
+      expect(countTiebaReplies(data)).toBe(2);
+    }
+  }, 90_000);
+
   // ── imdb ──
   it('imdb top returns chart data', async () => {
     const data = await expectImdbDataOrChallengeSkip(['imdb', 'top', '--limit', '3', '-f', 'json'], 'imdb top');

package/tests/e2e/management.test.ts

@@ -101,6 +101,6 @@ describe('management commands E2E', () => {
   // ── unknown command ──
   it('unknown command shows error', async () => {
     const { stderr, code } = await runCli(['nonexistent-command-xyz']);
-    expect(code).toBe(1);
+    expect(code).toBe(2);
   });
 });

package/tests/e2e/plugin-management.test.ts

@@ -134,7 +134,7 @@ describe('plugin management E2E', () => {
 
   it('plugin update without name or --all shows error', async () => {
     const { stderr, code } = await runPluginCli(['plugin', 'update']);
-    expect(code).toBe(1);
+    expect(code).toBe(2);
     expect(stderr).toContain('specify a plugin name');
   });
 });

package/vitest.config.ts

@@ -25,6 +25,7 @@ export default defineConfig({
           name: 'e2e',
           include: [
             'tests/e2e/browser-public.test.ts',
+            'tests/e2e/band-auth.test.ts',
             'tests/e2e/public-commands.test.ts',
             'tests/e2e/management.test.ts',
             'tests/e2e/output-formats.test.ts',