@jackwener/opencli 1.1.1 → 1.2.0

package/src/clis/tiktok/unlike.yaml

@@ -0,0 +1,38 @@
+site: tiktok
+name: unlike
+description: Unlike a TikTok video
+domain: www.tiktok.com
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: TikTok video URL
+
+pipeline:
+  - navigate:
+      url: ${{ args.url }}
+      settleMs: 6000
+
+  - evaluate: |
+      (async () => {
+        const url = ${{ args.url | json }};
+        const btn = document.querySelector('[data-e2e="like-icon"]');
+        if (!btn) throw new Error('Like button not found - make sure you are logged in');
+        const container = btn.closest('button') || btn.closest('[role="button"]') || btn;
+        const aria = (container.getAttribute('aria-label') || '').toLowerCase();
+        const color = window.getComputedStyle(btn).color;
+        const isLiked = aria.includes('unlike') || aria.includes('取消点赞') ||
+                        (color && (color.includes('255, 65') || color.includes('fe2c55')));
+        if (!isLiked) {
+          const count = document.querySelector('[data-e2e="like-count"]');
+          return [{ status: 'Not liked', likes: count ? count.textContent.trim() : '-', url: url }];
+        }
+        container.click();
+        await new Promise(r => setTimeout(r, 2000));
+        const count = document.querySelector('[data-e2e="like-count"]');
+        return [{ status: 'Unliked', likes: count ? count.textContent.trim() : '-', url: url }];
+      })()
+
+columns: [status, likes, url]

package/src/clis/tiktok/unsave.yaml

@@ -0,0 +1,36 @@
+site: tiktok
+name: unsave
+description: Remove a TikTok video from Favorites
+domain: www.tiktok.com
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: TikTok video URL
+
+pipeline:
+  - navigate:
+      url: ${{ args.url }}
+      settleMs: 6000
+
+  - evaluate: |
+      (async () => {
+        const url = ${{ args.url | json }};
+        const btn = document.querySelector('[data-e2e="bookmark-icon"]') ||
+                    document.querySelector('[data-e2e="collect-icon"]');
+        if (!btn) throw new Error('Favorites button not found - make sure you are logged in');
+        const container = btn.closest('button') || btn.closest('[role="button"]') || btn;
+        const aria = (container.getAttribute('aria-label') || '').toLowerCase();
+        if (aria.includes('add to favorites') || aria.includes('收藏')) {
+          if (!aria.includes('remove') && !aria.includes('取消')) {
+            return [{ status: 'Not in Favorites', url: url }];
+          }
+        }
+        container.click();
+        await new Promise(r => setTimeout(r, 2000));
+        return [{ status: 'Removed from Favorites', url: url }];
+      })()
+
+columns: [status, url]

package/src/clis/tiktok/user.yaml

@@ -0,0 +1,44 @@
+site: tiktok
+name: user
+description: Get recent videos from a TikTok user
+domain: www.tiktok.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: TikTok username (without @)
+  limit:
+    type: int
+    default: 10
+    description: Number of videos
+
+pipeline:
+  - navigate:
+      url: https://www.tiktok.com/@${{ args.username }}
+      settleMs: 6000
+
+  - evaluate: |
+      (() => {
+        const limit = ${{ args.limit }};
+        const username = ${{ args.username | json }};
+        const links = Array.from(document.querySelectorAll('a[href*="/video/"]'));
+        const seen = {};
+        const results = [];
+        for (const a of links) {
+          const href = a.href;
+          if (seen[href]) continue;
+          seen[href] = true;
+          results.push({
+            index: results.length + 1,
+            views: a.textContent.trim() || '-',
+            url: href,
+          });
+          if (results.length >= limit) break;
+        }
+        if (results.length === 0) throw new Error('No videos found for @' + username);
+        return results;
+      })()
+
+columns: [index, views, url]

package/src/clis/twitter/download.ts

@@ -2,7 +2,7 @@
  * Twitter/X download — download images and videos from tweets.
  *
  * Usage:
- *   opencli twitter download --username elonmusk --limit 10 --output ./twitter
+ *   opencli twitter download elonmusk --limit 10 --output ./twitter
  *   opencli twitter download --tweet-url https://x.com/xxx/status/123 --output ./twitter
  */
 
@@ -27,7 +27,7 @@ cli({
   domain: 'x.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'username', help: 'Twitter username (downloads from media tab)' },
+    { name: 'username', positional: true, help: 'Twitter username (downloads from media tab)' },
     { name: 'tweet-url', help: 'Single tweet URL to download' },
     { name: 'limit', type: 'int', default: 10, help: 'Number of tweets to scan' },
     { name: 'output', default: './twitter-downloads', help: 'Output directory' },
@@ -44,7 +44,7 @@ cli({
         index: 0,
         type: '-',
         status: 'failed',
-        size: 'Must provide --username or --tweet-url',
+        size: 'Must provide a username or --tweet-url',
       }];
     }
 

package/src/clis/twitter/followers.ts

@@ -8,7 +8,7 @@ cli({
   strategy: Strategy.INTERCEPT,
   browser: true,
   args: [
-    { name: 'user', type: 'string', required: false },
+    { name: 'user', positional: true, type: 'string', required: false },
     { name: 'limit', type: 'int', default: 50 },
   ],
   columns: ['screen_name', 'name', 'bio', 'followers'],

package/src/clis/twitter/following.ts

@@ -8,7 +8,7 @@ cli({
   strategy: Strategy.INTERCEPT,
   browser: true,
   args: [
-    { name: 'user', type: 'string', required: false },
+    { name: 'user', positional: true, type: 'string', required: false },
     { name: 'limit', type: 'int', default: 50 },
   ],
   columns: ['screen_name', 'name', 'bio', 'followers'],

package/src/clis/twitter/thread.ts

@@ -122,7 +122,7 @@ cli({
   strategy: Strategy.COOKIE,
   browser: true,
   args: [
-    { name: 'tweet-id', type: 'string', required: true },
+    { name: 'tweet-id', positional: true, type: 'string', required: true },
     { name: 'limit', type: 'int', default: 50 },
   ],
   columns: ['id', 'author', 'text', 'likes', 'retweets', 'url'],

package/src/clis/twitter/timeline.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './timeline.js';
+
+describe('twitter timeline helpers', () => {
+  it('builds for-you variables with withCommunity', () => {
+    expect(__test__.buildTimelineVariables('for-you', 20)).toEqual({
+      count: 20,
+      includePromotedContent: false,
+      latestControlAvailable: true,
+      requestContext: 'launch',
+      withCommunity: true,
+    });
+  });
+
+  it('builds following variables with seenTweetIds instead of withCommunity', () => {
+    expect(__test__.buildTimelineVariables('following', 20, 'cursor-1')).toEqual({
+      count: 20,
+      includePromotedContent: false,
+      latestControlAvailable: true,
+      requestContext: 'launch',
+      seenTweetIds: [],
+      cursor: 'cursor-1',
+    });
+  });
+
+  it('encodes variables into timeline url', () => {
+    const url = __test__.buildHomeTimelineUrl('query123', 'HomeLatestTimeline', {
+      count: 20,
+      seenTweetIds: [],
+    });
+
+    expect(url).toContain('/i/api/graphql/query123/HomeLatestTimeline');
+    expect(url).toContain('variables=');
+    expect(url).toContain('features=');
+    expect(decodeURIComponent(url)).toContain('"seenTweetIds":[]');
+  });
+
+  it('parses tweets and bottom cursor from home timeline payload', () => {
+    const payload = {
+      data: {
+        home: {
+          home_timeline_urt: {
+            instructions: [
+              {
+                entries: [
+                  {
+                    entryId: 'tweet-1',
+                    content: {
+                      itemContent: {
+                        tweet_results: {
+                          result: {
+                            rest_id: '1',
+                            legacy: {
+                              full_text: 'hello',
+                              favorite_count: 3,
+                              retweet_count: 2,
+                              reply_count: 1,
+                              created_at: 'now',
+                            },
+                            core: {
+                              user_results: {
+                                result: {
+                                  legacy: {
+                                    screen_name: 'alice',
+                                  },
+                                },
+                              },
+                            },
+                            views: {
+                              count: '9',
+                            },
+                          },
+                        },
+                      },
+                    },
+                  },
+                  {
+                    entryId: 'cursor-bottom-1',
+                    content: {
+                      entryType: 'TimelineTimelineCursor',
+                      cursorType: 'Bottom',
+                      value: 'cursor-next',
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const result = __test__.parseHomeTimeline(payload, new Set());
+
+    expect(result.nextCursor).toBe('cursor-next');
+    expect(result.tweets).toHaveLength(1);
+    expect(result.tweets[0]).toMatchObject({
+      id: '1',
+      author: 'alice',
+      text: 'hello',
+      likes: 3,
+      retweets: 2,
+      replies: 1,
+      views: 9,
+      created_at: 'now',
+      url: 'https://x.com/alice/status/1',
+    });
+  });
+});

package/src/clis/twitter/timeline.ts

@@ -2,8 +2,24 @@ import { cli, Strategy } from '../../registry.js';
 
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 
-const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+const BEARER_TOKEN =
+  'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const HOME_TIMELINE_QUERY_ID = 'c-CzHF1LboFilMpsx4ZCrQ';
+const HOME_LATEST_TIMELINE_QUERY_ID = 'BKB7oi212Fi7kQtCBGE4zA';
+
+type TimelineType = 'for-you' | 'following';
+
+interface TimelineEndpointConfig {
+  endpoint: string;
+  method: 'GET' | 'POST';
+  fallbackQueryId: string;
+}
+
+// Endpoint config: for-you uses GET HomeTimeline, following uses POST HomeLatestTimeline
+const TIMELINE_ENDPOINTS: Record<TimelineType, TimelineEndpointConfig> = {
+  'for-you': { endpoint: 'HomeTimeline', method: 'GET', fallbackQueryId: HOME_TIMELINE_QUERY_ID },
+  following: { endpoint: 'HomeLatestTimeline', method: 'POST', fallbackQueryId: HOME_LATEST_TIMELINE_QUERY_ID },
+};
 
 const FEATURES = {
   rweb_video_screen_enabled: false,
@@ -53,19 +69,26 @@ interface TimelineTweet {
   url: string;
 }
 
-function buildHomeTimelineUrl(count: number, cursor?: string | null): string {
-  const vars: Record<string, any> = {
+function buildTimelineVariables(type: TimelineType, count: number, cursor?: string | null): Record<string, unknown> {
+  const vars: Record<string, unknown> = {
     count,
     includePromotedContent: false,
     latestControlAvailable: true,
     requestContext: 'launch',
-    withCommunity: true,
   };
+  if (type === 'for-you') vars.withCommunity = true;
+  if (type === 'following') vars.seenTweetIds = [];
   if (cursor) vars.cursor = cursor;
+  return vars;
+}
+
+function buildHomeTimelineUrl(queryId: string, endpoint: string, vars: Record<string, unknown>): string {
 
-  return `/i/api/graphql/${HOME_TIMELINE_QUERY_ID}/HomeTimeline`
-    + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
-    + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+  return (
+    `/i/api/graphql/${queryId}/${endpoint}` +
+    `?variables=${encodeURIComponent(JSON.stringify(vars))}` +
+    `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`
+  );
 }
 
 function extractTweet(result: any, seen: Set<string>): TimelineTweet | null {
@@ -97,8 +120,8 @@ function parseHomeTimeline(data: any, seen: Set<string>): { tweets: TimelineTwee
   const tweets: TimelineTweet[] = [];
   let nextCursor: string | null = null;
 
-  const instructions =
-    data?.data?.home?.home_timeline_urt?.instructions || [];
+  // Both HomeTimeline and HomeLatestTimeline share the same response envelope
+  const instructions = data?.data?.home?.home_timeline_urt?.instructions || [];
 
   for (const inst of instructions) {
     for (const entry of inst.entries || []) {
@@ -144,16 +167,24 @@ function parseHomeTimeline(data: any, seen: Set<string>): { tweets: TimelineTwee
 cli({
   site: 'twitter',
   name: 'timeline',
-  description: 'Fetch Twitter Home Timeline',
+  description: 'Fetch Twitter timeline (for-you or following)',
   domain: 'x.com',
   strategy: Strategy.COOKIE,
   browser: true,
   args: [
+    {
+      name: 'type',
+      default: 'for-you',
+      choices: ['for-you', 'following'],
+      help: 'Timeline type: for-you (algorithmic) or following (chronological)',
+    },
     { name: 'limit', type: 'int', default: 20 },
   ],
   columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url'],
   func: async (page, kwargs) => {
     const limit = kwargs.limit || 20;
+    const timelineType: TimelineType = kwargs.type === 'following' ? 'following' : 'for-you';
+    const { endpoint, method, fallbackQueryId } = TIMELINE_ENDPOINTS[timelineType];
 
     // Navigate to x.com for cookie context
     await page.goto('https://x.com');
@@ -165,22 +196,24 @@ cli({
     }`);
     if (!ct0) throw new Error('Not logged into x.com (no ct0 cookie)');
 
-    // Dynamically resolve queryId
-    const queryId = await page.evaluate(`async () => {
+    // Dynamically resolve queryId for the selected endpoint
+    const resolved = await page.evaluate(`async () => {
       try {
         const ghResp = await fetch('https://raw.githubusercontent.com/fa0311/twitter-openapi/refs/heads/main/src/config/placeholder.json');
         if (ghResp.ok) {
           const data = await ghResp.json();
-          const entry = data['HomeTimeline'];
+          const entry = data['${endpoint}'];
           if (entry && entry.queryId) return entry.queryId;
         }
       } catch {}
       return null;
-    }`) || HOME_TIMELINE_QUERY_ID;
+    }`);
+    // Validate queryId format to prevent injection from untrusted upstream
+    const queryId = typeof resolved === 'string' && /^[A-Za-z0-9_-]+$/.test(resolved) ? resolved : fallbackQueryId;
 
     // Build auth headers
     const headers = JSON.stringify({
-      'Authorization': `Bearer ${decodeURIComponent(BEARER_TOKEN)}`,
+      Authorization: `Bearer ${decodeURIComponent(BEARER_TOKEN)}`,
       'X-Csrf-Token': ct0,
       'X-Twitter-Auth-Type': 'OAuth2Session',
       'X-Twitter-Active-User': 'yes',
@@ -193,16 +226,17 @@ cli({
 
     for (let i = 0; i < 5 && allTweets.length < limit; i++) {
       const fetchCount = Math.min(40, limit - allTweets.length + 5); // over-fetch slightly for promoted filtering
-      const apiUrl = buildHomeTimelineUrl(fetchCount, cursor)
-        .replace(HOME_TIMELINE_QUERY_ID, queryId);
+      const variables = buildTimelineVariables(timelineType, fetchCount, cursor);
+      const apiUrl = buildHomeTimelineUrl(queryId, endpoint, variables);
 
       const data = await page.evaluate(`async () => {
-        const r = await fetch("${apiUrl}", { headers: ${headers}, credentials: 'include' });
+        const r = await fetch("${apiUrl}", { method: "${method}", headers: ${headers}, credentials: 'include' });
         return r.ok ? await r.json() : { error: r.status };
       }`);
 
       if (data?.error) {
-        if (allTweets.length === 0) throw new Error(`HTTP ${data.error}: Failed to fetch timeline. queryId may have expired.`);
+        if (allTweets.length === 0)
+          throw new Error(`HTTP ${data.error}: Failed to fetch timeline. queryId may have expired.`);
         break;
       }
 
@@ -216,3 +250,9 @@ cli({
     return allTweets.slice(0, limit);
   },
 });
+
+export const __test__ = {
+  buildTimelineVariables,
+  buildHomeTimelineUrl,
+  parseHomeTimeline,
+};

package/src/clis/wikipedia/random.ts

@@ -0,0 +1,19 @@
+import { CliError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { type WikiSummary, formatSummaryRow, wikiFetch } from './utils.js';
+
+cli({
+  site: 'wikipedia',
+  name: 'random',
+  description: 'Get a random Wikipedia article',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [{ name: 'lang', default: 'en', help: 'Language code (e.g. en, zh, ja)' }],
+  columns: ['title', 'description', 'extract', 'url'],
+  func: async (_page, args) => {
+    const lang = args.lang || 'en';
+    const data = (await wikiFetch(lang, '/api/rest_v1/page/random/summary')) as WikiSummary;
+    if (!data?.title) throw new CliError('NOT_FOUND', 'No random article returned', 'Try again');
+    return [formatSummaryRow(data, lang)];
+  },
+});

package/src/clis/wikipedia/search.ts

@@ -1,8 +1,11 @@
-import { cli, Strategy } from '../../registry.js';
 import { CliError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
 import { wikiFetch } from './utils.js';
 
-interface WikiSearchResult { title: string; snippet: string; }
+interface WikiSearchResult {
+  title: string;
+  snippet: string;
+}
 
 cli({
   site: 'wikipedia',
@@ -19,8 +22,11 @@ cli({
   func: async (_page, args) => {
     const limit = Math.max(1, Math.min(Number(args.limit), 50));
     const lang = args.lang || 'en';
-    const q = encodeURIComponent(args.keyword);
-    const data = await wikiFetch(lang, `/w/api.php?action=query&list=search&srsearch=${q}&srlimit=${limit}&format=json&utf8=1`) as { query?: { search?: WikiSearchResult[] } };
+    const q = encodeURIComponent(args.query);
+    const data = (await wikiFetch(
+      lang,
+      `/w/api.php?action=query&list=search&srsearch=${q}&srlimit=${limit}&format=json&utf8=1`,
+    )) as { query?: { search?: WikiSearchResult[] } };
     const results = data?.query?.search;
     if (!results?.length) throw new CliError('NOT_FOUND', 'No articles found', 'Try a different keyword');
     return results.map((r) => ({

package/src/clis/wikipedia/summary.ts

@@ -1,6 +1,6 @@
-import { cli, Strategy } from '../../registry.js';
 import { CliError } from '../../errors.js';
-import { wikiFetch } from './utils.js';
+import { cli, Strategy } from '../../registry.js';
+import { type WikiSummary, formatSummaryRow, wikiFetch } from './utils.js';
 
 cli({
   site: 'wikipedia',
@@ -16,13 +16,8 @@ cli({
   func: async (_page, args) => {
     const lang = args.lang || 'en';
     const title = encodeURIComponent(args.title.replace(/ /g, '_'));
-    const data = await wikiFetch(lang, `/api/rest_v1/page/summary/${title}`) as { title?: string; description?: string; extract?: string; content_urls?: { desktop?: { page?: string } } };
+    const data = (await wikiFetch(lang, `/api/rest_v1/page/summary/${title}`)) as WikiSummary;
     if (!data?.title) throw new CliError('NOT_FOUND', `Article "${args.title}" not found`, 'Try searching first: opencli wikipedia search <keyword>');
-    return [{
-      title: data.title,
-      description: data.description ?? '-',
-      extract: (data.extract ?? '').slice(0, 300),
-      url: data.content_urls?.desktop?.page ?? `https://${lang}.wikipedia.org/wiki/${title}`,
-    }];
+    return [formatSummaryRow(data, lang)];
   },
 });

package/src/clis/wikipedia/trending.ts

@@ -0,0 +1,41 @@
+import { CliError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { DESC_MAX_LEN, type WikiMostReadArticle, wikiFetch } from './utils.js';
+
+cli({
+  site: 'wikipedia',
+  name: 'trending',
+  description: 'Most-read Wikipedia articles (yesterday)',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'limit', type: 'int', default: 10, help: 'Max results' },
+    { name: 'lang', default: 'en', help: 'Language code (e.g. en, zh, ja)' },
+  ],
+  columns: ['rank', 'title', 'description', 'views'],
+  func: async (_page, args) => {
+    const lang = args.lang || 'en';
+    const limit = Math.max(1, Math.min(Number(args.limit), 50));
+
+    // Use yesterday's UTC date — Wikipedia API expects UTC and yesterday
+    // guarantees data availability (today's aggregation may be incomplete).
+    const d = new Date(Date.now() - 86_400_000);
+    const yyyy = d.getUTCFullYear();
+    const mm = String(d.getUTCMonth() + 1).padStart(2, '0');
+    const dd = String(d.getUTCDate()).padStart(2, '0');
+
+    const data = (await wikiFetch(lang, `/api/rest_v1/feed/featured/${yyyy}/${mm}/${dd}`)) as {
+      mostread?: { articles?: WikiMostReadArticle[] };
+    };
+    const articles = data?.mostread?.articles;
+    if (!articles?.length)
+      throw new CliError('NOT_FOUND', 'No trending articles available', 'Try a different language with --lang');
+
+    return articles.slice(0, limit).map((a, i) => ({
+      rank: i + 1,
+      title: a.title ?? '-',
+      description: (a.description ?? '-').slice(0, DESC_MAX_LEN),
+      views: a.views ?? 0,
+    }));
+  },
+});

package/src/clis/wikipedia/utils.ts

@@ -8,6 +8,27 @@
 
 import { CliError } from '../../errors.js';
 
+/** Maximum character length for article extract fields. */
+export const EXTRACT_MAX_LEN = 300;
+
+/** Maximum character length for short description fields. */
+export const DESC_MAX_LEN = 80;
+
+/** Response shape shared by /page/summary and /page/random/summary endpoints. */
+export interface WikiSummary {
+  title?: string;
+  description?: string;
+  extract?: string;
+  content_urls?: { desktop?: { page?: string } };
+}
+
+/** Article entry returned by the /feed/featured most-read endpoint. */
+export interface WikiMostReadArticle {
+  title?: string;
+  description?: string;
+  views?: number;
+}
+
 export async function wikiFetch(lang: string, path: string): Promise<unknown> {
   const url = `https://${lang}.wikipedia.org${path}`;
   const resp = await fetch(url, {
@@ -18,3 +39,13 @@ export async function wikiFetch(lang: string, path: string): Promise<unknown> {
   }
   return resp.json();
 }
+
+/** Map a WikiSummary API response to the standard output row. */
+export function formatSummaryRow(data: WikiSummary, lang: string) {
+  return {
+    title: data.title!,
+    description: data.description ?? '-',
+    extract: (data.extract ?? '').slice(0, EXTRACT_MAX_LEN),
+    url: data.content_urls?.desktop?.page ?? `https://${lang}.wikipedia.org`,
+  };
+}

package/src/clis/xiaohongshu/creator-note-detail.test.ts

@@ -18,6 +18,8 @@ function createPageMock(evaluateResult: any): IPage {
     click: vi.fn().mockResolvedValue(undefined),
     typeText: vi.fn().mockResolvedValue(undefined),
     pressKey: vi.fn().mockResolvedValue(undefined),
+    scrollTo: vi.fn().mockResolvedValue(undefined),
+    getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
     wait: vi.fn().mockResolvedValue(undefined),
     tabs: vi.fn().mockResolvedValue([]),
     closeTab: vi.fn().mockResolvedValue(undefined),

package/src/clis/xiaohongshu/creator-note-detail.ts

@@ -430,7 +430,7 @@ cli({
   strategy: Strategy.COOKIE,
   browser: true,
   args: [
-    { name: 'note-id', type: 'string', required: true, help: 'Note ID (from creator-notes or note-detail page URL)' },
+    { name: 'note-id', positional: true, type: 'string', required: true, help: 'Note ID (from creator-notes or note-detail page URL)' },
   ],
   columns: ['section', 'metric', 'value', 'extra'],
   func: async (page, kwargs) => {

package/src/clis/xiaohongshu/creator-notes.test.ts

@@ -22,6 +22,8 @@ function createPageMock(evaluateResult: any, interceptedRequests: any[] = []): I
     click: vi.fn().mockResolvedValue(undefined),
     typeText: vi.fn().mockResolvedValue(undefined),
     pressKey: vi.fn().mockResolvedValue(undefined),
+    scrollTo: vi.fn().mockResolvedValue(undefined),
+    getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
     wait: vi.fn().mockResolvedValue(undefined),
     tabs: vi.fn().mockResolvedValue([]),
     closeTab: vi.fn().mockResolvedValue(undefined),

package/src/clis/xiaohongshu/download.ts

@@ -22,7 +22,7 @@ cli({
   domain: 'www.xiaohongshu.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'note-id', required: true, help: 'Note ID (from URL)' },
+    { name: 'note-id', positional: true, required: true, help: 'Note ID (from URL)' },
     { name: 'output', default: './xiaohongshu-downloads', help: 'Output directory' },
   ],
   columns: ['index', 'type', 'status', 'size'],