@lightcone-ai/daemon 0.14.0 → 0.14.2

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

@@ -16,6 +16,7 @@ import { injectWorkspaceContext } from './drivers/claude.js';
 import { parseKimiLine, encodeKimiStdin } from './drivers/kimi.js';
 import { startSession, stopSession, stopAllSessions } from './browser-login.js';
 import { markInvalidatedLeases } from './governance-state.js';
+import { runPublishJob } from './publish-job-runner.js';
 
 const KIMI_SYSTEM_PROMPT_FILE = '.lightcone-kimi-system.md';
 const KIMI_AGENT_FILE = '.lightcone-kimi-agent.yaml';
@@ -156,6 +157,7 @@ export class AgentManager {
       case 'agent:start':       return this._startAgent(msg, connection);
       case 'agent:stop':        return this._stopAgent(msg.agentId, msg.workspaceId, connection);
       case 'agent:deliver':     return this._deliverMessage(msg, connection);
+      case 'publish:job':       return this._handlePublishJob(msg, connection);
       case 'browser:start_login': return this._startBrowserLogin(msg, connection);
       case 'browser:stop_login':  return this._stopBrowserLogin(msg);
       case 'policy_invalidate':   return this._handlePolicyInvalidate(msg, connection);
@@ -462,7 +464,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 +481,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 +542,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;
@@ -996,6 +1007,96 @@ export class AgentManager {
     }
   }
 
+  async _postInternalActionComplete({ agentId, actionId, ok, result, error }) {
+    const url = `${this.serverUrl.replace(/\/$/, '')}/internal/agent/${encodeURIComponent(agentId)}/actions/${encodeURIComponent(actionId)}/complete`;
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.machineApiKey}`,
+      },
+      body: JSON.stringify({ ok, result, error }),
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`action complete failed (${res.status}): ${text}`);
+    }
+    return res.json();
+  }
+
+  async _handlePublishJob(msg, connection) {
+    const job = normalizeObject(msg.job);
+    const jobId = String(job.id ?? '').trim();
+    const actionId = String(job.approval_action_id ?? '').trim();
+    const agentId = String(job.agent_id ?? '').trim();
+    const workspaceId = String(job.workspace_id ?? '').trim() || null;
+
+    if (!jobId || !actionId || !agentId) {
+      console.warn('[AgentManager] publish:job missing required fields (id, approval_action_id, agent_id)');
+      return;
+    }
+
+    connection.send({
+      type: 'publish:job_status',
+      job_id: jobId,
+      action_id: actionId,
+      status: 'running',
+      started_at: new Date().toISOString(),
+    });
+
+    try {
+      const workspaceDir = this._workspaceDir(agentId, workspaceId);
+      const publishResult = await runPublishJob({
+        serverUrl: this.serverUrl,
+        machineApiKey: this.machineApiKey,
+        agentId,
+        workspaceDir,
+        job,
+      });
+
+      await this._postInternalActionComplete({
+        agentId,
+        actionId,
+        ok: true,
+        result: publishResult.completionResult,
+        error: null,
+      });
+
+      connection.send({
+        type: 'publish:job_status',
+        job_id: jobId,
+        action_id: actionId,
+        status: 'succeeded',
+        completed_at: new Date().toISOString(),
+        result: publishResult.completionResult,
+      });
+    } catch (err) {
+      const errorMessage = err?.message ?? String(err);
+      try {
+        await this._postInternalActionComplete({
+          agentId,
+          actionId,
+          ok: false,
+          result: null,
+          error: errorMessage,
+        });
+      } catch (completeErr) {
+        console.error(
+          `[AgentManager] Failed to report publish job completion for action=${actionId}: ${completeErr.message}`
+        );
+      }
+
+      connection.send({
+        type: 'publish:job_status',
+        job_id: jobId,
+        action_id: actionId,
+        status: 'failed',
+        completed_at: new Date().toISOString(),
+        error: errorMessage,
+      });
+    }
+  }
+
   _stopAgent(agentId, workspaceId, connection) {
     const key = this._key(agentId, workspaceId);
     const agent = this.agents.get(key);