@jackwener/opencli 1.7.17 → 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/reply.js

@@ -0,0 +1,182 @@
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+const REDDIT_COMMENT_ID_RE = /^[a-z0-9]+$/i;
+
+function normalizeBareCommentId(value) {
+    const commentId = String(value || '').trim();
+    if (!REDDIT_COMMENT_ID_RE.test(commentId)) {
+        throw new ArgumentError(
+            'Comment ID must be a Reddit comment id, t1_ fullname, or reddit.com comment URL.',
+            'Use a bare comment id like okf3s7u, a fullname like t1_okf3s7u, or a full Reddit comment URL.',
+        );
+    }
+    return commentId.toLowerCase();
+}
+
+export function normalizeRedditCommentFullname(value) {
+    const raw = String(value || '').trim();
+    if (!raw) {
+        throw new ArgumentError(
+            'Comment ID is required.',
+            'Use a bare comment id like okf3s7u, a fullname like t1_okf3s7u, or a full Reddit comment URL.',
+        );
+    }
+
+    const fullname = raw.match(/^t1_([a-z0-9]+)$/i);
+    if (fullname) return `t1_${normalizeBareCommentId(fullname[1])}`;
+
+    if (/^https?:\/\//i.test(raw)) {
+        let parsed;
+        try {
+            parsed = new URL(raw);
+        } catch {
+            throw new ArgumentError(`Invalid Reddit comment URL: ${raw}`);
+        }
+        const host = parsed.hostname.toLowerCase();
+        if (parsed.protocol !== 'https:' || (host !== 'reddit.com' && !host.endsWith('.reddit.com'))) {
+            throw new ArgumentError(
+                'Comment URL must be an https reddit.com URL.',
+                'Use a URL like https://www.reddit.com/r/sub/comments/post/title/okf3s7u/',
+            );
+        }
+        const parts = parsed.pathname.split('/').filter(Boolean);
+        const commentsIndex = parts.indexOf('comments');
+        const commentIndex = commentsIndex + 3;
+        if (commentsIndex < 0 || parts.length <= commentIndex) {
+            throw new ArgumentError(
+                'Comment URL must include the target comment id.',
+                'Use a URL like https://www.reddit.com/r/sub/comments/post/title/okf3s7u/',
+            );
+        }
+        if (parts.length !== commentIndex + 1) {
+            throw new ArgumentError(
+                'Comment URL must end at the target comment id.',
+                'Remove extra path segments after the comment id.',
+            );
+        }
+        return `t1_${normalizeBareCommentId(parts[commentIndex])}`;
+    }
+
+    if (raw.includes('/') || raw.startsWith('t3_')) {
+        throw new ArgumentError(
+            'Comment ID must be a Reddit comment id, t1_ fullname, or reddit.com comment URL.',
+            'Use a bare comment id like okf3s7u, a fullname like t1_okf3s7u, or a full Reddit comment URL.',
+        );
+    }
+
+    return `t1_${normalizeBareCommentId(raw)}`;
+}
+
+export function requireReplyText(value) {
+    const text = String(value || '');
+    if (!text.trim()) {
+        throw new ArgumentError('Reply text is required.', 'Pass non-empty text to post as the Reddit reply.');
+    }
+    return text;
+}
+
+cli({
+    site: 'reddit',
+    name: 'reply',
+    access: 'write',
+    description: 'Reply to a Reddit comment',
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'comment-id', type: 'string', required: true, positional: true, help: 'Comment ID (e.g. okf3s7u) or fullname (t1_xxx)' },
+        { name: 'text', type: 'string', required: true, positional: true, help: 'Reply text' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        const fullname = normalizeRedditCommentFullname(kwargs['comment-id']);
+        const text = requireReplyText(kwargs.text);
+        await page.goto('https://www.reddit.com');
+        // Inside page.evaluate we can't throw typed errors (they don't survive
+        // the worker boundary), so we surface a structured `kind` discriminator
+        // and re-throw the matching typed error on the Node side. Each kind
+        // maps 1:1 to a typed-error class — no silent-sentinel rows on failure.
+        //
+        // Intermediate object keys deliberately avoid `status` / `message` to
+        // sidestep the silent-column-drop audit (columns are ['status',
+        // 'message']) — see PR #1329 sediment "中间解析对象 key 不能跟 columns
+        // 任一项重叠".
+        const result = await page.evaluate(`(async () => {
+      try {
+        const fullname = ${JSON.stringify(fullname)};
+        const text = ${JSON.stringify(text)};
+
+        // Probe identity + modhash. /api/me.json returns data.name only when
+        // logged in — empty modhash alone is not a strong enough auth signal
+        // because Reddit sometimes returns 200 with empty modhash for stale
+        // anonymous sessions.
+        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 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.status === 401 || res.status === 403) {
+          return { kind: 'auth', detail: 'Reddit /api/comment returned HTTP ' + res.status };
+        }
+        if (!res.ok) {
+          return { kind: 'http', httpStatus: res.status, where: '/api/comment' };
+        }
+        const data = await res.json();
+        const errors = data?.json?.errors;
+        if (errors && errors.length > 0) {
+          return { kind: 'reddit-error', detail: errors.map(e => e.join(': ')).join('; ') };
+        }
+        const things = data?.json?.data?.things;
+        const created = Array.isArray(things)
+          ? things.find((thing) => thing?.kind === 't1' || String(thing?.data?.name || '').startsWith('t1_'))
+          : null;
+        const createdName = created?.data?.name || (created?.data?.id ? 't1_' + created.data.id : '');
+        if (!createdName) {
+          return { kind: 'postcondition', detail: 'Reddit comment response did not include a created reply id' };
+        }
+        return { kind: 'ok', detail: 'Reply posted on ' + fullname + ' as ' + createdName };
+      } 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 === 'reddit-error') {
+            throw new CommandExecutionError(`Reddit rejected reply: ${result.detail}`);
+        }
+        if (result?.kind === 'postcondition') {
+            throw new CommandExecutionError(result.detail);
+        }
+        if (result?.kind === 'exception') {
+            throw new CommandExecutionError(`Reply failed: ${result.detail}`);
+        }
+        if (result?.kind !== 'ok') {
+            throw new CommandExecutionError(`Unexpected result from reddit reply: ${JSON.stringify(result)}`);
+        }
+        return [{ status: 'success', message: result.detail }];
+    },
+});

package/clis/reddit/reply.test.js

@@ -0,0 +1,89 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { normalizeRedditCommentFullname, requireReplyText } from './reply.js';
+import './reply.js';
+
+function makePage(result = { kind: 'ok', detail: 'Reply posted on t1_okf3s7u as t1_reply123' }) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(result),
+    };
+}
+
+describe('reddit reply command', () => {
+    const command = getRegistry().get('reddit/reply');
+
+    it('normalizes bare ids, fullnames, and exact reddit comment URLs', () => {
+        expect(normalizeRedditCommentFullname('okf3s7u')).toBe('t1_okf3s7u');
+        expect(normalizeRedditCommentFullname('T1_OKF3S7U')).toBe('t1_okf3s7u');
+        expect(normalizeRedditCommentFullname('https://www.reddit.com/r/opencli/comments/1abc23/title_slug/okf3s7u/?context=3')).toBe('t1_okf3s7u');
+        expect(normalizeRedditCommentFullname('https://old.reddit.com/r/opencli/comments/1abc23/title_slug/okf3s7u/')).toBe('t1_okf3s7u');
+    });
+
+    it('rejects invalid or ambiguous comment identities before navigation', async () => {
+        const page = makePage();
+
+        for (const value of [
+            '',
+            't3_1abc23',
+            'abc/def',
+            'https://reddit.com.evil.com/r/opencli/comments/1abc23/title_slug/okf3s7u/',
+            'http://www.reddit.com/r/opencli/comments/1abc23/title_slug/okf3s7u/',
+            'https://www.reddit.com/r/opencli/comments/1abc23/title_slug/',
+            'https://www.reddit.com/r/opencli/comments/1abc23/title_slug/okf3s7u/evil',
+        ]) {
+            await expect(command.func(page, { 'comment-id': value, text: 'hello' })).rejects.toBeInstanceOf(ArgumentError);
+        }
+
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('rejects blank reply text before navigation', async () => {
+        const page = makePage();
+
+        await expect(command.func(page, { 'comment-id': 'okf3s7u', text: '   ' })).rejects.toBeInstanceOf(ArgumentError);
+
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+        expect(() => requireReplyText('hello')).not.toThrow();
+    });
+
+    it('posts to the normalized t1 fullname and returns success only on ok result', async () => {
+        const page = makePage();
+
+        const rows = await command.func(page, {
+            'comment-id': 'https://www.reddit.com/r/opencli/comments/1abc23/title_slug/okf3s7u/',
+            text: 'hello',
+        });
+
+        expect(page.goto).toHaveBeenCalledWith('https://www.reddit.com');
+        const script = page.evaluate.mock.calls[0][0];
+        expect(script).toContain('const fullname = "t1_okf3s7u"');
+        expect(script).toContain('const text = "hello"');
+        expect(rows).toEqual([{ status: 'success', message: 'Reply posted on t1_okf3s7u as t1_reply123' }]);
+    });
+
+    it('maps auth, http, reddit, exception, and postcondition failures to typed errors', async () => {
+        await expect(command.func(makePage({ kind: 'auth', detail: 'login required' }), { 'comment-id': 'okf3s7u', text: 'hello' }))
+            .rejects.toBeInstanceOf(AuthRequiredError);
+        await expect(command.func(makePage({ kind: 'http', httpStatus: 500, where: '/api/comment' }), { 'comment-id': 'okf3s7u', text: 'hello' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(command.func(makePage({ kind: 'reddit-error', detail: 'RATELIMIT: try later' }), { 'comment-id': 'okf3s7u', text: 'hello' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(command.func(makePage({ kind: 'exception', detail: 'bad json' }), { 'comment-id': 'okf3s7u', text: 'hello' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(command.func(makePage({ kind: 'postcondition', detail: 'Reddit comment response did not include a created reply id' }), { 'comment-id': 'okf3s7u', text: 'hello' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('requires the Reddit response to include a created reply id', async () => {
+        const page = makePage();
+
+        await command.func(page, { 'comment-id': 'okf3s7u', text: 'hello' });
+
+        expect(page.evaluate.mock.calls[0][0]).toContain('Reddit comment response did not include a created reply id');
+        expect(page.evaluate.mock.calls[0][0]).toContain("String(thing?.data?.name || '').startsWith('t1_')");
+    });
+});