@jackwener/opencli 1.5.5 → 1.5.7

package/dist/clis/douyin/user-videos.test.js

@@ -0,0 +1,108 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { fetchDouyinUserVideosMock, fetchDouyinCommentsMock } = vi.hoisted(() => ({
+    fetchDouyinUserVideosMock: vi.fn(),
+    fetchDouyinCommentsMock: vi.fn(),
+}));
+vi.mock('./_shared/public-api.js', () => ({
+    fetchDouyinUserVideos: fetchDouyinUserVideosMock,
+    fetchDouyinComments: fetchDouyinCommentsMock,
+}));
+import { getRegistry } from '../../registry.js';
+import { DEFAULT_COMMENT_LIMIT, MAX_USER_VIDEOS_LIMIT, normalizeCommentLimit, normalizeUserVideosLimit } from './user-videos.js';
+describe('douyin user-videos', () => {
+    beforeEach(() => {
+        fetchDouyinUserVideosMock.mockReset();
+        fetchDouyinCommentsMock.mockReset();
+    });
+    it('registers the command', () => {
+        const registry = getRegistry();
+        const values = [...registry.values()];
+        const command = values.find((cmd) => cmd.site === 'douyin' && cmd.name === 'user-videos');
+        expect(command).toBeDefined();
+    });
+    it('clamps limit to a safe maximum', () => {
+        expect(normalizeUserVideosLimit(100)).toBe(MAX_USER_VIDEOS_LIMIT);
+        expect(normalizeUserVideosLimit(0)).toBe(1);
+        expect(normalizeCommentLimit(99)).toBe(DEFAULT_COMMENT_LIMIT);
+    });
+    it('uses shared public-api helpers and applies clamped limits', async () => {
+        const registry = getRegistry();
+        const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'user-videos');
+        expect(command?.func).toBeDefined();
+        if (!command?.func)
+            throw new Error('douyin user-videos command not registered');
+        fetchDouyinUserVideosMock.mockResolvedValueOnce([
+            {
+                aweme_id: '1',
+                desc: 'test video',
+                video: { duration: 1234, play_addr: { url_list: ['https://example.com/video.mp4'] } },
+                statistics: { digg_count: 9 },
+            },
+        ]);
+        fetchDouyinCommentsMock.mockResolvedValueOnce([
+            { text: 'nice', digg_count: 3, nickname: 'alice' },
+        ]);
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+        };
+        const rows = await command.func(page, {
+            sec_uid: 'MS4w-test',
+            limit: 100,
+            comment_limit: 99,
+            with_comments: true,
+        });
+        expect(fetchDouyinUserVideosMock).toHaveBeenCalledWith(page, 'MS4w-test', MAX_USER_VIDEOS_LIMIT);
+        expect(fetchDouyinCommentsMock).toHaveBeenCalledWith(page, '1', DEFAULT_COMMENT_LIMIT);
+        expect(rows).toEqual([
+            {
+                index: 1,
+                aweme_id: '1',
+                title: 'test video',
+                duration: 1,
+                digg_count: 9,
+                play_url: 'https://example.com/video.mp4',
+                top_comments: [
+                    { text: 'nice', digg_count: 3, nickname: 'alice' },
+                ],
+            },
+        ]);
+    });
+    it('skips comment enrichment when with_comments is false', async () => {
+        const registry = getRegistry();
+        const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'user-videos');
+        expect(command?.func).toBeDefined();
+        if (!command?.func)
+            throw new Error('douyin user-videos command not registered');
+        fetchDouyinUserVideosMock.mockResolvedValueOnce([
+            {
+                aweme_id: '2',
+                desc: 'plain video',
+                video: { duration: 2000, play_addr: { url_list: ['https://example.com/plain.mp4'] } },
+                statistics: { digg_count: 1 },
+            },
+        ]);
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+        };
+        const rows = await command.func(page, {
+            sec_uid: 'MS4w-test',
+            limit: 3,
+            with_comments: false,
+            comment_limit: 5,
+        });
+        expect(fetchDouyinCommentsMock).not.toHaveBeenCalled();
+        expect(rows).toEqual([
+            {
+                index: 1,
+                aweme_id: '2',
+                title: 'plain video',
+                duration: 2,
+                digg_count: 1,
+                play_url: 'https://example.com/plain.mp4',
+                top_comments: [],
+            },
+        ]);
+    });
+});

package/dist/clis/douyin/videos.js

@@ -1,5 +1,22 @@
 import { cli, Strategy } from '../../registry.js';
 import { browserFetch } from './_shared/browser-fetch.js';
+function normalizeVideoStatus(status, publicTime) {
+    if (typeof status === 'number')
+        return status;
+    if (!status)
+        return publicTime && publicTime > Date.now() / 1000 ? 'scheduled' : 'published';
+    if (status.is_delete)
+        return 'deleted';
+    if (status.is_prohibited)
+        return 'prohibited';
+    if (status.in_reviewing)
+        return 'reviewing';
+    if (status.is_private)
+        return 'private';
+    if (publicTime && publicTime > Date.now() / 1000)
+        return 'scheduled';
+    return 'published';
+}
 cli({
     site: 'douyin',
     name: 'videos',
@@ -17,18 +34,18 @@ cli({
         const statusNum = statusMap[kwargs.status] ?? 0;
         const url = `https://creator.douyin.com/janus/douyin/creator/pc/work_list?page_size=${kwargs.limit}&page_num=${kwargs.page}&status=${statusNum}`;
         const res = (await browserFetch(page, 'GET', url));
-        let items = res.data?.work_list ?? [];
+        let items = res.data?.work_list ?? res.aweme_list ?? [];
         // The API has a bug with status=16 for scheduled, so filter client-side
         if (kwargs.status === 'scheduled') {
-            items = items.filter((v) => v.public_time > Date.now() / 1000);
+            items = items.filter((v) => (v.public_time ?? 0) > Date.now() / 1000);
         }
         return items.map((v) => ({
             aweme_id: v.aweme_id,
-            title: v.desc,
-            status: v.status,
+            title: v.desc ?? '',
+            status: normalizeVideoStatus(v.status, v.public_time),
             play_count: v.statistics?.play_count ?? 0,
             digg_count: v.statistics?.digg_count ?? 0,
-            create_time: new Date(v.create_time * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' }),
+            create_time: new Date((v.create_time ?? v.public_time ?? 0) * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' }),
         }));
     },
 });

package/dist/clis/douyin/videos.test.js

@@ -1,11 +1,54 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { browserFetchMock } = vi.hoisted(() => ({
+    browserFetchMock: vi.fn(),
+}));
+vi.mock('./_shared/browser-fetch.js', () => ({
+    browserFetch: browserFetchMock,
+}));
 import { getRegistry } from '../../registry.js';
 import './videos.js';
-describe('douyin videos registration', () => {
+describe('douyin videos', () => {
+    beforeEach(() => {
+        browserFetchMock.mockReset();
+    });
     it('registers the videos command', () => {
         const registry = getRegistry();
         const values = [...registry.values()];
         const cmd = values.find(c => c.site === 'douyin' && c.name === 'videos');
         expect(cmd).toBeDefined();
     });
+    it('parses the current creator work_list api shape', async () => {
+        const registry = getRegistry();
+        const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'videos');
+        expect(command?.func).toBeDefined();
+        if (!command?.func)
+            throw new Error('douyin videos command not registered');
+        browserFetchMock.mockResolvedValueOnce({
+            aweme_list: [
+                {
+                    aweme_id: '7000000000000000001',
+                    desc: '测试视频标题',
+                    create_time: 1581571130,
+                    statistics: {
+                        play_count: 0,
+                        digg_count: 12,
+                    },
+                    status: {
+                        is_private: true,
+                    },
+                },
+            ],
+        });
+        const rows = await command.func({}, { limit: 5, page: 1, status: 'all' });
+        expect(rows).toEqual([
+            {
+                aweme_id: '7000000000000000001',
+                title: '测试视频标题',
+                status: 'private',
+                play_count: 0,
+                digg_count: 12,
+                create_time: new Date(1581571130 * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' }),
+            },
+        ]);
+    });
 });

package/dist/clis/facebook/search.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Regression test for issue #625.
+ * Facebook search must navigate in the pipeline before DOM extraction.
+ */
+export {};

package/dist/clis/facebook/search.test.js

@@ -0,0 +1,60 @@
+/**
+ * Regression test for issue #625.
+ * Facebook search must navigate in the pipeline before DOM extraction.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import yaml from 'js-yaml';
+import { describe, expect, it, vi } from 'vitest';
+import { executePipeline } from '../../pipeline/index.js';
+/**
+ * Minimal browser mock for pipeline execution tests.
+ * Only methods touched by this adapter path are implemented.
+ */
+function createMockPage() {
+    return {
+        goto: vi.fn(),
+        evaluate: vi.fn().mockResolvedValue([]),
+        getCookies: vi.fn().mockResolvedValue([]),
+        snapshot: vi.fn().mockResolvedValue(''),
+        click: vi.fn(),
+        typeText: vi.fn(),
+        pressKey: vi.fn(),
+        scrollTo: vi.fn(),
+        getFormState: vi.fn().mockResolvedValue({}),
+        wait: vi.fn(),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn(),
+        newTab: vi.fn(),
+        selectTab: vi.fn(),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue(''),
+        scroll: vi.fn(),
+        autoScroll: vi.fn(),
+        installInterceptor: vi.fn(),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
+        screenshot: vi.fn().mockResolvedValue(''),
+    };
+}
+describe('facebook search pipeline', () => {
+    it('navigates to search results before extracting DOM data', async () => {
+        // Load the YAML adapter directly so the regression test covers the shipped command definition.
+        const filePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'search.yaml');
+        const raw = fs.readFileSync(filePath, 'utf8');
+        const command = yaml.load(raw);
+        const pipeline = command.pipeline ?? [];
+        const page = createMockPage();
+        await executePipeline(page, pipeline, {
+            args: { query: 'AI agent', limit: 3 },
+        });
+        expect(page.goto).toHaveBeenNthCalledWith(1, 'https://www.facebook.com');
+        expect(page.goto).toHaveBeenNthCalledWith(2, 'https://www.facebook.com/search/top?q=AI%20agent', {
+            waitUntil: undefined,
+            settleMs: 4000,
+        });
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(String(page.evaluate.mock.calls[0]?.[0] ?? '')).not.toContain('window.location.href');
+    });
+});

package/dist/clis/facebook/search.yaml

@@ -17,12 +17,13 @@ args:
 pipeline:
   - navigate: https://www.facebook.com
 
+  - navigate:
+      url: https://www.facebook.com/search/top?q=${{ args.query | urlencode }}
+      settleMs: 4000
+
   - evaluate: |
       (async () => {
-        const query = ${{ args.query | json }};
         const limit = ${{ args.limit }};
-        window.location.href = 'https://www.facebook.com/search/top?q=' + encodeURIComponent(query);
-        await new Promise(r => setTimeout(r, 4000));
         // Search results are typically in role="article" or role="listitem"
         let items = document.querySelectorAll('[role="article"]');
         if (items.length === 0) {

package/dist/clis/instagram/download.d.ts

@@ -0,0 +1,16 @@
+export interface InstagramMediaTarget {
+    kind: 'p' | 'reel' | 'tv';
+    shortcode: string;
+    canonicalUrl: string;
+}
+interface InstagramPageMediaItem {
+    type: 'image' | 'video';
+    url: string;
+}
+interface DownloadedMediaItem extends InstagramPageMediaItem {
+    filename: string;
+}
+export declare function parseInstagramMediaTarget(input: string): InstagramMediaTarget;
+export declare function buildInstagramDownloadItems(shortcode: string, items: InstagramPageMediaItem[]): DownloadedMediaItem[];
+export declare function buildInstagramFetchScript(shortcode: string): string;
+export {};

package/dist/clis/instagram/download.js

@@ -0,0 +1,225 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { ArgumentError, AuthRequiredError, CliError, CommandExecutionError, EXIT_CODES } from '../../errors.js';
+import { httpDownload } from '../../download/index.js';
+const INSTAGRAM_GRAPHQL_DOC_ID = '8845758582119845';
+const INSTAGRAM_GRAPHQL_APP_ID = '936619743392459';
+const INSTAGRAM_HOST_SUFFIX = 'instagram.com';
+const SUPPORTED_KINDS = new Set(['p', 'reel', 'tv']);
+function displayPath(filePath) {
+    const home = os.homedir();
+    return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+}
+export function parseInstagramMediaTarget(input) {
+    const raw = String(input || '').trim();
+    if (!raw) {
+        throw new ArgumentError('Instagram URL is required', 'Expected https://www.instagram.com/p/... or https://www.instagram.com/reel/...');
+    }
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new ArgumentError(`Invalid Instagram URL: ${raw}`, 'Expected https://www.instagram.com/p/<shortcode>/ or /reel/<shortcode>/');
+    }
+    if (!['http:', 'https:'].includes(url.protocol)) {
+        throw new ArgumentError(`Unsupported URL protocol: ${url.protocol}`);
+    }
+    const host = url.hostname.toLowerCase();
+    if (host !== INSTAGRAM_HOST_SUFFIX && !host.endsWith(`.${INSTAGRAM_HOST_SUFFIX}`)) {
+        throw new ArgumentError(`Unsupported host: ${host}`, 'Only instagram.com URLs are supported');
+    }
+    const segments = url.pathname.split('/').filter(Boolean);
+    let kind;
+    let shortcode;
+    if (segments.length >= 2 && SUPPORTED_KINDS.has(segments[0])) {
+        kind = segments[0];
+        shortcode = segments[1];
+    }
+    else if (segments.length >= 3 && SUPPORTED_KINDS.has(segments[1])) {
+        kind = segments[1];
+        shortcode = segments[2];
+    }
+    if (!kind || !shortcode) {
+        throw new ArgumentError(`Unsupported Instagram media URL: ${raw}`, 'Only /p/<shortcode>/, /reel/<shortcode>/, and /tv/<shortcode>/ links are supported');
+    }
+    return {
+        kind: kind,
+        shortcode,
+        canonicalUrl: `https://www.instagram.com/${kind}/${shortcode}/`,
+    };
+}
+export function buildInstagramDownloadItems(shortcode, items) {
+    return items
+        .filter((item) => item?.url)
+        .map((item, index) => {
+        const fallbackExt = item.type === 'video' ? '.mp4' : '.jpg';
+        let ext = fallbackExt;
+        try {
+            const pathname = new URL(item.url).pathname;
+            const candidateExt = path.extname(pathname).toLowerCase();
+            if (candidateExt && candidateExt.length <= 8)
+                ext = candidateExt;
+        }
+        catch {
+            ext = fallbackExt;
+        }
+        return {
+            type: item.type,
+            url: item.url,
+            filename: `${shortcode}_${String(index + 1).padStart(2, '0')}${ext}`,
+        };
+    });
+}
+export function buildInstagramFetchScript(shortcode) {
+    return `
+    (async () => {
+      const shortcode = ${JSON.stringify(shortcode)};
+      const docId = ${JSON.stringify(INSTAGRAM_GRAPHQL_DOC_ID)};
+      const variables = {
+        shortcode,
+        fetch_tagged_user_count: null,
+        hoisted_comment_id: null,
+        hoisted_reply_id: null,
+      };
+      const url = 'https://www.instagram.com/graphql/query/?doc_id=' + docId + '&variables=' + encodeURIComponent(JSON.stringify(variables));
+      const res = await fetch(url, {
+        credentials: 'include',
+        headers: {
+          'Accept': 'application/json,text/plain,*/*',
+          'X-IG-App-ID': ${JSON.stringify(INSTAGRAM_GRAPHQL_APP_ID)},
+        },
+      });
+      const rawText = await res.text();
+
+      let data = null;
+      try {
+        data = rawText ? JSON.parse(rawText) : null;
+      } catch {
+        return {
+          ok: false,
+          errorCode: 'COMMAND_EXEC',
+          error: 'Instagram returned non-JSON content while fetching media metadata',
+        };
+      }
+
+      const message = typeof data?.message === 'string' ? data.message : '';
+      const lowered = (message || '').toLowerCase();
+
+      if (!res.ok) {
+        if (res.status === 401 || res.status === 403 || data?.require_login) {
+          return { ok: false, errorCode: 'AUTH_REQUIRED', error: message || ('HTTP ' + res.status) };
+        }
+        if (res.status === 429) {
+          return { ok: false, errorCode: 'RATE_LIMITED', error: message || 'HTTP 429' };
+        }
+        if (res.status === 404 || res.status === 410) {
+          return { ok: false, errorCode: 'PRIVATE_OR_UNAVAILABLE', error: message || ('HTTP ' + res.status) };
+        }
+        return { ok: false, errorCode: 'COMMAND_EXEC', error: message || ('HTTP ' + res.status) };
+      }
+
+      if (data?.require_login) {
+        return { ok: false, errorCode: 'AUTH_REQUIRED', error: message || 'Instagram login required' };
+      }
+      if (lowered.includes('wait a few minutes') || lowered.includes('rate')) {
+        return { ok: false, errorCode: 'RATE_LIMITED', error: message || 'Instagram rate limit triggered' };
+      }
+
+      const media = data?.data?.xdt_shortcode_media;
+      if (!media) {
+        return {
+          ok: false,
+          errorCode: 'PRIVATE_OR_UNAVAILABLE',
+          error: message || 'Post may be private, unavailable, or inaccessible to the current browser session',
+        };
+      }
+
+      const nodes = Array.isArray(media?.edge_sidecar_to_children?.edges) && media.edge_sidecar_to_children.edges.length > 0
+        ? media.edge_sidecar_to_children.edges.map((edge) => edge?.node).filter(Boolean)
+        : [media];
+
+      const items = nodes
+        .map((node) => ({
+          type: node?.is_video ? 'video' : 'image',
+          url: String(node?.is_video ? (node?.video_url || '') : (node?.display_url || '')),
+        }))
+        .filter((item) => item.url);
+
+      return {
+        ok: true,
+        shortcode: media.shortcode || shortcode,
+        owner: media?.owner?.username || '',
+        items,
+      };
+    })()
+  `;
+}
+function ensurePage(page) {
+    if (!page)
+        throw new CommandExecutionError('Browser session required');
+    return page;
+}
+function normalizeFetchResult(result) {
+    if (!result || typeof result !== 'object') {
+        throw new CommandExecutionError('Failed to fetch Instagram media metadata');
+    }
+    return result;
+}
+function handleFetchFailure(result) {
+    const message = result.error || 'Instagram media fetch failed';
+    if (result.errorCode === 'AUTH_REQUIRED') {
+        throw new AuthRequiredError('instagram.com', message);
+    }
+    if (result.errorCode === 'RATE_LIMITED') {
+        throw new CliError('RATE_LIMITED', message, 'Wait a few minutes and retry, or switch to a browser session with a warmer Instagram login state.', EXIT_CODES.TEMPFAIL);
+    }
+    if (result.errorCode === 'PRIVATE_OR_UNAVAILABLE') {
+        throw new CommandExecutionError(message, 'Open the post in a logged-in browser session and retry');
+    }
+    throw new CommandExecutionError(message);
+}
+async function downloadInstagramMedia(items, outputDir) {
+    fs.mkdirSync(outputDir, { recursive: true });
+    for (const item of items) {
+        const destPath = path.join(outputDir, item.filename);
+        const result = await httpDownload(item.url, destPath, {
+            timeout: item.type === 'video' ? 120000 : 60000,
+        });
+        if (!result.success) {
+            throw new CommandExecutionError(`Failed to download ${item.filename}: ${result.error || 'unknown error'}`);
+        }
+    }
+}
+cli({
+    site: 'instagram',
+    name: 'download',
+    description: 'Download images and videos from Instagram posts and reels',
+    domain: 'www.instagram.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        { name: 'url', positional: true, required: true, help: 'Instagram post / reel / tv URL' },
+        { name: 'path', default: path.join(os.homedir(), 'Downloads', 'Instagram'), help: 'Download directory' },
+    ],
+    func: async (page, kwargs) => {
+        const browserPage = ensurePage(page);
+        const target = parseInstagramMediaTarget(String(kwargs.url ?? ''));
+        const outputRoot = String(kwargs.path ?? path.join(os.homedir(), 'Downloads', 'Instagram'));
+        await browserPage.goto(target.canonicalUrl);
+        const fetchResult = normalizeFetchResult(await browserPage.evaluate(buildInstagramFetchScript(target.shortcode)));
+        if (!fetchResult.ok)
+            handleFetchFailure(fetchResult);
+        const shortcode = fetchResult.shortcode || target.shortcode;
+        const mediaItems = buildInstagramDownloadItems(shortcode, fetchResult.items || []);
+        if (mediaItems.length === 0) {
+            throw new CommandExecutionError('No downloadable media found');
+        }
+        const savedDir = path.join(outputRoot, shortcode);
+        await downloadInstagramMedia(mediaItems, savedDir);
+        console.log(`📁 saved: ${displayPath(savedDir)}`);
+        return null;
+    },
+});

package/dist/clis/instagram/download.test.d.ts

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

package/dist/clis/instagram/download.test.js

@@ -0,0 +1,118 @@
+import * as os from 'node:os';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '../../errors.js';
+const { mockHttpDownload, logSpy } = vi.hoisted(() => ({
+    mockHttpDownload: vi.fn(),
+    logSpy: vi.spyOn(console, 'log').mockImplementation(() => undefined),
+}));
+vi.mock('../../download/index.js', async () => {
+    const actual = await vi.importActual('../../download/index.js');
+    return { ...actual, httpDownload: mockHttpDownload };
+});
+const { buildInstagramDownloadItems, parseInstagramMediaTarget, } = await import('./download.js');
+let cmd;
+beforeAll(() => {
+    cmd = getRegistry().get('instagram/download');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+function createPageMock(evaluateResult) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(evaluateResult),
+    };
+}
+describe('instagram download helpers', () => {
+    it('parses canonical and username-prefixed Instagram media URLs', () => {
+        expect(parseInstagramMediaTarget('https://www.instagram.com/reel/DWg8NuZEj9p/?utm_source=ig_web_copy_link')).toEqual({
+            kind: 'reel',
+            shortcode: 'DWg8NuZEj9p',
+            canonicalUrl: 'https://www.instagram.com/reel/DWg8NuZEj9p/',
+        });
+        expect(parseInstagramMediaTarget('https://www.instagram.com/nasa/p/DWUR_azCWbN/?img_index=1')).toEqual({
+            kind: 'p',
+            shortcode: 'DWUR_azCWbN',
+            canonicalUrl: 'https://www.instagram.com/p/DWUR_azCWbN/',
+        });
+    });
+    it('rejects unsupported URLs early', () => {
+        expect(() => parseInstagramMediaTarget('https://example.com/p/abc')).toThrow(ArgumentError);
+        expect(() => parseInstagramMediaTarget('https://www.instagram.com/stories/abc/123')).toThrow(ArgumentError);
+    });
+    it('builds padded filenames and preserves known file extensions', () => {
+        expect(buildInstagramDownloadItems('DWUR_azCWbN', [
+            { type: 'image', url: 'https://cdn.example.com/photo.webp?foo=1' },
+            { type: 'video', url: 'https://cdn.example.com/video.mp4?bar=2' },
+            { type: 'image', url: 'not-a-valid-url' },
+        ])).toEqual([
+            { type: 'image', url: 'https://cdn.example.com/photo.webp?foo=1', filename: 'DWUR_azCWbN_01.webp' },
+            { type: 'video', url: 'https://cdn.example.com/video.mp4?bar=2', filename: 'DWUR_azCWbN_02.mp4' },
+            { type: 'image', url: 'not-a-valid-url', filename: 'DWUR_azCWbN_03.jpg' },
+        ]);
+    });
+});
+describe('instagram download command', () => {
+    beforeEach(() => {
+        mockHttpDownload.mockReset();
+        logSpy.mockClear();
+    });
+    it('rejects invalid URLs before browser work', async () => {
+        const page = createPageMock({ ok: true, items: [] });
+        await expect(cmd.func(page, { url: 'https://example.com/not-instagram' })).rejects.toThrow(ArgumentError);
+        expect(page.goto.mock.calls).toHaveLength(0);
+    });
+    it('maps auth failures to AuthRequiredError', async () => {
+        const page = createPageMock({ ok: false, errorCode: 'AUTH_REQUIRED', error: 'Instagram login required' });
+        await expect(cmd.func(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' })).rejects.toThrow(AuthRequiredError);
+        expect(mockHttpDownload).not.toHaveBeenCalled();
+    });
+    it('maps rate limit failures to CliError with RATE_LIMITED code', async () => {
+        const page = createPageMock({ ok: false, errorCode: 'RATE_LIMITED', error: 'Please wait a few minutes' });
+        await expect(cmd.func(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' })).rejects.toMatchObject({ code: 'RATE_LIMITED' });
+        expect(mockHttpDownload).not.toHaveBeenCalled();
+    });
+    it('maps private/unavailable failures to CommandExecutionError', async () => {
+        const page = createPageMock({ ok: false, errorCode: 'PRIVATE_OR_UNAVAILABLE', error: 'Post may be private' });
+        await expect(cmd.func(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' })).rejects.toThrow(CommandExecutionError);
+        expect(mockHttpDownload).not.toHaveBeenCalled();
+    });
+    it('throws when no downloadable media is found', async () => {
+        const page = createPageMock({ ok: true, shortcode: 'DWUR_azCWbN', items: [] });
+        await expect(cmd.func(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' })).rejects.toThrow(CommandExecutionError);
+        expect(mockHttpDownload).not.toHaveBeenCalled();
+    });
+    it('downloads media and prints saved directory', async () => {
+        mockHttpDownload
+            .mockResolvedValueOnce({ success: true, size: 120_000 })
+            .mockResolvedValueOnce({ success: true, size: 8_200_000 });
+        const page = createPageMock({
+            ok: true,
+            shortcode: 'DWUR_azCWbN',
+            items: [
+                { type: 'image', url: 'https://cdn.example.com/photo.webp?foo=1' },
+                { type: 'video', url: 'https://cdn.example.com/video.mp4?bar=2' },
+            ],
+        });
+        const result = await cmd.func(page, {
+            url: 'https://www.instagram.com/nasa/p/DWUR_azCWbN/?img_index=1',
+            path: './instagram-test',
+        });
+        expect(result).toBeNull();
+        expect(page.goto.mock.calls[0]?.[0]).toBe('https://www.instagram.com/p/DWUR_azCWbN/');
+        expect(mockHttpDownload).toHaveBeenNthCalledWith(1, 'https://cdn.example.com/photo.webp?foo=1', expect.stringContaining('instagram-test/DWUR_azCWbN/DWUR_azCWbN_01.webp'), expect.objectContaining({ timeout: 60000 }));
+        expect(mockHttpDownload).toHaveBeenNthCalledWith(2, 'https://cdn.example.com/video.mp4?bar=2', expect.stringContaining('instagram-test/DWUR_azCWbN/DWUR_azCWbN_02.mp4'), expect.objectContaining({ timeout: 120000 }));
+        expect(logSpy).toHaveBeenCalledWith('📁 saved: instagram-test/DWUR_azCWbN');
+    });
+    it('uses a cross-platform Downloads default when path is omitted', async () => {
+        mockHttpDownload.mockResolvedValueOnce({ success: true, size: 120_000 });
+        const page = createPageMock({
+            ok: true,
+            shortcode: 'DWUR_azCWbN',
+            items: [
+                { type: 'image', url: 'https://cdn.example.com/photo.webp?foo=1' },
+            ],
+        });
+        await cmd.func(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' });
+        expect(mockHttpDownload).toHaveBeenCalledWith('https://cdn.example.com/photo.webp?foo=1', expect.stringContaining(`${os.homedir()}/Downloads/Instagram/DWUR_azCWbN/DWUR_azCWbN_01.webp`), expect.objectContaining({ timeout: 60000 }));
+    });
+});

package/dist/clis/notebooklm/bind-current.d.ts

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