@jackwener/opencli 0.6.3 → 0.7.0

package/src/clis/reddit/upvote.ts

@@ -0,0 +1,67 @@
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'reddit',
+  name: 'upvote',
+  description: 'Upvote or downvote a Reddit post',
+  domain: 'reddit.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'post_id', type: 'string', required: true, help: 'Post ID (e.g. 1abc123) or fullname (t3_xxx)' },
+    { name: 'direction', type: 'string', default: 'up', help: 'Vote direction: up, down, none' },
+  ],
+  columns: ['status', 'message'],
+  func: async (page, kwargs) => {
+    if (!page) throw new Error('Requires browser');
+
+    await page.goto('https://www.reddit.com');
+    await page.wait(3);
+
+    const result = await page.evaluate(`(async () => {
+      try {
+        let postId = ${JSON.stringify(kwargs.post_id)};
+        // Extract ID from URL if needed
+        const urlMatch = postId.match(/comments\\/([a-z0-9]+)/);
+        if (urlMatch) postId = urlMatch[1];
+        // Build fullname
+        const fullname = postId.startsWith('t3_') || postId.startsWith('t1_')
+          ? postId : 't3_' + postId;
+
+        const dir = ${JSON.stringify(kwargs.direction)};
+        const direction = dir === 'down' ? -1 : dir === 'none' ? 0 : 1;
+
+        // Get modhash from Reddit config
+        const configEl = document.getElementById('config');
+        let modhash = '';
+        if (configEl) {
+          modhash = configEl.querySelector('[name="uh"]')?.getAttribute('content') || '';
+        }
+        if (!modhash) {
+          // Try fetching from /api/me.json
+          const meRes = await fetch('/api/me.json', { credentials: 'include' });
+          const me = await meRes.json();
+          modhash = me?.data?.modhash || '';
+        }
+
+        const res = await fetch('/api/vote', {
+          method: 'POST',
+          credentials: 'include',
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+          body: 'id=' + encodeURIComponent(fullname)
+            + '&dir=' + direction
+            + (modhash ? '&uh=' + encodeURIComponent(modhash) : ''),
+        });
+
+        if (!res.ok) return { ok: false, message: 'HTTP ' + res.status };
+
+        const labels = { '1': 'Upvoted', '-1': 'Downvoted', '0': 'Vote removed' };
+        return { ok: true, message: (labels[String(direction)] || 'Voted') + ' ' + fullname };
+      } catch (e) {
+        return { ok: false, message: e.toString() };
+      }
+    })()`);
+
+    return [{ status: result.ok ? 'success' : 'failed', message: result.message }];
+  }
+});

package/src/clis/reddit/upvoted.ts

@@ -0,0 +1,48 @@
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'reddit',
+  name: 'upvoted',
+  description: 'Browse your upvoted Reddit posts',
+  domain: 'reddit.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'limit', type: 'int', default: 15 },
+  ],
+  columns: ['title', 'subreddit', 'score', 'comments', 'url'],
+  func: async (page, kwargs) => {
+    if (!page) throw new Error('Requires browser');
+
+    await page.goto('https://www.reddit.com');
+    await page.wait(3);
+
+    const result = await page.evaluate(`(async () => {
+      try {
+        // Get current username
+        const meRes = await fetch('/api/me.json?raw_json=1', { credentials: 'include' });
+        const me = await meRes.json();
+        const username = me?.name || me?.data?.name;
+        if (!username) return { error: 'Not logged in — cannot determine username' };
+
+        const limit = ${kwargs.limit};
+        const res = await fetch('/user/' + username + '/upvoted.json?limit=' + limit + '&raw_json=1', {
+          credentials: 'include'
+        });
+        const d = await res.json();
+        return (d?.data?.children || []).map(c => ({
+          title: c.data.title || '-',
+          subreddit: c.data.subreddit_name_prefixed || 'r/' + (c.data.subreddit || '?'),
+          score: c.data.score || 0,
+          comments: c.data.num_comments || 0,
+          url: 'https://www.reddit.com' + (c.data.permalink || ''),
+        }));
+      } catch (e) {
+        return { error: e.toString() };
+      }
+    })()`);
+
+    if (result?.error) throw new Error(result.error);
+    return (result || []).slice(0, kwargs.limit);
+  }
+});

package/src/clis/reddit/user-comments.yaml

@@ -0,0 +1,45 @@
+site: reddit
+name: user-comments
+description: View a Reddit user's comment history
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  username:
+    type: string
+    required: true
+  limit:
+    type: int
+    default: 15
+
+columns: [subreddit, score, body, url]
+
+pipeline:
+  - navigate: https://www.reddit.com
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const name = username.startsWith('u/') ? username.slice(2) : username;
+        const limit = ${{ args.limit }};
+        const res = await fetch('/user/' + name + '/comments.json?limit=' + limit + '&raw_json=1', {
+          credentials: 'include'
+        });
+        const d = await res.json();
+        return (d?.data?.children || []).map(c => {
+          let body = c.data.body || '';
+          if (body.length > 300) body = body.slice(0, 300) + '...';
+          return {
+            subreddit: c.data.subreddit_name_prefixed,
+            score: c.data.score,
+            body: body,
+            url: 'https://www.reddit.com' + c.data.permalink,
+          };
+        });
+      })()
+  - map:
+      subreddit: ${{ item.subreddit }}
+      score: ${{ item.score }}
+      body: ${{ item.body }}
+      url: ${{ item.url }}
+  - limit: ${{ args.limit }}

package/src/clis/reddit/user-posts.yaml

@@ -0,0 +1,43 @@
+site: reddit
+name: user-posts
+description: View a Reddit user's submitted posts
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  username:
+    type: string
+    required: true
+  limit:
+    type: int
+    default: 15
+
+columns: [title, subreddit, score, comments, url]
+
+pipeline:
+  - navigate: https://www.reddit.com
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const name = username.startsWith('u/') ? username.slice(2) : username;
+        const limit = ${{ args.limit }};
+        const res = await fetch('/user/' + name + '/submitted.json?limit=' + limit + '&raw_json=1', {
+          credentials: 'include'
+        });
+        const d = await res.json();
+        return (d?.data?.children || []).map(c => ({
+          title: c.data.title,
+          subreddit: c.data.subreddit_name_prefixed,
+          score: c.data.score,
+          comments: c.data.num_comments,
+          url: 'https://www.reddit.com' + c.data.permalink,
+        }));
+      })()
+  - map:
+      title: ${{ item.title }}
+      subreddit: ${{ item.subreddit }}
+      score: ${{ item.score }}
+      comments: ${{ item.comments }}
+      url: ${{ item.url }}
+  - limit: ${{ args.limit }}

package/src/clis/reddit/user.yaml

@@ -0,0 +1,39 @@
+site: reddit
+name: user
+description: View a Reddit user profile
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  username:
+    type: string
+    required: true
+
+columns: [field, value]
+
+pipeline:
+  - navigate: https://www.reddit.com
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const name = username.startsWith('u/') ? username.slice(2) : username;
+        const res = await fetch('/user/' + name + '/about.json?raw_json=1', {
+          credentials: 'include'
+        });
+        const d = await res.json();
+        const u = d?.data || d || {};
+        const created = u.created_utc ? new Date(u.created_utc * 1000).toISOString().split('T')[0] : '-';
+        return [
+          { field: 'Username', value: 'u/' + (u.name || name) },
+          { field: 'Post Karma', value: String(u.link_karma || 0) },
+          { field: 'Comment Karma', value: String(u.comment_karma || 0) },
+          { field: 'Total Karma', value: String(u.total_karma || (u.link_karma||0) + (u.comment_karma||0)) },
+          { field: 'Account Created', value: created },
+          { field: 'Gold', value: u.is_gold ? '⭐ Yes' : 'No' },
+          { field: 'Verified', value: u.verified ? '✅ Yes' : 'No' },
+        ];
+      })()
+  - map:
+      field: ${{ item.field }}
+      value: ${{ item.value }}

package/src/clis/twitter/article.ts

@@ -0,0 +1,161 @@
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'twitter',
+  name: 'article',
+  description: 'Fetch a Twitter Article (long-form content) and export as Markdown',
+  domain: 'x.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'tweet_id', type: 'string', positional: true, required: true, help: 'Tweet ID or URL containing the article' },
+  ],
+  columns: ['title', 'author', 'content', 'url'],
+  func: async (page, kwargs) => {
+    // Extract tweet ID from URL if needed
+    let tweetId = kwargs.tweet_id;
+    const urlMatch = tweetId.match(/\/(?:status|article)\/(\d+)/);
+    if (urlMatch) tweetId = urlMatch[1];
+
+    // Navigate to the tweet page for cookie context
+    await page.goto(`https://x.com/i/status/${tweetId}`);
+    await page.wait(3);
+
+    const result = await page.evaluate(`
+      async () => {
+        const tweetId = "${tweetId}";
+        const ct0 = document.cookie.split(';').map(c=>c.trim()).find(c=>c.startsWith('ct0='))?.split('=')[1];
+        if (!ct0) return {error: 'No ct0 cookie — not logged into x.com'};
+
+        const bearer = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+        const headers = {
+          'Authorization': 'Bearer ' + decodeURIComponent(bearer),
+          'X-Csrf-Token': ct0,
+          'X-Twitter-Auth-Type': 'OAuth2Session',
+          'X-Twitter-Active-User': 'yes'
+        };
+
+        const variables = JSON.stringify({
+          tweetId: tweetId,
+          withCommunity: false,
+          includePromotedContent: false,
+          withVoice: false,
+        });
+        const features = JSON.stringify({
+          longform_notetweets_consumption_enabled: true,
+          responsive_web_twitter_article_tweet_consumption_enabled: true,
+          longform_notetweets_rich_text_read_enabled: true,
+          longform_notetweets_inline_media_enabled: true,
+          articles_preview_enabled: true,
+          responsive_web_graphql_exclude_directive_enabled: true,
+          verified_phone_label_enabled: false,
+        });
+        const fieldToggles = JSON.stringify({
+          withArticleRichContentState: true,
+          withArticlePlainText: true,
+        });
+
+        // Dynamically resolve queryId: GitHub community source → JS bundle scan → hardcoded fallback
+        async function resolveQueryId(operationName, fallbackId) {
+          try {
+            const ghResp = await fetch('https://raw.githubusercontent.com/fa0311/twitter-openapi/refs/heads/main/src/config/placeholder.json');
+            if (ghResp.ok) {
+              const data = await ghResp.json();
+              const entry = data[operationName];
+              if (entry && entry.queryId) return entry.queryId;
+            }
+          } catch {}
+          try {
+            const scripts = performance.getEntriesByType('resource')
+              .filter(r => r.name.includes('client-web') && r.name.endsWith('.js'))
+              .map(r => r.name);
+            for (const scriptUrl of scripts.slice(0, 15)) {
+              try {
+                const text = await (await fetch(scriptUrl)).text();
+                const re = new RegExp('queryId:"([A-Za-z0-9_-]+)"[^}]{0,200}operationName:"' + operationName + '"');
+                const m = text.match(re);
+                if (m) return m[1];
+              } catch {}
+            }
+          } catch {}
+          return fallbackId;
+        }
+
+        const queryId = await resolveQueryId('TweetResultByRestId', '7xflPyRiUxGVbJd4uWmbfg');
+        const url = '/i/api/graphql/' + queryId + '/TweetResultByRestId?variables='
+          + encodeURIComponent(variables)
+          + '&features=' + encodeURIComponent(features)
+          + '&fieldToggles=' + encodeURIComponent(fieldToggles);
+
+        const resp = await fetch(url, {headers, credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status, hint: 'Tweet may not exist or queryId expired'};
+        const d = await resp.json();
+
+        const result = d.data?.tweetResult?.result;
+        if (!result) return {error: 'Article not found'};
+
+        // Unwrap TweetWithVisibilityResults
+        const tw = result.tweet || result;
+        const legacy = tw.legacy || {};
+        const user = tw.core?.user_results?.result;
+        const screenName = user?.legacy?.screen_name || user?.core?.screen_name || 'unknown';
+
+        // Extract article content
+        const articleResults = tw.article?.article_results?.result;
+        if (!articleResults) {
+          // Fallback: return note_tweet text if present
+          const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
+          if (noteText) {
+            return [{
+              title: '(Note Tweet)',
+              author: screenName,
+              content: noteText,
+              url: 'https://x.com/' + screenName + '/status/' + tweetId,
+            }];
+          }
+          return {error: 'Tweet ' + tweetId + ' has no article content'};
+        }
+
+        const title = articleResults.title || '(Untitled)';
+        const contentState = articleResults.content_state || {};
+        const blocks = contentState.blocks || [];
+
+        // Convert draft.js blocks to Markdown
+        const parts = [];
+        let orderedCounter = 0;
+        for (const block of blocks) {
+          const blockType = block.type || 'unstyled';
+          if (blockType === 'atomic') continue;
+          const text = block.text || '';
+          if (!text) continue;
+          if (blockType !== 'ordered-list-item') orderedCounter = 0;
+
+          if (blockType === 'header-one')           parts.push('# ' + text);
+          else if (blockType === 'header-two')      parts.push('## ' + text);
+          else if (blockType === 'header-three')    parts.push('### ' + text);
+          else if (blockType === 'blockquote')       parts.push('> ' + text);
+          else if (blockType === 'unordered-list-item') parts.push('- ' + text);
+          else if (blockType === 'ordered-list-item') {
+            orderedCounter++;
+            parts.push(orderedCounter + '. ' + text);
+          }
+          else if (blockType === 'code-block')       parts.push('\`\`\`\\n' + text + '\\n\`\`\`');
+          else                                       parts.push(text);
+        }
+
+        return [{
+          title,
+          author: screenName,
+          content: parts.join('\\n\\n') || legacy.full_text || '',
+          url: 'https://x.com/' + screenName + '/status/' + tweetId,
+        }];
+      }
+    `);
+
+    if (result?.error) {
+      throw new Error(result.error + (result.hint ? ` (${result.hint})` : ''));
+    }
+
+    return result || [];
+  }
+});

package/src/clis/twitter/bookmark.ts

@@ -0,0 +1,67 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'twitter',
+  name: 'bookmark',
+  description: 'Bookmark a tweet',
+  domain: 'x.com',
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'url', type: 'string', positional: true, required: true, help: 'Tweet URL to bookmark' },
+  ],
+  columns: ['status', 'message'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+
+    await page.goto(kwargs.url);
+    await page.wait(5);
+
+    const result = await page.evaluate(`(async () => {
+        try {
+            let attempts = 0;
+            let bookmarkBtn = null;
+            let removeBtn = null;
+
+            while (attempts < 20) {
+                // Check if already bookmarked
+                removeBtn = document.querySelector('[data-testid="removeBookmark"]');
+                if (removeBtn) {
+                    return { ok: true, message: 'Tweet is already bookmarked.' };
+                }
+
+                bookmarkBtn = document.querySelector('[data-testid="bookmark"]');
+                if (bookmarkBtn) break;
+
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            if (!bookmarkBtn) {
+                return { ok: false, message: 'Could not find Bookmark button. Are you logged in?' };
+            }
+
+            bookmarkBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Verify
+            const verify = document.querySelector('[data-testid="removeBookmark"]');
+            if (verify) {
+                return { ok: true, message: 'Tweet successfully bookmarked.' };
+            } else {
+                return { ok: false, message: 'Bookmark action initiated but UI did not update.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+
+    if (result.ok) await page.wait(2);
+
+    return [{
+      status: result.ok ? 'success' : 'failed',
+      message: result.message
+    }];
+  }
+});

package/src/clis/twitter/follow.ts

@@ -0,0 +1,69 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'twitter',
+  name: 'follow',
+  description: 'Follow a Twitter user',
+  domain: 'x.com',
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'username', type: 'string', positional: true, required: true, help: 'Twitter screen name (without @)' },
+  ],
+  columns: ['status', 'message'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+    const username = kwargs.username.replace(/^@/, '');
+
+    await page.goto(`https://x.com/${username}`);
+    await page.wait(5);
+
+    const result = await page.evaluate(`(async () => {
+        try {
+            let attempts = 0;
+            let followBtn = null;
+            let unfollowTestId = null;
+
+            while (attempts < 20) {
+                // Check if already following (button shows screen_name-unfollow)
+                unfollowTestId = document.querySelector('[data-testid$="-unfollow"]');
+                if (unfollowTestId) {
+                    return { ok: true, message: 'Already following @${username}.' };
+                }
+
+                // Look for the Follow button
+                followBtn = document.querySelector('[data-testid$="-follow"]');
+                if (followBtn) break;
+
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            if (!followBtn) {
+                return { ok: false, message: 'Could not find Follow button. Are you logged in?' };
+            }
+
+            followBtn.click();
+            await new Promise(r => setTimeout(r, 1500));
+
+            // Verify
+            const verify = document.querySelector('[data-testid$="-unfollow"]');
+            if (verify) {
+                return { ok: true, message: 'Successfully followed @${username}.' };
+            } else {
+                return { ok: false, message: 'Follow action initiated but UI did not update.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+
+    if (result.ok) await page.wait(2);
+
+    return [{
+      status: result.ok ? 'success' : 'failed',
+      message: result.message
+    }];
+  }
+});