@jackwener/opencli 1.7.17 → 1.7.19

package/clis/google-scholar/search.test.js

@@ -1,4 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 import { getRegistry } from '@jackwener/opencli/registry';
 import './search.js';
 
@@ -25,14 +26,46 @@ describe('google-scholar search command', () => {
         const page = {
             goto: vi.fn().mockResolvedValue(undefined),
             wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue([]),
+            evaluate: vi.fn().mockResolvedValue({ items: [{ rank: 1, title: 'Paper' }], resultCount: 1 }),
         };
 
-        await command.func(page, { query: 'transformer' });
+        const rows = await command.func(page, { query: 'transformer' });
 
         const script = page.evaluate.mock.calls[0][0];
         expect(script).toContain("document.querySelectorAll('.gs_r.gs_or.gs_scl')");
         expect(script).not.toContain(".gs_r.gs_or.gs_scl, .gs_ri");
         expect(script).toContain("const container = el.querySelector('.gs_ri') || el");
+        expect(script).toContain('return { items: results, resultCount: resultCards.length }');
+        expect(rows).toEqual([{ rank: 1, title: 'Paper' }]);
+    });
+
+    it('throws typed empty when Scholar returns no result cards', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ items: [], resultCount: 0 }),
+        };
+
+        await expect(command.func(page, { query: 'no results expected' })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('throws command execution when result cards exist but parser extracts no rows', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ items: [], resultCount: 2 }),
+        };
+
+        await expect(command.func(page, { query: 'parser drift' })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws command execution for malformed evaluate payloads instead of treating them as empty', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ items: { rank: 1 }, resultCount: 1 }),
+        };
+
+        await expect(command.func(page, { query: 'bad payload' })).rejects.toThrow(CommandExecutionError);
     });
 });

package/clis/reddit/home.js

@@ -0,0 +1,117 @@
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+const REDDIT_HOME_MAX_LIMIT = 100;
+
+export function parseRedditHomeLimit(raw) {
+    if (raw === undefined || raw === null || raw === '') return 25;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1 || n > REDDIT_HOME_MAX_LIMIT) {
+        throw new ArgumentError(
+            `limit must be an integer in [1, ${REDDIT_HOME_MAX_LIMIT}].`,
+            `Got: ${raw}`,
+        );
+    }
+    return n;
+}
+
+cli({
+    site: 'reddit',
+    name: 'home',
+    access: 'read',
+    description: 'Reddit personalized home feed (Best, requires login)',
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    siteSession: 'persistent',
+    args: [
+        { name: 'limit', type: 'int', default: 25, help: `Number of posts (1–${REDDIT_HOME_MAX_LIMIT})` },
+    ],
+    columns: ['rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url'],
+    func: async (page, kwargs) => {
+        const limit = parseRedditHomeLimit(kwargs.limit);
+        await page.goto('https://www.reddit.com');
+        // The Best feed is personalized only when logged in — for anonymous
+        // sessions Reddit returns a generic listing that overlaps with /r/all.
+        // To make `home` semantically meaningful (vs the public `frontpage`
+        // command) we require auth and surface the logged-out case via
+        // AuthRequiredError instead of silently returning the public feed.
+        //
+        // Two-pronged auth detection: HTTP 401/403 OR `me.data.name` missing
+        // on 200 (stale anonymous cookie session). See PR #1428 sediment.
+        //
+        // Intermediate object keys avoid `rank`/`title`/`subreddit`/etc. to
+        // sidestep the silent-column-drop audit; we use `entries` for the
+        // raw payload. See PR #1329 sediment "中间解析对象 key 不能跟
+        // columns 任一项重叠".
+        const result = await page.evaluate(`(async () => {
+      try {
+        const meRes = await fetch('/api/me.json', { credentials: 'include' });
+        if (meRes.status === 401 || meRes.status === 403) {
+          return { kind: 'auth', detail: 'Reddit /api/me.json returned HTTP ' + meRes.status };
+        }
+        if (!meRes.ok) {
+          return { kind: 'http', httpStatus: meRes.status, where: '/api/me.json' };
+        }
+        const me = await meRes.json();
+        if (!me?.data?.name) {
+          return { kind: 'auth', detail: 'Not logged in to reddit.com (no identity in /api/me.json)' };
+        }
+
+        const limit = ${JSON.stringify(limit)};
+        const res = await fetch('/best.json?limit=' + limit + '&raw_json=1', { credentials: 'include' });
+        if (res.status === 401 || res.status === 403) {
+          return { kind: 'auth', detail: 'Reddit /best.json returned HTTP ' + res.status };
+        }
+        if (!res.ok) {
+          return { kind: 'http', httpStatus: res.status, where: '/best.json' };
+        }
+        const j = await res.json();
+        const entries = j?.data?.children;
+        if (!Array.isArray(entries)) {
+          return { kind: 'http', httpStatus: 200, where: '/best.json (no data.children array)' };
+        }
+        return { kind: 'ok', entries };
+      } catch (e) {
+        return { kind: 'exception', detail: String(e && e.message || e) };
+      }
+    })()`);
+
+        if (result?.kind === 'auth') {
+            throw new AuthRequiredError('reddit.com', result.detail);
+        }
+        if (result?.kind === 'http') {
+            throw new CommandExecutionError(`HTTP ${result.httpStatus} from ${result.where}`);
+        }
+        if (result?.kind === 'exception') {
+            throw new CommandExecutionError(`home failed: ${result.detail}`);
+        }
+        if (result?.kind !== 'ok') {
+            throw new CommandExecutionError(`Unexpected result from reddit home: ${JSON.stringify(result)}`);
+        }
+
+        const rows = [];
+        const entries = result.entries.slice(0, limit);
+        for (let i = 0; i < entries.length; i++) {
+            const d = entries[i]?.data;
+            if (!d || !d.id) continue;
+            rows.push({
+                rank: i + 1,
+                title: typeof d.title === 'string' ? d.title : null,
+                subreddit: typeof d.subreddit_name_prefixed === 'string' ? d.subreddit_name_prefixed : null,
+                score: typeof d.score === 'number' ? d.score : null,
+                comments: typeof d.num_comments === 'number' ? d.num_comments : null,
+                postId: d.id,
+                author: typeof d.author === 'string' ? d.author : null,
+                url: d.permalink ? 'https://www.reddit.com' + d.permalink : null,
+            });
+        }
+        if (rows.length === 0) {
+            if (entries.length > 0) {
+                throw new CommandExecutionError('Reddit home feed entries were missing required post id anchors');
+            }
+            throw new EmptyResultError('Reddit returned no posts in the personalized home feed.');
+        }
+        return rows;
+    },
+});

package/clis/reddit/home.test.js

@@ -0,0 +1,127 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { parseRedditHomeLimit } from './home.js';
+import './home.js';
+
+function makePage(result) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(result),
+    };
+}
+
+function makeEntry(id, overrides = {}) {
+    return {
+        data: {
+            id,
+            title: `Title for ${id}`,
+            subreddit_name_prefixed: 'r/dummy',
+            score: 100,
+            num_comments: 10,
+            author: 'someone',
+            permalink: `/r/dummy/comments/${id}/title/`,
+            ...overrides,
+        },
+    };
+}
+
+describe('reddit home command', () => {
+    const command = getRegistry().get('reddit/home');
+
+    it('registers with the expected shape', () => {
+        expect(command).toBeDefined();
+        expect(command.access).toBe('read');
+        expect(command.browser).toBe(true);
+        expect(command.columns).toEqual(['rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url']);
+    });
+
+    it('parseRedditHomeLimit accepts [1,100] and rejects out-of-range / non-integer without silent clamp', () => {
+        expect(parseRedditHomeLimit(undefined)).toBe(25);
+        expect(parseRedditHomeLimit(null)).toBe(25);
+        expect(parseRedditHomeLimit('')).toBe(25);
+        expect(parseRedditHomeLimit(1)).toBe(1);
+        expect(parseRedditHomeLimit(25)).toBe(25);
+        expect(parseRedditHomeLimit(100)).toBe(100);
+
+        for (const bad of [0, -1, 101, 1.5, NaN, 'abc']) {
+            expect(() => parseRedditHomeLimit(bad)).toThrow(ArgumentError);
+        }
+    });
+
+    it('rejects a bad limit BEFORE navigating', async () => {
+        const page = makePage({ kind: 'ok', entries: [] });
+        await expect(command.func(page, { limit: 101 })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('throws AuthRequiredError when logged out (401/403 or missing identity)', async () => {
+        await expect(command.func(makePage({ kind: 'auth', detail: 'login required' }), { limit: 25 }))
+            .rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('throws CommandExecutionError on HTTP / exception failure modes', async () => {
+        await expect(command.func(makePage({ kind: 'http', httpStatus: 503, where: '/best.json' }), { limit: 25 }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(command.func(makePage({ kind: 'exception', detail: 'network' }), { limit: 25 }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when Reddit returns no posts', async () => {
+        await expect(command.func(makePage({ kind: 'ok', entries: [] }), { limit: 25 }))
+            .rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('maps entries to row shape with 1-based rank, full URLs, and typed numbers', async () => {
+        const entries = [makeEntry('a1'), makeEntry('b2', { score: 250, num_comments: 42 })];
+        const rows = await command.func(makePage({ kind: 'ok', entries }), { limit: 25 });
+
+        expect(rows).toEqual([
+            {
+                rank: 1, title: 'Title for a1', subreddit: 'r/dummy', score: 100, comments: 10,
+                postId: 'a1', author: 'someone', url: 'https://www.reddit.com/r/dummy/comments/a1/title/',
+            },
+            {
+                rank: 2, title: 'Title for b2', subreddit: 'r/dummy', score: 250, comments: 42,
+                postId: 'b2', author: 'someone', url: 'https://www.reddit.com/r/dummy/comments/b2/title/',
+            },
+        ]);
+        // Row shape must match declared columns exactly.
+        for (const row of rows) {
+            expect(Object.keys(row).sort()).toEqual(
+                ['author', 'comments', 'postId', 'rank', 'score', 'subreddit', 'title', 'url'],
+            );
+        }
+    });
+
+    it('applies the post-fetch limit slice (defence in depth vs Reddit overshoot)', async () => {
+        const entries = Array.from({ length: 30 }, (_, i) => makeEntry(`p${i}`));
+        const rows = await command.func(makePage({ kind: 'ok', entries }), { limit: 5 });
+        expect(rows).toHaveLength(5);
+        expect(rows[0].postId).toBe('p0');
+        expect(rows[4].postId).toBe('p4');
+    });
+
+    it('drops entries with no data.id rather than silently emitting sentinels', async () => {
+        const entries = [makeEntry('keep1'), { data: { title: 'no id' } }, makeEntry('keep2')];
+        const rows = await command.func(makePage({ kind: 'ok', entries }), { limit: 25 });
+        expect(rows.map((r) => r.postId)).toEqual(['keep1', 'keep2']);
+    });
+
+    it('throws CommandExecutionError when all home entries are missing post ids', async () => {
+        const entries = [{ data: { title: 'no id' } }, { data: { title: 'also no id' } }];
+        await expect(command.func(makePage({ kind: 'ok', entries }), { limit: 25 }))
+            .rejects.toMatchObject({
+                code: 'COMMAND_EXEC',
+                message: expect.stringContaining('required post id anchors'),
+            });
+    });
+
+    it('embeds the requested limit literally inside the evaluate script', async () => {
+        const page = makePage({ kind: 'ok', entries: [makeEntry('x')] });
+        await command.func(page, { limit: 7 });
+        const script = page.evaluate.mock.calls[0][0];
+        expect(script).toContain('const limit = 7');
+    });
+});