@jackwener/opencli 1.3.3 → 1.4.1

package/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/dist/clis/douyin/_shared/imagex-upload.test.d.ts

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

package/dist/clis/douyin/_shared/imagex-upload.test.js

@@ -0,0 +1,87 @@
+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';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function makeTempImage(ext = '.jpg') {
+    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 = {
+    upload_url: 'https://imagex.bytedance.com/upload/presigned/fake',
+    store_uri: 'tos-cn-i-alisg.example.com/cover/abc123',
+};
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe('imagexUpload', () => {
+    let imagePath;
+    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];
+        expect(url).toBe(FAKE_UPLOAD_INFO.upload_url);
+        expect(init.method).toBe('PUT');
+        expect(init.headers['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];
+            expect(init.headers['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/dist/clis/douyin/_shared/sts2.d.ts

@@ -0,0 +1,8 @@
+import type { IPage } from '../../../types.js';
+import type { Sts2Credentials } from './types.js';
+/**
+ * Fetch STS2 temporary credentials from the creator center.
+ * These are used to authenticate Node.js-side TOS multipart uploads.
+ * Returns: { access_key_id, secret_access_key, session_token, expired_time }
+ */
+export declare function getSts2Credentials(page: IPage): Promise<Sts2Credentials>;

package/dist/clis/douyin/_shared/sts2.js

@@ -0,0 +1,15 @@
+import { AuthRequiredError } from '../../../errors.js';
+const STS2_URL = 'https://creator.douyin.com/aweme/mid/video/sts2/?scene=web&aid=1128&cookie_enabled=true&device_platform=web';
+/**
+ * Fetch STS2 temporary credentials from the creator center.
+ * These are used to authenticate Node.js-side TOS multipart uploads.
+ * Returns: { access_key_id, secret_access_key, session_token, expired_time }
+ */
+export async function getSts2Credentials(page) {
+    const js = `fetch(${JSON.stringify(STS2_URL)}, { credentials: 'include' }).then(r => r.json())`;
+    const res = await page.evaluate(js);
+    if (!res?.data?.access_key_id) {
+        throw new AuthRequiredError('creator.douyin.com', 'STS2 credentials missing');
+    }
+    return res.data;
+}

package/dist/clis/douyin/_shared/text-extra.d.ts

@@ -0,0 +1,18 @@
+export interface HashtagInfo {
+    name: string;
+    id: number;
+    start: number;
+    end: number;
+}
+export interface TextExtraItem {
+    type: number;
+    hashtag_id: number;
+    hashtag_name: string;
+    start: number;
+    end: number;
+    caption_start: number;
+    caption_end: number;
+}
+export declare function parseTextExtra(_text: string, hashtags: HashtagInfo[]): TextExtraItem[];
+/** Extract hashtag names from text (e.g. "#话题" → ["话题"]) */
+export declare function extractHashtagNames(text: string): string[];

package/dist/clis/douyin/_shared/text-extra.js

@@ -0,0 +1,15 @@
+export function parseTextExtra(_text, hashtags) {
+    return hashtags.map((h) => ({
+        type: 1,
+        hashtag_id: h.id,
+        hashtag_name: h.name,
+        start: h.start,
+        end: h.end,
+        caption_start: 0,
+        caption_end: h.end - h.start,
+    }));
+}
+/** Extract hashtag names from text (e.g. "#话题" → ["话题"]) */
+export function extractHashtagNames(text) {
+    return [...text.matchAll(/#([^\s#]+)/g)].map((m) => m[1]);
+}

package/dist/clis/douyin/_shared/text-extra.test.d.ts

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

package/dist/clis/douyin/_shared/text-extra.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { parseTextExtra, extractHashtagNames } from './text-extra.js';
+describe('parseTextExtra', () => {
+    it('returns empty array for text with no hashtags', () => {
+        const result = parseTextExtra('普通文本内容', []);
+        expect(result).toEqual([]);
+    });
+    it('produces type-1 entry for each hashtag', () => {
+        const hashtags = [
+            { name: '话题', id: 12345, start: 5, end: 8 },
+        ];
+        const result = parseTextExtra('普通文本 #话题', hashtags);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            type: 1,
+            hashtag_name: '话题',
+            hashtag_id: 12345,
+            start: 5,
+            end: 8,
+        });
+    });
+    it('sets hashtag_id to 0 when not found', () => {
+        const hashtags = [
+            { name: '未知话题', id: 0, start: 0, end: 5 },
+        ];
+        const result = parseTextExtra('#未知话题', hashtags);
+        expect(result[0].hashtag_id).toBe(0);
+    });
+});
+describe('extractHashtagNames', () => {
+    it('extracts hashtag names from text', () => {
+        expect(extractHashtagNames('hello #foo and #bar')).toEqual(['foo', 'bar']);
+    });
+    it('returns empty array when no hashtags', () => {
+        expect(extractHashtagNames('no hashtags here')).toEqual([]);
+    });
+});

package/dist/clis/douyin/_shared/timing.d.ts

@@ -0,0 +1,2 @@
+export declare function validateTiming(unixSeconds: number): void;
+export declare function toUnixSeconds(input: string | number): number;

package/dist/clis/douyin/_shared/timing.js

@@ -0,0 +1,22 @@
+const MIN_OFFSET = 7200; // 2 hours
+const MAX_OFFSET = 14 * 86400; // 14 days
+export function validateTiming(unixSeconds) {
+    if (!Number.isFinite(unixSeconds))
+        throw new Error(`无效的时间戳: ${unixSeconds}`);
+    const now = Math.floor(Date.now() / 1000);
+    if (unixSeconds < now + MIN_OFFSET)
+        throw new Error(`定时发布时间必须在至少 2 小时后`);
+    if (unixSeconds > now + MAX_OFFSET)
+        throw new Error(`定时发布时间不能超过 14 天`);
+}
+export function toUnixSeconds(input) {
+    if (typeof input === 'number')
+        return input;
+    if (/^\d+$/.test(input)) {
+        return Number(input);
+    }
+    const ms = new Date(input).getTime();
+    if (isNaN(ms))
+        throw new Error(`无效的时间格式: "${input}"`);
+    return Math.floor(ms / 1000);
+}

package/dist/clis/douyin/_shared/timing.test.d.ts

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

package/dist/clis/douyin/_shared/timing.test.js

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+import { validateTiming, toUnixSeconds } from './timing.js';
+describe('validateTiming', () => {
+    const now = () => Math.floor(Date.now() / 1000);
+    it('accepts a time 3 hours from now', () => {
+        expect(() => validateTiming(now() + 3 * 3600)).not.toThrow();
+    });
+    it('rejects a time less than 2 hours from now', () => {
+        expect(() => validateTiming(now() + 3600)).toThrow('至少 2 小时后');
+    });
+    it('rejects a time more than 14 days from now', () => {
+        expect(() => validateTiming(now() + 15 * 86400)).toThrow('不能超过 14 天');
+    });
+});
+describe('toUnixSeconds', () => {
+    it('passes through a numeric unix timestamp', () => {
+        expect(toUnixSeconds(1744070400)).toBe(1744070400);
+    });
+    it('parses a numeric unix timestamp string', () => {
+        expect(toUnixSeconds('1744070400')).toBe(1744070400);
+    });
+    it('parses ISO8601 string', () => {
+        expect(toUnixSeconds('2026-04-08T12:00:00Z')).toBe(Math.floor(new Date('2026-04-08T12:00:00Z').getTime() / 1000));
+    });
+    it('throws on invalid input', () => {
+        expect(() => toUnixSeconds('not-a-date')).toThrow();
+    });
+});

package/dist/clis/douyin/_shared/tos-upload-short-read.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tests for the fs.readSync short-read guard in tosUpload.
+ *
+ * This file is separate from tos-upload.test.ts because vi.mock is hoisted and
+ * would interfere with the real-fs tests there.
+ *
+ * Strategy:
+ * - Use setReadSyncOverride (exported testing seam) to force readSync to return 0
+ * - Mock global fetch to satisfy initMultipartUpload so the code path reaches readSync
+ */
+export {};

package/dist/clis/douyin/_shared/tos-upload-short-read.test.js

@@ -0,0 +1,83 @@
+/**
+ * Tests for the fs.readSync short-read guard in tosUpload.
+ *
+ * This file is separate from tos-upload.test.ts because vi.mock is hoisted and
+ * would interfere with the real-fs tests there.
+ *
+ * Strategy:
+ * - Use setReadSyncOverride (exported testing seam) to force readSync to return 0
+ * - Mock global fetch to satisfy initMultipartUpload so the code path reaches readSync
+ */
+import * as actualFs 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 { setReadSyncOverride, tosUpload } from './tos-upload.js';
+/** Build a minimal fetch mock that satisfies initMultipartUpload (POST ?uploads → 200 + UploadId XML). */
+function makeFetchMock() {
+    return vi.fn().mockResolvedValue({
+        status: 200,
+        text: async () => '<InitiateMultipartUploadResult><UploadId>mock-upload-id</UploadId></InitiateMultipartUploadResult>',
+        headers: { forEach: (_cb) => { } },
+    });
+}
+describe('tosUpload short-read guard', () => {
+    let tmpDir;
+    let tmpFile;
+    let originalFetch;
+    beforeEach(() => {
+        originalFetch = globalThis.fetch;
+        tmpDir = actualFs.mkdtempSync(path.join(os.tmpdir(), 'tos-upload-shortread-'));
+        tmpFile = path.join(tmpDir, 'video.mp4');
+        // 100-byte file — fits in a single part
+        actualFs.writeFileSync(tmpFile, Buffer.alloc(100, 0xff));
+    });
+    afterEach(() => {
+        setReadSyncOverride(null);
+        globalThis.fetch = originalFetch;
+        actualFs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('throws CommandExecutionError on short read', async () => {
+        // Mock fetch so initMultipartUpload succeeds and code reaches readSync
+        globalThis.fetch = makeFetchMock();
+        // Override readSync to return 0 (fewer bytes than requested)
+        setReadSyncOverride(() => 0);
+        const mockCredentials = {
+            access_key_id: 'AKIAIOSFODNN7EXAMPLE',
+            secret_access_key: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+            session_token: 'test-session-token',
+            expired_time: Date.now() / 1000 + 3600,
+        };
+        const uploadInfo = {
+            tos_upload_url: 'https://tos-cn-i-alisg.volces.com/bucket/key',
+            auth: 'AWS4-HMAC-SHA256 Credential=test',
+            video_id: 'test-video-id',
+        };
+        await expect(tosUpload({
+            filePath: tmpFile,
+            uploadInfo,
+            credentials: mockCredentials,
+        })).rejects.toThrow(CommandExecutionError);
+    });
+    it('error message identifies the part number and byte counts', async () => {
+        globalThis.fetch = makeFetchMock();
+        setReadSyncOverride(() => 0);
+        const mockCredentials = {
+            access_key_id: 'AKIAIOSFODNN7EXAMPLE',
+            secret_access_key: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+            session_token: 'test-session-token',
+            expired_time: Date.now() / 1000 + 3600,
+        };
+        const uploadInfo = {
+            tos_upload_url: 'https://tos-cn-i-alisg.volces.com/bucket/key',
+            auth: 'AWS4-HMAC-SHA256 Credential=test',
+            video_id: 'test-video-id',
+        };
+        await expect(tosUpload({
+            filePath: tmpFile,
+            uploadInfo,
+            credentials: mockCredentials,
+        })).rejects.toThrow(/Short read on part 1: expected 100 bytes, got 0/);
+    });
+});

package/dist/clis/douyin/_shared/tos-upload.d.ts

@@ -0,0 +1,53 @@
+/**
+ * TOS (ByteDance Object Storage) multipart uploader with resume support.
+ *
+ * Uses AWS Signature V4 (HMAC-SHA256) with STS2 temporary credentials.
+ * For the init multipart upload call, the pre-computed auth from TosUploadInfo is used.
+ * For PUT part uploads and the final complete call, AWS4 is computed from STS2 credentials.
+ */
+import type { Sts2Credentials, TosUploadInfo } from './types.js';
+export interface TosUploadOptions {
+    filePath: string;
+    uploadInfo: TosUploadInfo;
+    credentials: Sts2Credentials;
+    onProgress?: (uploaded: number, total: number) => void;
+}
+interface ResumePart {
+    partNumber: number;
+    etag: string;
+}
+interface ResumeState {
+    uploadId: string;
+    fileSize: number;
+    parts: ResumePart[];
+}
+declare const PART_SIZE: number;
+declare const RESUME_DIR: string;
+declare function getResumeFilePath(filePath: string): string;
+declare function loadResumeState(resumePath: string, fileSize: number): ResumeState | null;
+declare function saveResumeState(resumePath: string, state: ResumeState): void;
+declare function deleteResumeState(resumePath: string): void;
+declare function extractRegionFromHost(host: string): string;
+interface SignedHeaders {
+    [key: string]: string;
+}
+/**
+ * Compute AWS Signature V4 headers for a TOS request.
+ * Returns a Record of all headers to include (including Authorization, x-amz-date, etc.)
+ */
+declare function computeAws4Headers(opts: {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body: Buffer | string;
+    credentials: Sts2Credentials;
+    service: string;
+    region: string;
+    datetime: string;
+}): SignedHeaders;
+type ReadSyncFn = (fd: number, buffer: Buffer, offset: number, length: number, position: number) => number;
+/** @internal — for testing only */
+export declare function setReadSyncOverride(fn: ReadSyncFn | null): void;
+export declare function tosUpload(options: TosUploadOptions): Promise<void>;
+export { PART_SIZE, RESUME_DIR, extractRegionFromHost, getResumeFilePath, loadResumeState, saveResumeState, deleteResumeState, computeAws4Headers, };
+export type { ResumeState, ResumePart };