@lightcone-ai/daemon 0.14.13 → 0.14.15

package/package.json

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

package/src/chat-bridge.js

@@ -17,6 +17,7 @@ import {
   VIDEO_MIME,
   writeLocalFileToWorkspace,
 } from './workspace-file-upload.js';
+import { runSubmitToLibraryTool } from './submit-to-library-tool.js';
 import { isLeaseInvalidated, clearInvalidatedLease } from './governance-state.js';
 import { classifyLeaseWindow } from './lease-window.js';
 
@@ -197,6 +198,7 @@ const DEFAULT_TOOL_CLASSIFICATION = {
   request_credential_auth: 'mandatory',
   generate_voiceover: 'mandatory',
   compose_video: 'mandatory',
+  submit_to_library: 'mandatory',
   register_data_source: 'mandatory',
   bind_workspace_scenario: 'mandatory',
   create_workspace: 'mandatory',
@@ -254,6 +256,7 @@ const CACHE_INVALIDATION_TOOLS = new Set([
   'supersede_goal_field',
   'request_credential_auth',
   'register_data_source',
+  'submit_to_library',
   'bind_workspace_scenario',
   'create_workspace',
   'rename_workspace',
@@ -331,6 +334,7 @@ function inferToolForApi(method, apiPath, body) {
   if (method === 'POST' && cleanPath === '/goal-fields/supersede') return 'supersede_goal_field';
   if (method === 'POST' && cleanPath === '/credential-auth/request') return 'request_credential_auth';
   if (method === 'POST' && cleanPath === '/tts/voiceover') return 'generate_voiceover';
+  if (method === 'POST' && cleanPath === '/content-library/submit') return 'submit_to_library';
   if (method === 'POST' && cleanPath === '/api/data-sources') return 'register_data_source';
   if (method === 'POST' && cleanPath === '/orchestrate/decision') return 'write_governance_decision';
   if (method === 'POST' && cleanPath === '/orchestrate/correction') return 'write_governance_correction';
@@ -1503,6 +1507,26 @@ server.tool('compose_video',
   }
 );
 
+// ── submit_to_library ──────────────────────────────────────────────────────────
+server.tool('submit_to_library',
+  '把已生成的视频成片归档进内容库（content_video_draft entry）。调用前 mp4 必须已经通过 write_workspace_file 落到 workspace 的 artifacts/ 路径。归档后内容库会出现一张新卡片，含视频预览 + 元数据 + 后续支持发布/回采链路。',
+  {
+    video_path: z.string().describe('Workspace-relative video path, e.g. "artifacts/foo.mp4"'),
+    title: z.string().optional().describe('Library card 标题；若省略由系统从 understanding 推导'),
+    summary: z.string().optional().describe('一句话摘要'),
+    source_url: z.string().optional().describe('原始 URL（如有）'),
+    target_platform: z.string().optional().describe('目标发布平台，如 xhs / douyin'),
+    metadata: z.record(z.any()).optional().describe('其它 metadata（brand_voice / persona / account / goal_state 等）'),
+    understanding: z.record(z.any()).optional().describe('analyze_page 输出'),
+    plan: z.record(z.any()).optional().describe('plan_video / detail_sections 输出'),
+  },
+  async (args) => runSubmitToLibraryTool({
+    args,
+    currentWorkspaceId,
+    apiFn: api,
+  })
+);
+
 // ── register_data_source ───────────────────────────────────────────────────────
 server.tool('register_data_source',
   'Register a workspace data source without binding credential yet. Returns a one-time secure auth URL (10-minute expiry) that should be sent to the user via IM.',

package/src/publish-job-runner.js

@@ -1,4 +1,4 @@
-import { existsSync, statSync, realpathSync, mkdirSync, writeFileSync } from 'fs';
+import { existsSync, statSync, realpathSync, mkdirSync, writeFileSync, renameSync, rmSync, readdirSync } from 'fs';
 import path from 'path';
 import { getSession, closeSession } from '../mcp-servers/publisher/chrome-pool.js';
 import { XhsAdapter } from '../mcp-servers/publisher/adapters/xhs.js';
@@ -26,6 +26,7 @@ const DEFAULT_MEDIA_LIMITS = {
   douyin: { maxImages: 35, imageExts: ['.jpg', '.jpeg', '.png', '.webp'], videoExts: ['.mp4', '.mov', '.webm'] },
   kuaishou: { maxImages: 12, imageExts: ['.jpg', '.jpeg', '.png'], videoExts: ['.mp4', '.mov'] },
 };
+const PARTIAL_FILE_RE = /\.partial-\d+-[a-z0-9]+$/;
 
 function normalizeText(value) {
   const normalized = String(value ?? '').trim();
@@ -130,6 +131,82 @@ function decodeWorkspaceContent(content) {
   return Buffer.from(decodeURIComponent(body), 'utf8');
 }
 
+function buildPartialFilePath(localPath) {
+  return `${localPath}.partial-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function normalizeExpectedSizeBytes(value) {
+  if (value == null) return null;
+  const size = Number(value);
+  if (!Number.isInteger(size) || size < 0) return null;
+  return size;
+}
+
+export function isWorkspaceCacheValid(localPath, expected = {}) {
+  if (!existsSync(localPath)) return false;
+  let stat = null;
+  try {
+    stat = statSync(localPath);
+  } catch {
+    return false;
+  }
+  if (!stat.isFile()) return false;
+  const expectedSize = normalizeExpectedSizeBytes(expected?.size_bytes);
+  if (expectedSize != null && stat.size !== expectedSize) return false;
+  return true;
+}
+
+export function writeFileAtomically(localPath, data, {
+  mkdirRecursive = mkdirSync,
+  writeFile = writeFileSync,
+  renameFile = renameSync,
+  removeFile = rmSync,
+} = {}) {
+  mkdirRecursive(path.dirname(localPath), { recursive: true });
+  const tmpPath = buildPartialFilePath(localPath);
+  try {
+    writeFile(tmpPath, data);
+    renameFile(tmpPath, localPath);
+  } catch (error) {
+    try { removeFile(tmpPath, { force: true }); } catch {}
+    throw error;
+  }
+  return localPath;
+}
+
+function removePartialFilesRecursively(rootDir) {
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries = null;
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const entryPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(entryPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!PARTIAL_FILE_RE.test(entry.name)) continue;
+      try { rmSync(entryPath, { force: true }); } catch {}
+    }
+  }
+}
+
+export function cleanupWorkspacePartialFiles(workspaceRootDir) {
+  const normalizedRoot = String(workspaceRootDir ?? '').trim();
+  if (!normalizedRoot) return;
+  const scanRoots = ['artifacts', 'notes', 'tmp'].map(dir => path.join(normalizedRoot, dir));
+  for (const root of scanRoots) {
+    if (!existsSync(root)) continue;
+    removePartialFilesRecursively(root);
+  }
+}
+
 export async function fetchPublishJobWorkspaceFile({ serverUrl, machineApiKey, jobId, relPath }) {
   const normalizedJobId = String(jobId ?? '').trim();
   if (!normalizedJobId) {
@@ -148,7 +225,14 @@ export async function fetchPublishJobWorkspaceFile({ serverUrl, machineApiKey, j
   return res.json();
 }
 
-export async function streamPublishJobVideo({ serverUrl, machineApiKey, jobId, videoId, localPath }) {
+export async function streamPublishJobVideo({
+  serverUrl,
+  machineApiKey,
+  jobId,
+  videoId,
+  localPath,
+  writeBinaryFile = writeFileAtomically,
+}) {
   const normalizedJobId = String(jobId ?? '').trim();
   if (!normalizedJobId) {
     throw new Error('publish job id is required to fetch video files');
@@ -168,8 +252,7 @@ export async function streamPublishJobVideo({ serverUrl, machineApiKey, jobId, v
     throw new Error(`publish-jobs video-files GET failed (${res.status}): ${text}`);
   }
   const data = Buffer.from(await res.arrayBuffer());
-  mkdirSync(path.dirname(localPath), { recursive: true });
-  writeFileSync(localPath, data);
+  writeBinaryFile(localPath, data);
   return localPath;
 }
 
@@ -208,11 +291,15 @@ export async function materializeWorkspaceMedia({
   jobId,
   fetchWorkspaceFile = fetchPublishJobWorkspaceFile,
   streamVideoFile = streamPublishJobVideo,
+  writeBinaryFile = writeFileAtomically,
 }) {
-  if (!filePath || existsSync(filePath)) return filePath;
+  if (!filePath) return filePath;
 
   const workspacePath = workspacePathFromMediaPath(filePath, workspaceId);
-  if (!workspacePath?.workspaceId || !workspacePath.relPath) return filePath;
+  if (!workspacePath?.workspaceId || !workspacePath.relPath) {
+    if (existsSync(filePath)) return filePath;
+    return filePath;
+  }
 
   const localPath = path.resolve(workspaceRootDir, workspacePath.relPath);
   const allowedRoots = ['artifacts', 'notes', 'tmp'].map(dir => path.join(workspaceRootDir, dir));
@@ -220,14 +307,14 @@ export async function materializeWorkspaceMedia({
     throw new Error(`workspace media path is outside allowed workspace directories: ${filePath}`);
   }
 
-  if (existsSync(localPath)) return localPath;
-
   const data = await fetchWorkspaceFile({
     serverUrl,
     machineApiKey,
     jobId,
     relPath: workspacePath.relPath,
   });
+  if (isWorkspaceCacheValid(localPath, data)) return localPath;
+
   if (data?.videoId) {
     await streamVideoFile({
       serverUrl,
@@ -237,8 +324,7 @@ export async function materializeWorkspaceMedia({
       localPath,
     });
   } else {
-    mkdirSync(path.dirname(localPath), { recursive: true });
-    writeFileSync(localPath, decodeWorkspaceContent(data.content));
+    writeBinaryFile(localPath, decodeWorkspaceContent(data.content));
   }
   return localPath;
 }
@@ -253,6 +339,7 @@ async function materializeMedia({
   machineApiKey,
   jobId,
 }) {
+  cleanupWorkspacePartialFiles(workspaceRootDir);
   return {
     images: await Promise.all(images.map(filePath => materializeWorkspaceMedia({
       filePath,

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

@@ -0,0 +1,39 @@
+function toolText(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function toolError(text) {
+  return { isError: true, content: [{ type: 'text', text }] };
+}
+
+export function buildSubmitToLibraryBody(args = {}, workspaceId = '') {
+  return {
+    ...(args ?? {}),
+    workspace_id: workspaceId,
+  };
+}
+
+export async function runSubmitToLibraryTool({
+  args = {},
+  currentWorkspaceId = '',
+  apiFn,
+} = {}) {
+  if (!currentWorkspaceId) {
+    return toolError('No workspace context.');
+  }
+  if (typeof apiFn !== 'function') {
+    return toolError('Error: submit_to_library apiFn is required.');
+  }
+  try {
+    const data = await apiFn(
+      'POST',
+      '/content-library/submit',
+      buildSubmitToLibraryBody(args, currentWorkspaceId)
+    );
+    return toolText(
+      `Submitted to content library: itemId=${data.itemId}, version=${data.version}, kind=${data.kind ?? 'content_video_draft'}`
+    );
+  } catch (err) {
+    return toolError(`Error: ${err.message}`);
+  }
+}