@jackwener/opencli 1.7.11 → 1.7.13

package/clis/linkedin/search.js

@@ -1,5 +1,9 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+const LINKEDIN_DOMAIN = 'linkedin.com';
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 100;
+const MIN_START = 0;
 // ── Filter value mappings ──────────────────────────────────────────────
 const EXPERIENCE_LEVELS = {
     internship: '1',
@@ -66,6 +70,19 @@ function mapFilterValues(input, mapping, label) {
 function normalizeWhitespace(value) {
     return String(value ?? '').replace(/\s+/g, ' ').trim();
 }
+function parseIntegerArg(value, label, fallback, min, max = Infinity) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`${label} must be an integer, got ${JSON.stringify(value)}`);
+    }
+    if (parsed < min || parsed > max) {
+        const range = Number.isFinite(max) ? `between ${min} and ${max}` : `at least ${min}`;
+        throw new ArgumentError(`${label} must be ${range}, got ${parsed}`);
+    }
+    return parsed;
+}
 function decodeLinkedinRedirect(url) {
     if (!url)
         return '';
@@ -120,6 +137,31 @@ function buildVoyagerUrl(input, offset, count) {
         .replace(/%29/gi, ')');
     return '/voyager/api/voyagerJobsDashJobCards?' + params.toString() + '&query=' + query + '&start=' + offset;
 }
+function looksLinkedInAuthWallText(value) {
+    const text = String(value ?? '').replace(/\s+/g, ' ').trim().toLowerCase();
+    if (!text)
+        return false;
+    return /\b(sign in|log in|join linkedin)\b/.test(text) ||
+        /linkedin\.com\/(login|checkpoint|authwall)/i.test(text) ||
+        /\b(captcha|verification required)\b/.test(text) ||
+        /(请登录|登录领英|安全验证)/.test(text);
+}
+function buildLinkedInAuthProbeScript() {
+    return `(() => {
+      const text = [
+        window.location.href || '',
+        document.title || '',
+        document.body ? (document.body.innerText || '').slice(0, 4000) : '',
+      ].join('\\n');
+      return ${looksLinkedInAuthWallText.toString()}(text);
+    })()`;
+}
+async function assertLinkedInAuthenticated(page, context) {
+    const authRequired = await page.evaluate(buildLinkedInAuthProbeScript());
+    if (authRequired) {
+        throw new AuthRequiredError(LINKEDIN_DOMAIN, `${context} requires an active signed-in LinkedIn browser session`);
+    }
+}
 // ── Company ID resolution (requires DOM interaction) ──────────────────
 async function resolveCompanyIds(page, input) {
     const rawValues = parseCsvArg(input);
@@ -209,13 +251,25 @@ async function fetchJobCards(page, input) {
         const batch = await page.evaluate(`(async () => {
       const jsession = document.cookie.split(';').map(p => p.trim())
         .find(p => p.startsWith('JSESSIONID='))?.slice('JSESSIONID='.length);
-      if (!jsession) return { error: 'LinkedIn JSESSIONID cookie not found. Please sign in to LinkedIn in the browser.' };
+      if (!jsession) {
+        return {
+          authRequired: true,
+          error: 'LinkedIn JSESSIONID cookie not found. Please sign in to LinkedIn in the browser.'
+        };
+      }
 
       const csrf = jsession.replace(/^"|"$/g, '');
       const res = await fetch(${JSON.stringify(apiPath)}, {
         credentials: 'include',
         headers: { 'csrf-token': csrf, 'x-restli-protocol-version': '2.0.0' },
       });
+      if (res.status === 401 || res.status === 403) {
+        const text = await res.text();
+        return {
+          authRequired: true,
+          error: 'LinkedIn API authentication failed: HTTP ' + res.status + ' ' + text.slice(0, 200)
+        };
+      }
       if (!res.ok) {
         const text = await res.text();
         return { error: 'LinkedIn API error: HTTP ' + res.status + ' ' + text.slice(0, 200) };
@@ -223,6 +277,9 @@ async function fetchJobCards(page, input) {
       return res.json();
     })()`);
         if (!batch || batch.error) {
+            if (batch?.authRequired) {
+                throw new AuthRequiredError(LINKEDIN_DOMAIN, batch.error);
+            }
             throw new CommandExecutionError(batch?.error || 'LinkedIn search returned an unexpected response');
         }
         const elements = Array.isArray(batch?.elements) ? batch.elements : [];
@@ -259,17 +316,31 @@ async function fetchJobCards(page, input) {
     }));
 }
 // ── Job detail enrichment (--details flag) ────────────────────────────
+//
+// Per-row failures should NOT abort the whole list (--details enriches N rows;
+// partial failure is expected). But silent empty-string fields hide the failure
+// from callers — previously `catch {}` and the `if (!job.url)` early-return
+// both produced indistinguishable `description: '', apply_url: ''` payloads,
+// so users could not tell "fetch failed" from "upstream had no description".
+//
+// The fix: surface `null` instead of `''` for missing/failed rows, set
+// `detail_error` to a short reason ("no url" / "fetch failed: <message>" /
+// "missing description"), and log every failure to stderr with the offending
+// URL so debugging is possible. Successful rows have `detail_error: null`.
 async function enrichJobDetails(page, jobs) {
     const enriched = [];
     for (let i = 0; i < jobs.length; i++) {
         const job = jobs[i];
         console.error(`[opencli:linkedin] Fetching details ${i + 1}/${jobs.length}: ${job.title}`);
         if (!job.url) {
-            enriched.push({ ...job, description: '', apply_url: '' });
+            const reason = 'no url';
+            console.error(`[opencli:linkedin] Skipping detail for "${job.title}": ${reason}`);
+            enriched.push({ ...job, description: null, apply_url: null, detail_error: reason });
             continue;
         }
         try {
             await page.goto(job.url);
+            await assertLinkedInAuthenticated(page, 'LinkedIn job detail');
             await page.wait({ text: 'About the job', timeout: 8 });
             // Expand "Show more" button if present
             await page.evaluate(`(() => {
@@ -301,14 +372,25 @@ async function enrichJobDetails(page, jobs) {
 
         return { description, applyUrl: applyLink?.href || '' };
       })()`);
+            const description = normalizeWhitespace(detail?.description);
+            const apply_url = decodeLinkedinRedirect(String(detail?.applyUrl ?? ''));
+            // Empty description after a successful fetch is itself a
+            // recognizable signal — surface it via detail_error instead of
+            // silently emitting an empty string.
+            const detail_error = description ? null : 'missing description';
             enriched.push({
                 ...job,
-                description: normalizeWhitespace(detail?.description),
-                apply_url: decodeLinkedinRedirect(String(detail?.applyUrl ?? '')),
+                description: description || null,
+                apply_url: apply_url || null,
+                detail_error,
             });
         }
-        catch {
-            enriched.push({ ...job, description: '', apply_url: '' });
+        catch (err) {
+            if (err instanceof AuthRequiredError)
+                throw err;
+            const reason = `fetch failed: ${err?.message || err}`;
+            console.error(`[opencli:linkedin] Detail fetch failed for ${job.url}: ${reason}`);
+            enriched.push({ ...job, description: null, apply_url: null, detail_error: reason });
         }
     }
     return enriched;
@@ -317,9 +399,10 @@ async function enrichJobDetails(page, jobs) {
 cli({
     site: 'linkedin',
     name: 'search',
+    access: 'read',
     description: 'Search LinkedIn jobs',
     domain: 'www.linkedin.com',
-    strategy: Strategy.HEADER,
+    strategy: Strategy.COOKIE,
     browser: true,
     args: [
         { name: 'query', type: 'string', required: true, positional: true, help: 'Job search keywords' },
@@ -335,8 +418,8 @@ cli({
     ],
     columns: ['rank', 'title', 'company', 'location', 'listed', 'salary', 'url'],
     func: async (page, kwargs) => {
-        const limit = Math.max(1, Math.min(kwargs.limit ?? 10, 100));
-        const start = Math.max(0, kwargs.start ?? 0);
+        const limit = parseIntegerArg(kwargs.limit, '--limit', 10, MIN_LIMIT, MAX_LIMIT);
+        const start = parseIntegerArg(kwargs.start, '--start', 0, MIN_START);
         const includeDetails = Boolean(kwargs.details);
         const location = (kwargs.location ?? '').trim();
         const keywords = String(kwargs.query ?? '').trim();
@@ -346,6 +429,7 @@ cli({
         if (location)
             searchParams.set('location', location);
         await page.goto(`https://www.linkedin.com/jobs/search/?${searchParams.toString()}`);
+        await assertLinkedInAuthenticated(page, 'LinkedIn search');
         await page.wait({ text: 'Jobs', timeout: 10 });
         const companyIds = await resolveCompanyIds(page, kwargs.company);
         const input = {
@@ -365,3 +449,17 @@ cli({
         return enrichJobDetails(page, data);
     },
 });
+
+export const __test__ = {
+    parseCsvArg,
+    parseIntegerArg,
+    mapFilterValues,
+    decodeLinkedinRedirect,
+    looksLinkedInAuthWallText,
+    assertLinkedInAuthenticated,
+    enrichJobDetails,
+    EXPERIENCE_LEVELS,
+    JOB_TYPES,
+    DATE_POSTED,
+    REMOTE_TYPES,
+};

package/clis/linkedin/search.test.js

@@ -0,0 +1,222 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError } from '@jackwener/opencli/errors';
+import { __test__ } from './search.js';
+
+const {
+    parseCsvArg,
+    parseIntegerArg,
+    mapFilterValues,
+    decodeLinkedinRedirect,
+    looksLinkedInAuthWallText,
+    enrichJobDetails,
+    EXPERIENCE_LEVELS,
+    JOB_TYPES,
+    DATE_POSTED,
+    REMOTE_TYPES,
+} = __test__;
+
+const getSearchCommand = () => getRegistry().get('linkedin/search');
+
+describe('linkedin parseCsvArg', () => {
+    it('returns empty array for empty / null / undefined', () => {
+        expect(parseCsvArg(undefined)).toEqual([]);
+        expect(parseCsvArg(null)).toEqual([]);
+        expect(parseCsvArg('')).toEqual([]);
+    });
+
+    it('splits and trims comma-separated values', () => {
+        expect(parseCsvArg('full-time, contract')).toEqual(['full-time', 'contract']);
+        expect(parseCsvArg(' a , b , , c ')).toEqual(['a', 'b', 'c']);
+    });
+});
+
+describe('linkedin mapFilterValues', () => {
+    it('maps known values to upstream codes and dedupes', () => {
+        expect(mapFilterValues('full-time, contract, full', JOB_TYPES, 'job_type')).toEqual(['F', 'C']);
+        expect(mapFilterValues('remote, hybrid', REMOTE_TYPES, 'remote')).toEqual(['2', '3']);
+    });
+
+    it('throws ArgumentError on unknown filter values (no silent drop)', () => {
+        expect(() => mapFilterValues('martian', JOB_TYPES, 'job_type')).toThrow(ArgumentError);
+        expect(() => mapFilterValues('full-time, ufo', JOB_TYPES, 'job_type')).toThrow(ArgumentError);
+    });
+
+    it('returns empty array for empty input', () => {
+        expect(mapFilterValues('', EXPERIENCE_LEVELS, 'experience_level')).toEqual([]);
+        expect(mapFilterValues(undefined, DATE_POSTED, 'date_posted')).toEqual([]);
+    });
+});
+
+describe('linkedin argument validation', () => {
+    it('rejects --limit outside 1..100 instead of silently clamping', () => {
+        expect(() => parseIntegerArg(0, '--limit', 10, 1, 100)).toThrow(ArgumentError);
+        expect(() => parseIntegerArg(101, '--limit', 10, 1, 100)).toThrow(ArgumentError);
+        expect(() => parseIntegerArg('10.5', '--limit', 10, 1, 100)).toThrow(ArgumentError);
+    });
+
+    it('rejects negative --start instead of silently clamping to zero', () => {
+        expect(() => parseIntegerArg(-1, '--start', 0, 0)).toThrow(ArgumentError);
+        expect(parseIntegerArg(undefined, '--start', 0, 0)).toBe(0);
+        expect(parseIntegerArg('25', '--start', 0, 0)).toBe(25);
+    });
+
+    it('validates command args before browser navigation', async () => {
+        const command = getSearchCommand();
+        const page = { goto: vi.fn(), wait: vi.fn(), evaluate: vi.fn() };
+
+        await expect(command.func(page, { query: 'engineer', limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(command.func(page, { query: 'engineer', start: -1 })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+});
+
+describe('linkedin auth wall detection', () => {
+    it('recognizes login/authwall signals', () => {
+        expect(looksLinkedInAuthWallText('https://www.linkedin.com/authwall?trk=guest Sign in to continue')).toBe(true);
+        expect(looksLinkedInAuthWallText('LinkedIn Login, Sign in')).toBe(true);
+        expect(looksLinkedInAuthWallText('About the job Senior infrastructure engineer')).toBe(false);
+    });
+
+    it('throws AuthRequiredError when search lands on a login wall', async () => {
+        const command = getSearchCommand();
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue(true),
+        };
+
+        await expect(command.func(page, { query: 'engineer', limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+});
+
+describe('linkedin decodeLinkedinRedirect', () => {
+    it('extracts the underlying url from a /redir/redirect/ wrapper', () => {
+        const target = 'https://example.com/jobs/apply?id=42';
+        const wrapped = `https://www.linkedin.com/redir/redirect/?url=${encodeURIComponent(target)}&source=jobs`;
+        expect(decodeLinkedinRedirect(wrapped)).toBe(target);
+    });
+
+    it('returns the input unchanged for non-redirect urls', () => {
+        const direct = 'https://example.com/jobs/42/';
+        expect(decodeLinkedinRedirect(direct)).toBe(direct);
+    });
+
+    it('returns empty string for falsy input', () => {
+        expect(decodeLinkedinRedirect('')).toBe('');
+        expect(decodeLinkedinRedirect(null)).toBe('');
+    });
+});
+
+describe('linkedin enrichJobDetails (silent failure fix)', () => {
+    function makeFakePage({ evaluateResults = [], gotoFails = [], evaluateFails = [] } = {}) {
+        let evalCall = 0;
+        let gotoCall = 0;
+        return {
+            goto: vi.fn(async () => {
+                if (gotoFails[gotoCall++]) {
+                    throw new Error(gotoFails[gotoCall - 1]);
+                }
+            }),
+            wait: vi.fn(async () => undefined),
+            evaluate: vi.fn(async () => {
+                const idx = evalCall++;
+                if (evaluateFails[idx]) throw new Error(evaluateFails[idx]);
+                return evaluateResults[idx];
+            }),
+        };
+    }
+
+    it('surfaces detail_error="no url" when row has no URL (instead of silent empty string)', async () => {
+        const page = makeFakePage();
+        const out = await enrichJobDetails(page, [
+            { rank: 1, title: 'No URL Job', company: 'X', url: '' },
+        ]);
+        expect(out).toHaveLength(1);
+        expect(out[0]).toMatchObject({
+            description: null,
+            apply_url: null,
+            detail_error: 'no url',
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('surfaces detail_error="fetch failed: ..." when goto throws (no silent swallow)', async () => {
+        const page = makeFakePage({ gotoFails: ['network down'] });
+        const out = await enrichJobDetails(page, [
+            { rank: 1, title: 'Fetch Fail', company: 'X', url: 'https://www.linkedin.com/jobs/view/1' },
+        ]);
+        expect(out).toHaveLength(1);
+        expect(out[0].description).toBeNull();
+        expect(out[0].apply_url).toBeNull();
+        expect(out[0].detail_error).toMatch(/^fetch failed: .*network down/);
+    });
+
+    it('surfaces detail_error="missing description" on empty description (signals upstream gap, not crash)', async () => {
+        const page = makeFakePage({
+            evaluateResults: [
+                false, // auth wall probe
+                undefined, // expand-show-more click result (ignored)
+                { description: '', applyUrl: '' },
+            ],
+        });
+        const out = await enrichJobDetails(page, [
+            { rank: 1, title: 'Empty Desc', company: 'X', url: 'https://www.linkedin.com/jobs/view/2' },
+        ]);
+        expect(out[0].description).toBeNull();
+        expect(out[0].apply_url).toBeNull();
+        expect(out[0].detail_error).toBe('missing description');
+    });
+
+    it('surfaces detail_error=null on a fully successful enrichment', async () => {
+        const page = makeFakePage({
+            evaluateResults: [
+                false, // auth wall probe
+                undefined,
+                { description: '  An interesting role  ', applyUrl: 'https://example.com/apply' },
+            ],
+        });
+        const out = await enrichJobDetails(page, [
+            { rank: 1, title: 'OK', company: 'X', url: 'https://www.linkedin.com/jobs/view/3' },
+        ]);
+        expect(out[0]).toMatchObject({
+            description: 'An interesting role',
+            apply_url: 'https://example.com/apply',
+            detail_error: null,
+        });
+    });
+
+    it('processes multiple rows with mixed outcomes without aborting the batch', async () => {
+        const page = makeFakePage({
+            evaluateResults: [
+                // Row 1 (success)
+                false,
+                undefined,
+                { description: 'Good', applyUrl: 'https://a.example/' },
+                // Row 3 (success — row 2 had no URL so didn't navigate)
+                false,
+                undefined,
+                { description: 'Also good', applyUrl: 'https://b.example/' },
+            ],
+        });
+        const out = await enrichJobDetails(page, [
+            { rank: 1, title: 'A', company: 'X', url: 'https://www.linkedin.com/jobs/view/10' },
+            { rank: 2, title: 'B', company: 'X', url: '' },
+            { rank: 3, title: 'C', company: 'X', url: 'https://www.linkedin.com/jobs/view/30' },
+        ]);
+        expect(out).toHaveLength(3);
+        expect(out[0].detail_error).toBeNull();
+        expect(out[1].detail_error).toBe('no url');
+        expect(out[2].detail_error).toBeNull();
+        // Goto was only called for rows with URL (1 and 3)
+        expect(page.goto).toHaveBeenCalledTimes(2);
+    });
+
+    it('throws AuthRequiredError on detail auth wall instead of burying it in detail_error', async () => {
+        const page = makeFakePage({ evaluateResults: [true] });
+
+        await expect(enrichJobDetails(page, [
+            { rank: 1, title: 'Needs Auth', company: 'X', url: 'https://www.linkedin.com/jobs/view/4' },
+        ])).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+});

package/clis/linkedin/timeline.js

@@ -460,6 +460,7 @@ async function extractVisiblePosts(page) {
 cli({
     site: 'linkedin',
     name: 'timeline',
+    access: 'read',
     description: 'Read LinkedIn home timeline posts',
     domain: 'www.linkedin.com',
     strategy: Strategy.COOKIE,

package/clis/linux-do/categories.js

@@ -3,6 +3,7 @@ import { fetchLinuxDoJson } from './feed.js';
 cli({
     site: 'linux-do',
     name: 'categories',
+    access: 'read',
     description: 'linux.do 分类列表',
     domain: 'linux.do',
     strategy: Strategy.COOKIE,

package/clis/linux-do/feed.js

@@ -355,26 +355,24 @@ export const LINUX_DO_FEED_ARGS = [
         choices: ['all', 'daily', 'weekly', 'monthly', 'quarterly', 'yearly'],
     },
 ];
-export async function executeLinuxDoFeed(page, kwargs) {
+async function runLinuxDoFeed(page, kwargs) {
     const limit = (kwargs.limit || 20);
     await ensureLinuxDoHome(page);
     const request = await resolveFeedRequest(page, kwargs);
     const data = await fetchLinuxDoJson(page, request.url, { skipNavigate: true });
     return topicListRichFromJson(data, limit);
 }
-export function buildLinuxDoCompatFooter(replacement) {
-    return `Deprecated compatibility command. Prefer: ${replacement}`;
-}
 cli({
     site: 'linux-do',
     name: 'feed',
+    access: 'read',
     description: 'linux.do 话题列表（需登录；支持全站、标签、分类）',
     domain: 'linux.do',
     strategy: Strategy.COOKIE,
     browser: true,
     columns: ['title', 'replies', 'created', 'likes', 'views', 'url'],
     args: LINUX_DO_FEED_ARGS,
-    func: executeLinuxDoFeed,
+    func: runLinuxDoFeed,
 });
 export const __test__ = {
     resetMetadataCaches() {

package/clis/linux-do/feed.test.js

@@ -7,6 +7,21 @@ describe('linux-do feed metadata resolution', () => {
     afterEach(() => {
         __test__.resetMetadataCaches();
     });
+    it('builds the replacement URL for legacy latest', async () => {
+        const request = await __test__.resolveFeedRequest(null, {
+            view: 'latest',
+            limit: 20,
+        });
+        expect(request.url).toBe('/latest.json?per_page=20');
+    });
+    it('builds the replacement URL for legacy hot weekly', async () => {
+        const request = await __test__.resolveFeedRequest(null, {
+            view: 'top',
+            period: 'weekly',
+            limit: 20,
+        });
+        expect(request.url).toBe('/top.json?per_page=20&period=weekly');
+    });
     it('prefers live tag metadata over the bundled snapshot', async () => {
         __test__.setLiveMetadataForTests({
             tags: [{ id: 9999, slug: 'fresh-tag', name: 'Fresh Tag' }],
@@ -86,6 +101,26 @@ describe('linux-do feed metadata resolution', () => {
         });
         expect(request.url).toBe('/c/parent/fresh-child/11.json?per_page=20');
     });
+    it('builds the replacement URL for legacy category id', async () => {
+        __test__.setLiveMetadataForTests({
+            categories: [
+                {
+                    id: 4,
+                    name: '开发调优',
+                    description: '',
+                    slug: 'develop',
+                    parentCategoryId: null,
+                    parent: null,
+                },
+            ],
+        });
+        const request = await __test__.resolveFeedRequest(null, {
+            category: '4',
+            view: 'latest',
+            limit: 20,
+        });
+        expect(request.url).toBe('/c/develop/4.json?per_page=20');
+    });
     it('falls back to cached metadata when live metadata is unavailable', async () => {
         const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-linux-do-cache-'));
         __test__.setCacheDirForTests(cacheDir);

package/clis/linux-do/search.js

@@ -3,6 +3,7 @@ import { fetchLinuxDoJson } from './feed.js';
 cli({
     site: 'linux-do',
     name: 'search',
+    access: 'read',
     description: '搜索 linux.do',
     domain: 'linux.do',
     strategy: Strategy.COOKIE,

package/clis/linux-do/tags.js

@@ -3,6 +3,7 @@ import { fetchLinuxDoJson } from './feed.js';
 cli({
     site: 'linux-do',
     name: 'tags',
+    access: 'read',
     description: 'linux.do 标签列表',
     domain: 'linux.do',
     strategy: Strategy.COOKIE,
@@ -10,7 +11,7 @@ cli({
     args: [
         { name: 'limit', type: 'int', default: 30, help: 'Number of tags' },
     ],
-    columns: ['rank', 'name', 'count', 'url'],
+    columns: ['rank', 'name', 'slug', 'count', 'url'],
     func: async (page, kwargs) => {
         const data = await fetchLinuxDoJson(page, '/tags.json');
         const tags = (data?.tags || []);

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

@@ -128,6 +128,7 @@ async function fetchTopicPayload(page, id) {
 cli({
     site: 'linux-do',
     name: 'topic-content',
+    access: 'read',
     description: 'Get the main topic body as Markdown',
     domain: LINUX_DO_DOMAIN,
     strategy: Strategy.COOKIE,

package/clis/linux-do/topic.js

@@ -30,6 +30,7 @@ function strip(html) {
 cli({
     site: 'linux-do',
     name: 'topic',
+    access: 'read',
     description: 'linux.do 帖子首页摘要和回复（首屏）',
     domain: 'linux.do',
     strategy: Strategy.COOKIE,

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

@@ -30,6 +30,7 @@ function strip(html) {
 cli({
     site: 'linux-do',
     name: 'user-posts',
+    access: 'read',
     description: 'linux.do 用户的帖子',
     domain: 'linux.do',
     strategy: Strategy.COOKIE,

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

@@ -9,6 +9,7 @@ function toLocalTime(utcStr) {
 cli({
     site: 'linux-do',
     name: 'user-topics',
+    access: 'read',
     description: 'linux.do 用户创建的话题',
     domain: 'linux.do',
     strategy: Strategy.COOKIE,

package/clis/lobsters/active.js

@@ -2,6 +2,7 @@ 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,
@@ -9,15 +10,17 @@ cli({
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Number of stories' },
     ],
-    columns: ['rank', 'title', 'score', 'author', 'comments', 'tags'],
+    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 }}',
             } },