@jackwener/opencli 1.4.0 → 1.5.0

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

@@ -0,0 +1,229 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { PART_SIZE, computeAws4Headers, deleteResumeState, extractRegionFromHost, getResumeFilePath, loadResumeState, saveResumeState, } from './tos-upload.js';
+// ── extractRegionFromHost ────────────────────────────────────────────────────
+describe('extractRegionFromHost', () => {
+    it('extracts region from standard TOS host', () => {
+        expect(extractRegionFromHost('tos-cn-i-alisg.volces.com')).toBe('cn-i-alisg');
+    });
+    it('extracts region from beijing TOS host', () => {
+        expect(extractRegionFromHost('tos-cn-beijing.ivolces.com')).toBe('cn-beijing');
+    });
+    it('falls back to cn-north-1 for unknown host', () => {
+        expect(extractRegionFromHost('unknown.example.com')).toBe('cn-north-1');
+    });
+});
+// ── Part chunking ────────────────────────────────────────────────────────────
+describe('PART_SIZE and part chunking logic', () => {
+    it('PART_SIZE is exactly 5 MB', () => {
+        expect(PART_SIZE).toBe(5 * 1024 * 1024);
+    });
+    it('single file smaller than PART_SIZE fits in 1 part', () => {
+        const fileSize = 1 * 1024 * 1024; // 1 MB
+        const totalParts = Math.ceil(fileSize / PART_SIZE);
+        expect(totalParts).toBe(1);
+        const lastPartSize = fileSize - (totalParts - 1) * PART_SIZE;
+        expect(lastPartSize).toBe(fileSize);
+    });
+    it('exactly 5 MB file produces 1 part', () => {
+        const fileSize = PART_SIZE;
+        expect(Math.ceil(fileSize / PART_SIZE)).toBe(1);
+    });
+    it('5 MB + 1 byte produces 2 parts', () => {
+        const fileSize = PART_SIZE + 1;
+        expect(Math.ceil(fileSize / PART_SIZE)).toBe(2);
+    });
+    it('100 MB file produces 20 parts of 5 MB each', () => {
+        const fileSize = 100 * 1024 * 1024;
+        const totalParts = Math.ceil(fileSize / PART_SIZE);
+        expect(totalParts).toBe(20);
+        // Each part is exactly PART_SIZE
+        for (let i = 1; i <= totalParts; i++) {
+            const offset = (i - 1) * PART_SIZE;
+            const chunkSize = Math.min(PART_SIZE, fileSize - offset);
+            expect(chunkSize).toBe(PART_SIZE);
+        }
+    });
+    it('101 MB file produces 21 parts, last part is 1 MB', () => {
+        const fileSize = 101 * 1024 * 1024;
+        const totalParts = Math.ceil(fileSize / PART_SIZE);
+        expect(totalParts).toBe(21);
+        const lastOffset = (totalParts - 1) * PART_SIZE;
+        const lastPartSize = fileSize - lastOffset;
+        expect(lastPartSize).toBe(1 * 1024 * 1024);
+    });
+});
+// ── Resume file serialization/deserialization ─────────────────────────────────
+describe('resume state read/write', () => {
+    let tmpDir;
+    let resumePath;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tos-upload-test-'));
+        resumePath = path.join(tmpDir, 'resume.json');
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('saves and loads resume state correctly', () => {
+        const state = {
+            uploadId: 'test-upload-id-123',
+            fileSize: 12345678,
+            parts: [
+                { partNumber: 1, etag: '"abc123"' },
+                { partNumber: 2, etag: '"def456"' },
+            ],
+        };
+        saveResumeState(resumePath, state);
+        const loaded = loadResumeState(resumePath, 12345678);
+        expect(loaded).not.toBeNull();
+        expect(loaded.uploadId).toBe('test-upload-id-123');
+        expect(loaded.fileSize).toBe(12345678);
+        expect(loaded.parts).toHaveLength(2);
+        expect(loaded.parts[0]).toEqual({ partNumber: 1, etag: '"abc123"' });
+        expect(loaded.parts[1]).toEqual({ partNumber: 2, etag: '"def456"' });
+    });
+    it('returns null when file does not exist', () => {
+        const result = loadResumeState('/nonexistent/path/resume.json', 12345678);
+        expect(result).toBeNull();
+    });
+    it('returns null when fileSize does not match', () => {
+        const state = {
+            uploadId: 'upload-id',
+            fileSize: 100,
+            parts: [],
+        };
+        saveResumeState(resumePath, state);
+        // Different file size — should not resume
+        const result = loadResumeState(resumePath, 999);
+        expect(result).toBeNull();
+    });
+    it('returns null when JSON is malformed', () => {
+        fs.writeFileSync(resumePath, 'not-valid-json', 'utf8');
+        const result = loadResumeState(resumePath, 100);
+        expect(result).toBeNull();
+    });
+    it('returns null when uploadId is missing', () => {
+        const broken = { fileSize: 100, parts: [] };
+        fs.writeFileSync(resumePath, JSON.stringify(broken), 'utf8');
+        const result = loadResumeState(resumePath, 100);
+        expect(result).toBeNull();
+    });
+    it('deletes resume file without throwing when file exists', () => {
+        fs.writeFileSync(resumePath, '{}', 'utf8');
+        expect(() => deleteResumeState(resumePath)).not.toThrow();
+        expect(fs.existsSync(resumePath)).toBe(false);
+    });
+    it('deleteResumeState does not throw when file does not exist', () => {
+        expect(() => deleteResumeState('/nonexistent/path/resume.json')).not.toThrow();
+    });
+    it('saveResumeState creates parent directories if missing', () => {
+        const nestedPath = path.join(tmpDir, 'nested', 'deep', 'resume.json');
+        const state = { uploadId: 'x', fileSize: 0, parts: [] };
+        expect(() => saveResumeState(nestedPath, state)).not.toThrow();
+        expect(fs.existsSync(nestedPath)).toBe(true);
+    });
+});
+// ── getResumeFilePath ────────────────────────────────────────────────────────
+describe('getResumeFilePath', () => {
+    it('returns a path inside ~/.opencli/douyin-resume/', () => {
+        const result = getResumeFilePath('/some/video/file.mp4');
+        expect(result).toContain('douyin-resume');
+        expect(result).toMatch(/\.json$/);
+    });
+    it('produces same path for same input', () => {
+        const a = getResumeFilePath('/video.mp4');
+        const b = getResumeFilePath('/video.mp4');
+        expect(a).toBe(b);
+    });
+    it('produces different paths for different inputs', () => {
+        const a = getResumeFilePath('/video1.mp4');
+        const b = getResumeFilePath('/video2.mp4');
+        expect(a).not.toBe(b);
+    });
+});
+// ── computeAws4Headers ───────────────────────────────────────────────────────
+describe('computeAws4Headers', () => {
+    const mockCredentials = {
+        access_key_id: 'AKIAIOSFODNN7EXAMPLE',
+        secret_access_key: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+        session_token: 'FQoGZXIvYXdzEJr//////////test-session-token',
+        expired_time: Date.now() / 1000 + 3600,
+    };
+    it('returns Authorization header', () => {
+        const headers = computeAws4Headers({
+            method: 'PUT',
+            url: 'https://tos-cn-i-alisg.volces.com/bucket/object?partNumber=1&uploadId=abc',
+            headers: { 'content-type': 'application/octet-stream' },
+            body: Buffer.from('hello'),
+            credentials: mockCredentials,
+            service: 'tos',
+            region: 'cn-i-alisg',
+            datetime: '20260325T120000Z',
+        });
+        expect(headers['Authorization']).toMatch(/^AWS4-HMAC-SHA256 Credential=/);
+        expect(headers['Authorization']).toContain('AKIAIOSFODNN7EXAMPLE/20260325/cn-i-alisg/tos/aws4_request');
+        expect(headers['Authorization']).toContain('SignedHeaders=');
+        expect(headers['Authorization']).toContain('Signature=');
+    });
+    it('includes x-amz-date header', () => {
+        const headers = computeAws4Headers({
+            method: 'PUT',
+            url: 'https://tos-cn-i-alisg.volces.com/bucket/object?partNumber=1&uploadId=abc',
+            headers: {},
+            body: Buffer.alloc(0),
+            credentials: mockCredentials,
+            service: 'tos',
+            region: 'cn-i-alisg',
+            datetime: '20260325T120000Z',
+        });
+        expect(headers['x-amz-date']).toBe('20260325T120000Z');
+    });
+    it('includes x-amz-security-token with session token', () => {
+        const headers = computeAws4Headers({
+            method: 'PUT',
+            url: 'https://tos-cn-i-alisg.volces.com/bucket/object',
+            headers: {},
+            body: '',
+            credentials: mockCredentials,
+            service: 'tos',
+            region: 'cn-i-alisg',
+            datetime: '20260325T120000Z',
+        });
+        expect(headers['x-amz-security-token']).toBe(mockCredentials.session_token);
+    });
+    it('signed headers list is sorted', () => {
+        const headers = computeAws4Headers({
+            method: 'POST',
+            url: 'https://tos-cn-i-alisg.volces.com/bucket/object?uploadId=abc',
+            headers: { 'content-type': 'application/xml' },
+            body: '<xml/>',
+            credentials: mockCredentials,
+            service: 'tos',
+            region: 'cn-i-alisg',
+            datetime: '20260325T120000Z',
+        });
+        const authHeader = headers['Authorization'];
+        const signedHeadersMatch = authHeader.match(/SignedHeaders=([^,]+)/);
+        expect(signedHeadersMatch).not.toBeNull();
+        const signedHeadersList = signedHeadersMatch[1].split(';');
+        const sorted = [...signedHeadersList].sort((a, b) => a.localeCompare(b));
+        expect(signedHeadersList).toEqual(sorted);
+    });
+    it('produces deterministic signature for same inputs', () => {
+        const opts = {
+            method: 'PUT',
+            url: 'https://tos-cn-i-alisg.volces.com/bucket/key?partNumber=1&uploadId=xyz',
+            headers: { 'content-type': 'application/octet-stream' },
+            body: Buffer.from('test-data'),
+            credentials: mockCredentials,
+            service: 'tos',
+            region: 'cn-i-alisg',
+            datetime: '20260325T120000Z',
+        };
+        const h1 = computeAws4Headers(opts);
+        const h2 = computeAws4Headers(opts);
+        expect(h1['Authorization']).toBe(h2['Authorization']);
+    });
+});

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

@@ -0,0 +1,27 @@
+/**
+ * Transcode poller for Douyin video processing.
+ *
+ * After a video is uploaded via TOS and the "confirm upload" API is called,
+ * Douyin transcodes the video asynchronously. This module polls the transcode
+ * status endpoint until encode=2 (complete) or a timeout is reached.
+ */
+import type { IPage } from '../../../types.js';
+import type { TranscodeResult } from './types.js';
+type BrowserFetchFn = (page: IPage, method: 'GET' | 'POST', url: string) => Promise<unknown>;
+/**
+ * Lower-level poll function that accepts an injected fetch function.
+ * Exported for testability.
+ */
+export declare function pollTranscodeWithFetch(fetchFn: BrowserFetchFn, page: IPage, videoId: string, timeoutMs?: number): Promise<TranscodeResult>;
+/**
+ * Poll Douyin's transcode status endpoint until the video is fully transcoded
+ * (encode=2) or the timeout expires.
+ *
+ * @param page - Browser page for making credentialed API calls
+ * @param videoId - The video_id returned from the confirm upload step
+ * @param timeoutMs - Maximum wait time in ms (default: 300 000 = 5 minutes)
+ * @returns TranscodeResult including duration, fps, dimensions, and poster info
+ * @throws TimeoutError if transcode does not complete within timeoutMs
+ */
+export declare function pollTranscode(page: IPage, videoId: string, timeoutMs?: number): Promise<TranscodeResult>;
+export {};

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

@@ -0,0 +1,45 @@
+/**
+ * Transcode poller for Douyin video processing.
+ *
+ * After a video is uploaded via TOS and the "confirm upload" API is called,
+ * Douyin transcodes the video asynchronously. This module polls the transcode
+ * status endpoint until encode=2 (complete) or a timeout is reached.
+ */
+import { TimeoutError } from '../../../errors.js';
+import { browserFetch } from './browser-fetch.js';
+const POLL_INTERVAL_MS = 3_000;
+const DEFAULT_TIMEOUT_MS = 300_000;
+const TRANSCODE_URL_BASE = 'https://creator.douyin.com/web/api/media/video/transend/';
+/**
+ * Lower-level poll function that accepts an injected fetch function.
+ * Exported for testability.
+ */
+export async function pollTranscodeWithFetch(fetchFn, page, videoId, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const url = `${TRANSCODE_URL_BASE}?video_id=${encodeURIComponent(videoId)}&aid=1128`;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const result = (await fetchFn(page, 'GET', url));
+        if (result.encode === 2) {
+            return result;
+        }
+        // Wait before next poll, but don't exceed the deadline
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            break;
+        await new Promise(resolve => setTimeout(resolve, Math.min(POLL_INTERVAL_MS, remaining)));
+    }
+    throw new TimeoutError(`Douyin transcode for video ${videoId}`, Math.round(timeoutMs / 1000));
+}
+/**
+ * Poll Douyin's transcode status endpoint until the video is fully transcoded
+ * (encode=2) or the timeout expires.
+ *
+ * @param page - Browser page for making credentialed API calls
+ * @param videoId - The video_id returned from the confirm upload step
+ * @param timeoutMs - Maximum wait time in ms (default: 300 000 = 5 minutes)
+ * @returns TranscodeResult including duration, fps, dimensions, and poster info
+ * @throws TimeoutError if transcode does not complete within timeoutMs
+ */
+export async function pollTranscode(page, videoId, timeoutMs) {
+    return pollTranscodeWithFetch(browserFetch, page, videoId, timeoutMs);
+}

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

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

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

@@ -0,0 +1,93 @@
+import { describe, expect, it, vi } from 'vitest';
+import { TimeoutError } from '../../../errors.js';
+import { pollTranscodeWithFetch } from './transcode.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function makePage() {
+    return {
+        goto: vi.fn(),
+        evaluate: vi.fn(),
+        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(),
+    };
+}
+const COMPLETE_RESULT = {
+    encode: 2,
+    duration: 30,
+    fps: 30,
+    height: 1920,
+    width: 1080,
+    poster_uri: 'tos-cn-i-alisg.volces.com/poster/abc',
+    poster_url: 'https://p3-creator.douyinpic.com/poster/abc',
+};
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe('pollTranscodeWithFetch', () => {
+    it('returns TranscodeResult immediately when first response has encode=2', async () => {
+        const fetchFn = vi.fn().mockResolvedValue(COMPLETE_RESULT);
+        const page = makePage();
+        const result = await pollTranscodeWithFetch(fetchFn, page, 'vid_123');
+        expect(result).toEqual(COMPLETE_RESULT);
+        expect(fetchFn).toHaveBeenCalledOnce();
+        const [, method, url] = fetchFn.mock.calls[0];
+        expect(method).toBe('GET');
+        expect(url).toContain('video_id=vid_123');
+        expect(url).toContain('aid=1128');
+    });
+    it('polls multiple times until encode=2 is received', async () => {
+        const pending = { encode: 1, duration: 0, fps: 0, height: 0, width: 0, poster_uri: '', poster_url: '' };
+        const fetchFn = vi
+            .fn()
+            .mockResolvedValueOnce(pending)
+            .mockResolvedValueOnce(pending)
+            .mockResolvedValueOnce(COMPLETE_RESULT);
+        const page = makePage();
+        // Use a large timeoutMs so it doesn't expire, but override POLL_INTERVAL via
+        // a short timeout knowing we'll get 3 calls quickly with mocked promises.
+        // Since pollTranscodeWithFetch uses setTimeout for 3s between polls, we need
+        // to mock timers to keep tests fast.
+        vi.useFakeTimers();
+        const resultPromise = pollTranscodeWithFetch(fetchFn, page, 'vid_456', 60_000);
+        // Advance timers for each pending poll cycle
+        await vi.runAllTimersAsync();
+        const result = await resultPromise;
+        expect(result).toEqual(COMPLETE_RESULT);
+        expect(fetchFn).toHaveBeenCalledTimes(3);
+        vi.useRealTimers();
+    });
+    it('throws TimeoutError when encode never becomes 2 within timeoutMs', async () => {
+        const pending = { encode: 1, duration: 0, fps: 0, height: 0, width: 0, poster_uri: '', poster_url: '' };
+        const fetchFn = vi.fn().mockResolvedValue(pending);
+        const page = makePage();
+        vi.useFakeTimers();
+        const resultPromise = pollTranscodeWithFetch(fetchFn, page, 'vid_789', 5_000);
+        // Suppress unhandled-rejection so vitest doesn't flag it
+        resultPromise.catch(() => undefined);
+        // Advance time past the 5s timeout
+        await vi.runAllTimersAsync();
+        await expect(resultPromise).rejects.toBeInstanceOf(TimeoutError);
+        vi.useRealTimers();
+    });
+    it('URL encodes video_id in the request URL', async () => {
+        const fetchFn = vi.fn().mockResolvedValue(COMPLETE_RESULT);
+        const page = makePage();
+        await pollTranscodeWithFetch(fetchFn, page, 'vid with spaces');
+        const [, , url] = fetchFn.mock.calls[0];
+        expect(url).toContain('video_id=vid%20with%20spaces');
+    });
+});

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

@@ -0,0 +1,26 @@
+export interface Sts2Credentials {
+    access_key_id: string;
+    secret_access_key: string;
+    session_token: string;
+    expired_time: number;
+}
+export interface TosUploadInfo {
+    tos_upload_url: string;
+    /** Pre-computed Authorization header value returned by ApplyVideoUpload (StoreInfos[0].Auth) */
+    auth: string;
+    video_id: string;
+}
+export interface TranscodeResult {
+    encode: number;
+    duration: number;
+    fps: number;
+    height: number;
+    width: number;
+    poster_uri: string;
+    poster_url: string;
+}
+export interface PublishResult {
+    aweme_id: string;
+    url: string;
+    publish_time: number;
+}

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

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

package/dist/clis/douyin/activities.d.ts

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

package/dist/clis/douyin/activities.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '../../registry.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+cli({
+    site: 'douyin',
+    name: 'activities',
+    description: '官方活动列表',
+    domain: 'creator.douyin.com',
+    strategy: Strategy.COOKIE,
+    args: [],
+    columns: ['activity_id', 'title', 'end_time'],
+    func: async (page, _kwargs) => {
+        const url = 'https://creator.douyin.com/web/api/media/activity/get/?aid=1128';
+        const res = await browserFetch(page, 'GET', url);
+        return (res.activity_list ?? []).map(a => ({
+            activity_id: a.activity_id,
+            title: a.title,
+            end_time: new Date(a.end_time * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' }),
+        }));
+    },
+});

package/dist/clis/douyin/activities.test.d.ts

@@ -0,0 +1 @@
+import './activities.js';

package/dist/clis/douyin/activities.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './activities.js';
+describe('douyin activities registration', () => {
+    it('registers the activities command', () => {
+        const registry = getRegistry();
+        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
+        expect(cmd).toBeDefined();
+    });
+    it('has expected columns', () => {
+        const registry = getRegistry();
+        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
+        expect(cmd?.columns).toContain('activity_id');
+        expect(cmd?.columns).toContain('title');
+        expect(cmd?.columns).toContain('end_time');
+    });
+    it('uses COOKIE strategy', () => {
+        const registry = getRegistry();
+        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
+        expect(cmd?.strategy).toBe('cookie');
+    });
+});

package/dist/clis/douyin/collections.d.ts

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

package/dist/clis/douyin/collections.js

@@ -0,0 +1,22 @@
+import { cli, Strategy } from '../../registry.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+cli({
+    site: 'douyin',
+    name: 'collections',
+    description: '合集列表',
+    domain: 'creator.douyin.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'limit', type: 'int', default: 20 },
+    ],
+    columns: ['mix_id', 'name', 'item_count'],
+    func: async (page, kwargs) => {
+        const url = `https://creator.douyin.com/web/api/mix/list/?aid=1128&count=${kwargs.limit}`;
+        const res = await browserFetch(page, 'GET', url);
+        return (res.mix_list ?? []).map(m => ({
+            mix_id: m.mix_id,
+            name: m.mix_name,
+            item_count: m.item_count,
+        }));
+    },
+});

package/dist/clis/douyin/collections.test.d.ts

@@ -0,0 +1 @@
+import './collections.js';

package/dist/clis/douyin/collections.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './collections.js';
+describe('douyin collections registration', () => {
+    it('registers the collections command', () => {
+        const registry = getRegistry();
+        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'collections');
+        expect(cmd).toBeDefined();
+        expect(cmd?.args.some(a => a.name === 'limit')).toBe(true);
+    });
+    it('has expected columns', () => {
+        const registry = getRegistry();
+        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'collections');
+        expect(cmd?.columns).toContain('mix_id');
+        expect(cmd?.columns).toContain('name');
+        expect(cmd?.columns).toContain('item_count');
+    });
+    it('uses COOKIE strategy', () => {
+        const registry = getRegistry();
+        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'collections');
+        expect(cmd?.strategy).toBe('cookie');
+    });
+});

package/dist/clis/douyin/delete.d.ts

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

package/dist/clis/douyin/delete.js

@@ -0,0 +1,18 @@
+import { cli, Strategy } from '../../registry.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+cli({
+    site: 'douyin',
+    name: 'delete',
+    description: '删除作品',
+    domain: 'creator.douyin.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'aweme_id', required: true, positional: true, help: '作品 ID' },
+    ],
+    columns: ['status'],
+    func: async (page, kwargs) => {
+        const url = 'https://creator.douyin.com/web/api/media/aweme/delete/?aid=1128';
+        await browserFetch(page, 'POST', url, { body: { aweme_id: kwargs.aweme_id } });
+        return [{ status: `✅ 已删除 ${kwargs.aweme_id}` }];
+    },
+});

package/dist/clis/douyin/delete.test.d.ts

@@ -0,0 +1 @@
+import './delete.js';

package/dist/clis/douyin/delete.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './delete.js';
+describe('douyin delete registration', () => {
+    it('registers the delete command', () => {
+        const registry = getRegistry();
+        const values = [...registry.values()];
+        const cmd = values.find(c => c.site === 'douyin' && c.name === 'delete');
+        expect(cmd).toBeDefined();
+    });
+});

package/dist/clis/douyin/draft.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Douyin draft — 6-phase pipeline for saving video as draft.
+ *
+ * Phases:
+ *   1. STS2 credentials
+ *   2. Apply TOS upload URL
+ *   3. TOS multipart upload
+ *   4. Cover upload (optional, via ImageX)
+ *   5. Enable video
+ *   6. Poll transcode
+ *   7. (skipped — no safety check for drafts)
+ *   8. create_v2 with is_draft: 1
+ */
+export {};