feat(reddit): add whoami, home, subreddit-info read commands (#1491)

* feat(reddit): add whoami, home, subreddit-info read commands

Closes gap against jackwener/rdt-cli — three commands the existing 17 reddit
adapters were missing:

- `reddit whoami` — show the currently logged-in identity (fields:
  Username, ID, Post / Comment / Total Karma, Account Created, Gold, Mod,
  Verified Email, Has Mail, Inbox Count). Probes `/api/me.json` with
  two-pronged auth detection (401/403 OR `data.name` missing on 200 —
  Reddit returns 200 with an empty body for stale anon sessions, see PR
  #1428).

- `reddit home` — personalized Best feed (`/best.json`). Distinct from
  the public `frontpage`/`r/all` command: enforces login via the same
  two-pronged auth check rather than silently degrading to the
  unauthenticated default feed. `--limit` accepts [1, 100] — out-of-range
  raises `ArgumentError` before navigation, no silent clamp.

- `reddit subreddit-info` — subreddit metadata (Name, Title, Subscribers,
  Active Now, NSFW, Type, Description, Created, URL) from
  `/r/<X>/about.json`. Banned / private / quarantined / 404 subreddits
  raise `EmptyResultError` so the output table never holds a silent
  sentinel row.

All three use Strategy.COOKIE + siteSession:'persistent' matching the
existing reddit adapters, validate args upfront before `page.goto`, and
use the 5-kind discriminated-union pattern (kind: auth/http/missing/
exception/ok) from PR #1428 to map page.evaluate results to typed errors
on the Node side. Intermediate object keys deliberately avoid the
declared columns (`field`/`value`/`rank`/etc.) per the silent-column-drop
audit sediment from PR #1329.

Tests: 28 new (whoami 6, home 9, subreddit-info 13); full reddit suite
38/38. Audits: typed-error-lint 189/189 (0 new), silent-column-drop
103/103 (0 new). Manifest 812 → 815.

Refs: https://github.com/jackwener/rdt-cli

* fix(reddit): tighten new read command failure contracts

* fix(reddit): treat inaccessible subreddit info as empty

Author: jackwener

cli-manifest.json

@@ -19199,6 +19199,39 @@
     "navigateBefore": "https://reddit.com",
     "siteSession": "persistent"
   },
+  {
+    "site": "reddit",
+    "name": "home",
+    "description": "Reddit personalized home feed (Best, requires login)",
+    "access": "read",
+    "domain": "reddit.com",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "limit",
+        "type": "int",
+        "default": 25,
+        "required": false,
+        "help": "Number of posts (1–100)"
+      }
+    ],
+    "columns": [
+      "rank",
+      "title",
+      "subreddit",
+      "score",
+      "comments",
+      "postId",
+      "author",
+      "url"
+    ],
+    "type": "js",
+    "modulePath": "reddit/home.js",
+    "sourceFile": "reddit/home.js",
+    "navigateBefore": "https://reddit.com",
+    "siteSession": "persistent"
+  },
   {
     "site": "reddit",
     "name": "hot",
@@ -19540,6 +19573,33 @@
     "navigateBefore": "https://reddit.com",
     "siteSession": "persistent"
   },
+  {
+    "site": "reddit",
+    "name": "subreddit-info",
+    "description": "Show metadata for a Reddit subreddit (subscribers, description, created date, NSFW)",
+    "access": "read",
+    "domain": "reddit.com",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "name",
+        "type": "string",
+        "required": true,
+        "positional": true,
+        "help": "Subreddit name (no `r/` prefix needed)"
+      }
+    ],
+    "columns": [
+      "field",
+      "value"
+    ],
+    "type": "js",
+    "modulePath": "reddit/subreddit-info.js",
+    "sourceFile": "reddit/subreddit-info.js",
+    "navigateBefore": "https://reddit.com",
+    "siteSession": "persistent"
+  },
   {
     "site": "reddit",
     "name": "subscribe",
@@ -19738,6 +19798,25 @@
     "navigateBefore": "https://reddit.com",
     "siteSession": "persistent"
   },
+  {
+    "site": "reddit",
+    "name": "whoami",
+    "description": "Show the currently logged-in Reddit user",
+    "access": "read",
+    "domain": "reddit.com",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [],
+    "columns": [
+      "field",
+      "value"
+    ],
+    "type": "js",
+    "modulePath": "reddit/whoami.js",
+    "sourceFile": "reddit/whoami.js",
+    "navigateBefore": "https://reddit.com",
+    "siteSession": "persistent"
+  },
   {
     "site": "rednote",
     "name": "comments",

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;
+    },
+});

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');
+    });
+});