@jackwener/opencli 1.7.3 → 1.7.4

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/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;
+    },
+});

package/clis/youtube/history.js

@@ -0,0 +1,118 @@
+/**
+ * YouTube history — watch history via InnerTube browse API (FEhistory).
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+cli({
+    site: 'youtube',
+    name: 'history',
+    description: 'Get YouTube watch history',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'limit', type: 'int', default: 30, help: 'Max videos to return (default 30, max 200)' },
+    ],
+    columns: ['rank', 'title', 'channel', 'views', 'duration', 'url'],
+    func: async (page, kwargs) => {
+        const limit = Math.min(kwargs.limit || 30, 200);
+        await page.goto('https://www.youtube.com/feed/history');
+        await page.wait(3);
+        await page.autoScroll({ times: Math.min(Math.max(Math.ceil(limit / 20), 1), 8), delayMs: 1200 });
+        const data = await page.evaluate(`
+      (async () => {
+        const limit = ${limit};
+
+        const videos = [];
+        const seen = new Set();
+        const root = document.querySelector('ytd-two-column-browse-results-renderer #primary ytd-section-list-renderer');
+        if (!root) return { error: 'YouTube history list not found' };
+
+        function text(el) {
+          return (el?.textContent || '').replace(/\\s+/g, ' ').trim();
+        }
+
+        function push(entry) {
+          if (!entry?.url || seen.has(entry.url) || videos.length >= limit) return;
+          seen.add(entry.url);
+          videos.push({ rank: videos.length + 1, ...entry });
+        }
+
+        for (const section of root.querySelectorAll('ytd-item-section-renderer')) {
+          if (videos.length >= limit) break;
+
+          for (const renderer of section.querySelectorAll('yt-lockup-view-model, ytd-video-renderer, ytd-rich-item-renderer, ytd-grid-video-renderer, ytd-compact-video-renderer')) {
+            if (videos.length >= limit) break;
+            const link = renderer.querySelector('a[href^="/watch?v="]');
+            const href = link?.getAttribute('href') || '';
+            if (!href) continue;
+            const title =
+              link?.getAttribute('title')
+              || text(renderer.querySelector('#video-title'))
+              || text(renderer.querySelector('h3 a'))
+              || text(renderer.querySelector('h3'))
+              || text(link);
+            const channel =
+              text(renderer.querySelector('#channel-name a'))
+              || text(renderer.querySelector('[aria-label^="前往频道："]'))
+              || text(renderer.querySelector('[aria-label^="Go to channel:"]'))
+              || text(renderer.querySelector('ytd-channel-name'))
+              || text(renderer.querySelector('#metadata #byline-container'))
+              || '';
+            const metadata = Array.from(renderer.querySelectorAll('#metadata-line span, #metadata span, .metadata span'))
+              .map(node => text(node))
+              .filter(Boolean);
+            const lockupMetadata = Array.from(renderer.querySelectorAll('yt-content-metadata-view-model span, yt-lockup-metadata-view-model span'))
+              .map(node => text(node))
+              .filter(Boolean);
+            const combinedMetadata = (metadata.length ? metadata : lockupMetadata)
+              .filter(value => value && value !== title && value !== '•');
+            const inferredChannel = channel || combinedMetadata.find(value => !/观看|views|前|前に|ago|次观看|次查看|stream/i.test(value)) || '';
+            const inferredViews = combinedMetadata.find(value => /观看|views/i.test(value)) || '';
+            const inferredPublished = combinedMetadata.find(value => value !== inferredChannel && value !== inferredViews) || '';
+            const duration =
+              text(renderer.querySelector('ytd-thumbnail-overlay-time-status-renderer'))
+              || text(renderer.querySelector('yt-thumbnail-badge-view-model'))
+              || text(renderer.querySelector('badge-shape'))
+              || '';
+            push({
+              title,
+              channel: inferredChannel,
+              views: inferredViews,
+              duration,
+              published: inferredPublished,
+              url: href.startsWith('http') ? href : 'https://www.youtube.com' + href,
+            });
+          }
+
+          for (const shortLink of section.querySelectorAll('a[href^="/shorts/"]')) {
+            if (videos.length >= limit) break;
+            const card = shortLink.closest('ytm-shorts-lockup-view-model-v2, ytm-shorts-lockup-view-model, ytd-reel-item-renderer') || shortLink.parentElement;
+            const href = shortLink.getAttribute('href') || '';
+            if (!href) continue;
+            const title = shortLink.getAttribute('title') || text(card?.querySelector('h3')) || text(shortLink);
+            const stats = Array.from(card?.querySelectorAll('span') || []).map(node => text(node)).filter(Boolean);
+            push({
+              title,
+              channel: 'Shorts',
+              views: stats.find(value => /观看|views/i.test(value)) || '',
+              duration: 'SHORT',
+              published: '',
+              url: href.startsWith('http') ? href : 'https://www.youtube.com' + href,
+            });
+          }
+        }
+
+        return videos.length ? videos : { error: 'No watch history items found on youtube.com/feed/history' };
+      })()
+    `);
+        if (!Array.isArray(data)) {
+            const errMsg = data && typeof data === 'object' ? String(data.error || '') : '';
+            throw new CommandExecutionError(errMsg || 'Failed to fetch watch history — make sure you are logged into YouTube');
+        }
+        if (data.length === 0) {
+            throw new EmptyResultError('youtube history');
+        }
+        return data;
+    },
+});

package/clis/youtube/like.js

@@ -0,0 +1,62 @@
+/**
+ * YouTube like — like a video via InnerTube like API (requires SAPISIDHASH auth).
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { parseVideoId, prepareYoutubeApiPage, SAPISID_HASH_FN } from './utils.js';
+import { CommandExecutionError, AuthRequiredError } from '@jackwener/opencli/errors';
+
+cli({
+    site: 'youtube',
+    name: 'like',
+    description: 'Like a YouTube video',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'url', required: true, positional: true, help: 'YouTube video URL or video ID' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        const videoId = parseVideoId(String(kwargs.url));
+        await prepareYoutubeApiPage(page);
+        const result = await page.evaluate(`
+      (async () => {
+        ${SAPISID_HASH_FN}
+
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return { error: 'config', message: 'YouTube config not found' };
+
+        const authHash = await getSapisidHash('https://www.youtube.com');
+        if (!authHash) return { error: 'auth', message: 'Not logged in (SAPISID cookie missing)' };
+
+        const resp = await fetch('/youtubei/v1/like/like?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST',
+          credentials: 'include',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': authHash,
+            'X-Origin': 'https://www.youtube.com',
+          },
+          body: JSON.stringify({ context, target: { videoId: ${JSON.stringify(videoId)} } }),
+        });
+
+        if (resp.status === 401 || resp.status === 403) return { error: 'auth', message: 'Not logged in' };
+        if (!resp.ok) {
+          const body = await resp.json().catch(() => ({}));
+          const errStatus = body?.error?.status || '';
+          if (errStatus === 'UNAUTHENTICATED') return { error: 'auth', message: 'Not logged in' };
+          return { error: 'http', message: 'HTTP ' + resp.status + (errStatus ? ' ' + errStatus : '') };
+        }
+        return { ok: true };
+      })()
+    `);
+        if (result?.error === 'auth') {
+            throw new AuthRequiredError('www.youtube.com');
+        }
+        if (result?.error) {
+            throw new CommandExecutionError(result.message || 'Failed to like video');
+        }
+        return [{ status: 'success', message: 'Liked: ' + videoId }];
+    },
+});

package/clis/youtube/playlist.js

@@ -0,0 +1,97 @@
+/**
+ * YouTube playlist — get playlist info and video list via InnerTube browse API.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { prepareYoutubeApiPage, FETCH_BROWSE_FN, extractPlaylistVideos } from './utils.js';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+/**
+ * Parse a playlist ID from a URL or bare ID string.
+ */
+function parsePlaylistId(input) {
+    if (!input.startsWith('http'))
+        return input;
+    try {
+        const url = new URL(input);
+        return url.searchParams.get('list') || input;
+    }
+    catch {
+        return input;
+    }
+}
+
+cli({
+    site: 'youtube',
+    name: 'playlist',
+    description: 'Get YouTube playlist info and video list',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'Playlist URL or playlist ID (PLxxxxxx)' },
+        { name: 'limit', type: 'int', default: 50, help: 'Max videos to return (default 50, max 200)' },
+    ],
+    columns: ['rank', 'title', 'channel', 'duration', 'views', 'published', 'url'],
+    func: async (page, kwargs) => {
+        const playlistId = parsePlaylistId(String(kwargs.id));
+        const limit = Math.min(kwargs.limit || 50, 200);
+        await prepareYoutubeApiPage(page);
+        const data = await page.evaluate(`
+      (async () => {
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return { error: 'YouTube config not found' };
+
+        const browseId = 'VL' + ${JSON.stringify(playlistId)};
+        const limit = ${limit};
+
+        ${FETCH_BROWSE_FN}
+
+        const data = await fetchBrowse(apiKey, { context, browseId });
+        if (data.error) return data;
+
+        const header = data.header?.pageHeaderRenderer;
+        const title = header?.pageTitle || '';
+        const metaRows = header?.content?.pageHeaderViewModel?.metadata?.contentMetadataViewModel?.metadataRows || [];
+        const stats = metaRows.flatMap(r => (r.metadataParts || []).map(p => p.text?.content || '').filter(Boolean));
+
+        const sidebarItems = data.sidebar?.playlistSidebarRenderer?.items || [];
+        const secondaryInfo = sidebarItems.find(i => i.playlistSidebarSecondaryInfoRenderer)?.playlistSidebarSecondaryInfoRenderer;
+        const channelName = secondaryInfo?.videoOwner?.videoOwnerRenderer?.title?.runs?.[0]?.text || '';
+
+        const tabs = data.contents?.twoColumnBrowseResultsRenderer?.tabs || [];
+        let listContents = tabs[0]?.tabRenderer?.content?.sectionListRenderer?.contents?.[0]?.itemSectionRenderer?.contents?.[0]?.playlistVideoListRenderer?.contents || [];
+
+        const extractVideos = ${extractPlaylistVideos.toString()};
+
+        let videos = extractVideos(listContents);
+
+        let contItem = listContents[listContents.length - 1];
+        while (videos.length < limit && contItem?.continuationItemRenderer) {
+          const token = contItem.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+          if (!token) break;
+          const contData = await fetchBrowse(apiKey, { context, continuation: token });
+          if (contData.error) break;
+          const newItems = contData.onResponseReceivedActions?.[0]?.appendContinuationItemsAction?.continuationItems || [];
+          if (!newItems.length) break;
+          videos = videos.concat(extractVideos(newItems));
+          contItem = newItems[newItems.length - 1];
+        }
+
+        return { title, channelName, stats, videos: videos.slice(0, limit) };
+      })()
+    `);
+        if (!data || typeof data !== 'object') {
+            throw new CommandExecutionError('Failed to fetch playlist data');
+        }
+        if (data.error) {
+            throw new CommandExecutionError(String(data.error));
+        }
+        if (!data.videos?.length) {
+            throw new EmptyResultError('youtube playlist');
+        }
+        const statsStr = (data.stats || []).join(' | ');
+        process.stderr.write(`${data.title}  [${data.channelName}]  ${statsStr}\n`);
+        return data.videos;
+    },
+});

package/clis/youtube/subscribe.js

@@ -0,0 +1,71 @@
+/**
+ * YouTube subscribe — subscribe to a channel via InnerTube subscription API.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { prepareYoutubeApiPage, SAPISID_HASH_FN, RESOLVE_CHANNEL_HANDLE_FN } from './utils.js';
+import { CommandExecutionError, AuthRequiredError } from '@jackwener/opencli/errors';
+
+cli({
+    site: 'youtube',
+    name: 'subscribe',
+    description: 'Subscribe to a YouTube channel',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'channel', required: true, positional: true, help: 'Channel ID (UCxxxx) or handle (@name)' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        const channelInput = String(kwargs.channel);
+        await prepareYoutubeApiPage(page);
+        const result = await page.evaluate(`
+      (async () => {
+        ${SAPISID_HASH_FN}
+
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return { error: 'config', message: 'YouTube config not found' };
+
+        const authHash = await getSapisidHash('https://www.youtube.com');
+        if (!authHash) return { error: 'auth', message: 'Not logged in (SAPISID cookie missing)' };
+
+        ${RESOLVE_CHANNEL_HANDLE_FN}
+
+        let channelId = ${JSON.stringify(channelInput)};
+        channelId = await resolveChannelHandle(channelId, apiKey, context);
+
+        if (!channelId.startsWith('UC')) {
+          return { error: 'arg', message: 'Could not resolve channel ID from: ' + ${JSON.stringify(channelInput)} };
+        }
+
+        const resp = await fetch('/youtubei/v1/subscription/subscribe?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST',
+          credentials: 'include',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': authHash,
+            'X-Origin': 'https://www.youtube.com',
+          },
+          body: JSON.stringify({ context, channelIds: [channelId] }),
+        });
+
+        if (resp.status === 401 || resp.status === 403) return { error: 'auth', message: 'Not logged in' };
+        if (!resp.ok) {
+          const body = await resp.json().catch(() => ({}));
+          const errStatus = body?.error?.status || '';
+          if (errStatus === 'UNAUTHENTICATED') return { error: 'auth', message: 'Not logged in' };
+          return { error: 'http', message: 'HTTP ' + resp.status + (errStatus ? ' ' + errStatus : '') };
+        }
+        return { ok: true, channelId };
+      })()
+    `);
+        if (result?.error === 'auth') {
+            throw new AuthRequiredError('www.youtube.com');
+        }
+        if (result?.error) {
+            throw new CommandExecutionError(result.message || 'Failed to subscribe');
+        }
+        return [{ status: 'success', message: 'Subscribed to: ' + (result.channelId || channelInput) }];
+    },
+});