@jackwener/opencli 0.6.1 → 0.6.3

package/src/clis/boss/detail.ts

@@ -0,0 +1,115 @@
+/**
+ * BOSS直聘 job detail — fetch full job posting details via browser cookie API.
+ *
+ * Uses securityId from search results to call the detail API.
+ * Returns: job description, skills, welfare, boss info, company info, address.
+ */
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'boss',
+  name: 'detail',
+  description: 'BOSS直聘查看职位详情',
+  domain: 'www.zhipin.com',
+  strategy: Strategy.COOKIE,
+
+  browser: true,
+  args: [
+    { name: 'security_id', required: true, help: 'Security ID from search results (securityId field)' },
+  ],
+  columns: [
+    'name', 'salary', 'experience', 'degree', 'city', 'district',
+    'description', 'skills', 'welfare',
+    'boss_name', 'boss_title', 'active_time',
+    'company', 'industry', 'scale', 'stage',
+    'address', 'url',
+  ],
+  func: async (page: IPage | null, kwargs) => {
+    if (!page) throw new Error('Browser page required');
+
+    const securityId = kwargs.security_id;
+
+    // Navigate to zhipin.com first to establish cookie context (referrer + cookies)
+    await page.goto('https://www.zhipin.com/web/geek/job');
+    await page.wait({ time: 1 });
+
+    const targetUrl = `https://www.zhipin.com/wapi/zpgeek/job/detail.json?securityId=${encodeURIComponent(securityId)}`;
+
+    if (process.env.OPENCLI_VERBOSE || process.env.DEBUG?.includes('opencli')) {
+      console.error(`[opencli:boss] Fetching job detail...`);
+    }
+
+    const evaluateScript = `
+      async () => {
+        return new Promise((resolve, reject) => {
+          const xhr = new window.XMLHttpRequest();
+          xhr.open('GET', ${JSON.stringify(targetUrl)}, true);
+          xhr.withCredentials = true;
+          xhr.timeout = 15000;
+          xhr.setRequestHeader('Accept', 'application/json, text/plain, */*');
+          xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300) {
+              try {
+                resolve(JSON.parse(xhr.responseText));
+              } catch (e) {
+                reject(new Error('Failed to parse JSON. Raw (200 chars): ' + xhr.responseText.substring(0, 200)));
+              }
+            } else {
+              reject(new Error('XHR HTTP Status: ' + xhr.status));
+            }
+          };
+          xhr.onerror = () => reject(new Error('XHR Network Error'));
+          xhr.ontimeout = () => reject(new Error('XHR Timeout'));
+          xhr.send();
+        });
+      }
+    `;
+
+    let data: any;
+    try {
+      data = await page.evaluate(evaluateScript);
+    } catch (e: any) {
+      throw new Error('API evaluate failed: ' + e.message);
+    }
+
+    if (data.code !== 0) {
+      if (data.code === 37) {
+        throw new Error('Cookie 已过期！请在当前 Chrome 浏览器中重新登录 BOSS 直聘。');
+      }
+      throw new Error(`BOSS API error: ${data.message || 'Unknown'} (code=${data.code})`);
+    }
+
+    const zpData = data.zpData || {};
+    const jobInfo = zpData.jobInfo || {};
+    const bossInfo = zpData.bossInfo || {};
+    const brandComInfo = zpData.brandComInfo || {};
+
+    if (!jobInfo.jobName) {
+      throw new Error('该职位信息不存在或已下架');
+    }
+
+    return [{
+      name: jobInfo.jobName || '',
+      salary: jobInfo.salaryDesc || '',
+      experience: jobInfo.experienceName || '',
+      degree: jobInfo.degreeName || '',
+      city: jobInfo.locationName || '',
+      district: [jobInfo.areaDistrict, jobInfo.businessDistrict].filter(Boolean).join('·'),
+      description: jobInfo.postDescription || '',
+      skills: (jobInfo.showSkills || []).join(', '),
+      welfare: (brandComInfo.labels || []).join(', '),
+      boss_name: bossInfo.name || '',
+      boss_title: bossInfo.title || '',
+      active_time: bossInfo.activeTimeDesc || '',
+      company: brandComInfo.brandName || bossInfo.brandName || '',
+      industry: brandComInfo.industryName || '',
+      scale: brandComInfo.scaleName || '',
+      stage: brandComInfo.stageName || '',
+      address: jobInfo.address || '',
+      url: jobInfo.encryptId
+        ? 'https://www.zhipin.com/job_detail/' + jobInfo.encryptId + '.html'
+        : '',
+    }];
+  },
+});

package/src/clis/boss/search.ts

@@ -81,7 +81,7 @@ cli({
     { name: 'page', type: 'int', default: 1, help: 'Page number' },
     { name: 'limit', type: 'int', default: 15, help: 'Number of results' },
   ],
-  columns: ['name', 'salary', 'company', 'area', 'experience', 'degree', 'skills', 'boss', 'url'],
+  columns: ['name', 'salary', 'company', 'area', 'experience', 'degree', 'skills', 'boss', 'security_id', 'url'],
   func: async (page: IPage | null, kwargs) => {
     if (!page) throw new Error('Browser page required');
 
@@ -191,6 +191,7 @@ cli({
           degree: j.jobDegree,
           skills: (j.skills || []).join(','),
           boss: j.bossName + ' · ' + j.bossTitle,
+          security_id: j.securityId || '',
           url: 'https://www.zhipin.com/job_detail/' + j.encryptJobId + '.html',
         });
         addedInBatch++;

package/src/clis/twitter/notifications.ts

@@ -30,7 +30,7 @@ cli({
     let results: any[] = [];
     for (const req of requests) {
       try {
-        let instructions = [];
+        let instructions: any[] = [];
         if (req.data?.data?.viewer?.timeline_response?.timeline?.instructions) {
              instructions = req.data.data.viewer.timeline_response.timeline.instructions;
         } else if (req.data?.data?.viewer_v2?.user_results?.result?.notification_timeline?.timeline?.instructions) {

package/src/engine.ts

@@ -185,7 +185,7 @@ export async function executeCommand(
     const { getRegistry, fullName } = await import('./registry.js');
     const updated = getRegistry().get(fullName(cmd));
     if (updated && updated.func) {
-      return updated.func(page, kwargs, debug);
+      return updated.func(page!, kwargs, debug);
     }
     if (updated && updated.pipeline) {
       return executePipeline(page, updated.pipeline, { args: kwargs, debug });
@@ -193,7 +193,7 @@ export async function executeCommand(
   }
 
   if (cmd.func) {
-    return cmd.func(page, kwargs, debug);
+    return cmd.func(page!, kwargs, debug);
   }
   if (cmd.pipeline) {
     return executePipeline(page, cmd.pipeline, { args: kwargs, debug });

package/src/interceptor.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Tests for interceptor.ts: JavaScript code generators for XHR/Fetch interception.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { generateInterceptorJs, generateReadInterceptedJs, generateTapInterceptorJs } from './interceptor.js';
+
+describe('generateInterceptorJs', () => {
+  it('generates valid JavaScript function source', () => {
+    const js = generateInterceptorJs('"api/search"');
+    expect(js).toContain('window.fetch');
+    expect(js).toContain('XMLHttpRequest');
+    expect(js).toContain('"api/search"');
+    // Should be a function expression wrapping
+    expect(js.trim()).toMatch(/^\(\)\s*=>/);
+  });
+
+  it('uses default array name and patch guard', () => {
+    const js = generateInterceptorJs('"test"');
+    expect(js).toContain('__opencli_intercepted');
+    expect(js).toContain('__opencli_interceptor_patched');
+  });
+
+  it('uses custom array name and patch guard', () => {
+    const js = generateInterceptorJs('"test"', {
+      arrayName: '__my_data',
+      patchGuard: '__my_guard',
+    });
+    expect(js).toContain('__my_data');
+    expect(js).toContain('__my_guard');
+    expect(js).not.toContain('__opencli_intercepted');
+  });
+
+  it('includes fetch clone and json parsing', () => {
+    const js = generateInterceptorJs('"api"');
+    expect(js).toContain('response.clone()');
+    expect(js).toContain('clone.json()');
+  });
+
+  it('includes XHR open and send patching', () => {
+    const js = generateInterceptorJs('"api"');
+    expect(js).toContain('XMLHttpRequest.prototype');
+    expect(js).toContain('__origOpen');
+    expect(js).toContain('__origSend');
+  });
+});
+
+describe('generateReadInterceptedJs', () => {
+  it('generates valid JavaScript to read and clear data', () => {
+    const js = generateReadInterceptedJs();
+    expect(js).toContain('__opencli_intercepted');
+    // Should clear the array after reading
+    expect(js).toContain('= []');
+  });
+
+  it('uses custom array name', () => {
+    const js = generateReadInterceptedJs('__custom_arr');
+    expect(js).toContain('__custom_arr');
+    expect(js).not.toContain('__opencli_intercepted');
+  });
+});
+
+describe('generateTapInterceptorJs', () => {
+  it('returns all required fields', () => {
+    const tap = generateTapInterceptorJs('"api/data"');
+
+    expect(tap.setupVar).toBeDefined();
+    expect(tap.capturedVar).toBe('captured');
+    expect(tap.promiseVar).toBe('capturePromise');
+    expect(tap.resolveVar).toBe('captureResolve');
+    expect(tap.fetchPatch).toBeDefined();
+    expect(tap.xhrPatch).toBeDefined();
+    expect(tap.restorePatch).toBeDefined();
+  });
+
+  it('contains the capture pattern in setup', () => {
+    const tap = generateTapInterceptorJs('"my-pattern"');
+    expect(tap.setupVar).toContain('"my-pattern"');
+  });
+
+  it('restores original fetch and XHR in restorePatch', () => {
+    const tap = generateTapInterceptorJs('"test"');
+    expect(tap.restorePatch).toContain('origFetch');
+    expect(tap.restorePatch).toContain('origXhrOpen');
+    expect(tap.restorePatch).toContain('origXhrSend');
+  });
+
+  it('uses first-match capture (only first response)', () => {
+    const tap = generateTapInterceptorJs('"test"');
+    // Both fetch and xhr patches should check !captured before storing
+    expect(tap.fetchPatch).toContain('!captured');
+    expect(tap.xhrPatch).toContain('!captured');
+  });
+});

package/src/output.test.ts

@@ -1,3 +1,7 @@
+/**
+ * Tests for output.ts: render function format coverage.
+ */
+
 import { describe, it, expect, vi, afterEach } from 'vitest';
 import { render } from './output.js';
 
@@ -6,11 +10,67 @@ afterEach(() => {
 });
 
 describe('render', () => {
-  it('renders YAML output', () => {
+  it('renders JSON output', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render([{ title: 'Hello', rank: 1 }], { fmt: 'json' });
+    expect(log).toHaveBeenCalledOnce();
+    const output = log.mock.calls[0]?.[0];
+    const parsed = JSON.parse(output);
+    expect(parsed).toEqual([{ title: 'Hello', rank: 1 }]);
+  });
+
+  it('renders Markdown table output', () => {
     const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render([{ name: 'Alice', score: 100 }], { fmt: 'md', columns: ['name', 'score'] });
+    const calls = log.mock.calls.map(c => c[0]);
+    expect(calls[0]).toContain('| name | score |');
+    expect(calls[1]).toContain('| --- | --- |');
+    expect(calls[2]).toContain('| Alice | 100 |');
+  });
 
-    render([{ title: 'Hello', rank: 1 }], { fmt: 'yaml' });
+  it('renders CSV output with proper quoting', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render([{ name: 'Alice, Bob', value: 'say "hi"' }], { fmt: 'csv' });
+    const calls = log.mock.calls.map(c => c[0]);
+    // Header
+    expect(calls[0]).toBe('name,value');
+    // Values with commas/quotes are quoted
+    expect(calls[1]).toContain('"Alice, Bob"');
+    expect(calls[1]).toContain('"say ""hi"""');
+  });
+
+  it('handles null and undefined data', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render(null, { fmt: 'json' });
+    expect(log).toHaveBeenCalledWith(null);
+  });
+
+  it('renders single object as single-row table', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render({ title: 'Test' }, { fmt: 'json' });
+    const output = log.mock.calls[0]?.[0];
+    const parsed = JSON.parse(output);
+    expect(parsed).toEqual({ title: 'Test' });
+  });
+
+  it('handles empty array gracefully', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render([], { fmt: 'table' });
+    // Should show "(no data)" for empty arrays
+    expect(log).toHaveBeenCalled();
+  });
 
+  it('uses custom columns for CSV', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render([{ a: 1, b: 2, c: 3 }], { fmt: 'csv', columns: ['a', 'c'] });
+    const calls = log.mock.calls.map(c => c[0]);
+    expect(calls[0]).toBe('a,c');
+    expect(calls[1]).toBe('1,3');
+  });
+
+  it('renders YAML output', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render([{ title: 'Hello', rank: 1 }], { fmt: 'yaml' });
     expect(log).toHaveBeenCalledOnce();
     expect(log.mock.calls[0]?.[0]).toContain('- title: Hello');
     expect(log.mock.calls[0]?.[0]).toContain('rank: 1');
@@ -18,10 +78,15 @@ describe('render', () => {
 
   it('renders yml alias as YAML output', () => {
     const log = vi.spyOn(console, 'log').mockImplementation(() => {});
-
     render({ title: 'Hello' }, { fmt: 'yml' });
-
     expect(log).toHaveBeenCalledOnce();
     expect(log.mock.calls[0]?.[0]).toContain('title: Hello');
   });
+
+  it('handles null values in CSV cells', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render([{ name: 'test', value: null }], { fmt: 'csv' });
+    const calls = log.mock.calls.map(c => c[0]);
+    expect(calls[1]).toBe('test,');
+  });
 });

package/src/pipeline/executor.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Tests for pipeline/executor.ts: pipeline execution with mock page.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { executePipeline } from './index.js';
+import type { IPage } from '../types.js';
+
+/** Create a minimal mock page for testing */
+function createMockPage(overrides: Partial<IPage> = {}): IPage {
+  return {
+    goto: vi.fn(),
+    evaluate: vi.fn().mockResolvedValue(null),
+    snapshot: vi.fn().mockResolvedValue(''),
+    click: vi.fn(),
+    typeText: vi.fn(),
+    pressKey: vi.fn(),
+    wait: vi.fn(),
+    tabs: vi.fn().mockResolvedValue([]),
+    closeTab: vi.fn(),
+    newTab: vi.fn(),
+    selectTab: vi.fn(),
+    networkRequests: vi.fn().mockResolvedValue([]),
+    consoleMessages: vi.fn().mockResolvedValue(''),
+    scroll: vi.fn(),
+    autoScroll: vi.fn(),
+    installInterceptor: vi.fn(),
+    getInterceptedRequests: vi.fn().mockResolvedValue([]),
+    ...overrides,
+  };
+}
+
+describe('executePipeline', () => {
+  it('returns null for empty pipeline', async () => {
+    const result = await executePipeline(null, []);
+    expect(result).toBeNull();
+  });
+
+  it('skips null/invalid steps', async () => {
+    const result = await executePipeline(null, [null, undefined, 42] as any);
+    expect(result).toBeNull();
+  });
+
+  it('executes navigate step', async () => {
+    const page = createMockPage();
+    await executePipeline(page, [
+      { navigate: 'https://example.com' },
+    ]);
+    expect(page.goto).toHaveBeenCalledWith('https://example.com');
+  });
+
+  it('executes evaluate + select pipeline', async () => {
+    const page = createMockPage({
+      evaluate: vi.fn().mockResolvedValue({ data: { list: [{ name: 'a' }, { name: 'b' }] } }),
+    });
+    const result = await executePipeline(page, [
+      { evaluate: '() => ({ data: { list: [{name: "a"}, {name: "b"}] } })' },
+      { select: 'data.list' },
+    ]);
+    expect(result).toEqual([{ name: 'a' }, { name: 'b' }]);
+  });
+
+  it('executes map step to transform items', async () => {
+    const page = createMockPage({
+      evaluate: vi.fn().mockResolvedValue([
+        { title: 'Hello', count: 10 },
+        { title: 'World', count: 20 },
+      ]),
+    });
+    const result = await executePipeline(page, [
+      { evaluate: 'test' },
+      { map: { name: '${{ item.title }}', score: '${{ item.count }}' } },
+    ]);
+    expect(result).toEqual([
+      { name: 'Hello', score: 10 },
+      { name: 'World', score: 20 },
+    ]);
+  });
+
+  it('executes limit step', async () => {
+    const page = createMockPage({
+      evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
+    });
+    const result = await executePipeline(page, [
+      { evaluate: 'test' },
+      { limit: '3' },
+    ]);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('executes sort step', async () => {
+    const page = createMockPage({
+      evaluate: vi.fn().mockResolvedValue([{ n: 3 }, { n: 1 }, { n: 2 }]),
+    });
+    const result = await executePipeline(page, [
+      { evaluate: 'test' },
+      { sort: { by: 'n', order: 'asc' } },
+    ]);
+    expect(result).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
+  });
+
+  it('executes sort step with desc order', async () => {
+    const page = createMockPage({
+      evaluate: vi.fn().mockResolvedValue([{ n: 1 }, { n: 3 }, { n: 2 }]),
+    });
+    const result = await executePipeline(page, [
+      { evaluate: 'test' },
+      { sort: { by: 'n', order: 'desc' } },
+    ]);
+    expect(result).toEqual([{ n: 3 }, { n: 2 }, { n: 1 }]);
+  });
+
+  it('executes wait step with number', async () => {
+    const page = createMockPage();
+    await executePipeline(page, [
+      { wait: 2 },
+    ]);
+    expect(page.wait).toHaveBeenCalledWith(2);
+  });
+
+  it('handles unknown steps gracefully in debug mode', async () => {
+    const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    await executePipeline(null, [
+      { unknownStep: 'test' },
+    ], { debug: true });
+    expect(stderr).toHaveBeenCalledWith(expect.stringContaining('Unknown step'));
+    stderr.mockRestore();
+  });
+
+  it('passes args through template rendering', async () => {
+    const page = createMockPage({
+      evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
+    });
+    const result = await executePipeline(page, [
+      { evaluate: 'test' },
+      { limit: '${{ args.count }}' },
+    ], { args: { count: 2 } });
+    expect(result).toEqual([1, 2]);
+  });
+
+  it('click step calls page.click', async () => {
+    const page = createMockPage();
+    await executePipeline(page, [
+      { click: '@5' },
+    ]);
+    expect(page.click).toHaveBeenCalledWith('5');
+  });
+
+  it('navigate preserves existing data through pipeline', async () => {
+    const page = createMockPage({
+      evaluate: vi.fn().mockResolvedValue([{ a: 1 }]),
+    });
+    const result = await executePipeline(page, [
+      { evaluate: 'test' },
+      { navigate: 'https://example.com' },
+    ]);
+    // navigate should preserve existing data
+    expect(result).toEqual([{ a: 1 }]);
+    expect(page.goto).toHaveBeenCalledWith('https://example.com');
+  });
+});

package/src/pipeline/executor.ts

@@ -60,11 +60,6 @@ export async function executePipeline(
         if (debug) process.stderr.write(`  ${chalk.yellow('⚠')}  Unknown step: ${op}\n`);
       }
 
-      // Detect error objects returned by steps (e.g. tap store not found)
-      if (data && typeof data === 'object' && !Array.isArray(data) && data.error) {
-        process.stderr.write(`  ${chalk.yellow('⚠')}  ${chalk.yellow(op)}: ${data.error}\n`);
-        if (data.hint) process.stderr.write(`  ${chalk.dim('💡')} ${chalk.dim(data.hint)}\n`);
-      }
       if (debug) debugStepResult(op, data);
     }
   }

package/src/pipeline/steps/fetch.ts

@@ -45,11 +45,12 @@ async function fetchSingle(
   }
 
   const headersJs = JSON.stringify(renderedHeaders);
-  const escapedUrl = finalUrl.replace(/"/g, '\\"');
+  const urlJs = JSON.stringify(finalUrl);
+  const methodJs = JSON.stringify(method.toUpperCase());
   return page.evaluate(`
     async () => {
-      const resp = await fetch("${escapedUrl}", {
-        method: "${method}", headers: ${headersJs}, credentials: "include"
+      const resp = await fetch(${urlJs}, {
+        method: ${methodJs}, headers: ${headersJs}, credentials: "include"
       });
       return await resp.json();
     }

package/src/registry.ts

@@ -30,7 +30,7 @@ export interface CliCommand {
   browser?: boolean;
   args: Arg[];
   columns?: string[];
-  func?: (page: IPage | null, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
+  func?: (page: IPage, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
   pipeline?: any[];
   timeoutSeconds?: number;
   source?: string;
@@ -50,7 +50,7 @@ export interface CliOptions {
   browser?: boolean;
   args?: Arg[];
   columns?: string[];
-  func?: (page: IPage | null, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
+  func?: (page: IPage, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
   pipeline?: any[];
   timeoutSeconds?: number;
 }

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

@@ -0,0 +1,90 @@
+/**
+ * E2E tests for login-required browser commands.
+ * These commands REQUIRE authentication (cookie/session).
+ * In CI (headless, no login), they should fail gracefully — NOT crash.
+ *
+ * These tests verify the error handling path, not the data extraction.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { runCli } from './helpers.js';
+
+/**
+ * Verify a login-required command fails gracefully (no crash, no hang).
+ * Acceptable outcomes: exit code 1 with error message, OR timeout handled.
+ */
+async function expectGracefulAuthFailure(args: string[], label: string) {
+  const { stdout, stderr, code } = await runCli(args, { timeout: 60_000 });
+  // Should either fail with exit code 1 (error message) or succeed with empty data
+  // The key assertion: it should NOT hang forever or crash with unhandled exception
+  if (code !== 0) {
+    // Verify stderr has a meaningful error, not an unhandled crash
+    const output = stderr + stdout;
+    expect(output.length).toBeGreaterThan(0);
+  }
+  // If it somehow succeeds (e.g., partial public data), that's fine too
+}
+
+describe('login-required commands — graceful failure', () => {
+
+  // ── bilibili (requires cookie session) ──
+  it('bilibili me fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['bilibili', 'me', '-f', 'json'], 'bilibili me');
+  }, 60_000);
+
+  it('bilibili dynamic fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['bilibili', 'dynamic', '--limit', '3', '-f', 'json'], 'bilibili dynamic');
+  }, 60_000);
+
+  it('bilibili favorite fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['bilibili', 'favorite', '--limit', '3', '-f', 'json'], 'bilibili favorite');
+  }, 60_000);
+
+  it('bilibili history fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['bilibili', 'history', '--limit', '3', '-f', 'json'], 'bilibili history');
+  }, 60_000);
+
+  it('bilibili following fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['bilibili', 'following', '--limit', '3', '-f', 'json'], 'bilibili following');
+  }, 60_000);
+
+  // ── twitter (requires login) ──
+  it('twitter bookmarks fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['twitter', 'bookmarks', '--limit', '3', '-f', 'json'], 'twitter bookmarks');
+  }, 60_000);
+
+  it('twitter timeline fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['twitter', 'timeline', '--limit', '3', '-f', 'json'], 'twitter timeline');
+  }, 60_000);
+
+  it('twitter notifications fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['twitter', 'notifications', '--limit', '3', '-f', 'json'], 'twitter notifications');
+  }, 60_000);
+
+  // ── v2ex (requires login) ──
+  it('v2ex me fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['v2ex', 'me', '-f', 'json'], 'v2ex me');
+  }, 60_000);
+
+  it('v2ex notifications fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['v2ex', 'notifications', '--limit', '3', '-f', 'json'], 'v2ex notifications');
+  }, 60_000);
+
+  // ── xueqiu (requires login) ──
+  it('xueqiu feed fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['xueqiu', 'feed', '--limit', '3', '-f', 'json'], 'xueqiu feed');
+  }, 60_000);
+
+  it('xueqiu watchlist fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['xueqiu', 'watchlist', '-f', 'json'], 'xueqiu watchlist');
+  }, 60_000);
+
+  // ── xiaohongshu (requires login) ──
+  it('xiaohongshu feed fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['xiaohongshu', 'feed', '--limit', '3', '-f', 'json'], 'xiaohongshu feed');
+  }, 60_000);
+
+  it('xiaohongshu notifications fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['xiaohongshu', 'notifications', '--limit', '3', '-f', 'json'], 'xiaohongshu notifications');
+  }, 60_000);
+});