@jackwener/opencli 0.7.9 → 0.7.11

package/dist/clis/barchart/quote.js

@@ -0,0 +1,133 @@
+/**
+ * Barchart stock quote — price, volume, market cap, P/E, EPS, and key metrics.
+ * Auth: CSRF token from <meta name="csrf-token"> + session cookies.
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'barchart',
+    name: 'quote',
+    description: 'Barchart stock quote with price, volume, and key metrics',
+    domain: 'www.barchart.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'symbol', required: true, help: 'Stock ticker (e.g. AAPL, MSFT, TSLA)' },
+    ],
+    columns: [
+        'symbol', 'name', 'price', 'change', 'changePct',
+        'open', 'high', 'low', 'prevClose', 'volume',
+        'avgVolume', 'marketCap', 'peRatio', 'eps',
+    ],
+    func: async (page, kwargs) => {
+        const symbol = kwargs.symbol.toUpperCase().trim();
+        await page.goto(`https://www.barchart.com/stocks/quotes/${encodeURIComponent(symbol)}/overview`);
+        await page.wait(4);
+        const data = await page.evaluate(`
+      (async () => {
+        const sym = '${symbol}';
+        const csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
+
+        // Strategy 1: internal proxy API with CSRF token
+        try {
+          const fields = [
+            'symbol','symbolName','lastPrice','priceChange','percentChange',
+            'highPrice','lowPrice','openPrice','previousPrice','volume','averageVolume',
+            'marketCap','peRatio','earningsPerShare','tradeTime',
+          ].join(',');
+          const url = '/proxies/core-api/v1/quotes/get?symbol=' + encodeURIComponent(sym) + '&fields=' + fields;
+          const resp = await fetch(url, {
+            credentials: 'include',
+            headers: { 'X-CSRF-TOKEN': csrf },
+          });
+          if (resp.ok) {
+            const d = await resp.json();
+            const row = d?.data?.[0] || null;
+            if (row) {
+              return { source: 'api', row };
+            }
+          }
+        } catch(e) {}
+
+        // Strategy 2: parse from DOM
+        try {
+          const priceEl = document.querySelector('span.last-change');
+          const price = priceEl ? priceEl.textContent.trim() : null;
+
+          // Change values are sibling spans inside .pricechangerow > .last-change
+          const changeParent = priceEl?.parentElement;
+          const changeSpans = changeParent ? changeParent.querySelectorAll('span') : [];
+          let change = null;
+          let changePct = null;
+          for (const s of changeSpans) {
+            const t = s.textContent.trim();
+            if (s === priceEl) continue;
+            if (t.includes('%')) changePct = t.replace(/[()]/g, '');
+            else if (t.match(/^[+-]?[\\d.]+$/)) change = t;
+          }
+
+          // Financial data rows
+          const rows = document.querySelectorAll('.financial-data-row');
+          const fdata = {};
+          for (const row of rows) {
+            const spans = row.querySelectorAll('span');
+            if (spans.length >= 2) {
+              const label = spans[0].textContent.trim();
+              const valSpan = row.querySelector('span.right span:not(.ng-hide)');
+              fdata[label] = valSpan ? valSpan.textContent.trim() : '';
+            }
+          }
+
+          // Day high/low from row chart
+          const dayLow = document.querySelector('.bc-quote-row-chart .small-6:first-child .inline:not(.ng-hide)');
+          const dayHigh = document.querySelector('.bc-quote-row-chart .text-right .inline:not(.ng-hide)');
+          const openEl = document.querySelector('.mark span');
+          const openText = openEl ? openEl.textContent.trim().replace('Open ', '') : null;
+
+          const name = document.querySelector('h1 span.symbol');
+
+          return {
+            source: 'dom',
+            row: {
+              symbol: sym,
+              symbolName: name ? name.textContent.trim() : sym,
+              lastPrice: price,
+              priceChange: change,
+              percentChange: changePct,
+              open: openText,
+              highPrice: dayHigh ? dayHigh.textContent.trim() : null,
+              lowPrice: dayLow ? dayLow.textContent.trim() : null,
+              previousClose: fdata['Previous Close'] || null,
+              volume: fdata['Volume'] || null,
+              averageVolume: fdata['Average Volume'] || null,
+              marketCap: null,
+              peRatio: null,
+              earningsPerShare: null,
+            }
+          };
+        } catch(e) {
+          return { error: 'Could not fetch quote for ' + sym + ': ' + e.message };
+        }
+      })()
+    `);
+        if (!data || data.error)
+            return [];
+        const r = data.row || {};
+        // API returns formatted strings like "+1.41" and "+0.56%"; use raw if available
+        const raw = r.raw || {};
+        return [{
+                symbol: r.symbol || symbol,
+                name: r.symbolName || r.name || symbol,
+                price: r.lastPrice ?? null,
+                change: r.priceChange ?? null,
+                changePct: r.percentChange ?? null,
+                open: r.openPrice ?? r.open ?? null,
+                high: r.highPrice ?? null,
+                low: r.lowPrice ?? null,
+                prevClose: r.previousPrice ?? r.previousClose ?? null,
+                volume: r.volume ?? null,
+                avgVolume: r.averageVolume ?? null,
+                marketCap: r.marketCap ?? null,
+                peRatio: r.peRatio ?? null,
+                eps: r.earningsPerShare ?? null,
+            }];
+    },
+});

package/dist/clis/twitter/bookmarks.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/twitter/bookmarks.js

@@ -0,0 +1,171 @@
+import { cli, Strategy } from '../../registry.js';
+const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+const BOOKMARKS_QUERY_ID = 'Fy0QMy4q_aZCpkO0PnyLYw';
+const FEATURES = {
+    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,
+};
+function buildBookmarksUrl(count, cursor) {
+    const vars = {
+        count,
+        includePromotedContent: false,
+    };
+    if (cursor)
+        vars.cursor = cursor;
+    return `/i/api/graphql/${BOOKMARKS_QUERY_ID}/Bookmarks`
+        + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
+        + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+}
+function extractBookmarkTweet(result, seen) {
+    if (!result)
+        return null;
+    const tw = result.tweet || result;
+    const legacy = tw.legacy || {};
+    if (!tw.rest_id || seen.has(tw.rest_id))
+        return null;
+    seen.add(tw.rest_id);
+    const user = tw.core?.user_results?.result;
+    const screenName = user?.legacy?.screen_name || user?.core?.screen_name || 'unknown';
+    const displayName = user?.legacy?.name || user?.core?.name || '';
+    const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
+    return {
+        id: tw.rest_id,
+        author: screenName,
+        name: displayName,
+        text: noteText || legacy.full_text || '',
+        likes: legacy.favorite_count || 0,
+        retweets: legacy.retweet_count || 0,
+        created_at: legacy.created_at || '',
+        url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+    };
+}
+function parseBookmarks(data, seen) {
+    const tweets = [];
+    let nextCursor = null;
+    const instructions = data?.data?.bookmark_timeline_v2?.timeline?.instructions
+        || data?.data?.bookmark_timeline?.timeline?.instructions
+        || [];
+    for (const inst of instructions) {
+        for (const entry of inst.entries || []) {
+            const content = entry.content;
+            if (content?.entryType === 'TimelineTimelineCursor' || content?.__typename === 'TimelineTimelineCursor') {
+                if (content.cursorType === 'Bottom' || content.cursorType === 'ShowMore')
+                    nextCursor = content.value;
+                continue;
+            }
+            if (entry.entryId?.startsWith('cursor-bottom-') || entry.entryId?.startsWith('cursor-showMore-')) {
+                nextCursor = content?.value || content?.itemContent?.value || nextCursor;
+                continue;
+            }
+            const direct = extractBookmarkTweet(content?.itemContent?.tweet_results?.result, seen);
+            if (direct) {
+                tweets.push(direct);
+                continue;
+            }
+            for (const item of content?.items || []) {
+                const nested = extractBookmarkTweet(item.item?.itemContent?.tweet_results?.result, seen);
+                if (nested)
+                    tweets.push(nested);
+            }
+        }
+    }
+    return { tweets, nextCursor };
+}
+cli({
+    site: 'twitter',
+    name: 'bookmarks',
+    description: 'Fetch Twitter/X bookmarks',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20 },
+    ],
+    columns: ['author', 'text', 'likes', 'url'],
+    func: async (page, kwargs) => {
+        const limit = kwargs.limit || 20;
+        await page.goto('https://x.com');
+        await page.wait(3);
+        const ct0 = await page.evaluate(`() => {
+      return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
+    }`);
+        if (!ct0)
+            throw new Error('Not logged into x.com (no ct0 cookie)');
+        const queryId = 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['Bookmarks'];
+          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 = /queryId:"([A-Za-z0-9_-]+)"[^}]{0,200}operationName:"Bookmarks"/;
+            const m = text.match(re);
+            if (m) return m[1];
+          } catch {}
+        }
+      } catch {}
+      return null;
+    }`) || BOOKMARKS_QUERY_ID;
+        const headers = JSON.stringify({
+            'Authorization': `Bearer ${decodeURIComponent(BEARER_TOKEN)}`,
+            'X-Csrf-Token': ct0,
+            'X-Twitter-Auth-Type': 'OAuth2Session',
+            'X-Twitter-Active-User': 'yes',
+        });
+        const allTweets = [];
+        const seen = new Set();
+        let cursor = null;
+        for (let i = 0; i < 5 && allTweets.length < limit; i++) {
+            const fetchCount = Math.min(100, limit - allTweets.length + 10);
+            const apiUrl = buildBookmarksUrl(fetchCount, cursor).replace(BOOKMARKS_QUERY_ID, queryId);
+            const data = await page.evaluate(`async () => {
+        const r = await fetch("${apiUrl}", { 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 bookmarks. queryId may have expired.`);
+                break;
+            }
+            const { tweets, nextCursor } = parseBookmarks(data, seen);
+            allTweets.push(...tweets);
+            if (!nextCursor || nextCursor === cursor)
+                break;
+            cursor = nextCursor;
+        }
+        return allTweets.slice(0, limit);
+    },
+});

package/dist/clis/twitter/delete.js

@@ -13,7 +13,6 @@ cli({
     func: async (page, kwargs) => {
         if (!page)
             throw new Error('Requires browser');
-        console.log(`Navigating to tweet: ${kwargs.url}`);
         await page.goto(kwargs.url);
         await page.wait(5); // Wait for tweet to load completely
         const result = await page.evaluate(`(async () => {

package/dist/clis/twitter/followers.js

@@ -30,8 +30,8 @@ cli({
         // 1. Navigate to user profile page
         await page.goto(`https://x.com/${targetUser}`);
         await page.wait(3);
-        // 2. Inject interceptor for Followers GraphQL API (or user_flow.json)
-        await page.installInterceptor('graphql');
+        // 2. Inject interceptor for the followers GraphQL API
+        await page.installInterceptor('Followers');
         // 3. Click the followers link inside the profile page
         await page.evaluate(`() => {
         const target = '${targetUser}';
@@ -43,23 +43,12 @@ cli({
         await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
         // 4. Retrieve data from opencli's registered interceptors
         const allRequests = await page.getInterceptedRequests();
-        // Debug: Force dump all intercepted XHRs that match followers
-        if (!allRequests || allRequests.length === 0) {
-            console.log('No GraphQL requests captured by the interceptor backend.');
+        const requestList = Array.isArray(allRequests) ? allRequests : [];
+        if (requestList.length === 0) {
             return [];
         }
-        console.log('Intercepted keys:', allRequests.map((r) => {
-            try {
-                const u = new URL(r.url);
-                return u.pathname;
-            }
-            catch (e) {
-                return r.url;
-            }
-        }));
-        const requests = allRequests.filter((r) => r.url.includes('Followers'));
+        const requests = requestList.filter((r) => r?.url?.includes('Followers'));
         if (!requests || requests.length === 0) {
-            console.log('No specific Followers requests captured. Check keys printed above.');
             return [];
         }
         let results = [];

package/dist/clis/twitter/following.js

@@ -43,13 +43,12 @@ cli({
         await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
         // 4. Retrieve data from opencli's registered interceptors
         const requests = await page.getInterceptedRequests();
-        // Debug: Force dump all intercepted XHRs that match following
-        if (!requests || requests.length === 0) {
-            console.log('No Following requests captured by the interceptor backend.');
+        const requestList = Array.isArray(requests) ? requests : [];
+        if (requestList.length === 0) {
             return [];
         }
         let results = [];
-        for (const req of requests) {
+        for (const req of requestList) {
             try {
                 let instructions = req.data?.data?.user?.result?.timeline?.timeline?.instructions;
                 if (!instructions)

package/dist/clis/twitter/like.js

@@ -13,7 +13,6 @@ cli({
     func: async (page, kwargs) => {
         if (!page)
             throw new Error('Requires browser');
-        console.log(`Navigating to tweet: ${kwargs.url}`);
         await page.goto(kwargs.url);
         await page.wait(5); // Wait for tweet to load completely
         const result = await page.evaluate(`(async () => {

package/dist/clis/twitter/notifications.js

@@ -11,11 +11,14 @@ cli({
     ],
     columns: ['id', 'action', 'author', 'text', 'url'],
     func: async (page, kwargs) => {
+        // Install the interceptor before loading the notifications page so we
+        // capture the initial timeline request triggered during page load.
+        await page.goto('https://x.com');
+        await page.wait(2);
+        await page.installInterceptor('NotificationsTimeline');
         // 1. Navigate to notifications
         await page.goto('https://x.com/notifications');
         await page.wait(5);
-        // 2. Inject interceptor
-        await page.installInterceptor('NotificationsTimeline');
         // 3. Trigger API by scrolling (if we need to load more)
         await page.autoScroll({ times: 2, delayMs: 2000 });
         // 4. Retrieve data
@@ -23,6 +26,7 @@ cli({
         if (!requests || requests.length === 0)
             return [];
         let results = [];
+        const seen = new Set();
         for (const req of requests) {
             try {
                 let instructions = [];
@@ -65,13 +69,15 @@ cli({
                     if (item.__typename === 'TimelineNotification') {
                         // Greet likes, retweet, mentions
                         text = item.rich_message?.text || item.message?.text || '';
-                        author = item.template?.from_users?.[0]?.user_results?.result?.core?.screen_name || 'unknown';
+                        const fromUser = item.template?.from_users?.[0]?.user_results?.result;
+                        author = fromUser?.legacy?.screen_name || fromUser?.core?.screen_name || 'unknown';
                         urlStr = item.notification_url?.url || '';
                         actionText = item.notification_icon || 'Activity';
                         // If there's an attached tweet
                         const targetTweet = item.template?.target_objects?.[0]?.tweet_results?.result;
                         if (targetTweet) {
-                            text += ' | ' + (targetTweet.legacy?.full_text || '');
+                            const targetText = targetTweet.note_tweet?.note_tweet_results?.result?.text || targetTweet.legacy?.full_text || '';
+                            text += text && targetText ? ' | ' + targetText : targetText;
                             if (!urlStr) {
                                 urlStr = `https://x.com/i/status/${targetTweet.rest_id}`;
                             }
@@ -81,18 +87,22 @@ cli({
                         // Direct mention/reply
                         const tweet = item.tweet_result?.result;
                         author = tweet?.core?.user_results?.result?.legacy?.screen_name || 'unknown';
-                        text = tweet?.legacy?.full_text || item.message?.text || '';
+                        text = tweet?.note_tweet?.note_tweet_results?.result?.text || tweet?.legacy?.full_text || item.message?.text || '';
                         actionText = 'Mention/Reply';
                         urlStr = `https://x.com/i/status/${tweet?.rest_id}`;
                     }
                     else if (item.__typename === 'Tweet') {
                         author = item.core?.user_results?.result?.legacy?.screen_name || 'unknown';
-                        text = item.legacy?.full_text || '';
+                        text = item.note_tweet?.note_tweet_results?.result?.text || item.legacy?.full_text || '';
                         actionText = 'Mention';
                         urlStr = `https://x.com/i/status/${item.rest_id}`;
                     }
+                    const id = item.id || item.rest_id || entryId;
+                    if (seen.has(id))
+                        return;
+                    seen.add(id);
                     results.push({
-                        id: item.id || item.rest_id || entryId,
+                        id,
                         action: actionText,
                         author: author,
                         text: text,

package/dist/clis/twitter/search.js

@@ -12,12 +12,15 @@ cli({
     ],
     columns: ['id', 'author', 'text', 'likes', 'views', 'url'],
     func: async (page, kwargs) => {
+        // Install the interceptor before opening the target page so we don't miss
+        // the initial SearchTimeline request fired during hydration.
+        await page.goto('https://x.com');
+        await page.wait(2);
+        await page.installInterceptor('SearchTimeline');
         // 1. Navigate to the search page
         const q = encodeURIComponent(kwargs.query);
         await page.goto(`https://x.com/search?q=${q}&f=top`);
         await page.wait(5);
-        // 2. Inject XHR interceptor
-        await page.installInterceptor('SearchTimeline');
         // 3. Trigger API by scrolling
         await page.autoScroll({ times: 3, delayMs: 2000 });
         // 4. Retrieve data
@@ -25,11 +28,13 @@ cli({
         if (!requests || requests.length === 0)
             return [];
         let results = [];
+        const seen = new Set();
         for (const req of requests) {
             try {
-                const insts = req.data.data.search_by_raw_query.search_timeline.timeline.instructions;
-                const addEntries = insts.find((i) => i.type === 'TimelineAddEntries');
-                if (!addEntries)
+                const insts = req.data?.data?.search_by_raw_query?.search_timeline?.timeline?.instructions || [];
+                const addEntries = insts.find((i) => i.type === 'TimelineAddEntries')
+                    || insts.find((i) => i.entries && Array.isArray(i.entries));
+                if (!addEntries?.entries)
                     continue;
                 for (const entry of addEntries.entries) {
                     if (!entry.entryId.startsWith('tweet-'))
@@ -41,10 +46,13 @@ cli({
                     if (tweet.__typename === 'TweetWithVisibilityResults' && tweet.tweet) {
                         tweet = tweet.tweet;
                     }
+                    if (!tweet.rest_id || seen.has(tweet.rest_id))
+                        continue;
+                    seen.add(tweet.rest_id);
                     results.push({
                         id: tweet.rest_id,
                         author: tweet.core?.user_results?.result?.legacy?.screen_name || 'unknown',
-                        text: tweet.legacy?.full_text || '',
+                        text: tweet.note_tweet?.note_tweet_results?.result?.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}`

package/dist/clis/twitter/trending.yaml

@@ -25,9 +25,15 @@ pipeline:
           credentials: 'include',
           headers: { 'x-twitter-active-user': 'yes', 'x-csrf-token': csrfToken, 'authorization': 'Bearer ' + bearerToken }
         });
+        if (!res.ok) throw new Error('HTTP ' + res.status + '. Hint: trending endpoint may require login or API shape changed.');
         const data = await res.json();
-        const trends = data?.timeline?.instructions?.[1]?.addEntries?.entries || [];
-        return trends.filter(e => e.content?.timelineModule).flatMap(e => e.content.timelineModule.items || []).map(t => t?.item?.content?.trend).filter(Boolean);
+        const instructions = data?.timeline?.instructions || [];
+        const entries = instructions.flatMap(inst => inst?.addEntries?.entries || inst?.entries || []);
+        return entries
+          .filter(e => e.content?.timelineModule)
+          .flatMap(e => e.content.timelineModule.items || [])
+          .map(t => t?.item?.content?.trend)
+          .filter(Boolean);
       })()
 
   - map:

package/package.json

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