@jackwener/opencli 1.4.0 → 1.4.1

package/dist/clis/apple-podcasts/search.js

@@ -11,7 +11,7 @@ cli({
         { name: 'query', positional: true, required: true, help: 'Search keyword' },
         { name: 'limit', type: 'int', default: 10, help: 'Max results' },
     ],
-    columns: ['id', 'title', 'author', 'episodes', 'genre'],
+    columns: ['id', 'title', 'author', 'episodes', 'genre', 'url'],
     func: async (_page, args) => {
         const term = encodeURIComponent(args.query);
         const limit = Math.max(1, Math.min(Number(args.limit), 25));
@@ -24,6 +24,7 @@ cli({
             author: p.artistName,
             episodes: p.trackCount ?? '-',
             genre: p.primaryGenreName ?? '-',
+            url: p.collectionViewUrl || '',
         }));
     },
 });

package/dist/clis/arxiv/search.js

@@ -11,7 +11,7 @@ cli({
         { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "attention is all you need")' },
         { name: 'limit', type: 'int', default: 10, help: 'Max results (max 25)' },
     ],
-    columns: ['id', 'title', 'authors', 'published'],
+    columns: ['id', 'title', 'authors', 'published', 'url'],
     func: async (_page, args) => {
         const limit = Math.max(1, Math.min(Number(args.limit), 25));
         const query = encodeURIComponent(`all:${args.query}`);
@@ -19,6 +19,6 @@ cli({
         const entries = parseEntries(xml);
         if (!entries.length)
             throw new CliError('NOT_FOUND', 'No papers found', 'Try a different keyword');
-        return entries.map(e => ({ id: e.id, title: e.title, authors: e.authors, published: e.published }));
+        return entries.map(e => ({ id: e.id, title: e.title, authors: e.authors, published: e.published, url: e.url }));
     },
 });

package/dist/clis/bbc/news.js

@@ -1,6 +1,5 @@
 /**
  * BBC News headlines — public RSS feed, no browser needed.
- * Source: bb-sites/bbc/news.js
  */
 import { cli, Strategy } from '../../registry.js';
 cli({

package/dist/clis/ctrip/search.js

@@ -1,6 +1,5 @@
 /**
  * 携程旅行搜索 — browser cookie, multi-strategy.
- * Source: bb-sites/ctrip/search.js (simplified to suggestion API)
  */
 import { cli, Strategy } from '../../registry.js';
 cli({

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

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

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

@@ -0,0 +1,31 @@
+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(),
+        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(),
+    };
+}
+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/dist/clis/douyin/_shared/creation-id.d.ts

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

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

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

package/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/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/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 };