@jackwener/opencli 1.1.0 → 1.2.0

package/dist/clis/douban/shared.js

@@ -0,0 +1,155 @@
+import { CliError } from '../../errors.js';
+function clampLimit(limit) {
+    return Math.max(1, Math.min(limit || 20, 50));
+}
+async function ensureDoubanReady(page) {
+    const state = await page.evaluate(`
+    (() => {
+      const title = (document.title || '').trim();
+      const href = (location.href || '').trim();
+      const blocked = href.includes('sec.douban.com') || /登录跳转/.test(title) || /异常请求/.test(document.body?.innerText || '');
+      return { blocked, title, href };
+    })()
+  `);
+    if (state?.blocked) {
+        throw new CliError('AUTH_REQUIRED', 'Douban requires a logged-in browser session before these commands can load data.', 'Please sign in to douban.com in the browser that opencli reuses, then rerun the command.');
+    }
+}
+export async function loadDoubanBookHot(page, limit) {
+    const safeLimit = clampLimit(limit);
+    await page.goto('https://book.douban.com/chart');
+    await page.wait(4);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const books = [];
+      for (const el of Array.from(document.querySelectorAll('.media.clearfix'))) {
+        try {
+          const titleEl = el.querySelector('h2 a[href*="/subject/"]');
+          const title = normalize(titleEl?.textContent);
+          let url = titleEl?.getAttribute('href') || '';
+          if (!title || !url) continue;
+          if (!url.startsWith('http')) url = 'https://book.douban.com' + url;
+
+          const info = normalize(el.querySelector('.subject-abstract, .pl, .pub')?.textContent);
+          const infoParts = info.split('/').map((part) => part.trim()).filter(Boolean);
+          const ratingText = normalize(el.querySelector('.subject-rating .font-small, .rating_nums, .rating')?.textContent);
+          const quote = Array.from(el.querySelectorAll('.subject-tags .tag'))
+            .map((node) => normalize(node.textContent))
+            .filter(Boolean)
+            .join(' / ');
+
+          books.push({
+            rank: parseInt(normalize(el.querySelector('.green-num-box')?.textContent), 10) || books.length + 1,
+            title,
+            rating: parseFloat(ratingText) || 0,
+            quote,
+            author: infoParts[0] || '',
+            publisher: infoParts.find((part) => /出版社|出版公司|Press/i.test(part)) || infoParts[2] || '',
+            year: infoParts.find((part) => /\\d{4}(?:-\\d{1,2})?/.test(part))?.match(/\\d{4}/)?.[0] || '',
+            price: infoParts.find((part) => /元|USD|\\$|￥/.test(part)) || '',
+            url,
+            cover: el.querySelector('img')?.getAttribute('src') || '',
+          });
+        } catch {}
+      }
+      return books.slice(0, ${safeLimit});
+    })()
+  `);
+    return Array.isArray(data) ? data : [];
+}
+export async function loadDoubanMovieHot(page, limit) {
+    const safeLimit = clampLimit(limit);
+    await page.goto('https://movie.douban.com/chart');
+    await page.wait(4);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const results = [];
+      for (const el of Array.from(document.querySelectorAll('.item'))) {
+        const titleEl = el.querySelector('.pl2 a');
+        const title = normalize(titleEl?.textContent);
+        let url = titleEl?.getAttribute('href') || '';
+        if (!title || !url) continue;
+        if (!url.startsWith('http')) url = 'https://movie.douban.com' + url;
+
+        const info = normalize(el.querySelector('.pl2 p')?.textContent);
+        const infoParts = info.split('/').map((part) => part.trim()).filter(Boolean);
+        const releaseIndex = (() => {
+          for (let i = infoParts.length - 1; i >= 0; i -= 1) {
+            if (/\\d{4}-\\d{2}-\\d{2}|\\d{4}\\/\\d{2}\\/\\d{2}/.test(infoParts[i])) return i;
+          }
+          return -1;
+        })();
+        const directorPart = releaseIndex >= 1 ? infoParts[releaseIndex - 1] : '';
+        const regionPart = releaseIndex >= 2 ? infoParts[releaseIndex - 2] : '';
+        const yearMatch = info.match(/\\b(19|20)\\d{2}\\b/);
+        results.push({
+          rank: results.length + 1,
+          title,
+          rating: parseFloat(normalize(el.querySelector('.rating_nums')?.textContent)) || 0,
+          quote: normalize(el.querySelector('.inq')?.textContent),
+          director: directorPart.replace(/^导演:\\s*/, ''),
+          year: yearMatch?.[0] || '',
+          region: regionPart,
+          url,
+          cover: el.querySelector('img')?.getAttribute('src') || '',
+        });
+        if (results.length >= ${safeLimit}) break;
+      }
+      return results;
+    })()
+  `);
+    return Array.isArray(data) ? data : [];
+}
+export async function searchDouban(page, type, keyword, limit) {
+    const safeLimit = clampLimit(limit);
+    await page.goto(`https://search.douban.com/${encodeURIComponent(type)}/subject_search?search_text=${encodeURIComponent(keyword)}`);
+    await page.wait(2);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (async () => {
+      const type = ${JSON.stringify(type)};
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const seen = new Set();
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+      for (let i = 0; i < 20; i += 1) {
+        if (document.querySelector('.item-root .title-text, .item-root .title a')) break;
+        await sleep(300);
+      }
+
+      const items = Array.from(document.querySelectorAll('.item-root'));
+
+      const results = [];
+      for (const el of items) {
+        const titleEl = el.querySelector('.title-text, .title a, a[title]');
+        const title = normalize(titleEl?.textContent) || normalize(titleEl?.getAttribute('title'));
+        let url = titleEl?.getAttribute('href') || '';
+        if (!title || !url) continue;
+        if (!url.startsWith('http')) url = 'https://search.douban.com' + url;
+        if (!url.includes('/subject/') || seen.has(url)) continue;
+        seen.add(url);
+        const ratingText = normalize(el.querySelector('.rating_nums')?.textContent);
+        const abstract = normalize(
+          el.querySelector('.meta.abstract, .meta, .abstract, p')?.textContent,
+        );
+        results.push({
+          rank: results.length + 1,
+          id: url.match(/subject\\/(\\d+)/)?.[1] || '',
+          type,
+          title,
+          rating: ratingText.includes('.') ? parseFloat(ratingText) : 0,
+          abstract: abstract.slice(0, 100) + (abstract.length > 100 ? '...' : ''),
+          url,
+          cover: el.querySelector('img')?.getAttribute('src') || '',
+        });
+        if (results.length >= ${safeLimit}) break;
+      }
+      return results;
+    })()
+  `);
+    return Array.isArray(data) ? data : [];
+}

package/dist/clis/douban/subject.yaml

@@ -0,0 +1,76 @@
+site: douban
+name: subject
+description: 获取电影详情
+domain: movie.douban.com
+strategy: cookie
+browser: true
+
+args:
+  id:
+    positional: true
+    required: true
+    type: str
+    description: 电影 ID
+
+pipeline:
+  - navigate: https://movie.douban.com/subject/${{ args.id }}
+
+  - evaluate: |
+      (async () => {
+        const id = '${{ args.id }}';
+        
+        // Wait for page to load
+        await new Promise(r => setTimeout(r, 2000));
+        
+        // Extract title
+        const titleEl = document.querySelector('span[property="v:itemreviewed"]');
+        const title = titleEl?.textContent?.trim() || '';
+        
+        // Extract original title
+        const ogTitleEl = document.querySelector('span[property="v:originalTitle"]');
+        const originalTitle = ogTitleEl?.textContent?.trim() || '';
+        
+        // Extract year
+        const yearEl = document.querySelector('.year');
+        const year = yearEl?.textContent?.trim() || '';
+        
+        // Extract rating
+        const ratingEl = document.querySelector('strong[property="v:average"]');
+        const rating = parseFloat(ratingEl?.textContent || '0');
+        
+        // Extract rating count
+        const ratingCountEl = document.querySelector('span[property="v:votes"]');
+        const ratingCount = parseInt(ratingCountEl?.textContent || '0', 10);
+        
+        // Extract genres
+        const genreEls = document.querySelectorAll('span[property="v:genre"]');
+        const genres = Array.from(genreEls).map(el => el.textContent?.trim()).filter(Boolean).join(',');
+        
+        // Extract directors
+        const directorEls = document.querySelectorAll('a[rel="v:directedBy"]');
+        const directors = Array.from(directorEls).map(el => el.textContent?.trim()).filter(Boolean).join(',');
+        
+        // Extract casts
+        const castEls = document.querySelectorAll('a[rel="v:starring"]');
+        const casts = Array.from(castEls).slice(0, 5).map(el => el.textContent?.trim()).filter(Boolean).join(',');
+        
+        // Extract summary
+        const summaryEl = document.querySelector('span[property="v:summary"]');
+        const summary = summaryEl?.textContent?.trim() || '';
+        
+        return [{
+          id,
+          title,
+          originalTitle,
+          year,
+          rating,
+          ratingCount,
+          genres,
+          directors,
+          casts,
+          summary: summary.substring(0, 200),
+          url: `https://movie.douban.com/subject/${id}`
+        }];
+      })()
+
+columns: [id, title, originalTitle, year, rating, ratingCount, genres, directors, casts, summary, url]

package/dist/clis/douban/top250.yaml

@@ -0,0 +1,70 @@
+site: douban
+name: top250
+description: 豆瓣电影 Top250
+domain: movie.douban.com
+strategy: cookie
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 250
+    description: 返回结果数量
+
+pipeline:
+  - navigate: https://movie.douban.com/top250
+
+  - evaluate: |
+      async () => {
+        const results = [];
+        const limit = ${{ args.limit }};
+
+        const parsePage = (doc) => {
+          const items = doc.querySelectorAll('.item');
+          for (const item of items) {
+            if (results.length >= limit) break;
+
+            const rankEl = item.querySelector('.pic em');
+            const linkEl = item.querySelector('a');
+            const titleEl = item.querySelector('.title');
+            const ratingEl = item.querySelector('.rating_num');
+
+            const href = linkEl?.href || '';
+            const matchResult = href.match(/subject\/(\d+)/);
+            const id = matchResult ? matchResult[1] : '';
+
+            const title = titleEl?.textContent?.trim() || '';
+            const rank = parseInt(rankEl?.textContent || '0', 10);
+            const rating = ratingEl?.textContent?.trim() || '';
+
+            if (id && title) {
+              results.push({
+                rank: rank || results.length + 1,
+                id,
+                title,
+                rating: rating ? parseFloat(rating) : 0,
+                url: href
+              });
+            }
+          }
+        };
+
+        parsePage(document);
+
+        for (let start = 25; start < 250 && results.length < limit; start += 25) {
+          const resp = await fetch(`https://movie.douban.com/top250?start=${start}`);
+          if (!resp.ok) break;
+          const html = await resp.text();
+          if (!html) break;
+
+          const doc = new DOMParser().parseFromString(html, 'text/html');
+          parsePage(doc);
+          await new Promise(r => setTimeout(r, 150));
+        }
+
+        return results;
+      }
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, id, title, rating, url]

package/dist/clis/douban/utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Douban movie adapter utilities.
+ */
+import type { IPage } from '../../types.js';
+/**
+ * Get current user's Douban ID from movie.douban.com/mine page
+ */
+export declare function getSelfUid(page: IPage): Promise<string>;
+/**
+ * Douban mark (viewing record) interface
+ */
+export interface DoubanMark {
+    movieId: string;
+    title: string;
+    year: string;
+    myRating: number | null;
+    myStatus: 'collect' | 'wish' | 'do';
+    myComment: string;
+    myDate: string;
+    url: string;
+}
+/**
+ * Douban review interface
+ */
+export interface DoubanReview {
+    reviewId: string;
+    movieId: string;
+    movieTitle: string;
+    title: string;
+    content: string;
+    myRating: number;
+    createdAt: string;
+    votes: number;
+    url: string;
+}

package/dist/clis/douban/utils.js

@@ -0,0 +1,48 @@
+/**
+ * Douban movie adapter utilities.
+ */
+/**
+ * Get current user's Douban ID from movie.douban.com/mine page
+ */
+export async function getSelfUid(page) {
+    await page.goto('https://movie.douban.com/mine');
+    await page.wait({ time: 2 });
+    const uid = await page.evaluate(`
+    (() => {
+      // 方案1: 尝试从全局变量获取
+      if (window.__DATA__ && window.__DATA__.uid) {
+        return window.__DATA__.uid;
+      }
+      
+      // 方案2: 从导航栏用户链接获取
+      const navUserLink = document.querySelector('.nav-user-account a');
+      if (navUserLink) {
+        const href = navUserLink.href || '';
+        const match = href.match(/people\\/([^/]+)/);
+        if (match) return match[1];
+      }
+      
+      // 方案3: 从页面中的个人主页链接获取
+      const profileLink = document.querySelector('a[href*="/people/"]');
+      if (profileLink) {
+        const href = profileLink.getAttribute('href') || profileLink.href || '';
+        const match = href.match(/people\\/([^/]+)/);
+        if (match) return match[1];
+      }
+      
+      // 方案4: 从头部用户名区域获取
+      const userLink = document.querySelector('.global-nav-items a[href*="/people/"]');
+      if (userLink) {
+        const href = userLink.getAttribute('href') || userLink.href || '';
+        const match = href.match(/people\\/([^/]+)/);
+        if (match) return match[1];
+      }
+      
+      return '';
+    })()
+  `);
+    if (!uid) {
+        throw new Error('Not logged in to Douban. Please login in Chrome first.');
+    }
+    return uid;
+}

package/dist/clis/facebook/add-friend.yaml

@@ -0,0 +1,43 @@
+site: facebook
+name: add-friend
+description: Send a friend request on Facebook
+domain: www.facebook.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: Facebook username or profile URL
+
+pipeline:
+  - navigate:
+      url: https://www.facebook.com/${{ args.username }}
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        // Find "Add Friend" button
+        const buttons = Array.from(document.querySelectorAll('[role="button"]'));
+        const addBtn = buttons.find(b => {
+          const text = b.textContent.trim();
+          return text === '加好友' || text === 'Add Friend' || text === 'Add friend';
+        });
+
+        if (!addBtn) {
+          // Check if already friends
+          const isFriend = buttons.some(b => {
+            const t = b.textContent.trim();
+            return t === '好友' || t === 'Friends' || t.includes('已发送') || t.includes('Pending');
+          });
+          if (isFriend) return [{ status: 'Already friends or request pending', username }];
+          return [{ status: 'Add Friend button not found', username }];
+        }
+
+        addBtn.click();
+        await new Promise(r => setTimeout(r, 1500));
+        return [{ status: 'Friend request sent', username }];
+      })()
+
+columns: [status, username]

package/dist/clis/facebook/events.yaml

@@ -0,0 +1,44 @@
+site: facebook
+name: events
+description: Browse Facebook event categories
+domain: www.facebook.com
+
+args:
+  limit:
+    type: int
+    default: 15
+    description: Number of categories
+
+pipeline:
+  - navigate:
+      url: https://www.facebook.com/events
+      settleMs: 3000
+
+  - evaluate: |
+      (() => {
+        const limit = ${{ args.limit }};
+        // Try actual event items first
+        const articles = document.querySelectorAll('[role="article"]');
+        if (articles.length > 0) {
+          return Array.from(articles).slice(0, limit).map((el, i) => ({
+            index: i + 1,
+            name: el.textContent.trim().replace(/\s+/g, ' ').substring(0, 120),
+          }));
+        }
+
+        // List event categories from sidebar navigation
+        const links = Array.from(document.querySelectorAll('[role="navigation"] a'))
+          .filter(a => {
+            const href = a.href || '';
+            const text = a.textContent.trim();
+            return href.includes('/events/') && text.length > 1 && text.length < 60 &&
+              !href.includes('create');
+          });
+
+        return links.slice(0, limit).map((a, i) => ({
+          index: i + 1,
+          name: a.textContent.trim(),
+        }));
+      })()
+
+columns: [index, name]

package/dist/clis/facebook/feed.yaml

@@ -0,0 +1,63 @@
+site: facebook
+name: feed
+description: Get your Facebook news feed
+domain: www.facebook.com
+
+args:
+  limit:
+    type: int
+    default: 10
+    description: Number of posts
+
+pipeline:
+  - navigate:
+      url: https://www.facebook.com/
+      settleMs: 4000
+
+  - evaluate: |
+      (() => {
+        const limit = ${{ args.limit }};
+        const posts = document.querySelectorAll('[role="article"]');
+        return Array.from(posts)
+          .filter(el => {
+            const text = el.textContent.trim();
+            // Filter out "People you may know" suggestions (both CN and EN)
+            return text.length > 30 &&
+              !text.startsWith('可能认识') &&
+              !text.startsWith('People you may know') &&
+              !text.startsWith('People You May Know');
+          })
+          .slice(0, limit)
+          .map((el, i) => {
+            // Author from header link
+            const headerLink = el.querySelector('h2 a, h3 a, h4 a, strong a');
+            const author = headerLink ? headerLink.textContent.trim() : '';
+
+            // Post text: grab visible spans, filter noise
+            const spans = Array.from(el.querySelectorAll('div[dir="auto"]'))
+              .map(s => s.textContent.trim())
+              .filter(t => t.length > 10 && t.length < 500);
+            const content = spans.length > 0 ? spans[0] : '';
+
+            // Engagement: find like/comment/share counts (CN + EN)
+            const allText = el.textContent;
+            const likesMatch = allText.match(/所有心情：([\d,.\s]*[\d万亿KMk]+)/) ||
+                               allText.match(/All:\s*([\d,.KMk]+)/) ||
+                               allText.match(/([\d,.KMk]+)\s*(?:likes?|reactions?)/i);
+            const commentsMatch = allText.match(/([\d,.]+\s*[万亿]?)\s*条评论/) ||
+                                  allText.match(/([\d,.KMk]+)\s*comments?/i);
+            const sharesMatch = allText.match(/([\d,.]+\s*[万亿]?)\s*次分享/) ||
+                                allText.match(/([\d,.KMk]+)\s*shares?/i);
+
+            return {
+              index: i + 1,
+              author: author.substring(0, 50),
+              content: content.replace(/\n/g, ' ').substring(0, 120),
+              likes: likesMatch ? likesMatch[1] : '-',
+              comments: commentsMatch ? commentsMatch[1] : '-',
+              shares: sharesMatch ? sharesMatch[1] : '-',
+            };
+          });
+      })()
+
+columns: [index, author, content, likes, comments, shares]

package/dist/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/dist/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/dist/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]