@jackwener/opencli 1.7.18 → 1.7.19

package/clis/reddit/read.test.js

@@ -1,20 +1,163 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { normalizeRedditPostId, parseExpandRounds } from './read.js';
 import './read.js';
+
+function makePage(result) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(result),
+    };
+}
+
+function redditPostEnvelope(children) {
+    return [
+        {
+            data: {
+                children: [{
+                    data: {
+                        title: 'Post title',
+                        selftext: '',
+                        author: 'op',
+                        score: 10,
+                        is_self: true,
+                    },
+                }],
+            },
+        },
+        { data: { children } },
+    ];
+}
+
+function commentThing(id, body, parent = 't3_abc123', score = 1) {
+    return {
+        kind: 't1',
+        data: {
+            id,
+            name: `t1_${id}`,
+            parent_id: parent,
+            author: id,
+            score,
+            body,
+            replies: '',
+        },
+    };
+}
+
+function moreThing(id, children, parent = 't3_abc123', count = children.length) {
+    return {
+        kind: 'more',
+        data: { id, parent_id: parent, children, count },
+    };
+}
+
+function jsonResponse(payload, status = 200) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        json: vi.fn().mockResolvedValue(payload),
+    };
+}
+
+function makeRuntimePage(fetchImpl) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn(async (script) => {
+            const previousFetch = globalThis.fetch;
+            globalThis.fetch = fetchImpl;
+            try {
+                return await eval(script);
+            } finally {
+                globalThis.fetch = previousFetch;
+            }
+        }),
+    };
+}
+
 describe('reddit read adapter', () => {
     const command = getRegistry().get('reddit/read');
+
     it('opts into the Reddit persistent site session', () => {
         expect(command?.browser).toBe(true);
         expect(command?.siteSession).toBe('persistent');
+        expect(command?.columns).toEqual(['type', 'author', 'score', 'text']);
     });
-    it('returns threaded rows from the browser-evaluated payload', async () => {
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue([
+
+    it('exposes the new --expand-more / --expand-rounds args', () => {
+        const argNames = command.args.map((a) => a.name);
+        expect(argNames).toContain('expand-more');
+        expect(argNames).toContain('expand-rounds');
+        const expandMore = command.args.find((a) => a.name === 'expand-more');
+        expect(expandMore.type).toBe('bool');
+        expect(expandMore.default).toBe(false);
+        const rounds = command.args.find((a) => a.name === 'expand-rounds');
+        expect(rounds.type).toBe('int');
+        expect(rounds.default).toBe(2);
+    });
+
+    describe('normalizeRedditPostId', () => {
+        it('accepts bare ids, t3 fullnames, and exact reddit post URLs', () => {
+            expect(normalizeRedditPostId('1AbC23')).toBe('1abc23');
+            expect(normalizeRedditPostId('t3_1AbC23')).toBe('1abc23');
+            expect(normalizeRedditPostId('https://www.reddit.com/r/opencli/comments/1abc23/title_slug/?sort=top')).toBe('1abc23');
+            expect(normalizeRedditPostId('https://www.reddit.com/r/opencli/comments/1abc23/title_slug/okf3s7u/?context=3')).toBe('1abc23');
+            expect(normalizeRedditPostId('https://old.reddit.com/comments/1abc23/title_slug/')).toBe('1abc23');
+        });
+
+        it('rejects invalid or structurally loose post identities before navigation', () => {
+            for (const bad of [
+                '',
+                't1_okf3s7u',
+                'https://reddit.com.evil.com/r/opencli/comments/1abc23/title_slug/',
+                'http://www.reddit.com/r/opencli/comments/1abc23/title_slug/',
+                'https://www.reddit.com/r/opencli/comments/',
+                'https://www.reddit.com/r/opencli/comments/1abc23/title_slug/okf3s7u/evil',
+                'not/a/post',
+            ]) {
+                expect(() => normalizeRedditPostId(bad)).toThrow(ArgumentError);
+            }
+        });
+    });
+
+    describe('parseExpandRounds', () => {
+        it('returns the default for absent input but throws on out-of-range / non-integer', () => {
+            expect(parseExpandRounds(undefined)).toBe(2);
+            expect(parseExpandRounds(null)).toBe(2);
+            expect(parseExpandRounds('')).toBe(2);
+            expect(parseExpandRounds(1)).toBe(1);
+            expect(parseExpandRounds(5)).toBe(5);
+            for (const bad of [0, -1, 6, 1.5, NaN, 'abc']) {
+                expect(() => parseExpandRounds(bad)).toThrow(ArgumentError);
+            }
+        });
+    });
+
+    it('rejects a bad --expand-rounds BEFORE navigating', async () => {
+        const page = makePage({ kind: 'ok', rows: [] });
+        await expect(command.func(page, { 'post-id': 'abc123', 'expand-rounds': 99 }))
+            .rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('rejects a bad post identity BEFORE navigating', async () => {
+        const page = makePage({ kind: 'ok', rows: [] });
+        await expect(command.func(page, { 'post-id': 'https://evil.test/r/x/comments/abc/title/' }))
+            .rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('returns rows when the evaluate script reports kind=ok', async () => {
+        const page = makePage({
+            kind: 'ok',
+            rows: [
                 { type: 'POST', author: 'alice', score: 10, text: 'Title' },
                 { type: 'L0', author: 'bob', score: 5, text: 'Comment' },
-            ]),
-        };
+            ],
+            expandMeta: { rounds: 0, fetched: 0, capped: false, errors: [] },
+        });
         const result = await command.func(page, { 'post-id': 'abc123', limit: 5 });
         expect(page.goto).toHaveBeenCalledWith('https://www.reddit.com');
         expect(result).toEqual([
@@ -22,11 +165,171 @@ describe('reddit read adapter', () => {
             { type: 'L0', author: 'bob', score: 5, text: 'Comment' },
         ]);
     });
-    it('surfaces adapter-level API errors clearly', async () => {
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({ error: 'Reddit API returned HTTP 403' }),
-        };
-        await expect(command.func(page, { 'post-id': 'abc123' })).rejects.toThrow('Reddit API returned HTTP 403');
+
+    it('maps the five failure kinds to the right typed errors', async () => {
+        await expect(command.func(makePage({ kind: 'inaccessible', detail: 'post 403' }), { 'post-id': 'abc123' }))
+            .rejects.toBeInstanceOf(EmptyResultError);
+
+        await expect(command.func(makePage({ kind: 'auth', detail: 'morechildren 401' }), { 'post-id': 'abc123' }))
+            .rejects.toBeInstanceOf(AuthRequiredError);
+
+        await expect(command.func(makePage({ kind: 'http', httpStatus: 503, where: '/comments/abc.json' }), { 'post-id': 'abc123' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+
+        await expect(command.func(makePage({ kind: 'malformed', detail: 'no comment listing' }), { 'post-id': 'abc123' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+
+        await expect(command.func(makePage({ kind: 'parser-drift', detail: 'walker drift' }), { 'post-id': 'abc123' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+
+        await expect(command.func(makePage({ kind: 'expand-failed', detail: 'morechildren errors' }), { 'post-id': 'abc123' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws CommandExecutionError on an unknown envelope shape (no kind)', async () => {
+        await expect(command.func(makePage({ random: 'stuff' }), { 'post-id': 'abc123' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(command.func(makePage(null), { 'post-id': 'abc123' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('embeds expandMore=false by default and inlines flags into the evaluate script', async () => {
+        const page = makePage({ kind: 'ok', rows: [], expandMeta: { rounds: 0, fetched: 0, capped: false, errors: [] } });
+        await command.func(page, { 'post-id': 'xyz', sort: 'top', limit: 3 });
+        const script = page.evaluate.mock.calls[0][0];
+        expect(script).toContain('var expandMore = false');
+        expect(script).toContain('var expandRounds = 2');
+        expect(script).toContain('var sort = "top"');
+        expect(script).toContain('var limit = 3');
+        expect(script).toContain('var postId = "xyz"');
+    });
+
+    it('embeds expandMore=true and the requested expandRounds when --expand-more is on', async () => {
+        const page = makePage({ kind: 'ok', rows: [], expandMeta: { rounds: 3, fetched: 12, capped: true, errors: [] } });
+        await command.func(page, { 'post-id': 'xyz', 'expand-more': true, 'expand-rounds': 3 });
+        const script = page.evaluate.mock.calls[0][0];
+        expect(script).toContain('var expandMore = true');
+        expect(script).toContain('var expandRounds = 3');
+        // The /api/morechildren request body construction must be present in
+        // the evaluate script (round-trips the link_id + children CSV).
+        expect(script).toContain("'/api/morechildren'");
+        expect(script).toContain("'api_type=json'");
+        expect(script).toContain("encodeURIComponent(linkFullname)");
+        expect(script).toContain("encodeURIComponent(batch.join(','))");
+    });
+
+    it('normalizes a full reddit URL before building the browser script', async () => {
+        const page = makePage({ kind: 'ok', rows: [], expandMeta: { rounds: 0, fetched: 0, capped: false, errors: [] } });
+        await command.func(page, { 'post-id': 'https://www.reddit.com/r/python/comments/1abc23/title_slug/' });
+        const script = page.evaluate.mock.calls[0][0];
+        expect(script).toContain('var postId = "1abc23"');
+        expect(script).not.toContain('postIdRaw.match');
+    });
+
+    it('expands morechildren in the original tree position instead of appending to the parent', async () => {
+        const fetchMock = vi.fn(async (url) => {
+            if (String(url).startsWith('/comments/')) {
+                return jsonResponse(redditPostEnvelope([
+                    commentThing('a', 'A'),
+                    moreThing('more_top', ['b', 'c']),
+                    commentThing('d', 'D'),
+                ]));
+            }
+            if (String(url) === '/api/morechildren') {
+                return jsonResponse({
+                    json: {
+                        errors: [],
+                        data: { things: [commentThing('b', 'B'), commentThing('c', 'C')] },
+                    },
+                });
+            }
+            throw new Error(`unexpected URL ${url}`);
+        });
+        const page = makeRuntimePage(fetchMock);
+
+        const result = await command.func(page, {
+            'post-id': 'abc123',
+            'expand-more': true,
+            limit: 10,
+            replies: 10,
+        });
+
+        expect(result.map((row) => row.author)).toEqual(['op', 'a', 'b', 'c', 'd']);
+        expect(fetchMock).toHaveBeenCalledWith(
+            '/api/morechildren',
+            expect.objectContaining({
+                method: 'POST',
+                body: expect.stringContaining('link_id=t3_abc123'),
+            }),
+        );
+    });
+
+    it('fails expand-more when Reddit returns a child that cannot be placed in the requested tree', async () => {
+        const fetchMock = vi.fn(async (url) => {
+            if (String(url).startsWith('/comments/')) {
+                return jsonResponse(redditPostEnvelope([moreThing('more_top', ['b'])]));
+            }
+            if (String(url) === '/api/morechildren') {
+                return jsonResponse({
+                    json: {
+                        errors: [],
+                        data: { things: [commentThing('b', 'B', 't3_other')] },
+                    },
+                });
+            }
+            throw new Error(`unexpected URL ${url}`);
+        });
+        const page = makeRuntimePage(fetchMock);
+
+        await expect(command.func(page, {
+            'post-id': 'abc123',
+            'expand-more': true,
+        })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('fails expand-more when Reddit omits a requested child instead of silently dropping the stub', async () => {
+        const fetchMock = vi.fn(async (url) => {
+            if (String(url).startsWith('/comments/')) {
+                return jsonResponse(redditPostEnvelope([moreThing('more_top', ['b', 'c'])]));
+            }
+            if (String(url) === '/api/morechildren') {
+                return jsonResponse({
+                    json: {
+                        errors: [],
+                        data: { things: [commentThing('b', 'B')] },
+                    },
+                });
+            }
+            throw new Error(`unexpected URL ${url}`);
+        });
+        const page = makeRuntimePage(fetchMock);
+
+        await expect(command.func(page, {
+            'post-id': 'abc123',
+            'expand-more': true,
+        })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('uses 5-kind discriminated union keys that DO NOT collide with declared columns', () => {
+        // Read the evaluate template once to assert the intermediate keys we
+        // return on the browser side never name any of `type` / `author` /
+        // `score` / `text` (the declared columns) — that pattern would
+        // trigger the silent-column-drop audit.
+        const page = makePage({ kind: 'ok', rows: [], expandMeta: { rounds: 0, fetched: 0, capped: false, errors: [] } });
+        return command.func(page, { 'post-id': 'xyz' }).then(() => {
+            const script = page.evaluate.mock.calls[0][0];
+            // Each return shape uses kind / detail / httpStatus / where /
+            // rows / expandMeta. None overlap with the four declared
+            // columns. The walker IS allowed to push column-shaped row
+            // objects into `rows` — that's the final shape, not an
+            // intermediate one.
+            expect(script).toContain("kind: 'inaccessible'");
+            expect(script).toContain("kind: 'auth'");
+            expect(script).toContain("kind: 'http'");
+            expect(script).toContain("kind: 'malformed'");
+            expect(script).toContain("kind: 'parser-drift'");
+            expect(script).toContain("kind: 'expand-failed'");
+            expect(script).toContain("kind: 'ok'");
+        });
     });
 });

package/clis/reddit/subreddit-info.js

@@ -0,0 +1,117 @@
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+// Reddit subreddit names: 3–21 chars, letters/digits/underscore, must start
+// with a letter. Accept an optional `r/` prefix and normalise it off.
+const SUBREDDIT_NAME_RE = /^[A-Za-z][A-Za-z0-9_]{2,20}$/;
+
+export function parseSubredditName(raw) {
+    let name = String(raw || '').trim();
+    if (!name) {
+        throw new ArgumentError(
+            'Subreddit name is required.',
+            'Pass a subreddit name like `python` (or `r/python`).',
+        );
+    }
+    if (name.startsWith('/r/')) name = name.slice(3);
+    else if (name.startsWith('r/')) name = name.slice(2);
+    if (!SUBREDDIT_NAME_RE.test(name)) {
+        throw new ArgumentError(
+            'Invalid subreddit name.',
+            'Subreddit names are 3–21 characters, start with a letter, and contain only letters, digits, and underscores.',
+        );
+    }
+    return name;
+}
+
+cli({
+    site: 'reddit',
+    name: 'subreddit-info',
+    access: 'read',
+    description: 'Show metadata for a Reddit subreddit (subscribers, description, created date, NSFW)',
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    siteSession: 'persistent',
+    args: [
+        { name: 'name', type: 'string', required: true, positional: true, help: 'Subreddit name (no `r/` prefix needed)' },
+    ],
+    columns: ['field', 'value'],
+    func: async (page, kwargs) => {
+        const sub = parseSubredditName(kwargs.name);
+        await page.goto('https://www.reddit.com');
+        // Banned / private / non-existent subreddits return a 404 envelope
+        // ({"error":404,"reason":"banned"|"private"|null,"message":"Not Found"}).
+        // We surface those as EmptyResultError so the table never contains a
+        // silent sentinel row. Intermediate keys avoid `field`/`value`.
+        const result = await page.evaluate(`(async () => {
+      try {
+        const sub = ${JSON.stringify(sub)};
+        const res = await fetch('/r/' + encodeURIComponent(sub) + '/about.json?raw_json=1', { credentials: 'include' });
+        if (res.status === 401 || res.status === 403 || res.status === 404) {
+          return { kind: 'missing', detail: 'Subreddit r/' + sub + ' was not found or is not accessible (HTTP ' + res.status + ').' };
+        }
+        if (!res.ok) {
+          return { kind: 'http', httpStatus: res.status, where: '/r/' + sub + '/about.json' };
+        }
+        const j = await res.json();
+        // Reddit may return an envelope-style 200 with {"kind":"Listing"} or
+        // an error body for quarantined / private subs. Identify "subreddit
+        // not found / not accessible" by the absence of data.display_name.
+        if (j?.error) {
+          if (j.error === 404 || j.reason === 'banned' || j.reason === 'private' || j.reason === 'quarantined') {
+            return { kind: 'missing', detail: 'Subreddit r/' + sub + ' is ' + (j.reason || 'unavailable') + '.' };
+          }
+          return { kind: 'http', httpStatus: j.error, where: '/r/' + sub + '/about.json (' + (j.reason || 'error') + ')' };
+        }
+        const info = j?.data;
+        if (!info || !info.display_name) {
+          return { kind: 'malformed', detail: 'Reddit returned malformed subreddit info for r/' + sub + ' (missing data.display_name).' };
+        }
+        return { kind: 'ok', info };
+      } catch (e) {
+        return { kind: 'exception', detail: String(e && e.message || e) };
+      }
+    })()`);
+
+        if (result?.kind === 'missing') {
+            throw new EmptyResultError(result.detail);
+        }
+        if (result?.kind === 'http') {
+            throw new CommandExecutionError(`HTTP ${result.httpStatus} from ${result.where}`);
+        }
+        if (result?.kind === 'malformed') {
+            throw new CommandExecutionError(result.detail);
+        }
+        if (result?.kind === 'exception') {
+            throw new CommandExecutionError(`subreddit-info failed: ${result.detail}`);
+        }
+        if (result?.kind !== 'ok') {
+            throw new CommandExecutionError(`Unexpected result from reddit subreddit-info: ${JSON.stringify(result)}`);
+        }
+
+        const s = result.info;
+        const created = s.created_utc
+            ? new Date(s.created_utc * 1000).toISOString().split('T')[0]
+            : null;
+        const subscribers = typeof s.subscribers === 'number' ? s.subscribers : null;
+        const activeNow = typeof s.active_user_count === 'number'
+            ? s.active_user_count
+            : (typeof s.accounts_active === 'number' ? s.accounts_active : null);
+        const description = typeof s.public_description === 'string'
+            ? s.public_description.trim()
+            : '';
+
+        return [
+            { field: 'Name', value: s.display_name_prefixed || ('r/' + s.display_name) },
+            { field: 'Title', value: typeof s.title === 'string' ? s.title : null },
+            { field: 'Subscribers', value: subscribers != null ? String(subscribers) : null },
+            { field: 'Active Now', value: activeNow != null ? String(activeNow) : null },
+            { field: 'NSFW', value: s.over18 ? 'Yes' : 'No' },
+            { field: 'Type', value: typeof s.subreddit_type === 'string' ? s.subreddit_type : null },
+            { field: 'Description', value: description || null },
+            { field: 'Created', value: created },
+            { field: 'URL', value: s.url ? 'https://www.reddit.com' + s.url : null },
+        ];
+    },
+});

package/clis/reddit/subreddit-info.test.js

@@ -0,0 +1,163 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { parseSubredditName } from './subreddit-info.js';
+import './subreddit-info.js';
+
+function makePage(result) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(result),
+    };
+}
+
+describe('reddit subreddit-info command', () => {
+    const command = getRegistry().get('reddit/subreddit-info');
+
+    it('registers with the expected shape', () => {
+        expect(command).toBeDefined();
+        expect(command.access).toBe('read');
+        expect(command.browser).toBe(true);
+        expect(command.columns).toEqual(['field', 'value']);
+    });
+
+    it('parseSubredditName strips prefixes and validates the name shape', () => {
+        expect(parseSubredditName('python')).toBe('python');
+        expect(parseSubredditName('r/python')).toBe('python');
+        expect(parseSubredditName('/r/python')).toBe('python');
+        expect(parseSubredditName('  AskReddit  ')).toBe('AskReddit');
+        expect(parseSubredditName('aw3some_sub')).toBe('aw3some_sub');
+    });
+
+    it('parseSubredditName rejects invalid names without silent fallback', () => {
+        for (const bad of [
+            '',
+            '  ',
+            'py',                   // too short
+            '1abc',                 // must start with letter
+            '_sub',                 // must start with letter
+            'has space',            // no spaces
+            'has-dash',             // no dashes
+            'way_too_long_subreddit_name_here', // too long (>21)
+        ]) {
+            expect(() => parseSubredditName(bad)).toThrow(ArgumentError);
+        }
+    });
+
+    it('rejects bad subreddit names BEFORE navigating', async () => {
+        const page = makePage({ kind: 'ok', info: {} });
+        await expect(command.func(page, { name: 'has space' })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('throws EmptyResultError for missing / banned / private / quarantined subreddits', async () => {
+        for (const detail of ['not found', 'banned', 'private', 'quarantined']) {
+            await expect(command.func(makePage({ kind: 'missing', detail }), { name: 'python' }))
+                .rejects.toBeInstanceOf(EmptyResultError);
+        }
+    });
+
+    it('treats HTTP 401/403/404 about.json responses as inaccessible subreddit, not auth-required', async () => {
+        for (const status of [401, 403, 404]) {
+            const scriptResults = [];
+            const page = {
+                goto: vi.fn().mockResolvedValue(undefined),
+                evaluate: vi.fn(async (script) => {
+                    const result = await (new Function('fetch', `return (${script})`))(vi.fn(async () => ({
+                        status,
+                        ok: false,
+                    })));
+                    scriptResults.push(result);
+                    return result;
+                }),
+            };
+            await expect(command.func(page, { name: 'python' })).rejects.toBeInstanceOf(EmptyResultError);
+            expect(scriptResults[0]).toMatchObject({ kind: 'missing' });
+        }
+    });
+
+    it('throws CommandExecutionError on HTTP and exception failure modes', async () => {
+        await expect(command.func(makePage({ kind: 'http', httpStatus: 500, where: 'about.json' }), { name: 'python' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(command.func(makePage({ kind: 'exception', detail: 'bad' }), { name: 'python' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws CommandExecutionError for malformed 200 subreddit payloads', async () => {
+        await expect(command.func(makePage({
+            kind: 'malformed',
+            detail: 'Reddit returned malformed subreddit info for r/python (missing data.display_name).',
+        }), { name: 'python' }))
+            .rejects.toMatchObject({
+                code: 'COMMAND_EXEC',
+                message: expect.stringContaining('malformed subreddit info'),
+            });
+    });
+
+    it('maps a normal subreddit payload into typed field/value rows', async () => {
+        const info = {
+            display_name: 'python',
+            display_name_prefixed: 'r/python',
+            title: 'Python',
+            public_description: '  News about the programming language Python.  ',
+            subscribers: 1234567,
+            active_user_count: 4321,
+            over18: false,
+            subreddit_type: 'public',
+            created_utc: 1201881600, // 2008-02-01
+            url: '/r/python/',
+        };
+        const rows = await command.func(makePage({ kind: 'ok', info }), { name: 'python' });
+        const byField = Object.fromEntries(rows.map((r) => [r.field, r.value]));
+
+        expect(byField.Name).toBe('r/python');
+        expect(byField.Title).toBe('Python');
+        expect(byField.Subscribers).toBe('1234567');
+        expect(byField['Active Now']).toBe('4321');
+        expect(byField.NSFW).toBe('No');
+        expect(byField.Type).toBe('public');
+        expect(byField.Description).toBe('News about the programming language Python.');
+        expect(byField.Created).toBe('2008-02-01');
+        expect(byField.URL).toBe('https://www.reddit.com/r/python/');
+
+        for (const row of rows) {
+            expect(Object.keys(row).sort()).toEqual(['field', 'value']);
+        }
+    });
+
+    it('falls back to accounts_active when active_user_count is missing', async () => {
+        const info = {
+            display_name: 'sub',
+            display_name_prefixed: 'r/sub',
+            accounts_active: 99,
+            url: '/r/sub/',
+        };
+        const rows = await command.func(makePage({ kind: 'ok', info }), { name: 'sub' });
+        const byField = Object.fromEntries(rows.map((r) => [r.field, r.value]));
+        expect(byField['Active Now']).toBe('99');
+    });
+
+    it('emits typed null (not "-" sentinel) when subscribers / activity / created are missing', async () => {
+        const info = {
+            display_name: 'sparse',
+            display_name_prefixed: 'r/sparse',
+            url: '/r/sparse/',
+        };
+        const rows = await command.func(makePage({ kind: 'ok', info }), { name: 'sparse' });
+        const byField = Object.fromEntries(rows.map((r) => [r.field, r.value]));
+        expect(byField.Subscribers).toBeNull();
+        expect(byField['Active Now']).toBeNull();
+        expect(byField.Created).toBeNull();
+        expect(byField.Description).toBeNull();
+        expect(byField.Title).toBeNull();
+        expect(byField.Type).toBeNull();
+    });
+
+    it('encodes the subreddit name into the fetch URL embedded in evaluate', async () => {
+        const page = makePage({ kind: 'ok', info: { display_name: 'python', display_name_prefixed: 'r/python', url: '/r/python/' } });
+        await command.func(page, { name: 'r/python' });
+        const script = page.evaluate.mock.calls[0][0];
+        expect(script).toContain('const sub = "python"');
+    });
+});