@jackwener/opencli 1.4.0 → 1.5.0

package/dist/clis/douban/utils.js

@@ -1,10 +1,15 @@
 /**
  * Douban adapter utilities.
  */
-import { CliError } from '../../errors.js';
+import { ArgumentError, CliError, EmptyResultError } from '../../errors.js';
+const DOUBAN_PHOTO_PAGE_SIZE = 30;
+const MAX_DOUBAN_PHOTOS = 500;
 function clampLimit(limit) {
     return Math.max(1, Math.min(limit || 20, 50));
 }
+function clampPhotoLimit(limit) {
+    return Math.max(1, Math.min(limit || 120, MAX_DOUBAN_PHOTOS));
+}
 async function ensureDoubanReady(page) {
     const state = await page.evaluate(`
     (() => {
@@ -18,6 +23,190 @@ async function ensureDoubanReady(page) {
         throw new CliError('AUTH_REQUIRED', 'Douban requires a logged-in browser session before these commands can load data.', 'Please sign in to douban.com in the browser that opencli reuses, then rerun the command.');
     }
 }
+export function normalizeDoubanSubjectId(subjectId) {
+    const normalized = String(subjectId || '').trim();
+    if (!/^\d+$/.test(normalized)) {
+        throw new ArgumentError(`Invalid Douban subject ID: ${subjectId}`);
+    }
+    return normalized;
+}
+export function promoteDoubanPhotoUrl(url, size = 'l') {
+    const normalized = String(url || '').trim();
+    if (!normalized)
+        return '';
+    if (/^[a-z]+:/i.test(normalized) && !/^https?:/i.test(normalized))
+        return '';
+    return normalized.replace(/\/view\/photo\/[^/]+\/public\//, `/view/photo/${size}/public/`);
+}
+export function resolveDoubanPhotoAssetUrl(candidates, baseUrl = '') {
+    for (const candidate of candidates) {
+        const normalized = String(candidate || '').trim();
+        if (!normalized)
+            continue;
+        let resolved = normalized;
+        try {
+            resolved = baseUrl
+                ? new URL(normalized, baseUrl).toString()
+                : new URL(normalized).toString();
+        }
+        catch {
+            resolved = normalized;
+        }
+        if (/^https?:\/\//i.test(resolved)) {
+            return resolved;
+        }
+    }
+    return '';
+}
+export function getDoubanPhotoExtension(url) {
+    const normalized = String(url || '').trim();
+    if (!normalized)
+        return '.jpg';
+    try {
+        const ext = new URL(normalized).pathname.match(/\.(jpe?g|png|gif|webp|avif|bmp)$/i)?.[0];
+        return ext || '.jpg';
+    }
+    catch {
+        const ext = normalized.match(/\.(jpe?g|png|gif|webp|avif|bmp)(?:$|[?#])/i)?.[0];
+        return ext ? ext.replace(/[?#].*$/, '') : '.jpg';
+    }
+}
+export async function loadDoubanSubjectPhotos(page, subjectId, options = {}) {
+    const normalizedId = normalizeDoubanSubjectId(subjectId);
+    const type = String(options.type || 'Rb').trim() || 'Rb';
+    const targetPhotoId = String(options.targetPhotoId || '').trim();
+    const safeLimit = targetPhotoId ? Number.MAX_SAFE_INTEGER : clampPhotoLimit(Number(options.limit) || 120);
+    const resolvePhotoAssetUrlSource = resolveDoubanPhotoAssetUrl.toString();
+    const galleryUrl = `https://movie.douban.com/subject/${normalizedId}/photos?type=${encodeURIComponent(type)}`;
+    await page.goto(galleryUrl);
+    await page.wait(2);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (async () => {
+      const subjectId = ${JSON.stringify(normalizedId)};
+      const type = ${JSON.stringify(type)};
+      const limit = ${safeLimit};
+      const targetPhotoId = ${JSON.stringify(targetPhotoId)};
+      const pageSize = ${DOUBAN_PHOTO_PAGE_SIZE};
+      const resolveDoubanPhotoAssetUrl = ${resolvePhotoAssetUrlSource};
+
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const toAbsoluteUrl = (value) => {
+        if (!value) return '';
+        try {
+          return new URL(value, location.origin).toString();
+        } catch {
+          return value;
+        }
+      };
+      const promotePhotoUrl = (value) => {
+        const absolute = toAbsoluteUrl(value);
+        if (!absolute) return '';
+        if (/^[a-z]+:/i.test(absolute) && !/^https?:/i.test(absolute)) return '';
+        return absolute.replace(/\\/view\\/photo\\/[^/]+\\/public\\//, '/view/photo/l/public/');
+      };
+      const buildPageUrl = (start) => {
+        const url = new URL(location.href);
+        url.searchParams.set('type', type);
+        if (start > 0) url.searchParams.set('start', String(start));
+        else url.searchParams.delete('start');
+        return url.toString();
+      };
+      const getTitle = (doc) => {
+        const raw = normalize(doc.querySelector('#content h1')?.textContent)
+          || normalize(doc.querySelector('title')?.textContent);
+        return raw.replace(/\\s*\\(豆瓣\\)\\s*$/, '');
+      };
+      const extractPhotos = (doc, pageNumber) => {
+        const nodes = Array.from(doc.querySelectorAll('.poster-col3 li, .poster-col3l li, .article li'));
+        const rows = [];
+        for (const node of nodes) {
+          const link = node.querySelector('a[href*="/photos/photo/"]');
+          const img = node.querySelector('img');
+          if (!link || !img) continue;
+
+          const detailUrl = toAbsoluteUrl(link.getAttribute('href') || '');
+          const photoId = detailUrl.match(/\\/photo\\/(\\d+)/)?.[1] || '';
+          const thumbUrl = resolveDoubanPhotoAssetUrl([
+            img.getAttribute('data-origin'),
+            img.getAttribute('data-src'),
+            img.getAttribute('src'),
+          ], location.href);
+          const imageUrl = promotePhotoUrl(thumbUrl);
+          const title = normalize(link.getAttribute('title'))
+            || normalize(img.getAttribute('alt'))
+            || (photoId ? 'photo_' + photoId : 'photo_' + String(rows.length + 1));
+
+          if (!detailUrl || !thumbUrl || !imageUrl) continue;
+
+          rows.push({
+            photoId,
+            title,
+            imageUrl,
+            thumbUrl,
+            detailUrl,
+            page: pageNumber,
+          });
+        }
+        return rows;
+      };
+
+      const subjectTitle = getTitle(document);
+      const seen = new Set();
+      const photos = [];
+
+      for (let pageIndex = 0; photos.length < limit; pageIndex += 1) {
+        let doc = document;
+        if (pageIndex > 0) {
+          const response = await fetch(buildPageUrl(pageIndex * pageSize), { credentials: 'include' });
+          if (!response.ok) break;
+          const html = await response.text();
+          doc = new DOMParser().parseFromString(html, 'text/html');
+        }
+
+        const pagePhotos = extractPhotos(doc, pageIndex + 1);
+        if (!pagePhotos.length) break;
+
+        let appended = 0;
+        let foundTarget = false;
+        for (const photo of pagePhotos) {
+          const key = photo.photoId || photo.detailUrl || photo.imageUrl;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          photos.push({
+            index: photos.length + 1,
+            ...photo,
+          });
+          appended += 1;
+          if (targetPhotoId && photo.photoId === targetPhotoId) {
+            foundTarget = true;
+            break;
+          }
+          if (photos.length >= limit) break;
+        }
+
+        if (foundTarget || pagePhotos.length < pageSize || appended === 0) break;
+      }
+
+      return {
+        subjectId,
+        subjectTitle,
+        type,
+        photos,
+      };
+    })()
+  `);
+    const photos = Array.isArray(data?.photos) ? data.photos : [];
+    if (!photos.length) {
+        throw new EmptyResultError('douban photos', 'No photos found. Try a different subject ID or a different --type value such as Rb.');
+    }
+    return {
+        subjectId: normalizedId,
+        subjectTitle: String(data?.subjectTitle || '').trim(),
+        type,
+        photos,
+    };
+}
 export async function loadDoubanBookHot(page, limit) {
     const safeLimit = clampLimit(limit);
     await page.goto('https://book.douban.com/chart');

package/dist/clis/douban/utils.test.d.ts

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

package/dist/clis/douban/utils.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getDoubanPhotoExtension, loadDoubanSubjectPhotos, normalizeDoubanSubjectId, promoteDoubanPhotoUrl, resolveDoubanPhotoAssetUrl, } from './utils.js';
+describe('douban utils', () => {
+    it('normalizes valid subject ids', () => {
+        expect(normalizeDoubanSubjectId(' 30382501 ')).toBe('30382501');
+    });
+    it('rejects invalid subject ids', () => {
+        expect(() => normalizeDoubanSubjectId('tt30382501')).toThrow('Invalid Douban subject ID');
+    });
+    it('promotes thumbnail urls to large photo urls', () => {
+        expect(promoteDoubanPhotoUrl('https://img1.doubanio.com/view/photo/m/public/p2913450214.webp')).toBe('https://img1.doubanio.com/view/photo/l/public/p2913450214.webp');
+        expect(promoteDoubanPhotoUrl('https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2578474613.jpg')).toBe('https://img9.doubanio.com/view/photo/l/public/p2578474613.jpg');
+    });
+    it('rejects non-http photo urls during promotion', () => {
+        expect(promoteDoubanPhotoUrl('data:image/gif;base64,abc')).toBe('');
+    });
+    it('prefers lazy-loaded photo urls over data placeholders', () => {
+        expect(resolveDoubanPhotoAssetUrl([
+            '',
+            'https://img1.doubanio.com/view/photo/m/public/p2913450214.webp',
+            'data:image/gif;base64,abc',
+        ], 'https://movie.douban.com/subject/30382501/photos?type=Rb')).toBe('https://img1.doubanio.com/view/photo/m/public/p2913450214.webp');
+    });
+    it('drops unsupported non-http photo urls when no real image url exists', () => {
+        expect(resolveDoubanPhotoAssetUrl(['data:image/gif;base64,abc', 'blob:https://movie.douban.com/example'], 'https://movie.douban.com/subject/30382501/photos?type=Rb')).toBe('');
+    });
+    it('removes the default photo cap when scanning for an exact photo id', async () => {
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce({ blocked: false, title: 'Some Movie', href: 'https://movie.douban.com/subject/30382501/photos?type=Rb' })
+            .mockResolvedValueOnce({
+            subjectId: '30382501',
+            subjectTitle: 'The Wandering Earth 2',
+            type: 'Rb',
+            photos: [
+                {
+                    index: 731,
+                    photoId: '2913450215',
+                    title: 'Character poster',
+                    imageUrl: 'https://img1.doubanio.com/view/photo/l/public/p2913450215.jpg',
+                    thumbUrl: 'https://img1.doubanio.com/view/photo/m/public/p2913450215.jpg',
+                    detailUrl: 'https://movie.douban.com/photos/photo/2913450215/',
+                    page: 25,
+                },
+            ],
+        });
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+        };
+        await loadDoubanSubjectPhotos(page, '30382501', {
+            type: 'Rb',
+            targetPhotoId: '2913450215',
+        });
+        const scanScript = evaluate.mock.calls[1]?.[0];
+        expect(scanScript).toContain('const targetPhotoId = "2913450215";');
+        expect(scanScript).toContain(`const limit = ${Number.MAX_SAFE_INTEGER};`);
+        expect(scanScript).toContain('for (let pageIndex = 0; photos.length < limit; pageIndex += 1)');
+    });
+    it('keeps image extensions when download urls contain query params', () => {
+        expect(getDoubanPhotoExtension('https://img1.doubanio.com/view/photo/l/public/p2913450214.webp?foo=1')).toBe('.webp');
+        expect(getDoubanPhotoExtension('https://img1.doubanio.com/view/photo/l/public/p2913450214.jpeg')).toBe('.jpeg');
+    });
+});

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;