@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/clis/douyin/publish.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Douyin publish — 8-phase pipeline for scheduling video posts.
+ *
+ * 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. Content safety check
+ *   8. create_v2 publish
+ */
+export {};

package/vendor/opencli/dist/clis/douyin/publish.js

@@ -0,0 +1,288 @@
+/**
+ * Douyin publish — 8-phase pipeline for scheduling video posts.
+ *
+ * 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. Content safety check
+ *   8. create_v2 publish
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { ArgumentError, CommandExecutionError } from '../../errors.js';
+import { getSts2Credentials } from './_shared/sts2.js';
+import { tosUpload } from './_shared/tos-upload.js';
+import { imagexUpload } from './_shared/imagex-upload.js';
+import { pollTranscode } from './_shared/transcode.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+import { generateCreationId } from './_shared/creation-id.js';
+import { validateTiming, toUnixSeconds } from './_shared/timing.js';
+import { parseTextExtra, extractHashtagNames } from './_shared/text-extra.js';
+const VISIBILITY_MAP = {
+    public: 0,
+    friends: 1,
+    private: 2,
+};
+const IMAGEX_BASE = 'https://imagex.bytedanceapi.com';
+const IMAGEX_SERVICE_ID = '1147';
+const DEVICE_PARAMS = 'aid=1128&cookie_enabled=true&screen_width=1512&screen_height=982&browser_language=zh-CN&browser_platform=MacIntel&browser_name=Mozilla&browser_online=true&timezone_name=Asia%2FTokyo&support_h265=1';
+const DEFAULT_COVER_TOOLS_INFO = JSON.stringify({
+    video_cover_source: 2,
+    cover_timestamp: 0,
+    recommend_timestamp: 0,
+    is_cover_edit: 0,
+    is_cover_template: 0,
+    cover_template_id: '',
+    is_text_template: 0,
+    text_template_id: '',
+    text_template_content: '',
+    is_text: 0,
+    text_num: 0,
+    text_content: '',
+    is_use_sticker: 0,
+    sticker_id: '',
+    is_use_filter: 0,
+    filter_id: '',
+    is_cover_modify: 0,
+    to_status: 0,
+    cover_type: 0,
+    initial_cover_uri: '',
+    cut_coordinate: '',
+});
+cli({
+    site: 'douyin',
+    name: 'publish',
+    description: '定时发布视频到抖音（必须设置 2h ~ 14天后的发布时间）',
+    domain: 'creator.douyin.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'video', required: true, positional: true, help: '视频文件路径' },
+        { name: 'title', required: true, help: '视频标题（≤30字）' },
+        { name: 'schedule', required: true, help: '定时发布时间（ISO8601 或 Unix 秒，2h ~ 14天后）' },
+        { name: 'caption', default: '', help: '正文内容（≤1000字，支持 #话题）' },
+        { name: 'cover', default: '', help: '封面图片路径（不提供时使用视频截帧）' },
+        { name: 'visibility', default: 'public', choices: ['public', 'friends', 'private'] },
+        { name: 'allow_download', type: 'bool', default: false, help: '允许下载' },
+        { name: 'collection', default: '', help: '合集 ID' },
+        { name: 'activity', default: '', help: '活动 ID' },
+        { name: 'poi_id', default: '', help: '地理位置 ID' },
+        { name: 'poi_name', default: '', help: '地理位置名称' },
+        { name: 'hotspot', default: '', help: '关联热点词' },
+        { name: 'no_safety_check', type: 'bool', default: false, help: '跳过内容安全检测' },
+        { name: 'sync_toutiao', type: 'bool', default: false, help: '同步发布到头条' },
+    ],
+    columns: ['status', 'aweme_id', 'url', 'publish_time'],
+    func: async (page, kwargs) => {
+        // ── Fail-fast validation ────────────────────────────────────────────
+        const videoPath = path.resolve(kwargs.video);
+        if (!fs.existsSync(videoPath)) {
+            throw new ArgumentError(`视频文件不存在: ${videoPath}`);
+        }
+        const ext = path.extname(videoPath).toLowerCase();
+        if (!['.mp4', '.mov', '.avi', '.webm'].includes(ext)) {
+            throw new ArgumentError(`不支持的视频格式: ${ext}（支持 mp4/mov/avi/webm）`);
+        }
+        const fileSize = fs.statSync(videoPath).size;
+        const title = kwargs.title;
+        if (title.length > 30) {
+            throw new ArgumentError('标题不能超过 30 字');
+        }
+        const caption = kwargs.caption || '';
+        if (caption.length > 1000) {
+            throw new ArgumentError('正文不能超过 1000 字');
+        }
+        const timingTs = toUnixSeconds(kwargs.schedule);
+        validateTiming(timingTs);
+        const visibilityType = VISIBILITY_MAP[kwargs.visibility] ?? 0;
+        const coverPath = kwargs.cover;
+        if (coverPath) {
+            if (!fs.existsSync(path.resolve(coverPath))) {
+                throw new ArgumentError(`封面文件不存在: ${path.resolve(coverPath)}`);
+            }
+        }
+        // ── Phase 1: STS2 credentials ───────────────────────────────────────
+        const credentials = await getSts2Credentials(page);
+        // ── Phase 2: Apply TOS upload URL ───────────────────────────────────
+        const vodUrl = `https://vod.bytedanceapi.com/?Action=ApplyVideoUpload&ServiceId=1128&Version=2021-01-01&FileType=video&FileSize=${fileSize}`;
+        const vodJs = `fetch(${JSON.stringify(vodUrl)}, { credentials: 'include' }).then(r => r.json())`;
+        const vodRes = (await page.evaluate(vodJs));
+        const { VideoId: videoId, UploadHosts, StoreInfos } = vodRes.Result.UploadAddress;
+        const tosUrl = `https://${UploadHosts[0]}/${StoreInfos[0].StoreUri}`;
+        const tosUploadInfo = {
+            tos_upload_url: tosUrl,
+            auth: StoreInfos[0].Auth,
+            video_id: videoId,
+        };
+        // ── Phase 3: TOS upload ─────────────────────────────────────────────
+        await tosUpload({
+            filePath: videoPath,
+            uploadInfo: tosUploadInfo,
+            credentials,
+            onProgress: (uploaded, total) => {
+                const pct = Math.round((uploaded / total) * 100);
+                process.stderr.write(`\r  上传进度: ${pct}%`);
+            },
+        });
+        process.stderr.write('\n');
+        // ── Phase 4: Cover upload (optional) ────────────────────────────────
+        let coverUri = '';
+        let coverWidth = 720;
+        let coverHeight = 1280;
+        if (kwargs.cover) {
+            const resolvedCoverPath = path.resolve(kwargs.cover);
+            // 4A: Apply ImageX upload
+            const applyUrl = `${IMAGEX_BASE}/?Action=ApplyImageUpload&ServiceId=${IMAGEX_SERVICE_ID}&Version=2018-08-01&UploadNum=1`;
+            const applyJs = `fetch(${JSON.stringify(applyUrl)}, { credentials: 'include' }).then(r => r.json())`;
+            const applyRes = (await page.evaluate(applyJs));
+            const { StoreInfos: imgStoreInfos } = applyRes.Result.UploadAddress;
+            const imgUploadUrl = `https://${imgStoreInfos[0].UploadHost}/${imgStoreInfos[0].StoreUri}`;
+            // 4B: Upload image
+            const coverStoreUri = await imagexUpload(resolvedCoverPath, {
+                upload_url: imgUploadUrl,
+                store_uri: imgStoreInfos[0].StoreUri,
+            });
+            // 4C: Commit ImageX upload
+            const commitUrl = `${IMAGEX_BASE}/?Action=CommitImageUpload&ServiceId=${IMAGEX_SERVICE_ID}&Version=2018-08-01`;
+            const commitBody = JSON.stringify({ SuccessObjKeys: [coverStoreUri] });
+            const commitJs = `
+        fetch(${JSON.stringify(commitUrl)}, {
+          method: 'POST',
+          credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: ${JSON.stringify(commitBody)}
+        }).then(r => r.json())
+      `;
+            await page.evaluate(commitJs);
+            coverUri = coverStoreUri;
+        }
+        // ── Phase 5: Enable video ───────────────────────────────────────────
+        const enableUrl = `https://creator.douyin.com/web/api/media/video/enable/?video_id=${videoId}&aid=1128`;
+        await browserFetch(page, 'GET', enableUrl);
+        // ── Phase 6: Poll transcode ─────────────────────────────────────────
+        const transResult = await pollTranscode(page, videoId);
+        coverWidth = transResult.width;
+        coverHeight = transResult.height;
+        if (!coverUri) {
+            coverUri = transResult.poster_uri;
+        }
+        // ── Phase 7: Content safety check ───────────────────────────────────
+        if (!kwargs.no_safety_check) {
+            const safetyUrl = 'https://creator.douyin.com/aweme/v1/post_assistant/fast_detect/pre_check';
+            const safetyBody = {
+                video_id: videoId,
+                title,
+                desc: caption,
+            };
+            await browserFetch(page, 'POST', safetyUrl, { body: safetyBody });
+            const pollUrl = 'https://creator.douyin.com/aweme/v1/post_assistant/fast_detect/poll';
+            const deadline = Date.now() + 30_000;
+            let safetyPassed = false;
+            while (Date.now() < deadline) {
+                const pollRes = (await browserFetch(page, 'POST', pollUrl, {
+                    body: safetyBody,
+                }));
+                if (pollRes.status === 0) {
+                    safetyPassed = true;
+                    break;
+                }
+                if (pollRes.status === 1) {
+                    throw new CommandExecutionError('内容安全检测不通过，请修改后重试', '使用 --no_safety_check 跳过');
+                }
+                await new Promise((r) => setTimeout(r, 2000));
+            }
+            if (!safetyPassed) {
+                throw new CommandExecutionError('内容安全检测超时（30s），请稍后重试', '使用 --no_safety_check 跳过');
+            }
+        }
+        // ── Phase 8: create_v2 publish ──────────────────────────────────────
+        const hashtagNames = extractHashtagNames(caption);
+        const hashtags = [];
+        let searchFrom = 0;
+        for (const name of hashtagNames) {
+            const idx = caption.indexOf(`#${name}`, searchFrom);
+            if (idx === -1)
+                continue;
+            hashtags.push({ name, id: 0, start: idx, end: idx + name.length + 1 });
+            searchFrom = idx + name.length + 1;
+        }
+        const textExtraArr = parseTextExtra(caption, hashtags);
+        const publishBody = {
+            item: {
+                common: {
+                    text: caption,
+                    caption: '',
+                    item_title: title,
+                    activity: JSON.stringify(kwargs.activity ? [kwargs.activity] : []),
+                    text_extra: JSON.stringify(textExtraArr),
+                    challenges: '[]',
+                    mentions: '[]',
+                    hashtag_source: '',
+                    hot_sentence: kwargs.hotspot || '',
+                    interaction_stickers: '[]',
+                    visibility_type: visibilityType,
+                    download: kwargs.allow_download ? 1 : 0,
+                    timing: timingTs,
+                    creation_id: generateCreationId(),
+                    media_type: 4,
+                    video_id: videoId,
+                    music_source: 0,
+                    music_id: null,
+                    ...(kwargs.poi_id
+                        ? { poi_id: kwargs.poi_id, poi_name: kwargs.poi_name }
+                        : {}),
+                },
+                cover: {
+                    poster: coverUri,
+                    custom_cover_image_height: coverHeight,
+                    custom_cover_image_width: coverWidth,
+                    poster_delay: 0,
+                    cover_tools_info: DEFAULT_COVER_TOOLS_INFO,
+                    cover_tools_extend_info: '{}',
+                },
+                mix: kwargs.collection
+                    ? { mix_id: kwargs.collection, mix_order: 0 }
+                    : {},
+                chapter: {
+                    chapter: JSON.stringify({
+                        chapter_abstract: '',
+                        chapter_details: [],
+                        chapter_type: 0,
+                    }),
+                },
+                anchor: {},
+                sync: {
+                    should_sync: false,
+                    sync_to_toutiao: kwargs.sync_toutiao ? 1 : 0,
+                },
+                open_platform: {},
+                assistant: { is_preview: 0, is_post_assistant: 1 },
+                declare: { user_declare_info: '{}' },
+            },
+        };
+        const publishUrl = `https://creator.douyin.com/web/api/media/aweme/create_v2/?read_aid=2906&${DEVICE_PARAMS}`;
+        const publishRes = (await browserFetch(page, 'POST', publishUrl, {
+            body: publishBody,
+        }));
+        const awemeId = publishRes.aweme_id;
+        if (!awemeId) {
+            throw new CommandExecutionError(`发布成功但未返回 aweme_id: ${JSON.stringify(publishRes)}`);
+        }
+        const url = `https://www.douyin.com/video/${awemeId}`;
+        const publishTimeStr = new Date(timingTs * 1000).toLocaleString('zh-CN', {
+            timeZone: 'Asia/Tokyo',
+        });
+        return [
+            {
+                status: '✅ 定时发布成功！',
+                aweme_id: awemeId,
+                url,
+                publish_time: publishTimeStr,
+            },
+        ];
+    },
+});

package/vendor/opencli/dist/clis/douyin/publish.test.d.ts

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

package/vendor/opencli/dist/clis/douyin/publish.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './publish.js';
+describe('douyin publish registration', () => {
+    it('registers the publish command', () => {
+        const registry = getRegistry();
+        const cmds = [...registry.values()];
+        const cmd = cmds.find((c) => c.site === 'douyin' && c.name === 'publish');
+        expect(cmd).toBeDefined();
+        expect(cmd?.args.some((a) => a.name === 'video')).toBe(true);
+        expect(cmd?.args.some((a) => a.name === 'title')).toBe(true);
+        expect(cmd?.args.some((a) => a.name === 'schedule')).toBe(true);
+    });
+    it('has all expected args', () => {
+        const registry = getRegistry();
+        const cmd = [...registry.values()].find((c) => c.site === 'douyin' && c.name === 'publish');
+        const argNames = cmd?.args.map((a) => a.name) ?? [];
+        expect(argNames).toContain('video');
+        expect(argNames).toContain('title');
+        expect(argNames).toContain('schedule');
+        expect(argNames).toContain('caption');
+        expect(argNames).toContain('cover');
+        expect(argNames).toContain('visibility');
+        expect(argNames).toContain('allow_download');
+        expect(argNames).toContain('collection');
+        expect(argNames).toContain('activity');
+        expect(argNames).toContain('poi_id');
+        expect(argNames).toContain('poi_name');
+        expect(argNames).toContain('hotspot');
+        expect(argNames).toContain('no_safety_check');
+        expect(argNames).toContain('sync_toutiao');
+    });
+    it('uses COOKIE strategy', () => {
+        const registry = getRegistry();
+        const cmd = [...registry.values()].find((c) => c.site === 'douyin' && c.name === 'publish');
+        expect(cmd?.strategy).toBe('cookie');
+    });
+});

package/vendor/opencli/dist/clis/douyin/stats.d.ts

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

package/vendor/opencli/dist/clis/douyin/stats.js

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../registry.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+cli({
+    site: 'douyin',
+    name: 'stats',
+    description: '作品数据分析',
+    domain: 'creator.douyin.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'aweme_id', required: true, positional: true },
+    ],
+    columns: ['metric', 'value'],
+    func: async (page, kwargs) => {
+        const now = Math.floor(Date.now() / 1000);
+        const sevenDaysAgo = now - 7 * 86400;
+        const url = 'https://creator.douyin.com/janus/douyin/creator/data/item_analysis/metrics_trend';
+        const body = {
+            aweme_id: kwargs.aweme_id,
+            start_time: sevenDaysAgo,
+            end_time: now,
+            metrics: ['play_count', 'like_count', 'comment_count', 'share_count'],
+        };
+        const res = await browserFetch(page, 'POST', url, { body });
+        const data = res.data ?? {};
+        return Object.entries(data).map(([metric, value]) => ({ metric, value }));
+    },
+});

package/vendor/opencli/dist/clis/douyin/stats.test.d.ts

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

package/vendor/opencli/dist/clis/douyin/stats.test.js

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

package/vendor/opencli/dist/clis/douyin/update.d.ts

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

package/vendor/opencli/dist/clis/douyin/update.js

@@ -0,0 +1,31 @@
+import { cli, Strategy } from '../../registry.js';
+import { ArgumentError } from '../../errors.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+import { toUnixSeconds, validateTiming } from './_shared/timing.js';
+cli({
+    site: 'douyin',
+    name: 'update',
+    description: '更新视频信息',
+    domain: 'creator.douyin.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'aweme_id', required: true, positional: true },
+        { name: 'reschedule', default: '', help: '新的发布时间（ISO8601 或 Unix 秒）' },
+        { name: 'caption', default: '', help: '新的正文内容' },
+    ],
+    columns: ['status'],
+    func: async (page, kwargs) => {
+        if (!kwargs.reschedule && !kwargs.caption) {
+            throw new ArgumentError('必须提供 --reschedule 或 --caption');
+        }
+        if (kwargs.reschedule) {
+            const newTime = toUnixSeconds(kwargs.reschedule);
+            validateTiming(newTime);
+            await browserFetch(page, 'POST', 'https://creator.douyin.com/web/api/media/update/timer/?aid=1128', { body: { aweme_id: kwargs.aweme_id, publish_time: newTime } });
+        }
+        if (kwargs.caption) {
+            await browserFetch(page, 'POST', 'https://creator.douyin.com/web/api/media/update/desc/?aid=1128', { body: { aweme_id: kwargs.aweme_id, desc: kwargs.caption } });
+        }
+        return [{ status: '✅ 更新成功' }];
+    },
+});

package/vendor/opencli/dist/clis/douyin/update.test.d.ts

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

package/vendor/opencli/dist/clis/douyin/update.test.js

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

package/vendor/opencli/dist/clis/douyin/user-videos.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_USER_VIDEOS_LIMIT = 20;
+export declare const USER_VIDEO_COMMENT_CONCURRENCY = 4;
+export declare const DEFAULT_COMMENT_LIMIT = 10;
+export declare function normalizeUserVideosLimit(limit: unknown): number;
+export declare function normalizeCommentLimit(limit: unknown): number;

package/vendor/opencli/dist/clis/douyin/user-videos.js

@@ -0,0 +1,74 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchDouyinComments, fetchDouyinUserVideos } from './_shared/public-api.js';
+export const MAX_USER_VIDEOS_LIMIT = 20;
+export const USER_VIDEO_COMMENT_CONCURRENCY = 4;
+export const DEFAULT_COMMENT_LIMIT = 10;
+export function normalizeUserVideosLimit(limit) {
+    const numeric = Number(limit);
+    if (!Number.isFinite(numeric))
+        return MAX_USER_VIDEOS_LIMIT;
+    return Math.min(MAX_USER_VIDEOS_LIMIT, Math.max(1, Math.round(numeric)));
+}
+export function normalizeCommentLimit(limit) {
+    const numeric = Number(limit);
+    if (!Number.isFinite(numeric))
+        return DEFAULT_COMMENT_LIMIT;
+    return Math.min(DEFAULT_COMMENT_LIMIT, Math.max(1, Math.round(numeric)));
+}
+async function mapInBatches(items, concurrency, mapper) {
+    const results = [];
+    for (let index = 0; index < items.length; index += concurrency) {
+        const chunk = items.slice(index, index + concurrency);
+        results.push(...(await Promise.all(chunk.map(mapper))));
+    }
+    return results;
+}
+async function fetchTopComments(page, awemeId, count) {
+    try {
+        return await fetchDouyinComments(page, awemeId, count);
+    }
+    catch {
+        return [];
+    }
+}
+cli({
+    site: 'douyin',
+    name: 'user-videos',
+    description: '获取指定用户的视频列表（含下载地址和热门评论）',
+    domain: 'www.douyin.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'sec_uid', type: 'string', required: true, positional: true, help: '用户 sec_uid（URL 末尾部分）' },
+        { name: 'limit', type: 'int', default: 20, help: '获取数量（最大 20）' },
+        { name: 'with_comments', type: 'bool', default: true, help: '包含热门评论（默认: true）' },
+        { name: 'comment_limit', type: 'int', default: 10, help: '每个视频获取多少条评论（最大 10）' },
+    ],
+    columns: ['index', 'aweme_id', 'title', 'duration', 'digg_count', 'play_url', 'top_comments'],
+    func: async (page, kwargs) => {
+        const secUid = kwargs.sec_uid;
+        const limit = normalizeUserVideosLimit(kwargs.limit);
+        const withComments = kwargs.with_comments !== false;
+        const commentLimit = normalizeCommentLimit(kwargs.comment_limit);
+        await page.goto(`https://www.douyin.com/user/${secUid}`);
+        await page.wait(3);
+        const awemeList = (await fetchDouyinUserVideos(page, secUid, limit)).slice(0, limit);
+        const videos = withComments
+            ? await mapInBatches(awemeList, USER_VIDEO_COMMENT_CONCURRENCY, async (video) => ({
+                ...video,
+                top_comments: await fetchTopComments(page, video.aweme_id, commentLimit),
+            }))
+            : awemeList.map((video) => ({ ...video, top_comments: [] }));
+        return videos.map((video, index) => {
+            const playUrl = video.video?.play_addr?.url_list?.[0] ?? '';
+            return {
+                index: index + 1,
+                aweme_id: video.aweme_id,
+                title: video.desc ?? '',
+                duration: Math.round((video.video?.duration ?? 0) / 1000),
+                digg_count: video.statistics?.digg_count ?? 0,
+                play_url: playUrl,
+                top_comments: video.top_comments ?? [],
+            };
+        });
+    },
+});

package/vendor/opencli/dist/clis/douyin/user-videos.test.d.ts

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

package/vendor/opencli/dist/clis/douyin/user-videos.test.js

@@ -0,0 +1,108 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { fetchDouyinUserVideosMock, fetchDouyinCommentsMock } = vi.hoisted(() => ({
+    fetchDouyinUserVideosMock: vi.fn(),
+    fetchDouyinCommentsMock: vi.fn(),
+}));
+vi.mock('./_shared/public-api.js', () => ({
+    fetchDouyinUserVideos: fetchDouyinUserVideosMock,
+    fetchDouyinComments: fetchDouyinCommentsMock,
+}));
+import { getRegistry } from '../../registry.js';
+import { DEFAULT_COMMENT_LIMIT, MAX_USER_VIDEOS_LIMIT, normalizeCommentLimit, normalizeUserVideosLimit } from './user-videos.js';
+describe('douyin user-videos', () => {
+    beforeEach(() => {
+        fetchDouyinUserVideosMock.mockReset();
+        fetchDouyinCommentsMock.mockReset();
+    });
+    it('registers the command', () => {
+        const registry = getRegistry();
+        const values = [...registry.values()];
+        const command = values.find((cmd) => cmd.site === 'douyin' && cmd.name === 'user-videos');
+        expect(command).toBeDefined();
+    });
+    it('clamps limit to a safe maximum', () => {
+        expect(normalizeUserVideosLimit(100)).toBe(MAX_USER_VIDEOS_LIMIT);
+        expect(normalizeUserVideosLimit(0)).toBe(1);
+        expect(normalizeCommentLimit(99)).toBe(DEFAULT_COMMENT_LIMIT);
+    });
+    it('uses shared public-api helpers and applies clamped limits', async () => {
+        const registry = getRegistry();
+        const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'user-videos');
+        expect(command?.func).toBeDefined();
+        if (!command?.func)
+            throw new Error('douyin user-videos command not registered');
+        fetchDouyinUserVideosMock.mockResolvedValueOnce([
+            {
+                aweme_id: '1',
+                desc: 'test video',
+                video: { duration: 1234, play_addr: { url_list: ['https://example.com/video.mp4'] } },
+                statistics: { digg_count: 9 },
+            },
+        ]);
+        fetchDouyinCommentsMock.mockResolvedValueOnce([
+            { text: 'nice', digg_count: 3, nickname: 'alice' },
+        ]);
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+        };
+        const rows = await command.func(page, {
+            sec_uid: 'MS4w-test',
+            limit: 100,
+            comment_limit: 99,
+            with_comments: true,
+        });
+        expect(fetchDouyinUserVideosMock).toHaveBeenCalledWith(page, 'MS4w-test', MAX_USER_VIDEOS_LIMIT);
+        expect(fetchDouyinCommentsMock).toHaveBeenCalledWith(page, '1', DEFAULT_COMMENT_LIMIT);
+        expect(rows).toEqual([
+            {
+                index: 1,
+                aweme_id: '1',
+                title: 'test video',
+                duration: 1,
+                digg_count: 9,
+                play_url: 'https://example.com/video.mp4',
+                top_comments: [
+                    { text: 'nice', digg_count: 3, nickname: 'alice' },
+                ],
+            },
+        ]);
+    });
+    it('skips comment enrichment when with_comments is false', async () => {
+        const registry = getRegistry();
+        const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'user-videos');
+        expect(command?.func).toBeDefined();
+        if (!command?.func)
+            throw new Error('douyin user-videos command not registered');
+        fetchDouyinUserVideosMock.mockResolvedValueOnce([
+            {
+                aweme_id: '2',
+                desc: 'plain video',
+                video: { duration: 2000, play_addr: { url_list: ['https://example.com/plain.mp4'] } },
+                statistics: { digg_count: 1 },
+            },
+        ]);
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+        };
+        const rows = await command.func(page, {
+            sec_uid: 'MS4w-test',
+            limit: 3,
+            with_comments: false,
+            comment_limit: 5,
+        });
+        expect(fetchDouyinCommentsMock).not.toHaveBeenCalled();
+        expect(rows).toEqual([
+            {
+                index: 1,
+                aweme_id: '2',
+                title: 'plain video',
+                duration: 2,
+                digg_count: 1,
+                play_url: 'https://example.com/plain.mp4',
+                top_comments: [],
+            },
+        ]);
+    });
+});

package/vendor/opencli/dist/clis/douyin/videos.d.ts

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