@jackwener/opencli 1.4.0 → 1.5.0

package/src/clis/douban/utils.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { IPage } from '../../types.js';
+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,
+    } as unknown as IPage;
+
+    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/src/clis/douban/utils.ts

@@ -2,13 +2,20 @@
  * Douban adapter utilities.
  */
 
-import { CliError } from '../../errors.js';
+import { ArgumentError, CliError, EmptyResultError } from '../../errors.js';
 import type { IPage } from '../../types.js';
 
+const DOUBAN_PHOTO_PAGE_SIZE = 30;
+const MAX_DOUBAN_PHOTOS = 500;
+
 function clampLimit(limit: number): number {
   return Math.max(1, Math.min(limit || 20, 50));
 }
 
+function clampPhotoLimit(limit: number): number {
+  return Math.max(1, Math.min(limit || 120, MAX_DOUBAN_PHOTOS));
+}
+
 async function ensureDoubanReady(page: IPage): Promise<void> {
   const state = await page.evaluate(`
     (() => {
@@ -27,6 +34,230 @@ async function ensureDoubanReady(page: IPage): Promise<void> {
   }
 }
 
+export interface DoubanSubjectPhoto {
+  index: number;
+  photoId: string;
+  title: string;
+  imageUrl: string;
+  thumbUrl: string;
+  detailUrl: string;
+  page: number;
+}
+
+export interface DoubanSubjectPhotosResult {
+  subjectId: string;
+  subjectTitle: string;
+  type: string;
+  photos: DoubanSubjectPhoto[];
+}
+
+export interface LoadDoubanSubjectPhotosOptions {
+  type?: string;
+  limit?: number;
+  targetPhotoId?: string;
+}
+
+export function normalizeDoubanSubjectId(subjectId: string): string {
+  const normalized = String(subjectId || '').trim();
+  if (!/^\d+$/.test(normalized)) {
+    throw new ArgumentError(`Invalid Douban subject ID: ${subjectId}`);
+  }
+  return normalized;
+}
+
+export function promoteDoubanPhotoUrl(url: string, size: 's' | 'm' | 'l' = 'l'): string {
+  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: Array<string | null | undefined>,
+  baseUrl = '',
+): string {
+  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: string): string {
+  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: IPage,
+  subjectId: string,
+  options: LoadDoubanSubjectPhotosOptions = {},
+): Promise<DoubanSubjectPhotosResult> {
+  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: IPage, limit: number): Promise<any[]> {
   const safeLimit = clampLimit(limit);
   await page.goto('https://book.douban.com/chart');

package/src/clis/douyin/_shared/browser-fetch.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { IPage } from '../../../types.js';
+import { browserFetch } from './browser-fetch.js';
+
+function makePage(result: unknown): IPage {
+  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(),
+  } as unknown as IPage;
+}
+
+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/src/clis/douyin/_shared/browser-fetch.ts

@@ -0,0 +1,45 @@
+import type { IPage } from '../../../types.js';
+import { CommandExecutionError } from '../../../errors.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 async function browserFetch(
+  page: IPage,
+  method: 'GET' | 'POST',
+  url: string,
+  options: FetchOptions = {}
+): Promise<unknown> {
+  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 as { status_code: number }).status_code;
+    if (code !== 0) {
+      const msg = (result as { status_msg?: string }).status_msg ?? 'unknown error';
+      throw new CommandExecutionError(`Douyin API error ${code}: ${msg}`);
+    }
+  }
+
+  return result;
+}

package/src/clis/douyin/_shared/creation-id.test.ts

@@ -0,0 +1,26 @@
+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/src/clis/douyin/_shared/creation-id.ts

@@ -0,0 +1,8 @@
+const CHARS = 'abcdefghijklmnopqrstuvwxyz0123456789';
+
+export function generateCreationId(): string {
+  const random = Array.from({ length: 4 }, () =>
+    CHARS[Math.floor(Math.random() * CHARS.length)]
+  ).join('');
+  return 'pin' + random + Date.now();
+}

package/src/clis/douyin/_shared/imagex-upload.test.ts

@@ -0,0 +1,113 @@
+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';
+import type { ImageXUploadInfo } from './imagex-upload.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeTempImage(ext = '.jpg'): string {
+  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: ImageXUploadInfo = {
+  upload_url: 'https://imagex.bytedance.com/upload/presigned/fake',
+  store_uri: 'tos-cn-i-alisg.example.com/cover/abc123',
+};
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('imagexUpload', () => {
+  let imagePath: string;
+
+  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] as [string, RequestInit];
+    expect(url).toBe(FAKE_UPLOAD_INFO.upload_url);
+    expect(init.method).toBe('PUT');
+    expect((init.headers as Record<string, string>)['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] as [string, RequestInit];
+      expect((init.headers as Record<string, string>)['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/src/clis/douyin/_shared/imagex-upload.ts

@@ -0,0 +1,76 @@
+/**
+ * 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';
+
+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;
+}
+
+/**
+ * Detect MIME type from file extension.
+ * Falls back to image/jpeg for unknown extensions.
+ */
+function detectContentType(filePath: string): string {
+  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: string,
+  uploadInfo: ImageXUploadInfo,
+): Promise<string> {
+  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 as unknown as BodyInit,
+  });
+
+  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/src/clis/douyin/_shared/sts2.ts

@@ -0,0 +1,20 @@
+import type { IPage } from '../../../types.js';
+import type { Sts2Credentials } from './types.js';
+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: IPage): Promise<Sts2Credentials> {
+  const js = `fetch(${JSON.stringify(STS2_URL)}, { credentials: 'include' }).then(r => r.json())`;
+  const res = await page.evaluate(js) as { data: Sts2Credentials };
+  if (!res?.data?.access_key_id) {
+    throw new AuthRequiredError('creator.douyin.com', 'STS2 credentials missing');
+  }
+  return res.data;
+}