@jackwener/opencli 1.4.0 → 1.5.0

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

@@ -39,6 +39,7 @@ describe('twitter search command', () => {
                                   legacy: {
                                     full_text: 'hello world',
                                     favorite_count: 7,
+                                    created_at: 'Thu Mar 26 10:30:00 +0000 2026',
                                   },
                                   core: {
                                     user_results: {
@@ -68,13 +69,14 @@ describe('twitter search command', () => {
       ]),
     };
 
-    const result = await command!.func!(page as any, { query: 'from:alice', limit: 5 });
+    const result = await command!.func!(page as any, { query: 'from:alice', filter: 'top', limit: 5 });
 
     expect(result).toEqual([
       {
         id: '1',
         author: 'alice',
         text: 'hello world',
+        created_at: 'Thu Mar 26 10:30:00 +0000 2026',
         likes: 7,
         views: '12',
         url: 'https://x.com/i/status/1',
@@ -84,6 +86,73 @@ describe('twitter search command', () => {
     expect(evaluate).toHaveBeenCalledTimes(4);
   });
 
+  it('uses f=live in search URL when filter is live', async () => {
+    const command = getRegistry().get('twitter/search');
+
+    const evaluate = vi.fn()
+      .mockResolvedValueOnce(undefined)
+      .mockResolvedValueOnce('/search');
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      installInterceptor: vi.fn().mockResolvedValue(undefined),
+      evaluate,
+      autoScroll: vi.fn().mockResolvedValue(undefined),
+      getInterceptedRequests: vi.fn().mockResolvedValue([]),
+    };
+
+    await command!.func!(page as any, { query: 'breaking news', filter: 'live', limit: 5 });
+
+    const pushStateCall = evaluate.mock.calls[0][0] as string;
+    expect(pushStateCall).toContain('f=live');
+    expect(pushStateCall).toContain(encodeURIComponent('breaking news'));
+  });
+
+  it('uses f=top in search URL when filter is top', async () => {
+    const command = getRegistry().get('twitter/search');
+
+    const evaluate = vi.fn()
+      .mockResolvedValueOnce(undefined)
+      .mockResolvedValueOnce('/search');
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      installInterceptor: vi.fn().mockResolvedValue(undefined),
+      evaluate,
+      autoScroll: vi.fn().mockResolvedValue(undefined),
+      getInterceptedRequests: vi.fn().mockResolvedValue([]),
+    };
+
+    await command!.func!(page as any, { query: 'test', filter: 'top', limit: 5 });
+
+    const pushStateCall = evaluate.mock.calls[0][0] as string;
+    expect(pushStateCall).toContain('f=top');
+  });
+
+  it('falls back to top when filter is omitted', async () => {
+    const command = getRegistry().get('twitter/search');
+
+    const evaluate = vi.fn()
+      .mockResolvedValueOnce(undefined)
+      .mockResolvedValueOnce('/search');
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      installInterceptor: vi.fn().mockResolvedValue(undefined),
+      evaluate,
+      autoScroll: vi.fn().mockResolvedValue(undefined),
+      getInterceptedRequests: vi.fn().mockResolvedValue([]),
+    };
+
+    await command!.func!(page as any, { query: 'test', limit: 5 });
+
+    const pushStateCall = evaluate.mock.calls[0][0] as string;
+    expect(pushStateCall).toContain('f=top');
+  });
+
   it('throws with the final path after both attempts fail', async () => {
     const command = getRegistry().get('twitter/search');
     expect(command?.func).toBeTypeOf('function');
@@ -103,7 +172,7 @@ describe('twitter search command', () => {
       getInterceptedRequests: vi.fn(),
     };
 
-    await expect(command!.func!(page as any, { query: 'from:alice', limit: 5 }))
+    await expect(command!.func!(page as any, { query: 'from:alice', filter: 'top', limit: 5 }))
       .rejects
       .toThrow('Final path: /login');
     expect(page.autoScroll).not.toHaveBeenCalled();

package/src/clis/twitter/search.ts

@@ -9,8 +9,8 @@ import type { IPage } from '../../types.js';
  * pushState + popstate. A second attempt is enough for the intermittent cases
  * reported in issue #353 while keeping the flow narrowly scoped.
  */
-async function navigateToSearch(page: Pick<IPage, 'evaluate' | 'wait'>, query: string): Promise<void> {
-  const searchUrl = JSON.stringify(`/search?q=${encodeURIComponent(query)}&f=top`);
+async function navigateToSearch(page: Pick<IPage, 'evaluate' | 'wait'>, query: string, filter: string): Promise<void> {
+  const searchUrl = JSON.stringify(`/search?q=${encodeURIComponent(query)}&f=${filter}`);
   let lastPath = '';
 
   for (let attempt = 1; attempt <= 2; attempt++) {
@@ -46,11 +46,13 @@ cli({
   browser: true,
   args: [
     { name: 'query', type: 'string', required: true, positional: true },
+    { name: 'filter', type: 'string', default: 'top', choices: ['top', 'live'] },
     { name: 'limit', type: 'int', default: 15 },
   ],
-  columns: ['id', 'author', 'text', 'likes', 'views', 'url'],
+  columns: ['id', 'author', 'text', 'created_at', 'likes', 'views', 'url'],
   func: async (page, kwargs) => {
     const query = kwargs.query;
+    const filter = kwargs.filter === 'live' ? 'live' : 'top';
 
     // 1. Navigate to x.com/explore (has a search input at the top)
     await page.goto('https://x.com/explore');
@@ -66,7 +68,7 @@ cli({
     //    a full page reload, so the interceptor stays alive.
     //    Note: the previous approach (nativeSetter + Enter keydown on the
     //    search input) does not reliably trigger Twitter's form submission.
-    await navigateToSearch(page, query);
+    await navigateToSearch(page, query, filter);
 
     // 4. Scroll to trigger additional pagination
     await page.autoScroll({ times: 3, delayMs: 2000 });
@@ -99,10 +101,12 @@ cli({
 
           // Twitter moved screen_name from legacy to core
           const tweetUser = tweet.core?.user_results?.result;
+
           results.push({
             id: tweet.rest_id,
             author: tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown',
             text: tweet.note_tweet?.note_tweet_results?.result?.text || tweet.legacy?.full_text || '',
+            created_at: tweet.legacy?.created_at || '',
             likes: tweet.legacy?.favorite_count || 0,
             views: tweet.views?.count || '0',
             url: `https://x.com/i/status/${tweet.rest_id}`

package/src/clis/twitter/shared.ts

@@ -0,0 +1,45 @@
+import type { IPage } from '../../types.js';
+
+const QUERY_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+
+export function sanitizeQueryId(resolved: unknown, fallbackId: string): string {
+  return typeof resolved === 'string' && QUERY_ID_PATTERN.test(resolved) ? resolved : fallbackId;
+}
+
+export async function resolveTwitterQueryId(
+  page: Pick<IPage, 'evaluate'>,
+  operationName: string,
+  fallbackId: string,
+): Promise<string> {
+  const resolved = await page.evaluate(`async () => {
+    const operationName = ${JSON.stringify(operationName)};
+    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?.[operationName];
+        if (entry && entry.queryId) return entry.queryId;
+      }
+    } catch {}
+    try {
+      const scripts = performance.getEntriesByType('resource')
+        .filter(r => r.name.includes('client-web') && r.name.endsWith('.js'))
+        .map(r => r.name);
+      for (const scriptUrl of scripts.slice(0, 15)) {
+        try {
+          const text = await (await fetch(scriptUrl)).text();
+          const re = new RegExp('queryId:"([A-Za-z0-9_-]+)"[^}]{0,200}operationName:"' + operationName + '"');
+          const match = text.match(re);
+          if (match) return match[1];
+        } catch {}
+      }
+    } catch {}
+    return null;
+  }`);
+
+  return sanitizeQueryId(resolved, fallbackId);
+}
+
+export const __test__ = {
+  sanitizeQueryId,
+};

package/src/clis/twitter/timeline.ts

@@ -1,5 +1,6 @@
 import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
 import { cli, Strategy } from '../../registry.js';
+import { resolveTwitterQueryId } from './shared.js';
 
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 
@@ -198,19 +199,7 @@ cli({
     if (!ct0) throw new AuthRequiredError('x.com', 'Not logged into x.com (no ct0 cookie)');
 
     // 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['${endpoint}'];
-          if (entry && entry.queryId) return entry.queryId;
-        }
-      } catch {}
-      return null;
-    }`);
-    // Validate queryId format to prevent injection from untrusted upstream
-    const queryId = typeof resolved === 'string' && /^[A-Za-z0-9_-]+$/.test(resolved) ? resolved : fallbackQueryId;
+    const queryId = await resolveTwitterQueryId(page, endpoint, fallbackQueryId);
 
     // Build auth headers
     const headers = JSON.stringify({

package/src/clis/weibo/comments.ts

@@ -0,0 +1,54 @@
+/**
+ * Weibo comments — get comments on a post.
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'weibo',
+  name: 'comments',
+  description: 'Get comments on a Weibo post',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'id', required: true, positional: true, help: 'Post ID (numeric idstr)' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of comments (max 50)' },
+  ],
+  columns: ['rank', 'author', 'text', 'likes', 'replies', 'time'],
+  func: async (page, kwargs) => {
+    const count = Math.min(kwargs.limit || 20, 50);
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+
+    const id = String(kwargs.id);
+    const data = await page.evaluate(`
+      (async () => {
+        const id = ${JSON.stringify(id)};
+        const count = ${count};
+        const strip = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
+
+        const url = '/ajax/statuses/buildComments?flow=0&is_reload=1&id=' + id + '&is_show_bulletin=2&is_mix=0&count=' + count;
+        const resp = await fetch(url, {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const data = await resp.json();
+        if (!data.ok) return {error: 'API error: ' + (data.msg || 'unknown')};
+
+        return (data.data || []).map((c, i) => {
+          const item = {
+            rank: i + 1,
+            author: c.user?.screen_name || '',
+            text: strip(c.text || ''),
+            likes: c.like_count || 0,
+            replies: c.total_number || 0,
+            time: c.created_at || '',
+          };
+          if (c.reply_comment) {
+            item.reply_to = (c.reply_comment.user?.screen_name || '') + ': ' + strip(c.reply_comment.text || '').substring(0, 80);
+          }
+          return item;
+        });
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data;
+  },
+});

package/src/clis/weibo/feed.ts

@@ -0,0 +1,57 @@
+/**
+ * Weibo feed — home timeline from followed users.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { getSelfUid } from './utils.js';
+
+cli({
+  site: 'weibo',
+  name: 'feed',
+  description: 'Weibo home timeline (posts from followed users)',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 15, help: 'Number of posts (max 50)' },
+  ],
+  columns: ['author', 'text', 'reposts', 'comments', 'likes', 'time', 'url'],
+  func: async (page, kwargs) => {
+    const count = Math.min(kwargs.limit || 15, 50);
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+    const uid = await getSelfUid(page);
+
+    const data = await page.evaluate(`
+      (async () => {
+        const uid = ${JSON.stringify(uid)};
+        const count = ${count};
+        const listId = '10001' + uid;
+        const strip = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
+
+        const resp = await fetch('/ajax/feed/unreadfriendstimeline?list_id=' + listId + '&refresh=4&since_id=0&count=' + count, {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const data = await resp.json();
+        if (!data.ok) return {error: 'API error: ' + (data.msg || 'unknown')};
+
+        return (data.statuses || []).slice(0, count).map(s => {
+          const u = s.user || {};
+          const item = {
+            author: u.screen_name || '',
+            text: (s.text_raw || strip(s.text || '')).substring(0, 200),
+            reposts: s.reposts_count || 0,
+            comments: s.comments_count || 0,
+            likes: s.attitudes_count || 0,
+            time: s.created_at || '',
+            url: 'https://weibo.com/' + (u.id || '') + '/' + (s.mblogid || ''),
+          };
+          if (s.retweeted_status) {
+            const rt = s.retweeted_status;
+            item.retweeted = (rt.user?.screen_name || '[deleted]') + ': ' + (rt.text_raw || strip(rt.text || '')).substring(0, 100);
+          }
+          return item;
+        });
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data;
+  },
+});

package/src/clis/weibo/hot.ts

@@ -1,6 +1,5 @@
 /**
  * Weibo hot search — browser cookie API.
- * Source: bb-sites/weibo/hot.js
  */
 import { cli, Strategy } from '../../registry.js';
 

package/src/clis/weibo/me.ts

@@ -0,0 +1,77 @@
+/**
+ * Weibo me — current logged-in user profile.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+import { getSelfUid } from './utils.js';
+
+cli({
+  site: 'weibo',
+  name: 'me',
+  description: 'My Weibo profile info',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [],
+  columns: ['screen_name', 'uid', 'followers', 'following', 'statuses', 'verified', 'location'],
+  func: async (page) => {
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+    const uid = await getSelfUid(page);
+
+    const data = await page.evaluate(`
+      (async () => {
+        const uid = ${JSON.stringify(uid)};
+
+        // Try Vue store first
+        const app = document.querySelector('#app')?.__vue_app__;
+        const store = app?.config?.globalProperties?.$store;
+        const cfg = store?.state?.config?.config;
+        const u = cfg?.user;
+
+        // Fetch detail info
+        const detailResp = await fetch('/ajax/profile/detail?uid=' + uid, {credentials: 'include'});
+        const detail = detailResp.ok ? await detailResp.json() : null;
+        const d = detail?.data || {};
+
+        if (u && u.id) {
+          return {
+            screen_name: u.screen_name,
+            uid: u.id,
+            followers: u.followers_count,
+            following: u.friends_count,
+            statuses: u.statuses_count,
+            verified: u.verified || false,
+            location: u.location || '',
+            description: u.description || d.description || '',
+            avatar: u.avatar_hd || u.avatar_large || '',
+            profile_url: 'https://weibo.com' + (u.profile_url || '/u/' + u.id),
+          };
+        }
+
+        // Fallback: fetch profile API
+        const resp = await fetch('/ajax/profile/info?uid=' + uid, {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const info = await resp.json();
+        if (!info.ok) return {error: 'API error'};
+        const p = info.data?.user;
+        if (!p) return {error: 'User data not found'};
+        return {
+          screen_name: p.screen_name,
+          uid: p.id,
+          followers: p.followers_count,
+          following: p.friends_count,
+          statuses: p.statuses_count,
+          verified: p.verified || false,
+          location: p.location || '',
+          description: p.description || d.description || '',
+          avatar: p.avatar_hd || p.avatar_large || '',
+          profile_url: 'https://weibo.com' + (p.profile_url || '/u/' + p.id),
+        };
+      })()
+    `);
+
+    if (!data || typeof data !== 'object') throw new CommandExecutionError('Failed to fetch profile');
+    if ((data as Record<string, unknown>).error) throw new CommandExecutionError(String((data as Record<string, unknown>).error));
+    return data as Record<string, unknown>;
+  },
+});

package/src/clis/weibo/post.ts

@@ -0,0 +1,77 @@
+/**
+ * Weibo post — get a single post by ID.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+
+cli({
+  site: 'weibo',
+  name: 'post',
+  description: 'Get a single Weibo post',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'id', required: true, positional: true, help: 'Post ID (numeric idstr or mblogid from URL)' },
+  ],
+  columns: ['field', 'value'],
+  func: async (page, kwargs) => {
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+
+    const id = String(kwargs.id);
+    const data = await page.evaluate(`
+      (async () => {
+        const id = ${JSON.stringify(id)};
+        const strip = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
+
+        const resp = await fetch('/ajax/statuses/show?id=' + encodeURIComponent(id), {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const s = await resp.json();
+        if (!s.ok && !s.idstr) return {error: 'Post not found'};
+
+        // Fetch long text if needed
+        let fullText = s.text_raw || strip(s.text || '');
+        if (s.isLongText || s.is_long_text) {
+          try {
+            const ltResp = await fetch('/ajax/statuses/longtext?id=' + s.idstr, {credentials: 'include'});
+            if (ltResp.ok) {
+              const lt = await ltResp.json();
+              if (lt.data?.longTextContent) fullText = strip(lt.data.longTextContent);
+            }
+          } catch {}
+        }
+
+        const u = s.user || {};
+        const result = {
+          id: s.idstr || String(s.id),
+          mblogid: s.mblogid,
+          author: u.screen_name || '',
+          text: fullText,
+          created_at: s.created_at,
+          source: strip(s.source || ''),
+          reposts: s.reposts_count || 0,
+          comments: s.comments_count || 0,
+          likes: s.attitudes_count || 0,
+          pic_count: s.pic_num || 0,
+          url: 'https://weibo.com/' + (u.id || '') + '/' + (s.mblogid || ''),
+        };
+
+        if (s.retweeted_status) {
+          const rt = s.retweeted_status;
+          result.retweeted_from = (rt.user?.screen_name || '[deleted]');
+          result.retweeted_text = rt.text_raw || strip(rt.text || '');
+        }
+
+        return result;
+      })()
+    `);
+
+    if (!data || typeof data !== 'object') throw new CommandExecutionError('Failed to fetch post');
+    if ((data as Record<string, unknown>).error) throw new CommandExecutionError(String((data as Record<string, unknown>).error));
+
+    return Object.entries(data as Record<string, unknown>).map(([field, value]) => ({
+      field,
+      value: String(value),
+    }));
+  },
+});

package/src/clis/weibo/user.ts

@@ -0,0 +1,64 @@
+/**
+ * Weibo user — get user profile by uid or screen_name.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+
+cli({
+  site: 'weibo',
+  name: 'user',
+  description: 'Get Weibo user profile',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'id', required: true, positional: true, help: 'User ID (numeric uid) or screen name' },
+  ],
+  columns: ['screen_name', 'uid', 'followers', 'following', 'statuses', 'verified', 'description', 'location', 'url'],
+  func: async (page, kwargs) => {
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+
+    const id = String(kwargs.id);
+    const data = await page.evaluate(`
+      (async () => {
+        const id = ${JSON.stringify(id)};
+        const isUid = /^\\d+$/.test(id);
+        const query = isUid ? 'uid=' + id : 'screen_name=' + encodeURIComponent(id);
+
+        const resp = await fetch('/ajax/profile/info?' + query, {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const data = await resp.json();
+        if (!data.ok || !data.data?.user) return {error: 'User not found'};
+
+        const u = data.data.user;
+
+        // Fetch detail info
+        const detailResp = await fetch('/ajax/profile/detail?uid=' + u.id, {credentials: 'include'});
+        const detail = detailResp.ok ? await detailResp.json() : null;
+        const d = detail?.data || {};
+
+        return {
+          screen_name: u.screen_name,
+          uid: u.id,
+          followers: u.followers_count,
+          following: u.friends_count,
+          statuses: u.statuses_count,
+          verified: u.verified || false,
+          verified_reason: u.verified_reason || '',
+          description: u.description || d.description || '',
+          location: u.location || '',
+          gender: u.gender === 'm' ? 'male' : u.gender === 'f' ? 'female' : '',
+          avatar: u.avatar_hd || u.avatar_large || '',
+          url: 'https://weibo.com' + (u.profile_url || '/u/' + u.id),
+          birthday: d.birthday || '',
+          created_at: d.created_at || '',
+          ip_location: d.ip_location || '',
+        };
+      })()
+    `);
+
+    if (!data || typeof data !== 'object') throw new CommandExecutionError('Failed to fetch user profile');
+    if ((data as Record<string, unknown>).error) throw new CommandExecutionError(String((data as Record<string, unknown>).error));
+    return data as Record<string, unknown>;
+  },
+});

package/src/clis/weibo/utils.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared Weibo utilities — uid extraction.
+ */
+
+import type { IPage } from '../../types.js';
+import { AuthRequiredError } from '../../errors.js';
+
+/** Get the currently logged-in user's uid from Vue store or config API. */
+export async function getSelfUid(page: IPage): Promise<string> {
+  const uid = await page.evaluate(`
+    (() => {
+      const app = document.querySelector('#app')?.__vue_app__;
+      const store = app?.config?.globalProperties?.$store;
+      const uid = store?.state?.config?.config?.uid;
+      if (uid) return String(uid);
+      return null;
+    })()
+  `);
+  if (uid) return uid as string;
+
+  // Fallback: config API
+  const config = await page.evaluate(`
+    (async () => {
+      const resp = await fetch('/ajax/config/get_config', {credentials: 'include'});
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      return data.ok && data.data?.uid ? String(data.data.uid) : null;
+    })()
+  `);
+  if (config) return config as string;
+  throw new AuthRequiredError('weibo.com');
+}