@jackwener/opencli 0.6.3 → 0.7.0

package/dist/clis/twitter/unbookmark.js

@@ -0,0 +1,62 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'unbookmark',
+    description: 'Remove a tweet from bookmarks',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'url', type: 'string', positional: true, required: true, help: 'Tweet URL to unbookmark' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        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 removeBtn = null;
+
+            while (attempts < 20) {
+                // Check if not bookmarked
+                const bookmarkBtn = document.querySelector('[data-testid="bookmark"]');
+                if (bookmarkBtn) {
+                    return { ok: true, message: 'Tweet is not bookmarked (already removed).' };
+                }
+
+                removeBtn = document.querySelector('[data-testid="removeBookmark"]');
+                if (removeBtn) break;
+
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            if (!removeBtn) {
+                return { ok: false, message: 'Could not find Remove Bookmark button. Are you logged in?' };
+            }
+
+            removeBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Verify
+            const verify = document.querySelector('[data-testid="bookmark"]');
+            if (verify) {
+                return { ok: true, message: 'Tweet successfully removed from bookmarks.' };
+            } else {
+                return { ok: false, message: 'Unbookmark 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/dist/clis/twitter/unfollow.d.ts

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

package/dist/clis/twitter/unfollow.js

@@ -0,0 +1,71 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'unfollow',
+    description: 'Unfollow 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, kwargs) => {
+        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 unfollowBtn = null;
+
+            while (attempts < 20) {
+                // Check if already not following
+                const followBtn = document.querySelector('[data-testid$="-follow"]');
+                if (followBtn) {
+                    return { ok: true, message: 'Not following @${username} (already unfollowed).' };
+                }
+
+                unfollowBtn = document.querySelector('[data-testid$="-unfollow"]');
+                if (unfollowBtn) break;
+
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            if (!unfollowBtn) {
+                return { ok: false, message: 'Could not find Unfollow button. Are you logged in?' };
+            }
+
+            // Click the unfollow button — this opens a confirmation dialog
+            unfollowBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Confirm the unfollow in the dialog
+            const confirmBtn = document.querySelector('[data-testid="confirmationSheetConfirm"]');
+            if (confirmBtn) {
+                confirmBtn.click();
+                await new Promise(r => setTimeout(r, 1000));
+            }
+
+            // Verify
+            const verify = document.querySelector('[data-testid$="-follow"]');
+            if (verify) {
+                return { ok: true, message: 'Successfully unfollowed @${username}.' };
+            } else {
+                return { ok: false, message: 'Unfollow 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/dist/main.js

@@ -131,20 +131,43 @@ for (const [, cmd] of registry) {
         siteGroups.set(cmd.site, siteCmd);
     }
     const subCmd = siteCmd.command(cmd.name).description(cmd.description);
+    // Register positional args first, then named options
+    const positionalArgs = [];
     for (const arg of cmd.args) {
-        const flag = arg.required ? `--${arg.name} <value>` : `--${arg.name} [value]`;
-        if (arg.required)
-            subCmd.requiredOption(flag, arg.help ?? '');
-        else if (arg.default != null)
-            subCmd.option(flag, arg.help ?? '', String(arg.default));
-        else
-            subCmd.option(flag, arg.help ?? '');
+        if (arg.positional) {
+            const bracket = arg.required ? `<${arg.name}>` : `[${arg.name}]`;
+            subCmd.argument(bracket, arg.help ?? '');
+            positionalArgs.push(arg);
+        }
+        else {
+            const flag = arg.required ? `--${arg.name} <value>` : `--${arg.name} [value]`;
+            if (arg.required)
+                subCmd.requiredOption(flag, arg.help ?? '');
+            else if (arg.default != null)
+                subCmd.option(flag, arg.help ?? '', String(arg.default));
+            else
+                subCmd.option(flag, arg.help ?? '');
+        }
     }
     subCmd.option('-f, --format <fmt>', 'Output format: table, json, yaml, md, csv', 'table').option('-v, --verbose', 'Debug output', false);
-    subCmd.action(async (actionOpts) => {
+    subCmd.action(async (...actionArgs) => {
+        // Commander passes positional args first, then options object, then the Command
+        const actionOpts = actionArgs[positionalArgs.length] ?? {};
         const startTime = Date.now();
         const kwargs = {};
+        // Collect positional args
+        for (let i = 0; i < positionalArgs.length; i++) {
+            const arg = positionalArgs[i];
+            const v = actionArgs[i];
+            if (v !== undefined)
+                kwargs[arg.name] = coerce(v, arg.type ?? 'str');
+            else if (arg.default != null)
+                kwargs[arg.name] = arg.default;
+        }
+        // Collect named options
         for (const arg of cmd.args) {
+            if (arg.positional)
+                continue;
             const v = actionOpts[arg.name];
             if (v !== undefined)
                 kwargs[arg.name] = coerce(v, arg.type ?? 'str');

package/dist/registry.d.ts

@@ -14,6 +14,7 @@ export interface Arg {
     type?: string;
     default?: any;
     required?: boolean;
+    positional?: boolean;
     help?: string;
     choices?: string[];
 }

package/package.json

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

package/src/build-manifest.ts

@@ -30,6 +30,7 @@ interface ManifestEntry {
     type?: string;
     default?: any;
     required?: boolean;
+    positional?: boolean;
     help?: string;
     choices?: string[];
   }>;
@@ -140,6 +141,7 @@ function scanTs(filePath: string, site: string): ManifestEntry {
         const defaultMatch = body.match(/default\s*:\s*([^,}]+)/);
         const requiredMatch = body.match(/required\s*:\s*(true|false)/);
         const helpMatch = body.match(/help\s*:\s*['"`]([^'"`]*)['"`]/);
+        const positionalMatch = body.match(/positional\s*:\s*(true|false)/);
 
         let defaultVal: any = undefined;
         if (defaultMatch) {
@@ -156,6 +158,7 @@ function scanTs(filePath: string, site: string): ManifestEntry {
           type: typeMatch?.[1] ?? 'str',
           default: defaultVal,
           required: requiredMatch?.[1] === 'true',
+          positional: positionalMatch?.[1] === 'true' || undefined,
           help: helpMatch?.[1] ?? '',
         });
       }

package/src/clis/reddit/comment.ts

@@ -0,0 +1,60 @@
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'reddit',
+  name: 'comment',
+  description: 'Post a comment on 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: 'text', type: 'string', required: true, help: 'Comment text' },
+  ],
+  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)};
+        const urlMatch = postId.match(/comments\\/([a-z0-9]+)/);
+        if (urlMatch) postId = urlMatch[1];
+        const fullname = postId.startsWith('t3_') || postId.startsWith('t1_')
+          ? postId : 't3_' + postId;
+
+        const text = ${JSON.stringify(kwargs.text)};
+
+        // Get modhash
+        const meRes = await fetch('/api/me.json', { credentials: 'include' });
+        const me = await meRes.json();
+        const modhash = me?.data?.modhash || '';
+
+        const res = await fetch('/api/comment', {
+          method: 'POST',
+          credentials: 'include',
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+          body: 'parent=' + encodeURIComponent(fullname)
+            + '&text=' + encodeURIComponent(text)
+            + '&api_type=json'
+            + (modhash ? '&uh=' + encodeURIComponent(modhash) : ''),
+        });
+
+        if (!res.ok) return { ok: false, message: 'HTTP ' + res.status };
+        const data = await res.json();
+        const errors = data?.json?.errors;
+        if (errors && errors.length > 0) {
+          return { ok: false, message: errors.map(e => e.join(': ')).join('; ') };
+        }
+        return { ok: true, message: 'Comment posted on ' + fullname };
+      } catch (e) {
+        return { ok: false, message: e.toString() };
+      }
+    })()`);
+
+    return [{ status: result.ok ? 'success' : 'failed', message: result.message }];
+  }
+});

package/src/clis/reddit/popular.yaml

@@ -0,0 +1,40 @@
+site: reddit
+name: popular
+description: Reddit Popular posts (/r/popular)
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 20
+
+columns: [rank, title, subreddit, score, comments, url]
+
+pipeline:
+  - navigate: https://www.reddit.com
+  - evaluate: |
+      (async () => {
+        const limit = ${{ args.limit }};
+        const res = await fetch('/r/popular.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,
+          author: c.data.author,
+          url: 'https://www.reddit.com' + c.data.permalink,
+        }));
+      })()
+  - map:
+      rank: ${{ index + 1 }}
+      title: ${{ item.title }}
+      subreddit: ${{ item.subreddit }}
+      score: ${{ item.score }}
+      comments: ${{ item.comments }}
+      url: ${{ item.url }}
+  - limit: ${{ args.limit }}

package/src/clis/reddit/read.yaml

@@ -0,0 +1,76 @@
+site: reddit
+name: read
+description: Read a Reddit post and its comments
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  post_id:
+    type: string
+    required: true
+    description: "Post ID (e.g. 1abc123) or full URL"
+  sort:
+    type: string
+    default: best
+    description: "Comment sort: best, top, new, controversial, old, qa"
+  limit:
+    type: int
+    default: 25
+    description: Number of top-level comments to fetch
+
+columns: [type, author, score, text]
+
+pipeline:
+  - navigate: https://www.reddit.com
+  - evaluate: |
+      (async () => {
+        let postId = ${{ args.post_id | json }};
+        const urlMatch = postId.match(/comments\/([a-z0-9]+)/);
+        if (urlMatch) postId = urlMatch[1];
+
+        const sort = ${{ args.sort | json }};
+        const limit = ${{ args.limit }};
+        const res = await fetch('/comments/' + postId + '.json?sort=' + sort + '&limit=' + limit + '&raw_json=1', {
+          credentials: 'include'
+        });
+        const data = await res.json();
+        if (!Array.isArray(data) || data.length < 1) return [];
+
+        const results = [];
+
+        // First element: post itself
+        const post = data[0]?.data?.children?.[0]?.data;
+        if (post) {
+          let body = post.selftext || '';
+          if (body.length > 2000) body = body.slice(0, 2000) + '\n... [truncated]';
+          results.push({
+            type: '📰 POST',
+            author: post.author,
+            score: post.score,
+            text: post.title + (body ? '\n\n' + body : '') + (post.url && !post.is_self ? '\n🔗 ' + post.url : ''),
+          });
+        }
+
+        // Second element: comments
+        const comments = data[1]?.data?.children || [];
+        for (const c of comments) {
+          if (c.kind !== 't1') continue;
+          const d = c.data;
+          let body = d.body || '';
+          if (body.length > 500) body = body.slice(0, 500) + '...';
+          results.push({
+            type: '💬 COMMENT',
+            author: d.author || '[deleted]',
+            score: d.score || 0,
+            text: body,
+          });
+        }
+
+        return results;
+      })()
+  - map:
+      type: ${{ item.type }}
+      author: ${{ item.author }}
+      score: ${{ item.score }}
+      text: ${{ item.text }}

package/src/clis/reddit/save.ts

@@ -0,0 +1,54 @@
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'reddit',
+  name: 'save',
+  description: 'Save or unsave 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: 'undo', type: 'boolean', default: false, help: 'Unsave instead of save' },
+  ],
+  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)};
+        const urlMatch = postId.match(/comments\\/([a-z0-9]+)/);
+        if (urlMatch) postId = urlMatch[1];
+        const fullname = postId.startsWith('t3_') || postId.startsWith('t1_')
+          ? postId : 't3_' + postId;
+
+        const undo = ${kwargs.undo ? 'true' : 'false'};
+        const endpoint = undo ? '/api/unsave' : '/api/save';
+
+        // Get modhash
+        const meRes = await fetch('/api/me.json', { credentials: 'include' });
+        const me = await meRes.json();
+        const modhash = me?.data?.modhash || '';
+
+        const res = await fetch(endpoint, {
+          method: 'POST',
+          credentials: 'include',
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+          body: 'id=' + encodeURIComponent(fullname)
+            + (modhash ? '&uh=' + encodeURIComponent(modhash) : ''),
+        });
+
+        if (!res.ok) return { ok: false, message: 'HTTP ' + res.status };
+        return { ok: true, message: (undo ? 'Unsaved' : 'Saved') + ' ' + fullname };
+      } catch (e) {
+        return { ok: false, message: e.toString() };
+      }
+    })()`);
+
+    return [{ status: result.ok ? 'success' : 'failed', message: result.message }];
+  }
+});

package/src/clis/reddit/saved.ts

@@ -0,0 +1,48 @@
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'reddit',
+  name: 'saved',
+  description: 'Browse your saved 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 + '/saved.json?limit=' + limit + '&raw_json=1', {
+          credentials: 'include'
+        });
+        const d = await res.json();
+        return (d?.data?.children || []).map(c => ({
+          title: c.data.title || c.data.body?.slice(0, 100) || '-',
+          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/search.yaml

@@ -9,26 +9,52 @@ args:
   query:
     type: string
     required: true
+  subreddit:
+    type: string
+    default: ""
+    description: "Search within a specific subreddit"
+  sort:
+    type: string
+    default: relevance
+    description: "Sort order: relevance, hot, top, new, comments"
+  time:
+    type: string
+    default: all
+    description: "Time filter: hour, day, week, month, year, all"
   limit:
     type: int
     default: 15
 
-columns: [title, subreddit, author, upvotes, comments, url]
+columns: [title, subreddit, author, score, comments, url]
 
 pipeline:
   - navigate: https://www.reddit.com
   - evaluate: |
       (async () => {
-        const q = encodeURIComponent('${{ args.query }}');
-        const res = await fetch('/search.json?q=' + q + '&limit=${{ args.limit }}', { credentials: 'include' });
-        const j = await res.json();
-        return j?.data?.children || [];
+        const q = encodeURIComponent(${{ args.query | json }});
+        const sub = ${{ args.subreddit | json }};
+        const sort = ${{ args.sort | json }};
+        const time = ${{ args.time | json }};
+        const limit = ${{ args.limit }};
+        const basePath = sub ? '/r/' + sub + '/search.json' : '/search.json';
+        const params = 'q=' + q + '&sort=' + sort + '&t=' + time + '&limit=' + limit
+          + '&restrict_sr=' + (sub ? 'on' : 'off') + '&raw_json=1';
+        const res = await fetch(basePath + '?' + params, { credentials: 'include' });
+        const d = await res.json();
+        return (d?.data?.children || []).map(c => ({
+          title: c.data.title,
+          subreddit: c.data.subreddit_name_prefixed,
+          author: c.data.author,
+          score: c.data.score,
+          comments: c.data.num_comments,
+          url: 'https://www.reddit.com' + c.data.permalink,
+        }));
       })()
   - map:
-      title: ${{ item.data.title }}
-      subreddit: ${{ item.data.subreddit_name_prefixed }}
-      author: ${{ item.data.author }}
-      upvotes: ${{ item.data.score }}
-      comments: ${{ item.data.num_comments }}
-      url: https://www.reddit.com${{ item.data.permalink }}
+      title: ${{ item.title }}
+      subreddit: ${{ item.subreddit }}
+      author: ${{ item.author }}
+      score: ${{ item.score }}
+      comments: ${{ item.comments }}
+      url: ${{ item.url }}
   - limit: ${{ args.limit }}

package/src/clis/reddit/subreddit.yaml

@@ -12,7 +12,11 @@ args:
   sort:
     type: string
     default: hot
-    description: "Sorting method: hot, new, top, rising"
+    description: "Sorting method: hot, new, top, rising, controversial"
+  time:
+    type: string
+    default: all
+    description: "Time filter for top/controversial: hour, day, week, month, year, all"
   limit:
     type: int
     default: 15
@@ -23,10 +27,16 @@ pipeline:
   - navigate: https://www.reddit.com
   - evaluate: |
       (async () => {
-        let sub = '${{ args.name }}';
+        let sub = ${{ args.name | json }};
         if (sub.startsWith('r/')) sub = sub.slice(2);
-        const sort = '${{ args.sort }}';
-        const res = await fetch('/r/' + sub + '/' + sort + '.json?limit=${{ args.limit }}', { credentials: 'include' });
+        const sort = ${{ args.sort | json }};
+        const time = ${{ args.time | json }};
+        const limit = ${{ args.limit }};
+        let url = '/r/' + sub + '/' + sort + '.json?limit=' + limit + '&raw_json=1';
+        if ((sort === 'top' || sort === 'controversial') && time) {
+          url += '&t=' + time;
+        }
+        const res = await fetch(url, { credentials: 'include' });
         const j = await res.json();
         return j?.data?.children || [];
       })()

package/src/clis/reddit/subscribe.ts

@@ -0,0 +1,53 @@
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'reddit',
+  name: 'subscribe',
+  description: 'Subscribe or unsubscribe to a subreddit',
+  domain: 'reddit.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'subreddit', type: 'string', required: true, help: 'Subreddit name (e.g. python)' },
+    { name: 'undo', type: 'boolean', default: false, help: 'Unsubscribe instead of subscribe' },
+  ],
+  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 sub = ${JSON.stringify(kwargs.subreddit)};
+        if (sub.startsWith('r/')) sub = sub.slice(2);
+
+        const undo = ${kwargs.undo ? 'true' : 'false'};
+        const action = undo ? 'unsub' : 'sub';
+
+        // Get modhash
+        const meRes = await fetch('/api/me.json', { credentials: 'include' });
+        const me = await meRes.json();
+        const modhash = me?.data?.modhash || '';
+
+        const res = await fetch('/api/subscribe', {
+          method: 'POST',
+          credentials: 'include',
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+          body: 'sr_name=' + encodeURIComponent(sub)
+            + '&action=' + action
+            + (modhash ? '&uh=' + encodeURIComponent(modhash) : ''),
+        });
+
+        if (!res.ok) return { ok: false, message: 'HTTP ' + res.status };
+        const label = undo ? 'Unsubscribed from' : 'Subscribed to';
+        return { ok: true, message: label + ' r/' + sub };
+      } catch (e) {
+        return { ok: false, message: e.toString() };
+      }
+    })()`);
+
+    return [{ status: result.ok ? 'success' : 'failed', message: result.message }];
+  }
+});