@jackwener/opencli 1.4.0 → 1.5.0

package/src/clis/douyin/_shared/text-extra.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { parseTextExtra, extractHashtagNames, type HashtagInfo } 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: HashtagInfo[] = [
+      { 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: HashtagInfo[] = [
+      { 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/src/clis/douyin/_shared/text-extra.ts

@@ -0,0 +1,33 @@
+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 function parseTextExtra(_text: string, hashtags: HashtagInfo[]): TextExtraItem[] {
+  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: string): string[] {
+  return [...text.matchAll(/#([^\s#]+)/g)].map((m) => m[1]);
+}

package/src/clis/douyin/_shared/timing.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { validateTiming, toUnixSeconds } from './timing.js';
+
+describe('validateTiming', () => {
+  const now = () => Math.floor(Date.now() / 1000);
+
+  it('accepts a time 3 hours from now', () => {
+    expect(() => validateTiming(now() + 3 * 3600)).not.toThrow();
+  });
+
+  it('rejects a time less than 2 hours from now', () => {
+    expect(() => validateTiming(now() + 3600)).toThrow('至少 2 小时后');
+  });
+
+  it('rejects a time more than 14 days from now', () => {
+    expect(() => validateTiming(now() + 15 * 86400)).toThrow('不能超过 14 天');
+  });
+});
+
+describe('toUnixSeconds', () => {
+  it('passes through a numeric unix timestamp', () => {
+    expect(toUnixSeconds(1744070400)).toBe(1744070400);
+  });
+
+  it('parses a numeric unix timestamp string', () => {
+    expect(toUnixSeconds('1744070400')).toBe(1744070400);
+  });
+
+  it('parses ISO8601 string', () => {
+    expect(toUnixSeconds('2026-04-08T12:00:00Z')).toBe(
+      Math.floor(new Date('2026-04-08T12:00:00Z').getTime() / 1000)
+    );
+  });
+
+  it('throws on invalid input', () => {
+    expect(() => toUnixSeconds('not-a-date')).toThrow();
+  });
+});

package/src/clis/douyin/_shared/timing.ts

@@ -0,0 +1,22 @@
+const MIN_OFFSET = 7200;        // 2 hours
+const MAX_OFFSET = 14 * 86400;  // 14 days
+
+export function validateTiming(unixSeconds: number): void {
+  if (!Number.isFinite(unixSeconds))
+    throw new Error(`无效的时间戳: ${unixSeconds}`);
+  const now = Math.floor(Date.now() / 1000);
+  if (unixSeconds < now + MIN_OFFSET)
+    throw new Error(`定时发布时间必须在至少 2 小时后`);
+  if (unixSeconds > now + MAX_OFFSET)
+    throw new Error(`定时发布时间不能超过 14 天`);
+}
+
+export function toUnixSeconds(input: string | number): number {
+  if (typeof input === 'number') return input;
+  if (/^\d+$/.test(input)) {
+    return Number(input);
+  }
+  const ms = new Date(input).getTime();
+  if (isNaN(ms)) throw new Error(`无效的时间格式: "${input}"`);
+  return Math.floor(ms / 1000);
+}

package/src/clis/douyin/_shared/tos-upload-short-read.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Tests for the fs.readSync short-read guard in tosUpload.
+ *
+ * This file is separate from tos-upload.test.ts because vi.mock is hoisted and
+ * would interfere with the real-fs tests there.
+ *
+ * Strategy:
+ * - Use setReadSyncOverride (exported testing seam) to force readSync to return 0
+ * - Mock global fetch to satisfy initMultipartUpload so the code path reaches readSync
+ */
+
+import * as actualFs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { CommandExecutionError } from '../../../errors.js';
+import { setReadSyncOverride, tosUpload } from './tos-upload.js';
+
+/** Build a minimal fetch mock that satisfies initMultipartUpload (POST ?uploads → 200 + UploadId XML). */
+function makeFetchMock(): typeof fetch {
+  return vi.fn().mockResolvedValue({
+    status: 200,
+    text: async () => '<InitiateMultipartUploadResult><UploadId>mock-upload-id</UploadId></InitiateMultipartUploadResult>',
+    headers: { forEach: (_cb: (v: string, k: string) => void) => {} },
+  } as unknown as Response);
+}
+
+describe('tosUpload short-read guard', () => {
+  let tmpDir: string;
+  let tmpFile: string;
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+
+    tmpDir = actualFs.mkdtempSync(path.join(os.tmpdir(), 'tos-upload-shortread-'));
+    tmpFile = path.join(tmpDir, 'video.mp4');
+    // 100-byte file — fits in a single part
+    actualFs.writeFileSync(tmpFile, Buffer.alloc(100, 0xff));
+  });
+
+  afterEach(() => {
+    setReadSyncOverride(null);
+    globalThis.fetch = originalFetch;
+    actualFs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('throws CommandExecutionError on short read', async () => {
+    // Mock fetch so initMultipartUpload succeeds and code reaches readSync
+    globalThis.fetch = makeFetchMock();
+
+    // Override readSync to return 0 (fewer bytes than requested)
+    setReadSyncOverride(() => 0);
+
+    const mockCredentials = {
+      access_key_id: 'AKIAIOSFODNN7EXAMPLE',
+      secret_access_key: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+      session_token: 'test-session-token',
+      expired_time: Date.now() / 1000 + 3600,
+    };
+
+    const uploadInfo = {
+      tos_upload_url: 'https://tos-cn-i-alisg.volces.com/bucket/key',
+      auth: 'AWS4-HMAC-SHA256 Credential=test',
+      video_id: 'test-video-id',
+    };
+
+    await expect(
+      tosUpload({
+        filePath: tmpFile,
+        uploadInfo,
+        credentials: mockCredentials,
+      }),
+    ).rejects.toThrow(CommandExecutionError);
+  });
+
+  it('error message identifies the part number and byte counts', async () => {
+    globalThis.fetch = makeFetchMock();
+    setReadSyncOverride(() => 0);
+
+    const mockCredentials = {
+      access_key_id: 'AKIAIOSFODNN7EXAMPLE',
+      secret_access_key: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+      session_token: 'test-session-token',
+      expired_time: Date.now() / 1000 + 3600,
+    };
+
+    const uploadInfo = {
+      tos_upload_url: 'https://tos-cn-i-alisg.volces.com/bucket/key',
+      auth: 'AWS4-HMAC-SHA256 Credential=test',
+      video_id: 'test-video-id',
+    };
+
+    await expect(
+      tosUpload({
+        filePath: tmpFile,
+        uploadInfo,
+        credentials: mockCredentials,
+      }),
+    ).rejects.toThrow(/Short read on part 1: expected 100 bytes, got 0/);
+  });
+});

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

@@ -0,0 +1,281 @@
+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';
+import type { ResumeState } 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: string;
+  let resumePath: string;
+
+  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: ResumeState = {
+      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: ResumeState = {
+      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: ResumeState = { 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']);
+  });
+});
+