@jackwener/opencli 1.4.1 → 1.5.1

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

@@ -0,0 +1,46 @@
+import type { IPage } from '../../types.js';
+/**
+ * Normalize an IMDb title or person input to a bare ID.
+ * Accepts bare IDs, desktop URLs, mobile URLs, and URLs with language prefixes or query params.
+ */
+export declare function normalizeImdbId(input: string, prefix: 'tt' | 'nm'): string;
+/**
+ * Convert an ISO 8601 duration string to a short human-readable format for table display.
+ * Example: PT2H28M -> 2h 28m.
+ */
+export declare function formatDuration(iso: string): string;
+/**
+ * Force an IMDb page URL to use the English language parameter,
+ * reducing structural differences across localized pages.
+ */
+export declare function forceEnglishUrl(url: string): string;
+/**
+ * Normalize IMDb title-type payloads that may be represented as an object,
+ * a raw string, or an empty text field with only an internal id.
+ */
+export declare function normalizeImdbTitleType(input: unknown): string;
+/**
+ * Extract structured JSON-LD data from the page.
+ * Accepts a single type string or an array of types to match against @type.
+ */
+export declare function extractJsonLd(page: IPage, type?: string | string[]): Promise<Record<string, unknown> | null>;
+/**
+ * Poll until the current IMDb page path matches the expected entity/search path.
+ */
+export declare function waitForImdbPath(page: IPage, pathPattern: string, timeoutMs?: number): Promise<boolean>;
+/**
+ * Wait until IMDb search results (or the search UI state) has rendered.
+ */
+export declare function waitForImdbSearchReady(page: IPage, timeoutMs?: number): Promise<boolean>;
+/**
+ * Wait until IMDb review cards (or the page review summary) has rendered.
+ */
+export declare function waitForImdbReviewsReady(page: IPage, timeoutMs?: number): Promise<boolean>;
+/**
+ * Read the current IMDb entity id from the page URL/canonical metadata.
+ */
+export declare function getCurrentImdbId(page: IPage, prefix: 'tt' | 'nm'): Promise<string>;
+/**
+ * Detect whether the current page is an IMDb bot-challenge or verification page.
+ */
+export declare function isChallengePage(page: IPage): Promise<boolean>;

package/dist/clis/imdb/utils.js

@@ -0,0 +1,285 @@
+import { ArgumentError } from '../../errors.js';
+/**
+ * Normalize an IMDb title or person input to a bare ID.
+ * Accepts bare IDs, desktop URLs, mobile URLs, and URLs with language prefixes or query params.
+ */
+export function normalizeImdbId(input, prefix) {
+    const trimmed = input.trim();
+    const barePattern = new RegExp(`^${prefix}\\d{7,8}$`);
+    if (barePattern.test(trimmed)) {
+        return trimmed;
+    }
+    const pathPattern = new RegExp(`/(?:[a-z]{2}/)?(?:title|name)/(${prefix}\\d{7,8})(?:[/?#]|$)`, 'i');
+    const pathMatch = trimmed.match(pathPattern);
+    if (pathMatch) {
+        return pathMatch[1];
+    }
+    throw new ArgumentError(`Invalid IMDb ID: "${input}"`, `Expected ${prefix === 'tt' ? 'title' : 'name'} ID like ${prefix === 'tt' ? 'tt1375666' : 'nm0634240'} or an IMDb URL`);
+}
+/**
+ * Convert an ISO 8601 duration string to a short human-readable format for table display.
+ * Example: PT2H28M -> 2h 28m.
+ */
+export function formatDuration(iso) {
+    if (!iso) {
+        return '';
+    }
+    const match = iso.match(/^PT(?:(\d+)H)?(?:(\d+)M)?$/);
+    if (!match) {
+        return '';
+    }
+    const parts = [];
+    if (match[1]) {
+        parts.push(`${match[1]}h`);
+    }
+    if (match[2]) {
+        parts.push(`${match[2]}m`);
+    }
+    return parts.join(' ');
+}
+/**
+ * Force an IMDb page URL to use the English language parameter,
+ * reducing structural differences across localized pages.
+ */
+export function forceEnglishUrl(url) {
+    const parsed = new URL(url);
+    parsed.searchParams.set('language', 'en-US');
+    return parsed.toString();
+}
+/**
+ * Normalize IMDb title-type payloads that may be represented as an object,
+ * a raw string, or an empty text field with only an internal id.
+ */
+export function normalizeImdbTitleType(input) {
+    const raw = (() => {
+        if (typeof input === 'string')
+            return input;
+        if (!input || typeof input !== 'object')
+            return '';
+        const value = input;
+        return typeof value.text === 'string' && value.text.trim()
+            ? value.text
+            : typeof value.id === 'string'
+                ? value.id
+                : '';
+    })().trim();
+    if (!raw)
+        return '';
+    const known = {
+        movie: 'Movie',
+        short: 'Short',
+        video: 'Video',
+        tvEpisode: 'TV Episode',
+        tvMiniSeries: 'TV Mini Series',
+        tvMovie: 'TV Movie',
+        tvSeries: 'TV Series',
+        tvShort: 'TV Short',
+        tvSpecial: 'TV Special',
+        videoGame: 'Video Game',
+    };
+    return known[raw] ?? raw;
+}
+/**
+ * Extract structured JSON-LD data from the page.
+ * Accepts a single type string or an array of types to match against @type.
+ */
+export async function extractJsonLd(page, type) {
+    const filterTypes = type ? (Array.isArray(type) ? type : [type]) : [];
+    return page.evaluate(`
+    (function() {
+      var scripts = document.querySelectorAll('script[type="application/ld+json"]');
+      var wantedTypes = ${JSON.stringify(filterTypes)};
+
+      function matchesType(data) {
+        if (wantedTypes.length === 0) {
+          return true;
+        }
+        if (!data || typeof data !== 'object') {
+          return false;
+        }
+        if (wantedTypes.indexOf(data['@type']) !== -1) {
+          return true;
+        }
+        if (Array.isArray(data['@type'])) {
+          for (var t = 0; t < data['@type'].length; t++) {
+            if (wantedTypes.indexOf(data['@type'][t]) !== -1) return true;
+          }
+        }
+        return false;
+      }
+
+      function findMatch(data) {
+        if (Array.isArray(data)) {
+          for (var i = 0; i < data.length; i++) {
+            var itemMatch = findMatch(data[i]);
+            if (itemMatch) {
+              return itemMatch;
+            }
+          }
+          return null;
+        }
+
+        if (!data || typeof data !== 'object') {
+          return null;
+        }
+
+        if (matchesType(data)) {
+          return data;
+        }
+
+        if (Array.isArray(data['@graph'])) {
+          return findMatch(data['@graph']);
+        }
+
+        return null;
+      }
+
+      for (var i = 0; i < scripts.length; i++) {
+        try {
+          var parsed = JSON.parse(scripts[i].textContent || 'null');
+          var match = findMatch(parsed);
+          if (match) {
+            return match;
+          }
+        } catch (error) {
+          void error;
+        }
+      }
+
+      return null;
+    })()
+  `);
+}
+/**
+ * Poll until the current IMDb page path matches the expected entity/search path.
+ */
+export async function waitForImdbPath(page, pathPattern, timeoutMs = 15000) {
+    const result = await page.evaluate(`
+    (async function() {
+      var deadline = Date.now() + ${timeoutMs};
+      var pattern = new RegExp(${JSON.stringify(pathPattern)}, 'i');
+      while (Date.now() < deadline) {
+        if (pattern.test(window.location.pathname)) {
+          return true;
+        }
+        await new Promise(function(resolve) { setTimeout(resolve, 250); });
+      }
+      return pattern.test(window.location.pathname);
+    })()
+  `);
+    return Boolean(result);
+}
+/**
+ * Wait until IMDb search results (or the search UI state) has rendered.
+ */
+export async function waitForImdbSearchReady(page, timeoutMs = 15000) {
+    const result = await page.evaluate(`
+    (async function() {
+      var deadline = Date.now() + ${timeoutMs};
+
+      function hasSearchResults() {
+        var nextDataEl = document.getElementById('__NEXT_DATA__');
+        if (nextDataEl) {
+          try {
+            var nextData = JSON.parse(nextDataEl.textContent || 'null');
+            var pageProps = nextData && nextData.props && nextData.props.pageProps;
+            var titleResults = (pageProps && pageProps.titleResults && pageProps.titleResults.results) || [];
+            var nameResults = (pageProps && pageProps.nameResults && pageProps.nameResults.results) || [];
+            if (titleResults.length > 0 || nameResults.length > 0) {
+              return true;
+            }
+          } catch (error) {
+            void error;
+          }
+        }
+
+        if (document.querySelector('a[href*="/title/"], a[href*="/name/"]')) {
+          return true;
+        }
+
+        var body = document.body ? (document.body.textContent || '') : '';
+        return body.includes('No results found for') || body.includes('No exact matches');
+      }
+
+      while (Date.now() < deadline) {
+        if (hasSearchResults()) {
+          return true;
+        }
+        await new Promise(function(resolve) { setTimeout(resolve, 250); });
+      }
+
+      return hasSearchResults();
+    })()
+  `);
+    return Boolean(result);
+}
+/**
+ * Wait until IMDb review cards (or the page review summary) has rendered.
+ */
+export async function waitForImdbReviewsReady(page, timeoutMs = 15000) {
+    const result = await page.evaluate(`
+    (async function() {
+      var deadline = Date.now() + ${timeoutMs};
+
+      function hasReviewContent() {
+        if (document.querySelector('article.user-review-item, [data-testid="review-card-parent"], [data-testid="tturv-total-reviews"]')) {
+          return true;
+        }
+        var body = document.body ? (document.body.textContent || '') : '';
+        return body.includes('No user reviews') || body.includes('Review this title');
+      }
+
+      while (Date.now() < deadline) {
+        if (hasReviewContent()) {
+          return true;
+        }
+        await new Promise(function(resolve) { setTimeout(resolve, 250); });
+      }
+
+      return hasReviewContent();
+    })()
+  `);
+    return Boolean(result);
+}
+/**
+ * Read the current IMDb entity id from the page URL/canonical metadata.
+ */
+export async function getCurrentImdbId(page, prefix) {
+    const result = await page.evaluate(`
+    (function() {
+      var pattern = new RegExp('(${prefix}\\\\d{7,8})', 'i');
+      var candidates = [
+        window.location.pathname || '',
+        document.querySelector('link[rel="canonical"]')?.getAttribute('href') || '',
+        document.querySelector('meta[property="og:url"]')?.getAttribute('content') || ''
+      ];
+
+      for (var i = 0; i < candidates.length; i++) {
+        var match = candidates[i].match(pattern);
+        if (match) {
+          return match[1];
+        }
+      }
+      return '';
+    })()
+  `);
+    return typeof result === 'string' ? result : '';
+}
+/**
+ * Detect whether the current page is an IMDb bot-challenge or verification page.
+ */
+export async function isChallengePage(page) {
+    const result = await page.evaluate(`
+    (function() {
+      var title = document.title || '';
+      var body = document.body ? (document.body.textContent || '') : '';
+      return title.includes('Robot Check') ||
+        title.includes('Are you a robot') ||
+        title.includes('JavaScript is disabled') ||
+        body.includes('captcha') ||
+        body.includes('verify that you are human') ||
+        body.includes('not a robot');
+    })()
+  `);
+    return Boolean(result);
+}

package/dist/clis/imdb/utils.test.d.ts

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

package/dist/clis/imdb/utils.test.js

@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from 'vitest';
+import { extractJsonLd, forceEnglishUrl, formatDuration, getCurrentImdbId, isChallengePage, normalizeImdbTitleType, normalizeImdbId, waitForImdbPath, waitForImdbReviewsReady, waitForImdbSearchReady, } from './utils.js';
+describe('normalizeImdbId', () => {
+    it('passes through bare ids', () => {
+        expect(normalizeImdbId('tt1375666', 'tt')).toBe('tt1375666');
+        expect(normalizeImdbId('nm0634240', 'nm')).toBe('nm0634240');
+    });
+    it('extracts ids from supported urls', () => {
+        expect(normalizeImdbId('https://www.imdb.com/title/tt1375666/', 'tt')).toBe('tt1375666');
+        expect(normalizeImdbId('https://m.imdb.com/title/tt1375666/', 'tt')).toBe('tt1375666');
+        expect(normalizeImdbId('https://www.imdb.com/de/title/tt1375666/?ref_=nv_sr_srsg_0', 'tt')).toBe('tt1375666');
+        expect(normalizeImdbId('https://www.imdb.com/name/nm0634240/', 'nm')).toBe('nm0634240');
+    });
+    it('throws on invalid or mismatched ids', () => {
+        expect(() => normalizeImdbId('invalid', 'tt')).toThrow('Invalid IMDb ID');
+        expect(() => normalizeImdbId('tt1', 'tt')).toThrow('Invalid IMDb ID');
+        expect(() => normalizeImdbId('nm0634240', 'tt')).toThrow('Invalid IMDb ID');
+    });
+});
+describe('formatDuration', () => {
+    it('converts ISO-8601 durations to a short human format', () => {
+        expect(formatDuration('PT2H28M')).toBe('2h 28m');
+        expect(formatDuration('PT1H')).toBe('1h');
+        expect(formatDuration('PT45M')).toBe('45m');
+        expect(formatDuration('PT2H')).toBe('2h');
+    });
+    it('returns an empty string for invalid input', () => {
+        expect(formatDuration('')).toBe('');
+        expect(formatDuration('invalid')).toBe('');
+    });
+});
+describe('forceEnglishUrl', () => {
+    it('adds the English language parameter', () => {
+        expect(forceEnglishUrl('https://www.imdb.com/title/tt1375666/')).toContain('language=en-US');
+    });
+    it('preserves existing query parameters', () => {
+        const result = forceEnglishUrl('https://www.imdb.com/title/tt1375666/?ref_=nv');
+        expect(result).toContain('language=en-US');
+        expect(result).toContain('ref_=nv');
+    });
+});
+describe('normalizeImdbTitleType', () => {
+    it('maps internal imdb ids to readable labels', () => {
+        expect(normalizeImdbTitleType({ id: 'movie', text: '' })).toBe('Movie');
+        expect(normalizeImdbTitleType({ id: 'tvSeries', text: '' })).toBe('TV Series');
+        expect(normalizeImdbTitleType('short')).toBe('Short');
+    });
+    it('preserves explicit text labels', () => {
+        expect(normalizeImdbTitleType({ id: 'movie', text: 'Feature Film' })).toBe('Feature Film');
+    });
+});
+describe('extractJsonLd', () => {
+    it('returns the evaluated JSON-LD payload', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValue({ '@type': 'Movie', name: 'Inception' }),
+        };
+        await expect(extractJsonLd(page, 'Movie')).resolves.toEqual({ '@type': 'Movie', name: 'Inception' });
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(page.evaluate).toHaveBeenCalledWith(expect.stringContaining('"Movie"'));
+    });
+});
+describe('isChallengePage', () => {
+    it('returns true when the page evaluation matches a challenge', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValue(true),
+        };
+        await expect(isChallengePage(page)).resolves.toBe(true);
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
+});
+describe('imdb browser helpers', () => {
+    it('reads the current imdb id from page metadata', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValue('nm0634240'),
+        };
+        await expect(getCurrentImdbId(page, 'nm')).resolves.toBe('nm0634240');
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
+    it('wait helpers resolve mocked readiness booleans', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValue(true),
+        };
+        await expect(waitForImdbPath(page, '^/find/?$')).resolves.toBe(true);
+        await expect(waitForImdbSearchReady(page)).resolves.toBe(true);
+        await expect(waitForImdbReviewsReady(page)).resolves.toBe(true);
+        expect(page.evaluate).toHaveBeenCalledTimes(3);
+    });
+});

package/dist/clis/jd/item.d.ts

@@ -1 +1,5 @@
+declare function extractAvifImages(imageUrls: string[], maxImages: number): string[];
+export declare const __test__: {
+    extractAvifImages: typeof extractAvifImages;
+};
 export {};

package/dist/clis/jd/item.js

@@ -5,10 +5,16 @@
  * 用法: opencli jd item 100291143898
  */
 import { cli, Strategy } from '../../registry.js';
+function extractAvifImages(imageUrls, maxImages) {
+    const unique = [...new Set(imageUrls.filter(Boolean))];
+    return unique
+        .filter((url) => url.includes('.avif') && url.includes('pcpubliccms'))
+        .slice(0, maxImages);
+}
 cli({
     site: 'jd',
     name: 'item',
-    description: '京东商品详情（价格、主图、详情图、规格参数）',
+    description: '京东商品详情（价格、店铺、规格参数、AVIF 图片）',
     domain: 'item.jd.com',
     strategy: Strategy.COOKIE,
     args: [
@@ -22,17 +28,17 @@ cli({
             name: 'images',
             type: 'int',
             default: 10,
-            help: '详情图数量（默认10）',
+            help: 'AVIF 图片数量上限（默认10）',
         },
     ],
-    columns: ['title', 'price', 'shop', 'specs', 'mainImages', 'detailImages'],
+    columns: ['title', 'price', 'shop', 'specs', 'avifImages'],
     func: async (page, kwargs) => {
         const sku = kwargs.sku;
         const maxImages = kwargs.images;
         const url = `https://item.jd.com/${sku}.html`;
         await page.goto(url, { waitUntil: 'load' });
         await page.wait(2);
-        // 滚动加载详情图
+        // 滚动加载商品详情区域中的延迟图片
         for (let i = 0; i < 6; i++) {
             await page.evaluate(`window.scrollTo(0, ${i * 2500})`);
             await page.wait(1);
@@ -61,17 +67,9 @@ cli({
         // 所有图片
         const allImgs = Array.from(document.querySelectorAll('img[src*="360buyimg.com"]'));
         const srcs = allImgs.map(img => img.src).filter(Boolean);
-        const unique = [...new Set(srcs)];
 
-        // 主图
-        const mainImgs = unique
-          .filter(u => u.includes('/n1/') || u.includes('/n3/') || u.includes('/n4/') || u.includes('/img/'))
-          .slice(0, maxImg);
-
-        // 详情图
-        const detailImgs = unique
-          .filter(u => u.includes('/babel/') || u.includes('/popshop/'))
-          .slice(0, maxImg);
+        // 所有 avif 图片（去重，只保留 pcpubliccms CDN）
+        const avifImages = ${extractAvifImages.toString()}(srcs, maxImg);
 
         // 规格参数：从页面文本提取
         const text = document.body.innerText;
@@ -88,9 +86,12 @@ cli({
           }
         }
 
-        return { title, price, shop, specs, mainImages: mainImgs, detailImages: detailImgs, totalImages: unique.length };
+        return { title, price, shop, specs, avifImages, totalImages: new Set(srcs).size };
       })()
     `);
         return [data];
     },
 });
+export const __test__ = {
+    extractAvifImages,
+};

package/dist/clis/jd/item.test.js

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { getRegistry } from '../../registry.js';
+import { __test__ } from './item.js';
 import './item.js';
 describe('jd item adapter', () => {
     const command = getRegistry().get('jd/item');
@@ -23,6 +24,20 @@ describe('jd item adapter', () => {
         expect(imagesArg.default).toBe(10);
     });
     it('includes expected columns', () => {
-        expect(command.columns).toEqual(expect.arrayContaining(['title', 'price', 'shop', 'specs', 'mainImages', 'detailImages']));
+        expect(command.columns).toEqual(expect.arrayContaining(['title', 'price', 'shop', 'specs', 'avifImages']));
+    });
+    it('extracts only pcpubliccms avif images and respects the limit', () => {
+        const result = __test__.extractAvifImages([
+            'https://img14.360buyimg.com/n1/jfs/t1/normal.jpg',
+            'https://img10.360buyimg.com/imgzone/jfs/t1/detail.avif',
+            'https://pcpubliccms.jd.com/image1.avif',
+            'https://pcpubliccms.jd.com/image1.avif',
+            'https://pcpubliccms.jd.com/image2.avif?x=1',
+            'https://example.com/not-jd.avif',
+        ], 2);
+        expect(result).toEqual([
+            'https://pcpubliccms.jd.com/image1.avif',
+            'https://pcpubliccms.jd.com/image2.avif?x=1',
+        ]);
     });
 });

package/dist/clis/linux-do/categories.yaml

@@ -2,9 +2,14 @@ site: linux-do
 name: categories
 description: linux.do 分类列表
 domain: linux.do
+strategy: cookie
 browser: true
 
 args:
+  subcategories:
+    type: boolean
+    default: false
+    description: Include subcategories
   limit:
     type: int
     default: 20
@@ -20,13 +25,39 @@ pipeline:
         let data;
         try { data = await res.json(); } catch { throw new Error('响应不是有效 JSON - 请先登录 linux.do'); }
         const cats = data?.category_list?.categories || [];
-        return cats.slice(0, ${{ args.limit }}).map(c => ({
-          name: c.name,
-          slug: c.slug,
-          id: c.id,
-          topics: c.topic_count,
-          description: (c.description_text || '').slice(0, 80),
-        }));
+        const showSub = ${{ args.subcategories }};
+        const results = [];
+        const limit = ${{ args.limit }};
+        for (const c of cats.slice(0, ${{ args.limit }})) {
+          results.push({
+            name: c.name,
+            slug: c.slug,
+            id: c.id,
+            topics: c.topic_count,
+            description: (c.description_text || '').slice(0, 80),
+          });
+          if (results.length >= limit) break;
+          if (showSub && c.subcategory_ids && c.subcategory_ids.length > 0) {
+            const subRes = await fetch('/categories.json?parent_category_id=' + c.id, { credentials: 'include' });
+            if (subRes.ok) {
+              let subData;
+              try { subData = await subRes.json(); } catch { continue; }
+              const subCats = subData?.category_list?.categories || [];
+              for (const sc of subCats) {
+                results.push({
+                  name: c.name + ' / ' + sc.name,
+                  slug: sc.slug,
+                  id: sc.id,
+                  topics: sc.topic_count,
+                  description: (sc.description_text || '').slice(0, 80),
+                });
+                if (results.length >= limit) break;
+              }
+            }
+          }
+          if (results.length >= limit) break;
+        }
+        return results;
       })()
 
   - map:
@@ -36,6 +67,4 @@ pipeline:
       topics: ${{ item.topics }}
       description: ${{ item.description }}
 
-  - limit: ${{ args.limit }}
-
 columns: [name, slug, id, topics, description]

package/dist/clis/linux-do/category.d.ts

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

package/dist/clis/linux-do/category.js

@@ -0,0 +1,36 @@
+import { cli, Strategy } from '../../registry.js';
+import { buildLinuxDoCompatFooter, executeLinuxDoFeed } from './feed.js';
+cli({
+    site: 'linux-do',
+    name: 'category',
+    description: 'linux.do 分类内话题',
+    domain: 'linux.do',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    columns: ['title', 'replies', 'created', 'likes', 'views', 'url'],
+    deprecated: 'opencli linux-do category is kept for backward compatibility.',
+    replacedBy: 'opencli linux-do feed --category <id-or-name>',
+    args: [
+        {
+            name: 'slug',
+            positional: true,
+            type: 'str',
+            required: true,
+            help: 'Category slug (legacy compatibility argument)',
+        },
+        {
+            name: 'id',
+            positional: true,
+            type: 'int',
+            required: true,
+            help: 'Category ID',
+        },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of items (per_page)' },
+    ],
+    func: async (page, kwargs) => executeLinuxDoFeed(page, {
+        limit: kwargs.limit,
+        category: String(kwargs.id),
+        view: 'latest',
+    }),
+    footerExtra: (kwargs) => buildLinuxDoCompatFooter(`opencli linux-do feed --category ${kwargs.id ?? '<id>'}`),
+});

package/dist/clis/linux-do/feed.d.ts

@@ -0,0 +1,45 @@
+import { type Arg, type CommandArgs } from '../../registry.js';
+import type { IPage } from '../../types.js';
+interface LinuxDoTagRecord {
+    id: number;
+    slug: string;
+    name: string;
+}
+interface LinuxDoCategoryRecord {
+    id: number;
+    name: string;
+    description: string;
+    slug: string;
+    parentCategoryId: number | null;
+}
+interface ResolvedLinuxDoCategory extends LinuxDoCategoryRecord {
+    parent: LinuxDoCategoryRecord | null;
+}
+interface FeedRequest {
+    url: string;
+}
+interface TopicListItem {
+    title: string;
+    replies: number;
+    created: string;
+    likes: number;
+    views: number;
+    url: string;
+}
+/**
+ * 将命令参数转换为最终请求地址
+ */
+declare function resolveFeedRequest(page: IPage | null, kwargs: Record<string, any>): Promise<FeedRequest>;
+export declare const LINUX_DO_FEED_ARGS: Arg[];
+export declare function executeLinuxDoFeed(page: IPage | null, kwargs: CommandArgs): Promise<TopicListItem[]>;
+export declare function buildLinuxDoCompatFooter(replacement: string): string;
+export declare const __test__: {
+    resetMetadataCaches(): void;
+    setLiveMetadataForTests({ tags, categories, }: {
+        tags?: LinuxDoTagRecord[] | null;
+        categories?: ResolvedLinuxDoCategory[] | null;
+    }): void;
+    setCacheDirForTests(dir: string | null): void;
+    resolveFeedRequest: typeof resolveFeedRequest;
+};
+export {};