@jackwener/opencli 1.7.22 → 1.8.1

package/clis/notebooklm/utils.test.js

@@ -1,6 +1,40 @@
 import { describe, expect, it } from 'vitest';
-import { buildNotebooklmRpcBody, classifyNotebooklmPage, extractNotebooklmHistoryPreview, extractNotebooklmRpcResult, getNotebooklmPageState, normalizeNotebooklmTitle, parseNotebooklmHistoryThreadIdsResult, parseNotebooklmIdFromUrl, parseNotebooklmListResult, parseNotebooklmNoteListRawRows, parseNotebooklmNotebookDetailResult, parseNotebooklmSourceFulltextResult, parseNotebooklmSourceGuideResult, parseNotebooklmSourceListResult, } from './utils.js';
+import { buildNotebooklmRpcBody, classifyNotebooklmPage, extractNotebooklmHistoryPreview, extractNotebooklmRpcResult, getNotebooklmPageState, isPlainObject, normalizeNotebooklmTitle, parseNotebooklmHistoryThreadIdsResult, parseNotebooklmIdFromUrl, parseNotebooklmListResult, parseNotebooklmNoteListRawRows, parseNotebooklmNotebookDetailResult, parseNotebooklmNotebookTarget, parseNotebooklmSourceFulltextResult, parseNotebooklmSourceGuideResult, parseNotebooklmSourceListResult, } from './utils.js';
+import { CliError } from '@jackwener/opencli/errors';
 describe('notebooklm utils', () => {
+    it('isPlainObject distinguishes objects from arrays / null / primitives', () => {
+        expect(isPlainObject({})).toBe(true);
+        expect(isPlainObject({ a: 1 })).toBe(true);
+        expect(isPlainObject([])).toBe(false);
+        expect(isPlainObject(null)).toBe(false);
+        expect(isPlainObject('x')).toBe(false);
+        expect(isPlainObject(0)).toBe(false);
+    });
+    it('parseNotebooklmNotebookTarget accepts canonical uuid input', () => {
+        const id = '17e2b882-aaaa-bbbb-cccc-abcdef012345';
+        expect(parseNotebooklmNotebookTarget(id)).toBe(id);
+    });
+    it('parseNotebooklmNotebookTarget accepts a notebook url with uuid', () => {
+        const id = '17e2b882-aaaa-bbbb-cccc-abcdef012345';
+        expect(parseNotebooklmNotebookTarget(`https://notebooklm.google.com/notebook/${id}?pli=1`)).toBe(id);
+    });
+    it('parseNotebooklmNotebookTarget rejects non-uuid bare ids', () => {
+        expect(() => parseNotebooklmNotebookTarget('nb-demo')).toThrow(CliError);
+    });
+    it('parseNotebooklmNotebookTarget rejects malformed notebook urls', () => {
+        expect(() => parseNotebooklmNotebookTarget('https://notebooklm.google.com/notebook/not-a-uuid')).toThrow(CliError);
+    });
+    it('parseNotebooklmNotebookTarget rejects off-domain or non-canonical notebook urls', () => {
+        const id = '17e2b882-aaaa-bbbb-cccc-abcdef012345';
+        expect(() => parseNotebooklmNotebookTarget(`https://evil.test/notebook/${id}`)).toThrow(CliError);
+        expect(() => parseNotebooklmNotebookTarget(`http://notebooklm.google.com/notebook/${id}`)).toThrow(CliError);
+        expect(() => parseNotebooklmNotebookTarget(`https://notebooklm.google.com:444/notebook/${id}`)).toThrow(CliError);
+        expect(() => parseNotebooklmNotebookTarget(`https://user:notsecret@notebooklm.google.com/notebook/${id}`)).toThrow(CliError);
+    });
+    it('parseNotebooklmNotebookTarget rejects empty input', () => {
+        expect(() => parseNotebooklmNotebookTarget('')).toThrow(CliError);
+        expect(() => parseNotebooklmNotebookTarget('   ')).toThrow(CliError);
+    });
     it('parses notebook id from a notebook url', () => {
         expect(parseNotebooklmIdFromUrl('https://notebooklm.google.com/notebook/abc-123')).toBe('abc-123');
     });
@@ -387,4 +421,29 @@ describe('notebooklm utils', () => {
             notebookCount: 0,
         });
     });
+    it('reads page state through Browser Bridge evaluate envelopes', async () => {
+        const page = {
+            evaluate: async () => ({
+                session: 'site:notebooklm:abc',
+                data: {
+                    url: 'https://notebooklm.google.com/notebook/nb-demo',
+                    title: 'Demo Notebook - NotebookLM',
+                    hostname: 'notebooklm.google.com',
+                    kind: 'notebook',
+                    notebookId: 'nb-demo',
+                    loginRequired: false,
+                    notebookCount: 0,
+                },
+            }),
+        };
+        await expect(getNotebooklmPageState(page)).resolves.toEqual({
+            url: 'https://notebooklm.google.com/notebook/nb-demo',
+            title: 'Demo Notebook - NotebookLM',
+            hostname: 'notebooklm.google.com',
+            kind: 'notebook',
+            notebookId: 'nb-demo',
+            loginRequired: false,
+            notebookCount: 0,
+        });
+    });
 });

package/clis/notebooklm/write-note.js

@@ -0,0 +1,103 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { callNotebooklmRpc } from './rpc.js';
+import { buildNotebooklmNotebookUrl, ensureNotebooklmHome, parseNotebooklmNotebookTarget, requireNotebooklmExecute, requireNotebooklmSession } from './utils.js';
+
+const NOTEBOOKLM_CREATE_NOTE_RPC_ID = 'CYK0Xb';
+const NOTEBOOKLM_MUTATE_NOTE_RPC_ID = 'cYAfTb';
+const MAX_TITLE_LEN = 200;
+const MAX_CONTENT_LEN = 1_000_000;
+const NOTE_UUID_RE = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+
+export function parseNoteTitle(value) {
+    const title = String(value ?? '').trim();
+    if (!title) throw new ArgumentError('--title is required');
+    if (title.length > MAX_TITLE_LEN) {
+        throw new ArgumentError(`--title must be at most ${MAX_TITLE_LEN} characters (got ${title.length})`);
+    }
+    return title;
+}
+
+export function parseNoteContent(value) {
+    const content = String(value ?? '');
+    if (!content) throw new ArgumentError('--content is required');
+    if (content.length > MAX_CONTENT_LEN) {
+        throw new ArgumentError(`--content exceeds ${MAX_CONTENT_LEN} characters; split into smaller notes.`);
+    }
+    return content;
+}
+
+export function buildCreateNoteShellArgs(projectId) {
+    return [projectId, '', [1], null, 'New Note', null, [2]];
+}
+
+export function buildMutateNoteArgs(projectId, noteId, content, title) {
+    return [projectId, noteId, [[[content, title, [], 0]]], [2]];
+}
+
+function toExcludedUuidSet(excludedIds) {
+    return new Set(excludedIds.map((id) => String(id ?? '').toLowerCase()).filter(Boolean));
+}
+
+export function parseNoteIdFromResult(result, excludedIds = []) {
+    const excluded = toExcludedUuidSet(excludedIds);
+    if (typeof result === 'string') return NOTE_UUID_RE.test(result) && !excluded.has(result.toLowerCase()) ? result : '';
+    const stack = [result];
+    while (stack.length) {
+        const node = stack.shift();
+        if (typeof node === 'string') {
+            if (NOTE_UUID_RE.test(node) && !excluded.has(node.toLowerCase())) return node;
+            continue;
+        }
+        if (Array.isArray(node)) for (const child of node) stack.push(child);
+        else if (node && typeof node === 'object') for (const v of Object.values(node)) stack.push(v);
+    }
+    return '';
+}
+
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'write-note',
+    access: 'write',
+    description: 'Create a Studio note in an existing NotebookLM notebook with the given title and Markdown content',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'notebook', positional: true, required: true, help: 'Notebook id from `notebooklm list` or full notebook URL' },
+        { name: 'title', required: true, help: 'Note title (1-200 chars)' },
+        { name: 'content', required: true, help: 'Note body as Markdown' },
+        { name: 'execute', type: 'boolean', help: 'Actually create the remote NotebookLM note' },
+    ],
+    columns: ['notebook_id', 'note_id', 'title', 'notebook_url'],
+    func: async (page, kwargs) => {
+        const notebookId = parseNotebooklmNotebookTarget(String(kwargs.notebook ?? ''));
+        const title = parseNoteTitle(kwargs.title);
+        const content = parseNoteContent(kwargs.content);
+        requireNotebooklmExecute(kwargs.execute, 'create a NotebookLM note');
+        await ensureNotebooklmHome(page);
+        await requireNotebooklmSession(page);
+        const shellRpc = await callNotebooklmRpc(page, NOTEBOOKLM_CREATE_NOTE_RPC_ID, buildCreateNoteShellArgs(notebookId));
+        const noteId = parseNoteIdFromResult(shellRpc.result, [notebookId]);
+        if (!noteId) {
+            throw new CommandExecutionError('NotebookLM CreateNote RPC returned no note id');
+        }
+        await callNotebooklmRpc(page, NOTEBOOKLM_MUTATE_NOTE_RPC_ID, buildMutateNoteArgs(notebookId, noteId, content, title));
+        return [{
+            notebook_id: notebookId,
+            note_id: noteId,
+            title,
+            notebook_url: buildNotebooklmNotebookUrl(notebookId),
+        }];
+    },
+});
+
+export const __test__ = {
+    parseNoteTitle,
+    parseNoteContent,
+    buildCreateNoteShellArgs,
+    buildMutateNoteArgs,
+    parseNoteIdFromResult,
+};

package/clis/notebooklm/write-note.test.js

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './write-note.js';
+
+const { parseNoteTitle, parseNoteContent, buildCreateNoteShellArgs, buildMutateNoteArgs, parseNoteIdFromResult } = __test__;
+
+describe('notebooklm write-note', () => {
+    it('parseNoteTitle accepts 1-200 char titles', () => {
+        expect(parseNoteTitle('Note A')).toBe('Note A');
+        expect(parseNoteTitle('  spaced  ')).toBe('spaced');
+        expect(parseNoteTitle('x'.repeat(200))).toHaveLength(200);
+    });
+
+    it('parseNoteTitle rejects empty / too-long titles', () => {
+        expect(() => parseNoteTitle('')).toThrow(ArgumentError);
+        expect(() => parseNoteTitle('   ')).toThrow(ArgumentError);
+        expect(() => parseNoteTitle('x'.repeat(201))).toThrow(ArgumentError);
+    });
+
+    it('parseNoteContent accepts non-empty content', () => {
+        expect(parseNoteContent('# heading\n\nbody')).toBe('# heading\n\nbody');
+    });
+
+    it('parseNoteContent rejects empty content', () => {
+        expect(() => parseNoteContent('')).toThrow(ArgumentError);
+        expect(() => parseNoteContent(undefined)).toThrow(ArgumentError);
+    });
+
+    it('buildCreateNoteShellArgs matches the HAR-verified wire format', () => {
+        expect(buildCreateNoteShellArgs('nb-123')).toEqual([
+            'nb-123', '', [1], null, 'New Note', null, [2],
+        ]);
+    });
+
+    it('buildMutateNoteArgs puts content before title in the inner tuple', () => {
+        expect(buildMutateNoteArgs('nb-123', 'note-7', 'body content', 'title-x')).toEqual([
+            'nb-123', 'note-7', [[['body content', 'title-x', [], 0]]], [2],
+        ]);
+    });
+
+    it('parseNoteIdFromResult walks the tree for the note-id UUID', () => {
+        const id = '0312fc89-075e-4b3a-810d-141fc8d5af6d';
+        expect(parseNoteIdFromResult([[[ [id] ]]])).toBe(id);
+        expect(parseNoteIdFromResult({ shell: { noteId: id } })).toBe(id);
+    });
+
+    it('parseNoteIdFromResult ignores non-UUID strings', () => {
+        expect(parseNoteIdFromResult([ 'project-id', 'not-a-uuid' ])).toBe('');
+        expect(parseNoteIdFromResult(null)).toBe('');
+        expect(parseNoteIdFromResult([])).toBe('');
+    });
+
+    it('parseNoteIdFromResult skips the input notebook id before selecting the created note id', () => {
+        const notebookId = '17e2b882-6a01-4c6c-9262-0738dfa2abee';
+        const noteId = '0312fc89-075e-4b3a-810d-141fc8d5af6d';
+        expect(parseNoteIdFromResult([notebookId, [[noteId]]], [notebookId])).toBe(noteId);
+    });
+
+    it('refuses to create a remote note without --execute', async () => {
+        const command = getRegistry().get('notebooklm/write-note');
+        const page = { goto: vi.fn() };
+        await expect(command.func(page, {
+            notebook: '17e2b882-6a01-4c6c-9262-0738dfa2abee',
+            title: 'Draft note',
+            content: 'body',
+        })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+});

package/clis/pixiv/detail.js

@@ -1,4 +1,21 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { pixivFetch } from './utils.js';
+
+function requireIllustBody(body, id) {
+    if (!body || Array.isArray(body) || typeof body !== 'object') {
+        throw new CommandExecutionError(`Pixiv illustration ${id} returned malformed detail payload`);
+    }
+    const illustId = String(body.illustId ?? '').trim();
+    const title = String(body.illustTitle ?? '').trim();
+    const userName = String(body.userName ?? '').trim();
+    const userId = String(body.userId ?? '').trim();
+    if (!/^\d+$/.test(illustId) || illustId !== id || !title || !userName || !/^\d+$/.test(userId)) {
+        throw new CommandExecutionError(`Pixiv illustration ${id} returned malformed detail payload`);
+    }
+    return { ...body, illustId, illustTitle: title, userName, userId };
+}
+
 cli({
     site: 'pixiv',
     name: 'detail',
@@ -6,7 +23,6 @@ cli({
     description: 'View illustration details (tags, stats, URLs)',
     domain: 'www.pixiv.net',
     strategy: Strategy.COOKIE,
-    browser: true,
     args: [
         { name: 'id', required: true, positional: true, help: 'Illustration ID' },
     ],
@@ -23,37 +39,28 @@ cli({
         'created',
         'url',
     ],
-    pipeline: [
-        { navigate: 'https://www.pixiv.net' },
-        { evaluate: `(async () => {
-  const id = \${{ args.id | json }};
-  const res = await fetch(
-    'https://www.pixiv.net/ajax/illust/' + id,
-    { credentials: 'include' }
-  );
-  if (!res.ok) {
-    if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
-    if (res.status === 404) throw new Error('Illustration not found: ' + id);
-    throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
-  }
-  const data = await res.json();
-  const b = data?.body;
-  if (!b) throw new Error('Illustration not found');
-  return [{
-    illust_id: b.illustId,
-    title: b.illustTitle,
-    author: b.userName,
-    user_id: b.userId,
-    type: b.illustType === 0 ? 'illust' : b.illustType === 1 ? 'manga' : b.illustType === 2 ? 'ugoira' : String(b.illustType),
-    pages: b.pageCount,
-    bookmarks: b.bookmarkCount,
-    likes: b.likeCount,
-    views: b.viewCount,
-    tags: (b.tags?.tags || []).map(t => t.tag).join(', '),
-    created: b.createDate?.split('T')[0] || '',
-    url: 'https://www.pixiv.net/artworks/' + b.illustId
-  }];
-})()
-` },
-    ],
+    func: async (page, kwargs) => {
+        const id = String(kwargs.id ?? '');
+        if (!/^\d+$/.test(id)) {
+            throw new ArgumentError(`Invalid illustration ID: ${id}`, 'Example: opencli pixiv detail 123456');
+        }
+        const body = await pixivFetch(page, `/ajax/illust/${id}`, {
+            notFoundMsg: `Illustration not found: ${id}`,
+        });
+        const b = requireIllustBody(body, id);
+        return [{
+            illust_id: b.illustId,
+            title: b.illustTitle,
+            author: b.userName,
+            user_id: b.userId,
+            type: b.illustType === 0 ? 'illust' : b.illustType === 1 ? 'manga' : b.illustType === 2 ? 'ugoira' : String(b.illustType),
+            pages: b.pageCount,
+            bookmarks: b.bookmarkCount,
+            likes: b.likeCount,
+            views: b.viewCount,
+            tags: (b.tags?.tags || []).map(t => t.tag).join(', '),
+            created: b.createDate?.split('T')[0] || '',
+            url: `https://www.pixiv.net/artworks/${b.illustId}`,
+        }];
+    },
 });

package/clis/pixiv/detail.test.js

@@ -0,0 +1,93 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { createPageMock } from '../test-utils.js';
+import './detail.js';
+let cmd;
+beforeAll(() => {
+    cmd = getRegistry().get('pixiv/detail');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+describe('pixiv detail', () => {
+    it('throws ArgumentError on invalid illustration ID before navigation', async () => {
+        const page = createPageMock([]);
+        await expect(cmd.func(page, { id: 'xyz' })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('throws AuthRequiredError on 401', async () => {
+        const page = createPageMock([{ __httpError: 401 }]);
+        await expect(cmd.func(page, { id: '12345' })).rejects.toThrow(AuthRequiredError);
+    });
+    it('throws CommandExecutionError on 404', async () => {
+        const page = createPageMock([{ __httpError: 404 }]);
+        await expect(cmd.func(page, { id: '12345' })).rejects.toThrow(CommandExecutionError);
+    });
+    it('throws CommandExecutionError on non-auth HTTP failure', async () => {
+        const page = createPageMock([{ __httpError: 500 }]);
+        await expect(cmd.func(page, { id: '12345' })).rejects.toThrow(CommandExecutionError);
+    });
+    it('surfaces HTTP error body messages from pixivFetch', async () => {
+        const page = createPageMock([{ __httpError: 429, message: 'Too many requests' }]);
+        await expect(cmd.func(page, { id: '12345' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('Too many requests'),
+        });
+    });
+    it('fails typed when the detail body lacks stable illustration identity fields', async () => {
+        const page = createPageMock([{ body: { illustId: '12345', illustTitle: 'Title' } }]);
+        await expect(cmd.func(page, { id: '12345' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('malformed detail payload'),
+        });
+    });
+    it('fails typed when the detail body id does not match the requested illustration', async () => {
+        const page = createPageMock([
+            {
+                body: {
+                    illustId: '99999',
+                    illustTitle: 'Wrong',
+                    userName: 'Artist',
+                    userId: '99',
+                },
+            },
+        ]);
+        await expect(cmd.func(page, { id: '12345' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('malformed detail payload'),
+        });
+    });
+    it('returns detail row with mapped fields', async () => {
+        const page = createPageMock([
+            {
+                body: {
+                    illustId: '12345',
+                    illustTitle: 'Test Illust',
+                    userName: 'Test Artist',
+                    userId: '99',
+                    illustType: 1,
+                    pageCount: 4,
+                    bookmarkCount: 200,
+                    likeCount: 100,
+                    viewCount: 5000,
+                    tags: { tags: [{ tag: 'original' }, { tag: 'fantasy' }] },
+                    createDate: '2025-01-15T12:00:00+09:00',
+                },
+            },
+        ]);
+        const result = await cmd.func(page, { id: '12345' });
+        expect(result).toEqual([{
+            illust_id: '12345',
+            title: 'Test Illust',
+            author: 'Test Artist',
+            user_id: '99',
+            type: 'manga',
+            pages: 4,
+            bookmarks: 200,
+            likes: 100,
+            views: 5000,
+            tags: 'original, fantasy',
+            created: '2025-01-15',
+            url: 'https://www.pixiv.net/artworks/12345',
+        }]);
+    });
+});

package/clis/pixiv/user.js

@@ -1,4 +1,18 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { pixivFetch } from './utils.js';
+
+function requireUserBody(body, uid) {
+    if (!body || Array.isArray(body) || typeof body !== 'object') {
+        throw new CommandExecutionError(`Pixiv user ${uid} returned malformed profile payload`);
+    }
+    const name = String(body.name ?? '').trim();
+    if (!name) {
+        throw new CommandExecutionError(`Pixiv user ${uid} returned malformed profile payload`);
+    }
+    return { ...body, name };
+}
+
 cli({
     site: 'pixiv',
     name: 'user',
@@ -6,7 +20,6 @@ cli({
     description: 'View Pixiv artist profile',
     domain: 'www.pixiv.net',
     strategy: Strategy.COOKIE,
-    browser: true,
     args: [
         { name: 'uid', required: true, positional: true, help: 'Pixiv user ID' },
     ],
@@ -21,34 +34,26 @@ cli({
         'comment',
         'url',
     ],
-    pipeline: [
-        { navigate: 'https://www.pixiv.net' },
-        { evaluate: `(async () => {
-  const uid = \${{ args.uid | json }};
-  const res = await fetch(
-    'https://www.pixiv.net/ajax/user/' + uid + '?full=1',
-    { credentials: 'include' }
-  );
-  if (!res.ok) {
-    if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
-    if (res.status === 404) throw new Error('User not found: ' + uid);
-    throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
-  }
-  const data = await res.json();
-  const b = data?.body;
-  if (!b) throw new Error('User not found');
-  return [{
-    user_id: uid,
-    name: b.name,
-    premium: b.premium ? 'Yes' : 'No',
-    following: b.following,
-    illusts: typeof b.illusts === 'object' ? Object.keys(b.illusts).length : (b.illusts || 0),
-    manga: typeof b.manga === 'object' ? Object.keys(b.manga).length : (b.manga || 0),
-    novels: typeof b.novels === 'object' ? Object.keys(b.novels).length : (b.novels || 0),
-    comment: (b.comment || '').slice(0, 80),
-    url: 'https://www.pixiv.net/users/' + uid
-  }];
-})()
-` },
-    ],
+    func: async (page, kwargs) => {
+        const uid = String(kwargs.uid ?? '');
+        if (!/^\d+$/.test(uid)) {
+            throw new ArgumentError(`Invalid user ID: ${uid}`, 'Example: opencli pixiv user 123456');
+        }
+        const body = await pixivFetch(page, `/ajax/user/${uid}`, {
+            params: { full: 1 },
+            notFoundMsg: `User not found: ${uid}`,
+        });
+        const b = requireUserBody(body, uid);
+        return [{
+            user_id: uid,
+            name: b.name,
+            premium: b.premium ? 'Yes' : 'No',
+            following: b.following,
+            illusts: typeof b.illusts === 'object' ? Object.keys(b.illusts).length : (b.illusts || 0),
+            manga: typeof b.manga === 'object' ? Object.keys(b.manga).length : (b.manga || 0),
+            novels: typeof b.novels === 'object' ? Object.keys(b.novels).length : (b.novels || 0),
+            comment: (b.comment || '').slice(0, 80),
+            url: `https://www.pixiv.net/users/${uid}`,
+        }];
+    },
 });

package/clis/pixiv/user.test.js

@@ -0,0 +1,100 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { createPageMock } from '../test-utils.js';
+import './user.js';
+let cmd;
+beforeAll(() => {
+    cmd = getRegistry().get('pixiv/user');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+describe('pixiv user', () => {
+    it('throws ArgumentError on invalid user ID before navigation', async () => {
+        const page = createPageMock([]);
+        await expect(cmd.func(page, { uid: 'abc' })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('throws AuthRequiredError on 401', async () => {
+        const page = createPageMock([{ __httpError: 401 }]);
+        await expect(cmd.func(page, { uid: '11' })).rejects.toThrow(AuthRequiredError);
+    });
+    it('throws CommandExecutionError on 404', async () => {
+        const page = createPageMock([{ __httpError: 404 }]);
+        await expect(cmd.func(page, { uid: '11' })).rejects.toThrow(CommandExecutionError);
+    });
+    it('throws CommandExecutionError on non-auth HTTP failure', async () => {
+        const page = createPageMock([{ __httpError: 500 }]);
+        await expect(cmd.func(page, { uid: '11' })).rejects.toThrow(CommandExecutionError);
+    });
+    it('unwraps Browser Bridge envelopes around Pixiv API payloads', async () => {
+        const page = createPageMock([
+            {
+                session: 'site:pixiv',
+                data: {
+                    body: {
+                        name: 'Envelope Artist',
+                        premium: false,
+                        following: 0,
+                        illusts: {},
+                        manga: {},
+                        novels: {},
+                    },
+                },
+            },
+        ]);
+        const result = await cmd.func(page, { uid: '12' });
+        expect(result[0]).toMatchObject({
+            user_id: '12',
+            name: 'Envelope Artist',
+            premium: 'No',
+        });
+    });
+    it('surfaces Pixiv API error bodies instead of treating them as not found', async () => {
+        const page = createPageMock([{ error: true, message: 'rate limited' }]);
+        await expect(cmd.func(page, { uid: '11' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: 'rate limited',
+        });
+    });
+    it('fails typed on malformed Pixiv API payloads', async () => {
+        const page = createPageMock([{ ok: true }]);
+        await expect(cmd.func(page, { uid: '11' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('malformed API payload'),
+        });
+    });
+    it('fails typed when the user body lacks stable profile identity fields', async () => {
+        const page = createPageMock([{ body: { premium: false, following: 0 } }]);
+        await expect(cmd.func(page, { uid: '11' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('malformed profile payload'),
+        });
+    });
+    it('returns profile row with computed counts for object-shaped illust fields', async () => {
+        const page = createPageMock([
+            {
+                body: {
+                    name: 'Test Artist',
+                    premium: true,
+                    following: 42,
+                    illusts: { '111': null, '222': null, '333': null },
+                    manga: {},
+                    novels: { '999': null },
+                    comment: 'Hello world',
+                },
+            },
+        ]);
+        const result = await cmd.func(page, { uid: '11' });
+        expect(result).toEqual([{
+            user_id: '11',
+            name: 'Test Artist',
+            premium: 'Yes',
+            following: 42,
+            illusts: 3,
+            manga: 0,
+            novels: 1,
+            comment: 'Hello world',
+            url: 'https://www.pixiv.net/users/11',
+        }]);
+    });
+});