@lightcone-ai/daemon 0.15.47 → 0.15.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.15.47",
+  "version": "0.15.49",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/_vendor/video/composer-v2/index.js

@@ -9,6 +9,53 @@ const DEFAULT_WIDTH = 1080;
 const DEFAULT_HEIGHT = 1920;
 const DEFAULT_FPS = 30;
 const TRANSITION_DURATION = 0.5;
+const SUBTITLE_FONT = 'PingFang SC,Microsoft YaHei,Arial';
+const SUBTITLE_FONT_SIZE = 72;
+const SUBTITLE_MARGIN_V = 120;
+
+function msToAssTimestamp(ms) {
+  const totalCs = Math.round(Math.max(0, ms) / 10);
+  const cs = totalCs % 100;
+  const totalSec = Math.floor(totalCs / 100);
+  const sec = totalSec % 60;
+  const min = Math.floor(totalSec / 60) % 60;
+  const hr = Math.floor(totalSec / 3600);
+  return `${hr}:${String(min).padStart(2, '0')}:${String(sec).padStart(2, '0')}.${String(cs).padStart(2, '0')}`;
+}
+
+function wrapSubtitleText(text, maxChars = 14) {
+  const chars = Array.from(String(text ?? ''));
+  if (chars.length <= maxChars) return chars.join('');
+  const lines = [];
+  for (let i = 0; i < chars.length; i += maxChars) {
+    lines.push(chars.slice(i, i + maxChars).join(''));
+  }
+  return lines.join('\\N');
+}
+
+function buildAssContent(subtitles, { playResX = DEFAULT_WIDTH, playResY = DEFAULT_HEIGHT } = {}) {
+  const maxChars = Math.floor((playResX - 60) / SUBTITLE_FONT_SIZE);
+  const header = [
+    '[Script Info]',
+    'ScriptType: v4.00+',
+    `PlayResX: ${playResX}`,
+    `PlayResY: ${playResY}`,
+    'WrapStyle: 2',
+    '',
+    '[V4+ Styles]',
+    'Format: Name, Fontname, Fontsize, PrimaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding',
+    `Style: Default,${SUBTITLE_FONT},${SUBTITLE_FONT_SIZE},&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,4,0,2,30,30,${SUBTITLE_MARGIN_V},1`,
+    '',
+    '[Events]',
+    'Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text',
+  ].join('\n');
+  const events = subtitles.map(({ text, start_ms, end_ms }) => {
+    const wrapped = wrapSubtitleText(text, maxChars);
+    const safe = wrapped.replace(/\r?\n/g, '\\N').replace(/,/g, '{\\,}');
+    return `Dialogue: 0,${msToAssTimestamp(start_ms)},${msToAssTimestamp(end_ms)},Default,,0,0,0,,${safe}`;
+  });
+  return `${header}\n${events.join('\n')}\n`;
+}
 
 async function fileExists(p) {
   try { await access(p, fsConstants.R_OK); return true; } catch { return false; }
@@ -245,7 +292,8 @@ export async function composeVideoV2({
         finalClip = await silentClip({ videoPath: visualClip.path, duration: visualClip.duration, tmpDir });
       }
 
-      readyClips.push({ path: finalClip, duration: visualClip.duration, transition });
+      const subtitleText = typeof seg.subtitle_text === 'string' ? seg.subtitle_text.trim() : '';
+      readyClips.push({ path: finalClip, duration: visualClip.duration, transition, subtitleText });
     }
 
     const outroClips = [];
@@ -256,6 +304,20 @@ export async function composeVideoV2({
       }
     }
 
+    // Build subtitle entries with cumulative timeline timestamps
+    let cursorMs = 0;
+    const subtitleEntries = [];
+    for (const clip of readyClips) {
+      if (clip.subtitleText) {
+        subtitleEntries.push({
+          text: clip.subtitleText,
+          start_ms: cursorMs,
+          end_ms: cursorMs + Math.round(clip.duration * 1000),
+        });
+      }
+      cursorMs += Math.round(clip.duration * 1000);
+    }
+
     const allClips = [];
     let accumulated = readyClips[0].path;
     for (let i = 1; i < readyClips.length; i++) {
@@ -271,10 +333,29 @@ export async function composeVideoV2({
 
     const finalSequence = [...allClips, ...outroClips];
 
+    // Compose without subtitles first (subtitles are burned in a separate pass)
+    const preSubPath = subtitleEntries.length > 0
+      ? path.join(tmpDir, `pre-sub-${randomUUID().slice(0, 8)}.mp4`)
+      : outPath;
+
     if (finalSequence.length === 1) {
-      await runFfmpeg(['-i', finalSequence[0], '-c', 'copy', '-movflags', '+faststart', outPath], 'ffmpeg copy');
+      await runFfmpeg(['-i', finalSequence[0], '-c', 'copy', '-movflags', '+faststart', preSubPath], 'ffmpeg copy');
     } else {
-      await concatWithCuts({ clips: finalSequence, outputPath: outPath });
+      await concatWithCuts({ clips: finalSequence, outputPath: preSubPath });
+    }
+
+    // Burn subtitles into final output
+    if (subtitleEntries.length > 0) {
+      const assPath = path.join(tmpDir, `subs-${randomUUID().slice(0, 8)}.ass`);
+      await writeFile(assPath, buildAssContent(subtitleEntries, { playResX: width, playResY: height }));
+      const escapedAssPath = assPath.replace(/\\/g, '/').replace(/:/g, '\\:').replace(/'/g, "\\'");
+      await runFfmpeg([
+        '-i', preSubPath,
+        '-vf', `subtitles='${escapedAssPath}'`,
+        '-c:a', 'copy',
+        '-movflags', '+faststart',
+        outPath,
+      ], 'ffmpeg burn-subtitles');
     }
 
     const totalDuration = await probeDurationSec(outPath);

package/src/chat-bridge.js

@@ -16,6 +16,7 @@ import { runSubmitToLibraryTool } from './submit-to-library-tool.js';
 import { runRenderTextToImageTool } from './tools/render-text-to-image.js';
 import { runRenderHtmlToImageTool } from './tools/render-html-to-image.js';
 import { runSynthesisTtsTool } from './tools/synthesize-tts.js';
+import { runPlanVideoSegmentsTool } from './tools/plan-video-segments.js';
 import { runComposeVideoV2Tool } from './tools/compose-video-v2.js';
 import { runTakePageScreenshotTool } from './tools/take-page-screenshot.js';
 import { runGetLibraryFileTool } from './tools/get-library-file.js';
@@ -1357,24 +1358,44 @@ server.tool('synthesize_tts',
   async (args) => runSynthesisTtsTool({ ...args, currentWorkspaceId, api })
 );
 
+// ── plan_video_segments ────────────────────────────────────────────────────────
+server.tool('plan_video_segments',
+  'Universal audio-video sync planning step. For each segment, call TTS to get the real audio duration, then compute the visual duration with a safety buffer. Returns a planned segments array ready to pass directly to compose_video_v2 (with audio_path, presentation.duration/per_card_duration, and subtitle_text pre-filled). Always call this before compose_video_v2 when you have narration text.',
+  {
+    segments: z.array(z.object({
+      text: z.string().describe('Narration text for this segment. TTS will be generated from this.'),
+      visual_kind: z.enum(['image', 'video', 'gif', 'carousel']).describe('Type of visual.'),
+      visual_path: z.string().optional().describe('Absolute path to a single image, video, or gif file.'),
+      visual_paths: z.array(z.string()).optional().describe('For carousel: array of image paths, one per card.'),
+      transition: z.enum(['cut', 'fade', 'crossfade']).optional().describe('Transition to next segment. Default cut.'),
+      presentation: z.object({
+        style: z.enum(['static', 'scroll']).optional(),
+      }).optional().describe('Partial presentation hints (style only). duration/per_card_duration are computed from TTS.'),
+    })).describe('Segments to plan. Each must have narration text and visual info.'),
+    voice_id: z.string().optional().describe('TTS voice ID. Omit to use workspace default.'),
+    workspace_id: z.string().optional().describe('Target workspace. Defaults to current workspace context.'),
+  },
+  async (args) => runPlanVideoSegmentsTool({ ...args, currentWorkspaceId, api })
+);
+
 // ── compose_video_v2 ───────────────────────────────────────────────────────────
 server.tool('compose_video_v2',
-  'Compose a video from a list of segments using ffmpeg. Each segment has a visual source (image/scroll/carousel/video/gif) and optional audio. Segments are concatenated in order; an outro clip is appended at the end. Returns a local mp4 path.',
+  'Compose a video from a list of segments using ffmpeg. Each segment has a visual source (image/scroll/carousel/video/gif), optional audio, and optional subtitle text. Subtitles are burned into the video by default when subtitle_text is provided. Segments are concatenated in order; outro clips are appended at the end. Returns a local mp4 path.\n\nTypical flow: plan_video_segments → compose_video_v2 (segments output fed directly in).',
   {
     segments: z.array(z.object({
       visual_path: z.string().optional().describe('Absolute path to a single image, video, or gif file.'),
       visual_paths: z.array(z.string()).optional().describe('For carousel: array of image paths, one per card.'),
-      visual_kind: z.enum(['image', 'video', 'gif', 'carousel']).describe('Type of visual. image: static image frame. video: video clip. gif: animated GIF. carousel: sequence of images (use visual_paths).'),
+      visual_kind: z.enum(['image', 'video', 'gif', 'carousel']).describe('Type of visual.'),
       presentation: z.object({
-        style: z.enum(['static', 'scroll']).optional().describe('For image: static (default) or scroll (pan upward). Ignored for video/gif/carousel.'),
-        duration: z.number().optional().describe('Segment duration in seconds. Required for image/scroll. For gif, omit to use natural GIF duration.'),
+        style: z.enum(['static', 'scroll']).optional().describe('For image: static (default) or scroll (pan upward).'),
+        duration: z.number().optional().describe('Segment duration in seconds. Required for image/scroll.'),
         per_card_duration: z.number().optional().describe('Seconds per card for carousel.'),
       }).optional(),
-      audio_path: z.string().nullable().optional().describe('Absolute path to an audio file (mp3) for this segment. null or omit for silence.'),
+      audio_path: z.string().nullable().optional().describe('Absolute path to audio (mp3). null or omit for silence.'),
+      subtitle_text: z.string().optional().describe('Narration text to burn as subtitle for this segment. Displayed for the full segment duration.'),
       transition: z.enum(['cut', 'fade', 'crossfade']).optional().describe('Transition to next segment. Default cut.'),
     })).describe('Ordered list of video segments.'),
     outro_paths: z.array(z.string()).optional().describe('Absolute paths to outro video clips appended after all segments.'),
-    format: z.string().optional().describe('Aspect ratio. Default "9:16".'),
     resolution: z.string().optional().describe('Output resolution WxH. Default "1080x1920".'),
     output_path: z.string().optional().describe('Absolute output path for the mp4. Auto-generated if omitted.'),
   },
@@ -1595,10 +1616,10 @@ server.tool('execute_approved_action',
 
 // ── promote_context ───────────────────────────────────────────────────────────
 server.tool('promote_context',
-  'Submit a workspace-level knowledge candidate for human review. Use this after finishing a task when you discover a stable fact, convention, or learning that future agents in this workspace should know. The candidate appears in the workspace owner\'s "My Context → Pending Proposals" panel; once a human (or the workspace Orchestrator) confirms it, it is auto-injected into every future agent\'s system prompt under "## Workspace context". This is the only sanctioned path for sharing workspace-level knowledge — do NOT write a "knowledge index" file via write_workspace.',
+  'Submit a candidate for human review to add to the workspace\'s persistent context. Use this (1) after finishing a task when you discover a stable fact, convention, or learning future agents should know, or (2) immediately after responding to a user message when the user expressed a persistent operational preference (e.g. "always add links", "use subtitles by default"). The candidate appears in the workspace owner\'s "My Context → Pending Proposals" panel; once confirmed, it is auto-injected into every future agent\'s system prompt under "## Workspace context". This is the only sanctioned path for shared knowledge or preference governance.',
   {
     workspace_id: z.string().optional().describe('Target workspace id. Defaults to your current workspace if omitted.'),
-    type: z.enum(['knowledge', 'workspace_norm', 'memory']).optional().describe('Candidate type. Default "knowledge" — use "workspace_norm" for standing rules, "memory" for durable facts.'),
+    type: z.enum(['knowledge', 'workspace_norm', 'memory', 'preference']).optional().describe('Candidate type: "knowledge" for facts/learnings, "workspace_norm" for standing rules, "memory" for durable facts, "preference" for persistent user preferences expressed in conversation.'),
     summary: z.string().describe('One-line title that reviewers will see in the Pending Proposals list.'),
     content: z.string().describe('Full candidate text that future agents will read. Be concrete, citable, and self-contained.'),
     source_message_id: z.string().optional().describe('Optional message id that motivated this candidate, for audit trail.'),
@@ -1627,11 +1648,12 @@ server.tool('promote_context',
         reason,
       });
       const proposal = data?.proposal ?? {};
+      const resolvedType = type ?? 'knowledge';
       return {
         content: [{
           type: 'text',
           text:
-            `Knowledge candidate submitted.\n` +
+            `${resolvedType === 'preference' ? 'Preference' : 'Knowledge'} candidate submitted.\n` +
             `proposal_id=${proposal.id ?? 'unknown'} workspace=${proposal.workspaceId ?? targetWorkspaceId} status=${proposal.status ?? 'candidate'}\n` +
             `It is now visible in the workspace owner's "My Context → Pending Proposals" panel; once confirmed, it will be injected into every future agent's "## Workspace context".`,
         }],

package/src/drivers/claude.js

@@ -238,7 +238,7 @@ The active workspace context (Goal State, constraints, decisions, knowledge) is
 
 **Write rule:**
 - Personal learnings → \`${t("write_memory")}\`
-- Workspace-level knowledge worth sharing across all future agents → \`${t("promote_context")}\` (submits a knowledge candidate; see below). Do **not** dump shared knowledge into ad-hoc files inside the workspace shared workspace.
+- Workspace-level knowledge or persistent user preferences → \`${t("promote_context")}\` (see below). Do **not** dump shared knowledge into ad-hoc files inside the workspace shared workspace.
 - **Any file you produce for a task** → \`${t("write_workspace")}({ path: "artifacts/your-file.ext", ... })\` or \`${t("write_workspace_file")}({ file_path, path: "artifacts/your-file.ext" })\`
 
 Temporary local files belong under \`tmp/\` in your personal workspace. If you need to show an image in chat, first save the durable copy to \`artifacts/\`, then optionally call \`${t("upload_image")}\` for a temporary public preview URL.
@@ -258,8 +258,8 @@ Example: writing a web page → \`${t("write_workspace")}({ path: "artifacts/job
 - \`${t("write_workspace_file")}({ file_path, path })\` — write a local file from your workspace to a workspace artifact without putting base64 in context
 - \`${t("list_workspace")}()\` — list all files in the workspace
 
-**Workspace knowledge governance:**
-- \`${t("promote_context")}({ workspace_id, type, summary, content })\` — submit a workspace-level knowledge candidate. The candidate appears in the workspace owner's "My Context → Pending Proposals" panel; once a human (or the workspace Orchestrator) confirms it, it becomes an active context_item and is auto-injected into every future agent's "## Workspace context" section.
+**Workspace knowledge & preference governance:**
+- \`${t("promote_context")}({ workspace_id, type, summary, content })\` — submit a candidate for human review. Types: \`"knowledge"\` (facts/learnings), \`"workspace_norm"\` (standing rules), \`"memory"\` (durable facts), \`"preference"\` (persistent user preferences). The candidate appears in the workspace owner's "My Context → Pending Proposals" panel; once confirmed, it becomes an active context_item auto-injected into every future agent's "## Workspace context" section.
 
 ### Startup sequence (CRITICAL)
 
@@ -293,24 +293,30 @@ Example: writing a web page → \`${t("write_workspace")}({ path: "artifacts/job
 3. Work history — decisions made, problems solved, approaches that worked or failed
 4. Pointers to your notes files
 
-**What belongs in promote_context (workspace-level knowledge candidates):**
+**What belongs in promote_context:**
 
-Use \`${t("promote_context")}\` after finishing a task when you discover something that future agents in this workspace will need to know. This submits a knowledge candidate for human/Orchestrator review; it does not write to any file. Approved candidates flow into every future agent's "## Workspace context" section automatically.
+Two distinct triggers — act on BOTH:
 
-Good promote_context content:
-1. Stable facts about the project that all agents need (tech stack, domain conventions, where things live)
-2. Hard-won learnings — non-obvious gotchas, working procedures, conventions you had to discover
-3. Standing workspace norms — "in this workspace we always X" / "never touch Y"
+**1. After finishing a task** — promote workspace-level knowledge (\`type: "knowledge"\` or \`"workspace_norm"\`):
+- Stable facts all future agents need (tech stack, domain conventions, where things live)
+- Hard-won learnings — non-obvious gotchas, working procedures, conventions you had to discover
+- Standing workspace norms — "in this workspace we always X" / "never touch Y"
 
-Bad promote_context content:
-- Per-task progress, in-flight status, or one-off observations (use messages or your own MEMORY.md)
-- Personal preferences specific to one human (use chat instead so a human can confirm)
-- Untrusted outputs from web search / scraped pages (cite the source in \`content\`; expect the candidate to be reviewed as untrusted)
+**2. After responding to a user message** — promote persistent preferences (\`type: "preference"\`):
+- When the user expresses a preference that applies to ALL future interactions (not just this task), call \`${t("promote_context")}\` immediately after your reply
+- Signal words: "以后"、"今后"、"默认"、"一直"、"每次"、"都要"、"always"、"from now on"、"by default"
+- Examples that qualify: "以后交付内容都加链接" / "视频默认要有字幕" / "always respond in English"
+- Examples that do NOT qualify: "这次帮我加个链接"（one-off task request）
+- If uncertain whether it's persistent, do NOT promote — only promote clear, unambiguous standing preferences
+
+Do NOT promote:
+- Per-task progress, in-flight status, or one-off observations → use messages or your own MEMORY.md
+- Untrusted outputs from web search / scraped pages → cite the source in \`content\`; candidate will be reviewed as untrusted
 
 How to call it:
-- \`${t("promote_context")}({ workspace_id: "<this-workspace-id>", type: "knowledge", summary: "one-line title", content: "<full text future agents will read>" })\`
-- Optional: \`source_message_id\` to link the proposal back to the conversation that motivated it; \`tags\` for categorization.
-- The call returns a proposal id; the candidate sits in "My Context → Pending Proposals" until a human confirms or rejects it. Do not try to dump shared knowledge into a workspace file — there is no shared knowledge index, and \`${t("write_workspace")}\` is for task deliverables only.
+- Knowledge: \`${t("promote_context")}({ workspace_id: "<id>", type: "knowledge", summary: "one-line title", content: "<full text>" })\`
+- Preference: \`${t("promote_context")}({ workspace_id: "<id>", type: "preference", summary: "User preference: always add links to deliverables", content: "The user has requested that all future deliverables include clickable links. Apply to every response going forward.", source_message_id: "<msg-id>" })\`
+- The call returns a proposal id; the candidate sits in "My Context → Pending Proposals" until a human confirms or rejects it.
 
 ### Compaction safety
 

package/src/tools/plan-video-segments.js

@@ -0,0 +1,115 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { randomUUID } from 'crypto';
+import path from 'path';
+import os from 'os';
+
+function toolText(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function toolError(text) {
+  return { isError: true, content: [{ type: 'text', text }] };
+}
+
+function inferAudioExt(url) {
+  const clean = String(url ?? '').split('?')[0];
+  const ext = path.extname(clean).toLowerCase();
+  return ['.mp3', '.wav', '.flac', '.aac', '.ogg'].includes(ext) ? ext : '.mp3';
+}
+
+async function synthesizeSegmentTts(text, { workspace_id, voice_id, api }) {
+  const payload = { workspace_id, text, speed: 1, format: 'mp3' };
+  if (voice_id) payload.voice_preset = String(voice_id).trim();
+
+  const data = await api('POST', '/tts/voiceover', payload);
+  const remoteAudioUrl = String(data.audio_url ?? '').trim();
+  if (!remoteAudioUrl) throw new Error('TTS API did not return audio_url');
+
+  const downloadRes = await fetch(remoteAudioUrl);
+  if (!downloadRes.ok) throw new Error(`Failed to download audio (${downloadRes.status})`);
+
+  const fileBuffer = Buffer.from(await downloadRes.arrayBuffer());
+  const outDir = path.join(os.tmpdir(), 'lightcone-tts');
+  mkdirSync(outDir, { recursive: true });
+  const ext = inferAudioExt(remoteAudioUrl);
+  const outPath = path.join(outDir, `tts-${Date.now()}-${randomUUID().slice(0, 8)}${ext}`);
+  writeFileSync(outPath, fileBuffer);
+
+  const durationMs = Number(data.duration_ms ?? 0);
+  return { audio_path: outPath, audio_duration_ms: durationMs };
+}
+
+// Compute segment duration from audio duration: audio + 0.5s buffer, rounded up to nearest 0.5s.
+function planDurationSec(audioDurationMs, bufferSec = 0.5) {
+  const raw = audioDurationMs / 1000 + bufferSec;
+  return Math.ceil(raw * 2) / 2; // round up to nearest 0.5s
+}
+
+export async function runPlanVideoSegmentsTool({ segments, workspace_id, voice_id, currentWorkspaceId, api }) {
+  if (!Array.isArray(segments) || segments.length === 0) {
+    return toolError('segments must be a non-empty array.');
+  }
+
+  const targetWorkspaceId = String(workspace_id ?? currentWorkspaceId ?? '').trim();
+  if (!targetWorkspaceId) {
+    return toolError('workspace_id is required (no current workspace context).');
+  }
+
+  const planned = [];
+  const errors = [];
+
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const text = String(seg.text ?? '').trim();
+    const kind = String(seg.visual_kind ?? 'image');
+
+    let audioResult = null;
+    if (text) {
+      try {
+        audioResult = await synthesizeSegmentTts(text, { workspace_id: targetWorkspaceId, voice_id, api });
+      } catch (err) {
+        errors.push(`segments[${i}]: TTS failed — ${err.message}`);
+        audioResult = { audio_path: null, audio_duration_ms: 3000 }; // fallback estimate
+      }
+    }
+
+    const audioDurationMs = audioResult?.audio_duration_ms ?? 0;
+    let presentation;
+
+    if (kind === 'carousel') {
+      const numCards = Array.isArray(seg.visual_paths) ? seg.visual_paths.length : 1;
+      const totalDuration = audioDurationMs > 0 ? planDurationSec(audioDurationMs) : numCards * 4;
+      const perCard = Math.max(2, Math.ceil((totalDuration / numCards) * 2) / 2);
+      presentation = { per_card_duration: perCard };
+    } else {
+      // image, scroll, video, gif
+      const duration = audioDurationMs > 0 ? planDurationSec(audioDurationMs, kind === 'scroll' ? 1.0 : 0.5) : 4;
+      presentation = { duration, ...(kind === 'scroll' ? { style: 'scroll' } : {}) };
+    }
+
+    const planned_seg = {
+      ...seg,
+      ...(audioResult?.audio_path ? { audio_path: audioResult.audio_path } : {}),
+      ...(text ? { subtitle_text: text } : {}),
+      presentation: { ...presentation, ...(seg.presentation ?? {}) },
+    };
+    if (audioResult?.audio_duration_ms) {
+      planned_seg.audio_duration_ms = audioResult.audio_duration_ms;
+    }
+    planned.push(planned_seg);
+  }
+
+  const result = {
+    segments: planned,
+    total_segments: planned.length,
+    total_duration_ms: planned.reduce((sum, s) => {
+      const d = s.presentation?.per_card_duration
+        ? s.presentation.per_card_duration * (Array.isArray(s.visual_paths) ? s.visual_paths.length : 1)
+        : (s.presentation?.duration ?? 4);
+      return sum + Math.round(d * 1000);
+    }, 0),
+    ...(errors.length > 0 ? { warnings: errors } : {}),
+  };
+
+  return toolText(JSON.stringify(result, null, 2));
+}

package/src/_vendor/video/composer/index.js

@@ -1,440 +0,0 @@
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { access, mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
-import { constants as fsConstants } from 'node:fs';
-import os from 'node:os';
-
-const SUBTITLE_FONT = 'WenQuanYi Micro Hei';
-const SUBTITLE_FONT_SIZE = 72;
-const SUBTITLE_MARGIN_V = 80;
-
-const MAX_STDERR_LENGTH = 4000;
-
-const TRANSCODE_TARGETS = Object.freeze({
-  short_video_cn: {
-    width: 1080,
-    height: 1920,
-    fps: 30,
-    videoCodec: 'libx264',
-    profile: 'baseline',
-    pixelFormat: 'yuv420p',
-    crf: 23,
-    preset: 'veryfast',
-    level: '4.0',
-    audioCodec: 'aac',
-    audioBitrate: '128k',
-    audioSampleRate: 48000,
-    audioChannels: 2,
-  },
-});
-
-function normalizeText(value) {
-  if (typeof value !== 'string') return '';
-  return value.trim();
-}
-
-function normalizePath(value, label) {
-  const raw = normalizeText(value);
-  if (!raw) throw new Error(`${label} required`);
-  return path.resolve(raw);
-}
-
-async function ensureReadableFile(filePath, label) {
-  try {
-    await access(filePath, fsConstants.R_OK);
-  } catch {
-    throw new Error(`${label} not found or unreadable: ${filePath}`);
-  }
-
-  const st = await stat(filePath);
-  if (!st.isFile()) throw new Error(`${label} is not a file: ${filePath}`);
-}
-
-async function ensureParentDir(filePath) {
-  await mkdir(path.dirname(filePath), { recursive: true });
-}
-
-function sanitizeStderr(stderr) {
-  const text = String(stderr ?? '').trim();
-  if (!text) return '';
-  if (text.length <= MAX_STDERR_LENGTH) return text;
-  return text.slice(text.length - MAX_STDERR_LENGTH);
-}
-
-function toolError(prefix, error, stderr = '') {
-  const details = [];
-  const message = normalizeText(error?.message);
-  if (message) details.push(message);
-  const cleanedStderr = sanitizeStderr(stderr);
-  if (cleanedStderr) details.push(cleanedStderr);
-  const suffix = details.length > 0 ? `: ${details.join(' | ')}` : '';
-  return new Error(`${prefix}${suffix}`);
-}
-
-function runProcess(binary, args, { name = binary } = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(binary, args, { stdio: ['ignore', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on('data', (chunk) => {
-      stderr += chunk.toString();
-    });
-
-    child.on('error', (error) => {
-      reject(toolError(`${name} failed`, error, stderr));
-    });
-
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve({ stdout, stderr });
-        return;
-      }
-      reject(toolError(`${name} exited with code ${code}`, null, stderr));
-    });
-  });
-}
-
-function normalizeStartMs(value) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed < 0) return null;
-  return Math.floor(parsed);
-}
-
-function resolveStartMsFromEvents(segment, eventsLog = []) {
-  const phase = normalizeText(segment?.phase ?? segment?.phase_id ?? segment?.phaseId);
-  if (!phase) return null;
-
-  let candidate = null;
-  for (const event of eventsLog) {
-    const eventPhase = normalizeText(event?.phase ?? event?.phase_id ?? event?.phaseId);
-    if (!eventPhase || eventPhase !== phase) continue;
-
-    const eventStart = normalizeStartMs(
-      event?.t_ms_start
-      ?? event?.tMsStart
-      ?? event?.t_ms
-      ?? event?.tMs
-    );
-    if (eventStart == null) continue;
-    if (candidate == null || eventStart < candidate) candidate = eventStart;
-  }
-
-  return candidate;
-}
-
-function normalizeAudioSegments(audioSegments = [], eventsLog = []) {
-  if (!Array.isArray(audioSegments)) {
-    throw new Error('audio_segments must be an array');
-  }
-
-  return audioSegments.map((segment, index) => {
-    if (!segment || typeof segment !== 'object' || Array.isArray(segment)) {
-      throw new Error(`audio_segments[${index}] must be an object`);
-    }
-
-    const audioPath = normalizePath(segment.audio_path ?? segment.audioPath, `audio_segments[${index}].audio_path`);
-    const startMs = normalizeStartMs(segment.start_ms ?? segment.startMs)
-      ?? resolveStartMsFromEvents(segment, eventsLog);
-    if (startMs == null) {
-      throw new Error(`audio_segments[${index}].start_ms missing (and no matching events_log entry found)`);
-    }
-
-    return {
-      audioPath,
-      startMs,
-    };
-  });
-}
-
-function defaultOutputPath(inputPath, suffix) {
-  const ext = path.extname(inputPath) || '.mp4';
-  const base = path.basename(inputPath, ext);
-  return path.join(path.dirname(inputPath), `${base}.${suffix}${ext}`);
-}
-
-function escapeConcatPath(filePath) {
-  return filePath.replace(/'/g, `'\\''`);
-}
-
-export async function muxAudioToVideo({
-  video_path,
-  audio_segments = [],
-  events_log = [],
-  output = null,
-} = {}) {
-  const videoPath = normalizePath(video_path, 'video_path');
-  await ensureReadableFile(videoPath, 'video_path');
-
-  const segments = normalizeAudioSegments(audio_segments, events_log).sort((a, b) => a.startMs - b.startMs);
-  for (const segment of segments) {
-    await ensureReadableFile(segment.audioPath, `audio segment (${segment.audioPath})`);
-  }
-
-  const outputPath = output
-    ? normalizePath(output, 'output')
-    : defaultOutputPath(videoPath, 'muxed');
-  if (outputPath === videoPath) throw new Error('output must not equal video_path');
-  await ensureParentDir(outputPath);
-
-  if (segments.length === 0) {
-    await runProcess('ffmpeg', [
-      '-y',
-      '-i', videoPath,
-      '-map', '0:v:0',
-      '-c:v', 'copy',
-      '-an',
-      outputPath,
-    ], { name: 'ffmpeg mux(no-audio)' });
-    return outputPath;
-  }
-
-  const filterChunks = [];
-  const mixInputs = [];
-  for (let i = 0; i < segments.length; i += 1) {
-    const delay = segments[i].startMs;
-    const label = `a${i}`;
-    filterChunks.push(`[${i + 1}:a]adelay=${delay}|${delay},aresample=async=1:first_pts=0[${label}]`);
-    mixInputs.push(`[${label}]`);
-  }
-  filterChunks.push(`${mixInputs.join('')}amix=inputs=${segments.length}:duration=longest:dropout_transition=0,apad[a]`);
-
-  const args = [
-    '-y',
-    '-i', videoPath,
-  ];
-
-  for (const segment of segments) {
-    args.push('-i', segment.audioPath);
-  }
-
-  args.push(
-    '-filter_complex', filterChunks.join(';'),
-    '-map', '0:v:0',
-    '-map', '[a]',
-    '-c:v', 'copy',
-    '-c:a', 'aac',
-    '-shortest',
-    '-movflags', '+faststart',
-    outputPath
-  );
-
-  await runProcess('ffmpeg', args, { name: 'ffmpeg mux' });
-  return outputPath;
-}
-
-export async function concatVideos({
-  inputs = [],
-  output,
-} = {}) {
-  if (!Array.isArray(inputs) || inputs.length === 0) {
-    throw new Error('inputs must be a non-empty array');
-  }
-
-  const normalizedInputs = inputs.map((input, index) => normalizePath(input, `inputs[${index}]`));
-  for (const inputPath of normalizedInputs) {
-    await ensureReadableFile(inputPath, `concat input (${inputPath})`);
-  }
-
-  const outputPath = output
-    ? normalizePath(output, 'output')
-    : defaultOutputPath(normalizedInputs[0], 'concat');
-  await ensureParentDir(outputPath);
-
-  if (normalizedInputs.length === 1) {
-    await runProcess('ffmpeg', [
-      '-y',
-      '-i', normalizedInputs[0],
-      '-c', 'copy',
-      outputPath,
-    ], { name: 'ffmpeg concat(single-input)' });
-    return outputPath;
-  }
-
-  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'lightcone-concat-'));
-  const listPath = path.join(tempDir, 'inputs.txt');
-
-  try {
-    const content = normalizedInputs
-      .map(inputPath => `file '${escapeConcatPath(inputPath)}'`)
-      .join('\n');
-    await writeFile(listPath, `${content}\n`, 'utf8');
-
-    await runProcess('ffmpeg', [
-      '-y',
-      '-f', 'concat',
-      '-safe', '0',
-      '-i', listPath,
-      '-c', 'copy',
-      '-movflags', '+faststart',
-      outputPath,
-    ], { name: 'ffmpeg concat' });
-  } finally {
-    await rm(tempDir, { recursive: true, force: true }).catch(() => {});
-  }
-
-  return outputPath;
-}
-
-function resolveTranscodeTarget(target) {
-  const normalized = normalizeText(target).toLowerCase();
-  if (!normalized) return TRANSCODE_TARGETS.short_video_cn;
-
-  if (normalized === 'short_video_cn' || normalized === 'douyin' || normalized === 'xhs') {
-    return TRANSCODE_TARGETS.short_video_cn;
-  }
-
-  throw new Error(`unsupported transcode target: ${target}`);
-}
-
-function msToAssTimestamp(ms) {
-  const totalCs = Math.round(Math.max(0, ms) / 10);
-  const cs = totalCs % 100;
-  const totalSec = Math.floor(totalCs / 100);
-  const sec = totalSec % 60;
-  const totalMin = Math.floor(totalSec / 60);
-  const min = totalMin % 60;
-  const hr = Math.floor(totalMin / 60);
-  return `${hr}:${String(min).padStart(2, '0')}:${String(sec).padStart(2, '0')}.${String(cs).padStart(2, '0')}`;
-}
-
-// Hard-wrap CJK subtitle text so it never overflows the video frame.
-// libass WrapStyle:0 doesn't handle Chinese text reliably (no word boundaries),
-// so we insert explicit \N breaks every maxChars characters.
-function wrapSubtitleText(text, maxChars = 14) {
-  const chars = Array.from(String(text ?? ''));
-  if (chars.length <= maxChars) return chars.join('');
-  const lines = [];
-  for (let i = 0; i < chars.length; i += maxChars) {
-    lines.push(chars.slice(i, i + maxChars).join(''));
-  }
-  return lines.join('\\N');
-}
-
-export function buildAssContent(subtitles = [], { playResX = 1080, playResY = 1920 } = {}) {
-  // Max chars per line: (playResX - marginL - marginR) / fontSizePx
-  // 1080 - 30 - 30 = 1020px, fontsize 72 ≈ 72px/char → 14 chars
-  const maxCharsPerLine = Math.floor((playResX - 60) / SUBTITLE_FONT_SIZE);
-
-  const header = [
-    '[Script Info]',
-    'ScriptType: v4.00+',
-    `PlayResX: ${playResX}`,
-    `PlayResY: ${playResY}`,
-    'WrapStyle: 2',
-    '',
-    '[V4+ Styles]',
-    'Format: Name, Fontname, Fontsize, PrimaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding',
-    `Style: Default,${SUBTITLE_FONT},${SUBTITLE_FONT_SIZE},&H00FFFFFF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,4,0,2,30,30,${SUBTITLE_MARGIN_V},1`,
-    '',
-    '[Events]',
-    'Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text',
-  ].join('\n');
-
-  const events = subtitles.map(({ text, start_ms, end_ms }) => {
-    const wrapped = wrapSubtitleText(text, maxCharsPerLine);
-    const safeText = wrapped.replace(/\r?\n/g, '\\N').replace(/,/g, '{\\,}');
-    return `Dialogue: 0,${msToAssTimestamp(start_ms)},${msToAssTimestamp(end_ms)},Default,,0,0,0,,${safeText}`;
-  });
-
-  return `${header}\n${events.join('\n')}\n`;
-}
-
-export async function transcodeForPlatform({
-  input,
-  output,
-  target = 'short_video_cn',
-  subtitlesAssPath = null,
-} = {}) {
-  const inputPath = normalizePath(input, 'input');
-  await ensureReadableFile(inputPath, 'input');
-
-  const outputPath = output
-    ? normalizePath(output, 'output')
-    : defaultOutputPath(inputPath, 'platform');
-  if (outputPath === inputPath) throw new Error('output must not equal input');
-  await ensureParentDir(outputPath);
-
-  const preset = resolveTranscodeTarget(target);
-  const vfParts = [
-    `scale=${preset.width}:${preset.height}:force_original_aspect_ratio=decrease`,
-    `pad=${preset.width}:${preset.height}:(ow-iw)/2:(oh-ih)/2:black`,
-    'setsar=1',
-  ];
-  if (subtitlesAssPath) {
-    const escapedPath = subtitlesAssPath.replace(/\\/g, '/').replace(/:/g, '\\:').replace(/'/g, "\\'");
-    vfParts.push(`subtitles='${escapedPath}'`);
-  }
-  const vf = vfParts.join(',');
-
-  await runProcess('ffmpeg', [
-    '-y',
-    '-i', inputPath,
-    '-vf', vf,
-    '-r', String(preset.fps),
-    '-c:v', preset.videoCodec,
-    '-profile:v', preset.profile,
-    '-level', preset.level,
-    '-pix_fmt', preset.pixelFormat,
-    '-preset', preset.preset,
-    '-crf', String(preset.crf),
-    '-c:a', preset.audioCodec,
-    '-b:a', preset.audioBitrate,
-    '-ar', String(preset.audioSampleRate),
-    '-ac', String(preset.audioChannels),
-    '-movflags', '+faststart',
-    outputPath,
-  ], { name: 'ffmpeg transcode' });
-
-  return outputPath;
-}
-
-export async function probeDurationMs(inputPath) {
-  const resolved = normalizePath(inputPath, 'input');
-  await ensureReadableFile(resolved, 'input');
-
-  const { stdout } = await runProcess('ffprobe', [
-    '-v', 'error',
-    '-show_entries', 'format=duration',
-    '-of', 'default=noprint_wrappers=1:nokey=1',
-    resolved,
-  ], { name: 'ffprobe duration' });
-
-  const seconds = Number.parseFloat(String(stdout ?? '').trim());
-  if (!Number.isFinite(seconds) || seconds <= 0) {
-    throw new Error(`ffprobe returned invalid duration for ${resolved}`);
-  }
-  return Math.floor(seconds * 1000);
-}
-
-export async function readMediaSpec(inputPath) {
-  const resolved = normalizePath(inputPath, 'input');
-  await ensureReadableFile(resolved, 'input');
-
-  const { stdout } = await runProcess('ffprobe', [
-    '-v', 'error',
-    '-select_streams', 'v:0',
-    '-show_entries', 'stream=width,height,r_frame_rate,pix_fmt,codec_name',
-    '-of', 'json',
-    resolved,
-  ], { name: 'ffprobe spec' });
-
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout);
-  } catch {
-    throw new Error(`Failed to parse ffprobe spec output for ${resolved}`);
-  }
-
-  const stream = parsed?.streams?.[0] ?? {};
-  return {
-    width: Number(stream.width) || null,
-    height: Number(stream.height) || null,
-    frame_rate: String(stream.r_frame_rate ?? ''),
-    pixel_format: String(stream.pix_fmt ?? ''),
-    video_codec: String(stream.codec_name ?? ''),
-  };
-}