@jackwener/opencli 1.3.3 → 1.4.0

package/dist/clis/pixiv/download.js

@@ -0,0 +1,78 @@
+/**
+ * Pixiv download — download all images from an illustration.
+ *
+ * Pixiv's CDN (i.pximg.net) requires Referer: https://www.pixiv.net/ header.
+ * Uses the /ajax/illust/{id}/pages API to get original-quality image URLs.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { formatCookieHeader, httpDownload } from '../../download/index.js';
+import { formatBytes } from '../../download/progress.js';
+import { CommandExecutionError, getErrorMessage } from '../../errors.js';
+import { pixivFetch } from './utils.js';
+cli({
+    site: 'pixiv',
+    name: 'download',
+    description: 'Download illustration images from Pixiv',
+    domain: 'www.pixiv.net',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'illust-id', positional: true, required: true, help: 'Illustration ID' },
+        { name: 'output', default: './pixiv-downloads', help: 'Output directory' },
+    ],
+    columns: ['index', 'type', 'status', 'size'],
+    func: async (page, kwargs) => {
+        const illustId = String(kwargs['illust-id'] ?? '');
+        const output = String(kwargs.output ?? './pixiv-downloads');
+        if (!/^\d+$/.test(illustId)) {
+            throw new CommandExecutionError(`Invalid illustration ID: ${illustId}`);
+        }
+        // pixivFetch handles navigate + error checking; returns the response body directly
+        const pages = await pixivFetch(page, `/ajax/illust/${illustId}/pages`, {
+            notFoundMsg: `Illustration not found: ${illustId}`,
+        }) || [];
+        if (pages.length === 0) {
+            return [{ index: 0, type: '-', status: 'failed', size: 'No images found' }];
+        }
+        // Extract cookies for authenticated downloads
+        const cookies = formatCookieHeader(await page.getCookies({ domain: 'pixiv.net' }));
+        // Create output directory
+        const outputDir = path.join(output, illustId);
+        fs.mkdirSync(outputDir, { recursive: true });
+        const results = [];
+        for (let i = 0; i < pages.length; i++) {
+            const p = pages[i];
+            const url = p.urls?.original || p.urls?.regular || '';
+            if (!url) {
+                results.push({ index: i + 1, type: 'image', status: 'failed', size: 'No URL' });
+                continue;
+            }
+            try {
+                const ext = path.extname(new URL(url).pathname) || '.jpg';
+                const filename = `${illustId}_p${i}${ext}`;
+                const destPath = path.join(outputDir, filename);
+                const result = await httpDownload(url, destPath, {
+                    cookies,
+                    headers: { Referer: 'https://www.pixiv.net/' },
+                    timeout: 60000,
+                });
+                results.push({
+                    index: i + 1,
+                    type: 'image',
+                    status: result.success ? 'success' : 'failed',
+                    size: result.success ? formatBytes(result.size) : (result.error || 'unknown error'),
+                });
+            }
+            catch (err) {
+                results.push({
+                    index: i + 1,
+                    type: 'image',
+                    status: 'failed',
+                    size: getErrorMessage(err),
+                });
+            }
+        }
+        return results;
+    },
+});

package/dist/clis/pixiv/download.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/pixiv/download.test.js

@@ -0,0 +1,87 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { createPageMock } from './test-utils.js';
+// Mock download dependencies before importing the adapter
+const { mockHttpDownload, mockMkdirSync } = vi.hoisted(() => ({
+    mockHttpDownload: vi.fn(),
+    mockMkdirSync: vi.fn(),
+}));
+vi.mock('../../download/index.js', () => ({
+    formatCookieHeader: vi.fn().mockReturnValue('cookie=value'),
+    httpDownload: mockHttpDownload,
+}));
+vi.mock('node:fs', () => ({
+    mkdirSync: mockMkdirSync,
+}));
+// Now import the adapter (after mocks are set up)
+await import('./download.js');
+let cmd;
+beforeAll(() => {
+    cmd = getRegistry().get('pixiv/download');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+describe('pixiv download', () => {
+    beforeEach(() => {
+        mockHttpDownload.mockReset();
+        mockMkdirSync.mockReset();
+    });
+    it('throws CommandExecutionError on invalid illust ID', async () => {
+        const page = createPageMock([]);
+        await expect(cmd.func(page, { 'illust-id': 'abc', output: '/tmp/test' })).rejects.toThrow(CommandExecutionError);
+    });
+    it('throws AuthRequiredError on 403', async () => {
+        const page = createPageMock([{ __httpError: 403 }]);
+        await expect(cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' })).rejects.toThrow(AuthRequiredError);
+    });
+    it('throws CommandExecutionError on 404', async () => {
+        const page = createPageMock([{ __httpError: 404 }]);
+        await expect(cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' })).rejects.toThrow(CommandExecutionError);
+    });
+    it('throws CommandExecutionError on non-auth HTTP failure', async () => {
+        const page = createPageMock([{ __httpError: 500 }]);
+        await expect(cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' })).rejects.toThrow(CommandExecutionError);
+    });
+    it('returns failure when no images found', async () => {
+        const page = createPageMock([{ body: [] }]);
+        const result = (await cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' }));
+        expect(result).toEqual([{ index: 0, type: '-', status: 'failed', size: 'No images found' }]);
+    });
+    it('downloads images with Referer header', async () => {
+        mockHttpDownload.mockResolvedValue({ success: true, size: 1024000 });
+        const page = createPageMock([
+            {
+                body: [
+                    { urls: { original: 'https://i.pximg.net/img-original/img/2025/01/01/00/00/00/12345_p0.png' } },
+                    { urls: { original: 'https://i.pximg.net/img-original/img/2025/01/01/00/00/00/12345_p1.jpg' } },
+                ],
+            },
+        ]);
+        const result = (await cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' }));
+        expect(result).toHaveLength(2);
+        expect(result[0]).toMatchObject({ index: 1, type: 'image', status: 'success' });
+        expect(result[1]).toMatchObject({ index: 2, type: 'image', status: 'success' });
+        // Verify Referer header was passed
+        expect(mockHttpDownload).toHaveBeenCalledTimes(2);
+        const firstCallOpts = mockHttpDownload.mock.calls[0][2];
+        expect(firstCallOpts.headers).toEqual({ Referer: 'https://www.pixiv.net/' });
+    });
+    it('handles individual download failures gracefully', async () => {
+        mockHttpDownload
+            .mockResolvedValueOnce({ success: true, size: 512000 })
+            .mockRejectedValueOnce(new Error('Connection timeout'));
+        const page = createPageMock([
+            {
+                body: [
+                    { urls: { original: 'https://i.pximg.net/img/12345_p0.png' } },
+                    { urls: { original: 'https://i.pximg.net/img/12345_p1.png' } },
+                ],
+            },
+        ]);
+        const result = (await cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' }));
+        expect(result).toHaveLength(2);
+        expect(result[0].status).toBe('success');
+        expect(result[1].status).toBe('failed');
+        expect(result[1].size).toBe('Connection timeout');
+    });
+});

package/dist/clis/pixiv/illusts.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pixiv illusts — list illustrations by an artist.
+ *
+ * Two-step process:
+ * 1. Fetch all illust IDs from the user's profile
+ * 2. Batch-fetch details for the most recent ones (max 48 IDs per request)
+ */
+export {};

package/dist/clis/pixiv/illusts.js

@@ -0,0 +1,65 @@
+/**
+ * Pixiv illusts — list illustrations by an artist.
+ *
+ * Two-step process:
+ * 1. Fetch all illust IDs from the user's profile
+ * 2. Batch-fetch details for the most recent ones (max 48 IDs per request)
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+import { pixivFetch, BATCH_SIZE } from './utils.js';
+cli({
+    site: 'pixiv',
+    name: 'illusts',
+    description: "List a Pixiv artist's illustrations",
+    domain: 'www.pixiv.net',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'user-id', positional: true, required: true, help: 'Pixiv user ID' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'illust_id', 'pages', 'bookmarks', 'tags', 'created'],
+    func: async (page, kwargs) => {
+        const userId = String(kwargs['user-id'] ?? '');
+        const limit = Number(kwargs.limit) || 20;
+        if (!/^\d+$/.test(userId)) {
+            throw new CommandExecutionError(`Invalid user ID: ${userId}`);
+        }
+        // Step 1: get all illust IDs
+        const profileBody = await pixivFetch(page, `/ajax/user/${userId}/profile/all`, {
+            notFoundMsg: `User not found: ${userId}`,
+        });
+        const allIds = Object.keys(profileBody?.illusts || {})
+            .sort((a, b) => Number(b) - Number(a))
+            .slice(0, limit);
+        if (allIds.length === 0)
+            return [];
+        // Step 2: batch fetch details (Pixiv supports up to ~48 IDs per request)
+        const allWorks = {};
+        for (let offset = 0; offset < allIds.length; offset += BATCH_SIZE) {
+            const batch = allIds.slice(offset, offset + BATCH_SIZE);
+            const idsParam = batch.map(id => `ids[]=${id}`).join('&');
+            // pixivFetch navigates on each call; for subsequent batches we re-navigate,
+            // which is fine — the cookie is already attached.
+            const detailBody = await pixivFetch(page, `/ajax/user/${userId}/profile/illusts?${idsParam}&work_category=illustManga&is_first_page=${offset === 0 ? 1 : 0}`);
+            Object.assign(allWorks, detailBody?.works || {});
+        }
+        return allIds
+            .map((id, i) => {
+            const w = allWorks[id];
+            if (!w)
+                return null;
+            return {
+                rank: i + 1,
+                title: w.title || '',
+                illust_id: w.id,
+                pages: w.pageCount || 1,
+                bookmarks: w.bookmarkCount || 0,
+                tags: (w.tags || []).slice(0, 5).join(', '),
+                created: (w.createDate || '').split('T')[0],
+                url: 'https://www.pixiv.net/artworks/' + w.id,
+            };
+        })
+            .filter(Boolean);
+    },
+});

package/dist/clis/pixiv/illusts.test.d.ts

@@ -0,0 +1 @@
+import './illusts.js';

package/dist/clis/pixiv/illusts.test.js

@@ -0,0 +1,99 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { createPageMock } from './test-utils.js';
+import './illusts.js';
+let cmd;
+beforeAll(() => {
+    cmd = getRegistry().get('pixiv/illusts');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+describe('pixiv illusts', () => {
+    it('throws CommandExecutionError on invalid user ID', async () => {
+        const page = createPageMock([]);
+        await expect(cmd.func(page, { 'user-id': 'abc', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+    it('throws AuthRequiredError on 401', async () => {
+        const page = createPageMock([{ __httpError: 401 }]);
+        await expect(cmd.func(page, { 'user-id': '11', limit: 5 })).rejects.toThrow(AuthRequiredError);
+    });
+    it('throws generic error on non-auth HTTP failure', async () => {
+        const page = createPageMock([{ __httpError: 500 }]);
+        await expect(cmd.func(page, { 'user-id': '11', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+    it('returns empty array when user has no illusts', async () => {
+        const page = createPageMock([
+            { body: { illusts: {} } },
+        ]);
+        const result = await cmd.func(page, { 'user-id': '11', limit: 5 });
+        expect(result).toEqual([]);
+    });
+    it('fetches illust IDs then batch-fetches details', async () => {
+        const page = createPageMock([
+            // Step 1: profile/all returns illust IDs
+            {
+                body: {
+                    illusts: { '99999': null, '88888': null, '77777': null },
+                },
+            },
+            // Step 2: batch detail response
+            {
+                body: {
+                    works: {
+                        '99999': {
+                            id: '99999',
+                            title: 'Latest Work',
+                            pageCount: 2,
+                            bookmarkCount: 300,
+                            tags: ['original', 'fantasy'],
+                            createDate: '2025-01-15T12:00:00+09:00',
+                        },
+                        '88888': {
+                            id: '88888',
+                            title: 'Older Work',
+                            pageCount: 1,
+                            bookmarkCount: 150,
+                            tags: ['landscape'],
+                            createDate: '2024-12-01T10:00:00+09:00',
+                        },
+                    },
+                },
+            },
+        ]);
+        const result = (await cmd.func(page, { 'user-id': '11', limit: 3 }));
+        // Should be sorted newest first (99999 > 88888 > 77777)
+        expect(result).toHaveLength(2); // 77777 has no detail data, filtered out
+        expect(result[0]).toMatchObject({
+            rank: 1,
+            title: 'Latest Work',
+            illust_id: '99999',
+            pages: 2,
+            bookmarks: 300,
+            created: '2025-01-15',
+        });
+        expect(result[1]).toMatchObject({
+            rank: 2,
+            title: 'Older Work',
+            illust_id: '88888',
+        });
+    });
+    it('respects the limit on illust IDs fetched', async () => {
+        const page = createPageMock([
+            {
+                body: {
+                    illusts: { '100': null, '200': null, '300': null, '400': null, '500': null },
+                },
+            },
+            {
+                body: {
+                    works: {
+                        '500': { id: '500', title: 'W5', pageCount: 1, bookmarkCount: 0, tags: [], createDate: '' },
+                        '400': { id: '400', title: 'W4', pageCount: 1, bookmarkCount: 0, tags: [], createDate: '' },
+                    },
+                },
+            },
+        ]);
+        const result = (await cmd.func(page, { 'user-id': '11', limit: 2 }));
+        expect(result).toHaveLength(2);
+    });
+});

package/dist/clis/pixiv/ranking.yaml

@@ -0,0 +1,53 @@
+site: pixiv
+name: ranking
+description: Pixiv illustration rankings (daily/weekly/monthly)
+domain: www.pixiv.net
+strategy: cookie
+browser: true
+
+args:
+  mode:
+    type: str
+    default: daily
+    description: Ranking mode
+    choices: [daily, weekly, monthly, rookie, original, male, female, daily_r18, weekly_r18]
+  page:
+    type: int
+    default: 1
+    description: Page number
+  limit:
+    type: int
+    default: 20
+    description: Number of results
+
+pipeline:
+  - navigate: https://www.pixiv.net
+
+  - evaluate: |
+      (async () => {
+        const mode = ${{ args.mode | json }};
+        const page = ${{ args.page | json }};
+        const limit = ${{ args.limit | json }};
+        const res = await fetch(
+          'https://www.pixiv.net/ranking.php?mode=' + mode + '&p=' + page + '&format=json',
+          { credentials: 'include' }
+        );
+        if (!res.ok) {
+          if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
+          throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
+        }
+        const data = await res.json();
+        const items = (data?.contents || []).slice(0, limit);
+        return items.map((item, i) => ({
+          rank: item.rank,
+          title: item.title,
+          author: item.user_name,
+          user_id: item.user_id,
+          illust_id: item.illust_id,
+          pages: item.illust_page_count,
+          bookmarks: item.illust_bookmark_count,
+          url: 'https://www.pixiv.net/artworks/' + item.illust_id
+        }));
+      })()
+
+columns: [rank, title, author, illust_id, pages, bookmarks]

package/dist/clis/pixiv/search.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pixiv search — search illustrations by keyword/tag.
+ *
+ * Uses the internal Ajax search API with browser cookies for authentication.
+ */
+export {};

package/dist/clis/pixiv/search.js

@@ -0,0 +1,43 @@
+/**
+ * Pixiv search — search illustrations by keyword/tag.
+ *
+ * Uses the internal Ajax search API with browser cookies for authentication.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { pixivFetch } from './utils.js';
+cli({
+    site: 'pixiv',
+    name: 'search',
+    description: 'Search Pixiv illustrations by keyword',
+    domain: 'www.pixiv.net',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword or tag' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+        { name: 'order', type: 'str', default: 'date_d', help: 'Sort order', choices: ['date_d', 'date', 'popular_d', 'popular_male_d', 'popular_female_d'] },
+        { name: 'mode', type: 'str', default: 'all', help: 'Search mode', choices: ['all', 'safe', 'r18'] },
+        { name: 'page', type: 'int', default: 1, help: 'Page number' },
+    ],
+    columns: ['rank', 'title', 'author', 'illust_id', 'pages', 'bookmarks', 'tags'],
+    func: async (page, kwargs) => {
+        const { query, limit = 20, order = 'date_d', mode = 'all', page: pageNum = 1 } = kwargs;
+        const encoded = encodeURIComponent(query);
+        // Pixiv search API requires the keyword in BOTH the URL path and the `word` query param.
+        const body = await pixivFetch(page, `/ajax/search/illustrations/${encoded}`, { params: { word: query, order, mode, p: pageNum, s_mode: 's_tag_full', type: 'illust_and_ugoira' } });
+        const items = body?.illust?.data || [];
+        return items
+            .filter((item) => item.id)
+            .slice(0, Number(limit))
+            .map((item, i) => ({
+            rank: i + 1,
+            title: item.title || '',
+            author: item.userName || '',
+            user_id: item.userId || '',
+            illust_id: item.id,
+            pages: item.pageCount || 1,
+            bookmarks: item.bookmarkCount || 0,
+            tags: (item.tags || []).slice(0, 5).join(', '),
+            url: 'https://www.pixiv.net/artworks/' + item.id,
+        }));
+    },
+});

package/dist/clis/pixiv/search.test.d.ts

@@ -0,0 +1 @@
+import './search.js';

package/dist/clis/pixiv/search.test.js

@@ -0,0 +1,83 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { createPageMock } from './test-utils.js';
+import './search.js';
+let cmd;
+beforeAll(() => {
+    cmd = getRegistry().get('pixiv/search');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+describe('pixiv search', () => {
+    it('throws AuthRequiredError on 401', async () => {
+        const page = createPageMock([{ __httpError: 401 }]);
+        await expect(cmd.func(page, { query: '初音ミク', limit: 5 })).rejects.toThrow(AuthRequiredError);
+    });
+    it('throws generic error on non-auth HTTP failure', async () => {
+        const page = createPageMock([{ __httpError: 500 }]);
+        await expect(cmd.func(page, { query: 'test', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+    it('returns ranked results with correct fields', async () => {
+        const page = createPageMock([
+            {
+                body: {
+                    illust: {
+                        data: [
+                            {
+                                id: '12345',
+                                title: 'Miku Illustration',
+                                userName: 'artist1',
+                                userId: '100',
+                                pageCount: 3,
+                                bookmarkCount: 500,
+                                tags: ['初音ミク', 'VOCALOID', 'ミク'],
+                            },
+                            {
+                                id: '67890',
+                                title: 'Another Art',
+                                userName: 'artist2',
+                                userId: '200',
+                                pageCount: 1,
+                                bookmarkCount: 100,
+                                tags: ['オリジナル'],
+                            },
+                        ],
+                    },
+                },
+            },
+        ]);
+        const result = (await cmd.func(page, { query: '初音ミク', limit: 10 }));
+        expect(result).toHaveLength(2);
+        expect(result[0]).toMatchObject({
+            rank: 1,
+            title: 'Miku Illustration',
+            author: 'artist1',
+            illust_id: '12345',
+            pages: 3,
+            bookmarks: 500,
+        });
+        expect(result[1]).toMatchObject({ rank: 2, illust_id: '67890' });
+    });
+    it('respects the limit parameter', async () => {
+        const page = createPageMock([
+            {
+                body: {
+                    illust: {
+                        data: [
+                            { id: '1', title: 'A', userName: 'u1', userId: '1', pageCount: 1, bookmarkCount: 0, tags: [] },
+                            { id: '2', title: 'B', userName: 'u2', userId: '2', pageCount: 1, bookmarkCount: 0, tags: [] },
+                            { id: '3', title: 'C', userName: 'u3', userId: '3', pageCount: 1, bookmarkCount: 0, tags: [] },
+                        ],
+                    },
+                },
+            },
+        ]);
+        const result = (await cmd.func(page, { query: 'test', limit: 2 }));
+        expect(result).toHaveLength(2);
+    });
+    it('returns empty array when no results', async () => {
+        const page = createPageMock([{ body: { illust: { data: [] } } }]);
+        const result = await cmd.func(page, { query: 'nonexistent', limit: 10 });
+        expect(result).toEqual([]);
+    });
+});

package/dist/clis/pixiv/test-utils.d.ts

@@ -0,0 +1,12 @@
+import type { IPage } from '../../types.js';
+/**
+ * Create a minimal page mock with only the methods commonly used by Pixiv adapters.
+ *
+ * Since all TS adapters now go through `pixivFetch` which calls `page.evaluate`,
+ * the evaluate results should match the raw Pixiv Ajax response format:
+ * - Success: `{ body: ... }` (pixivFetch returns the `body` field)
+ * - HTTP error: `{ __httpError: <status> }` (pixivFetch detects and throws)
+ *
+ * Additional methods can be overridden via the overrides parameter.
+ */
+export declare function createPageMock(evaluateResults: any[], overrides?: Partial<IPage>): IPage;

package/dist/clis/pixiv/test-utils.js

@@ -0,0 +1,23 @@
+import { vi } from 'vitest';
+/**
+ * Create a minimal page mock with only the methods commonly used by Pixiv adapters.
+ *
+ * Since all TS adapters now go through `pixivFetch` which calls `page.evaluate`,
+ * the evaluate results should match the raw Pixiv Ajax response format:
+ * - Success: `{ body: ... }` (pixivFetch returns the `body` field)
+ * - HTTP error: `{ __httpError: <status> }` (pixivFetch detects and throws)
+ *
+ * Additional methods can be overridden via the overrides parameter.
+ */
+export function createPageMock(evaluateResults, overrides) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+        getCookies: vi.fn().mockResolvedValue([]),
+        ...overrides,
+    };
+}

package/dist/clis/pixiv/user.yaml

@@ -0,0 +1,46 @@
+site: pixiv
+name: user
+description: View Pixiv artist profile
+domain: www.pixiv.net
+strategy: cookie
+browser: true
+
+args:
+  uid:
+    type: str
+    required: true
+    positional: true
+    description: Pixiv user ID
+
+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
+        }];
+      })()
+
+columns: [user_id, name, premium, following, illusts, manga, novels, comment]

package/dist/clis/pixiv/utils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pixiv shared helpers: authenticated Ajax fetch with standard error handling.
+ *
+ * All Pixiv Ajax APIs return `{ error: false, body: ... }` on success.
+ * On failure the HTTP status code is used to distinguish auth (401/403),
+ * not-found (404), and other errors.
+ */
+import type { IPage } from '../../types.js';
+/**
+ * Navigate to Pixiv (to attach cookies) then fetch a Pixiv Ajax API endpoint.
+ *
+ * Handles the common navigate → evaluate(fetch) → error-check pattern used
+ * by every Pixiv TS adapter.
+ *
+ * @param page  - Browser page instance
+ * @param path  - API path, e.g. '/ajax/illust/12345'
+ * @param opts  - Optional query params
+ * @returns     - The parsed `body` from the JSON response
+ * @throws AuthRequiredError on 401/403
+ * @throws CommandExecutionError on 404 or other HTTP errors
+ */
+export declare function pixivFetch(page: IPage, path: string, opts?: {
+    params?: Record<string, string | number>;
+    notFoundMsg?: string;
+}): Promise<any>;
+/** Maximum number of illust IDs per batch detail request (Pixiv server limit). */
+export declare const BATCH_SIZE = 48;