@jackwener/opencli 1.4.0 → 1.5.0

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

package/dist/clis/douyin/_shared/tos-upload.js

@@ -0,0 +1,295 @@
+/**
+ * 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 * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { CommandExecutionError } from '../../../errors.js';
+const PART_SIZE = 5 * 1024 * 1024; // 5 MB minimum per TOS/S3 spec
+const RESUME_DIR = path.join(os.homedir(), '.opencli', 'douyin-resume');
+// ── Resume file helpers ──────────────────────────────────────────────────────
+function getResumeFilePath(filePath) {
+    const hash = crypto.createHash('sha256').update(filePath).digest('hex');
+    return path.join(RESUME_DIR, `${hash}.json`);
+}
+function loadResumeState(resumePath, fileSize) {
+    try {
+        const raw = fs.readFileSync(resumePath, 'utf8');
+        const state = JSON.parse(raw);
+        if (state.fileSize === fileSize && state.uploadId && Array.isArray(state.parts)) {
+            return state;
+        }
+    }
+    catch {
+        // no valid resume state
+    }
+    return null;
+}
+function saveResumeState(resumePath, state) {
+    fs.mkdirSync(path.dirname(resumePath), { recursive: true });
+    fs.writeFileSync(resumePath, JSON.stringify(state, null, 2), 'utf8');
+}
+function deleteResumeState(resumePath) {
+    try {
+        fs.unlinkSync(resumePath);
+    }
+    catch {
+        // ignore if not found
+    }
+}
+// ── AWS Signature V4 ─────────────────────────────────────────────────────────
+function hmacSha256(key, data) {
+    return crypto.createHmac('sha256', key).update(data, 'utf8').digest();
+}
+function sha256Hex(data) {
+    const hash = crypto.createHash('sha256');
+    if (typeof data === 'string') {
+        hash.update(data, 'utf8');
+    }
+    else {
+        hash.update(data);
+    }
+    return hash.digest('hex');
+}
+function extractRegionFromHost(host) {
+    // e.g. "tos-cn-i-alisg.volces.com" → "cn-i-alisg"
+    // e.g. "tos-cn-beijing.ivolces.com" → "cn-beijing"
+    const match = host.match(/^tos-([^.]+)\./);
+    if (match)
+        return match[1];
+    return 'cn-north-1'; // fallback
+}
+/**
+ * Compute AWS Signature V4 headers for a TOS request.
+ * Returns a Record of all headers to include (including Authorization, x-amz-date, etc.)
+ */
+function computeAws4Headers(opts) {
+    const { method, url, credentials, service, region, datetime } = opts;
+    const date = datetime.slice(0, 8); // YYYYMMDD
+    const parsedUrl = new URL(url);
+    const canonicalUri = parsedUrl.pathname || '/';
+    // Canonical query string: sort by name, encode
+    const queryParams = [...parsedUrl.searchParams.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+        .join('&');
+    const bodyHash = sha256Hex(opts.body);
+    // Merge in required headers and compute canonical headers
+    const allHeaders = {
+        ...opts.headers,
+        host: parsedUrl.host,
+        'x-amz-content-sha256': bodyHash,
+        'x-amz-date': datetime,
+        'x-amz-security-token': credentials.session_token,
+    };
+    const sortedHeaderKeys = Object.keys(allHeaders).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    const canonicalHeaders = sortedHeaderKeys
+        .map(k => `${k.toLowerCase()}:${allHeaders[k].trim()}`)
+        .join('\n') + '\n';
+    const signedHeadersList = sortedHeaderKeys.map(k => k.toLowerCase()).join(';');
+    const canonicalRequest = [
+        method.toUpperCase(),
+        canonicalUri,
+        queryParams,
+        canonicalHeaders,
+        signedHeadersList,
+        bodyHash,
+    ].join('\n');
+    const credentialScope = `${date}/${region}/${service}/aws4_request`;
+    const stringToSign = [
+        'AWS4-HMAC-SHA256',
+        datetime,
+        credentialScope,
+        sha256Hex(canonicalRequest),
+    ].join('\n');
+    // Signing key chain
+    const kDate = hmacSha256(`AWS4${credentials.secret_access_key}`, date);
+    const kRegion = hmacSha256(kDate, region);
+    const kService = hmacSha256(kRegion, service);
+    const kSigning = hmacSha256(kService, 'aws4_request');
+    const signature = hmacSha256(kSigning, stringToSign).toString('hex');
+    const authorization = `AWS4-HMAC-SHA256 Credential=${credentials.access_key_id}/${credentialScope}, SignedHeaders=${signedHeadersList}, Signature=${signature}`;
+    return {
+        ...allHeaders,
+        Authorization: authorization,
+    };
+}
+// ── HTTP helpers ─────────────────────────────────────────────────────────────
+async function tosRequest(opts) {
+    const { method, url, headers, body } = opts;
+    const fetchBody = body == null ? null
+        : typeof body === 'string' ? body
+            : body;
+    const res = await fetch(url, {
+        method,
+        headers,
+        body: fetchBody,
+    });
+    const responseBody = await res.text();
+    const responseHeaders = {};
+    res.headers.forEach((value, key) => {
+        responseHeaders[key.toLowerCase()] = value;
+    });
+    return { status: res.status, headers: responseHeaders, body: responseBody };
+}
+function nowDatetime() {
+    return new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
+}
+// ── Phase 1: Init multipart upload ───────────────────────────────────────────
+async function initMultipartUpload(tosUrl, auth, credentials) {
+    const initUrl = `${tosUrl}?uploads`;
+    const datetime = nowDatetime();
+    // Use the pre-computed auth for INIT, as it comes from ApplyVideoUpload
+    const headers = {
+        Authorization: auth,
+        'x-amz-date': datetime,
+        'x-amz-security-token': credentials.session_token,
+        'content-type': 'application/octet-stream',
+    };
+    const res = await tosRequest({ method: 'POST', url: initUrl, headers });
+    if (res.status !== 200) {
+        throw new CommandExecutionError(`TOS init multipart upload failed with status ${res.status}: ${res.body}`, 'Check that TOS credentials are valid and not expired.');
+    }
+    // Parse UploadId from XML: <UploadId>...</UploadId>
+    const match = res.body.match(/<UploadId>([^<]+)<\/UploadId>/);
+    if (!match) {
+        throw new CommandExecutionError(`TOS init response missing UploadId: ${res.body}`);
+    }
+    return match[1];
+}
+// ── Phase 2: Upload a single part ────────────────────────────────────────────
+async function uploadPart(tosUrl, partNumber, uploadId, data, credentials, region) {
+    const parsedUrl = new URL(tosUrl);
+    parsedUrl.searchParams.set('partNumber', String(partNumber));
+    parsedUrl.searchParams.set('uploadId', uploadId);
+    const url = parsedUrl.toString();
+    const datetime = nowDatetime();
+    const headers = computeAws4Headers({
+        method: 'PUT',
+        url,
+        headers: { 'content-type': 'application/octet-stream' },
+        body: data,
+        credentials,
+        service: 'tos',
+        region,
+        datetime,
+    });
+    const res = await tosRequest({ method: 'PUT', url, headers, body: data });
+    if (res.status !== 200) {
+        throw new CommandExecutionError(`TOS upload part ${partNumber} failed with status ${res.status}: ${res.body}`, 'Check that STS2 credentials are valid and not expired.');
+    }
+    const etag = res.headers['etag'];
+    if (!etag) {
+        throw new CommandExecutionError(`TOS upload part ${partNumber} response missing ETag header`);
+    }
+    return etag;
+}
+// ── Phase 3: Complete multipart upload ───────────────────────────────────────
+async function completeMultipartUpload(tosUrl, uploadId, parts, credentials, region) {
+    const parsedUrl = new URL(tosUrl);
+    parsedUrl.searchParams.set('uploadId', uploadId);
+    const url = parsedUrl.toString();
+    const xmlBody = '<CompleteMultipartUpload>' +
+        parts
+            .sort((a, b) => a.partNumber - b.partNumber)
+            .map(p => `<Part><PartNumber>${p.partNumber}</PartNumber><ETag>${p.etag}</ETag></Part>`)
+            .join('') +
+        '</CompleteMultipartUpload>';
+    const datetime = nowDatetime();
+    const headers = computeAws4Headers({
+        method: 'POST',
+        url,
+        headers: { 'content-type': 'application/xml' },
+        body: xmlBody,
+        credentials,
+        service: 'tos',
+        region,
+        datetime,
+    });
+    const res = await tosRequest({
+        method: 'POST',
+        url,
+        headers,
+        body: xmlBody,
+    });
+    if (res.status !== 200) {
+        throw new CommandExecutionError(`TOS complete multipart upload failed with status ${res.status}: ${res.body}`, 'Check that all parts were uploaded successfully.');
+    }
+}
+let _readSyncOverride = null;
+/** @internal — for testing only */
+export function setReadSyncOverride(fn) {
+    _readSyncOverride = fn;
+}
+// ── Public API ───────────────────────────────────────────────────────────────
+export async function tosUpload(options) {
+    const { filePath, uploadInfo, credentials, onProgress } = options;
+    // Validate file exists
+    if (!fs.existsSync(filePath)) {
+        throw new CommandExecutionError(`Video file not found: ${filePath}`, 'Ensure the file path is correct and accessible.');
+    }
+    const { size: fileSize } = fs.statSync(filePath);
+    if (fileSize === 0) {
+        throw new CommandExecutionError(`Video file is empty: ${filePath}`);
+    }
+    const { tos_upload_url: tosUrl, auth } = uploadInfo;
+    const parsedTosUrl = new URL(tosUrl);
+    const region = extractRegionFromHost(parsedTosUrl.host);
+    const resumePath = getResumeFilePath(filePath);
+    let resumeState = loadResumeState(resumePath, fileSize);
+    let uploadId;
+    let completedParts;
+    if (resumeState) {
+        // Resume from previous state
+        uploadId = resumeState.uploadId;
+        completedParts = resumeState.parts;
+    }
+    else {
+        // Start fresh
+        uploadId = await initMultipartUpload(tosUrl, auth, credentials);
+        completedParts = [];
+        saveResumeState(resumePath, { uploadId, fileSize, parts: completedParts });
+    }
+    // Determine which parts are already done
+    const completedPartNumbers = new Set(completedParts.map(p => p.partNumber));
+    // Calculate total parts
+    const totalParts = Math.ceil(fileSize / PART_SIZE);
+    // Track uploaded bytes for progress
+    let uploadedBytes = completedParts.length * PART_SIZE;
+    if (onProgress)
+        onProgress(Math.min(uploadedBytes, fileSize), fileSize);
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        for (let partNumber = 1; partNumber <= totalParts; partNumber++) {
+            if (completedPartNumbers.has(partNumber)) {
+                continue; // already uploaded
+            }
+            const offset = (partNumber - 1) * PART_SIZE;
+            const chunkSize = Math.min(PART_SIZE, fileSize - offset);
+            const buffer = Buffer.allocUnsafe(chunkSize);
+            const readFn = _readSyncOverride ?? fs.readSync;
+            const bytesRead = readFn(fd, buffer, 0, chunkSize, offset);
+            if (bytesRead !== chunkSize) {
+                throw new CommandExecutionError(`Short read on part ${partNumber}: expected ${chunkSize} bytes, got ${bytesRead}`);
+            }
+            const etag = await uploadPart(tosUrl, partNumber, uploadId, buffer, credentials, region);
+            completedParts.push({ partNumber, etag });
+            saveResumeState(resumePath, { uploadId, fileSize, parts: completedParts });
+            uploadedBytes = Math.min(offset + chunkSize, fileSize);
+            if (onProgress)
+                onProgress(uploadedBytes, fileSize);
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    await completeMultipartUpload(tosUrl, uploadId, completedParts, credentials, region);
+    deleteResumeState(resumePath);
+}
+// ── Internal exports for testing ─────────────────────────────────────────────
+export { PART_SIZE, RESUME_DIR, extractRegionFromHost, getResumeFilePath, loadResumeState, saveResumeState, deleteResumeState, computeAws4Headers, };

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

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