@jackwener/opencli 1.4.0 → 1.5.0

package/src/clis/linux-do/user-posts.yaml

@@ -0,0 +1,67 @@
+site: linux-do
+name: user-posts
+description: linux.do 用户的帖子
+domain: linux.do
+strategy: cookie
+browser: true
+
+args:
+  username:
+    positional: true
+    type: str
+    required: true
+    description: Username
+  limit:
+    type: int
+    default: 20
+    description: Number of posts
+
+pipeline:
+  - navigate: https://linux.do
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const toLocalTime = (utcStr) => {
+          if (!utcStr) return '';
+          const date = new Date(utcStr);
+          return Number.isNaN(date.getTime()) ? utcStr : date.toLocaleString();
+        };
+        const strip = (html) => (html || '')
+          .replace(/<br\s*\/?>/gi, ' ')
+          .replace(/<\/(p|div|li|blockquote|h[1-6])>/gi, ' ')
+          .replace(/<[^>]+>/g, '')
+          .replace(/&nbsp;/g, ' ')
+          .replace(/&amp;/g, '&')
+          .replace(/&lt;/g, '<')
+          .replace(/&gt;/g, '>')
+          .replace(/&quot;/g, '"')
+          .replace(/&#(?:(\d+)|x([0-9a-fA-F]+));/g, (_, dec, hex) => {
+            try { return String.fromCodePoint(dec !== undefined ? Number(dec) : parseInt(hex, 16)); } catch { return ''; }
+          })
+          .replace(/\s+/g, ' ')
+          .trim();
+        const limit = ${{ args.limit | default(20) }};
+        const res = await fetch('/user_actions.json?username=' + encodeURIComponent(username) + '&filter=5&offset=0&limit=' + limit, { credentials: 'include' });
+        if (!res.ok) throw new Error('HTTP ' + res.status + ' - 请先登录 linux.do');
+        let data;
+        try { data = await res.json(); } catch { throw new Error('响应不是有效 JSON - 请先登录 linux.do'); }
+        const actions = data?.user_actions || [];
+        return actions.slice(0, limit).map(a => ({
+          author: a.acting_username || a.username || '',
+          title: a.title || '',
+          content: strip(a.excerpt).slice(0, 200),
+          created_at: toLocalTime(a.created_at),
+          url: 'https://linux.do/t/topic/' + a.topic_id + '/' + a.post_number,
+        }));
+      })()
+
+  - map:
+      index: ${{ index + 1 }}
+      topic_user: ${{ item.author }}
+      topic: ${{ item.title }}
+      reply: ${{ item.content }}
+      time: ${{ item.created_at }}
+      url: ${{ item.url }}
+
+columns: [index, topic_user, topic, reply, time, url]

package/src/clis/linux-do/user-topics.yaml

@@ -0,0 +1,54 @@
+site: linux-do
+name: user-topics
+description: linux.do 用户创建的话题
+domain: linux.do
+strategy: cookie
+browser: true
+
+args:
+  username:
+    positional: true
+    type: str
+    required: true
+    description: Username
+  limit:
+    type: int
+    default: 20
+    description: Number of topics
+
+pipeline:
+  - navigate: https://linux.do
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const toLocalTime = (utcStr) => {
+          if (!utcStr) return '';
+          const date = new Date(utcStr);
+          return Number.isNaN(date.getTime()) ? utcStr : date.toLocaleString();
+        };
+        const res = await fetch('/topics/created-by/' + encodeURIComponent(username) + '.json', { credentials: 'include' });
+        if (!res.ok) throw new Error('HTTP ' + res.status + ' - 请先登录 linux.do');
+        let data;
+        try { data = await res.json(); } catch { throw new Error('响应不是有效 JSON - 请先登录 linux.do'); }
+        const topics = data?.topic_list?.topics || [];
+        return topics.slice(0, ${{ args.limit }}).map(t => ({
+          title: t.fancy_title || t.title || '',
+          replies: t.posts_count || 0,
+          created_at: toLocalTime(t.created_at),
+          likes: t.like_count || 0,
+          views: t.views || 0,
+          url: 'https://linux.do/t/topic/' + t.id,
+        }));
+      })()
+
+  - map:
+      rank: ${{ index + 1 }}
+      title: ${{ item.title }}
+      replies: ${{ item.replies }}
+      created_at: ${{ item.created_at }}
+      likes: ${{ item.likes }}
+      views: ${{ item.views }}
+      url: ${{ item.url }}
+
+columns: [rank, title, replies, created_at, likes, views, url]

package/src/clis/medium/search.ts

@@ -11,6 +11,6 @@ cli({
     { name: 'keyword', required: true, positional: true, help: '搜索关键词' },
     { name: 'limit', type: 'int', default: 20, help: '返回的文章数量' },
   ],
-  columns: ['rank', 'title', 'author', 'date', 'readTime', 'claps'],
+  columns: ['rank', 'title', 'author', 'date', 'readTime', 'claps', 'url'],
   func: async (page, args) => loadMediumPosts(page, buildMediumSearchUrl(args.keyword), Number(args.limit) || 20),
 });

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

@@ -0,0 +1,283 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  mockReadPdfFile,
+  mockRequestJson,
+  mockUploadPresignedPdf,
+  mockValidateHelpfulness,
+  mockParseYesNo,
+} = vi.hoisted(() => ({
+  mockReadPdfFile: vi.fn(),
+  mockRequestJson: vi.fn(),
+  mockUploadPresignedPdf: vi.fn(),
+  mockValidateHelpfulness: vi.fn(),
+  mockParseYesNo: vi.fn(),
+}));
+
+vi.mock('./utils.js', async () => {
+  const actual = await vi.importActual<typeof import('./utils.js')>('./utils.js');
+  return {
+    ...actual,
+    readPdfFile: mockReadPdfFile,
+    requestJson: mockRequestJson,
+    uploadPresignedPdf: mockUploadPresignedPdf,
+    validateHelpfulness: mockValidateHelpfulness,
+    parseYesNo: mockParseYesNo,
+  };
+});
+
+import { getRegistry } from '../../registry.js';
+import './submit.js';
+import './review.js';
+import './feedback.js';
+
+describe('paperreview submit command', () => {
+  beforeEach(() => {
+    mockReadPdfFile.mockReset();
+    mockRequestJson.mockReset();
+    mockUploadPresignedPdf.mockReset();
+    mockValidateHelpfulness.mockReset();
+    mockParseYesNo.mockReset();
+  });
+
+  it('supports dry run without any remote request', async () => {
+    const cmd = getRegistry().get('paperreview/submit');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    mockReadPdfFile.mockResolvedValue({
+      buffer: Buffer.from('%PDF'),
+      fileName: 'paper.pdf',
+      resolvedPath: '/tmp/paper.pdf',
+      sizeBytes: 4096,
+    });
+
+    const result = await cmd!.func!(null as any, {
+      pdf: './paper.pdf',
+      email: 'wang2629651228@gmail.com',
+      venue: 'RAL',
+      'dry-run': true,
+      'prepare-only': false,
+    });
+
+    expect(mockRequestJson).not.toHaveBeenCalled();
+    expect(result).toMatchObject({
+      status: 'dry-run',
+      file: 'paper.pdf',
+      email: 'wang2629651228@gmail.com',
+      venue: 'RAL',
+    });
+  });
+
+  it('treats explicit false flags as false and performs the real submission path', async () => {
+    const cmd = getRegistry().get('paperreview/submit');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    mockReadPdfFile.mockResolvedValue({
+      buffer: Buffer.from('%PDF'),
+      fileName: 'paper.pdf',
+      resolvedPath: '/tmp/paper.pdf',
+      sizeBytes: 4096,
+    });
+    mockRequestJson
+      .mockResolvedValueOnce({
+        response: { ok: true, status: 200 } as Response,
+        payload: {
+          success: true,
+          presigned_url: 'https://upload.example.com',
+          presigned_fields: { key: 'uploads/paper.pdf' },
+          s3_key: 'uploads/paper.pdf',
+        },
+      })
+      .mockResolvedValueOnce({
+        response: { ok: true, status: 200 } as Response,
+        payload: {
+          success: true,
+          token: 'tok_false',
+          message: 'Submission accepted',
+        },
+      });
+
+    const result = await cmd!.func!(null as any, {
+      pdf: './paper.pdf',
+      email: 'wang2629651228@gmail.com',
+      venue: 'RAL',
+      'dry-run': false,
+      'prepare-only': false,
+    });
+
+    expect(mockUploadPresignedPdf).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject({
+      status: 'submitted',
+      token: 'tok_false',
+      review_url: 'https://paperreview.ai/review?token=tok_false',
+    });
+  });
+
+  it('supports prepare-only without uploading the PDF', async () => {
+    const cmd = getRegistry().get('paperreview/submit');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    mockReadPdfFile.mockResolvedValue({
+      buffer: Buffer.from('%PDF'),
+      fileName: 'paper.pdf',
+      resolvedPath: '/tmp/paper.pdf',
+      sizeBytes: 4096,
+    });
+    mockRequestJson.mockResolvedValueOnce({
+      response: { ok: true, status: 200 } as Response,
+      payload: {
+        success: true,
+        presigned_url: 'https://upload.example.com',
+        presigned_fields: { key: 'uploads/paper.pdf' },
+        s3_key: 'uploads/paper.pdf',
+      },
+    });
+
+    const result = await cmd!.func!(null as any, {
+      pdf: './paper.pdf',
+      email: 'wang2629651228@gmail.com',
+      venue: 'RAL',
+      'dry-run': false,
+      'prepare-only': true,
+    });
+
+    expect(mockUploadPresignedPdf).not.toHaveBeenCalled();
+    expect(mockRequestJson).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject({
+      status: 'prepared',
+      s3_key: 'uploads/paper.pdf',
+    });
+  });
+
+  it('requests an upload URL, uploads the PDF, and confirms the submission', async () => {
+    const cmd = getRegistry().get('paperreview/submit');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    mockReadPdfFile.mockResolvedValue({
+      buffer: Buffer.from('%PDF'),
+      fileName: 'paper.pdf',
+      resolvedPath: '/tmp/paper.pdf',
+      sizeBytes: 4096,
+    });
+    mockRequestJson
+      .mockResolvedValueOnce({
+        response: { ok: true, status: 200 } as Response,
+        payload: {
+          success: true,
+          presigned_url: 'https://upload.example.com',
+          presigned_fields: { key: 'uploads/paper.pdf' },
+          s3_key: 'uploads/paper.pdf',
+        },
+      })
+      .mockResolvedValueOnce({
+        response: { ok: true, status: 200 } as Response,
+        payload: {
+          success: true,
+          token: 'tok_123',
+          message: 'Submission accepted',
+        },
+      });
+
+    const result = await cmd!.func!(null as any, {
+      pdf: './paper.pdf',
+      email: 'wang2629651228@gmail.com',
+      venue: 'RAL',
+      'dry-run': false,
+      'prepare-only': false,
+    });
+
+    expect(mockRequestJson).toHaveBeenNthCalledWith(1, '/api/get-upload-url', expect.objectContaining({
+      method: 'POST',
+      body: JSON.stringify({
+        filename: 'paper.pdf',
+        venue: 'RAL',
+      }),
+    }));
+    expect(mockUploadPresignedPdf).toHaveBeenCalledWith(
+      'https://upload.example.com',
+      expect.objectContaining({ fileName: 'paper.pdf' }),
+      expect.objectContaining({ s3_key: 'uploads/paper.pdf' }),
+    );
+    expect(mockRequestJson).toHaveBeenNthCalledWith(2, '/api/confirm-upload', expect.objectContaining({
+      method: 'POST',
+      body: expect.any(FormData),
+    }));
+    expect(result).toMatchObject({
+      status: 'submitted',
+      token: 'tok_123',
+      review_url: 'https://paperreview.ai/review?token=tok_123',
+    });
+  });
+});
+
+describe('paperreview review command', () => {
+  beforeEach(() => {
+    mockRequestJson.mockReset();
+  });
+
+  it('returns processing status when the review is not ready yet', async () => {
+    const cmd = getRegistry().get('paperreview/review');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    mockRequestJson.mockResolvedValue({
+      response: { status: 202 } as Response,
+      payload: { detail: 'Review is still processing.' },
+    });
+
+    const result = await cmd!.func!(null as any, { token: 'tok_123' });
+
+    expect(result).toMatchObject({
+      status: 'processing',
+      token: 'tok_123',
+      review_url: 'https://paperreview.ai/review?token=tok_123',
+      message: 'Review is still processing.',
+    });
+  });
+});
+
+describe('paperreview feedback command', () => {
+  beforeEach(() => {
+    mockRequestJson.mockReset();
+    mockValidateHelpfulness.mockReset();
+    mockParseYesNo.mockReset();
+  });
+
+  it('normalizes feedback inputs and posts them to the API', async () => {
+    const cmd = getRegistry().get('paperreview/feedback');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    mockValidateHelpfulness.mockReturnValue(4);
+    mockParseYesNo.mockReturnValueOnce(true).mockReturnValueOnce(false);
+    mockRequestJson.mockResolvedValue({
+      response: { ok: true, status: 200 } as Response,
+      payload: { message: 'Thanks for the feedback.' },
+    });
+
+    const result = await cmd!.func!(null as any, {
+      token: 'tok_123',
+      helpfulness: 4,
+      'critical-error': 'yes',
+      'actionable-suggestions': 'no',
+      'additional-comments': 'Helpful summary, but the contribution section needs more detail.',
+    });
+
+    expect(mockRequestJson).toHaveBeenCalledWith('/api/feedback/tok_123', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        helpfulness: 4,
+        has_critical_error: true,
+        has_actionable_suggestions: false,
+        additional_comments: 'Helpful summary, but the contribution section needs more detail.',
+      }),
+    });
+    expect(result).toMatchObject({
+      status: 'submitted',
+      token: 'tok_123',
+      helpfulness: 4,
+      critical_error: true,
+      actionable_suggestions: false,
+      message: 'Thanks for the feedback.',
+    });
+  });
+});

package/src/clis/paperreview/feedback.ts

@@ -0,0 +1,64 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import {
+  PAPERREVIEW_DOMAIN,
+  ensureSuccess,
+  parseYesNo,
+  requestJson,
+  summarizeFeedback,
+  validateHelpfulness,
+} from './utils.js';
+
+cli({
+  site: 'paperreview',
+  name: 'feedback',
+  description: 'Submit feedback for a paperreview.ai review token',
+  domain: PAPERREVIEW_DOMAIN,
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  timeoutSeconds: 30,
+  args: [
+    { name: 'token', positional: true, required: true, help: 'Review token returned by paperreview.ai' },
+    { name: 'helpfulness', required: true, type: 'int', help: 'Helpfulness score from 1 to 5' },
+    { name: 'critical-error', required: true, choices: ['yes', 'no'], help: 'Whether the review contains a critical error' },
+    { name: 'actionable-suggestions', required: true, choices: ['yes', 'no'], help: 'Whether the review contains actionable suggestions' },
+    { name: 'additional-comments', help: 'Optional free-text feedback' },
+  ],
+  columns: ['status', 'token', 'helpfulness', 'critical_error', 'actionable_suggestions', 'message'],
+  func: async (_page, kwargs) => {
+    const token = String(kwargs.token ?? '').trim();
+    if (!token) {
+      throw new CliError('ARGUMENT', 'A review token is required.');
+    }
+
+    const helpfulness = validateHelpfulness(kwargs.helpfulness);
+    const criticalError = parseYesNo(kwargs['critical-error'], 'critical-error');
+    const actionableSuggestions = parseYesNo(kwargs['actionable-suggestions'], 'actionable-suggestions');
+    const comments = String(kwargs['additional-comments'] ?? '').trim();
+
+    const payload: Record<string, unknown> = {
+      helpfulness,
+      has_critical_error: criticalError,
+      has_actionable_suggestions: actionableSuggestions,
+    };
+    if (comments) {
+      payload.additional_comments = comments;
+    }
+
+    const { response, payload: responsePayload } = await requestJson(`/api/feedback/${encodeURIComponent(token)}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    ensureSuccess(response, responsePayload, 'Failed to submit feedback.', 'Check the token and try again');
+
+    return summarizeFeedback({
+      token,
+      helpfulness,
+      criticalError,
+      actionableSuggestions,
+      comments,
+      payload: responsePayload,
+    });
+  },
+});

package/src/clis/paperreview/review.ts

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import {
+  PAPERREVIEW_DOMAIN,
+  buildReviewUrl,
+  ensureSuccess,
+  requestJson,
+  summarizeReview,
+} from './utils.js';
+
+cli({
+  site: 'paperreview',
+  name: 'review',
+  description: 'Fetch a paperreview.ai review by token',
+  domain: PAPERREVIEW_DOMAIN,
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  timeoutSeconds: 30,
+  args: [
+    { name: 'token', positional: true, required: true, help: 'Review token returned by paperreview.ai' },
+  ],
+  columns: ['status', 'title', 'venue', 'numerical_score', 'has_feedback', 'review_url'],
+  func: async (_page, kwargs) => {
+    const token = String(kwargs.token ?? '').trim();
+    if (!token) {
+      throw new CliError('ARGUMENT', 'A review token is required.');
+    }
+
+    const { response, payload } = await requestJson(`/api/review/${encodeURIComponent(token)}`);
+
+    if (response.status === 202) {
+      return {
+        status: 'processing',
+        token,
+        review_url: buildReviewUrl(token),
+        title: '',
+        venue: '',
+        numerical_score: '',
+        has_feedback: '',
+        message: typeof payload === 'object' && payload ? payload.detail ?? 'Review is still processing.' : 'Review is still processing.',
+      };
+    }
+
+    ensureSuccess(response, payload, 'Failed to fetch the review.', 'Check the token and try again');
+    return summarizeReview(token, payload);
+  },
+});

package/src/clis/paperreview/submit.ts

@@ -0,0 +1,119 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import {
+  PAPERREVIEW_DOMAIN,
+  ensureApiSuccess,
+  ensureSuccess,
+  normalizeVenue,
+  readPdfFile,
+  requestJson,
+  summarizeSubmission,
+  uploadPresignedPdf,
+} from './utils.js';
+
+cli({
+  site: 'paperreview',
+  name: 'submit',
+  description: 'Submit a PDF to paperreview.ai for review',
+  domain: PAPERREVIEW_DOMAIN,
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  timeoutSeconds: 120,
+  args: [
+    { name: 'pdf', positional: true, required: true, help: 'Path to the paper PDF' },
+    { name: 'email', required: true, help: 'Email address for the submission' },
+    { name: 'venue', help: 'Optional target venue such as ICLR or NeurIPS' },
+    { name: 'dry-run', type: 'bool', default: false, help: 'Validate the input and stop before remote submission' },
+    { name: 'prepare-only', type: 'bool', default: false, help: 'Request an upload slot but stop before uploading the PDF' },
+  ],
+  columns: ['status', 'file', 'email', 'venue', 'token', 'review_url', 'message'],
+  footerExtra: (kwargs) => {
+    if (kwargs['dry-run'] === true) return 'dry run only';
+    if (kwargs['prepare-only'] === true) return 'prepared only';
+    return undefined;
+  },
+  func: async (_page, kwargs) => {
+    const pdfFile = await readPdfFile(kwargs.pdf);
+    const email = String(kwargs.email ?? '').trim();
+    const venue = normalizeVenue(kwargs.venue);
+    const dryRun = kwargs['dry-run'] === true;
+    const prepareOnly = kwargs['prepare-only'] === true;
+
+    if (!email) {
+      throw new CliError('ARGUMENT', 'An email address is required.', 'Pass --email <address>');
+    }
+
+    if (dryRun) {
+      return summarizeSubmission({
+        pdfFile,
+        email,
+        venue,
+        message: 'Input validation passed. No remote request was sent.',
+        dryRun: true,
+      });
+    }
+
+    const { response: uploadUrlResponse, payload: uploadUrlPayload } = await requestJson('/api/get-upload-url', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        filename: pdfFile.fileName,
+        venue,
+      }),
+    });
+    ensureSuccess(
+      uploadUrlResponse,
+      uploadUrlPayload,
+      'Failed to request an upload URL.',
+      'Try again in a moment',
+    );
+    ensureApiSuccess(
+      uploadUrlPayload,
+      'paperreview.ai did not return a usable upload URL.',
+      'Try again in a moment',
+    );
+
+    if (prepareOnly) {
+      return summarizeSubmission({
+        pdfFile,
+        email,
+        venue,
+        message: 'Upload slot prepared. The PDF was not uploaded and no submission was confirmed.',
+        s3Key: uploadUrlPayload.s3_key,
+        status: 'prepared',
+      });
+    }
+
+    await uploadPresignedPdf(uploadUrlPayload.presigned_url, pdfFile, uploadUrlPayload);
+
+    const confirmForm = new FormData();
+    confirmForm.append('s3_key', uploadUrlPayload.s3_key);
+    confirmForm.append('venue', venue);
+    confirmForm.append('email', email);
+
+    const { response: confirmResponse, payload: confirmPayload } = await requestJson('/api/confirm-upload', {
+      method: 'POST',
+      body: confirmForm,
+    });
+    ensureSuccess(
+      confirmResponse,
+      confirmPayload,
+      'Failed to confirm the upload with paperreview.ai.',
+      'Try again in a moment',
+    );
+    ensureApiSuccess(
+      confirmPayload,
+      'paperreview.ai did not confirm the submission.',
+      'Try again in a moment',
+    );
+
+    return summarizeSubmission({
+      pdfFile,
+      email,
+      venue,
+      token: confirmPayload.token,
+      message: confirmPayload.message,
+      s3Key: uploadUrlPayload.s3_key,
+    });
+  },
+});