@jackwener/opencli 1.7.3 → 1.7.5

package/clis/xiaoyuzhou/podcast-episodes.js

@@ -1,30 +1,34 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { CliError } from '@jackwener/opencli/errors';
-import { fetchPageProps, formatDuration, formatDate } from './utils.js';
+import { loadXiaoyuzhouCredentials, requestXiaoyuzhouJson } from './auth.js';
+import { formatDuration, formatDate } from './utils.js';
 cli({
     site: 'xiaoyuzhou',
     name: 'podcast-episodes',
-    description: 'List recent episodes of a Xiaoyuzhou podcast (up to 15, SSR limit)',
+    description: 'List episodes of a Xiaoyuzhou podcast',
     domain: 'www.xiaoyuzhoufm.com',
-    strategy: Strategy.PUBLIC,
+    strategy: Strategy.LOCAL,
     browser: false,
     args: [
         { name: 'id', positional: true, required: true, help: 'Podcast ID (from xiaoyuzhoufm.com URL)' },
-        { name: 'limit', type: 'int', default: 15, help: 'Max episodes to show (up to 15, SSR limit)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max episodes to show' },
     ],
     columns: ['eid', 'title', 'duration', 'plays', 'date'],
     func: async (_page, args) => {
-        const pageProps = await fetchPageProps(`/podcast/${args.id}`);
-        const podcast = pageProps.podcast;
-        if (!podcast)
-            throw new CliError('NOT_FOUND', 'Podcast not found', 'Please check the ID');
-        const allEpisodes = podcast.episodes ?? [];
         const requestedLimit = Number(args.limit);
         if (!Number.isInteger(requestedLimit) || requestedLimit < 1) {
             throw new CliError('INVALID_ARGUMENT', 'limit must be a positive integer', 'Example: --limit 5');
         }
-        const limit = Math.min(requestedLimit, allEpisodes.length);
-        const episodes = allEpisodes.slice(0, limit);
+        const credentials = loadXiaoyuzhouCredentials();
+        const response = await requestXiaoyuzhouJson('/v1/podcast/listEpisode', {
+            method: 'POST',
+            body: { pid: args.id, limit: requestedLimit },
+            credentials,
+        });
+        const episodes = response.data ?? [];
+        if (!Array.isArray(episodes)) {
+            throw new CliError('PARSE_ERROR', 'Unexpected API response format', 'Expected an array of episodes');
+        }
         return episodes.map((ep) => ({
             eid: ep.eid,
             title: ep.title,

package/clis/xiaoyuzhou/podcast.js

@@ -1,18 +1,23 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { CliError } from '@jackwener/opencli/errors';
-import { fetchPageProps, formatDate } from './utils.js';
+import { loadXiaoyuzhouCredentials, requestXiaoyuzhouJson } from './auth.js';
+import { formatDate } from './utils.js';
 cli({
     site: 'xiaoyuzhou',
     name: 'podcast',
     description: 'View a Xiaoyuzhou podcast profile',
     domain: 'www.xiaoyuzhoufm.com',
-    strategy: Strategy.PUBLIC,
+    strategy: Strategy.LOCAL,
     browser: false,
     args: [{ name: 'id', positional: true, required: true, help: 'Podcast ID (from xiaoyuzhoufm.com URL)' }],
     columns: ['title', 'author', 'description', 'subscribers', 'episodes', 'updated'],
     func: async (_page, args) => {
-        const pageProps = await fetchPageProps(`/podcast/${args.id}`);
-        const p = pageProps.podcast;
+        const credentials = loadXiaoyuzhouCredentials();
+        const response = await requestXiaoyuzhouJson('/v1/podcast/get', {
+            query: { pid: args.id },
+            credentials,
+        });
+        const p = response.data;
         if (!p)
             throw new CliError('NOT_FOUND', 'Podcast not found', 'Please check the ID');
         return [{

package/clis/xiaoyuzhou/transcript.js

@@ -0,0 +1,76 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CliError } from '@jackwener/opencli/errors';
+import { loadXiaoyuzhouCredentials, requestXiaoyuzhouJson, fetchXiaoyuzhouTranscriptBody, extractTranscriptText } from './auth.js';
+
+cli({
+    site: 'xiaoyuzhou',
+    name: 'transcript',
+    description: 'Download Xiaoyuzhou transcript as JSON and text (requires local credentials)',
+    domain: 'www.xiaoyuzhoufm.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Episode ID (eid from podcast-episodes output)' },
+        { name: 'output', default: './xiaoyuzhou-transcripts', help: 'Output directory' },
+        { name: 'json', type: 'boolean', default: true, help: 'Save transcript JSON file' },
+        { name: 'text', type: 'boolean', default: true, help: 'Save extracted transcript text file' },
+    ],
+    columns: ['title', 'podcast', 'status', 'segments', 'json_file', 'text_file'],
+    func: async (_page, kwargs) => {
+        if (kwargs.json === false && kwargs.text === false) {
+            throw new ArgumentError('At least one of --json or --text must be enabled', 'Example: opencli xiaoyuzhou transcript 69dd0c98e2c8be31551f6a33 --text true');
+        }
+        let credentials = loadXiaoyuzhouCredentials();
+        const episodeResponse = await requestXiaoyuzhouJson('/v1/episode/get', {
+            query: { eid: kwargs.id },
+            credentials,
+        });
+        credentials = episodeResponse.credentials;
+        const episode = episodeResponse.data;
+        if (!episode) {
+            throw new CliError('NOT_FOUND', 'Episode not found', 'Please check the episode ID');
+        }
+        const mediaId = String(episode.transcript?.mediaId || episode.media?.id || episode.transcriptMediaId || '').trim();
+        if (!mediaId) {
+            throw new CliError('PARSE_ERROR', 'mediaId not found in episode payload', 'Transcript metadata requires episode.transcript.mediaId, episode.media.id, or episode.transcriptMediaId');
+        }
+        const transcriptResponse = await requestXiaoyuzhouJson('/v1/episode-transcript/get', {
+            method: 'POST',
+            body: {
+                eid: kwargs.id,
+                mediaId,
+            },
+            credentials,
+        });
+        const transcriptMeta = transcriptResponse.data;
+        const transcriptUrl = String(transcriptMeta?.transcriptUrl || transcriptMeta?.url || '').trim();
+        if (!transcriptUrl) {
+            throw new CliError('EMPTY_RESULT', 'Transcript URL not found', 'This episode may not have transcript data available');
+        }
+        const transcriptBody = await fetchXiaoyuzhouTranscriptBody(transcriptUrl);
+        const { text, segmentCount } = extractTranscriptText(transcriptBody);
+        if (kwargs.text !== false && transcriptBody.trim() && !text.trim()) {
+            throw new CliError('PARSE_ERROR', 'Failed to extract transcript text', 'Transcript payload format is unsupported. Re-run with --json true to inspect the raw payload.');
+        }
+        const outputDir = path.join(String(kwargs.output || './xiaoyuzhou-transcripts'), String(kwargs.id));
+        fs.mkdirSync(outputDir, { recursive: true });
+        const jsonPath = path.join(outputDir, 'transcript.json');
+        const textPath = path.join(outputDir, 'transcript.txt');
+        if (kwargs.json !== false) {
+            fs.writeFileSync(jsonPath, transcriptBody, 'utf-8');
+        }
+        if (kwargs.text !== false) {
+            fs.writeFileSync(textPath, text, 'utf-8');
+        }
+        return [{
+                title: episode.title || 'episode',
+                podcast: episode.podcast?.title || '-',
+                status: 'success',
+                segments: kwargs.text === false ? '-' : String(segmentCount),
+                json_file: kwargs.json === false ? '-' : jsonPath,
+                text_file: kwargs.text === false ? '-' : textPath,
+            }];
+    },
+});

package/clis/xiaoyuzhou/transcript.test.js

@@ -0,0 +1,195 @@
+import path from 'node:path';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+
+const { mockLoadCredentials, mockRequestJson, mockFetchTranscriptBody, mockMkdirSync, mockWriteFileSync } = vi.hoisted(() => ({
+    mockLoadCredentials: vi.fn(),
+    mockRequestJson: vi.fn(),
+    mockFetchTranscriptBody: vi.fn(),
+    mockMkdirSync: vi.fn(),
+    mockWriteFileSync: vi.fn(),
+}));
+
+vi.mock('./auth.js', async () => {
+    const actual = await vi.importActual('./auth.js');
+    return {
+        ...actual,
+        loadXiaoyuzhouCredentials: mockLoadCredentials,
+        requestXiaoyuzhouJson: mockRequestJson,
+        fetchXiaoyuzhouTranscriptBody: mockFetchTranscriptBody,
+    };
+});
+
+vi.mock('node:fs', () => ({
+    mkdirSync: mockMkdirSync,
+    writeFileSync: mockWriteFileSync,
+}));
+
+await import('./transcript.js');
+
+let cmd;
+
+function toPosixPath(value) {
+    return value.replaceAll(path.sep, '/');
+}
+
+beforeAll(() => {
+    cmd = getRegistry().get('xiaoyuzhou/transcript');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+
+describe('xiaoyuzhou transcript', () => {
+    beforeEach(() => {
+        mockLoadCredentials.mockReset();
+        mockRequestJson.mockReset();
+        mockFetchTranscriptBody.mockReset();
+        mockMkdirSync.mockReset();
+        mockWriteFileSync.mockReset();
+        mockLoadCredentials.mockReturnValue({ access_token: 'access', refresh_token: 'refresh' });
+    });
+
+    it('downloads transcript json and extracted text files', async () => {
+        mockRequestJson
+            .mockResolvedValueOnce({
+            credentials: { access_token: 'access-1', refresh_token: 'refresh-1' },
+            data: {
+                title: 'Transcript Episode',
+                podcast: { title: 'OpenCLI FM' },
+                transcript: { mediaId: 'media-123' },
+            },
+        })
+            .mockResolvedValueOnce({
+            credentials: { access_token: 'access-1', refresh_token: 'refresh-1' },
+            data: {
+                transcriptUrl: 'https://cdn.example.com/transcript.json',
+            },
+        });
+        mockFetchTranscriptBody.mockResolvedValue(JSON.stringify({
+            segments: [{ text: 'hello' }, { text: 'world' }],
+        }));
+        const result = await cmd.func(null, {
+            id: 'ep123',
+            output: '/tmp/xiaoyuzhou-transcripts',
+            json: true,
+            text: true,
+        });
+        expect(mockRequestJson).toHaveBeenNthCalledWith(1, '/v1/episode/get', {
+            query: { eid: 'ep123' },
+            credentials: { access_token: 'access', refresh_token: 'refresh' },
+        });
+        expect(mockRequestJson).toHaveBeenNthCalledWith(2, '/v1/episode-transcript/get', {
+            method: 'POST',
+            body: { eid: 'ep123', mediaId: 'media-123' },
+            credentials: { access_token: 'access-1', refresh_token: 'refresh-1' },
+        });
+        expect(mockMkdirSync).toHaveBeenCalledWith('/tmp/xiaoyuzhou-transcripts/ep123', { recursive: true });
+        expect(mockWriteFileSync).toHaveBeenNthCalledWith(1, '/tmp/xiaoyuzhou-transcripts/ep123/transcript.json', expect.any(String), 'utf-8');
+        expect(mockWriteFileSync).toHaveBeenNthCalledWith(2, '/tmp/xiaoyuzhou-transcripts/ep123/transcript.txt', 'hello\nworld', 'utf-8');
+        expect(result).toEqual([{
+                title: 'Transcript Episode',
+                podcast: 'OpenCLI FM',
+                status: 'success',
+                segments: '2',
+                json_file: '/tmp/xiaoyuzhou-transcripts/ep123/transcript.json',
+                text_file: '/tmp/xiaoyuzhou-transcripts/ep123/transcript.txt',
+            }]);
+    });
+
+    it('derives mediaId from episode.media.id when transcript.mediaId is absent', async () => {
+        mockRequestJson
+            .mockResolvedValueOnce({
+            credentials: { access_token: 'access-1', refresh_token: 'refresh-1' },
+            data: {
+                title: 'Transcript Episode',
+                podcast: { title: 'OpenCLI FM' },
+                media: { id: 'media-456' },
+            },
+        })
+            .mockResolvedValueOnce({
+            credentials: { access_token: 'access-1', refresh_token: 'refresh-1' },
+            data: {
+                transcriptUrl: 'https://cdn.example.com/transcript.json',
+            },
+        });
+        mockFetchTranscriptBody.mockResolvedValue(JSON.stringify({ text: 'hello' }));
+        await cmd.func(null, {
+            id: 'ep456',
+            output: '/tmp/xiaoyuzhou-transcripts',
+            json: false,
+            text: true,
+        });
+        expect(mockRequestJson.mock.calls[1][1].body.mediaId).toBe('media-456');
+        expect(mockWriteFileSync).toHaveBeenCalledTimes(1);
+        expect(mockWriteFileSync).toHaveBeenCalledWith('/tmp/xiaoyuzhou-transcripts/ep456/transcript.txt', 'hello', 'utf-8');
+    });
+
+    it('throws when transcript url is missing', async () => {
+        mockRequestJson
+            .mockResolvedValueOnce({
+            credentials: { access_token: 'access-1', refresh_token: 'refresh-1' },
+            data: {
+                title: 'Transcript Episode',
+                podcast: { title: 'OpenCLI FM' },
+                transcript: { mediaId: 'media-123' },
+            },
+        })
+            .mockResolvedValueOnce({
+            credentials: { access_token: 'access-1', refresh_token: 'refresh-1' },
+            data: {},
+        });
+        await expect(cmd.func(null, {
+            id: 'ep123',
+            output: '/tmp/xiaoyuzhou-transcripts',
+            json: true,
+            text: true,
+        })).rejects.toMatchObject({
+            code: 'EMPTY_RESULT',
+            message: 'Transcript URL not found',
+        });
+        expect(mockWriteFileSync).not.toHaveBeenCalled();
+    });
+
+    it('throws parse_error when transcript text extraction fails', async () => {
+        mockRequestJson
+            .mockResolvedValueOnce({
+            credentials: { access_token: 'access-1', refresh_token: 'refresh-1' },
+            data: {
+                title: 'Transcript Episode',
+                podcast: { title: 'OpenCLI FM' },
+                transcript: { mediaId: 'media-123' },
+            },
+        })
+            .mockResolvedValueOnce({
+            credentials: { access_token: 'access-1', refresh_token: 'refresh-1' },
+            data: {
+                transcriptUrl: 'https://cdn.example.com/transcript.json',
+            },
+        });
+        mockFetchTranscriptBody.mockResolvedValue(JSON.stringify({
+            segments: [{ startAt: 0, endAt: 1 }],
+        }));
+        await expect(cmd.func(null, {
+            id: 'ep123',
+            output: '/tmp/xiaoyuzhou-transcripts',
+            json: true,
+            text: true,
+        })).rejects.toMatchObject({
+            code: 'PARSE_ERROR',
+            message: 'Failed to extract transcript text',
+        });
+        expect(mockWriteFileSync).not.toHaveBeenCalled();
+    });
+
+    it('rejects disabling both json and text outputs', async () => {
+        await expect(cmd.func(null, {
+            id: 'ep123',
+            output: '/tmp/xiaoyuzhou-transcripts',
+            json: false,
+            text: false,
+        })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: 'At least one of --json or --text must be enabled',
+        });
+        expect(mockRequestJson).not.toHaveBeenCalled();
+    });
+});

package/clis/xiaoyuzhou/utils.js

@@ -1,43 +1,3 @@
-/**
- * Shared Xiaoyuzhou utilities — page data extraction and formatting.
- *
- * Xiaoyuzhou (小宇宙) is a Next.js app that embeds full page data in
- * <script id="__NEXT_DATA__">. We fetch the HTML and extract that JSON
- * instead of using their authenticated API.
- */
-import { CliError } from '@jackwener/opencli/errors';
-/**
- * Fetch a Xiaoyuzhou page and extract __NEXT_DATA__.props.pageProps.
- * @param path - URL path, e.g. '/podcast/xxx' or '/episode/xxx'
- */
-export async function fetchPageProps(path) {
-    const url = `https://www.xiaoyuzhoufm.com${path}`;
-    // Node.js fetch sends UA "node" which gets blocked; use a browser-like UA
-    const resp = await fetch(url, {
-        headers: { 'User-Agent': 'Mozilla/5.0 (compatible; opencli)' },
-    });
-    if (!resp.ok) {
-        throw new CliError('FETCH_ERROR', `HTTP ${resp.status} for ${path}`, 'Please check the ID — you can find it in xiaoyuzhoufm.com URLs');
-    }
-    const html = await resp.text();
-    // [\s\S]*? for multiline safety (JSON may span lines)
-    const match = html.match(/<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/);
-    if (!match) {
-        throw new CliError('PARSE_ERROR', 'Failed to extract __NEXT_DATA__', 'Page structure may have changed');
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(match[1]);
-    }
-    catch {
-        throw new CliError('PARSE_ERROR', 'Malformed __NEXT_DATA__ JSON', 'Page structure may have changed');
-    }
-    const pageProps = parsed.props?.pageProps;
-    if (!pageProps || Object.keys(pageProps).length === 0) {
-        throw new CliError('NOT_FOUND', 'Resource not found', 'Please check the ID — you can find it in xiaoyuzhoufm.com URLs');
-    }
-    return pageProps;
-}
 /** Format seconds to mm:ss (e.g. 3890 → "64:50"). Returns '-' for invalid input. */
 export function formatDuration(seconds) {
     if (!Number.isFinite(seconds) || seconds < 0)

package/clis/xiaoyuzhou/utils.test.js

@@ -1,5 +1,5 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { formatDuration, formatDate, fetchPageProps } from './utils.js';
+import { describe, it, expect } from 'vitest';
+import { formatDuration, formatDate } from './utils.js';
 describe('formatDuration', () => {
     it('formats typical duration', () => {
         expect(formatDuration(3890)).toBe('64:50');
@@ -8,13 +8,13 @@ describe('formatDuration', () => {
         expect(formatDuration(0)).toBe('0:00');
     });
     it('pads single-digit seconds', () => {
-        expect(formatDuration(65)).toBe('1:05');
+        expect(formatDuration(62)).toBe('1:02');
     });
-    it('formats exact minutes', () => {
-        expect(formatDuration(3600)).toBe('60:00');
+    it('handles exact minutes', () => {
+        expect(formatDuration(120)).toBe('2:00');
     });
-    it('rounds floating-point seconds', () => {
-        expect(formatDuration(3890.7)).toBe('64:51');
+    it('rounds fractional seconds', () => {
+        expect(formatDuration(65.7)).toBe('1:06');
     });
     it('returns dash for NaN', () => {
         expect(formatDuration(NaN)).toBe('-');
@@ -22,78 +22,18 @@ describe('formatDuration', () => {
     it('returns dash for negative', () => {
         expect(formatDuration(-1)).toBe('-');
     });
+    it('returns dash for Infinity', () => {
+        expect(formatDuration(Infinity)).toBe('-');
+    });
 });
 describe('formatDate', () => {
-    it('extracts YYYY-MM-DD from ISO string', () => {
-        expect(formatDate('2026-03-13T11:00:06.686Z')).toBe('2026-03-13');
-    });
-    it('handles date-only string', () => {
-        expect(formatDate('2025-01-01')).toBe('2025-01-01');
+    it('slices ISO string to date', () => {
+        expect(formatDate('2026-03-15T12:00:00Z')).toBe('2026-03-15');
     });
-    it('returns dash for undefined/empty', () => {
+    it('returns dash for empty string', () => {
         expect(formatDate('')).toBe('-');
-        expect(formatDate(undefined)).toBe('-');
-    });
-});
-describe('fetchPageProps', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('extracts pageProps from valid HTML', async () => {
-        const mockHtml = `<html><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"podcast":{"title":"Test"}}}}</script></html>`;
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: true,
-            text: () => Promise.resolve(mockHtml),
-        }));
-        const result = await fetchPageProps('/podcast/abc123');
-        expect(result).toEqual({ podcast: { title: 'Test' } });
     });
-    it('throws on HTTP error', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: false,
-            status: 404,
-            text: () => Promise.resolve('Not Found'),
-        }));
-        await expect(fetchPageProps('/podcast/invalid')).rejects.toThrow('HTTP 404');
-    });
-    it('throws when __NEXT_DATA__ is missing', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: true,
-            text: () => Promise.resolve('<html><body>No data here</body></html>'),
-        }));
-        await expect(fetchPageProps('/podcast/abc')).rejects.toThrow('Failed to extract');
-    });
-    it('throws when pageProps is empty', async () => {
-        const mockHtml = `<script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{}}}</script>`;
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: true,
-            text: () => Promise.resolve(mockHtml),
-        }));
-        await expect(fetchPageProps('/podcast/abc')).rejects.toThrow('Resource not found');
-    });
-    it('throws on malformed JSON in __NEXT_DATA__', async () => {
-        const mockHtml = `<script id="__NEXT_DATA__" type="application/json">{broken json</script>`;
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: true,
-            text: () => Promise.resolve(mockHtml),
-        }));
-        await expect(fetchPageProps('/podcast/abc')).rejects.toThrow('Malformed __NEXT_DATA__');
-    });
-    it('handles multiline JSON in __NEXT_DATA__', async () => {
-        const mockHtml = `<script id="__NEXT_DATA__" type="application/json">
-{
-  "props": {
-    "pageProps": {
-      "episode": {"title": "Multiline Test"}
-    }
-  }
-}
-</script>`;
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: true,
-            text: () => Promise.resolve(mockHtml),
-        }));
-        const result = await fetchPageProps('/episode/abc');
-        expect(result).toEqual({ episode: { title: 'Multiline Test' } });
+    it('returns dash for undefined', () => {
+        expect(formatDate(undefined)).toBe('-');
     });
 });

package/clis/youtube/feed.js

@@ -0,0 +1,120 @@
+/**
+ * YouTube feed — homepage recommended videos.
+ * Reads ytInitialData from the homepage directly (personalized, no separate API call needed).
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+cli({
+    site: 'youtube',
+    name: 'feed',
+    description: 'Get YouTube homepage recommended videos',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Max videos to return (default 20, max 100)' },
+    ],
+    columns: ['rank', 'title', 'channel', 'views', 'duration', 'published', 'url'],
+    func: async (page, kwargs) => {
+        const limit = Math.min(kwargs.limit || 20, 100);
+        await page.goto('https://www.youtube.com');
+        await page.wait(3);
+        const data = await page.evaluate(`
+      (async () => {
+        const d = window.ytInitialData;
+        if (!d) return { error: 'YouTube data not found — are you logged in?' };
+
+        const limit = ${limit};
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+
+        function extractFromItem(item) {
+          // Modern lockupViewModel format
+          const lvm = item.richItemRenderer?.content?.lockupViewModel;
+          if (lvm && lvm.contentType === 'LOCKUP_CONTENT_TYPE_VIDEO') {
+            const meta = lvm.metadata?.lockupMetadataViewModel;
+            const rows = meta?.metadata?.contentMetadataViewModel?.metadataRows || [];
+            const parts = rows.flatMap(r => (r.metadataParts || []).map(p => p.text?.content || '').filter(Boolean));
+            let duration = '';
+            for (const ov of (lvm.contentImage?.thumbnailViewModel?.overlays || [])) {
+              for (const b of (ov.thumbnailBottomOverlayViewModel?.badges || [])) {
+                if (b.thumbnailBadgeViewModel?.text) duration = b.thumbnailBadgeViewModel.text;
+              }
+            }
+            return {
+              title: meta?.title?.content || '',
+              channel: parts[0] || '',
+              views: parts[1] || '',
+              duration,
+              published: parts[2] || '',
+              videoId: lvm.contentId,
+            };
+          }
+
+          // Legacy videoRenderer format
+          const v = item.richItemRenderer?.content?.videoRenderer || item.videoRenderer;
+          if (v?.videoId) {
+            return {
+              title: v.title?.runs?.[0]?.text || '',
+              channel: v.ownerText?.runs?.[0]?.text || v.shortBylineText?.runs?.[0]?.text || '',
+              views: v.viewCountText?.simpleText || v.shortViewCountText?.simpleText || '',
+              duration: v.lengthText?.simpleText || '',
+              published: v.publishedTimeText?.simpleText || '',
+              videoId: v.videoId,
+            };
+          }
+          return null;
+        }
+
+        const tabs = d.contents?.twoColumnBrowseResultsRenderer?.tabs || [];
+        const richContents = tabs[0]?.tabRenderer?.content?.richGridRenderer?.contents || [];
+
+        const videos = [];
+        for (const item of richContents) {
+          if (videos.length >= limit) break;
+          const v = extractFromItem(item);
+          if (v?.videoId) {
+            videos.push({ rank: videos.length + 1, ...v, url: 'https://www.youtube.com/watch?v=' + v.videoId });
+          }
+        }
+
+        // Pagination
+        if (videos.length < limit && apiKey && context) {
+          let contItem = richContents[richContents.length - 1];
+          while (videos.length < limit && contItem?.continuationItemRenderer) {
+            const token = contItem.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+            if (!token) break;
+            const resp = await fetch('/youtubei/v1/browse?key=' + apiKey + '&prettyPrint=false', {
+              method: 'POST', credentials: 'include',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ context, continuation: token }),
+            });
+            if (!resp.ok) break;
+            const contData = await resp.json();
+            const newItems = contData.onResponseReceivedActions?.[0]?.appendContinuationItemsAction?.continuationItems || [];
+            if (!newItems.length) break;
+            for (const item of newItems) {
+              if (videos.length >= limit) break;
+              const v = extractFromItem(item);
+              if (v?.videoId) {
+                videos.push({ rank: videos.length + 1, ...v, url: 'https://www.youtube.com/watch?v=' + v.videoId });
+              }
+            }
+            contItem = newItems[newItems.length - 1];
+          }
+        }
+
+        return videos;
+      })()
+    `);
+        if (!Array.isArray(data)) {
+            const errMsg = data && typeof data === 'object' ? String(data.error || '') : '';
+            throw new CommandExecutionError(errMsg || 'Failed to fetch YouTube feed');
+        }
+        if (data.length === 0) {
+            throw new EmptyResultError('youtube feed');
+        }
+        return data;
+    },
+});