@jackwener/opencli 1.6.0 → 1.6.2

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

@@ -0,0 +1 @@
+import './reel.js';

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

@@ -0,0 +1,167 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '../../errors.js';
+import { getRegistry } from '../../registry.js';
+import './reel.js';
+const tempDirs = [];
+function createTempVideo(name = 'demo.mp4', bytes = Buffer.from('video')) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-instagram-reel-'));
+    tempDirs.push(dir);
+    const filePath = path.join(dir, name);
+    fs.writeFileSync(filePath, bytes);
+    return filePath;
+}
+function createPageMock(evaluateResults, overrides = {}) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+        getCookies: vi.fn().mockResolvedValue([]),
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn().mockResolvedValue(undefined),
+        newTab: vi.fn().mockResolvedValue(undefined),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
+        screenshot: vi.fn().mockResolvedValue(''),
+        setFileInput: vi.fn().mockResolvedValue(undefined),
+        insertText: vi.fn().mockResolvedValue(undefined),
+        getCurrentUrl: vi.fn().mockResolvedValue(null),
+        ...overrides,
+    };
+}
+afterAll(() => {
+    for (const dir of tempDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('instagram reel registration', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('registers the reel command with a required-value video arg', () => {
+        const cmd = getRegistry().get('instagram/reel');
+        expect(cmd).toBeDefined();
+        expect(cmd?.browser).toBe(true);
+        expect(cmd?.args.some((arg) => arg.name === 'video' && !arg.required && arg.valueRequired)).toBe(true);
+        expect(cmd?.args.some((arg) => arg.name === 'content' && arg.positional && !arg.required)).toBe(true);
+    });
+    it('rejects missing --video before browser work', async () => {
+        const page = createPageMock([]);
+        const cmd = getRegistry().get('instagram/reel');
+        await expect(cmd.func(page, { content: 'hello reel' })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('rejects unsupported video formats', async () => {
+        const videoPath = createTempVideo('demo.mov');
+        const page = createPageMock([]);
+        const cmd = getRegistry().get('instagram/reel');
+        await expect(cmd.func(page, { video: videoPath })).rejects.toThrow('Unsupported video format');
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('uploads a reel video without caption and shares it', async () => {
+        const videoPath = createTempVideo();
+        const page = createPageMock([
+            { ok: false }, // dismiss residual dialogs
+            { ok: true }, // ensure composer open
+            { ok: true }, // composer upload input ready
+            { ok: true, selectors: ['[data-opencli-reel-upload-index="0"]', '[data-opencli-reel-upload-index="1"]'] }, // resolve upload selector
+            { count: 1 }, // file bound to input
+            { state: 'preview', detail: 'Crop Back Next' }, // preview detected
+            { ok: true, label: 'OK' }, // dismiss reels nux
+            { ok: true, label: 'Next' }, // move from crop to edit
+            { state: 'edit' }, // edit stage
+            { ok: true, label: 'Next' }, // move from edit to composer
+            { state: 'composer' }, // composer stage
+            { ok: true, label: 'Share' }, // share
+            { ok: true, url: 'https://www.instagram.com/reel/REEL123/' }, // success
+        ]);
+        const cmd = getRegistry().get('instagram/reel');
+        const result = await cmd.func(page, { video: videoPath });
+        expect(page.setFileInput).toHaveBeenCalledWith([videoPath], '[data-opencli-reel-upload-index="0"]');
+        expect(page.insertText).not.toHaveBeenCalled();
+        expect(result).toEqual([
+            {
+                status: '✅ Posted',
+                detail: 'Single reel shared successfully',
+                url: 'https://www.instagram.com/reel/REEL123/',
+            },
+        ]);
+    });
+    it('copies query-style local video filenames to a safe temp upload path before setFileInput', async () => {
+        const videoPath = createTempVideo('demo.mp4?sign=abc&t=123video.MP4');
+        const page = createPageMock([
+            { ok: false },
+            { ok: true },
+            { ok: true },
+            { ok: true, selectors: ['[data-opencli-reel-upload-index="0"]'] },
+            { count: 1 },
+            { state: 'preview', detail: 'Crop Back Next' },
+            { ok: true, label: 'OK' },
+            { ok: true, label: 'Next' },
+            { state: 'edit' },
+            { ok: true, label: 'Next' },
+            { state: 'composer' },
+            { ok: true, label: 'Share' },
+            { ok: true, url: 'https://www.instagram.com/reel/REELSAFE123/' },
+        ]);
+        const cmd = getRegistry().get('instagram/reel');
+        await cmd.func(page, { video: videoPath });
+        const uploadPaths = page.setFileInput.mock.calls[0]?.[0] ?? [];
+        expect(uploadPaths).toHaveLength(1);
+        expect(uploadPaths[0]).not.toBe(videoPath);
+        expect(String(uploadPaths[0])).toContain('opencli-instagram-video-real');
+        expect(String(uploadPaths[0]).toLowerCase()).toContain('.mp4');
+    });
+    it('uploads a reel video with caption and shares it', async () => {
+        const videoPath = createTempVideo('captioned.mp4');
+        const page = createPageMock([
+            { ok: false }, // dismiss residual dialogs
+            { ok: true }, // ensure composer open
+            { ok: true }, // composer upload input ready
+            { ok: true, selectors: ['[data-opencli-reel-upload-index="0"]'] }, // resolve upload selector
+            { count: 1 }, // file bound to input
+            { state: 'preview', detail: 'Crop Back Next' }, // preview detected
+            { ok: true, label: 'OK' }, // dismiss reels nux
+            { ok: true, label: 'Next' }, // move from crop to edit
+            { state: 'edit' }, // edit stage
+            { ok: true, label: 'Next' }, // move from edit to composer
+            { state: 'composer' }, // composer stage
+            { ok: true }, // focus caption editor
+            { ok: true }, // post-insert event dispatch
+            { ok: true }, // caption matches
+            { ok: true, label: 'Share' }, // share
+            { ok: true, url: 'https://www.instagram.com/reel/REEL456/' }, // success
+        ]);
+        const cmd = getRegistry().get('instagram/reel');
+        const result = await cmd.func(page, { video: videoPath, content: 'hello reel' });
+        expect(page.insertText).toHaveBeenCalledWith('hello reel');
+        expect(result).toEqual([
+            {
+                status: '✅ Posted',
+                detail: 'Single reel shared successfully',
+                url: 'https://www.instagram.com/reel/REEL456/',
+            },
+        ]);
+    });
+});

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

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

package/dist/clis/instagram/story.js

@@ -0,0 +1,115 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ArgumentError, CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { publishStoryViaPrivateApi, resolveInstagramPrivatePublishConfig, } from './_shared/private-publish.js';
+import { resolveInstagramRuntimeInfo } from './_shared/runtime-info.js';
+const INSTAGRAM_HOME_URL = 'https://www.instagram.com/';
+const SUPPORTED_STORY_IMAGE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.webp']);
+const SUPPORTED_STORY_VIDEO_EXTENSIONS = new Set(['.mp4']);
+function requirePage(page) {
+    if (!page)
+        throw new CommandExecutionError('Browser session required for instagram story');
+    return page;
+}
+function validateInstagramStoryArgs(kwargs) {
+    if (kwargs.media === undefined) {
+        throw new ArgumentError('Argument "media" is required.', 'Provide --media /path/to/file.jpg or --media /path/to/file.mp4');
+    }
+}
+function normalizeStoryMediaItem(kwargs) {
+    const raw = String(kwargs.media ?? '').trim();
+    const parts = raw.split(',').map((part) => part.trim()).filter(Boolean);
+    if (parts.length === 0) {
+        throw new ArgumentError('Argument "media" is required.', 'Provide --media /path/to/file.jpg or --media /path/to/file.mp4');
+    }
+    if (parts.length > 1) {
+        throw new ArgumentError('Instagram story currently supports a single media item.', 'Provide one image or one video path with --media');
+    }
+    const resolved = path.resolve(parts[0]);
+    if (!fs.existsSync(resolved)) {
+        throw new ArgumentError(`Story media file not found: ${resolved}`);
+    }
+    const ext = path.extname(resolved).toLowerCase();
+    if (SUPPORTED_STORY_IMAGE_EXTENSIONS.has(ext)) {
+        return { type: 'image', filePath: resolved };
+    }
+    if (SUPPORTED_STORY_VIDEO_EXTENSIONS.has(ext)) {
+        return { type: 'video', filePath: resolved };
+    }
+    throw new ArgumentError(`Unsupported story media format: ${ext}`, 'Supported formats: images (.jpg, .jpeg, .png, .webp) and videos (.mp4)');
+}
+async function resolveCurrentUserId(page) {
+    const cookies = await page.getCookies({ domain: 'instagram.com' });
+    return cookies.find((cookie) => cookie.name === 'ds_user_id')?.value || '';
+}
+async function resolveCurrentUsername(page, currentUserId = '') {
+    if (!currentUserId)
+        return '';
+    const runtimeInfo = await resolveInstagramRuntimeInfo(page);
+    const apiResult = await page.evaluate(`
+    (async () => {
+      const userId = ${JSON.stringify(currentUserId)};
+      const appId = ${JSON.stringify(runtimeInfo.appId || '')};
+      try {
+        const res = await fetch(
+          'https://www.instagram.com/api/v1/users/' + encodeURIComponent(userId) + '/info/',
+          {
+            credentials: 'include',
+            headers: appId ? { 'X-IG-App-ID': appId } : {},
+          },
+        );
+        if (!res.ok) return { ok: false };
+        const data = await res.json();
+        const username = data?.user?.username || '';
+        return { ok: !!username, username };
+      } catch {
+        return { ok: false };
+      }
+    })()
+  `);
+    return apiResult?.ok && apiResult.username ? apiResult.username : '';
+}
+function buildStorySuccessResult(mediaItem, url) {
+    return [{
+            status: '✅ Posted',
+            detail: mediaItem.type === 'video'
+                ? 'Single video story shared successfully'
+                : 'Single story shared successfully',
+            url,
+        }];
+}
+cli({
+    site: 'instagram',
+    name: 'story',
+    description: 'Post a single Instagram story image or video',
+    domain: 'www.instagram.com',
+    strategy: Strategy.UI,
+    browser: true,
+    timeoutSeconds: 300,
+    args: [
+        { name: 'media', required: false, valueRequired: true, help: 'Path to a single story image or video file' },
+    ],
+    columns: ['status', 'detail', 'url'],
+    validateArgs: validateInstagramStoryArgs,
+    func: async (page, kwargs) => {
+        const browserPage = requirePage(page);
+        const mediaItem = normalizeStoryMediaItem(kwargs);
+        const currentUserId = await resolveCurrentUserId(browserPage);
+        const privateConfig = await resolveInstagramPrivatePublishConfig(browserPage);
+        const storyResult = await publishStoryViaPrivateApi({
+            page: browserPage,
+            mediaItem,
+            content: '',
+            apiContext: privateConfig.apiContext,
+            jazoest: privateConfig.jazoest,
+            currentUserId,
+        });
+        const username = await resolveCurrentUsername(browserPage, currentUserId);
+        const mediaPk = storyResult.mediaPk || storyResult.uploadId;
+        const url = username && mediaPk
+            ? new URL(`/stories/${username}/${mediaPk}/`, INSTAGRAM_HOME_URL).toString()
+            : '';
+        return buildStorySuccessResult(mediaItem, url);
+    },
+});

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

@@ -0,0 +1 @@
+import './story.js';

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

@@ -0,0 +1,167 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '../../errors.js';
+import { getRegistry } from '../../registry.js';
+import * as privatePublish from './_shared/private-publish.js';
+import './story.js';
+const tempDirs = [];
+function createTempFile(name, bytes = Buffer.from('story-media')) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-instagram-story-'));
+    tempDirs.push(dir);
+    const filePath = path.join(dir, name);
+    fs.writeFileSync(filePath, bytes);
+    return filePath;
+}
+function createPageMock(evaluateResults = [], overrides = {}) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+        getCookies: vi.fn().mockResolvedValue([]),
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn().mockResolvedValue(undefined),
+        newTab: vi.fn().mockResolvedValue(undefined),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
+        screenshot: vi.fn().mockResolvedValue(''),
+        setFileInput: vi.fn().mockResolvedValue(undefined),
+        insertText: vi.fn().mockResolvedValue(undefined),
+        getCurrentUrl: vi.fn().mockResolvedValue(null),
+        ...overrides,
+    };
+}
+afterAll(() => {
+    for (const dir of tempDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('instagram story registration', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('registers the story command with a required-value media arg', () => {
+        const cmd = getRegistry().get('instagram/story');
+        expect(cmd).toBeDefined();
+        expect(cmd?.browser).toBe(true);
+        expect(cmd?.args.some((arg) => arg.name === 'media' && !arg.required && arg.valueRequired)).toBe(true);
+        expect(cmd?.args.some((arg) => arg.name === 'content')).toBe(false);
+    });
+    it('rejects missing --media before browser work', async () => {
+        const page = createPageMock();
+        const cmd = getRegistry().get('instagram/story');
+        await expect(cmd.func(page, {})).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('rejects multiple media inputs for a single story', async () => {
+        const first = createTempFile('one.jpg');
+        const second = createTempFile('two.mp4');
+        const page = createPageMock();
+        const cmd = getRegistry().get('instagram/story');
+        await expect(cmd.func(page, { media: `${first},${second}` })).rejects.toThrow('single media');
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('rejects unsupported story formats', async () => {
+        const filePath = createTempFile('story.mov');
+        const page = createPageMock();
+        const cmd = getRegistry().get('instagram/story');
+        await expect(cmd.func(page, { media: filePath })).rejects.toThrow('Unsupported story media format');
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('publishes a single image story through the private route', async () => {
+        const imagePath = createTempFile('story.jpg');
+        const page = createPageMock([
+            { appId: '936619743392459', csrfToken: '', instagramAjax: 'ajax' },
+            { ok: true, username: 'tsezi_ray' },
+        ], {
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ds_user_id', value: '123', domain: 'instagram.com' }]),
+        });
+        const cmd = getRegistry().get('instagram/story');
+        vi.spyOn(privatePublish, 'resolveInstagramPrivatePublishConfig').mockResolvedValue({
+            apiContext: {
+                asbdId: '359341',
+                csrfToken: 'csrf-token',
+                igAppId: '936619743392459',
+                igWwwClaim: 'claim',
+                instagramAjax: 'ajax',
+                webSessionId: 'session',
+            },
+            jazoest: '22047',
+        });
+        vi.spyOn(privatePublish, 'publishStoryViaPrivateApi').mockResolvedValue({
+            mediaPk: '1234567890',
+            uploadId: '1234567890',
+        });
+        const result = await cmd.func(page, { media: imagePath });
+        expect(privatePublish.publishStoryViaPrivateApi).toHaveBeenCalledWith(expect.objectContaining({
+            page,
+            mediaItem: { type: 'image', filePath: imagePath },
+            content: '',
+        }));
+        expect(result).toEqual([
+            {
+                status: '✅ Posted',
+                detail: 'Single story shared successfully',
+                url: 'https://www.instagram.com/stories/tsezi_ray/1234567890/',
+            },
+        ]);
+    });
+    it('publishes a single video story through the private route', async () => {
+        const videoPath = createTempFile('story.mp4');
+        const page = createPageMock([
+            { appId: '936619743392459', csrfToken: '', instagramAjax: 'ajax' },
+            { ok: true, username: 'tsezi_ray' },
+        ], {
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ds_user_id', value: '123', domain: 'instagram.com' }]),
+        });
+        const cmd = getRegistry().get('instagram/story');
+        vi.spyOn(privatePublish, 'resolveInstagramPrivatePublishConfig').mockResolvedValue({
+            apiContext: {
+                asbdId: '359341',
+                csrfToken: 'csrf-token',
+                igAppId: '936619743392459',
+                igWwwClaim: 'claim',
+                instagramAjax: 'ajax',
+                webSessionId: 'session',
+            },
+            jazoest: '22047',
+        });
+        vi.spyOn(privatePublish, 'publishStoryViaPrivateApi').mockResolvedValue({
+            mediaPk: '9988776655',
+            uploadId: '9988776655',
+        });
+        const result = await cmd.func(page, { media: videoPath });
+        expect(privatePublish.publishStoryViaPrivateApi).toHaveBeenCalledWith(expect.objectContaining({
+            page,
+            mediaItem: { type: 'video', filePath: videoPath },
+            content: '',
+        }));
+        expect(result).toEqual([
+            {
+                status: '✅ Posted',
+                detail: 'Single video story shared successfully',
+                url: 'https://www.instagram.com/stories/tsezi_ray/9988776655/',
+            },
+        ]);
+    });
+});

package/dist/clis/sinafinance/stock-rank.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sinafinance stock rank
+ */
+export {};

package/dist/clis/sinafinance/stock-rank.js

@@ -0,0 +1,65 @@
+/**
+ * Sinafinance stock rank
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'sinafinance',
+    name: 'stock-rank',
+    description: '新浪财经热搜榜',
+    domain: 'finance.sina.cn',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        { name: 'market', type: 'string', default: 'cn', choices: ['cn', 'hk', 'us', 'wh', 'ft'], help: 'Market: cn (A股), hk (港股), us (美股), wh (外汇), ft (期货)' },
+    ],
+    columns: ['rank', 'name', 'symbol', 'market', 'price', 'change', 'url'],
+    func: async (page, _args) => {
+        const market = _args.market || 'cn';
+        await page.goto('https://finance.sina.cn/');
+        await page.wait({ selector: '#actionSearch', timeout: 10000 });
+        const payload = await page.evaluate(`
+      (async () => {
+        const wait = (ms) => new Promise(r => setTimeout(r, ms));
+        const cleanText = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+        const marketType = ${JSON.stringify(market)};
+
+        const searchBtn = document.querySelector('#actionSearch');
+        if (searchBtn) {
+          searchBtn.dispatchEvent(new Event('tap', { bubbles: true }));
+          await wait(3000);
+        }
+
+        const tabEl = document.querySelector('[data-type="' + marketType + '"]');
+        const marketName = tabEl?.textContent || marketType;
+        if (marketType !== 'cn' && tabEl) {
+          tabEl.click();
+          await wait(2000);
+        }
+
+        const results = [];
+        document.querySelectorAll('#stock-list .j-stock-row').forEach(el => {
+          const rankEl = el.querySelector('.rank');
+          const nameEl = el.querySelector('.j-sname');
+          const codeEl = el.querySelector('.stock-code');
+          const priceEl = el.querySelector('.j-price');
+          const changeEl = el.querySelector('.j-change');
+          const openUrl = el.getAttribute('open-url') || '';
+          const fullUrl = openUrl ? 'https:' + openUrl : '';
+          results.push({
+            rank: cleanText(rankEl?.textContent || ''),
+            name: cleanText(nameEl?.textContent || ''),
+            symbol: cleanText(codeEl?.textContent || ''),
+            market: cleanText(marketName),
+            price: cleanText(priceEl?.textContent || ''),
+            change: cleanText(changeEl?.textContent || ''),
+            url: fullUrl,
+          });
+        });
+        return results;
+      })()
+    `);
+        if (!Array.isArray(payload))
+            return [];
+        return payload;
+    },
+});

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

@@ -12,8 +12,6 @@ function createPageMock(evaluateResult) {
         getFormState: vi.fn().mockResolvedValue({}),
         wait: vi.fn().mockResolvedValue(undefined),
         tabs: vi.fn().mockResolvedValue([]),
-        closeTab: vi.fn().mockResolvedValue(undefined),
-        newTab: vi.fn().mockResolvedValue(undefined),
         selectTab: vi.fn().mockResolvedValue(undefined),
         networkRequests: vi.fn().mockResolvedValue([]),
         consoleMessages: vi.fn().mockResolvedValue([]),