@huyuan-ai/cli 1.0.0 → 1.0.1

package/vendor/opencli/dist/clis/doubao/utils.test.d.ts

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

package/vendor/opencli/dist/clis/doubao/utils.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { mergeTranscriptSnapshots, parseDoubaoConversationId } from './utils.js';
+describe('parseDoubaoConversationId', () => {
+    it('extracts the numeric id from a full conversation URL', () => {
+        expect(parseDoubaoConversationId('https://www.doubao.com/chat/1234567890123')).toBe('1234567890123');
+    });
+    it('keeps a raw id unchanged', () => {
+        expect(parseDoubaoConversationId('1234567890123')).toBe('1234567890123');
+    });
+});
+describe('mergeTranscriptSnapshots', () => {
+    it('extends the transcript when the next snapshot overlaps with the tail', () => {
+        const merged = mergeTranscriptSnapshots('Alice 00:00\nHello team\nBob 00:05\nHi', 'Bob 00:05\nHi\nAlice 00:10\nNext topic');
+        expect(merged).toBe('Alice 00:00\nHello team\nBob 00:05\nHi\nAlice 00:10\nNext topic');
+    });
+    it('does not duplicate a snapshot that is already contained in the transcript', () => {
+        const merged = mergeTranscriptSnapshots('Alice 00:00\nHello team\nBob 00:05\nHi', 'Bob 00:05\nHi');
+        expect(merged).toBe('Alice 00:00\nHello team\nBob 00:05\nHi');
+    });
+    it('keeps both windows when a virtualized panel returns adjacent chunks without full history', () => {
+        const merged = mergeTranscriptSnapshots('Alice 00:00\nHello team\nBob 00:05\nHi', 'Alice 00:10\nNext topic\nBob 00:15\nAction items');
+        expect(merged).toBe('Alice 00:00\nHello team\nBob 00:05\nHi\nAlice 00:10\nNext topic\nBob 00:15\nAction items');
+    });
+});

package/vendor/opencli/dist/clis/doubao-app/ask.d.ts

@@ -0,0 +1 @@
+export declare const askCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao-app/ask.js

@@ -0,0 +1,53 @@
+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;
+        const timeout = kwargs.timeout || 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/vendor/opencli/dist/clis/doubao-app/dump.d.ts

@@ -0,0 +1 @@
+export declare const dumpCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao-app/dump.js

@@ -0,0 +1,24 @@
+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/vendor/opencli/dist/clis/doubao-app/new.d.ts

@@ -0,0 +1 @@
+export declare const newCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao-app/new.js

@@ -0,0 +1,20 @@
+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/vendor/opencli/dist/clis/doubao-app/read.d.ts

@@ -0,0 +1 @@
+export declare const readCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao-app/read.js

@@ -0,0 +1,18 @@
+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) => ({ Role: m.role, Text: m.text }));
+    },
+});

package/vendor/opencli/dist/clis/doubao-app/screenshot.d.ts

@@ -0,0 +1 @@
+export declare const screenshotCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao-app/screenshot.js

@@ -0,0 +1,18 @@
+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 || '/tmp/doubao-screenshot.png';
+        await page.screenshot({ path: outputPath });
+        return [{ Status: 'Success', File: outputPath }];
+    },
+});

package/vendor/opencli/dist/clis/doubao-app/send.d.ts

@@ -0,0 +1 @@
+export declare const sendCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao-app/send.js

@@ -0,0 +1,27 @@
+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;
+        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/vendor/opencli/dist/clis/doubao-app/status.d.ts

@@ -0,0 +1 @@
+export declare const statusCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao-app/status.js

@@ -0,0 +1,16 @@
+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/vendor/opencli/dist/clis/doubao-app/utils.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 declare const SEL: {
+    readonly INPUT: "[data-testid=\"chat_input_input\"]";
+    readonly SEND_BTN: "[data-testid=\"chat_input_send_button\"]";
+    readonly MESSAGE: "[data-testid=\"message_content\"]";
+    readonly MESSAGE_TEXT: "[data-testid=\"message_text_content\"]";
+    readonly INDICATOR: "[data-testid=\"indicator\"]";
+    readonly NEW_CHAT: "[data-testid=\"new_chat_button\"]";
+    readonly NEW_CHAT_SIDEBAR: "[data-testid=\"app-open-newChat\"]";
+};
+/**
+ * Inject text into the Doubao chat textarea via React-compatible value setter.
+ * Returns an evaluate script string.
+ */
+export declare function injectTextScript(text: string): string;
+/**
+ * Click the send button. Returns an evaluate script string.
+ */
+export declare function clickSendScript(): string;
+/**
+ * Read all chat messages from the DOM. Returns an evaluate script string.
+ */
+export declare function readMessagesScript(): string;
+/**
+ * Click the new-chat button. Returns an evaluate script string.
+ */
+export declare function clickNewChatScript(): string;
+/**
+ * Poll for a new assistant response after sending.
+ * Returns evaluate script that checks message count vs baseline.
+ */
+export declare function pollResponseScript(beforeCount: number): string;

package/vendor/opencli/dist/clis/doubao-app/utils.js

@@ -0,0 +1,110 @@
+/**
+ * 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"]',
+};
+/**
+ * Inject text into the Doubao chat textarea via React-compatible value setter.
+ * Returns an evaluate script string.
+ */
+export function injectTextScript(text) {
+    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() {
+    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() {
+    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() {
+    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) {
+    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/vendor/opencli/dist/clis/douyin/_shared/browser-fetch.d.ts

@@ -0,0 +1,10 @@
+import type { IPage } from '../../../types.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 declare function browserFetch(page: IPage, method: 'GET' | 'POST', url: string, options?: FetchOptions): Promise<unknown>;

package/vendor/opencli/dist/clis/douyin/_shared/browser-fetch.js

@@ -0,0 +1,30 @@
+import { CommandExecutionError } from '../../../errors.js';
+/**
+ * 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, method, url, options = {}) {
+    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.status_code;
+        if (code !== 0) {
+            const msg = result.status_msg ?? 'unknown error';
+            throw new CommandExecutionError(`Douyin API error ${code}: ${msg}`);
+        }
+    }
+    return result;
+}

package/vendor/opencli/dist/clis/douyin/_shared/browser-fetch.test.d.ts

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

package/vendor/opencli/dist/clis/douyin/_shared/browser-fetch.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it, vi } from 'vitest';
+import { browserFetch } from './browser-fetch.js';
+function makePage(result) {
+    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(),
+        networkRequests: vi.fn(), consoleMessages: vi.fn(),
+        scroll: vi.fn(), autoScroll: vi.fn(),
+        installInterceptor: vi.fn(), getInterceptedRequests: vi.fn(),
+        screenshot: vi.fn(),
+    };
+}
+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/vendor/opencli/dist/clis/douyin/_shared/creation-id.d.ts

@@ -0,0 +1 @@
+export declare function generateCreationId(): string;

package/vendor/opencli/dist/clis/douyin/_shared/creation-id.js

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

package/vendor/opencli/dist/clis/douyin/_shared/creation-id.test.d.ts

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

package/vendor/opencli/dist/clis/douyin/_shared/creation-id.test.js

@@ -0,0 +1,22 @@
+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/vendor/opencli/dist/clis/douyin/_shared/imagex-upload.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+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;
+}
+/**
+ * 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 declare function imagexUpload(imagePath: string, uploadInfo: ImageXUploadInfo): Promise<string>;

package/vendor/opencli/dist/clis/douyin/_shared/imagex-upload.js

@@ -0,0 +1,53 @@
+/**
+ * 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';
+/**
+ * Detect MIME type from file extension.
+ * Falls back to image/jpeg for unknown extensions.
+ */
+function detectContentType(filePath) {
+    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, uploadInfo) {
+    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,
+    });
+    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;
+}

package/vendor/opencli/dist/clis/douyin/_shared/imagex-upload.test.d.ts

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