@jackwener/opencli 1.6.1 → 1.6.3

package/src/clis/pixiv/illusts.ts

@@ -1,78 +0,0 @@
-/**
- * Pixiv illusts — list illustrations by an artist.
- *
- * Two-step process:
- * 1. Fetch all illust IDs from the user's profile
- * 2. Batch-fetch details for the most recent ones (max 48 IDs per request)
- */
-
-import { cli, Strategy } from '../../registry.js';
-import { CommandExecutionError } from '../../errors.js';
-import { pixivFetch, BATCH_SIZE } from './utils.js';
-
-cli({
-  site: 'pixiv',
-  name: 'illusts',
-  description: "List a Pixiv artist's illustrations",
-  domain: 'www.pixiv.net',
-  strategy: Strategy.COOKIE,
-  args: [
-    { name: 'user-id', positional: true, required: true, help: 'Pixiv user ID' },
-    { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
-  ],
-  columns: ['rank', 'title', 'illust_id', 'pages', 'bookmarks', 'tags', 'created'],
-
-  func: async (page, kwargs) => {
-    const userId = String(kwargs['user-id'] ?? '');
-    const limit = Number(kwargs.limit) || 20;
-
-    if (!/^\d+$/.test(userId)) {
-      throw new CommandExecutionError(`Invalid user ID: ${userId}`);
-    }
-
-    // Step 1: get all illust IDs
-    const profileBody = await pixivFetch(page, `/ajax/user/${userId}/profile/all`, {
-      notFoundMsg: `User not found: ${userId}`,
-    });
-
-    const allIds = Object.keys(profileBody?.illusts || {})
-      .sort((a, b) => Number(b) - Number(a))
-      .slice(0, limit);
-
-    if (allIds.length === 0) return [];
-
-    // Step 2: batch fetch details (Pixiv supports up to ~48 IDs per request)
-    const allWorks: Record<string, any> = {};
-
-    for (let offset = 0; offset < allIds.length; offset += BATCH_SIZE) {
-      const batch = allIds.slice(offset, offset + BATCH_SIZE);
-      const idsParam = batch.map(id => `ids[]=${id}`).join('&');
-
-      // pixivFetch navigates on each call; for subsequent batches we re-navigate,
-      // which is fine — the cookie is already attached.
-      const detailBody = await pixivFetch(
-        page,
-        `/ajax/user/${userId}/profile/illusts?${idsParam}&work_category=illustManga&is_first_page=${offset === 0 ? 1 : 0}`,
-      );
-
-      Object.assign(allWorks, detailBody?.works || {});
-    }
-
-    return allIds
-      .map((id, i) => {
-        const w = allWorks[id];
-        if (!w) return null;
-        return {
-          rank: i + 1,
-          title: w.title || '',
-          illust_id: w.id,
-          pages: w.pageCount || 1,
-          bookmarks: w.bookmarkCount || 0,
-          tags: (w.tags || []).slice(0, 5).join(', '),
-          created: (w.createDate || '').split('T')[0],
-          url: 'https://www.pixiv.net/artworks/' + w.id,
-        };
-      })
-      .filter(Boolean);
-  },
-});

package/src/clis/pixiv/ranking.yaml

@@ -1,53 +0,0 @@
-site: pixiv
-name: ranking
-description: Pixiv illustration rankings (daily/weekly/monthly)
-domain: www.pixiv.net
-strategy: cookie
-browser: true
-
-args:
-  mode:
-    type: str
-    default: daily
-    description: Ranking mode
-    choices: [daily, weekly, monthly, rookie, original, male, female, daily_r18, weekly_r18]
-  page:
-    type: int
-    default: 1
-    description: Page number
-  limit:
-    type: int
-    default: 20
-    description: Number of results
-
-pipeline:
-  - navigate: https://www.pixiv.net
-
-  - evaluate: |
-      (async () => {
-        const mode = ${{ args.mode | json }};
-        const page = ${{ args.page | json }};
-        const limit = ${{ args.limit | json }};
-        const res = await fetch(
-          'https://www.pixiv.net/ranking.php?mode=' + mode + '&p=' + page + '&format=json',
-          { credentials: 'include' }
-        );
-        if (!res.ok) {
-          if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
-          throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
-        }
-        const data = await res.json();
-        const items = (data?.contents || []).slice(0, limit);
-        return items.map((item, i) => ({
-          rank: item.rank,
-          title: item.title,
-          author: item.user_name,
-          user_id: item.user_id,
-          illust_id: item.illust_id,
-          pages: item.illust_page_count,
-          bookmarks: item.illust_bookmark_count,
-          url: 'https://www.pixiv.net/artworks/' + item.illust_id
-        }));
-      })()
-
-columns: [rank, title, author, illust_id, pages, bookmarks]

package/src/clis/pixiv/search.test.ts

@@ -1,97 +0,0 @@
-import { beforeAll, describe, expect, it } from 'vitest';
-import type { CliCommand } from '../../registry.js';
-import { getRegistry } from '../../registry.js';
-import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
-import { createPageMock } from './test-utils.js';
-import './search.js';
-
-let cmd: CliCommand;
-
-beforeAll(() => {
-  cmd = getRegistry().get('pixiv/search')!;
-  expect(cmd?.func).toBeTypeOf('function');
-});
-
-describe('pixiv search', () => {
-  it('throws AuthRequiredError on 401', async () => {
-    const page = createPageMock([{ __httpError: 401 }]);
-
-    await expect(cmd.func!(page, { query: '初音ミク', limit: 5 })).rejects.toThrow(AuthRequiredError);
-  });
-
-  it('throws generic error on non-auth HTTP failure', async () => {
-    const page = createPageMock([{ __httpError: 500 }]);
-
-    await expect(cmd.func!(page, { query: 'test', limit: 5 })).rejects.toThrow(CommandExecutionError);
-  });
-
-  it('returns ranked results with correct fields', async () => {
-    const page = createPageMock([
-      {
-        body: {
-          illust: {
-            data: [
-              {
-                id: '12345',
-                title: 'Miku Illustration',
-                userName: 'artist1',
-                userId: '100',
-                pageCount: 3,
-                bookmarkCount: 500,
-                tags: ['初音ミク', 'VOCALOID', 'ミク'],
-              },
-              {
-                id: '67890',
-                title: 'Another Art',
-                userName: 'artist2',
-                userId: '200',
-                pageCount: 1,
-                bookmarkCount: 100,
-                tags: ['オリジナル'],
-              },
-            ],
-          },
-        },
-      },
-    ]);
-
-    const result = (await cmd.func!(page, { query: '初音ミク', limit: 10 })) as any[];
-
-    expect(result).toHaveLength(2);
-    expect(result[0]).toMatchObject({
-      rank: 1,
-      title: 'Miku Illustration',
-      author: 'artist1',
-      illust_id: '12345',
-      pages: 3,
-      bookmarks: 500,
-    });
-    expect(result[1]).toMatchObject({ rank: 2, illust_id: '67890' });
-  });
-
-  it('respects the limit parameter', async () => {
-    const page = createPageMock([
-      {
-        body: {
-          illust: {
-            data: [
-              { id: '1', title: 'A', userName: 'u1', userId: '1', pageCount: 1, bookmarkCount: 0, tags: [] },
-              { id: '2', title: 'B', userName: 'u2', userId: '2', pageCount: 1, bookmarkCount: 0, tags: [] },
-              { id: '3', title: 'C', userName: 'u3', userId: '3', pageCount: 1, bookmarkCount: 0, tags: [] },
-            ],
-          },
-        },
-      },
-    ]);
-
-    const result = (await cmd.func!(page, { query: 'test', limit: 2 })) as any[];
-    expect(result).toHaveLength(2);
-  });
-
-  it('returns empty array when no results', async () => {
-    const page = createPageMock([{ body: { illust: { data: [] } } }]);
-
-    const result = await cmd.func!(page, { query: 'nonexistent', limit: 10 });
-    expect(result).toEqual([]);
-  });
-});

package/src/clis/pixiv/search.ts

@@ -1,53 +0,0 @@
-/**
- * Pixiv search — search illustrations by keyword/tag.
- *
- * Uses the internal Ajax search API with browser cookies for authentication.
- */
-
-import { cli, Strategy } from '../../registry.js';
-import { pixivFetch } from './utils.js';
-
-cli({
-  site: 'pixiv',
-  name: 'search',
-  description: 'Search Pixiv illustrations by keyword',
-  domain: 'www.pixiv.net',
-  strategy: Strategy.COOKIE,
-  args: [
-    { name: 'query', positional: true, required: true, help: 'Search keyword or tag' },
-    { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
-    { name: 'order', type: 'str', default: 'date_d', help: 'Sort order', choices: ['date_d', 'date', 'popular_d', 'popular_male_d', 'popular_female_d'] },
-    { name: 'mode', type: 'str', default: 'all', help: 'Search mode', choices: ['all', 'safe', 'r18'] },
-    { name: 'page', type: 'int', default: 1, help: 'Page number' },
-  ],
-  columns: ['rank', 'title', 'author', 'illust_id', 'pages', 'bookmarks', 'tags'],
-
-  func: async (page, kwargs) => {
-    const { query, limit = 20, order = 'date_d', mode = 'all', page: pageNum = 1 } = kwargs;
-    const encoded = encodeURIComponent(query);
-
-    // Pixiv search API requires the keyword in BOTH the URL path and the `word` query param.
-    const body = await pixivFetch(
-      page,
-      `/ajax/search/illustrations/${encoded}`,
-      { params: { word: query, order, mode, p: pageNum, s_mode: 's_tag_full', type: 'illust_and_ugoira' } },
-    );
-
-    const items: any[] = body?.illust?.data || [];
-
-    return items
-      .filter((item: any) => item.id)
-      .slice(0, Number(limit))
-      .map((item: any, i: number) => ({
-        rank: i + 1,
-        title: item.title || '',
-        author: item.userName || '',
-        user_id: item.userId || '',
-        illust_id: item.id,
-        pages: item.pageCount || 1,
-        bookmarks: item.bookmarkCount || 0,
-        tags: (item.tags || []).slice(0, 5).join(', '),
-        url: 'https://www.pixiv.net/artworks/' + item.id,
-      }));
-  },
-});

package/src/clis/pixiv/test-utils.ts

@@ -1,29 +0,0 @@
-import { vi } from 'vitest';
-import type { IPage } from '../../types.js';
-
-/**
- * Create a minimal page mock with only the methods commonly used by Pixiv adapters.
- *
- * Since all TS adapters now go through `pixivFetch` which calls `page.evaluate`,
- * the evaluate results should match the raw Pixiv Ajax response format:
- * - Success: `{ body: ... }` (pixivFetch returns the `body` field)
- * - HTTP error: `{ __httpError: <status> }` (pixivFetch detects and throws)
- *
- * Additional methods can be overridden via the overrides parameter.
- */
-export function createPageMock(
-  evaluateResults: any[],
-  overrides?: Partial<IPage>,
-): IPage {
-  const evaluate = vi.fn();
-  for (const result of evaluateResults) {
-    evaluate.mockResolvedValueOnce(result);
-  }
-
-  return {
-    goto: vi.fn().mockResolvedValue(undefined),
-    evaluate,
-    getCookies: vi.fn().mockResolvedValue([]),
-    ...overrides,
-  } as unknown as IPage;
-}

package/src/clis/pixiv/user.yaml

@@ -1,46 +0,0 @@
-site: pixiv
-name: user
-description: View Pixiv artist profile
-domain: www.pixiv.net
-strategy: cookie
-browser: true
-
-args:
-  uid:
-    type: str
-    required: true
-    positional: true
-    description: Pixiv user ID
-
-pipeline:
-  - navigate: https://www.pixiv.net
-
-  - evaluate: |
-      (async () => {
-        const uid = ${{ args.uid | json }};
-        const res = await fetch(
-          'https://www.pixiv.net/ajax/user/' + uid + '?full=1',
-          { credentials: 'include' }
-        );
-        if (!res.ok) {
-          if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
-          if (res.status === 404) throw new Error('User not found: ' + uid);
-          throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
-        }
-        const data = await res.json();
-        const b = data?.body;
-        if (!b) throw new Error('User not found');
-        return [{
-          user_id: uid,
-          name: b.name,
-          premium: b.premium ? 'Yes' : 'No',
-          following: b.following,
-          illusts: typeof b.illusts === 'object' ? Object.keys(b.illusts).length : (b.illusts || 0),
-          manga: typeof b.manga === 'object' ? Object.keys(b.manga).length : (b.manga || 0),
-          novels: typeof b.novels === 'object' ? Object.keys(b.novels).length : (b.novels || 0),
-          comment: (b.comment || '').slice(0, 80),
-          url: 'https://www.pixiv.net/users/' + uid
-        }];
-      })()
-
-columns: [user_id, name, premium, following, illusts, manga, novels, comment]

package/src/clis/pixiv/utils.ts

@@ -1,62 +0,0 @@
-/**
- * Pixiv shared helpers: authenticated Ajax fetch with standard error handling.
- *
- * All Pixiv Ajax APIs return `{ error: false, body: ... }` on success.
- * On failure the HTTP status code is used to distinguish auth (401/403),
- * not-found (404), and other errors.
- */
-
-import type { IPage } from '../../types.js';
-import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
-
-const PIXIV_DOMAIN = 'www.pixiv.net';
-
-/**
- * Navigate to Pixiv (to attach cookies) then fetch a Pixiv Ajax API endpoint.
- *
- * Handles the common navigate → evaluate(fetch) → error-check pattern used
- * by every Pixiv TS adapter.
- *
- * @param page  - Browser page instance
- * @param path  - API path, e.g. '/ajax/illust/12345'
- * @param opts  - Optional query params
- * @returns     - The parsed `body` from the JSON response
- * @throws AuthRequiredError on 401/403
- * @throws CommandExecutionError on 404 or other HTTP errors
- */
-export async function pixivFetch(
-  page: IPage,
-  path: string,
-  opts: { params?: Record<string, string | number>; notFoundMsg?: string } = {},
-): Promise<any> {
-  await page.goto(`https://${PIXIV_DOMAIN}`);
-
-  const qs = opts.params
-    ? '?' + Object.entries(opts.params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join('&')
-    : '';
-  const url = `https://${PIXIV_DOMAIN}${path}${qs}`;
-
-  const data: any = await page.evaluate(`
-    (async () => {
-      const res = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
-      if (!res.ok) return { __httpError: res.status };
-      return await res.json();
-    })()
-  `);
-
-  if (data?.__httpError) {
-    const status = data.__httpError;
-    if (status === 401 || status === 403) {
-      throw new AuthRequiredError(PIXIV_DOMAIN, 'Authentication required — please log in to Pixiv in Chrome');
-    }
-    if (status === 404) {
-      throw new CommandExecutionError(opts.notFoundMsg || `Pixiv resource not found (HTTP 404)`);
-    }
-    throw new CommandExecutionError(`Pixiv request failed (HTTP ${status})`);
-  }
-
-  return data?.body;
-}
-
-/** Maximum number of illust IDs per batch detail request (Pixiv server limit). */
-export const BATCH_SIZE = 48;

package/src/clis/producthunt/browse.ts

@@ -1,109 +0,0 @@
-/**
- * Product Hunt category browse — INTERCEPT strategy.
- *
- * Navigates to a Product Hunt category page and scrapes the top-rated products.
- * Shows all-time best products for a category (ranked by review score, not daily votes).
- */
-import { cli, Strategy } from '../../registry.js';
-import { CliError } from '../../errors.js';
-import type { IPage } from '../../types.js';
-import { PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
-
-cli({
-  site: 'producthunt',
-  name: 'browse',
-  description: 'Best products in a Product Hunt category',
-  domain: 'www.producthunt.com',
-  strategy: Strategy.INTERCEPT,
-  args: [
-    {
-      name: 'category',
-      type: 'string',
-      positional: true,
-      required: true,
-      help: `Category slug, e.g. vibe-coding, ai-agents, developer-tools`,
-    },
-    { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
-  ],
-  columns: ['rank', 'name', 'tagline', 'reviews', 'url'],
-  func: async (page: IPage, args) => {
-    const count = Math.min(Number(args.limit) || 20, 50);
-    const slug = String(args.category || '').trim().toLowerCase();
-
-    await page.installInterceptor('producthunt.com');
-    await page.goto(`https://www.producthunt.com/categories/${slug}`);
-    await page.waitForCapture(5);
-
-    const domItems: any = await page.evaluate(`
-      (() => {
-        const seen = new Set();
-        const results = [];
-
-        // Card links: <a class="...flex-col" href="/products/<slug>"> (not review links)
-        const cardLinks = Array.from(document.querySelectorAll('a[href^="/products/"]')).filter(a => {
-          const href = a.getAttribute('href') || '';
-          const cls = a.className || '';
-          return cls.includes('flex-col') && !href.includes('/reviews');
-        });
-
-        for (const cardLink of cardLinks) {
-          const href = cardLink.getAttribute('href');
-          if (!href || seen.has(href)) continue;
-
-          // Child 0: div with name (strip "Launched this month/week/year" noise)
-          const nameDiv = cardLink.querySelector('div');
-          const rawName = nameDiv?.textContent?.trim() || '';
-          const name = rawName
-            .replace(/\\s*Launched\\s+this\\s+(month|week|year|day)\\s*/gi, '')
-            .replace(/\\s*Featured\\s*/gi, '')
-            .trim();
-
-          // Child 1: span.text-secondary — tagline
-          const taglineEl = cardLink.querySelector('span.text-secondary, span[class*="text-secondary"]');
-          const tagline = taglineEl?.textContent?.trim() || '';
-
-          if (!name) continue;
-
-          // Find reviews count from sibling /reviews link
-          let reviews = '';
-          let container = cardLink.parentElement;
-          for (let i = 0; i < 5 && container; i++) {
-            const reviewLink = container.querySelector('a[href="' + href + '/reviews"]');
-            if (reviewLink) {
-              reviews = (reviewLink.textContent?.trim() || '').replace(/\\s*reviews?\\s*/i, '').trim();
-              break;
-            }
-            container = container.parentElement;
-          }
-
-          seen.add(href);
-          results.push({
-            name,
-            tagline: tagline.slice(0, 120),
-            reviews: reviews || '0',
-            url: 'https://www.producthunt.com' + href,
-          });
-        }
-
-        return results;
-      })()
-    `);
-
-    const items = Array.isArray(domItems) ? (domItems as any[]) : [];
-    if (items.length === 0) {
-      throw new CliError(
-        'NO_DATA',
-        `No products found for category "${slug}"`,
-        'Check the category slug or try: ' + PRODUCTHUNT_CATEGORY_SLUGS.slice(0, 5).join(', '),
-      );
-    }
-
-    return items.slice(0, count).map((item: any, i: number) => ({
-      rank: i + 1,
-      name: item.name,
-      tagline: item.tagline,
-      reviews: item.reviews,
-      url: item.url,
-    }));
-  },
-});

package/src/clis/producthunt/hot.ts

@@ -1,127 +0,0 @@
-/**
- * Product Hunt top posts with vote counts — INTERCEPT strategy.
- *
- * Navigates to the Product Hunt homepage and scrapes rendered product cards.
- */
-import { cli, Strategy } from '../../registry.js';
-import { CliError } from '../../errors.js';
-import type { IPage } from '../../types.js';
-import { pickVoteCount } from './utils.js';
-
-cli({
-  site: 'producthunt',
-  name: 'hot',
-  description: "Today's top Product Hunt launches with vote counts",
-  domain: 'www.producthunt.com',
-  strategy: Strategy.INTERCEPT,
-  args: [
-    { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
-  ],
-  columns: ['rank', 'name', 'votes', 'url'],
-  func: async (page: IPage, args) => {
-    const count = Math.min(Number(args.limit) || 20, 50);
-
-    await page.installInterceptor('producthunt.com');
-    await page.goto('https://www.producthunt.com');
-    await page.waitForCapture(5);
-
-    const domItems: any = await page.evaluate(`
-      (() => {
-        const seen = new Set();
-        const results = [];
-
-        const cardLinks = Array.from(document.querySelectorAll('a[href^="/products/"]')).filter((el) => {
-          const href = el.getAttribute('href') || '';
-          const text = el.textContent?.trim() || '';
-          return href && !href.includes('/reviews') && text.length > 0 && text.length < 120;
-        });
-
-        const normalizeName = (text) => text
-          .replace(/^\\d+\\.\\s*/, '')
-          .replace(/\\s*Launched\\s+this\\s+(month|week|year|day)\\s*/gi, '')
-          .replace(/\\s*Featured\\s*/gi, '')
-          .trim();
-
-        for (const cardLink of cardLinks) {
-          const href = cardLink.getAttribute('href') || '';
-          if (!href || seen.has(href)) continue;
-
-          let card = cardLink;
-          let node = cardLink.parentElement;
-          for (let i = 0; i < 6 && node; i++) {
-            const hasReviewLink = !!node.querySelector('a[href="' + href + '/reviews"]');
-            const hasNumericNode = Array.from(node.querySelectorAll('button, [role="button"], p, span, div'))
-              .some((el) => /^\\d+$/.test(el.textContent?.trim() || ''));
-            if (hasReviewLink || hasNumericNode) {
-              card = node;
-              break;
-            }
-            node = node.parentElement;
-          }
-
-          const name = normalizeName(cardLink.textContent?.trim() || '');
-          if (!name) continue;
-
-          const voteCandidates = Array.from(card.querySelectorAll('button, [role="button"], a, p, span, div'))
-            .map((el) => {
-              const reviewLink = el.closest('a[href="' + href + '/reviews"]');
-              return {
-                text: el.textContent?.trim() || '',
-                tagName: el.tagName,
-                className: el.className || '',
-                role: el.getAttribute('role') || '',
-                inButton: !!el.closest('button, [role="button"]'),
-                inReviewLink: !!reviewLink,
-              };
-            })
-            .filter((candidate) => /^\\d+$/.test(candidate.text));
-
-          if (voteCandidates.length === 0) continue;
-
-          seen.add(href);
-          results.push({
-            name,
-            voteCandidates,
-            url: 'https://www.producthunt.com' + href,
-          });
-        }
-
-        return results;
-      })()
-    `);
-
-    const items = Array.isArray(domItems) ? (domItems as any[]) : [];
-    if (items.length === 0) {
-      throw new CliError(
-        'NO_DATA',
-        'Could not retrieve Product Hunt top posts',
-        'Product Hunt may have changed its layout',
-      );
-    }
-
-    const rankedItems = items
-      .map((item: any) => ({
-        name: item.name,
-        url: item.url,
-        votes: pickVoteCount(Array.isArray(item.voteCandidates) ? item.voteCandidates : []),
-      }))
-      .filter((item) => item.name && item.url && item.votes);
-
-    if (rankedItems.length === 0) {
-      throw new CliError(
-        'NO_DATA',
-        'Could not retrieve Product Hunt vote counts',
-        'Product Hunt may have changed its vote button structure',
-      );
-    }
-
-    rankedItems.sort((a, b) => parseInt(b.votes, 10) - parseInt(a.votes, 10));
-
-    return rankedItems.slice(0, count).map((item, i: number) => ({
-      rank: i + 1,
-      name: item.name,
-      votes: item.votes,
-      url: item.url,
-    }));
-  },
-});

package/src/clis/producthunt/posts.ts

@@ -1,29 +0,0 @@
-/**
- * Product Hunt latest posts — public Atom feed, no browser needed.
- */
-import { cli, Strategy } from '../../registry.js';
-import { fetchFeed, PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
-
-cli({
-  site: 'producthunt',
-  name: 'posts',
-  description: 'Latest Product Hunt launches (optional category filter)',
-  domain: 'www.producthunt.com',
-  strategy: Strategy.PUBLIC,
-  args: [
-    { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
-    {
-      name: 'category',
-      type: 'string',
-      default: '',
-      help: `Category filter: ${PRODUCTHUNT_CATEGORY_SLUGS.join(', ')}`,
-    },
-  ],
-  columns: ['rank', 'name', 'tagline', 'author', 'date', 'url'],
-  func: async (_page, args) => {
-    const count = Math.min(Number(args.limit) || 20, 50);
-    const category = String(args.category ?? '').trim() || undefined;
-    const posts = await fetchFeed(category);
-    return posts.slice(0, count);
-  },
-});