@jackwener/opencli 1.1.1 → 1.2.1

package/src/clis/facebook/friends.yaml

@@ -0,0 +1,42 @@
+site: facebook
+name: friends
+description: Get Facebook friend suggestions
+domain: www.facebook.com
+
+args:
+  limit:
+    type: int
+    default: 10
+    description: Number of friend suggestions
+
+pipeline:
+  - navigate:
+      url: https://www.facebook.com/friends
+      settleMs: 3000
+
+  - evaluate: |
+      (() => {
+        const limit = ${{ args.limit }};
+        const items = document.querySelectorAll('[role="listitem"]');
+        return Array.from(items)
+          .slice(0, limit)
+          .map((el, i) => {
+            const text = el.textContent.trim().replace(/\s+/g, ' ');
+            // Extract mutual info if present (before name extraction to avoid pollution)
+            const mutualMatch = text.match(/([\d,]+)\s*位.*(?:关注|共同|mutual)/);
+            // Extract name: remove mutual info, action buttons, etc.
+            let name = text
+              .replace(/[\d,]+\s*位.*(?:关注了|共同好友|mutual friends?)/, '')
+              .replace(/加好友.*/, '').replace(/Add [Ff]riend.*/, '')
+              .replace(/移除$/, '').replace(/Remove$/, '')
+              .trim();
+            return {
+              index: i + 1,
+              name: name.substring(0, 50),
+              mutual: mutualMatch ? mutualMatch[1] : '-',
+            };
+          })
+          .filter(item => item.name.length > 0);
+      })()
+
+columns: [index, name, mutual]

package/src/clis/facebook/groups.yaml

@@ -0,0 +1,50 @@
+site: facebook
+name: groups
+description: List your Facebook groups
+domain: www.facebook.com
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of groups
+
+pipeline:
+  - navigate:
+      url: https://www.facebook.com/groups/feed/
+      settleMs: 3000
+
+  - evaluate: |
+      (() => {
+        const limit = ${{ args.limit }};
+        const links = Array.from(document.querySelectorAll('a'))
+          .filter(a => {
+            const href = a.href || '';
+            return href.includes('/groups/') &&
+              !href.includes('/feed') &&
+              !href.includes('/discover') &&
+              !href.includes('/joins') &&
+              !href.includes('category=create') &&
+              a.textContent.trim().length > 2;
+          });
+
+        // Deduplicate by href
+        const seen = new Set();
+        const groups = [];
+        for (const a of links) {
+          const href = a.href.split('?')[0];
+          if (seen.has(href)) continue;
+          seen.add(href);
+          const raw = a.textContent.trim().replace(/\s+/g, ' ');
+          // Split name from "上次发帖" info
+          const parts = raw.split(/上次发帖|Last post/);
+          groups.push({
+            name: (parts[0] || '').trim().substring(0, 60),
+            last_post: parts[1] ? parts[1].replace(/^[：:]/, '').trim() : '-',
+            url: href,
+          });
+        }
+        return groups.slice(0, limit).map((g, i) => ({ index: i + 1, ...g }));
+      })()
+
+columns: [index, name, last_post, url]

package/src/clis/facebook/join-group.yaml

@@ -0,0 +1,44 @@
+site: facebook
+name: join-group
+description: Join a Facebook group
+domain: www.facebook.com
+
+args:
+  group:
+    type: str
+    required: true
+    positional: true
+    description: Group ID or URL path (e.g. '1876150192925481' or group name)
+
+pipeline:
+  - navigate:
+      url: https://www.facebook.com/groups/${{ args.group }}
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const group = ${{ args.group | json }};
+        const groupName = document.querySelector('h1')?.textContent?.trim() || group;
+
+        // Find "Join Group" button
+        const buttons = Array.from(document.querySelectorAll('[role="button"]'));
+        const joinBtn = buttons.find(b => {
+          const text = b.textContent.trim();
+          return text === '加入小组' || text === 'Join group' || text === 'Join Group';
+        });
+
+        if (!joinBtn) {
+          const isMember = buttons.some(b => {
+            const t = b.textContent.trim();
+            return t === '已加入' || t === 'Joined' || t === '成员' || t === 'Member';
+          });
+          if (isMember) return [{ status: 'Already a member', group: groupName }];
+          return [{ status: 'Join button not found', group: groupName }];
+        }
+
+        joinBtn.click();
+        await new Promise(r => setTimeout(r, 1500));
+        return [{ status: 'Join request sent', group: groupName }];
+      })()
+
+columns: [status, group]

package/src/clis/facebook/memories.yaml

@@ -0,0 +1,39 @@
+site: facebook
+name: memories
+description: Get your Facebook memories (On This Day)
+domain: www.facebook.com
+
+args:
+  limit:
+    type: int
+    default: 10
+    description: Number of memories
+
+pipeline:
+  - navigate:
+      url: https://www.facebook.com/onthisday
+      settleMs: 4000
+
+  - evaluate: |
+      (() => {
+        const limit = ${{ args.limit }};
+        const articles = document.querySelectorAll('[role="article"]');
+        return Array.from(articles)
+          .slice(0, limit)
+          .map((el, i) => {
+            const headerLink = el.querySelector('h2 a, h3 a, h4 a, strong a');
+            const spans = Array.from(el.querySelectorAll('div[dir="auto"]'))
+              .map(s => s.textContent.trim())
+              .filter(t => t.length > 5 && t.length < 500);
+            const timeEl = el.querySelector('a[href*="/posts/"] span, a[href*="story_fbid"] span');
+            return {
+              index: i + 1,
+              source: headerLink ? headerLink.textContent.trim().substring(0, 50) : '-',
+              content: (spans[0] || '').replace(/\n/g, ' ').substring(0, 150),
+              time: timeEl ? timeEl.textContent.trim() : '-',
+            };
+          })
+          .filter(item => item.content.length > 0 || item.source !== '-');
+      })()
+
+columns: [index, source, content, time]

package/src/clis/facebook/notifications.yaml

@@ -0,0 +1,40 @@
+site: facebook
+name: notifications
+description: Get recent Facebook notifications
+domain: www.facebook.com
+
+args:
+  limit:
+    type: int
+    default: 15
+    description: Number of notifications
+
+pipeline:
+  - navigate:
+      url: https://www.facebook.com/notifications
+      settleMs: 3000
+
+  - evaluate: |
+      (() => {
+        const limit = ${{ args.limit }};
+        const items = document.querySelectorAll('[role="listitem"]');
+        return Array.from(items)
+          .filter(el => el.querySelectorAll('a').length > 0)
+          .slice(0, limit)
+          .map((el, i) => {
+            const raw = el.textContent.trim().replace(/\s+/g, ' ');
+            // Remove leading "未读" and trailing "标记为已读"
+            const cleaned = raw.replace(/^未读/, '').replace(/标记为已读$/, '').replace(/^Unread/, '').replace(/Mark as read$/, '').trim();
+            // Try to extract time (last segment like "11小时", "5天", "1周")
+            const timeMatch = cleaned.match(/(\d+\s*(?:分钟|小时|天|周|个月|minutes?|hours?|days?|weeks?|months?))\s*$/);
+            const time = timeMatch ? timeMatch[1] : '';
+            const text = timeMatch ? cleaned.slice(0, -timeMatch[0].length).trim() : cleaned;
+            return {
+              index: i + 1,
+              text: text.substring(0, 150),
+              time: time || '-',
+            };
+          });
+      })()
+
+columns: [index, text, time]

package/src/clis/facebook/profile.yaml

@@ -0,0 +1,37 @@
+site: facebook
+name: profile
+description: Get Facebook user/page profile info
+domain: www.facebook.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: Facebook username or page name
+
+pipeline:
+  - navigate:
+      url: https://www.facebook.com/${{ args.username }}
+      settleMs: 3000
+
+  - evaluate: |
+      (() => {
+        const h1 = document.querySelector('h1');
+        let name = h1 ? h1.textContent.trim() : '';
+
+        // Find friends/followers links
+        const links = Array.from(document.querySelectorAll('a'));
+        const friendsLink = links.find(a => a.href && a.href.includes('/friends'));
+        const followersLink = links.find(a => a.href && a.href.includes('/followers'));
+
+        return [{
+          name: name,
+          username: ${{ args.username | json }},
+          friends: friendsLink ? friendsLink.textContent.trim() : '-',
+          followers: followersLink ? followersLink.textContent.trim() : '-',
+          url: window.location.href,
+        }];
+      })()
+
+columns: [name, username, friends, followers, url]

package/src/clis/facebook/search.yaml

@@ -0,0 +1,46 @@
+site: facebook
+name: search
+description: Search Facebook for people, pages, or posts
+domain: www.facebook.com
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Search query
+  limit:
+    type: int
+    default: 10
+    description: Number of results
+
+pipeline:
+  - navigate: https://www.facebook.com
+
+  - evaluate: |
+      (async () => {
+        const query = ${{ args.query | json }};
+        const limit = ${{ args.limit }};
+        window.location.href = 'https://www.facebook.com/search/top?q=' + encodeURIComponent(query);
+        await new Promise(r => setTimeout(r, 4000));
+        // Search results are typically in role="article" or role="listitem"
+        let items = document.querySelectorAll('[role="article"]');
+        if (items.length === 0) {
+          items = document.querySelectorAll('[role="listitem"]');
+        }
+        return Array.from(items)
+          .filter(el => el.textContent.trim().length > 20)
+          .slice(0, limit)
+          .map((el, i) => {
+            const link = el.querySelector('a[href*="facebook.com/"]');
+            const heading = el.querySelector('h2, h3, h4, strong');
+            return {
+              index: i + 1,
+              title: heading ? heading.textContent.trim().substring(0, 80) : '',
+              text: el.textContent.trim().replace(/\s+/g, ' ').substring(0, 150),
+              url: link ? link.href.split('?')[0] : '',
+            };
+          });
+      })()
+
+columns: [index, title, text, url]

package/src/clis/google/news.ts

@@ -0,0 +1,66 @@
+/**
+ * Google News via public RSS feed.
+ * Supports top stories (no keyword) and search (with keyword).
+ */
+
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { parseRssItems } from './utils.js';
+
+cli({
+  site: 'google',
+  name: 'news',
+  description: 'Get Google News headlines',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'keyword', positional: true, help: 'Search query (omit for top stories)' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of results' },
+    { name: 'lang', default: 'en', help: 'Language short code (e.g. en, zh)' },
+    { name: 'region', default: 'US', help: 'Region code (e.g. US, CN)' },
+  ],
+  columns: ['title', 'source', 'date', 'url'],
+  func: async (_page, args) => {
+    const limit = Math.max(1, Math.min(Number(args.limit), 100));
+    const lang = encodeURIComponent(args.lang);
+    const region = encodeURIComponent(args.region);
+    const ceid = `${args.region}:${args.lang}`;
+
+    // Top stories or search
+    const base = args.keyword
+      ? `https://news.google.com/rss/search?q=${encodeURIComponent(args.keyword)}&hl=${lang}&gl=${region}&ceid=${ceid}`
+      : `https://news.google.com/rss?hl=${lang}&gl=${region}&ceid=${ceid}`;
+
+    const resp = await fetch(base);
+    if (!resp.ok) {
+      throw new CliError('FETCH_ERROR', `HTTP ${resp.status}`, 'Check your network connection');
+    }
+
+    const xml = await resp.text();
+    const items = parseRssItems(xml, ['title', 'link', 'pubDate', 'source']);
+
+    if (!items.length) {
+      throw new CliError('NOT_FOUND', 'No news articles found', 'Try a different keyword or region');
+    }
+
+    return items.slice(0, limit).map(item => {
+      // Extract source: prefer <source> element, fallback to parsing title
+      let title = item['title'] || '';
+      let source = item['source'] || '';
+      if (!source) {
+        const idx = title.lastIndexOf(' - ');
+        if (idx !== -1) {
+          source = title.slice(idx + 3);
+          title = title.slice(0, idx);
+        }
+      }
+
+      return {
+        title,
+        source,
+        date: item['pubDate'] || '',
+        url: item['link'] || '',
+      };
+    });
+  },
+});

package/src/clis/google/search.ts

@@ -0,0 +1,133 @@
+/**
+ * Google Web Search via browser DOM extraction.
+ * Uses browser mode to navigate google.com and extract results from the DOM.
+ *
+ * Extraction strategy (2026-03): Google no longer uses `.g` class containers.
+ * Instead, we find all `a` tags containing `h3` within `#rso`, then walk up
+ * to the result container (`div.tF2Cxc` or closest `div[data-hveid]`) to find
+ * snippets. This approach is resilient to class name changes.
+ */
+
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+
+cli({
+  site: 'google',
+  name: 'search',
+  description: 'Search Google',
+  domain: 'google.com',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: 'keyword', positional: true, required: true, help: 'Search query' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of results (1-100)' },
+    { name: 'lang', default: 'en', help: 'Language short code (e.g. en, zh)' },
+  ],
+  columns: ['type', 'title', 'url', 'snippet'],
+  func: async (page, args) => {
+    const limit = Math.max(1, Math.min(Number(args.limit), 100));
+    const keyword = encodeURIComponent(args.keyword);
+    const lang = encodeURIComponent(args.lang);
+    const url = `https://www.google.com/search?q=${keyword}&hl=${lang}&num=${limit}`;
+
+    await page.goto(url);
+    await page.wait(2);
+
+    const results = await page.evaluate(`
+      (function() {
+        var results = [];
+        var seenUrls = {};
+        var rso = document.querySelector('#rso');
+        if (!rso) return results;
+
+        // -- Featured snippet (scoped to #rso to avoid matching unrelated elements) --
+        var featuredEl = rso.querySelector('.xpdopen .hgKElc')
+                      || rso.querySelector('.IZ6rdc');
+        if (featuredEl) {
+          var parentBlock = featuredEl.closest('[data-hveid]') || featuredEl.parentElement;
+          var fLink = parentBlock ? parentBlock.querySelector('a[href]') : null;
+          var fUrl = fLink ? fLink.href : '';
+          if (fUrl) seenUrls[fUrl] = true;
+          results.push({
+            type: 'snippet',
+            title: featuredEl.textContent.trim().slice(0, 200),
+            url: fUrl,
+            snippet: '',
+          });
+        }
+
+        // -- Standard search results --
+        // Strategy: find all links containing h3 within #rso
+        var allLinks = rso.querySelectorAll('a');
+        for (var i = 0; i < allLinks.length; i++) {
+          var link = allLinks[i];
+          var h3 = link.querySelector('h3');
+          if (!h3) continue;
+
+          var href = link.href || '';
+          // Skip non-http, Google internal links, and duplicates
+          if (!href.match(/^https?:\\/\\//)) continue;
+          if (href.indexOf('google.com/search') !== -1) continue;
+          if (seenUrls[href]) continue;
+          seenUrls[href] = true;
+
+          // Walk up to find result container for snippet extraction
+          var container = link;
+          for (var j = 0; j < 6; j++) {
+            if (container.parentElement && container.parentElement !== rso) {
+              container = container.parentElement;
+            }
+            // Stop at a known result boundary
+            if (container.getAttribute && container.getAttribute('data-hveid')) break;
+          }
+
+          // Find snippet: look for descriptive text, skip breadcrumbs and metadata
+          var snippetText = '';
+          var titleText = h3.textContent.trim();
+          var candidates = container.querySelectorAll('span, div');
+          for (var k = 0; k < candidates.length; k++) {
+            var el = candidates[k];
+            if (el.querySelector('h3') || el.querySelector('a[href]')) continue;
+            var text = el.textContent.trim();
+            if (text.length < 40 || text.length > 500) continue;
+            if (text === titleText) continue;
+            // Skip URL breadcrumbs (e.g. "https://example.com › path..." or "Site Namehttps://...")
+            if (text.indexOf('\u203A') !== -1) continue;
+            if (new RegExp('https?://').test(text.slice(0, 60))) continue;
+            snippetText = text;
+            break;
+          }
+
+          results.push({
+            type: 'result',
+            title: h3.textContent.trim(),
+            url: href,
+            snippet: snippetText.slice(0, 300),
+          });
+        }
+
+        // -- People Also Ask --
+        var paaContainers = document.querySelectorAll('[data-sgrd="true"]');
+        for (var i = 0; i < paaContainers.length; i++) {
+          var questionEl = paaContainers[i].querySelector('span.CSkcDe');
+          if (questionEl) {
+            results.push({
+              type: 'paa',
+              title: questionEl.textContent.trim(),
+              url: '',
+              snippet: '',
+            });
+          }
+        }
+
+        return results;
+      })()
+    `);
+
+    if (!Array.isArray(results) || results.length === 0) {
+      throw new CliError('NOT_FOUND', 'No search results found', 'Try a different keyword or check for CAPTCHA');
+    }
+
+    return results;
+  },
+});

package/src/clis/google/suggest.ts

@@ -0,0 +1,40 @@
+/**
+ * Google Search Suggestions via public JSON API.
+ * Uses suggestqueries.google.com with client=firefox for pure JSON (not JSONP).
+ */
+
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+
+cli({
+  site: 'google',
+  name: 'suggest',
+  description: 'Get Google search suggestions',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'keyword', positional: true, required: true, help: 'Search query' },
+    { name: 'lang', default: 'zh-CN', help: 'Language code' },
+  ],
+  columns: ['suggestion'],
+  func: async (_page, args) => {
+    const keyword = encodeURIComponent(args.keyword);
+    const lang = encodeURIComponent(args.lang);
+    const url = `https://suggestqueries.google.com/complete/search?client=firefox&q=${keyword}&hl=${lang}`;
+
+    const resp = await fetch(url);
+    if (!resp.ok) {
+      throw new CliError('FETCH_ERROR', `HTTP ${resp.status}`, 'Check your network connection');
+    }
+
+    const data = await resp.json();
+    // Response format: ["query", ["suggestion1", "suggestion2", ...]]
+    const suggestions: string[] = Array.isArray(data) && Array.isArray(data[1]) ? data[1] : [];
+
+    if (!suggestions.length) {
+      throw new CliError('NOT_FOUND', 'No suggestions found', 'Try a different keyword');
+    }
+
+    return suggestions.map(s => ({ suggestion: s }));
+  },
+});

package/src/clis/google/trends.ts

@@ -0,0 +1,44 @@
+/**
+ * Google Trends via public RSS feed.
+ * Shows daily trending searches for a given region.
+ */
+
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { parseRssItems } from './utils.js';
+
+cli({
+  site: 'google',
+  name: 'trends',
+  description: 'Get Google Trends daily trending searches',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'region', default: 'US', help: 'Region code (e.g. US, CN, JP)' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+  ],
+  columns: ['title', 'traffic', 'date'],
+  func: async (_page, args) => {
+    const limit = Math.max(1, Math.min(Number(args.limit), 100));
+    const region = encodeURIComponent(args.region);
+    const url = `https://trends.google.com/trending/rss?geo=${region}`;
+
+    const resp = await fetch(url);
+    if (!resp.ok) {
+      throw new CliError('FETCH_ERROR', `HTTP ${resp.status}`, 'Check your network connection or region code');
+    }
+
+    const xml = await resp.text();
+    const items = parseRssItems(xml, ['title', 'pubDate', 'ht:approx_traffic']);
+
+    if (!items.length) {
+      throw new CliError('NOT_FOUND', 'No trending data found', 'Try a different region code');
+    }
+
+    return items.slice(0, limit).map(item => ({
+      title: item['title'],
+      traffic: item['ht:approx_traffic'],  // raw string e.g. "1,000,000+", no numeric conversion
+      date: item['pubDate'],
+    }));
+  },
+});

package/src/clis/google/utils.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import { parseRssItems } from './utils.js';
+
+describe('parseRssItems', () => {
+  it('extracts plain text fields', () => {
+    const xml = `
+      <channel>
+        <item><title>Hello</title><link>https://example.com</link></item>
+        <item><title>World</title><link>https://test.com</link></item>
+      </channel>
+    `;
+    const items = parseRssItems(xml, ['title', 'link']);
+    expect(items).toEqual([
+      { title: 'Hello', link: 'https://example.com' },
+      { title: 'World', link: 'https://test.com' },
+    ]);
+  });
+
+  it('handles CDATA-wrapped content', () => {
+    const xml = `
+      <item><title><![CDATA[Breaking News]]></title><link>https://news.com</link></item>
+    `;
+    const items = parseRssItems(xml, ['title', 'link']);
+    expect(items).toEqual([
+      { title: 'Breaking News', link: 'https://news.com' },
+    ]);
+  });
+
+  it('handles namespaced fields like ht:approx_traffic', () => {
+    const xml = `
+      <item>
+        <title>AI</title>
+        <ht:approx_traffic>500,000+</ht:approx_traffic>
+        <pubDate>Mon, 20 Mar 2026</pubDate>
+      </item>
+    `;
+    const items = parseRssItems(xml, ['title', 'ht:approx_traffic', 'pubDate']);
+    expect(items).toEqual([
+      { title: 'AI', 'ht:approx_traffic': '500,000+', pubDate: 'Mon, 20 Mar 2026' },
+    ]);
+  });
+
+  it('returns empty string for missing fields', () => {
+    const xml = `<item><title>Test</title></item>`;
+    const items = parseRssItems(xml, ['title', 'missing']);
+    expect(items).toEqual([{ title: 'Test', missing: '' }]);
+  });
+
+  it('handles tags with attributes (e.g. <source url="...">)', () => {
+    const xml = `
+      <item>
+        <title><![CDATA[AI reshapes everything - Reuters]]></title>
+        <source url="https://reuters.com">Reuters</source>
+        <link>https://news.google.com/123</link>
+      </item>
+    `;
+    const items = parseRssItems(xml, ['title', 'source', 'link']);
+    expect(items).toEqual([
+      { title: 'AI reshapes everything - Reuters', source: 'Reuters', link: 'https://news.google.com/123' },
+    ]);
+  });
+
+  it('handles mixed CDATA and plain text in the same item', () => {
+    const xml = `
+      <item>
+        <title><![CDATA[Breaking: Major event]]></title>
+        <link>https://example.com/article</link>
+        <pubDate>Fri, 21 Mar 2026</pubDate>
+      </item>
+    `;
+    const items = parseRssItems(xml, ['title', 'link', 'pubDate']);
+    expect(items).toEqual([
+      { title: 'Breaking: Major event', link: 'https://example.com/article', pubDate: 'Fri, 21 Mar 2026' },
+    ]);
+  });
+
+  it('returns empty array for no items', () => {
+    const xml = `<channel><title>Empty</title></channel>`;
+    const items = parseRssItems(xml, ['title']);
+    expect(items).toEqual([]);
+  });
+});