@lightcone-ai/daemon 0.15.74 → 0.15.76

package/mcp-servers/official/media-tools/index.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+import { addTitleEffects } from './lib/render.js';
+import { SUPPORTED_PRESETS } from './lib/presets.js';
+
+const PRESET_ENUM = z.enum(SUPPORTED_PRESETS);
+const POSITION_ENUM = z.enum(['top', 'center', 'bottom']);
+
+const overlaySchema = z.object({
+  text: z.string().min(1).describe('Title text to overlay. Single line or use \\n for multi-line.'),
+  start_ms: z.number().int().nonnegative().describe('Overlay start time in milliseconds from video start.'),
+  end_ms: z.number().int().positive().describe('Overlay end time in milliseconds. Must be > start_ms.'),
+  preset: PRESET_ENUM.describe(`Animation preset: ${SUPPORTED_PRESETS.join(' | ')}. fade_zoom = fade in + scale-up pop (good for opening titles). karaoke_punch = per-character highlight fill (good for rhythmic, beat-driven titles).`),
+  position: POSITION_ENUM.optional().describe('Vertical position. Default top — leaves the bottom band free for the narration subtitle already burned by compose_video_v2.'),
+  style: z.object({
+    font_size: z.number().int().positive().optional().describe('Override font size in pixels. Default 96 (relative to source resolution).'),
+    color: z.string().optional().describe('Text fill colour as #RRGGBB. Default white.'),
+    outline_color: z.string().optional().describe('Outline colour as #RRGGBB. Default black.'),
+    bold: z.boolean().optional().describe('Bold. Default true.'),
+  }).optional(),
+}).strict();
+
+function toolError(message) {
+  return {
+    isError: true,
+    content: [{ type: 'text', text: `Error: ${message}` }],
+  };
+}
+
+const server = new McpServer({ name: 'official-media-tools', version: '0.1.0' });
+
+server.tool(
+  'add_title_effects',
+  'Burn animated title overlays into the START (or any time range) of an existing mp4. '
+  + 'Takes any video produced by compose_video_v2 / record_url_narration / etc. and adds '
+  + 'one or more on-screen title cards with animation presets (fade+zoom pop, per-character karaoke fill). '
+  + 'The default narration subtitle burned by compose_video_v2 stays at the bottom; titles default to the top band so they do not collide. '
+  + 'Output is a new mp4; original is not modified. Skip this tool entirely when a plain video is desired — not every video needs title effects.',
+  {
+    input_path: z.string().min(1).describe('Absolute path to the source mp4 (e.g. the output of compose_video_v2).'),
+    output_path: z.string().optional().describe('Optional absolute output path. If omitted, writes to a tmp path and returns it.'),
+    overlays: z.array(overlaySchema).min(1).describe('One or more title overlays. For a single opening title use overlays=[{text, start_ms:0, end_ms:2500, preset:"fade_zoom"}].'),
+  },
+  async (input) => {
+    try {
+      const result = await addTitleEffects({
+        inputPath: input.input_path,
+        outputPath: input.output_path,
+        overlays: input.overlays,
+      });
+      const lines = [
+        'add_title_effects completed.',
+        `path=${result.path}`,
+        `overlays=${result.overlays}`,
+      ];
+      return { content: [{ type: 'text', text: lines.join('\n') }] };
+    } catch (error) {
+      return toolError(`add_title_effects failed: ${error.message}`);
+    }
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error('[official-media-tools] MCP Server started');

package/mcp-servers/official/media-tools/lib/presets.js

@@ -0,0 +1,62 @@
+// Animation presets emit ASS inline override tags. Each preset receives the
+// overlay duration (ms) and returns:
+//   { prefix: string, body: (text) => string }
+// where the final Dialogue Text becomes `${prefix}${body(text)}`.
+//
+// Notes on units:
+//   - \fad takes ms
+//   - \t takes ms (since libass interprets \t(t1,t2,...) as ms when used with
+//     time-based override tags)
+//   - \k / \kf take centiseconds (1cs = 10ms)
+
+const SUPPORTED_PRESETS = Object.freeze(['fade_zoom', 'karaoke_punch']);
+
+function fadeZoom() {
+  // Fade in 250ms + fade out 250ms; scale from 100% to 130% over the first
+  // 500ms so the title "pops" before settling. Override tags applied once at
+  // the start of the line.
+  const prefix = '{\\fad(250,250)\\t(0,500,\\fscx130\\fscy130)}';
+  return { prefix, body: text => text };
+}
+
+function karaokePunch(durationMs) {
+  // Per-character karaoke fill: each char briefly highlights to the secondary
+  // colour. Distribute time evenly. Karaoke timings are in centiseconds and
+  // the sum must match the event duration; we round and adjust the last char
+  // so the total is exact (libass tolerates any remainder by clipping).
+  const totalCs = Math.max(1, Math.round(durationMs / 10));
+  // Reserve a small tail (~20cs / 200ms) so the last character finishes its
+  // fill before the event ends rather than mid-stroke.
+  const tailCs = Math.min(20, Math.max(0, totalCs - 1));
+  const animCs = totalCs - tailCs;
+  return {
+    prefix: '',
+    body: text => {
+      const chars = Array.from(String(text ?? ''));
+      if (chars.length === 0) return '';
+      const perChar = Math.max(1, Math.floor(animCs / chars.length));
+      const usedExceptLast = perChar * (chars.length - 1);
+      const lastCs = Math.max(1, animCs - usedExceptLast);
+      return chars.map((ch, i) => {
+        const cs = i === chars.length - 1 ? lastCs : perChar;
+        // Escape ASS comma in case the char itself is a comma (rare but
+        // shifts dialogue fields when unescaped).
+        const safe = ch === ',' ? '{\\,}' : ch;
+        return `{\\kf${cs}}${safe}`;
+      }).join('');
+    },
+  };
+}
+
+export function renderPreset(presetName, { durationMs }) {
+  switch (presetName) {
+    case 'fade_zoom':
+      return fadeZoom();
+    case 'karaoke_punch':
+      return karaokePunch(durationMs);
+    default:
+      throw new Error(`unknown preset: ${presetName}. supported: ${SUPPORTED_PRESETS.join(', ')}`);
+  }
+}
+
+export { SUPPORTED_PRESETS };

package/mcp-servers/official/media-tools/lib/render.js

@@ -0,0 +1,171 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import os from 'node:os';
+import { mkdir, writeFile, access, rm } from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+
+import { renderPreset, SUPPORTED_PRESETS } from './presets.js';
+
+const DEFAULT_FONT = (process.env.SUBTITLE_FONT || 'Noto Sans CJK SC').split(',')[0].trim() || 'Noto Sans CJK SC';
+const POSITION_ALIGNMENTS = Object.freeze({ top: 8, center: 5, bottom: 2 });
+const POSITION_MARGINS = Object.freeze({ top: 200, center: 0, bottom: 200 });
+
+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 runFfmpeg(args, label = 'ffmpeg') {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('ffmpeg', ['-y', ...args], { stdio: ['ignore', 'pipe', 'pipe'] });
+    const stderr = [];
+    proc.stderr.on('data', chunk => stderr.push(chunk));
+    proc.on('close', code => {
+      if (code === 0) return resolve();
+      const msg = Buffer.concat(stderr).toString().slice(-3000);
+      reject(new Error(`${label} exited ${code}:\n${msg}`));
+    });
+    proc.on('error', err => reject(new Error(`${label} spawn failed: ${err.message}`)));
+  });
+}
+
+function probeVideoSize(inputPath) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('ffprobe', [
+      '-v', 'error',
+      '-select_streams', 'v:0',
+      '-show_entries', 'stream=width,height',
+      '-of', 'csv=p=0',
+      inputPath,
+    ], { stdio: ['ignore', 'pipe', 'pipe'] });
+    const out = [];
+    proc.stdout.on('data', c => out.push(c));
+    proc.on('close', code => {
+      if (code !== 0) return reject(new Error(`ffprobe failed on ${inputPath}`));
+      const text = Buffer.concat(out).toString().trim();
+      const [wStr, hStr] = text.split(',');
+      const width = parseInt(wStr, 10);
+      const height = parseInt(hStr, 10);
+      if (!Number.isFinite(width) || !Number.isFinite(height)) {
+        return reject(new Error(`ffprobe returned unexpected size: ${text}`));
+      }
+      resolve({ width, height });
+    });
+    proc.on('error', reject);
+  });
+}
+
+async function fileExists(p) {
+  try { await access(p, fsConstants.R_OK); return true; } catch { return false; }
+}
+
+// Hex color in ASS is &HAABBGGRR (alpha + BGR). Accept input as #RRGGBB or
+// 0xRRGGBB and convert.
+function hexToAssColor(hex, alpha = 0) {
+  const raw = String(hex ?? '').trim().replace(/^#/, '').replace(/^0x/i, '');
+  if (!/^[0-9a-fA-F]{6}$/.test(raw)) return null;
+  const r = raw.slice(0, 2).toUpperCase();
+  const g = raw.slice(2, 4).toUpperCase();
+  const b = raw.slice(4, 6).toUpperCase();
+  const a = String(Math.max(0, Math.min(255, Math.round(alpha))).toString(16).padStart(2, '0')).toUpperCase();
+  return `&H${a}${b}${g}${r}`;
+}
+
+function buildAssContent({ playResX, playResY, overlays }) {
+  const header = [
+    '[Script Info]',
+    'ScriptType: v4.00+',
+    `PlayResX: ${playResX}`,
+    `PlayResY: ${playResY}`,
+    'WrapStyle: 2',
+    '',
+    '[V4+ Styles]',
+    'Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding',
+    // PrimaryColour white, SecondaryColour orange (for karaoke fill), OutlineColour black,
+    // Bold on, Outline 4px, Shadow 2px, default Alignment middle-center (5) — events
+    // override per-line via \an.
+    `Style: Title,${DEFAULT_FONT},96,&H00FFFFFF,&H000066FF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,4,2,5,30,30,0,1`,
+    '',
+    '[Events]',
+    'Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text',
+  ];
+
+  const events = overlays.map((overlay) => {
+    const start = overlay.start_ms;
+    const end = overlay.end_ms;
+    const alignment = POSITION_ALIGNMENTS[overlay.position] ?? POSITION_ALIGNMENTS.top;
+    const marginV = POSITION_MARGINS[overlay.position] ?? POSITION_MARGINS.top;
+
+    const styleOverrides = [`\\an${alignment}`];
+    if (overlay.style?.font_size) styleOverrides.push(`\\fs${overlay.style.font_size}`);
+    if (overlay.style?.color) {
+      const c = hexToAssColor(overlay.style.color);
+      if (c) styleOverrides.push(`\\1c${c}`);
+    }
+    if (overlay.style?.outline_color) {
+      const c = hexToAssColor(overlay.style.outline_color);
+      if (c) styleOverrides.push(`\\3c${c}`);
+    }
+    if (overlay.style?.bold === false) styleOverrides.push('\\b0');
+
+    const preset = renderPreset(overlay.preset, { durationMs: end - start });
+    const base = `{${styleOverrides.join('')}${preset.prefix.replace(/^\{|\}$/g, '')}}`;
+    const text = preset.body(overlay.text).replace(/\r?\n/g, '\\N');
+    return `Dialogue: 0,${msToAssTimestamp(start)},${msToAssTimestamp(end)},Title,,0,0,${marginV},,${base}${text}`;
+  });
+
+  return `${header.join('\n')}\n${events.join('\n')}\n`;
+}
+
+export async function addTitleEffects({ inputPath, outputPath, overlays }) {
+  if (!await fileExists(inputPath)) {
+    throw new Error(`input_path not found or unreadable: ${inputPath}`);
+  }
+  if (!Array.isArray(overlays) || overlays.length === 0) {
+    throw new Error('overlays must be a non-empty array');
+  }
+  for (let i = 0; i < overlays.length; i++) {
+    const o = overlays[i];
+    if (typeof o.text !== 'string' || !o.text.trim()) {
+      throw new Error(`overlays[${i}]: text must be a non-empty string`);
+    }
+    if (!Number.isFinite(o.start_ms) || !Number.isFinite(o.end_ms) || o.end_ms <= o.start_ms) {
+      throw new Error(`overlays[${i}]: start_ms/end_ms must be finite and end_ms > start_ms`);
+    }
+    if (!SUPPORTED_PRESETS.includes(o.preset)) {
+      throw new Error(`overlays[${i}]: preset must be one of ${SUPPORTED_PRESETS.join(', ')}`);
+    }
+  }
+
+  const { width, height } = await probeVideoSize(inputPath);
+
+  const tmpDir = path.join(os.tmpdir(), `media-tools-${randomUUID().slice(0, 8)}`);
+  await mkdir(tmpDir, { recursive: true });
+
+  const outPath = outputPath ?? path.join(os.tmpdir(), `media-tools-${Date.now()}-titled.mp4`);
+  await mkdir(path.dirname(outPath), { recursive: true });
+
+  const assPath = path.join(tmpDir, `title-${randomUUID().slice(0, 8)}.ass`);
+  const assContent = buildAssContent({ playResX: width, playResY: height, overlays });
+  await writeFile(assPath, assContent, 'utf8');
+
+  try {
+    const escapedAssPath = assPath.replace(/\\/g, '/').replace(/:/g, '\\:').replace(/'/g, "\\'");
+    await runFfmpeg([
+      '-i', inputPath,
+      '-vf', `subtitles='${escapedAssPath}'`,
+      '-c:a', 'copy',
+      '-movflags', '+faststart',
+      outPath,
+    ], 'ffmpeg add-title-effects');
+    return { path: outPath, overlays: overlays.length };
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  }
+}

package/mcp-servers/official/media-tools/manifest.json

@@ -0,0 +1,19 @@
+{
+  "id": "media-tools",
+  "name": "Official Media Tools MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "add_title_effects", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "add_title_effects",
+    "arguments": {
+      "input_path": "/tmp/__media_tools_smoke_does_not_exist.mp4",
+      "overlays": [
+        { "text": "标题特效", "start_ms": 0, "end_ms": 2000, "preset": "fade_zoom" }
+      ]
+    }
+  }
+}

package/package.json

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

package/src/chat-bridge.js

@@ -1523,7 +1523,7 @@ server.tool('register_data_source',
 
 // ── list_publish_accounts ─────────────────────────────────────────────────────
 server.tool('list_publish_accounts',
-  'List the platform accounts bound to a workspace and the selectors you can pass as credential_id when publishing via request_approval (the account display name, a role alias like 主号/矩阵号/测试号, or the account UUID). Call this before publishing whenever the workspace might have more than one account on the target platform — do NOT guess account names or ask the user to re-type one you can look up here.',
+  'List the platform accounts bound to a workspace. Each entry returns: account_id (workspace-account UUID), credential_id (REAL credential UUID — use this for credential-keyed tools like check_login_status / request_credential_auth), display_name, account_role, and selectors. The "selectors" list shows extra strings that request_approval will accept as credential_id (display name / role alias 主号·矩阵号·测试号) — for request_approval only; do NOT pass selectors or account_id to credential-keyed tools. Call this before publishing whenever the workspace might have more than one account on the target platform — never guess account names.',
   {
     workspace: z.string().optional().describe('Target #workspace-name. Defaults to the current workspace.'),
     platform: z.string().optional().describe('Optional platform filter, e.g. "xhs", "kuaishou", "douyin", "bilibili".'),
@@ -1544,10 +1544,14 @@ server.tool('list_publish_accounts',
       const text = accounts.map((a) => {
         const name = a.display_name ?? a.account_id ?? 'unknown';
         const role = a.account_role ? ` [${a.account_role}]` : '';
+        const credLine = a.credential_id
+          ? `\n    credential_id (for check_login_status etc.): ${a.credential_id}`
+          : '\n    credential_id: <unbound>';
+        const accLine = `\n    account_id: ${a.account_id ?? '?'}`;
         const sels = Array.isArray(a.selectors) && a.selectors.length
-          ? ` — credential_id can be: ${a.selectors.join(' / ')}`
+          ? `\n    request_approval credential_id can also be: ${a.selectors.join(' / ')}`
           : '';
-        return `- ${a.platform ?? '?'} / ${name}${role}${sels}`;
+        return `- ${a.platform ?? '?'} / ${name}${role}${credLine}${accLine}${sels}`;
       }).join('\n');
       return { content: [{ type: 'text', text }] };
     } catch (err) {

package/src/lifecycle-protocol.js

@@ -1,3 +1,14 @@
+// Convention: when a process catches SIGTERM and calls process.exit(143) /
+// process.exit(130), Node reports `code=143/130, signal=null` instead of
+// `code=null, signal='SIGTERM'`. Treat both forms identically — it's a clean
+// stop (used by AgentManager.restartAgent for skill-binding restarts), NOT a
+// crash. Without this, every skill bind made the UI flash "agent crashed".
+function isTerminationExit(code, signal) {
+  if (signal === 'SIGTERM' || signal === 'SIGINT') return true;
+  if (code === 143 || code === 130) return true;
+  return false;
+}
+
 export function resolveExitOfflineDetail({ code, signal, stopCause }) {
   if (stopCause === 'manual_stop') return '';
   if (stopCause === 'user_cancelled') return '';
@@ -5,7 +16,7 @@ export function resolveExitOfflineDetail({ code, signal, stopCause }) {
   if (stopCause === 'contract_violation') return 'contract_violation:visible_text_without_send_message';
   if (stopCause === 'outbound_rate_limited') return 'outbound_rate_limited';
   if (code === 0) return '';
-  if (signal === 'SIGTERM') return '';
+  if (isTerminationExit(code, signal)) return '';
   if (signal === 'SIGKILL') return 'agent_timeout';
   return 'spawn_session_crashed';
 }
@@ -66,7 +77,7 @@ export function resolveLifecycleExitState({ runtime, code, signal, stopCause })
       reachability: 'reachable',
       availability: 'available',
       runtimeState: 'stopped',
-      reason: signal === 'SIGTERM' ? 'terminated' : 'stopped',
+      reason: isTerminationExit(code, signal) ? 'terminated' : 'stopped',
     };
   }
   return {

package/src/submit-to-library-tool.js

@@ -30,6 +30,21 @@ export async function runSubmitToLibraryTool({
       '/content-library/submit',
       buildSubmitToLibraryBody(args, currentWorkspaceId)
     );
+    // Server returns 2xx + body.error for transient "still processing" cases
+    // (e.g. HTTP 202 + {error: "video is still uploading, retry shortly"} when
+    // the workspace file's object_status is still 'uploading'). The HTTP client
+    // treats any 2xx as success and returns the body verbatim, so we must
+    // surface body.error here — otherwise the agent reads `data.itemId` as
+    // undefined and (because the literal "undefined" looks like proof the
+    // submit silently failed) tends to redo the entire video instead of just
+    // retrying submit_to_library. Fail loudly with the server's message so the
+    // agent retries the right step.
+    if (data && typeof data === 'object' && typeof data.error === 'string' && data.error.trim()) {
+      return toolError(`submit_to_library not ready: ${data.error}. Retry submit_to_library with the same video_path in a few seconds — do NOT re-record or re-compose the video.`);
+    }
+    if (!data || typeof data.itemId !== 'string' || !data.itemId) {
+      return toolError(`submit_to_library returned no itemId. Server response: ${JSON.stringify(data).slice(0, 300)}. Retry submit_to_library with the same video_path — do NOT re-record or re-compose.`);
+    }
     return toolText(
       `Submitted to content library: itemId=${data.itemId}, version=${data.version}, kind=${data.kind ?? 'content_video_draft'}`
     );