@jackwener/opencli 1.5.5 → 1.5.6

package/src/clis/zsxq/utils.ts

@@ -0,0 +1,351 @@
+import { ArgumentError, AuthRequiredError, CliError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+
+export interface ZsxqUser {
+  user_id?: number;
+  name?: string;
+  avatar_url?: string;
+}
+
+export interface ZsxqGroup {
+  group_id?: number;
+  name?: string;
+  description?: string;
+  background_url?: string;
+  owner?: ZsxqUser;
+  statistics?: {
+    topics_count?: number;
+    answers_count?: number;
+    comments_count?: number;
+    likes_count?: number;
+    subscriptions_count?: number;
+  };
+  category?: {
+    title?: string;
+  };
+  user_specific?: {
+    join_time?: string;
+    validity?: {
+      end_time?: string;
+    };
+  };
+}
+
+export interface ZsxqComment {
+  comment_id?: number;
+  create_time?: string;
+  text?: string;
+  owner?: ZsxqUser;
+  likes_count?: number;
+  rewards_count?: number;
+  repliee?: ZsxqUser;
+}
+
+export interface ZsxqTopic {
+  topic_id?: number;
+  create_time?: string;
+  comments_count?: number;
+  likes_count?: number;
+  readers_count?: number;
+  reading_count?: number;
+  rewards_count?: number;
+  title?: string;
+  type?: string;
+  group?: ZsxqGroup;
+  owner?: ZsxqUser;
+  user_specific?: Record<string, unknown>;
+  talk?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  question?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  answer?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  task?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  solution?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  show_comments?: ZsxqComment[];
+  comments?: ZsxqComment[];
+}
+
+export interface BrowserFetchResult {
+  ok: boolean;
+  url?: string;
+  status?: number;
+  error?: string;
+  data?: unknown;
+}
+
+const SITE_DOMAIN = 'wx.zsxq.com';
+const SITE_URL = 'https://wx.zsxq.com';
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function pickArray<T>(...values: unknown[]): T[] {
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      return value as T[];
+    }
+  }
+  return [];
+}
+
+export async function ensureZsxqPage(page: IPage): Promise<void> {
+  await page.goto(SITE_URL);
+}
+
+export async function ensureZsxqAuth(page: IPage): Promise<void> {
+  // zsxq uses httpOnly cookies that may be on different subdomains.
+  // Verify auth by attempting a lightweight API call instead of checking cookies.
+  try {
+    const result = await page.evaluate(`
+      (async () => {
+        try {
+          const r = await new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            xhr.open('GET', 'https://api.zsxq.com/v2/groups', true);
+            xhr.withCredentials = true;
+            xhr.setRequestHeader('accept', 'application/json');
+            xhr.onload = () => {
+              if (xhr.status >= 200 && xhr.status < 300) {
+                try { resolve(JSON.parse(xhr.responseText)); }
+                catch { resolve(null); }
+              } else { resolve(null); }
+            };
+            xhr.onerror = () => resolve(null);
+            xhr.send();
+          });
+          return r !== null;
+        } catch { return false; }
+      })()
+    `);
+    if (!result) {
+      throw new AuthRequiredError('zsxq.com');
+    }
+  } catch (err) {
+    if (err instanceof AuthRequiredError) throw err;
+    throw new AuthRequiredError('zsxq.com');
+  }
+}
+
+export async function getCookieValue(page: IPage, name: string): Promise<string | undefined> {
+  const cookies = await page.getCookies({ domain: SITE_DOMAIN });
+  return cookies.find(cookie => cookie.name === name)?.value;
+}
+
+export async function getActiveGroupId(page: IPage): Promise<string> {
+  const groupId = await page.evaluate(`
+    (() => {
+      const target = localStorage.getItem('target_group');
+      if (target) {
+        try {
+          const parsed = JSON.parse(target);
+          if (parsed.group_id) return String(parsed.group_id);
+        } catch {}
+      }
+      return null;
+    })()
+  `);
+  if (groupId) return groupId;
+
+  throw new ArgumentError(
+    'Cannot determine active group_id',
+    'Pass --group_id <id> or open the target 知识星球 page in Chrome first',
+  );
+}
+
+export async function browserJsonRequest(page: IPage, path: string): Promise<BrowserFetchResult> {
+  return await page.evaluate(`
+    (async () => {
+      const path = ${JSON.stringify(path)};
+
+      try {
+        return await new Promise((resolve) => {
+          const xhr = new XMLHttpRequest();
+          xhr.open('GET', path, true);
+          xhr.withCredentials = true;
+          xhr.setRequestHeader('accept', 'application/json, text/plain, */*');
+          xhr.onload = () => {
+            let parsed = null;
+            if (xhr.responseText) {
+              try { parsed = JSON.parse(xhr.responseText); }
+              catch {}
+            }
+
+            resolve({
+              ok: xhr.status >= 200 && xhr.status < 300,
+              url: path,
+              status: xhr.status,
+              data: parsed,
+              error: xhr.status >= 200 && xhr.status < 300 ? undefined : 'HTTP ' + xhr.status,
+            });
+          };
+          xhr.onerror = () => resolve({
+            ok: false,
+            url: path,
+            error: 'Network error',
+          });
+          xhr.send();
+        });
+      } catch (error) {
+        return {
+          ok: false,
+          url: path,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    })()
+  `) as BrowserFetchResult;
+}
+
+export async function fetchFirstJson(page: IPage, paths: string[]): Promise<BrowserFetchResult> {
+  let lastFailure: BrowserFetchResult | null = null;
+
+  for (const path of paths) {
+    const result = await browserJsonRequest(page, path);
+    if (result.ok) {
+      return result;
+    }
+    lastFailure = result;
+  }
+
+  if (!lastFailure) {
+    throw new CliError(
+      'FETCH_ERROR',
+      'No candidate endpoint returned JSON',
+      `Checked endpoints: ${paths.join(', ')}`,
+    );
+  }
+
+  throw new CliError(
+    'FETCH_ERROR',
+    lastFailure.error || 'Failed to fetch ZSXQ API',
+    `Checked endpoints: ${paths.join(', ')}`,
+  );
+}
+
+export function unwrapRespData<T>(payload: unknown): T {
+  const record = asRecord(payload);
+  if (!record) {
+    throw new CliError('PARSE_ERROR', 'Invalid ZSXQ API response');
+  }
+
+  if (record.succeeded === false) {
+    const code = typeof record.code === 'number' ? String(record.code) : 'API_ERROR';
+    const message = typeof record.info === 'string'
+      ? record.info
+      : typeof record.error === 'string'
+        ? record.error
+        : 'ZSXQ API returned an error';
+    throw new CliError(code, message);
+  }
+
+  return (record.resp_data ?? record.data ?? payload) as T;
+}
+
+export function getTopicsFromResponse(payload: unknown): ZsxqTopic[] {
+  const data = unwrapRespData<Record<string, unknown> | ZsxqTopic[]>(payload);
+  if (Array.isArray(data)) return data;
+  return pickArray<ZsxqTopic>(
+    data.topics,
+    data.list,
+    data.records,
+    data.items,
+    data.search_result,
+  );
+}
+
+export function getCommentsFromResponse(payload: unknown): ZsxqComment[] {
+  const data = unwrapRespData<Record<string, unknown> | ZsxqComment[]>(payload);
+  if (Array.isArray(data)) return data;
+  return pickArray<ZsxqComment>(data.comments, data.list, data.items);
+}
+
+export function getGroupsFromResponse(payload: unknown): ZsxqGroup[] {
+  const data = unwrapRespData<Record<string, unknown> | ZsxqGroup[]>(payload);
+  if (Array.isArray(data)) return data;
+  return pickArray<ZsxqGroup>(data.groups, data.list, data.items);
+}
+
+export function getTopicFromResponse(payload: unknown): ZsxqTopic | null {
+  const data = unwrapRespData<Record<string, unknown> | ZsxqTopic>(payload);
+  if (Array.isArray(data)) return data[0] ?? null;
+  if (typeof data.topic_id === 'number') return data;
+  const record = asRecord(data);
+  if (!record) return null;
+  const topic = record.topic;
+  return topic && typeof topic === 'object' ? topic as ZsxqTopic : null;
+}
+
+export function getTopicAuthor(topic: ZsxqTopic): string {
+  return (
+    topic.owner?.name ||
+    topic.talk?.owner?.name ||
+    topic.question?.owner?.name ||
+    topic.answer?.owner?.name ||
+    topic.task?.owner?.name ||
+    topic.solution?.owner?.name ||
+    ''
+  );
+}
+
+export function getTopicText(topic: ZsxqTopic): string {
+  const primary = [
+    topic.title,
+    topic.talk?.text,
+    topic.question?.text,
+    topic.answer?.text,
+    topic.task?.text,
+    topic.solution?.text,
+  ].find(value => typeof value === 'string' && value.trim());
+  return (primary || '').replace(/\s+/g, ' ').trim();
+}
+
+export function getTopicUrl(topicId: number | string | undefined): string {
+  return topicId ? `${SITE_URL}/topic/${topicId}` : SITE_URL;
+}
+
+export function summarizeComments(comments: ZsxqComment[], limit: number = 3): string {
+  return comments
+    .slice(0, limit)
+    .map((comment) => {
+      const author = comment.owner?.name || '匿名';
+      const target = comment.repliee?.name ? ` -> ${comment.repliee.name}` : '';
+      const text = (comment.text || '').replace(/\s+/g, ' ').trim();
+      return `${author}${target}: ${text}`;
+    })
+    .join(' | ');
+}
+
+export function toTopicRow(topic: ZsxqTopic): Record<string, unknown> {
+  const topicId = topic.topic_id ?? '';
+  const comments = pickArray<ZsxqComment>(topic.show_comments, topic.comments);
+  return {
+    topic_id: topicId,
+    type: topic.type || '',
+    group: topic.group?.name || '',
+    author: getTopicAuthor(topic),
+    title: getTopicText(topic).slice(0, 120),
+    content: getTopicText(topic),
+    comments: topic.comments_count ?? comments.length ?? 0,
+    likes: topic.likes_count ?? 0,
+    readers: topic.readers_count ?? topic.reading_count ?? 0,
+    time: topic.create_time || '',
+    comment_preview: summarizeComments(comments),
+    url: getTopicUrl(topicId),
+  };
+}

package/src/commanderAdapter.test.ts

@@ -76,3 +76,50 @@ describe('commanderAdapter arg passing', () => {
     expect(mockExecuteCommand).not.toHaveBeenCalled();
   });
 });
+
+describe('commanderAdapter boolean alias support', () => {
+  const cmd: CliCommand = {
+    site: 'reddit',
+    name: 'save',
+    description: 'Save a post',
+    browser: false,
+    args: [
+      { name: 'post-id', positional: true, required: true, help: 'Post ID' },
+      { name: 'undo', type: 'boolean', default: false, help: 'Unsave instead of save' },
+    ],
+    func: vi.fn(),
+  };
+
+  beforeEach(() => {
+    mockExecuteCommand.mockReset();
+    mockExecuteCommand.mockResolvedValue([]);
+    mockRenderOutput.mockReset();
+    delete process.env.OPENCLI_VERBOSE;
+    process.exitCode = undefined;
+  });
+
+  it('coerces default false for boolean args to a real boolean', async () => {
+    const program = new Command();
+    const siteCmd = program.command('reddit');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'reddit', 'save', 't3_abc123']);
+
+    expect(mockExecuteCommand).toHaveBeenCalled();
+    const kwargs = mockExecuteCommand.mock.calls[0][1];
+    expect(kwargs['post-id']).toBe('t3_abc123');
+    expect(kwargs.undo).toBe(false);
+  });
+
+  it('coerces explicit false for boolean args to a real boolean', async () => {
+    const program = new Command();
+    const siteCmd = program.command('reddit');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'reddit', 'save', 't3_abc123', '--undo', 'false']);
+
+    expect(mockExecuteCommand).toHaveBeenCalled();
+    const kwargs = mockExecuteCommand.mock.calls[0][1];
+    expect(kwargs.undo).toBe(false);
+  });
+});

package/src/commanderAdapter.ts

@@ -33,7 +33,7 @@ import {
 import { checkDaemonStatus } from './browser/discover.js';
 
 export function normalizeArgValue(argType: string | undefined, value: unknown, name: string): unknown {
-  if (argType !== 'bool') return value;
+  if (argType !== 'bool' && argType !== 'boolean') return value;
   if (typeof value === 'boolean') return value;
   if (value == null || value === '') return false;
 

package/src/external-clis.yaml

@@ -30,6 +30,23 @@
   install:
     default: "npm install -g @larksuite/cli"
 
+- name: dws
+  binary: dws
+  description: "DingTalk Workspace CLI — messages, docs, calendar, contacts and more for humans and AI agents"
+  homepage: "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli"
+  tags: [dingtalk, collaboration, productivity, ai-agent]
+  install:
+    mac: "curl -fsSL https://raw.githubusercontent.com/DingTalk-Real-AI/dingtalk-workspace-cli/main/scripts/install.sh | sh"
+    linux: "curl -fsSL https://raw.githubusercontent.com/DingTalk-Real-AI/dingtalk-workspace-cli/main/scripts/install.sh | sh"
+
+- name: wecom-cli
+  binary: wecom-cli
+  description: "WeCom/企业微信 CLI — contacts, todos, meetings, messages, calendar, docs and smart sheets for AI agents"
+  homepage: "https://github.com/WecomTeam/wecom-cli"
+  tags: [wecom, wechat-work, collaboration, productivity, ai-agent]
+  install:
+    default: "npm install -g @wecom/cli"
+
 - name: vercel
   binary: vercel
   description: "Vercel CLI — deploy projects, manage domains, env vars, logs and serverless functions"

package/src/types.ts

@@ -67,6 +67,11 @@ export interface IPage {
   getInterceptedRequests(): Promise<any[]>;
   waitForCapture(timeout?: number): Promise<void>;
   screenshot(options?: ScreenshotOptions): Promise<string>;
+  /**
+   * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
+   * Chrome reads the files directly — no base64 encoding or payload size limits.
+   */
+  setFileInput?(files: string[], selector?: string): Promise<void>;
   closeWindow?(): Promise<void>;
   /** Returns the current page URL, or null if unavailable. */
   getCurrentUrl?(): Promise<string | null>;

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

@@ -0,0 +1,20 @@
+import { describe, it } from 'vitest';
+import { expectGracefulAuthFailure } from './browser-auth-helpers.js';
+
+describe('band auth-required commands — graceful failure', () => {
+  it('band bands fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['band', 'bands', '-f', 'json']);
+  }, 60_000);
+
+  it('band mentions fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['band', 'mentions', '--limit', '3', '-f', 'json']);
+  }, 60_000);
+
+  it('band posts fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['band', 'posts', '58400480', '--limit', '3', '-f', 'json']);
+  }, 60_000);
+
+  it('band post fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['band', 'post', '58400480', '1', '-f', 'json']);
+  }, 60_000);
+});

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

@@ -0,0 +1,18 @@
+import { 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.
+ */
+export async function expectGracefulAuthFailure(args: 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.
+}

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

@@ -6,148 +6,136 @@
  * 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
-}
+import { describe, it } from 'vitest';
+import { expectGracefulAuthFailure } from './browser-auth-helpers.js';
 
 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');
+    await expectGracefulAuthFailure(['bilibili', 'me', '-f', 'json']);
   }, 60_000);
 
   it('bilibili dynamic fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['bilibili', 'dynamic', '--limit', '3', '-f', 'json'], 'bilibili dynamic');
+    await expectGracefulAuthFailure(['bilibili', 'dynamic', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('bilibili favorite fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['bilibili', 'favorite', '--limit', '3', '-f', 'json'], 'bilibili favorite');
+    await expectGracefulAuthFailure(['bilibili', 'favorite', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('bilibili history fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['bilibili', 'history', '--limit', '3', '-f', 'json'], 'bilibili history');
+    await expectGracefulAuthFailure(['bilibili', 'history', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('bilibili following fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['bilibili', 'following', '--limit', '3', '-f', 'json'], 'bilibili following');
+    await expectGracefulAuthFailure(['bilibili', 'following', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   // ── twitter (requires login) ──
   it('twitter bookmarks fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['twitter', 'bookmarks', '--limit', '3', '-f', 'json'], 'twitter bookmarks');
+    await expectGracefulAuthFailure(['twitter', 'bookmarks', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('twitter timeline fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['twitter', 'timeline', '--limit', '3', '-f', 'json'], 'twitter timeline');
+    await expectGracefulAuthFailure(['twitter', 'timeline', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('twitter notifications fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['twitter', 'notifications', '--limit', '3', '-f', 'json'], 'twitter notifications');
+    await expectGracefulAuthFailure(['twitter', 'notifications', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   // ── v2ex (requires login) ──
   it('v2ex me fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['v2ex', 'me', '-f', 'json'], 'v2ex me');
+    await expectGracefulAuthFailure(['v2ex', 'me', '-f', 'json']);
   }, 60_000);
 
   it('v2ex notifications fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['v2ex', 'notifications', '--limit', '3', '-f', 'json'], 'v2ex notifications');
+    await expectGracefulAuthFailure(['v2ex', 'notifications', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   // ── xueqiu (requires login) ──
   it('xueqiu feed fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['xueqiu', 'feed', '--limit', '3', '-f', 'json'], 'xueqiu feed');
+    await expectGracefulAuthFailure(['xueqiu', 'feed', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('xueqiu watchlist fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['xueqiu', 'watchlist', '-f', 'json'], 'xueqiu watchlist');
+    await expectGracefulAuthFailure(['xueqiu', 'watchlist', '-f', 'json']);
+  }, 60_000);
+
+  it('xueqiu comments fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['xueqiu', 'comments', 'SH600519', '--limit', '3', '-f', 'json'], 'xueqiu comments');
   }, 60_000);
 
   // ── linux-do (requires login — all endpoints need authentication) ──
   it('linux-do feed fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['linux-do', 'feed', '--limit', '3', '-f', 'json'], 'linux-do feed');
+    await expectGracefulAuthFailure(['linux-do', 'feed', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('linux-do categories fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['linux-do', 'categories', '--limit', '3', '-f', 'json'], 'linux-do categories');
+    await expectGracefulAuthFailure(['linux-do', 'categories', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('linux-do tags fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['linux-do', 'tags', '--limit', '3', '-f', 'json'], 'linux-do tags');
+    await expectGracefulAuthFailure(['linux-do', 'tags', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('linux-do topic fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['linux-do', 'topic', '1', '-f', 'json'], 'linux-do topic');
+    await expectGracefulAuthFailure(['linux-do', 'topic', '1', '-f', 'json']);
   }, 60_000);
 
   it('linux-do search fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['linux-do', 'search', 'test', '--limit', '3', '-f', 'json'], 'linux-do search');
+    await expectGracefulAuthFailure(['linux-do', 'search', 'test', '--limit', '3', '-f', 'json']);
   }, 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');
+    await expectGracefulAuthFailure(['linux-do', 'user-topics', 'test', '--limit', '3', '-f', 'json']);
   }, 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');
+    await expectGracefulAuthFailure(['linux-do', 'user-posts', 'test', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   // ── xiaohongshu (requires login) ──
   it('xiaohongshu feed fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['xiaohongshu', 'feed', '--limit', '3', '-f', 'json'], 'xiaohongshu feed');
+    await expectGracefulAuthFailure(['xiaohongshu', 'feed', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('xiaohongshu notifications fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['xiaohongshu', 'notifications', '--limit', '3', '-f', 'json'], 'xiaohongshu notifications');
+    await expectGracefulAuthFailure(['xiaohongshu', 'notifications', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   // ── pixiv (requires login) ──
   it('pixiv ranking fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['pixiv', 'ranking', '--limit', '3', '-f', 'json'], 'pixiv ranking');
+    await expectGracefulAuthFailure(['pixiv', 'ranking', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('pixiv search fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['pixiv', 'search', '初音ミク', '--limit', '3', '-f', 'json'], 'pixiv search');
+    await expectGracefulAuthFailure(['pixiv', 'search', '初音ミク', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('pixiv user fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['pixiv', 'user', '11', '-f', 'json'], 'pixiv user');
+    await expectGracefulAuthFailure(['pixiv', 'user', '11', '-f', 'json']);
   }, 60_000);
 
   it('pixiv illusts fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['pixiv', 'illusts', '11', '--limit', '3', '-f', 'json'], 'pixiv illusts');
+    await expectGracefulAuthFailure(['pixiv', 'illusts', '11', '--limit', '3', '-f', 'json']);
   }, 60_000);
 
   it('pixiv detail fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['pixiv', 'detail', '123456', '-f', 'json'], 'pixiv detail');
+    await expectGracefulAuthFailure(['pixiv', 'detail', '123456', '-f', 'json']);
   }, 60_000);
 
   it('pixiv download fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['pixiv', 'download', '123456', '--output', '/tmp/pixiv-e2e-test', '-f', 'json'], 'pixiv download');
+    await expectGracefulAuthFailure(['pixiv', 'download', '123456', '--output', '/tmp/pixiv-e2e-test', '-f', 'json']);
   }, 60_000);
 
   // ── yollomi (requires login session) ──
   it('yollomi generate fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['yollomi', 'generate', 'a cute cat', '--no-download', '-f', 'json'], 'yollomi generate');
+    await expectGracefulAuthFailure(['yollomi', 'generate', 'a cute cat', '--no-download', '-f', 'json']);
   }, 60_000);
 
   it('yollomi video fails gracefully without login', async () => {
-    await expectGracefulAuthFailure(['yollomi', 'video', 'a sunset over the ocean', '--no-download', '-f', 'json'], 'yollomi video');
+    await expectGracefulAuthFailure(['yollomi', 'video', 'a sunset over the ocean', '--no-download', '-f', 'json']);
   }, 60_000);
 });