@jackwener/opencli 1.6.1 → 1.6.2

package/src/clis/instagram/story.test.ts

@@ -0,0 +1,191 @@
+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 type { IPage } from '../../types.js';
+import * as privatePublish from './_shared/private-publish.js';
+import './story.js';
+
+const tempDirs: string[] = [];
+
+function createTempFile(name: string, bytes = Buffer.from('story-media')): string {
+  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: unknown[] = [], overrides: Partial<IPage> = {}): IPage {
+  const evaluate = vi.fn();
+  for (const result of evaluateResults) {
+    evaluate.mockResolvedValueOnce(result);
+  }
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate,
+    getCookies: vi.fn().mockResolvedValue([]),
+    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/src/clis/instagram/story.ts

@@ -0,0 +1,151 @@
+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 type { IPage } from '../../types.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']);
+
+type InstagramStoryMediaItem = {
+  type: 'image' | 'video';
+  filePath: string;
+};
+
+type InstagramStorySuccessRow = {
+  status: string;
+  detail: string;
+  url: string;
+};
+
+function requirePage(page: IPage | null): IPage {
+  if (!page) throw new CommandExecutionError('Browser session required for instagram story');
+  return page;
+}
+
+function validateInstagramStoryArgs(kwargs: Record<string, unknown>): void {
+  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: Record<string, unknown>): InstagramStoryMediaItem {
+  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: IPage): Promise<string> {
+  const cookies = await page.getCookies({ domain: 'instagram.com' });
+  return cookies.find((cookie) => cookie.name === 'ds_user_id')?.value || '';
+}
+
+async function resolveCurrentUsername(page: IPage, currentUserId = ''): Promise<string> {
+  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 };
+      }
+    })()
+  `) as { ok?: boolean; username?: string };
+
+  return apiResult?.ok && apiResult.username ? apiResult.username : '';
+}
+
+function buildStorySuccessResult(mediaItem: InstagramStoryMediaItem, url: string): InstagramStorySuccessRow[] {
+  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: IPage | null, kwargs) => {
+    const browserPage = requirePage(page);
+    const mediaItem = normalizeStoryMediaItem(kwargs as Record<string, unknown>);
+    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/src/clis/sinafinance/stock-rank.ts

@@ -0,0 +1,68 @@
+/**
+ * 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/src/clis/substack/utils.test.ts

@@ -14,8 +14,6 @@ function createPageMock(evaluateResult: unknown): IPage {
     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([]),

package/src/clis/twitter/post.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './post.js';
+
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>();
+  return {
+    ...actual,
+    statSync: vi.fn((p: string, _opts?: any) => {
+      if (String(p).includes('missing')) return undefined;
+      return { isFile: () => true };
+    }),
+  };
+});
+
+vi.mock('node:path', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:path')>();
+  return {
+    ...actual,
+    resolve: vi.fn((p: string) => `/abs/${p}`),
+    extname: vi.fn((p: string) => {
+      const m = p.match(/\.[^.]+$/);
+      return m ? m[0] : '';
+    }),
+  };
+});
+
+function makePage(overrides: Record<string, any> = {}) {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue({ ok: true }),
+    setFileInput: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  };
+}
+
+describe('twitter post command', () => {
+  const getCommand = () => getRegistry().get('twitter/post');
+
+  it('posts text-only tweet successfully', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({ ok: true })
+        .mockResolvedValueOnce({ ok: true, message: 'Tweet posted successfully.' }),
+    });
+
+    const result = await command!.func!(page as any, { text: 'hello world' });
+
+    expect(result).toEqual([{ status: 'success', message: 'Tweet posted successfully.', text: 'hello world' }]);
+    expect(page.goto).toHaveBeenCalledWith('https://x.com/compose/tweet');
+  });
+
+  it('returns failed when text area not found', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({ ok: false, message: 'Could not find the tweet composer text area.' }),
+    });
+
+    const result = await command!.func!(page as any, { text: 'hello' });
+
+    expect(result).toEqual([{ status: 'failed', message: 'Could not find the tweet composer text area.', text: 'hello' }]);
+  });
+
+  it('throws when more than 4 images', async () => {
+    const command = getCommand();
+    const page = makePage();
+
+    await expect(
+      command!.func!(page as any, { text: 'hi', images: 'a.png,b.png,c.png,d.png,e.png' }),
+    ).rejects.toThrow('Too many images: 5 (max 4)');
+  });
+
+  it('throws when image file does not exist', async () => {
+    const command = getCommand();
+    const page = makePage();
+
+    await expect(
+      command!.func!(page as any, { text: 'hi', images: 'missing.png' }),
+    ).rejects.toThrow('Not a valid file');
+  });
+
+  it('throws on unsupported image format', async () => {
+    const command = getCommand();
+    const page = makePage();
+
+    await expect(
+      command!.func!(page as any, { text: 'hi', images: 'photo.bmp' }),
+    ).rejects.toThrow('Unsupported image format');
+  });
+
+  it('throws when page.setFileInput is not available', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluate: vi.fn().mockResolvedValueOnce({ ok: true }),
+      setFileInput: undefined,
+    });
+
+    await expect(
+      command!.func!(page as any, { text: 'hi', images: 'a.png' }),
+    ).rejects.toThrow('Browser extension does not support file upload');
+  });
+
+  it('posts with images when upload completes', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({ ok: true })   // type text
+        .mockResolvedValueOnce(true)            // upload polling returns true
+        .mockResolvedValueOnce({ ok: true, message: 'Tweet posted successfully.' }), // click post
+    });
+
+    const result = await command!.func!(page as any, { text: 'with images', images: 'a.png,b.png' });
+
+    expect(result).toEqual([{ status: 'success', message: 'Tweet posted successfully.', text: 'with images' }]);
+    expect(page.setFileInput).toHaveBeenCalled();
+
+    const uploadScript = page.evaluate.mock.calls[1][0] as string;
+    expect(uploadScript).toContain('[data-testid="attachments"]');
+    expect(uploadScript).toContain('[role="group"]');
+  });
+
+  it('returns failed when image upload times out', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({ ok: true })
+        .mockResolvedValueOnce(false),
+    });
+
+    const result = await command!.func!(page as any, { text: 'timeout', images: 'a.png' });
+
+    expect(result).toEqual([{ status: 'failed', message: 'Image upload timed out (30s).', text: 'timeout' }]);
+  });
+
+  it('validates images before navigating to compose page', async () => {
+    const command = getCommand();
+    const page = makePage();
+
+    await expect(
+      command!.func!(page as any, { text: 'hi', images: 'missing.png' }),
+    ).rejects.toThrow('Not a valid file');
+
+    // Should NOT have navigated since validation happens first
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('throws when no browser session', async () => {
+    const command = getCommand();
+
+    await expect(
+      command!.func!(null as any, { text: 'hi' }),
+    ).rejects.toThrow('Browser session required for twitter post');
+  });
+});