@lightcone-ai/daemon 0.14.12 → 0.14.14

package/package.json

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

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,6 +225,37 @@ export async function fetchPublishJobWorkspaceFile({ serverUrl, machineApiKey, j
   return res.json();
 }
 
+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');
+  }
+  const normalizedVideoId = String(videoId ?? '').trim();
+  if (!normalizedVideoId) {
+    throw new Error('video id is required to fetch video files');
+  }
+  const url = `${String(serverUrl).replace(/\/$/, '')}/internal/agent/publish-jobs/${encodeURIComponent(normalizedJobId)}/video-files/${encodeURIComponent(normalizedVideoId)}`;
+  const res = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${machineApiKey}`,
+    },
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`publish-jobs video-files GET failed (${res.status}): ${text}`);
+  }
+  const data = Buffer.from(await res.arrayBuffer());
+  writeBinaryFile(localPath, data);
+  return localPath;
+}
+
 export function workspacePathFromMediaPath(filePath, workspaceId) {
   if (!filePath) return null;
 
@@ -182,11 +290,16 @@ export async function materializeWorkspaceMedia({
   machineApiKey,
   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));
@@ -194,16 +307,25 @@ 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,
   });
-  mkdirSync(path.dirname(localPath), { recursive: true });
-  writeFileSync(localPath, decodeWorkspaceContent(data.content));
+  if (isWorkspaceCacheValid(localPath, data)) return localPath;
+
+  if (data?.videoId) {
+    await streamVideoFile({
+      serverUrl,
+      machineApiKey,
+      jobId,
+      videoId: data.videoId,
+      localPath,
+    });
+  } else {
+    writeBinaryFile(localPath, decodeWorkspaceContent(data.content));
+  }
   return localPath;
 }
 
@@ -217,6 +339,7 @@ async function materializeMedia({
   machineApiKey,
   jobId,
 }) {
+  cleanupWorkspacePartialFiles(workspaceRootDir);
   return {
     images: await Promise.all(images.map(filePath => materializeWorkspaceMedia({
       filePath,