@lightcone-ai/daemon 0.13.0 → 0.14.1

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

@@ -0,0 +1,377 @@
+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 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}`);
+}
+
+export async function transcodeForPlatform({
+  input,
+  output,
+  target = 'short_video_cn',
+} = {}) {
+  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 vf = [
+    `scale=${preset.width}:${preset.height}:force_original_aspect_ratio=decrease`,
+    `pad=${preset.width}:${preset.height}:(ow-iw)/2:(oh-ih)/2:black`,
+    'setsar=1',
+  ].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 ?? ''),
+  };
+}

package/src/agent-manager.js

@@ -462,7 +462,12 @@ export class AgentManager {
     chatBridgePath,
     config,
     triggerType = 'resume',
+    triggerContext = null,
   }) {
+    const mergedTriggerContext = {
+      source: 'daemon-agent-manager',
+      ...(triggerContext && typeof triggerContext === 'object' ? triggerContext : {}),
+    };
     const res = await fetch(`${this.serverUrl}/governance/spawn-directive`, {
       method: 'POST',
       headers: {
@@ -474,7 +479,7 @@ export class AgentManager {
         workspace_id: workspaceId ?? null,
         trigger: {
           type: triggerType,
-          context: { source: 'daemon-agent-manager' },
+          context: mergedTriggerContext,
         },
         runtime_context: {
           cli_type: runtime,
@@ -535,6 +540,10 @@ export class AgentManager {
         const nextDirective = await this._fetchSpawnDirective({
           ...context,
           triggerType: 'lease_refresh',
+          triggerContext: {
+            spawn_bundle_id: directive?.spawn_bundle_id ?? null,
+            policy_version: directive?.policy_version ?? null,
+          },
         });
         const agent = this.agents.get(key);
         if (!agent) return;