@jackwener/opencli 1.7.17 → 1.7.18

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

package/clis/rednote/comments.js

@@ -0,0 +1,76 @@
+/**
+ * Rednote comments — international mirror of xiaohongshu/comments.
+ * Reuses the DOM-extraction IIFE from `../xiaohongshu/comments.js`.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { buildCommentsExtractJs } from '../xiaohongshu/comments.js';
+import { buildNoteUrl, parseNoteId } from '../xiaohongshu/note-helpers.js';
+
+const REDNOTE_SIGNED_URL_HINT = 'Pass a full rednote.com note URL with xsec_token from search results or user/profile context.';
+
+function parseCommentLimit(raw) {
+    const parsed = Number(raw ?? 20);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`--limit must be an integer between 1 and 50, got ${JSON.stringify(raw)}`);
+    }
+    if (parsed < 1 || parsed > 50) {
+        throw new ArgumentError(`--limit must be between 1 and 50, got ${parsed}`);
+    }
+    return parsed;
+}
+
+cli({
+    site: 'rednote',
+    name: 'comments',
+    access: 'read',
+    description: 'Read comments from a rednote note (supports nested replies)',
+    domain: 'www.rednote.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        { name: 'note-id', required: true, positional: true, help: 'Full rednote note URL with xsec_token' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of top-level comments (max 50)' },
+        { name: 'with-replies', type: 'boolean', default: false, help: 'Include nested replies (楼中楼)' },
+    ],
+    columns: ['rank', 'author', 'text', 'likes', 'time', 'is_reply', 'reply_to'],
+    func: async (page, kwargs) => {
+        const limit = parseCommentLimit(kwargs.limit);
+        const withReplies = Boolean(kwargs['with-replies']);
+        const raw = String(kwargs['note-id']);
+        const noteId = parseNoteId(raw);
+        await page.goto(buildNoteUrl(raw, {
+            commandName: 'rednote comments',
+            cookieRoot: 'rednote.com',
+            signedUrlHint: REDNOTE_SIGNED_URL_HINT,
+        }));
+        await page.wait({ time: 2 + Math.random() * 3 });
+        const data = await page.evaluate(buildCommentsExtractJs(withReplies));
+        if (!data || typeof data !== 'object') {
+            throw new EmptyResultError('rednote/comments', 'Unexpected evaluate response');
+        }
+        if (data.securityBlock) {
+            throw new CommandExecutionError('Rednote security block: the note detail page was blocked by risk control.', /^https?:\/\//.test(raw)
+                ? 'The page may be temporarily restricted. Try again later or from a different session.'
+                : 'Try using a full URL from search results (with xsec_token) instead of a bare note ID.');
+        }
+        if (data.loginWall) {
+            throw new AuthRequiredError('www.rednote.com', 'Note comments require login');
+        }
+        void noteId;
+        const all = data.results ?? [];
+        if (withReplies) {
+            const limited = [];
+            let topCount = 0;
+            for (const c of all) {
+                if (!c.is_reply)
+                    topCount++;
+                if (topCount > limit)
+                    break;
+                limited.push(c);
+            }
+            return limited.map((c, i) => ({ rank: i + 1, ...c }));
+        }
+        return all.slice(0, limit).map((c, i) => ({ rank: i + 1, ...c }));
+    },
+});

package/clis/rednote/download.js

@@ -0,0 +1,59 @@
+/**
+ * Rednote download — international mirror of xiaohongshu/download.
+ * Reuses the DOM-extraction IIFE from `../xiaohongshu/download.js`; that
+ * IIFE's CDN allowlist already accepts rednote-hosted media URLs.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { formatCookieHeader } from '@jackwener/opencli/download';
+import { downloadMedia } from '@jackwener/opencli/download/media-download';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { buildDownloadExtractJs } from '../xiaohongshu/download.js';
+import { buildNoteUrl, parseNoteId } from '../xiaohongshu/note-helpers.js';
+
+const REDNOTE_SIGNED_URL_HINT = 'Pass a full rednote.com note URL with xsec_token from search results or user/profile context.';
+
+cli({
+    site: 'rednote',
+    name: 'download',
+    access: 'read',
+    description: 'Download images and videos from a rednote note',
+    domain: 'www.rednote.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        { name: 'note-id', positional: true, required: true, help: 'Full rednote note URL with xsec_token' },
+        { name: 'output', default: './rednote-downloads', help: 'Output directory' },
+    ],
+    columns: ['index', 'type', 'status', 'size'],
+    func: async (page, kwargs) => {
+        const rawInput = String(kwargs['note-id']);
+        const output = kwargs.output;
+        const noteId = parseNoteId(rawInput);
+        await page.goto(buildNoteUrl(rawInput, {
+            commandName: 'rednote download',
+            cookieRoot: 'rednote.com',
+            signedUrlHint: REDNOTE_SIGNED_URL_HINT,
+        }));
+        await page.wait({ time: 1 + Math.random() * 2 });
+        const data = await page.evaluate(buildDownloadExtractJs(noteId));
+        if (data?.securityBlock) {
+            throw new CommandExecutionError('Rednote security block: the note detail page was blocked by risk control.', /^https?:\/\//.test(rawInput)
+                ? 'The page may be temporarily restricted. Try again later or from a different session.'
+                : 'Try using a full URL from search results (with xsec_token) instead of a bare note ID.');
+        }
+        if (!data || !data.media || data.media.length === 0) {
+            throw new EmptyResultError('rednote/download', 'No downloadable media found on this rednote note.');
+        }
+        const cookies = formatCookieHeader(await page.getCookies({ url: 'https://www.rednote.com' }));
+        const resolvedNoteId = typeof data.noteId === 'string' && data.noteId.trim()
+            ? data.noteId.trim()
+            : noteId;
+        return downloadMedia(data.media, {
+            output,
+            subdir: resolvedNoteId,
+            cookies,
+            filenamePrefix: resolvedNoteId,
+            timeout: 60000,
+        });
+    },
+});

package/clis/rednote/feed.js

@@ -0,0 +1,95 @@
+/**
+ * Rednote home feed — reads the hydrated Pinia `feed.feeds` array directly.
+ *
+ * Differs from xiaohongshu/feed because rednote.com surfaces feed items in
+ * camelCase on the client side (`noteCard.displayTitle`, `interactInfo.likedCount`)
+ * while the xhs feed pipeline uses the snake_case shape returned by the
+ * `/homefeed` API on xiaohongshu.com. The store is already hydrated on first
+ * `/explore` load so a func-mode read avoids needing a network tap.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+function parseLimit(raw) {
+    const parsed = Number(raw ?? 20);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`--limit must be a positive integer, got ${JSON.stringify(raw)}`);
+    }
+    if (parsed < 1) {
+        throw new ArgumentError(`--limit must be a positive integer, got ${parsed}`);
+    }
+    return parsed;
+}
+
+const FEEDS_READ_JS = `
+  (() => {
+    let pinia = null;
+    const probe = (el) => el?.__vue_app__?.config?.globalProperties?.$pinia ?? null;
+    pinia = probe(document.querySelector('#app'));
+    if (!pinia) {
+      // Some rednote builds mount under a different root id; fall back to a
+      // full scan only when the standard mount node misses.
+      for (const el of document.querySelectorAll('*')) {
+        pinia = probe(el);
+        if (pinia) break;
+      }
+    }
+    if (!pinia || !pinia._s) return { error: 'no_pinia' };
+    const store = pinia._s.get('feed');
+    if (!store) return { error: 'no_feed_store' };
+    const feeds = store.feeds;
+    if (!Array.isArray(feeds)) return { error: 'feeds_not_array' };
+    return {
+      items: feeds.map(entry => {
+        const card = entry?.noteCard ?? {};
+        return {
+          id: entry?.id ?? '',
+          title: card.displayTitle ?? '',
+          type: card.type ?? '',
+          author: card.user?.nickName ?? card.user?.nickname ?? '',
+          likes: card.interactInfo?.likedCount ?? '',
+        };
+      }),
+    };
+  })()
+`;
+
+export const command = cli({
+    site: 'rednote',
+    name: 'feed',
+    access: 'read',
+    description: 'Rednote home feed (reads hydrated Pinia store)',
+    domain: 'www.rednote.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
+    ],
+    columns: ['id', 'title', 'author', 'likes', 'type', 'url'],
+    func: async (page, kwargs) => {
+        const limit = parseLimit(kwargs.limit);
+        await page.goto('https://www.rednote.com/explore');
+        // Pinia store hydrates synchronously from SSR; give the page a beat to
+        // finish bootstrapping before reading the array.
+        await page.wait({ time: 2 });
+        const data = await page.evaluate(FEEDS_READ_JS);
+        if (!data || typeof data !== 'object') {
+            throw new CommandExecutionError('rednote feed: unexpected evaluate response');
+        }
+        if (data.error) {
+            throw new CommandExecutionError(`rednote feed: ${data.error}`, 'The rednote SPA may still be hydrating; reload www.rednote.com/explore and retry.');
+        }
+        const rows = (data.items || [])
+            .filter((row) => row.id)
+            .slice(0, limit)
+            .map((row) => ({
+            ...row,
+            url: `https://www.rednote.com/explore/${row.id}`,
+        }));
+        if (rows.length === 0) {
+            throw new EmptyResultError('rednote/feed', 'No feed items in the hydrated store.');
+        }
+        return rows;
+    },
+});

package/clis/rednote/navigation.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './note.js';
+import './comments.js';
+import './download.js';
+import './feed.js';
+import './notifications.js';
+import './search.js';
+import './user.js';
+
+describe('rednote navigateBefore hardening', () => {
+    const expectedFalse = [
+        'rednote/note',
+        'rednote/comments',
+        'rednote/download',
+        'rednote/feed',
+        'rednote/notifications',
+        'rednote/search',
+        'rednote/user',
+    ];
+    it.each(expectedFalse)('%s sets navigateBefore=false', (name) => {
+        const cmd = getRegistry().get(name);
+        expect(cmd).toBeDefined();
+        expect(cmd.navigateBefore).toBe(false);
+    });
+});

package/clis/rednote/note.js

@@ -0,0 +1,68 @@
+/**
+ * Rednote note — international mirror of xiaohongshu/note.
+ * Reuses the DOM-extraction IIFE from `../xiaohongshu/note.js`; only the
+ * web host and cookie root differ.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { NOTE_EXTRACT_JS } from '../xiaohongshu/note.js';
+import { buildNoteUrl, parseNoteId } from '../xiaohongshu/note-helpers.js';
+
+const REDNOTE_SIGNED_URL_HINT = 'Pass a full rednote.com note URL with xsec_token from search results or user/profile context.';
+
+cli({
+    site: 'rednote',
+    name: 'note',
+    access: 'read',
+    description: 'Read note body and engagement counts from a rednote note',
+    domain: 'www.rednote.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        { name: 'note-id', required: true, positional: true, help: 'Full rednote note URL with xsec_token' },
+    ],
+    columns: ['field', 'value'],
+    func: async (page, kwargs) => {
+        const raw = String(kwargs['note-id']);
+        const noteId = parseNoteId(raw);
+        const url = buildNoteUrl(raw, {
+            commandName: 'rednote note',
+            cookieRoot: 'rednote.com',
+            signedUrlHint: REDNOTE_SIGNED_URL_HINT,
+        });
+        await page.goto(url);
+        await page.wait({ time: 2 + Math.random() * 3 });
+        const data = await page.evaluate(NOTE_EXTRACT_JS);
+        if (!data || typeof data !== 'object') {
+            throw new EmptyResultError('rednote/note', 'Unexpected evaluate response');
+        }
+        if (data.securityBlock) {
+            throw new CommandExecutionError('Rednote security block: the note detail page was blocked by risk control.', /^https?:\/\//.test(raw)
+                ? 'The page may be temporarily restricted. Try again later or from a different session.'
+                : 'Try using a full URL from search results (with xsec_token) instead of a bare note ID.');
+        }
+        if (data.loginWall) {
+            throw new AuthRequiredError('www.rednote.com', 'Note content requires login');
+        }
+        if (data.notFound) {
+            throw new EmptyResultError('rednote/note', `Note ${noteId} not found or unavailable — it may have been deleted or restricted`);
+        }
+        const d = data;
+        const numOrZero = (v) => /^\d+/.test(v) ? v : '0';
+        if (!d.title && !d.author) {
+            throw new EmptyResultError('rednote/note', 'The note page loaded without visible content. The note may be deleted or restricted.');
+        }
+        const rows = [
+            { field: 'title', value: d.title || '' },
+            { field: 'author', value: d.author || '' },
+            { field: 'content', value: d.desc || '' },
+            { field: 'likes', value: numOrZero(d.likes || '') },
+            { field: 'collects', value: numOrZero(d.collects || '') },
+            { field: 'comments', value: numOrZero(d.comments || '') },
+        ];
+        if (d.tags?.length) {
+            rows.push({ field: 'tags', value: d.tags.join(', ') });
+        }
+        return rows;
+    },
+});

package/clis/rednote/notifications.js

@@ -0,0 +1,139 @@
+/**
+ * Rednote notifications — calls `notification.getNotification(type)` and reads
+ * `notification.activeTabMessageList` from the Pinia store.
+ *
+ * Differs from xiaohongshu/notifications because the rednote intercept tap
+ * does not see a fresh `/you/` request after `getNotification`. The store is
+ * populated directly, so a `func`-mode read is more reliable. Field names
+ * accept both snake_case (`user_info.nickname`) and camelCase
+ * (`userInfo.nickName`) to absorb the same SSR client-transform diff that
+ * `feed` hits on rednote.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+const NOTIFICATION_TYPES = new Set(['mentions', 'likes', 'connections']);
+
+function parseNotificationType(raw) {
+    const type = String(raw ?? 'mentions');
+    if (!NOTIFICATION_TYPES.has(type)) {
+        throw new ArgumentError(`--type must be one of mentions, likes, or connections, got ${JSON.stringify(raw)}`);
+    }
+    return type;
+}
+
+function parseLimit(raw) {
+    const parsed = Number(raw ?? 20);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`--limit must be a positive integer, got ${JSON.stringify(raw)}`);
+    }
+    if (parsed < 1) {
+        throw new ArgumentError(`--limit must be a positive integer, got ${parsed}`);
+    }
+    return parsed;
+}
+
+const READ_NOTIFICATIONS_JS = `
+  (async (type) => {
+    let pinia = null;
+    const probe = (el) => el?.__vue_app__?.config?.globalProperties?.$pinia ?? null;
+    pinia = probe(document.querySelector('#app'));
+    if (!pinia) {
+      for (const el of document.querySelectorAll('*')) {
+        pinia = probe(el);
+        if (pinia) break;
+      }
+    }
+    if (!pinia || !pinia._s) return { error: 'no_pinia' };
+    const store = pinia._s.get('notification');
+    if (!store) return { error: 'no_notification_store' };
+    if (typeof store.getNotification !== 'function') return { error: 'no_getNotification_action' };
+    try { await store.getNotification(type); } catch (e) { return { error: 'action_failed', detail: e?.message }; }
+    // Read messages from whichever store path is populated. rednote keeps the
+    // current tab in activeTabMessageList but may instead drop the list into
+    // notificationMap[type] (or notificationMap[type].messages) depending on
+    // the build, so check both before timing out.
+    const readMessages = () => {
+      if (Array.isArray(store.activeTabMessageList) && store.activeTabMessageList.length > 0) return store.activeTabMessageList;
+      const tab = store.notificationMap?.[type];
+      if (Array.isArray(tab) && tab.length > 0) return tab;
+      if (Array.isArray(tab?.messages) && tab.messages.length > 0) return tab.messages;
+      if (Array.isArray(tab?.messageList) && tab.messageList.length > 0) return tab.messageList;
+      return null;
+    };
+    let messages = null;
+    for (let i = 0; i < 16; i++) {
+      messages = readMessages();
+      if (messages) break;
+      await new Promise(r => setTimeout(r, 500));
+    }
+    const arr = messages ?? (Array.isArray(store.activeTabMessageList) ? store.activeTabMessageList : []);
+    const pick = (item, snake, camel) => item?.[snake] ?? item?.[camel];
+    // Try the leaf as written, plus its snake→camel and camel→snake variants.
+    // Needed because rednote ships e.g. \`userInfo.nickName\` while xhs returns
+    // \`user_info.nickname\` (or \`user_info.nick_name\`); the field name varies
+    // independently of the wrapping object name.
+    const leafVariants = (leaf) => {
+      const camel = leaf.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+      const snake = leaf.replace(/([A-Z])/g, (_, c) => '_' + c.toLowerCase());
+      const capCamel = leaf.charAt(0) + leaf.slice(1).replace(/([a-z])([A-Z])/g, '$1$2').replace(/(^|_)([a-z])/g, (_, sep, c) => (sep ? c.toUpperCase() : c));
+      return [...new Set([leaf, camel, snake, capCamel])];
+    };
+    const nested = (item, snake, camel, ...leafCandidates) => {
+      const a = pick(item, snake, camel);
+      if (!a || typeof a !== 'object') return '';
+      for (const candidate of leafCandidates) {
+        for (const variant of leafVariants(candidate)) {
+          if (a[variant] != null && a[variant] !== '') return a[variant];
+        }
+      }
+      return '';
+    };
+    return {
+      items: arr.map(item => ({
+        user: nested(item, 'user_info', 'userInfo', 'nickname', 'nickName'),
+        action: item?.title ?? item?.actionTitle ?? '',
+        content: nested(item, 'comment_info', 'commentInfo', 'content'),
+        note: nested(item, 'item_info', 'itemInfo', 'content'),
+        time: item?.time ?? item?.timestamp ?? '',
+      })),
+    };
+  })(${JSON.stringify('PLACEHOLDER_TYPE')})
+`;
+
+export const command = cli({
+    site: 'rednote',
+    name: 'notifications',
+    access: 'read',
+    description: 'Rednote notifications (mentions/likes/connections)',
+    domain: 'www.rednote.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'type',
+            default: 'mentions',
+            help: 'Notification type: mentions, likes, or connections',
+        },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of notifications to return' },
+    ],
+    columns: ['rank', 'user', 'action', 'content', 'note', 'time'],
+    func: async (page, kwargs) => {
+        const type = parseNotificationType(kwargs.type);
+        const limit = parseLimit(kwargs.limit);
+        await page.goto('https://www.rednote.com/notification');
+        await page.wait({ time: 2 });
+        const script = READ_NOTIFICATIONS_JS.replace(JSON.stringify('PLACEHOLDER_TYPE'), JSON.stringify(type));
+        const data = await page.evaluate(script);
+        if (!data || typeof data !== 'object') {
+            throw new CommandExecutionError('rednote notifications: unexpected evaluate response');
+        }
+        if (data.error) {
+            throw new CommandExecutionError(`rednote notifications: ${data.error}${data.detail ? ' (' + data.detail + ')' : ''}`, 'The rednote SPA may still be hydrating; reload www.rednote.com/notification and retry.');
+        }
+        return (data.items || [])
+            .slice(0, limit)
+            .map((row, i) => ({ rank: i + 1, ...row }));
+    },
+});