@lightcone-ai/daemon 0.15.40 → 0.15.42

package/package.json

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

package/src/chat-bridge.js

@@ -21,6 +21,11 @@ import {
 } from './workspace-file-upload.js';
 import { runRecordUrlNarrationTool } from './record-url-narration-tool.js';
 import { runSubmitToLibraryTool } from './submit-to-library-tool.js';
+import { runRenderTextToImageTool } from './tools/render-text-to-image.js';
+import { runSynthesisTtsTool } from './tools/synthesize-tts.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';
 import { isLeaseInvalidated, clearInvalidatedLease } from './governance-state.js';
 import { classifyLeaseWindow } from './lease-window.js';
 import {
@@ -72,8 +77,11 @@ let currentWorkspaceId = WORKSPACE_ID;
 const VOICEOVER_LOCAL_DIR = path.join(WORKSPACE_DIR, 'artifacts', 'audio');
 const VIDEO_COMPOSE_LOCAL_DIR = path.join(WORKSPACE_DIR, 'artifacts', 'video');
 const DEFAULT_OUTRO_PATH = path.join(homedir(), '.lightcone', 'assets', 'outros', 'default.mp4');
-const CVMAX_WORKSPACE_ID = 'ae63cc9e-feff-4d7e-a62e-a7a7c5fd69d9';
-const CVMAX_EDITOR_IN_CHIEF_AGENT_ID = '91a45fd7-ce5f-4da6-9b27-e34bf7b7c0e2';
+// Temporary: block legacy video pipeline tools for a specific editor_in_chief agent.
+// Set via env so this doesn't need a code change when workspace/agent IDs rotate.
+// Remove entirely once the new atomic tool framework is stable and the legacy pipeline retires.
+const CVMAX_WORKSPACE_ID = process.env.BLOCKED_EDITOR_WORKSPACE_ID ?? '';
+const CVMAX_EDITOR_IN_CHIEF_AGENT_ID = process.env.BLOCKED_EDITOR_AGENT_ID ?? '';
 const CVMAX_EDITOR_BLOCKED_VIDEO_TOOLS = new Set([
   'generate_voiceover',
   'record_url_narration',
@@ -1399,6 +1407,80 @@ server.tool('request_credential_auth',
   }
 );
 
+// ── render_text_to_image ───────────────────────────────────────────────────────
+server.tool('render_text_to_image',
+  'Render text content into image(s) for video synthesis. style=scroll produces a single tall image (for a scrolling video segment); style=carousel produces one image per card (for a slide-show segment). Returns local file paths.',
+  {
+    content: z.union([z.string(), z.array(z.string())]).describe('Text content. For carousel, pass an array of strings — one per card. For scroll, pass a single string (or array joined with line breaks).'),
+    style: z.enum(['scroll', 'carousel']).describe('scroll: one tall image; carousel: one image per card.'),
+    theme: z.enum(['dark', 'light']).optional().describe('Color theme. Default dark.'),
+    width: z.number().optional().describe('Image width in pixels. Default 1080.'),
+    card_height: z.number().optional().describe('Card height in pixels (carousel) or viewport height (scroll baseline). Default 1920.'),
+    font_size: z.number().optional().describe('Base font size in pixels. Default 48.'),
+  },
+  async (args) => runRenderTextToImageTool(args)
+);
+
+// ── synthesize_tts ─────────────────────────────────────────────────────────────
+server.tool('synthesize_tts',
+  'Convert text to speech using the workspace MiniMax TTS credential. Returns a local mp3 file path and duration. Use this to generate narration audio for individual video segments.',
+  {
+    text: z.string().describe('Text to synthesize. Keep under 500 characters per call for reliable results.'),
+    voice_id: z.string().optional().describe('MiniMax voice ID. Omit to use the workspace default voice.'),
+    workspace_id: z.string().optional().describe('Target workspace. Defaults to current workspace context.'),
+  },
+  async (args) => runSynthesisTtsTool({ ...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.',
+  {
+    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).'),
+      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.'),
+        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.'),
+      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.'),
+  },
+  async (args) => runComposeVideoV2Tool({ ...args, workspaceDir: WORKSPACE_DIR })
+);
+
+// ── take_page_screenshot ───────────────────────────────────────────────────────
+server.tool('take_page_screenshot',
+  'Open a URL with a headless browser and capture a screenshot. crop=above_fold captures only the visible viewport (ideal for thumbnail-style frames); crop=full_page captures the entire page height.',
+  {
+    url: z.string().describe('Page URL to screenshot.'),
+    crop: z.enum(['above_fold', 'full_page']).optional().describe('Capture mode. Default above_fold.'),
+    viewport: z.object({
+      width: z.number().optional(),
+      height: z.number().optional(),
+    }).optional().describe('Viewport size. Default 390×844 (mobile).'),
+    wait_for: z.enum(['load', 'networkidle', 'domcontentloaded']).optional().describe('Page load event to wait for before screenshotting. Default networkidle.'),
+  },
+  async (args) => runTakePageScreenshotTool(args)
+);
+
+// ── get_library_file ───────────────────────────────────────────────────────────
+server.tool('get_library_file',
+  'Fetch a file (image, video, gif) from the content library by its ID and return a local absolute path. Use this to retrieve outro clips, emoji images, GIF animations, or any other asset stored in the workspace content library.',
+  {
+    library_id: z.string().describe('Content library item ID.'),
+    workspace_id: z.string().optional().describe('Target workspace. Defaults to current workspace context.'),
+  },
+  async (args) => runGetLibraryFileTool({ ...args, currentWorkspaceId, api, SERVER_URL, MACHINE_API_KEY, workspaceDir: WORKSPACE_DIR })
+);
+
 // ── generate_voiceover ─────────────────────────────────────────────────────────
 server.tool('generate_voiceover',
   'Generate a TTS voiceover using an authorized tts_provider credential and return a local audio file path.',

package/src/drivers/claude.js

@@ -138,7 +138,7 @@ Only top-level workspace / DM messages can become tasks. Messages inside threads
 **Primary-agent dispatch hard rule (fail-closed):**
 - If your role is the workspace primary agent/owner and a user sends an execution request, you MUST call \`${t("create_tasks")}\` first and include an explicit \`scenario_type\`, then immediately send a visible acknowledgment/update via \`${t("send_message")}\`.
 - Execution requests include requests like content writing, short-video scripting, research, design/asset production, implementation, or any request that requires downstream execution instead of a simple answer.
-- Use \`scenario_type\` values declared by your scenario manifest/dispatch protocol (for example: \`trend_scan\`, \`topic_research\`, \`research\`, \`graphic_writing\`, \`short_video_scripting\`, \`publish\`).
+- Use \`scenario_type\` values declared by your scenario manifest/dispatch protocol (for example: \`trend_scan\`, \`topic_scan\`, \`research\`, \`text_writing\`, \`video_scripting\`, \`publish\`).
 - Do not route execution work with only \`${t("send_message")}\`: skipping \`${t("create_tasks")}\` can cause downstream \`${t("claim_tasks")}\` failures and deadlock the workflow.
 - If the request is a direct Q&A (no downstream execution dispatch needed), reply directly with \`${t("send_message")}\` and do not force \`${t("create_tasks")}\`.
 

package/src/tools/compose-video-v2.js

@@ -0,0 +1,59 @@
+import path from 'path';
+import os from 'os';
+import { randomUUID } from 'crypto';
+import { composeVideoV2 } from '../../../src/video/composer-v2/index.js';
+
+function toolText(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function toolError(text) {
+  return { isError: true, content: [{ type: 'text', text }] };
+}
+
+export async function runComposeVideoV2Tool({ segments, outro_paths, format, resolution, output_path, workspaceDir }) {
+  if (!Array.isArray(segments) || segments.length === 0) {
+    return toolError('segments must be a non-empty array.');
+  }
+
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const kind = seg.visual_kind;
+    if (!kind) return toolError(`segments[${i}]: visual_kind is required.`);
+    const validKinds = ['image', 'video', 'gif', 'carousel'];
+    if (!validKinds.includes(kind)) {
+      return toolError(`segments[${i}]: visual_kind must be one of ${validKinds.join(', ')}.`);
+    }
+    if (kind === 'carousel' && (!Array.isArray(seg.visual_paths) || seg.visual_paths.length === 0)) {
+      return toolError(`segments[${i}]: visual_paths (array) required for kind=carousel.`);
+    }
+    if (kind !== 'carousel' && !seg.visual_path) {
+      return toolError(`segments[${i}]: visual_path required for kind=${kind}.`);
+    }
+  }
+
+  const outDir = workspaceDir
+    ? path.join(workspaceDir, 'artifacts', 'video')
+    : path.join(os.tmpdir(), 'lightcone-video');
+
+  const outPath = output_path ?? path.join(outDir, `composed-${Date.now()}-${randomUUID().slice(0, 8)}.mp4`);
+
+  try {
+    const result = await composeVideoV2({
+      segments,
+      outro_paths: outro_paths ?? [],
+      resolution: resolution ?? '1080x1920',
+      output_path: outPath,
+    });
+
+    return toolText([
+      'compose_video_v2 completed.',
+      `path=${result.path}`,
+      `duration_ms=${result.duration_ms}`,
+      `segments=${segments.length}`,
+      `outro_clips=${(outro_paths ?? []).length}`,
+    ].join('\n'));
+  } catch (error) {
+    return toolError(`compose_video_v2 failed: ${error.message}`);
+  }
+}

package/src/tools/get-library-file.js

@@ -0,0 +1,77 @@
+import path from 'path';
+import os from 'os';
+import { mkdirSync, writeFileSync, existsSync } from 'fs';
+import { randomUUID } from 'crypto';
+
+function toolText(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function toolError(text) {
+  return { isError: true, content: [{ type: 'text', text }] };
+}
+
+function guessExtension(mediaType, url = '') {
+  const mt = String(mediaType ?? '').toLowerCase();
+  if (mt.includes('mp4') || mt.includes('video')) return '.mp4';
+  if (mt.includes('gif')) return '.gif';
+  if (mt.includes('png')) return '.png';
+  if (mt.includes('jpeg') || mt.includes('jpg')) return '.jpg';
+  if (mt.includes('webp')) return '.webp';
+  const fromUrl = path.extname(String(url ?? '').split('?')[0]).toLowerCase();
+  return fromUrl || '.bin';
+}
+
+export async function runGetLibraryFileTool({ library_id, workspace_id, currentWorkspaceId, api, SERVER_URL, MACHINE_API_KEY }) {
+  const itemId = String(library_id ?? '').trim();
+  if (!itemId) return toolError('library_id is required for get_library_file.');
+
+  let data;
+  try {
+    data = await api('GET', `/content-library/file?id=${encodeURIComponent(itemId)}`);
+  } catch (error) {
+    return toolError(`get_library_file lookup failed: ${error.message}`);
+  }
+
+  // Server already resolved to a local file path (video stored on same machine)
+  if (data.path && typeof data.path === 'string') {
+    if (!existsSync(data.path)) {
+      return toolError(`File not found at resolved path: ${data.path}`);
+    }
+    return toolText([
+      'get_library_file completed.',
+      `path=${data.path}`,
+      `media_type=${data.media_type ?? 'unknown'}`,
+      `item_id=${data.item_id ?? itemId}`,
+    ].join('\n'));
+  }
+
+  // Server returned a download URL (image/GIF stored remotely or as URL)
+  if (data.download_url && typeof data.download_url === 'string') {
+    const downloadUrl = data.download_url.startsWith('http')
+      ? data.download_url
+      : `${SERVER_URL}${data.download_url}`;
+
+    const res = await fetch(downloadUrl, {
+      headers: { 'Authorization': `Bearer ${MACHINE_API_KEY}` },
+    });
+    if (!res.ok) {
+      return toolError(`Failed to download library file (${res.status}): ${downloadUrl}`);
+    }
+
+    const ext = guessExtension(data.media_type, downloadUrl);
+    const outDir = path.join(os.tmpdir(), 'lightcone-library');
+    mkdirSync(outDir, { recursive: true });
+    const outPath = path.join(outDir, `lib-${Date.now()}-${randomUUID().slice(0, 8)}${ext}`);
+    writeFileSync(outPath, Buffer.from(await res.arrayBuffer()));
+
+    return toolText([
+      'get_library_file completed.',
+      `path=${outPath}`,
+      `media_type=${data.media_type ?? 'unknown'}`,
+      `item_id=${data.item_id ?? itemId}`,
+    ].join('\n'));
+  }
+
+  return toolError(`get_library_file: server returned unexpected response for item ${itemId}.`);
+}

package/src/tools/render-text-to-image.js

@@ -0,0 +1,56 @@
+import { renderTextToImages } from '../../../src/video/text-renderer/index.js';
+
+function toolText(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function toolError(text) {
+  return { isError: true, content: [{ type: 'text', text }] };
+}
+
+export async function runRenderTextToImageTool({ content, style, theme, width, card_height, font_size }) {
+  const normalizedStyle = String(style ?? 'scroll');
+  if (normalizedStyle !== 'scroll' && normalizedStyle !== 'carousel') {
+    return toolError(`Invalid style "${normalizedStyle}". Must be "scroll" or "carousel".`);
+  }
+
+  const normalizedTheme = String(theme ?? 'dark');
+  if (normalizedTheme !== 'dark' && normalizedTheme !== 'light') {
+    return toolError(`Invalid theme "${normalizedTheme}". Must be "dark" or "light".`);
+  }
+
+  const normalizedContent = Array.isArray(content)
+    ? content.map(item => String(item ?? '').trim()).filter(Boolean)
+    : [String(content ?? '').trim()].filter(Boolean);
+
+  if (normalizedContent.length === 0) {
+    return toolError('content is required and must not be empty.');
+  }
+
+  if (normalizedStyle === 'carousel' && !Array.isArray(content)) {
+    return toolError('carousel style requires content to be an array of strings (one per card).');
+  }
+
+  const input = normalizedStyle === 'scroll' ? normalizedContent.join('\n\n') : normalizedContent;
+
+  try {
+    const paths = await renderTextToImages({
+      content: input,
+      style: normalizedStyle,
+      theme: normalizedTheme,
+      width: Number(width ?? 1080),
+      cardHeight: Number(card_height ?? 1920),
+      fontSize: Number(font_size ?? 48),
+    });
+
+    const lines = [
+      `render_text_to_image completed.`,
+      `style=${normalizedStyle}`,
+      `paths=${JSON.stringify(paths)}`,
+      `count=${paths.length}`,
+    ];
+    return toolText(lines.join('\n'));
+  } catch (error) {
+    return toolError(`render_text_to_image failed: ${error.message}`);
+  }
+}

package/src/tools/synthesize-tts.js

@@ -0,0 +1,69 @@
+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';
+}
+
+export async function runSynthesisTtsTool({ text, voice_id, workspace_id, currentWorkspaceId, api }) {
+  const normalizedText = String(text ?? '').trim();
+  if (!normalizedText) {
+    return toolError('text is required for synthesize_tts.');
+  }
+
+  const targetWorkspaceId = String(workspace_id ?? currentWorkspaceId ?? '').trim();
+  if (!targetWorkspaceId) {
+    return toolError('workspace_id is required (no current workspace context).');
+  }
+
+  const payload = {
+    workspace_id: targetWorkspaceId,
+    text: normalizedText,
+    speed: 1,
+    format: 'mp3',
+  };
+  if (voice_id) payload.voice_preset = String(voice_id).trim();
+
+  let data;
+  try {
+    data = await api('POST', '/tts/voiceover', payload);
+  } catch (error) {
+    return toolError(`synthesize_tts API error: ${error.message}`);
+  }
+
+  const remoteAudioUrl = String(data.audio_url ?? '').trim();
+  if (!remoteAudioUrl) {
+    return toolError('TTS API did not return audio_url.');
+  }
+
+  const downloadRes = await fetch(remoteAudioUrl);
+  if (!downloadRes.ok) {
+    return toolError(`Failed to download synthesized 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);
+
+  return toolText([
+    'synthesize_tts completed.',
+    `path=${outPath}`,
+    `duration_ms=${data.duration_ms ?? 'unknown'}`,
+    `size_bytes=${fileBuffer.length}`,
+  ].join('\n'));
+}

package/src/tools/take-page-screenshot.js

@@ -0,0 +1,74 @@
+import path from 'path';
+import os from 'os';
+import { mkdirSync } from 'fs';
+import { randomUUID } from 'crypto';
+
+function toolText(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function toolError(text) {
+  return { isError: true, content: [{ type: 'text', text }] };
+}
+
+export async function runTakePageScreenshotTool({ url, crop, viewport, wait_for }) {
+  const normalizedUrl = String(url ?? '').trim();
+  if (!normalizedUrl) return toolError('url is required for take_page_screenshot.');
+
+  const cropMode = String(crop ?? 'above_fold');
+  if (cropMode !== 'above_fold' && cropMode !== 'full_page') {
+    return toolError('crop must be "above_fold" or "full_page".');
+  }
+
+  const vp = {
+    width: Number(viewport?.width ?? 390),
+    height: Number(viewport?.height ?? 844),
+  };
+  const waitFor = String(wait_for ?? 'networkidle');
+
+  let playwright;
+  try {
+    playwright = await import('playwright');
+  } catch {
+    return toolError('playwright_import_failed: playwright is not installed.');
+  }
+
+  const browser = await playwright.chromium.launch({ headless: true });
+  try {
+    const context = await browser.newContext({
+      viewport: vp,
+      userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+      deviceScaleFactor: 2,
+      isMobile: true,
+      hasTouch: true,
+    });
+    const page = await context.newPage();
+
+    try {
+      await page.goto(normalizedUrl, { waitUntil: waitFor, timeout: 20000 });
+    } catch (navError) {
+      await browser.close();
+      return toolError(`Navigation failed for "${normalizedUrl}": ${navError.message}`);
+    }
+
+    const outDir = path.join(os.tmpdir(), 'lightcone-screenshots');
+    mkdirSync(outDir, { recursive: true });
+    const outPath = path.join(outDir, `screenshot-${Date.now()}-${randomUUID().slice(0, 8)}.png`);
+
+    await page.screenshot({
+      path: outPath,
+      fullPage: cropMode === 'full_page',
+    });
+
+    await browser.close();
+    return toolText([
+      'take_page_screenshot completed.',
+      `path=${outPath}`,
+      `crop=${cropMode}`,
+      `viewport=${vp.width}x${vp.height}`,
+    ].join('\n'));
+  } catch (error) {
+    await browser.close().catch(() => {});
+    return toolError(`take_page_screenshot failed: ${error.message}`);
+  }
+}