@jackwener/opencli 1.4.0 → 1.5.0

package/src/clis/paperreview/utils.test.ts

@@ -0,0 +1,68 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CliError } from '../../errors.js';
+import {
+  MAX_PDF_BYTES,
+  buildReviewUrl,
+  parseYesNo,
+  readPdfFile,
+  requestJson,
+  validateHelpfulness,
+} from './utils.js';
+
+describe('paperreview utils', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('builds review URLs from the token', () => {
+    expect(buildReviewUrl('tok 123')).toBe('https://paperreview.ai/review?token=tok%20123');
+  });
+
+  it('parses yes/no flags', () => {
+    expect(parseYesNo('yes', 'critical-error')).toBe(true);
+    expect(parseYesNo('NO', 'critical-error')).toBe(false);
+  });
+
+  it('rejects invalid yes/no flags with CliError', () => {
+    expect(() => parseYesNo('maybe', 'critical-error')).toThrow(CliError);
+    expect(() => parseYesNo('maybe', 'critical-error')).toThrow('"critical-error" must be either "yes" or "no".');
+  });
+
+  it('validates helpfulness scores', () => {
+    expect(validateHelpfulness(5)).toBe(5);
+    expect(() => validateHelpfulness(0)).toThrow(CliError);
+  });
+
+  it('reads a valid PDF file and returns metadata', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'paperreview-'));
+    const pdfPath = path.join(tempDir, 'sample.pdf');
+    const pdfBytes = Buffer.concat([Buffer.from('%PDF-1.4\n'), Buffer.alloc(256, 1)]);
+    await fs.writeFile(pdfPath, pdfBytes);
+
+    const result = await readPdfFile(pdfPath);
+
+    expect(result.fileName).toBe('sample.pdf');
+    expect(result.resolvedPath).toBe(pdfPath);
+    expect(result.sizeBytes).toBe(pdfBytes.length);
+    expect(result.buffer.equals(pdfBytes)).toBe(true);
+  });
+
+  it('rejects PDFs larger than the paperreview.ai size limit', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'paperreview-'));
+    const pdfPath = path.join(tempDir, 'large.pdf');
+    await fs.writeFile(pdfPath, Buffer.alloc(MAX_PDF_BYTES + 1, 1));
+
+    await expect(readPdfFile(pdfPath)).rejects.toThrow(CliError);
+    await expect(readPdfFile(pdfPath)).rejects.toThrow('The PDF is larger than paperreview.ai\'s 10MB limit.');
+  });
+
+  it('normalizes fetch failures into CliError', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('socket hang up')));
+
+    await expect(requestJson('/api/review/token')).rejects.toThrow(CliError);
+    await expect(requestJson('/api/review/token')).rejects.toThrow('Unable to reach paperreview.ai');
+  });
+});

package/src/clis/paperreview/utils.ts

@@ -0,0 +1,276 @@
+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/producthunt/browse.ts

@@ -0,0 +1,109 @@
+/**
+ * Product Hunt category browse — INTERCEPT strategy.
+ *
+ * Navigates to a Product Hunt category page and scrapes the top-rated products.
+ * Shows all-time best products for a category (ranked by review score, not daily votes).
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+import { PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
+
+cli({
+  site: 'producthunt',
+  name: 'browse',
+  description: 'Best products in a Product Hunt category',
+  domain: 'www.producthunt.com',
+  strategy: Strategy.INTERCEPT,
+  args: [
+    {
+      name: 'category',
+      type: 'string',
+      positional: true,
+      required: true,
+      help: `Category slug, e.g. vibe-coding, ai-agents, developer-tools`,
+    },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
+  ],
+  columns: ['rank', 'name', 'tagline', 'reviews', 'url'],
+  func: async (page: IPage, args) => {
+    const count = Math.min(Number(args.limit) || 20, 50);
+    const slug = String(args.category || '').trim().toLowerCase();
+
+    await page.installInterceptor('producthunt.com');
+    await page.goto(`https://www.producthunt.com/categories/${slug}`);
+    await page.wait(5);
+
+    const domItems: any = await page.evaluate(`
+      (() => {
+        const seen = new Set();
+        const results = [];
+
+        // Card links: <a class="...flex-col" href="/products/<slug>"> (not review links)
+        const cardLinks = Array.from(document.querySelectorAll('a[href^="/products/"]')).filter(a => {
+          const href = a.getAttribute('href') || '';
+          const cls = a.className || '';
+          return cls.includes('flex-col') && !href.includes('/reviews');
+        });
+
+        for (const cardLink of cardLinks) {
+          const href = cardLink.getAttribute('href');
+          if (!href || seen.has(href)) continue;
+
+          // Child 0: div with name (strip "Launched this month/week/year" noise)
+          const nameDiv = cardLink.querySelector('div');
+          const rawName = nameDiv?.textContent?.trim() || '';
+          const name = rawName
+            .replace(/\\s*Launched\\s+this\\s+(month|week|year|day)\\s*/gi, '')
+            .replace(/\\s*Featured\\s*/gi, '')
+            .trim();
+
+          // Child 1: span.text-secondary — tagline
+          const taglineEl = cardLink.querySelector('span.text-secondary, span[class*="text-secondary"]');
+          const tagline = taglineEl?.textContent?.trim() || '';
+
+          if (!name) continue;
+
+          // Find reviews count from sibling /reviews link
+          let reviews = '';
+          let container = cardLink.parentElement;
+          for (let i = 0; i < 5 && container; i++) {
+            const reviewLink = container.querySelector('a[href="' + href + '/reviews"]');
+            if (reviewLink) {
+              reviews = (reviewLink.textContent?.trim() || '').replace(/\\s*reviews?\\s*/i, '').trim();
+              break;
+            }
+            container = container.parentElement;
+          }
+
+          seen.add(href);
+          results.push({
+            name,
+            tagline: tagline.slice(0, 120),
+            reviews: reviews || '0',
+            url: 'https://www.producthunt.com' + href,
+          });
+        }
+
+        return results;
+      })()
+    `);
+
+    const items = Array.isArray(domItems) ? (domItems as any[]) : [];
+    if (items.length === 0) {
+      throw new CliError(
+        'NO_DATA',
+        `No products found for category "${slug}"`,
+        'Check the category slug or try: ' + PRODUCTHUNT_CATEGORY_SLUGS.slice(0, 5).join(', '),
+      );
+    }
+
+    return items.slice(0, count).map((item: any, i: number) => ({
+      rank: i + 1,
+      name: item.name,
+      tagline: item.tagline,
+      reviews: item.reviews,
+      url: item.url,
+    }));
+  },
+});

package/src/clis/producthunt/hot.ts

@@ -0,0 +1,127 @@
+/**
+ * Product Hunt top posts with vote counts — INTERCEPT strategy.
+ *
+ * Navigates to the Product Hunt homepage and scrapes rendered product cards.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+import { pickVoteCount } from './utils.js';
+
+cli({
+  site: 'producthunt',
+  name: 'hot',
+  description: "Today's top Product Hunt launches with vote counts",
+  domain: 'www.producthunt.com',
+  strategy: Strategy.INTERCEPT,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
+  ],
+  columns: ['rank', 'name', 'votes', 'url'],
+  func: async (page: IPage, args) => {
+    const count = Math.min(Number(args.limit) || 20, 50);
+
+    await page.installInterceptor('producthunt.com');
+    await page.goto('https://www.producthunt.com');
+    await page.wait(5);
+
+    const domItems: any = await page.evaluate(`
+      (() => {
+        const seen = new Set();
+        const results = [];
+
+        const cardLinks = Array.from(document.querySelectorAll('a[href^="/products/"]')).filter((el) => {
+          const href = el.getAttribute('href') || '';
+          const text = el.textContent?.trim() || '';
+          return href && !href.includes('/reviews') && text.length > 0 && text.length < 120;
+        });
+
+        const normalizeName = (text) => text
+          .replace(/^\\d+\\.\\s*/, '')
+          .replace(/\\s*Launched\\s+this\\s+(month|week|year|day)\\s*/gi, '')
+          .replace(/\\s*Featured\\s*/gi, '')
+          .trim();
+
+        for (const cardLink of cardLinks) {
+          const href = cardLink.getAttribute('href') || '';
+          if (!href || seen.has(href)) continue;
+
+          let card = cardLink;
+          let node = cardLink.parentElement;
+          for (let i = 0; i < 6 && node; i++) {
+            const hasReviewLink = !!node.querySelector('a[href="' + href + '/reviews"]');
+            const hasNumericNode = Array.from(node.querySelectorAll('button, [role="button"], p, span, div'))
+              .some((el) => /^\\d+$/.test(el.textContent?.trim() || ''));
+            if (hasReviewLink || hasNumericNode) {
+              card = node;
+              break;
+            }
+            node = node.parentElement;
+          }
+
+          const name = normalizeName(cardLink.textContent?.trim() || '');
+          if (!name) continue;
+
+          const voteCandidates = Array.from(card.querySelectorAll('button, [role="button"], a, p, span, div'))
+            .map((el) => {
+              const reviewLink = el.closest('a[href="' + href + '/reviews"]');
+              return {
+                text: el.textContent?.trim() || '',
+                tagName: el.tagName,
+                className: el.className || '',
+                role: el.getAttribute('role') || '',
+                inButton: !!el.closest('button, [role="button"]'),
+                inReviewLink: !!reviewLink,
+              };
+            })
+            .filter((candidate) => /^\\d+$/.test(candidate.text));
+
+          if (voteCandidates.length === 0) continue;
+
+          seen.add(href);
+          results.push({
+            name,
+            voteCandidates,
+            url: 'https://www.producthunt.com' + href,
+          });
+        }
+
+        return results;
+      })()
+    `);
+
+    const items = Array.isArray(domItems) ? (domItems as any[]) : [];
+    if (items.length === 0) {
+      throw new CliError(
+        'NO_DATA',
+        'Could not retrieve Product Hunt top posts',
+        'Product Hunt may have changed its layout',
+      );
+    }
+
+    const rankedItems = items
+      .map((item: any) => ({
+        name: item.name,
+        url: item.url,
+        votes: pickVoteCount(Array.isArray(item.voteCandidates) ? item.voteCandidates : []),
+      }))
+      .filter((item) => item.name && item.url && item.votes);
+
+    if (rankedItems.length === 0) {
+      throw new CliError(
+        'NO_DATA',
+        'Could not retrieve Product Hunt vote counts',
+        'Product Hunt may have changed its vote button structure',
+      );
+    }
+
+    rankedItems.sort((a, b) => parseInt(b.votes, 10) - parseInt(a.votes, 10));
+
+    return rankedItems.slice(0, count).map((item, i: number) => ({
+      rank: i + 1,
+      name: item.name,
+      votes: item.votes,
+      url: item.url,
+    }));
+  },
+});

package/src/clis/producthunt/posts.ts

@@ -0,0 +1,29 @@
+/**
+ * Product Hunt latest posts — public Atom feed, no browser needed.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { fetchFeed, PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
+
+cli({
+  site: 'producthunt',
+  name: 'posts',
+  description: 'Latest Product Hunt launches (optional category filter)',
+  domain: 'www.producthunt.com',
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
+    {
+      name: 'category',
+      type: 'string',
+      default: '',
+      help: `Category filter: ${PRODUCTHUNT_CATEGORY_SLUGS.join(', ')}`,
+    },
+  ],
+  columns: ['rank', 'name', 'tagline', 'author', 'date', 'url'],
+  func: async (_page, args) => {
+    const count = Math.min(Number(args.limit) || 20, 50);
+    const category = String(args.category ?? '').trim() || undefined;
+    const posts = await fetchFeed(category);
+    return posts.slice(0, count);
+  },
+});

package/src/clis/producthunt/today.ts

@@ -0,0 +1,37 @@
+/**
+ * Product Hunt today's top launches — filtered from public Atom feed.
+ *
+ * Shows the most recently published day's products (Product Hunt runs on
+ * Pacific Time; the feed date may differ from UTC local date by up to 1 day).
+ */
+import { cli, Strategy } from '../../registry.js';
+import { fetchFeed } from './utils.js';
+
+cli({
+  site: 'producthunt',
+  name: 'today',
+  description: "Today's Product Hunt launches (most recent day in feed)",
+  domain: 'www.producthunt.com',
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+  ],
+  columns: ['rank', 'name', 'tagline', 'author', 'url'],
+  func: async (_page, args) => {
+    const count = Math.min(Number(args.limit) || 20, 50);
+    const posts = await fetchFeed();
+    if (posts.length === 0) return [];
+
+    // Use the latest date in the feed (Product Hunt is PST-based)
+    const latestDate = posts.map(p => p.date).sort().reverse()[0];
+    const todayPosts = posts.filter(p => p.date === latestDate);
+
+    return todayPosts.slice(0, count).map((p, i) => ({
+      rank: i + 1,
+      name: p.name,
+      tagline: p.tagline,
+      author: p.author,
+      url: p.url,
+    }));
+  },
+});