@jackwener/opencli 1.6.2 → 1.6.4

package/src/clis/paperreview/utils.ts

@@ -1,276 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { CliError, getErrorMessage } from '../../errors.js';
-
-export const PAPERREVIEW_DOMAIN = 'paperreview.ai';
-export const PAPERREVIEW_BASE_URL = `https://${PAPERREVIEW_DOMAIN}`;
-export const MAX_PDF_BYTES = 10 * 1024 * 1024;
-
-export interface PaperreviewPdfFile {
-  buffer: Buffer;
-  fileName: string;
-  resolvedPath: string;
-  sizeBytes: number;
-}
-
-export interface PaperreviewRequestResult {
-  response: Response;
-  payload: any;
-}
-
-function asText(value: unknown): string {
-  return value == null ? '' : String(value);
-}
-
-function trimOrEmpty(value: unknown): string {
-  return asText(value).trim();
-}
-
-function toErrorMessage(payload: unknown, fallback: string): string {
-  if (payload && typeof payload === 'object') {
-    const detail = trimOrEmpty((payload as Record<string, unknown>).detail);
-    const message = trimOrEmpty((payload as Record<string, unknown>).message);
-    const error = trimOrEmpty((payload as Record<string, unknown>).error);
-    if (detail) return detail;
-    if (message) return message;
-    if (error) return error;
-  }
-  const text = trimOrEmpty(payload);
-  return text || fallback;
-}
-
-export function buildReviewUrl(token: string): string {
-  return `${PAPERREVIEW_BASE_URL}/review?token=${encodeURIComponent(token)}`;
-}
-
-export function parseYesNo(value: unknown, name: string): boolean {
-  const normalized = trimOrEmpty(value).toLowerCase();
-  if (normalized === 'yes') return true;
-  if (normalized === 'no') return false;
-  throw new CliError('ARGUMENT', `"${name}" must be either "yes" or "no".`);
-}
-
-export function normalizeVenue(value: unknown): string {
-  return trimOrEmpty(value);
-}
-
-export function validateHelpfulness(value: unknown): number {
-  const numeric = Number(value);
-  if (!Number.isInteger(numeric) || numeric < 1 || numeric > 5) {
-    throw new CliError('ARGUMENT', '"helpfulness" must be an integer from 1 to 5.');
-  }
-  return numeric;
-}
-
-export async function readPdfFile(inputPath: unknown): Promise<PaperreviewPdfFile> {
-  const rawPath = trimOrEmpty(inputPath);
-  if (!rawPath) {
-    throw new CliError('ARGUMENT', 'A PDF path is required.', 'Provide a local PDF file path');
-  }
-
-  const resolvedPath = path.resolve(rawPath);
-  const fileName = path.basename(resolvedPath);
-
-  if (!fileName.toLowerCase().endsWith('.pdf')) {
-    throw new CliError('ARGUMENT', 'The input file must end with .pdf.', 'Provide a PDF file path');
-  }
-
-  let fileStat;
-  try {
-    fileStat = await fs.stat(resolvedPath);
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException | undefined)?.code === 'ENOENT') {
-      throw new CliError('FILE_NOT_FOUND', `File not found: ${resolvedPath}`, 'Provide a valid PDF file path');
-    }
-    throw new CliError('FILE_READ_ERROR', `Unable to inspect file: ${resolvedPath}`, 'Check file permissions and try again');
-  }
-
-  if (!fileStat.isFile()) {
-    throw new CliError('FILE_NOT_FOUND', `Not a file: ${resolvedPath}`, 'Provide a valid PDF file path');
-  }
-
-  if (fileStat.size < 100) {
-    throw new CliError(
-      'ARGUMENT',
-      'The PDF is too small. paperreview.ai requires at least 100 bytes.',
-      'Provide the final paper PDF',
-    );
-  }
-
-  if (fileStat.size > MAX_PDF_BYTES) {
-    throw new CliError(
-      'FILE_TOO_LARGE',
-      'The PDF is larger than paperreview.ai\'s 10MB limit.',
-      'Compress the PDF or submit a smaller file',
-    );
-  }
-
-  let buffer: Buffer;
-  try {
-    buffer = await fs.readFile(resolvedPath);
-  } catch {
-    throw new CliError('FILE_READ_ERROR', `Unable to read file: ${resolvedPath}`, 'Check file permissions and try again');
-  }
-
-  return {
-    buffer,
-    fileName,
-    resolvedPath,
-    sizeBytes: buffer.byteLength,
-  };
-}
-
-export async function requestJson(pathname: string, init: RequestInit = {}): Promise<PaperreviewRequestResult> {
-  let response: Response;
-  try {
-    response = await fetch(`${PAPERREVIEW_BASE_URL}${pathname}`, init);
-  } catch (error: unknown) {
-    throw new CliError(
-      'FETCH_ERROR',
-      `Unable to reach paperreview.ai: ${getErrorMessage(error)}`,
-      'Check your network connection and try again',
-    );
-  }
-
-  const rawText = await response.text();
-
-  let payload: any = rawText;
-  if (rawText) {
-    try {
-      payload = JSON.parse(rawText);
-    } catch {
-      payload = rawText;
-    }
-  }
-
-  return { response, payload };
-}
-
-export function ensureSuccess(response: Response, payload: unknown, fallback: string, hint?: string): void {
-  if (!response.ok) {
-    const code = response.status === 404 ? 'NOT_FOUND' : 'API_ERROR';
-    throw new CliError(code, toErrorMessage(payload, fallback), hint);
-  }
-}
-
-export function ensureApiSuccess(payload: unknown, fallback: string, hint?: string): void {
-  if (!payload || typeof payload !== 'object' || (payload as Record<string, unknown>).success !== true) {
-    throw new CliError('API_ERROR', toErrorMessage(payload, fallback), hint);
-  }
-}
-
-export function createUploadForm(
-  urlData: { presigned_fields?: Record<string, string> },
-  pdfFile: PaperreviewPdfFile,
-): FormData {
-  const form = new FormData();
-  for (const [key, value] of Object.entries(urlData.presigned_fields ?? {})) {
-    form.append(key, value);
-  }
-  form.append(
-    'file',
-    new Blob([new Uint8Array(pdfFile.buffer)], { type: 'application/pdf' }),
-    pdfFile.fileName,
-  );
-  return form;
-}
-
-export async function uploadPresignedPdf(
-  presignedUrl: string,
-  pdfFile: PaperreviewPdfFile,
-  urlData: { presigned_fields?: Record<string, string> },
-): Promise<void> {
-  let response: Response;
-  try {
-    response = await fetch(presignedUrl, {
-      method: 'POST',
-      body: createUploadForm(urlData, pdfFile),
-    });
-  } catch (error: unknown) {
-    throw new CliError(
-      'UPLOAD_ERROR',
-      `S3 upload failed: ${getErrorMessage(error)}`,
-      'Try again in a moment',
-    );
-  }
-
-  if (!response.ok) {
-    const body = await response.text();
-    throw new CliError(
-      'UPLOAD_ERROR',
-      body || `S3 upload failed with status ${response.status}.`,
-      'Try again in a moment',
-    );
-  }
-}
-
-export function summarizeSubmission(options: {
-  pdfFile: PaperreviewPdfFile;
-  email: string;
-  venue: string;
-  token?: string;
-  message?: string;
-  s3Key?: string;
-  dryRun?: boolean;
-  status?: string;
-}): Record<string, unknown> {
-  const { pdfFile, email, venue, token, message, s3Key, dryRun = false, status } = options;
-  return {
-    status: status ?? (dryRun ? 'dry-run' : 'submitted'),
-    file: pdfFile.fileName,
-    file_path: pdfFile.resolvedPath,
-    size_bytes: pdfFile.sizeBytes,
-    email,
-    venue,
-    token: token ?? '',
-    review_url: token ? buildReviewUrl(token) : '',
-    message: message ?? '',
-    s3_key: s3Key ?? '',
-  };
-}
-
-export function summarizeReview(token: string, payload: any, status = 'ready'): Record<string, unknown> {
-  const sections = payload?.sections ?? {};
-  const availableSections = Object.keys(sections);
-
-  return {
-    status,
-    token,
-    review_url: buildReviewUrl(token),
-    title: trimOrEmpty(payload?.title),
-    venue: trimOrEmpty(payload?.venue),
-    submission_date: trimOrEmpty(payload?.submission_date),
-    numerical_score: payload?.numerical_score ?? '',
-    has_feedback: payload?.has_feedback ?? '',
-    available_sections: availableSections.join(', '),
-    section_count: availableSections.length,
-    summary: trimOrEmpty(sections.summary),
-    strengths: trimOrEmpty(sections.strengths),
-    weaknesses: trimOrEmpty(sections.weaknesses),
-    detailed_comments: trimOrEmpty(sections.detailed_comments),
-    questions: trimOrEmpty(sections.questions),
-    assessment: trimOrEmpty(sections.assessment),
-    content: trimOrEmpty(payload?.content),
-    sections,
-  };
-}
-
-export function summarizeFeedback(options: {
-  token: string;
-  helpfulness: number;
-  criticalError: boolean;
-  actionableSuggestions: boolean;
-  comments: string;
-  payload: any;
-}): Record<string, unknown> {
-  const { token, helpfulness, criticalError, actionableSuggestions, comments, payload } = options;
-  return {
-    status: 'submitted',
-    token,
-    helpfulness,
-    critical_error: criticalError,
-    actionable_suggestions: actionableSuggestions,
-    additional_comments: comments,
-    message: trimOrEmpty(payload?.message) || 'Feedback submitted.',
-  };
-}

package/src/clis/pixiv/detail.yaml

@@ -1,49 +0,0 @@
-site: pixiv
-name: detail
-description: View illustration details (tags, stats, URLs)
-domain: www.pixiv.net
-strategy: cookie
-browser: true
-
-args:
-  id:
-    type: str
-    required: true
-    positional: true
-    description: Illustration ID
-
-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
-        }];
-      })()
-
-columns: [illust_id, title, author, type, pages, bookmarks, likes, views, tags, created, url]

package/src/clis/pixiv/download.test.ts

@@ -1,114 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { CliCommand } from '../../registry.js';
-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: CliCommand;
-
-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' })) as any[];
-    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' })) as any[];
-
-    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' })) as any[];
-
-    expect(result).toHaveLength(2);
-    expect(result[0].status).toBe('success');
-    expect(result[1].status).toBe('failed');
-    expect(result[1].size).toBe('Connection timeout');
-  });
-});

package/src/clis/pixiv/download.ts

@@ -1,91 +0,0 @@
-/**
- * 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: any[] = 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/src/clis/pixiv/illusts.test.ts

@@ -1,115 +0,0 @@
-import { beforeAll, describe, expect, it } from 'vitest';
-import type { CliCommand } from '../../registry.js';
-import { getRegistry } from '../../registry.js';
-import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
-import { createPageMock } from './test-utils.js';
-import './illusts.js';
-
-let cmd: CliCommand;
-
-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 })) as any[];
-
-    // 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 })) as any[];
-    expect(result).toHaveLength(2);
-  });
-});