@jackwener/opencli 0.2.0 → 0.4.0

package/dist/pipeline/steps/tap.js

@@ -36,6 +36,8 @@ export async function stepTap(page, params, data, args) {
     async () => {
       // ── 1. Setup capture proxy (fetch + XHR dual interception) ──
       let captured = null;
+      let captureResolve;
+      const capturePromise = new Promise(r => { captureResolve = r; });
       const capturePattern = ${JSON.stringify(capturePattern)};
 
       // Intercept fetch API
@@ -46,7 +48,7 @@ export async function stepTap(page, params, data, args) {
           const url = typeof fetchArgs[0] === 'string' ? fetchArgs[0]
             : fetchArgs[0] instanceof Request ? fetchArgs[0].url : String(fetchArgs[0]);
           if (capturePattern && url.includes(capturePattern) && !captured) {
-            try { captured = await resp.clone().json(); } catch {}
+            try { captured = await resp.clone().json(); captureResolve(); } catch {}
           }
         } catch {}
         return resp;
@@ -65,13 +67,13 @@ export async function stepTap(page, params, data, args) {
           const origHandler = xhr.onreadystatechange;
           xhr.onreadystatechange = function() {
             if (xhr.readyState === 4 && !captured) {
-              try { captured = JSON.parse(xhr.responseText); } catch {}
+              try { captured = JSON.parse(xhr.responseText); captureResolve(); } catch {}
             }
             if (origHandler) origHandler.apply(this, arguments);
           };
           const origOnload = xhr.onload;
           xhr.onload = function() {
-            if (!captured) { try { captured = JSON.parse(xhr.responseText); } catch {} }
+            if (!captured) { try { captured = JSON.parse(xhr.responseText); captureResolve(); } catch {} }
             if (origOnload) origOnload.apply(this, arguments);
           };
         }
@@ -111,9 +113,9 @@ export async function stepTap(page, params, data, args) {
         await ${actionCall};
 
         // ── 4. Wait for network response ──
-        const deadline = Date.now() + ${timeout} * 1000;
-        while (!captured && Date.now() < deadline) {
-          await new Promise(r => setTimeout(r, 200));
+        if (!captured) {
+          const timeoutPromise = new Promise(r => setTimeout(r, ${timeout} * 1000));
+          await Promise.race([capturePromise, timeoutPromise]);
         }
       } finally {
         // ── 5. Always restore originals ──

package/dist/pipeline/template.js

@@ -68,7 +68,7 @@ export function evalExpr(expr, ctx) {
  * Apply a named filter to a value.
  * Supported filters:
  *   default(val), join(sep), upper, lower, truncate(n), trim,
- *   replace(old,new), keys, length, first, last
+ *   replace(old,new), keys, length, first, last, json
  */
 function applyFilter(filterExpr, value) {
     const match = filterExpr.match(/^(\w+)(?:\((.+)\))?$/);
@@ -112,6 +112,8 @@ function applyFilter(filterExpr, value) {
             return Array.isArray(value) ? value[0] : value;
         case 'last':
             return Array.isArray(value) ? value[value.length - 1] : value;
+        case 'json':
+            return JSON.stringify(value ?? null);
         default:
             return value;
     }

package/dist/pipeline/template.test.js

@@ -72,6 +72,12 @@ describe('evalExpr', () => {
     it('applies length filter', () => {
         expect(evalExpr('item.items | length', { item: { items: [1, 2, 3] } })).toBe(3);
     });
+    it('applies json filter to strings with quotes', () => {
+        expect(evalExpr('args.keyword | json', { args: { keyword: "O'Reilly" } })).toBe('"O\'Reilly"');
+    });
+    it('applies json filter to nullish values', () => {
+        expect(evalExpr('args.keyword | json', { args: {} })).toBe('null');
+    });
 });
 describe('render', () => {
     it('renders full expression', () => {

package/dist/types.d.ts

@@ -16,7 +16,11 @@ export interface IPage {
     click(ref: string): Promise<void>;
     typeText(ref: string, text: string): Promise<void>;
     pressKey(key: string): Promise<void>;
-    wait(seconds: number): Promise<void>;
+    wait(options: number | {
+        text?: string;
+        time?: number;
+        timeout?: number;
+    }): Promise<void>;
     tabs(): Promise<any>;
     closeTab(index?: number): Promise<void>;
     newTab(): Promise<void>;
@@ -24,4 +28,10 @@ export interface IPage {
     networkRequests(includeStatic?: boolean): Promise<any>;
     consoleMessages(level?: string): Promise<any>;
     scroll(direction?: string, amount?: number): Promise<void>;
+    autoScroll(options?: {
+        times?: number;
+        delayMs?: number;
+    }): Promise<void>;
+    installInterceptor(pattern: string): Promise<void>;
+    getInterceptedRequests(): Promise<any[]>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "publishConfig": {
     "access": "public"
   },

package/src/browser.ts

@@ -104,8 +104,13 @@ export class Page implements IPage {
     await this.call('tools/call', { name: 'browser_press_key', arguments: { key } });
   }
 
-  async wait(seconds: number): Promise<void> {
-    await this.call('tools/call', { name: 'browser_wait_for', arguments: { time: seconds } });
+  async wait(options: number | { text?: string; time?: number; timeout?: number }): Promise<void> {
+    if (typeof options === 'number') {
+      await this.call('tools/call', { name: 'browser_wait_for', arguments: { time: options } });
+    } else {
+      // Pass directly to native wait_for, which supports natively awaiting text strings without heavy DOM polling
+      await this.call('tools/call', { name: 'browser_wait_for', arguments: options });
+    }
   }
 
   async tabs(): Promise<any> {
@@ -135,6 +140,91 @@ export class Page implements IPage {
   async scroll(direction: string = 'down', amount: number = 500): Promise<void> {
     await this.call('tools/call', { name: 'browser_press_key', arguments: { key: direction === 'down' ? 'PageDown' : 'PageUp' } });
   }
+
+  async autoScroll(options: { times?: number; delayMs?: number } = {}): Promise<void> {
+    const times = options.times ?? 3;
+    const delayMs = options.delayMs ?? 2000;
+    const js = `
+      async () => {
+        const maxTimes = ${times};
+        const maxWaitMs = ${delayMs};
+        for (let i = 0; i < maxTimes; i++) {
+          const lastHeight = document.body.scrollHeight;
+          window.scrollTo(0, lastHeight);
+          await new Promise(resolve => {
+            let timeoutId;
+            const observer = new MutationObserver(() => {
+              if (document.body.scrollHeight > lastHeight) {
+                clearTimeout(timeoutId);
+                observer.disconnect();
+                setTimeout(resolve, 100); // Small debounce for rendering
+              }
+            });
+            observer.observe(document.body, { childList: true, subtree: true });
+            timeoutId = setTimeout(() => {
+              observer.disconnect();
+              resolve(null);
+            }, maxWaitMs);
+          });
+        }
+      }
+    `;
+    await this.evaluate(js);
+  }
+
+  async installInterceptor(pattern: string): Promise<void> {
+    const js = `
+      () => {
+        window.__opencli_xhr = window.__opencli_xhr || [];
+        window.__opencli_patterns = window.__opencli_patterns || [];
+        if (!window.__opencli_patterns.includes('${pattern}')) {
+          window.__opencli_patterns.push('${pattern}');
+        }
+        
+        if (!window.__patched_xhr) {
+          const checkMatch = (url) => window.__opencli_patterns.some(p => url.includes(p));
+
+          const XHR = XMLHttpRequest.prototype;
+          const open = XHR.open;
+          const send = XHR.send;
+          XHR.open = function(method, url) {
+            this._url = url;
+            return open.call(this, method, url, ...Array.prototype.slice.call(arguments, 2));
+          };
+          XHR.send = function() {
+            this.addEventListener('load', function() {
+              if (checkMatch(this._url)) {
+                try { window.__opencli_xhr.push({url: this._url, data: JSON.parse(this.responseText)}); } catch(e){}
+              }
+            });
+            return send.apply(this, arguments);
+          };
+
+          const origFetch = window.fetch;
+          window.fetch = async function(...args) {
+            let u = typeof args[0] === 'string' ? args[0] : (args[0] && args[0].url) || '';
+            const res = await origFetch.apply(this, args);
+            setTimeout(async () => {
+              try {
+                if (checkMatch(u)) {
+                  const clone = res.clone();
+                  const j = await clone.json();
+                  window.__opencli_xhr.push({url: u, data: j});
+                }
+              } catch(e) {}
+            }, 0);
+            return res;
+          };
+          window.__patched_xhr = true;
+        }
+      }
+    `;
+    await this.evaluate(js);
+  }
+
+  async getInterceptedRequests(): Promise<any[]> {
+    return (await this.evaluate('() => window.__opencli_xhr')) || [];
+  }
 }
 
 /**
@@ -158,10 +248,15 @@ export class PlaywrightMCP {
     return new Promise<Page>((resolve, reject) => {
       const timer = setTimeout(() => reject(new Error(`Timed out connecting to browser (${timeout}s)`)), timeout * 1000);
 
-      this._proc = spawn('node', [mcpPath, '--extension'], {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env, ...(process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN ? { PLAYWRIGHT_MCP_EXTENSION_TOKEN: process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN } : {}) },
-      });
+      const mcpArgs = [mcpPath, '--extension'];
+    if (process.env.OPENCLI_BROWSER_EXECUTABLE_PATH) {
+      mcpArgs.push('--executablePath', process.env.OPENCLI_BROWSER_EXECUTABLE_PATH);
+    }
+
+    this._proc = spawn('node', mcpArgs, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, ...(process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN ? { PLAYWRIGHT_MCP_EXTENSION_TOKEN: process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN } : {}) },
+    });
 
       // Increase max listeners to avoid warnings
       this._proc.setMaxListeners(20);

package/src/clis/bilibili/dynamic.ts

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet } from '../../bilibili.js';
+
+cli({
+  site: 'bilibili',
+  name: 'dynamic',
+  description: 'Get Bilibili user dynamic feed',
+  domain: 'www.bilibili.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 15 },
+  ],
+  columns: ['id', 'author', 'text', 'likes', 'url'],
+  func: async (page, kwargs) => {
+    const payload = await apiGet(page, '/x/polymer/web-dynamic/v1/feed/all', { params: {}, signed: false });
+    const results: any[] = payload?.data?.items ?? [];
+    return results.slice(0, Number(kwargs.limit)).map((item: any) => {
+      let text = '';
+      if (item.modules?.module_dynamic?.desc?.text) {
+          text = item.modules.module_dynamic.desc.text;
+      } else if (item.modules?.module_dynamic?.major?.archive?.title) {
+          text = item.modules.module_dynamic.major.archive.title;
+      }
+
+      return {
+        id: item.id_str ?? '',
+        author: item.modules?.module_author?.name ?? '',
+        text: text,
+        likes: item.modules?.module_stat?.like?.count ?? 0,
+        url: item.id_str ? `https://t.bilibili.com/${item.id_str}` : ''
+      };
+    });
+  },
+});

package/src/clis/bilibili/ranking.ts

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet } from '../../bilibili.js';
+
+cli({
+  site: 'bilibili',
+  name: 'ranking',
+  description: 'Get Bilibili video ranking board',
+  domain: 'www.bilibili.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 20 },
+  ],
+  columns: ['rank', 'title', 'author', 'score', 'url'],
+  func: async (page, kwargs) => {
+    const payload = await apiGet(page, '/x/web-interface/ranking/v2', { params: { rid: 0, type: 'all' }, signed: false });
+    const results: any[] = payload?.data?.list ?? [];
+    return results.slice(0, Number(kwargs.limit)).map((item: any, i: number) => ({
+      rank: i + 1,
+      title: item.title ?? '',
+      author: item.owner?.name ?? '',
+      score: item.stat?.view ?? 0,
+      url: item.bvid ? `https://www.bilibili.com/video/${item.bvid}` : ''
+    }));
+  },
+});

package/src/clis/bilibili/subtitle.ts

@@ -0,0 +1,100 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { apiGet } from '../../bilibili.js';
+
+cli({
+  site: 'bilibili',
+  name: 'subtitle',
+  description: '获取 Bilibili 视频的字幕',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'bvid', required: true },
+    { name: 'lang', required: false, help: '字幕语言代码 (如 zh-CN, en-US, ai-zh)，默认取第一个' },
+  ],
+  columns: ['index', 'from', 'to', 'content'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+    // 1. 先前往视频详情页 (建立有鉴权的 Session，且这里不需要加载完整个视频)
+    await page.goto(`https://www.bilibili.com/video/${kwargs.bvid}/`);
+
+    // 2. 利用 __INITIAL_STATE__ 获取基础信息，拿 CID
+    const cid = await page.evaluate(`(async () => {
+      const state = window.__INITIAL_STATE__ || {};
+      return state?.videoData?.cid;
+    })()`);
+
+    if (!cid) {
+      throw new Error('无法在页面中提取到当前视频的 CID，请检查页面是否正常加载。');
+    }
+
+    // 3. 在 Node 端使用 apiGet 获取带 Wbi 签名的字幕列表
+    // 之前纯靠 evaluate 里的 fetch 会失败，因为 B 站 /wbi/ 开头的接口强校验 w_rid，未签名直接被风控返回 403 HTML
+    const payload = await apiGet(page, '/x/player/wbi/v2', {
+      params: { bvid: kwargs.bvid, cid },
+      signed: true, // 开启 wbi_sign 自动签名
+    });
+
+    if (payload.code !== 0) {
+      throw new Error(`获取视频播放信息失败: ${payload.message} (${payload.code})`);
+    }
+
+    const subtitles = payload.data?.subtitle?.subtitles || [];
+    if (subtitles.length === 0) {
+      throw new Error('此视频没有发现外挂或智能字幕。');
+    }
+
+    // 4. 选择目标字幕语言
+    const target = kwargs.lang
+      ? subtitles.find((s: any) => s.lan === kwargs.lang) || subtitles[0]
+      : subtitles[0];
+
+    const targetSubUrl = target.subtitle_url;
+    if (!targetSubUrl || targetSubUrl === '') {
+      throw new Error('[风控拦截/未登录] 获取到的 subtitle_url 为空！请确保 CLI 已成功登录且风控未封锁此账号。');
+    }
+
+    const finalUrl = targetSubUrl.startsWith('//') ? 'https:' + targetSubUrl : targetSubUrl;
+
+
+    // 5. 解析并拉取 CDN 的 JSON 文件
+    const fetchJs = `
+      (async () => {
+         const url = ${JSON.stringify(finalUrl)};
+         const res = await fetch(url);
+         const text = await res.text();
+         
+         if (text.startsWith('<!DOCTYPE') || text.startsWith('<html')) {
+            return { error: 'HTML', text: text.substring(0, 100), url };
+         }
+         
+         try {
+             const subJson = JSON.parse(text);
+             // B站真实返回格式是 { font_size: 0.4, font_color: "#FFFFFF", background_alpha: 0.5, background_color: "#9C27B0", Stroke: "none", type: "json" , body: [{from: 0, to: 0, content: ""}] }
+             if (Array.isArray(subJson?.body)) return { success: true, data: subJson.body };
+             if (Array.isArray(subJson)) return { success: true, data: subJson };
+             return { error: 'UNKNOWN_JSON', data: subJson };
+         } catch (e) {
+             return { error: 'PARSE_FAILED', text: text.substring(0, 100) };
+         }
+      })()
+    `;
+    const items = await page.evaluate(fetchJs);
+
+    if (items?.error) {
+      throw new Error(`字幕获取失败: ${items.error}${items.text ? ' — ' + items.text : ''}`);
+    }
+
+    const finalItems = items?.data || [];
+    if (!Array.isArray(finalItems)) {
+      throw new Error('解析到的字幕列表对象不符合数组格式');
+    }
+
+    // 6. 数据映射
+    return finalItems.map((item: any, idx: number) => ({
+      index: idx + 1,
+      from: Number(item.from || 0).toFixed(2) + 's',
+      to: Number(item.to || 0).toFixed(2) + 's',
+      content: item.content
+    }));
+  },
+});

package/src/clis/reddit/frontpage.yaml

@@ -0,0 +1,30 @@
+site: reddit
+name: frontpage
+description: Reddit Frontpage / r/all
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 15
+
+columns: [title, subreddit, author, upvotes, comments, url]
+
+pipeline:
+  - navigate: https://www.reddit.com
+  - evaluate: |
+      (async () => {
+        const res = await fetch('/r/all.json?limit=${{ args.limit }}', { credentials: 'include' });
+        const j = await res.json();
+        return j?.data?.children || [];
+      })()
+  - map:
+      title: ${{ item.data.title }}
+      subreddit: ${{ item.data.subreddit_name_prefixed }}
+      author: ${{ item.data.author }}
+      upvotes: ${{ item.data.score }}
+      comments: ${{ item.data.num_comments }}
+      url: https://www.reddit.com${{ item.data.permalink }}
+  - limit: ${{ args.limit }}

package/src/clis/reddit/hot.yaml

@@ -18,9 +18,10 @@ pipeline:
 
   - evaluate: |
       (async () => {
-        const sub = '${{ args.subreddit }}';
+        const sub = ${{ args.subreddit | json }};
         const path = sub ? '/r/' + sub + '/hot.json' : '/hot.json';
-        const res = await fetch(path + '?limit=${{ args.limit }}&raw_json=1', {
+        const limit = ${{ args.limit }};
+        const res = await fetch(path + '?limit=' + limit + '&raw_json=1', {
           credentials: 'include'
         });
         const d = await res.json();

package/src/clis/reddit/search.yaml

@@ -0,0 +1,34 @@
+site: reddit
+name: search
+description: Search Reddit Posts
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  query:
+    type: string
+    required: true
+  limit:
+    type: int
+    default: 15
+
+columns: [title, subreddit, author, upvotes, comments, url]
+
+pipeline:
+  - navigate: https://www.reddit.com
+  - evaluate: |
+      (async () => {
+        const q = encodeURIComponent('${{ args.query }}');
+        const res = await fetch('/search.json?q=' + q + '&limit=${{ args.limit }}', { credentials: 'include' });
+        const j = await res.json();
+        return j?.data?.children || [];
+      })()
+  - map:
+      title: ${{ item.data.title }}
+      subreddit: ${{ item.data.subreddit_name_prefixed }}
+      author: ${{ item.data.author }}
+      upvotes: ${{ item.data.score }}
+      comments: ${{ item.data.num_comments }}
+      url: https://www.reddit.com${{ item.data.permalink }}
+  - limit: ${{ args.limit }}

package/src/clis/reddit/subreddit.yaml

@@ -0,0 +1,39 @@
+site: reddit
+name: subreddit
+description: Get posts from a specific Subreddit
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  name:
+    type: string
+    required: true
+  sort:
+    type: string
+    default: hot
+    description: "Sorting method: hot, new, top, rising"
+  limit:
+    type: int
+    default: 15
+
+columns: [title, author, upvotes, comments, url]
+
+pipeline:
+  - navigate: https://www.reddit.com
+  - evaluate: |
+      (async () => {
+        let sub = '${{ args.name }}';
+        if (sub.startsWith('r/')) sub = sub.slice(2);
+        const sort = '${{ args.sort }}';
+        const res = await fetch('/r/' + sub + '/' + sort + '.json?limit=${{ args.limit }}', { credentials: 'include' });
+        const j = await res.json();
+        return j?.data?.children || [];
+      })()
+  - map:
+      title: ${{ item.data.title }}
+      author: ${{ item.data.author }}
+      upvotes: ${{ item.data.score }}
+      comments: ${{ item.data.num_comments }}
+      url: https://www.reddit.com${{ item.data.permalink }}
+  - limit: ${{ args.limit }}

package/src/clis/twitter/bookmarks.yaml

@@ -0,0 +1,85 @@
+site: twitter
+name: bookmarks
+description: 获取 Twitter 书签列表
+domain: x.com
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of bookmarks to return (default 20)
+
+pipeline:
+  - navigate: https://x.com/i/bookmarks
+  - wait: 2
+  - evaluate: |
+      (async () => {
+        const ct0 = document.cookie.split(';').map(c=>c.trim()).find(c=>c.startsWith('ct0='))?.split('=')[1];
+        if (!ct0) throw new Error('No ct0 cookie. Hint: Not logged into x.com.');
+        const bearer = decodeURIComponent('AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA');
+        const _h = {'Authorization':'Bearer '+bearer, 'X-Csrf-Token':ct0, 'X-Twitter-Auth-Type':'OAuth2Session', 'X-Twitter-Active-User':'yes'};
+
+        const count = Math.min(${{ args.limit }}, 100);
+        const variables = JSON.stringify({count, includePromotedContent: false});
+        const features = JSON.stringify({
+          rweb_video_screen_enabled: false, profile_label_improvements_pcf_label_in_post_enabled: true,
+          responsive_web_profile_redirect_enabled: false, rweb_tipjar_consumption_enabled: false,
+          verified_phone_label_enabled: false, creator_subscriptions_tweet_preview_api_enabled: true,
+          responsive_web_graphql_timeline_navigation_enabled: true,
+          responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+           premium_content_api_read_enabled: false, communities_web_enable_tweet_community_results_fetch: true,
+          c9s_tweet_anatomy_moderator_badge_enabled: true,
+          articles_preview_enabled: true, responsive_web_edit_tweet_api_enabled: true,
+          graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+          view_counts_everywhere_api_enabled: true, longform_notetweets_consumption_enabled: true,
+          responsive_web_twitter_article_tweet_consumption_enabled: true,
+          tweet_awards_web_tipping_enabled: false,
+          content_disclosure_indicator_enabled: true, content_disclosure_ai_generated_indicator_enabled: true,
+          freedom_of_speech_not_reach_fetch_enabled: true, standardized_nudges_misinfo: true,
+          tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+          longform_notetweets_rich_text_read_enabled: true, longform_notetweets_inline_media_enabled: false,
+          responsive_web_enhance_cards_enabled: false
+        });
+        const url = '/i/api/graphql/Fy0QMy4q_aZCpkO0PnyLYw/Bookmarks?variables=' + encodeURIComponent(variables) + '&features=' + encodeURIComponent(features);
+        const resp = await fetch(url, {headers: _h, credentials: 'include'});
+        if (!resp.ok) throw new Error('HTTP ' + resp.status + '. Hint: queryId may have changed.');
+        const d = await resp.json();
+
+        const instructions = d.data?.bookmark_timeline_v2?.timeline?.instructions || d.data?.bookmark_timeline?.timeline?.instructions || [];
+        let tweets = [], seen = new Set();
+        for (const inst of instructions) {
+          for (const entry of (inst.entries || [])) {
+            const r = entry.content?.itemContent?.tweet_results?.result;
+            if (!r) continue;
+            const tw = r.tweet || r;
+            const l = tw.legacy || {};
+            if (!tw.rest_id || seen.has(tw.rest_id)) continue;
+            seen.add(tw.rest_id);
+            const u = tw.core?.user_results?.result;
+            const nt = tw.note_tweet?.note_tweet_results?.result?.text;
+            const screenName = u?.legacy?.screen_name || u?.core?.screen_name;
+            tweets.push({
+              id: tw.rest_id, 
+              author: screenName,
+              name: u?.legacy?.name || u?.core?.name,
+              url: 'https://x.com/' + (screenName || '_') + '/status/' + tw.rest_id,
+              text: nt || l.full_text || '',
+              likes: l.favorite_count, 
+              retweets: l.retweet_count,
+              created_at: l.created_at
+            });
+          }
+        }
+        return tweets;
+      })()
+
+  - map:
+      author: ${{ item.author }}
+      text: ${{ item.text }}
+      likes: ${{ item.likes }}
+      url: ${{ item.url }}
+
+  - limit: ${{ args.limit }}
+
+columns: [author, text, likes, url]

package/src/clis/twitter/profile.ts

@@ -0,0 +1,61 @@
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'twitter',
+  name: 'profile',
+  description: 'Fetch tweets from a user profile',
+  domain: 'x.com',
+  strategy: Strategy.INTERCEPT,
+  browser: true,
+  args: [
+    { name: 'username', type: 'string', required: true },
+    { name: 'limit', type: 'int', default: 15 },
+  ],
+  columns: ['id', 'text', 'likes', 'views', 'url'],
+  func: async (page, kwargs) => {
+    // Navigate to user profile via search for reliability
+    await page.goto(`https://x.com/search?q=from:${kwargs.username}&f=live`);
+    await page.wait(5);
+
+    // Inject XHR interceptor
+    await page.installInterceptor('SearchTimeline');
+
+    // Trigger API by scrolling
+    await page.autoScroll({ times: 3, delayMs: 2000 });
+    
+    // Retrieve data
+    const requests = await page.getInterceptedRequests();
+    if (!requests || requests.length === 0) return [];
+
+    let results: any[] = [];
+    for (const req of requests) {
+      try {
+        const insts = req.data.data.search_by_raw_query.search_timeline.timeline.instructions;
+        const addEntries = insts.find((i: any) => i.type === 'TimelineAddEntries');
+        if (!addEntries) continue;
+
+        for (const entry of addEntries.entries) {
+          if (!entry.entryId.startsWith('tweet-')) continue;
+          
+          let tweet = entry.content?.itemContent?.tweet_results?.result;
+          if (!tweet) continue;
+
+          if (tweet.__typename === 'TweetWithVisibilityResults' && tweet.tweet) {
+              tweet = tweet.tweet;
+          }
+
+          results.push({
+            id: tweet.rest_id,
+            text: tweet.legacy?.full_text || '',
+            likes: tweet.legacy?.favorite_count || 0,
+            views: tweet.views?.count || '0',
+            url: `https://x.com/i/status/${tweet.rest_id}`
+          });
+        }
+      } catch (e) {
+      }
+    }
+
+    return results.slice(0, kwargs.limit);
+  }
+});