@jackwener/opencli 1.4.1 → 1.5.1

package/dist/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/dist/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/dist/clis/paperreview/commands.test.d.ts

@@ -0,0 +1,3 @@
+import './submit.js';
+import './review.js';
+import './feedback.js';

package/dist/clis/paperreview/commands.test.js

@@ -0,0 +1,243 @@
+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('./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, {
+            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 },
+            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 },
+            payload: {
+                success: true,
+                token: 'tok_false',
+                message: 'Submission accepted',
+            },
+        });
+        const result = await cmd.func(null, {
+            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 },
+            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, {
+            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 },
+            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 },
+            payload: {
+                success: true,
+                token: 'tok_123',
+                message: 'Submission accepted',
+            },
+        });
+        const result = await cmd.func(null, {
+            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 },
+            payload: { detail: 'Review is still processing.' },
+        });
+        const result = await cmd.func(null, { 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 },
+            payload: { message: 'Thanks for the feedback.' },
+        });
+        const result = await cmd.func(null, {
+            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/dist/clis/paperreview/feedback.d.ts

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

package/dist/clis/paperreview/feedback.js

@@ -0,0 +1,52 @@
+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 = {
+            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/dist/clis/paperreview/review.d.ts

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

package/dist/clis/paperreview/review.js

@@ -0,0 +1,37 @@
+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/dist/clis/paperreview/submit.d.ts

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

package/dist/clis/paperreview/submit.js

@@ -0,0 +1,85 @@
+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,
+        });
+    },
+});

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

@@ -0,0 +1,46 @@
+export declare const PAPERREVIEW_DOMAIN = "paperreview.ai";
+export declare const PAPERREVIEW_BASE_URL = "https://paperreview.ai";
+export declare const MAX_PDF_BYTES: number;
+export interface PaperreviewPdfFile {
+    buffer: Buffer;
+    fileName: string;
+    resolvedPath: string;
+    sizeBytes: number;
+}
+export interface PaperreviewRequestResult {
+    response: Response;
+    payload: any;
+}
+export declare function buildReviewUrl(token: string): string;
+export declare function parseYesNo(value: unknown, name: string): boolean;
+export declare function normalizeVenue(value: unknown): string;
+export declare function validateHelpfulness(value: unknown): number;
+export declare function readPdfFile(inputPath: unknown): Promise<PaperreviewPdfFile>;
+export declare function requestJson(pathname: string, init?: RequestInit): Promise<PaperreviewRequestResult>;
+export declare function ensureSuccess(response: Response, payload: unknown, fallback: string, hint?: string): void;
+export declare function ensureApiSuccess(payload: unknown, fallback: string, hint?: string): void;
+export declare function createUploadForm(urlData: {
+    presigned_fields?: Record<string, string>;
+}, pdfFile: PaperreviewPdfFile): FormData;
+export declare function uploadPresignedPdf(presignedUrl: string, pdfFile: PaperreviewPdfFile, urlData: {
+    presigned_fields?: Record<string, string>;
+}): Promise<void>;
+export declare function summarizeSubmission(options: {
+    pdfFile: PaperreviewPdfFile;
+    email: string;
+    venue: string;
+    token?: string;
+    message?: string;
+    s3Key?: string;
+    dryRun?: boolean;
+    status?: string;
+}): Record<string, unknown>;
+export declare function summarizeReview(token: string, payload: any, status?: string): Record<string, unknown>;
+export declare function summarizeFeedback(options: {
+    token: string;
+    helpfulness: number;
+    criticalError: boolean;
+    actionableSuggestions: boolean;
+    comments: string;
+    payload: any;
+}): Record<string, unknown>;