publishport-opencli 1.8.4-pp.1

package/clis/linux-do/topic-content.js

@@ -0,0 +1,155 @@
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { htmlToMarkdown, isRecord } from '@jackwener/opencli/utils';
+const LINUX_DO_DOMAIN = 'linux.do';
+const LINUX_DO_HOME = 'https://linux.do';
+function toLocalTime(utcStr) {
+    if (!utcStr)
+        return '';
+    const date = new Date(utcStr);
+    return Number.isNaN(date.getTime()) ? utcStr : date.toLocaleString();
+}
+function normalizeTopicPayload(payload) {
+    if (!isRecord(payload))
+        return null;
+    const postStream = isRecord(payload.post_stream)
+        ? {
+            posts: Array.isArray(payload.post_stream.posts)
+                ? payload.post_stream.posts.filter(isRecord).map((post) => ({
+                    post_number: typeof post.post_number === 'number' ? post.post_number : undefined,
+                    username: typeof post.username === 'string' ? post.username : undefined,
+                    raw: typeof post.raw === 'string' ? post.raw : undefined,
+                    cooked: typeof post.cooked === 'string' ? post.cooked : undefined,
+                    like_count: typeof post.like_count === 'number' ? post.like_count : undefined,
+                    created_at: typeof post.created_at === 'string' ? post.created_at : undefined,
+                }))
+                : undefined,
+        }
+        : undefined;
+    return {
+        title: typeof payload.title === 'string' ? payload.title : undefined,
+        post_stream: postStream,
+    };
+}
+function buildTopicMarkdownDocument(params) {
+    const frontMatterLines = [];
+    const entries = [
+        ['title', params.title || undefined],
+        ['author', params.author || undefined],
+        ['likes', typeof params.likes === 'number' && Number.isFinite(params.likes) ? params.likes : undefined],
+        ['createdAt', params.createdAt || undefined],
+        ['url', params.url || undefined],
+    ];
+    for (const [key, value] of entries) {
+        if (value === undefined)
+            continue;
+        if (typeof value === 'number') {
+            frontMatterLines.push(`${key}: ${value}`);
+        }
+        else {
+            // Quote strings that could be misinterpreted by YAML parsers
+            const needsQuote = /[#{}[\],&*?|>!%@`'"]/.test(value) || /: /.test(value) || /:$/.test(value) || value.includes('\n');
+            frontMatterLines.push(`${key}: ${needsQuote ? `'${value.replace(/'/g, "''")}'` : value}`);
+        }
+    }
+    const frontMatter = frontMatterLines.join('\n');
+    return [
+        frontMatter ? `---\n${frontMatter}\n---` : '',
+        params.body.trim(),
+    ].filter(Boolean).join('\n\n').trim();
+}
+function extractTopicContent(payload, id) {
+    const topic = normalizeTopicPayload(payload);
+    if (!topic) {
+        throw new CommandExecutionError('linux.do returned an unexpected topic payload');
+    }
+    const posts = topic.post_stream?.posts ?? [];
+    const mainPost = posts.find((post) => post.post_number === 1);
+    if (!mainPost) {
+        throw new EmptyResultError('linux-do/topic-content', `Could not find the main post for topic ${id}.`);
+    }
+    const body = typeof mainPost.raw === 'string' && mainPost.raw.trim()
+        ? mainPost.raw.trim()
+        : htmlToMarkdown(mainPost.cooked ?? '');
+    if (!body) {
+        throw new EmptyResultError('linux-do/topic-content', `Topic ${id} does not contain a readable main post body.`);
+    }
+    return {
+        content: buildTopicMarkdownDocument({
+            title: topic.title?.trim() ?? '',
+            author: mainPost.username?.trim() ?? '',
+            likes: typeof mainPost.like_count === 'number' ? mainPost.like_count : undefined,
+            createdAt: toLocalTime(mainPost.created_at ?? ''),
+            url: `${LINUX_DO_HOME}/t/${id}`,
+            body,
+        }),
+    };
+}
+async function fetchTopicPayload(page, id) {
+    const result = await page.evaluate(`(async () => {
+    try {
+      const res = await fetch('/t/${id}.json?include_raw=true', { credentials: 'include' });
+      let data = null;
+      try {
+        data = await res.json();
+      } catch (_error) {
+        data = null;
+      }
+      return {
+        ok: res.ok,
+        status: res.status,
+        data,
+        error: data === null ? 'Response is not valid JSON' : '',
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  })()`);
+    if (!result) {
+        throw new CommandExecutionError('linux.do returned an empty browser response');
+    }
+    if (result.status === 401 || result.status === 403) {
+        throw new AuthRequiredError(LINUX_DO_DOMAIN, 'linux.do requires an active signed-in browser session');
+    }
+    if (result.error === 'Response is not valid JSON') {
+        throw new AuthRequiredError(LINUX_DO_DOMAIN, 'linux.do requires an active signed-in browser session');
+    }
+    if (!result.ok) {
+        throw new CommandExecutionError(result.error || `linux.do request failed: HTTP ${result.status ?? 'unknown'}`);
+    }
+    if (result.error) {
+        throw new CommandExecutionError(result.error, 'Please verify your linux.do session is still valid');
+    }
+    return result.data;
+}
+cli({
+    site: 'linux-do',
+    name: 'topic-content',
+    access: 'read',
+    description: 'Get the main topic body as Markdown',
+    domain: LINUX_DO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    defaultFormat: 'plain',
+    args: [
+        { name: 'id', positional: true, type: 'int', required: true, help: 'Topic ID' },
+    ],
+    columns: ['content'],
+    func: async (page, kwargs) => {
+        const id = Number(kwargs.id);
+        if (!Number.isInteger(id) || id <= 0) {
+            throw new CommandExecutionError(`Invalid linux.do topic id: ${String(kwargs.id ?? '')}`);
+        }
+        const payload = await fetchTopicPayload(page, id);
+        return [extractTopicContent(payload, id)];
+    },
+});
+export const __test__ = {
+    buildTopicMarkdownDocument,
+    extractTopicContent,
+    normalizeTopicPayload,
+    toLocalTime,
+};

package/clis/linux-do/topic-content.test.js

@@ -0,0 +1,59 @@
+import { getRegistry } from '@jackwener/opencli/registry';
+import fs from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './topic-content.js';
+describe('linux-do topic-content', () => {
+    it('prefers raw markdown when the topic payload includes it', () => {
+        const result = __test__.extractTopicContent({
+            title: 'Hello Linux.do',
+            post_stream: {
+                posts: [
+                    {
+                        post_number: 1,
+                        username: 'neo',
+                        raw: '## Heading\n\n- one\n- two',
+                        cooked: '<h2>Heading</h2><ul><li>one</li><li>two</li></ul>',
+                        like_count: 7,
+                        created_at: '2025-04-05T10:00:00.000Z',
+                    },
+                ],
+            },
+        }, 1234);
+        expect(result.content).toContain('---');
+        expect(result.content).toContain('title: Hello Linux.do');
+        expect(result.content).toContain('author: neo');
+        expect(result.content).toContain('likes: 7');
+        expect(result.content).toContain('url: https://linux.do/t/1234');
+        expect(result.content).toContain('## Heading');
+        expect(result.content).toContain('- one');
+    });
+    it('falls back to cooked html and converts it to markdown', () => {
+        const result = __test__.extractTopicContent({
+            title: 'Converted Topic',
+            post_stream: {
+                posts: [
+                    {
+                        post_number: 1,
+                        username: 'trinity',
+                        cooked: '<p>Hello <strong>world</strong></p><blockquote><p>quoted</p></blockquote>',
+                        like_count: 3,
+                        created_at: '2025-04-05T10:00:00.000Z',
+                    },
+                ],
+            },
+        }, 42);
+        expect(result.content).toContain('Hello **world**');
+        expect(result.content).toContain('> quoted');
+    });
+    it('registers topic-content with plain default output for markdown body rendering', () => {
+        const command = getRegistry().get('linux-do/topic-content');
+        expect(command?.defaultFormat).toBe('plain');
+        expect(command?.columns).toEqual(['content']);
+    });
+    it('keeps topic adapter as a summarized first-page reader after the split', () => {
+        const topicTs = fs.readFileSync(new URL('./topic.js', import.meta.url), 'utf8');
+        expect(topicTs).not.toContain('main_only');
+        expect(topicTs).toContain('slice(0, 200)');
+        expect(topicTs).toContain('帖子首页摘要和回复');
+    });
+});

package/clis/linux-do/topic.js

@@ -0,0 +1,53 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { fetchLinuxDoJson } from './feed.js';
+function toLocalTime(utcStr) {
+    if (!utcStr)
+        return '';
+    const date = new Date(utcStr);
+    return Number.isNaN(date.getTime()) ? utcStr : date.toLocaleString();
+}
+function strip(html) {
+    return (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();
+}
+cli({
+    site: 'linux-do',
+    name: 'topic',
+    access: 'read',
+    description: 'linux.do 帖子首页摘要和回复（首屏）',
+    domain: 'linux.do',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'id', type: 'int', required: true, positional: true, help: 'Topic ID' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of posts' },
+    ],
+    columns: ['author', 'content', 'likes', 'created_at'],
+    func: async (page, kwargs) => {
+        const data = await fetchLinuxDoJson(page, `/t/${kwargs.id}.json`);
+        const posts = (data?.post_stream?.posts || []);
+        return posts.slice(0, kwargs.limit).map((p) => ({
+            author: p.username,
+            content: strip(p.cooked).slice(0, 200),
+            likes: p.like_count,
+            created_at: toLocalTime(p.created_at),
+        }));
+    },
+});

package/clis/linux-do/user-posts.js

@@ -0,0 +1,57 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { fetchLinuxDoJson } from './feed.js';
+function toLocalTime(utcStr) {
+    if (!utcStr)
+        return '';
+    const date = new Date(utcStr);
+    return Number.isNaN(date.getTime()) ? utcStr : date.toLocaleString();
+}
+function strip(html) {
+    return (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();
+}
+cli({
+    site: 'linux-do',
+    name: 'user-posts',
+    access: 'read',
+    description: 'linux.do 用户的帖子',
+    domain: 'linux.do',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'username', required: true, positional: true, help: 'Username' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of posts' },
+    ],
+    columns: ['index', 'topic_user', 'topic', 'reply', 'time', 'url'],
+    func: async (page, kwargs) => {
+        const username = String(kwargs.username);
+        const limit = kwargs.limit;
+        const data = await fetchLinuxDoJson(page, `/user_actions.json?username=${encodeURIComponent(username)}&filter=5&offset=0&limit=${limit}`);
+        const actions = (data?.user_actions || []);
+        return actions.slice(0, limit).map((a, i) => ({
+            index: i + 1,
+            topic_user: a.acting_username || a.username || '',
+            topic: a.title || '',
+            reply: strip(a.excerpt).slice(0, 200),
+            time: toLocalTime(a.created_at),
+            url: 'https://linux.do/t/topic/' + a.topic_id + '/' + a.post_number,
+        }));
+    },
+});

package/clis/linux-do/user-topics.js

@@ -0,0 +1,37 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { fetchLinuxDoJson } from './feed.js';
+function toLocalTime(utcStr) {
+    if (!utcStr)
+        return '';
+    const date = new Date(utcStr);
+    return Number.isNaN(date.getTime()) ? utcStr : date.toLocaleString();
+}
+cli({
+    site: 'linux-do',
+    name: 'user-topics',
+    access: 'read',
+    description: 'linux.do 用户创建的话题',
+    domain: 'linux.do',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'username', required: true, positional: true, help: 'Username' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of topics' },
+    ],
+    columns: ['rank', 'title', 'replies', 'created_at', 'likes', 'views', 'url'],
+    func: async (page, kwargs) => {
+        const username = String(kwargs.username);
+        const limit = kwargs.limit;
+        const data = await fetchLinuxDoJson(page, `/topics/created-by/${encodeURIComponent(username)}.json`);
+        const topics = (data?.topic_list?.topics || []);
+        return topics.slice(0, limit).map((t, i) => ({
+            rank: i + 1,
+            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,
+        }));
+    },
+});

package/clis/lobsters/active.js

@@ -0,0 +1,29 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'lobsters',
+    name: 'active',
+    access: 'read',
+    description: 'Lobste.rs most active discussions',
+    domain: 'lobste.rs',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of stories' },
+    ],
+    columns: ['rank', 'id', 'title', 'score', 'author', 'comments', 'created_at', 'tags', 'url'],
+    pipeline: [
+        { fetch: { url: 'https://lobste.rs/active.json' } },
+        { map: {
+                rank: '${{ index + 1 }}',
+                id: '${{ item.short_id }}',
+                title: '${{ item.title }}',
+                score: '${{ item.score }}',
+                author: '${{ item.submitter_user }}',
+                comments: '${{ item.comment_count }}',
+                created_at: '${{ item.created_at }}',
+                tags: `\${{ item.tags | join(', ') }}`,
+                url: '${{ item.comments_url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/clis/lobsters/domain.js

@@ -0,0 +1,92 @@
+// lobsters domain — list Lobste.rs stories submitted from a specific domain.
+//
+// Hits the public `https://lobste.rs/domains/<domain>.json` endpoint
+// (returns the same per-story shape used by `lobsters tag` / `lobsters
+// hot`). Lets agents ask "what did Lobsters surface from github.com /
+// blog.cloudflare.com / arxiv.org lately?".
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const DOMAIN_PATTERN = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+$/i;
+
+function requireDomain(value) {
+    const s = String(value ?? '').trim().toLowerCase();
+    if (!s) {
+        throw new ArgumentError('lobsters domain is required (e.g. "github.com" or "arxiv.org")');
+    }
+    if (!DOMAIN_PATTERN.test(s)) {
+        throw new ArgumentError(`lobsters domain "${value}" is not a valid hostname`);
+    }
+    return s;
+}
+
+function requireBoundedInt(value, defaultValue, maxValue) {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError('lobsters limit must be a positive integer');
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`lobsters limit must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+cli({
+    site: 'lobsters',
+    name: 'domain',
+    access: 'read',
+    description: 'Lobste.rs stories submitted from a specific domain',
+    domain: 'lobste.rs',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'domain', positional: true, required: true, help: 'Source domain (e.g. github.com, arxiv.org, blog.cloudflare.com)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of stories (1-25 — single page)' },
+    ],
+    columns: ['rank', 'id', 'title', 'score', 'author', 'comments', 'created_at', 'tags', 'submission_url', 'comments_url'],
+    func: async (args) => {
+        const domain = requireDomain(args.domain);
+        const limit = requireBoundedInt(args.limit, 20, 25);
+        const url = `https://lobste.rs/domains/${encodeURIComponent(domain)}.json`;
+        let resp;
+        try {
+            resp = await fetch(url, { headers: { 'user-agent': 'opencli-lobsters-adapter (+https://github.com/jackwener/opencli)' } });
+        }
+        catch (err) {
+            throw new CommandExecutionError(
+                `lobsters domain request failed: ${err?.message ?? err}`,
+                'Check that lobste.rs is reachable from this network.',
+            );
+        }
+        if (resp.status === 404) {
+            throw new EmptyResultError('lobsters domain', `No Lobste.rs stories found for domain "${domain}".`);
+        }
+        if (!resp.ok) {
+            throw new CommandExecutionError(`lobsters domain returned HTTP ${resp.status}`);
+        }
+        let body;
+        try {
+            body = await resp.json();
+        }
+        catch (err) {
+            throw new CommandExecutionError(`lobsters domain returned malformed JSON: ${err?.message ?? err}`);
+        }
+        const list = Array.isArray(body) ? body : [];
+        if (!list.length) {
+            throw new EmptyResultError('lobsters domain', `No Lobste.rs stories found for domain "${domain}".`);
+        }
+        return list.slice(0, limit).map((item, i) => ({
+            rank: i + 1,
+            id: String(item.short_id ?? ''),
+            title: String(item.title ?? ''),
+            score: item.score != null ? Number(item.score) : null,
+            author: String(item.submitter_user ?? ''),
+            comments: item.comment_count != null ? Number(item.comment_count) : null,
+            created_at: String(item.created_at ?? '').slice(0, 10),
+            tags: Array.isArray(item.tags) ? item.tags.join(', ') : '',
+            submission_url: String(item.url ?? ''),
+            comments_url: String(item.comments_url ?? ''),
+        }));
+    },
+});

package/clis/lobsters/hot.js

@@ -0,0 +1,29 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'lobsters',
+    name: 'hot',
+    access: 'read',
+    description: 'Lobste.rs hottest stories',
+    domain: 'lobste.rs',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of stories' },
+    ],
+    columns: ['rank', 'id', 'title', 'score', 'author', 'comments', 'created_at', 'tags', 'url'],
+    pipeline: [
+        { fetch: { url: 'https://lobste.rs/hottest.json' } },
+        { map: {
+                rank: '${{ index + 1 }}',
+                id: '${{ item.short_id }}',
+                title: '${{ item.title }}',
+                score: '${{ item.score }}',
+                author: '${{ item.submitter_user }}',
+                comments: '${{ item.comment_count }}',
+                created_at: '${{ item.created_at }}',
+                tags: `\${{ item.tags | join(', ') }}`,
+                url: '${{ item.comments_url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});