@jackwener/opencli 0.1.2 → 0.3.0

package/dist/engine.js

@@ -6,7 +6,8 @@ import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { Strategy, registerCommand } from './registry.js';
 import { executePipeline } from './pipeline.js';
-export function discoverClis(...dirs) {
+export async function discoverClis(...dirs) {
+    const promises = [];
     for (const dir of dirs) {
         if (!fs.existsSync(dir))
             continue;
@@ -19,9 +20,16 @@ export function discoverClis(...dirs) {
                 if (file.endsWith('.yaml') || file.endsWith('.yml')) {
                     registerYamlCli(filePath, site);
                 }
+                else if (file.endsWith('.js')) {
+                    // Dynamic import of compiled adapter modules
+                    promises.push(import(`file://${filePath}`).catch((err) => {
+                        process.stderr.write(`Warning: failed to load module ${filePath}: ${err.message}\n`);
+                    }));
+                }
             }
         }
     }
+    await Promise.all(promises);
 }
 function registerYamlCli(filePath, defaultSite) {
     try {

package/dist/main.d.ts

@@ -2,4 +2,4 @@
 /**
  * opencli — Make any website your CLI. AI-powered.
  */
-import './clis/index.js';
+export {};

package/dist/main.js

@@ -11,7 +11,6 @@ import chalk from 'chalk';
 import { discoverClis, executeCommand } from './engine.js';
 import { fullName, getRegistry, strategyLabel } from './registry.js';
 import { render as renderOutput } from './output.js';
-import './clis/index.js';
 import { PlaywrightMCP } from './browser.js';
 import { browserSession, DEFAULT_BROWSER_COMMAND_TIMEOUT, runWithTimeout } from './runtime.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -21,7 +20,7 @@ const USER_CLIS = path.join(os.homedir(), '.opencli', 'clis');
 // Read version from package.json (single source of truth)
 const pkgJsonPath = path.resolve(__dirname, '..', 'package.json');
 const PKG_VERSION = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8')).version ?? '0.0.0';
-discoverClis(BUILTIN_CLIS, USER_CLIS);
+await discoverClis(BUILTIN_CLIS, USER_CLIS);
 const program = new Command();
 program.name('opencli').description('Make any website your CLI. Zero setup. AI-powered.').version(PKG_VERSION);
 // ── Built-in commands ──────────────────────────────────────────────────────
@@ -116,10 +115,18 @@ for (const [, cmd] of registry) {
             else {
                 result = await executeCommand(cmd, null, kwargs, actionOpts.verbose);
             }
+            if (actionOpts.verbose && (!result || (Array.isArray(result) && result.length === 0))) {
+                console.error(chalk.yellow(`[Verbose] Warning: Command returned an empty result. If the website structural API changed or requires authentication, check the network or update the adapter.`));
+            }
             renderOutput(result, { fmt: actionOpts.format, columns: cmd.columns, title: `${cmd.site}/${cmd.name}`, elapsed: (Date.now() - startTime) / 1000, source: fullName(cmd) });
         }
         catch (err) {
-            console.error(chalk.red(`Error: ${err.message ?? err}`));
+            if (actionOpts.verbose && err.stack) {
+                console.error(chalk.red(err.stack));
+            }
+            else {
+                console.error(chalk.red(`Error: ${err.message ?? err}`));
+            }
             process.exitCode = 1;
         }
     });

package/dist/output.d.ts

@@ -1,5 +1,5 @@
 /**
- * Output formatting: table, JSON, Markdown, CSV.
+ * Output formatting: table, JSON, Markdown, CSV, YAML.
  */
 export interface RenderOptions {
     fmt?: string;

package/dist/output.js

@@ -1,8 +1,9 @@
 /**
- * Output formatting: table, JSON, Markdown, CSV.
+ * Output formatting: table, JSON, Markdown, CSV, YAML.
  */
 import chalk from 'chalk';
 import Table from 'cli-table3';
+import yaml from 'js-yaml';
 export function render(data, opts = {}) {
     const fmt = opts.fmt ?? 'table';
     if (data === null || data === undefined) {
@@ -20,6 +21,10 @@ export function render(data, opts = {}) {
         case 'csv':
             renderCsv(data, opts);
             break;
+        case 'yaml':
+        case 'yml':
+            renderYaml(data);
+            break;
         default:
             renderTable(data, opts);
             break;
@@ -32,19 +37,15 @@ function renderTable(data, opts) {
         return;
     }
     const columns = opts.columns ?? Object.keys(rows[0]);
-    const header = columns.map((c, i) => i === 0 ? '#' : capitalize(c));
+    const header = columns.map(c => capitalize(c));
     const table = new Table({
         head: header.map(h => chalk.bold(h)),
         style: { head: [], border: [] },
         wordWrap: true,
         wrapOnWordBoundary: true,
-        colWidths: columns.map((c, i) => {
+        colWidths: columns.map((_c, i) => {
             if (i === 0)
-                return 4;
-            if (c === 'url' || c === 'description')
-                return null;
-            if (c === 'title' || c === 'name' || c === 'repo')
-                return null;
+                return 6;
             return null;
         }).filter(() => true),
     });
@@ -93,6 +94,9 @@ function renderCsv(data, opts) {
         }).join(','));
     }
 }
+function renderYaml(data) {
+    console.log(yaml.dump(data, { sortKeys: false, lineWidth: 120, noRefs: true }));
+}
 function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }

package/dist/pipeline/steps/intercept.js

@@ -10,7 +10,54 @@ export async function stepIntercept(page, params, data, args) {
     const selectPath = cfg.select ?? null;
     if (!capturePattern)
         return data;
-    // Step 1: Execute the trigger action
+    // Step 1: Inject fetch/XHR interceptor BEFORE trigger
+    await page.evaluate(`
+    () => {
+      window.__opencli_intercepted = window.__opencli_intercepted || [];
+      const pattern = ${JSON.stringify(capturePattern)};
+      
+      if (!window.__opencli_fetch_patched) {
+        const origFetch = window.fetch;
+        window.fetch = async function(...args) {
+          const reqUrl = typeof args[0] === 'string' ? args[0] : (args[0] && args[0].url) || '';
+          const response = await origFetch.apply(this, args);
+          setTimeout(async () => {
+            try {
+              if (reqUrl.includes(pattern)) {
+                const clone = response.clone();
+                const json = await clone.json();
+                window.__opencli_intercepted.push(json);
+              }
+            } catch(e) {}
+          }, 0);
+          return response;
+        };
+        window.__opencli_fetch_patched = true;
+      }
+
+      if (!window.__opencli_xhr_patched) {
+        const XHR = XMLHttpRequest.prototype;
+        const open = XHR.open;
+        const send = XHR.send;
+        XHR.open = function(method, url, ...args) {
+          this._reqUrl = url;
+          return open.call(this, method, url, ...args);
+        };
+        XHR.send = function(...args) {
+          this.addEventListener('load', function() {
+            try {
+              if (this._reqUrl && this._reqUrl.includes(pattern)) {
+                window.__opencli_intercepted.push(JSON.parse(this.responseText));
+              }
+            } catch(e) {}
+          });
+          return send.apply(this, args);
+        };
+        window.__opencli_xhr_patched = true;
+      }
+    }
+  `);
+    // Step 2: Execute the trigger action
     if (trigger.startsWith('navigate:')) {
         const url = render(trigger.slice('navigate:'.length), { args, data });
         await page.goto(String(url));
@@ -27,36 +74,16 @@ export async function stepIntercept(page, params, data, args) {
     else if (trigger === 'scroll') {
         await page.scroll('down');
     }
-    // Step 2: Wait a bit for network requests to fire
+    // Step 3: Wait a bit for network requests to fire
     await page.wait(Math.min(timeout, 3));
-    // Step 3: Get network requests and find matching ones
-    const rawNetwork = await page.networkRequests(false);
-    const matchingResponses = [];
-    if (typeof rawNetwork === 'string') {
-        const lines = rawNetwork.split('\n');
-        for (const line of lines) {
-            const match = line.match(/\[?(GET|POST)\]?\s+(\S+)\s*(?:=>|→)\s*\[?(\d+)\]?/i);
-            if (match) {
-                const [, , url, status] = match;
-                if (url.includes(capturePattern) && status === '200') {
-                    try {
-                        const body = await page.evaluate(`
-              async () => {
-                try {
-                  const resp = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
-                  if (!resp.ok) return null;
-                  return await resp.json();
-                } catch { return null; }
-              }
-            `);
-                        if (body)
-                            matchingResponses.push(body);
-                    }
-                    catch { }
-                }
-            }
-        }
+    // Step 4: Retrieve captured data
+    const matchingResponses = await page.evaluate(`
+    () => {
+      const data = window.__opencli_intercepted || [];
+      window.__opencli_intercepted = []; // clear after reading
+      return data;
     }
+  `);
     // Step 4: Select from response if specified
     let result = matchingResponses.length === 1 ? matchingResponses[0] :
         matchingResponses.length > 1 ? matchingResponses : data;

package/dist/pipeline/template.js

@@ -4,9 +4,19 @@
 export function render(template, ctx) {
     if (typeof template !== 'string')
         return template;
-    const fullMatch = template.match(/^\$\{\{\s*(.*?)\s*\}\}$/);
-    if (fullMatch)
+    // Full expression: entire string is a single ${{ ... }}
+    // Use [^}] to prevent matching across }} boundaries (e.g. "${{ a }}-${{ b }}")
+    const fullMatch = template.match(/^\$\{\{\s*([^}]*(?:\}[^}][^}]*)*)\s*\}\}$/);
+    if (fullMatch && !template.includes('}}-') && !template.includes('}}${{'))
         return evalExpr(fullMatch[1].trim(), ctx);
+    // Check if the entire string is a single expression (no other text around it)
+    const singleExpr = template.match(/^\$\{\{\s*([\s\S]*?)\s*\}\}$/);
+    if (singleExpr) {
+        // Verify it's truly a single expression (no other ${{ inside)
+        const inner = singleExpr[1];
+        if (!inner.includes('${{'))
+            return evalExpr(inner.trim(), ctx);
+    }
     return template.replace(/\$\{\{\s*(.*?)\s*\}\}/g, (_m, expr) => String(evalExpr(expr.trim(), ctx)));
 }
 export function evalExpr(expr, ctx) {
@@ -14,19 +24,14 @@ export function evalExpr(expr, ctx) {
     const item = ctx.item ?? {};
     const data = ctx.data;
     const index = ctx.index ?? 0;
-    // Default filter: args.limit | default(20)
-    if (expr.includes('|') && expr.includes('default(')) {
-        const [mainExpr, rest] = expr.split('|', 2);
-        const defaultMatch = rest.match(/default\((.+?)\)/);
-        const defaultVal = defaultMatch ? defaultMatch[1] : null;
-        const result = resolvePath(mainExpr.trim(), { args, item, data, index });
-        if (result === null || result === undefined) {
-            if (defaultVal !== null) {
-                const intVal = parseInt(defaultVal, 10);
-                if (!isNaN(intVal) && String(intVal) === defaultVal.trim())
-                    return intVal;
-                return defaultVal.replace(/^['"]|['"]$/g, '');
-            }
+    // ── Pipe filters: expr | filter1(arg) | filter2 ──
+    // Supports: default(val), join(sep), upper, lower, truncate(n), trim, replace(old,new)
+    if (expr.includes('|') && !expr.includes('||')) {
+        const segments = expr.split('|').map(s => s.trim());
+        const mainExpr = segments[0];
+        let result = resolvePath(mainExpr, { args, item, data, index });
+        for (let i = 1; i < segments.length; i++) {
+            result = applyFilter(segments[i], result);
         }
         return result;
     }
@@ -59,6 +64,60 @@ export function evalExpr(expr, ctx) {
     }
     return resolvePath(expr, { args, item, data, index });
 }
+/**
+ * Apply a named filter to a value.
+ * Supported filters:
+ *   default(val), join(sep), upper, lower, truncate(n), trim,
+ *   replace(old,new), keys, length, first, last, json
+ */
+function applyFilter(filterExpr, value) {
+    const match = filterExpr.match(/^(\w+)(?:\((.+)\))?$/);
+    if (!match)
+        return value;
+    const [, name, rawArgs] = match;
+    const filterArg = rawArgs?.replace(/^['"]|['"]$/g, '') ?? '';
+    switch (name) {
+        case 'default': {
+            if (value === null || value === undefined || value === '') {
+                const intVal = parseInt(filterArg, 10);
+                if (!isNaN(intVal) && String(intVal) === filterArg.trim())
+                    return intVal;
+                return filterArg;
+            }
+            return value;
+        }
+        case 'join':
+            return Array.isArray(value) ? value.join(filterArg || ', ') : value;
+        case 'upper':
+            return typeof value === 'string' ? value.toUpperCase() : value;
+        case 'lower':
+            return typeof value === 'string' ? value.toLowerCase() : value;
+        case 'trim':
+            return typeof value === 'string' ? value.trim() : value;
+        case 'truncate': {
+            const n = parseInt(filterArg, 10) || 50;
+            return typeof value === 'string' && value.length > n ? value.slice(0, n) + '...' : value;
+        }
+        case 'replace': {
+            if (typeof value !== 'string')
+                return value;
+            const parts = rawArgs?.split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')) ?? [];
+            return parts.length >= 2 ? value.replaceAll(parts[0], parts[1]) : value;
+        }
+        case 'keys':
+            return value && typeof value === 'object' ? Object.keys(value) : value;
+        case 'length':
+            return Array.isArray(value) ? value.length : typeof value === 'string' ? value.length : value;
+        case 'first':
+            return Array.isArray(value) ? value[0] : value;
+        case 'last':
+            return Array.isArray(value) ? value[value.length - 1] : value;
+        case 'json':
+            return JSON.stringify(value ?? null);
+        default:
+            return value;
+    }
+}
 export function resolvePath(pathStr, ctx) {
     const args = ctx.args ?? {};
     const item = ctx.item ?? {};

package/dist/pipeline/template.test.js

@@ -54,6 +54,30 @@ describe('evalExpr', () => {
     it('resolves simple path', () => {
         expect(evalExpr('item.title', { item: { title: 'Test' } })).toBe('Test');
     });
+    it('applies join filter', () => {
+        expect(evalExpr('item.tags | join(,)', { item: { tags: ['a', 'b', 'c'] } })).toBe('a,b,c');
+    });
+    it('applies upper filter', () => {
+        expect(evalExpr('item.name | upper', { item: { name: 'hello' } })).toBe('HELLO');
+    });
+    it('applies lower filter', () => {
+        expect(evalExpr('item.name | lower', { item: { name: 'HELLO' } })).toBe('hello');
+    });
+    it('applies truncate filter', () => {
+        expect(evalExpr('item.text | truncate(5)', { item: { text: 'Hello World!' } })).toBe('Hello...');
+    });
+    it('chains filters', () => {
+        expect(evalExpr('item.name | upper | truncate(3)', { item: { name: 'hello' } })).toBe('HEL...');
+    });
+    it('applies length filter', () => {
+        expect(evalExpr('item.items | length', { item: { items: [1, 2, 3] } })).toBe(3);
+    });
+    it('applies json filter to strings with quotes', () => {
+        expect(evalExpr('args.keyword | json', { args: { keyword: "O'Reilly" } })).toBe('"O\'Reilly"');
+    });
+    it('applies json filter to nullish values', () => {
+        expect(evalExpr('args.keyword | json', { args: {} })).toBe('null');
+    });
 });
 describe('render', () => {
     it('renders full expression', () => {

package/dist/types.d.ts

@@ -24,4 +24,10 @@ export interface IPage {
     networkRequests(includeStatic?: boolean): Promise<any>;
     consoleMessages(level?: string): Promise<any>;
     scroll(direction?: string, amount?: number): Promise<void>;
+    autoScroll(options?: {
+        times?: number;
+        delayMs?: number;
+    }): Promise<void>;
+    installInterceptor(pattern: string): Promise<void>;
+    getInterceptedRequests(): Promise<any[]>;
 }

package/package.json

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

package/src/browser.ts

@@ -67,7 +67,22 @@ export class Page implements IPage {
   }
 
   async evaluate(js: string): Promise<any> {
-    return this.call('tools/call', { name: 'browser_evaluate', arguments: { function: js } });
+    // Normalize IIFE format to function format expected by MCP browser_evaluate
+    const normalized = this.normalizeEval(js);
+    return this.call('tools/call', { name: 'browser_evaluate', arguments: { function: normalized } });
+  }
+
+  private normalizeEval(source: string): string {
+    const s = source.trim();
+    if (!s) return '() => undefined';
+    // IIFE: (async () => {...})()  →  wrap as () => (...)
+    if (s.startsWith('(') && s.endsWith(')()')) return `() => (${s})`;
+    // Already a function/arrow
+    if (/^(async\s+)?\([^)]*\)\s*=>/.test(s)) return s;
+    if (/^(async\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=>/.test(s)) return s;
+    if (s.startsWith('function ') || s.startsWith('async function ')) return s;
+    // Raw expression → wrap
+    return `() => (${s})`;
   }
 
   async snapshot(opts: { interactive?: boolean; compact?: boolean; maxDepth?: number; raw?: boolean } = {}): Promise<any> {
@@ -120,6 +135,69 @@ export class Page implements IPage {
   async scroll(direction: string = 'down', amount: number = 500): Promise<void> {
     await this.call('tools/call', { name: 'browser_press_key', arguments: { key: direction === 'down' ? 'PageDown' : 'PageUp' } });
   }
+
+  async autoScroll(options: { times?: number; delayMs?: number } = {}): Promise<void> {
+    const times = options.times ?? 3;
+    const delayMs = options.delayMs ?? 2000;
+    for (let i = 0; i < times; i++) {
+        await this.evaluate('() => window.scrollTo(0, document.body.scrollHeight)');
+        await this.wait(delayMs / 1000);
+    }
+  }
+
+  async installInterceptor(pattern: string): Promise<void> {
+    const js = `
+      () => {
+        window.__opencli_xhr = window.__opencli_xhr || [];
+        window.__opencli_patterns = window.__opencli_patterns || [];
+        if (!window.__opencli_patterns.includes('${pattern}')) {
+          window.__opencli_patterns.push('${pattern}');
+        }
+        
+        if (!window.__patched_xhr) {
+          const checkMatch = (url) => window.__opencli_patterns.some(p => url.includes(p));
+
+          const XHR = XMLHttpRequest.prototype;
+          const open = XHR.open;
+          const send = XHR.send;
+          XHR.open = function(method, url) {
+            this._url = url;
+            return open.call(this, method, url, ...Array.prototype.slice.call(arguments, 2));
+          };
+          XHR.send = function() {
+            this.addEventListener('load', function() {
+              if (checkMatch(this._url)) {
+                try { window.__opencli_xhr.push({url: this._url, data: JSON.parse(this.responseText)}); } catch(e){}
+              }
+            });
+            return send.apply(this, arguments);
+          };
+
+          const origFetch = window.fetch;
+          window.fetch = async function(...args) {
+            let u = typeof args[0] === 'string' ? args[0] : (args[0] && args[0].url) || '';
+            const res = await origFetch.apply(this, args);
+            setTimeout(async () => {
+              try {
+                if (checkMatch(u)) {
+                  const clone = res.clone();
+                  const j = await clone.json();
+                  window.__opencli_xhr.push({url: u, data: j});
+                }
+              } catch(e) {}
+            }, 0);
+            return res;
+          };
+          window.__patched_xhr = true;
+        }
+      }
+    `;
+    await this.evaluate(js);
+  }
+
+  async getInterceptedRequests(): Promise<any[]> {
+    return (await this.evaluate('() => window.__opencli_xhr')) || [];
+  }
 }
 
 /**
@@ -143,10 +221,15 @@ export class PlaywrightMCP {
     return new Promise<Page>((resolve, reject) => {
       const timer = setTimeout(() => reject(new Error(`Timed out connecting to browser (${timeout}s)`)), timeout * 1000);
 
-      this._proc = spawn('node', [mcpPath, '--extension'], {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env, ...(process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN ? { PLAYWRIGHT_MCP_EXTENSION_TOKEN: process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN } : {}) },
-      });
+      const mcpArgs = [mcpPath, '--extension'];
+    if (process.env.OPENCLI_BROWSER_EXECUTABLE_PATH) {
+      mcpArgs.push('--executablePath', process.env.OPENCLI_BROWSER_EXECUTABLE_PATH);
+    }
+
+    this._proc = spawn('node', mcpArgs, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, ...(process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN ? { PLAYWRIGHT_MCP_EXTENSION_TOKEN: process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN } : {}) },
+    });
 
       // Increase max listeners to avoid warnings
       this._proc.setMaxListeners(20);

package/src/clis/bilibili/dynamic.ts

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet } from '../../bilibili.js';
+
+cli({
+  site: 'bilibili',
+  name: 'dynamic',
+  description: 'Get Bilibili user dynamic feed',
+  domain: 'www.bilibili.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 15 },
+  ],
+  columns: ['id', 'author', 'text', 'likes', 'url'],
+  func: async (page, kwargs) => {
+    const payload = await apiGet(page, '/x/polymer/web-dynamic/v1/feed/all', { params: {}, signed: false });
+    const results: any[] = payload?.data?.items ?? [];
+    return results.slice(0, Number(kwargs.limit)).map((item: any) => {
+      let text = '';
+      if (item.modules?.module_dynamic?.desc?.text) {
+          text = item.modules.module_dynamic.desc.text;
+      } else if (item.modules?.module_dynamic?.major?.archive?.title) {
+          text = item.modules.module_dynamic.major.archive.title;
+      }
+
+      return {
+        id: item.id_str ?? '',
+        author: item.modules?.module_author?.name ?? '',
+        text: text,
+        likes: item.modules?.module_stat?.like?.count ?? 0,
+        url: item.id_str ? `https://t.bilibili.com/${item.id_str}` : ''
+      };
+    });
+  },
+});

package/src/clis/bilibili/ranking.ts

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet } from '../../bilibili.js';
+
+cli({
+  site: 'bilibili',
+  name: 'ranking',
+  description: 'Get Bilibili video ranking board',
+  domain: 'www.bilibili.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 20 },
+  ],
+  columns: ['rank', 'title', 'author', 'score', 'url'],
+  func: async (page, kwargs) => {
+    const payload = await apiGet(page, '/x/web-interface/ranking/v2', { params: { rid: 0, type: 'all' }, signed: false });
+    const results: any[] = payload?.data?.list ?? [];
+    return results.slice(0, Number(kwargs.limit)).map((item: any, i: number) => ({
+      rank: i + 1,
+      title: item.title ?? '',
+      author: item.owner?.name ?? '',
+      score: item.stat?.view ?? 0,
+      url: item.bvid ? `https://www.bilibili.com/video/${item.bvid}` : ''
+    }));
+  },
+});

package/src/clis/reddit/frontpage.yaml

@@ -0,0 +1,30 @@
+site: reddit
+name: frontpage
+description: Reddit Frontpage / r/all
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 15
+
+columns: [title, subreddit, author, upvotes, comments, url]
+
+pipeline:
+  - navigate: https://www.reddit.com
+  - evaluate: |
+      (async () => {
+        const res = await fetch('/r/all.json?limit=${{ args.limit }}', { credentials: 'include' });
+        const j = await res.json();
+        return j?.data?.children || [];
+      })()
+  - 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 }}
+  - limit: ${{ args.limit }}

package/src/clis/reddit/hot.yaml

@@ -18,9 +18,10 @@ pipeline:
 
   - evaluate: |
       (async () => {
-        const sub = '${{ args.subreddit }}';
+        const sub = ${{ args.subreddit | json }};
         const path = sub ? '/r/' + sub + '/hot.json' : '/hot.json';
-        const res = await fetch(path + '?limit=${{ args.limit }}&raw_json=1', {
+        const limit = ${{ args.limit }};
+        const res = await fetch(path + '?limit=' + limit + '&raw_json=1', {
           credentials: 'include'
         });
         const d = await res.json();

package/src/clis/reddit/search.yaml

@@ -0,0 +1,34 @@
+site: reddit
+name: search
+description: Search Reddit Posts
+domain: reddit.com
+strategy: cookie
+browser: true
+
+args:
+  query:
+    type: string
+    required: true
+  limit:
+    type: int
+    default: 15
+
+columns: [title, subreddit, author, upvotes, 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 || [];
+      })()
+  - 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 }}
+  - limit: ${{ args.limit }}