@jackwener/opencli 1.6.1 → 1.6.3

package/src/clis/doubao-app/ask.ts

@@ -1,60 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-import { SEL, injectTextScript, clickSendScript, pollResponseScript } from './utils.js';
-
-export const askCommand = cli({
-  site: 'doubao-app',
-  name: 'ask',
-  description: 'Send a message to Doubao desktop app and wait for the AI response',
-  domain: 'doubao-app',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [
-    { name: 'text', required: true, positional: true, help: 'Prompt to send' },
-    { name: 'timeout', type: 'int', default: 30, help: 'Max seconds to wait for response' },
-  ],
-  columns: ['Role', 'Text'],
-  func: async (page, kwargs) => {
-    const text = kwargs.text as string;
-    const timeout = (kwargs.timeout as number) || 30;
-
-    // Count existing messages before sending
-    const beforeCount = await page.evaluate(
-      `document.querySelectorAll('${SEL.MESSAGE}').length`
-    );
-
-    // Inject text + send
-    const injected = await page.evaluate(injectTextScript(text));
-    if (!injected?.ok) throw new Error('Could not find chat input.');
-    await page.wait(0.5);
-
-    const clicked = await page.evaluate(clickSendScript());
-    if (!clicked) await page.pressKey('Enter');
-
-    // Poll for response
-    const pollInterval = 1;
-    const maxPolls = Math.ceil(timeout / pollInterval);
-    let response = '';
-
-    for (let i = 0; i < maxPolls; i++) {
-      await page.wait(pollInterval);
-      const result = await page.evaluate(pollResponseScript(beforeCount));
-      if (!result) continue;
-      if (result.phase === 'done' && result.text) {
-        response = result.text;
-        break;
-      }
-    }
-
-    if (!response) {
-      return [
-        { Role: 'User', Text: text },
-        { Role: 'System', Text: `No response received within ${timeout}s.` },
-      ];
-    }
-
-    return [
-      { Role: 'User', Text: text },
-      { Role: 'Assistant', Text: response },
-    ];
-  },
-});

package/src/clis/doubao-app/dump.ts

@@ -1,28 +0,0 @@
-import * as fs from 'node:fs';
-import { cli, Strategy } from '../../registry.js';
-
-export const dumpCommand = cli({
-  site: 'doubao-app',
-  name: 'dump',
-  description: 'Dump Doubao desktop app DOM and snapshot to /tmp for debugging',
-  domain: 'doubao-app',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [],
-  columns: ['Status', 'File'],
-  func: async (page) => {
-    const htmlPath = '/tmp/doubao-dom.html';
-    const snapPath = '/tmp/doubao-snapshot.json';
-
-    const html = await page.evaluate('document.documentElement.outerHTML');
-    const snap = await page.snapshot({ compact: true });
-
-    fs.writeFileSync(htmlPath, html);
-    fs.writeFileSync(snapPath, typeof snap === 'string' ? snap : JSON.stringify(snap, null, 2));
-
-    return [
-      { Status: 'Success', File: htmlPath },
-      { Status: 'Success', File: snapPath },
-    ];
-  },
-});

package/src/clis/doubao-app/new.ts

@@ -1,21 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-import { clickNewChatScript } from './utils.js';
-
-export const newCommand = cli({
-  site: 'doubao-app',
-  name: 'new',
-  description: 'Start a new chat in Doubao desktop app',
-  domain: 'doubao-app',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [],
-  columns: ['Status'],
-  func: async (page) => {
-    const clicked = await page.evaluate(clickNewChatScript());
-    if (!clicked) {
-      await page.pressKey('Meta+N');
-    }
-    await page.wait(3);
-    return [{ Status: 'Success' }];
-  },
-});

package/src/clis/doubao-app/read.ts

@@ -1,21 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-import { readMessagesScript } from './utils.js';
-
-export const readCommand = cli({
-  site: 'doubao-app',
-  name: 'read',
-  description: 'Read chat history from Doubao desktop app',
-  domain: 'doubao-app',
-  strategy: Strategy.UI,
-  browser: true,
-  columns: ['Role', 'Text'],
-  func: async (page) => {
-    const messages = await page.evaluate(readMessagesScript());
-
-    if (!messages || messages.length === 0) {
-      return [{ Role: 'System', Text: 'No conversation found' }];
-    }
-
-    return messages.map((m: any) => ({ Role: m.role, Text: m.text }));
-  },
-});

package/src/clis/doubao-app/screenshot.ts

@@ -1,19 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-
-export const screenshotCommand = cli({
-  site: 'doubao-app',
-  name: 'screenshot',
-  description: 'Capture a screenshot of the Doubao desktop app window',
-  domain: 'doubao-app',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [
-    { name: 'output', required: false, help: 'Output file path (default: /tmp/doubao-screenshot.png)' },
-  ],
-  columns: ['Status', 'File'],
-  func: async (page, kwargs) => {
-    const outputPath = (kwargs.output as string) || '/tmp/doubao-screenshot.png';
-    await page.screenshot({ path: outputPath });
-    return [{ Status: 'Success', File: outputPath }];
-  },
-});

package/src/clis/doubao-app/send.ts

@@ -1,30 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-import { injectTextScript, clickSendScript } from './utils.js';
-
-export const sendCommand = cli({
-  site: 'doubao-app',
-  name: 'send',
-  description: 'Send a message to Doubao desktop app',
-  domain: 'doubao-app',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [
-    { name: 'text', required: true, positional: true, help: 'Message text to send' },
-  ],
-  columns: ['Status', 'Text'],
-  func: async (page, kwargs) => {
-    const text = kwargs.text as string;
-
-    const injected = await page.evaluate(injectTextScript(text));
-    if (!injected || !injected.ok) {
-      throw new Error('Could not find chat input: ' + (injected?.error || 'unknown'));
-    }
-    await page.wait(0.5);
-
-    const clicked = await page.evaluate(clickSendScript());
-    if (!clicked) await page.pressKey('Enter');
-
-    await page.wait(1);
-    return [{ Status: 'Sent', Text: text }];
-  },
-});

package/src/clis/doubao-app/status.ts

@@ -1,17 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-
-export const statusCommand = cli({
-  site: 'doubao-app',
-  name: 'status',
-  description: 'Check CDP connection to Doubao desktop app',
-  domain: 'doubao-app',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [],
-  columns: ['Status', 'Url', 'Title'],
-  func: async (page) => {
-    const url = await page.evaluate('window.location.href');
-    const title = await page.evaluate('document.title');
-    return [{ Status: 'Connected', Url: url, Title: title }];
-  },
-});

package/src/clis/doubao-app/utils.ts

@@ -1,116 +0,0 @@
-/**
- * Shared constants and helpers for Doubao desktop app (Electron + CDP).
- *
- * Requires: Doubao launched with --remote-debugging-port=9226
- */
-
-/** Selectors discovered via data-testid attributes */
-export const SEL = {
-  INPUT: '[data-testid="chat_input_input"]',
-  SEND_BTN: '[data-testid="chat_input_send_button"]',
-  MESSAGE: '[data-testid="message_content"]',
-  MESSAGE_TEXT: '[data-testid="message_text_content"]',
-  INDICATOR: '[data-testid="indicator"]',
-  NEW_CHAT: '[data-testid="new_chat_button"]',
-  NEW_CHAT_SIDEBAR: '[data-testid="app-open-newChat"]',
-} as const;
-
-/**
- * Inject text into the Doubao chat textarea via React-compatible value setter.
- * Returns an evaluate script string.
- */
-export function injectTextScript(text: string): string {
-  return `(function(t) {
-    const textarea = document.querySelector('${SEL.INPUT}');
-    if (!textarea) return { ok: false, error: 'No textarea found' };
-    textarea.focus();
-    const setter = Object.getOwnPropertyDescriptor(
-      window.HTMLTextAreaElement.prototype, 'value'
-    )?.set;
-    if (setter) setter.call(textarea, t);
-    else textarea.value = t;
-    textarea.dispatchEvent(new Event('input', { bubbles: true }));
-    textarea.dispatchEvent(new Event('change', { bubbles: true }));
-    return { ok: true };
-  })(${JSON.stringify(text)})`;
-}
-
-/**
- * Click the send button. Returns an evaluate script string.
- */
-export function clickSendScript(): string {
-  return `(function() {
-    const btn = document.querySelector('${SEL.SEND_BTN}');
-    if (!btn) return false;
-    btn.click();
-    return true;
-  })()`;
-}
-
-/**
- * Read all chat messages from the DOM. Returns an evaluate script string.
- */
-export function readMessagesScript(): string {
-  return `(function() {
-    const results = [];
-    const containers = document.querySelectorAll('${SEL.MESSAGE}');
-    for (const container of containers) {
-      const textEl = container.querySelector('${SEL.MESSAGE_TEXT}');
-      if (!textEl) continue;
-      // Skip streaming messages
-      if (textEl.querySelector('${SEL.INDICATOR}') ||
-          textEl.getAttribute('data-show-indicator') === 'true') continue;
-      const isUser = container.classList.contains('justify-end');
-      let text = '';
-      const children = textEl.querySelectorAll('div[dir]');
-      if (children.length > 0) {
-        text = Array.from(children).map(c => c.innerText || c.textContent || '').join('');
-      } else {
-        text = textEl.innerText?.trim() || textEl.textContent?.trim() || '';
-      }
-      if (!text) continue;
-      results.push({ role: isUser ? 'User' : 'Assistant', text: text.substring(0, 2000) });
-    }
-    return results;
-  })()`;
-}
-
-/**
- * Click the new-chat button. Returns an evaluate script string.
- */
-export function clickNewChatScript(): string {
-  return `(function() {
-    let btn = document.querySelector('${SEL.NEW_CHAT}');
-    if (btn) { btn.click(); return true; }
-    btn = document.querySelector('${SEL.NEW_CHAT_SIDEBAR}');
-    if (btn) { btn.click(); return true; }
-    return false;
-  })()`;
-}
-
-/**
- * Poll for a new assistant response after sending.
- * Returns evaluate script that checks message count vs baseline.
- */
-export function pollResponseScript(beforeCount: number): string {
-  return `(function(prevCount) {
-    const msgs = document.querySelectorAll('${SEL.MESSAGE}');
-    if (msgs.length <= prevCount) return { phase: 'waiting', text: null };
-    const lastMsg = msgs[msgs.length - 1];
-    if (lastMsg.classList.contains('justify-end')) return { phase: 'waiting', text: null };
-    const textEl = lastMsg.querySelector('${SEL.MESSAGE_TEXT}');
-    if (!textEl) return { phase: 'waiting', text: null };
-    if (textEl.querySelector('${SEL.INDICATOR}') ||
-        textEl.getAttribute('data-show-indicator') === 'true') {
-      return { phase: 'streaming', text: null };
-    }
-    let text = '';
-    const children = textEl.querySelectorAll('div[dir]');
-    if (children.length > 0) {
-      text = Array.from(children).map(c => c.innerText || c.textContent || '').join('');
-    } else {
-      text = textEl.innerText?.trim() || textEl.textContent?.trim() || '';
-    }
-    return { phase: 'done', text };
-  })(${beforeCount})`;
-}

package/src/clis/douyin/_shared/browser-fetch.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import type { IPage } from '../../../types.js';
-import { browserFetch } from './browser-fetch.js';
-
-function makePage(result: unknown): IPage {
-  return {
-    goto: vi.fn(), evaluate: vi.fn().mockResolvedValue(result),
-    getCookies: vi.fn(), snapshot: vi.fn(), click: vi.fn(),
-    typeText: vi.fn(), pressKey: vi.fn(), scrollTo: vi.fn(),
-    getFormState: vi.fn(), wait: vi.fn(), tabs: vi.fn(),
-    closeTab: vi.fn(), newTab: vi.fn(), selectTab: vi.fn(),
-    networkRequests: vi.fn(), consoleMessages: vi.fn(),
-    scroll: vi.fn(), autoScroll: vi.fn(),
-    installInterceptor: vi.fn(), getInterceptedRequests: vi.fn(),
-    screenshot: vi.fn(),
-  } as unknown as IPage;
-}
-
-describe('browserFetch', () => {
-  it('returns parsed JSON on success', async () => {
-    const page = makePage({ status_code: 0, data: { ak: 'KEY' } });
-    const result = await browserFetch(page, 'GET', 'https://creator.douyin.com/api/test');
-    expect(result).toEqual({ status_code: 0, data: { ak: 'KEY' } });
-  });
-
-  it('throws when status_code is non-zero', async () => {
-    const page = makePage({ status_code: 8, message: 'fail' });
-    await expect(
-      browserFetch(page, 'GET', 'https://creator.douyin.com/api/test')
-    ).rejects.toThrow('Douyin API error 8');
-  });
-
-  it('returns result even when no status_code field', async () => {
-    const page = makePage({ some_field: 'value' });
-    const result = await browserFetch(page, 'GET', 'https://creator.douyin.com/api/test');
-    expect(result).toEqual({ some_field: 'value' });
-  });
-});

package/src/clis/douyin/_shared/browser-fetch.ts

@@ -1,45 +0,0 @@
-import type { IPage } from '../../../types.js';
-import { CommandExecutionError } from '../../../errors.js';
-
-export interface FetchOptions {
-  body?: unknown;
-  headers?: Record<string, string>;
-}
-
-/**
- * Execute a fetch() call inside the Chrome browser context via page.evaluate.
- * This ensures a_bogus signing and cookies are handled automatically by the browser.
- */
-export async function browserFetch(
-  page: IPage,
-  method: 'GET' | 'POST',
-  url: string,
-  options: FetchOptions = {}
-): Promise<unknown> {
-  const js = `
-    (async () => {
-      const res = await fetch(${JSON.stringify(url)}, {
-        method: ${JSON.stringify(method)},
-        credentials: 'include',
-        headers: {
-          'Content-Type': 'application/json',
-          ...${JSON.stringify(options.headers ?? {})}
-        },
-        ${options.body ? `body: JSON.stringify(${JSON.stringify(options.body)}),` : ''}
-      });
-      return res.json();
-    })()
-  `;
-
-  const result = await page.evaluate(js);
-
-  if (result && typeof result === 'object' && 'status_code' in result) {
-    const code = (result as { status_code: number }).status_code;
-    if (code !== 0) {
-      const msg = (result as { status_msg?: string }).status_msg ?? 'unknown error';
-      throw new CommandExecutionError(`Douyin API error ${code}: ${msg}`);
-    }
-  }
-
-  return result;
-}

package/src/clis/douyin/_shared/creation-id.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { generateCreationId } from './creation-id.js';
-
-describe('generateCreationId', () => {
-  it('starts with "pin"', () => {
-    expect(generateCreationId()).toMatch(/^pin/);
-  });
-
-  it('has 4 random lowercase-alphanumeric chars after "pin"', () => {
-    expect(generateCreationId()).toMatch(/^pin[a-z0-9]{4}/);
-  });
-
-  it('ends with a numeric timestamp (ms)', () => {
-    const before = Date.now();
-    const id = generateCreationId();
-    const after = Date.now();
-    const ts = parseInt(id.replace(/^pin[a-z0-9]{4}/, ''), 10);
-    expect(ts).toBeGreaterThanOrEqual(before);
-    expect(ts).toBeLessThanOrEqual(after);
-  });
-
-  it('generates unique IDs', () => {
-    const ids = new Set(Array.from({ length: 100 }, generateCreationId));
-    expect(ids.size).toBe(100);
-  });
-});

package/src/clis/douyin/_shared/creation-id.ts

@@ -1,8 +0,0 @@
-const CHARS = 'abcdefghijklmnopqrstuvwxyz0123456789';
-
-export function generateCreationId(): string {
-  const random = Array.from({ length: 4 }, () =>
-    CHARS[Math.floor(Math.random() * CHARS.length)]
-  ).join('');
-  return 'pin' + random + Date.now();
-}

package/src/clis/douyin/_shared/imagex-upload.test.ts

@@ -1,113 +0,0 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { CommandExecutionError } from '../../../errors.js';
-import { imagexUpload } from './imagex-upload.js';
-import type { ImageXUploadInfo } from './imagex-upload.js';
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-function makeTempImage(ext = '.jpg'): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'imagex-test-'));
-  const filePath = path.join(dir, `cover${ext}`);
-  fs.writeFileSync(filePath, Buffer.from([0xff, 0xd8, 0xff, 0xe0])); // minimal JPEG header bytes
-  return filePath;
-}
-
-const FAKE_UPLOAD_INFO: ImageXUploadInfo = {
-  upload_url: 'https://imagex.bytedance.com/upload/presigned/fake',
-  store_uri: 'tos-cn-i-alisg.example.com/cover/abc123',
-};
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-describe('imagexUpload', () => {
-  let imagePath: string;
-
-  beforeEach(() => {
-    imagePath = makeTempImage('.jpg');
-  });
-
-  afterEach(() => {
-    // Clean up temp files
-    try {
-      fs.unlinkSync(imagePath);
-      fs.rmdirSync(path.dirname(imagePath));
-    } catch {
-      // ignore cleanup errors
-    }
-    vi.restoreAllMocks();
-  });
-
-  it('throws CommandExecutionError when image file does not exist', async () => {
-    await expect(
-      imagexUpload('/nonexistent/path/cover.jpg', FAKE_UPLOAD_INFO),
-    ).rejects.toThrow(CommandExecutionError);
-
-    await expect(
-      imagexUpload('/nonexistent/path/cover.jpg', FAKE_UPLOAD_INFO),
-    ).rejects.toThrow('Cover image file not found');
-  });
-
-  it('PUTs the image and returns store_uri on success', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      text: vi.fn().mockResolvedValue(''),
-    });
-    vi.stubGlobal('fetch', mockFetch);
-
-    const result = await imagexUpload(imagePath, FAKE_UPLOAD_INFO);
-
-    expect(result).toBe(FAKE_UPLOAD_INFO.store_uri);
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-    expect(url).toBe(FAKE_UPLOAD_INFO.upload_url);
-    expect(init.method).toBe('PUT');
-    expect((init.headers as Record<string, string>)['Content-Type']).toBe(
-      'image/jpeg',
-    );
-  });
-
-  it('uses image/png Content-Type for .png files', async () => {
-    const pngPath = makeTempImage('.png');
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      text: vi.fn().mockResolvedValue(''),
-    });
-    vi.stubGlobal('fetch', mockFetch);
-
-    try {
-      await imagexUpload(pngPath, FAKE_UPLOAD_INFO);
-      const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-      expect((init.headers as Record<string, string>)['Content-Type']).toBe(
-        'image/png',
-      );
-    } finally {
-      try {
-        fs.unlinkSync(pngPath);
-        fs.rmdirSync(path.dirname(pngPath));
-      } catch {
-        // ignore
-      }
-    }
-  });
-
-  it('throws CommandExecutionError on non-2xx PUT response', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: false,
-      status: 403,
-      text: vi.fn().mockResolvedValue('Forbidden'),
-    });
-    vi.stubGlobal('fetch', mockFetch);
-
-    await expect(imagexUpload(imagePath, FAKE_UPLOAD_INFO)).rejects.toThrow(
-      CommandExecutionError,
-    );
-    await expect(imagexUpload(imagePath, FAKE_UPLOAD_INFO)).rejects.toThrow(
-      'ImageX upload failed with status 403',
-    );
-  });
-});

package/src/clis/douyin/_shared/imagex-upload.ts

@@ -1,76 +0,0 @@
-/**
- * ImageX cover image uploader.
- *
- * Uploads a JPEG/PNG image to ByteDance ImageX via a pre-signed PUT URL
- * obtained from the Douyin "apply cover upload" API.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { CommandExecutionError } from '../../../errors.js';
-
-export interface ImageXUploadInfo {
-  /** Pre-signed PUT target URL (provided by the apply cover upload API) */
-  upload_url: string;
-  /** Image URI to use in create_v2 (returned from the apply step) */
-  store_uri: string;
-}
-
-/**
- * Detect MIME type from file extension.
- * Falls back to image/jpeg for unknown extensions.
- */
-function detectContentType(filePath: string): string {
-  const ext = path.extname(filePath).toLowerCase();
-  switch (ext) {
-    case '.png':
-      return 'image/png';
-    case '.gif':
-      return 'image/gif';
-    case '.webp':
-      return 'image/webp';
-    default:
-      return 'image/jpeg';
-  }
-}
-
-/**
- * Upload a cover image to ByteDance ImageX via a pre-signed PUT URL.
- *
- * @param imagePath - Local file path to the image (JPEG/PNG/etc.)
- * @param uploadInfo - Upload URL and store_uri from the apply cover upload API
- * @returns The store_uri (= image_uri for use in create_v2)
- */
-export async function imagexUpload(
-  imagePath: string,
-  uploadInfo: ImageXUploadInfo,
-): Promise<string> {
-  if (!fs.existsSync(imagePath)) {
-    throw new CommandExecutionError(
-      `Cover image file not found: ${imagePath}`,
-      'Ensure the file path is correct and accessible.',
-    );
-  }
-
-  const imageBuffer = fs.readFileSync(imagePath);
-  const contentType = detectContentType(imagePath);
-
-  const res = await fetch(uploadInfo.upload_url, {
-    method: 'PUT',
-    headers: {
-      'Content-Type': contentType,
-      'Content-Length': String(imageBuffer.byteLength),
-    },
-    body: imageBuffer as unknown as BodyInit,
-  });
-
-  if (!res.ok) {
-    const body = await res.text().catch(() => '');
-    throw new CommandExecutionError(
-      `ImageX upload failed with status ${res.status}: ${body}`,
-      'Check that the upload URL is valid and has not expired.',
-    );
-  }
-
-  return uploadInfo.store_uri;
-}