cerevox 4.0.0-alpha.2 → 4.0.0-alpha.4

package/dist/mcp/servers/zerocut.js

@@ -140,6 +140,8 @@ async function saveMaterial(session, url, saveToFileName) {
     const terminal = session.terminal;
     const saveToPath = `/home/user/cerevox-zerocut/projects/${terminal.id}/materials/${saveToFileName}`;
     const saveLocalPath = (0, node_path_1.resolve)(projectLocalDir, 'materials', saveToFileName);
+    // 确保目录存在
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(saveLocalPath), { recursive: true });
     // 先下载到本地，再上传 sandbox，比直接 sandbox 更好，也以免下载超时
     // 通过 fetch 下载到本地
     const res = await fetch(url);
@@ -261,7 +263,7 @@ async function filterMaterialsForUpload(materials, projectLocalDir) {
             regularFiles.push(material);
         }
     }
-    // 处理场景文件（scXX_ 前缀）
+    // 处理分镜文件（scXX_ 前缀）
     if (sceneFiles.length > 0 && mediaLogs.length > 0) {
         // 按前缀和扩展名分组
         const groupedFiles = new Map();
@@ -309,7 +311,7 @@ async function filterMaterialsForUpload(materials, projectLocalDir) {
         }
     }
     else {
-        // 如果没有 media_logs.json 或没有场景文件，全部上传
+        // 如果没有 media_logs.json 或没有分镜文件，全部上传
         filesToUpload.push(...sceneFiles);
     }
     // 处理普通文件（全量上传）
@@ -341,7 +343,7 @@ server.registerPrompt('zerocut-guideline', {
     description: '专业的短视频创作 Agent 指导规范，包含完整的工作流程、工具说明和质量建议',
 }, async () => {
     try {
-        const promptPath = (0, node_path_1.resolve)(__dirname, './prompts/zerocut-core.md');
+        const promptPath = (0, node_path_1.resolve)(__dirname, './prompts/zerocut-core-web.md');
         const promptContent = await (0, promises_1.readFile)(promptPath, 'utf-8');
         return {
             messages: [
@@ -356,8 +358,8 @@ server.registerPrompt('zerocut-guideline', {
         };
     }
     catch (error) {
-        console.error('Failed to load zerocut-guideline prompt:', error);
-        throw new Error(`Failed to load zerocut-guideline prompt: ${error}`);
+        console.error('Failed to load zerocut-guideline-web prompt:', error);
+        throw new Error(`Failed to load zerocut-guideline-web prompt: ${error}`);
     }
 });
 server.registerTool('project-open', {
@@ -1020,12 +1022,12 @@ server.registerTool('generate-image', {
             .default('seedream-pro'),
         prompt: zod_1.z
             .string()
-            .describe('The prompt to generate. 一般要严格对应 storyboard 中当前场景的 start_frame 或 end_frame 中的字段描述，如果是生成线稿，则 type 使用 line-sketch，如果是生成故事板印样或人物镜头宫格，则 type 使用 shot-grid'),
+            .describe('The prompt to generate. 一般要严格对应 storyboard 中当前分镜的 start_frame 或 end_frame 中的字段描述，如果是生成线稿，则 type 使用 line-sketch，如果是生成故事板印样或人物镜头宫格，则 type 使用 shot-grid'),
         sceneIndex: zod_1.z
             .number()
             .min(1)
             .optional()
-            .describe('场景索引，从1开始的下标，如果非场景对应素材，则可不传，场景素材必传'),
+            .describe('分镜索引，从1开始的下标，如果非分镜对应素材，则可不传，分镜素材必传'),
         storyBoardFile: zod_1.z
             .string()
             .optional()
@@ -1131,14 +1133,7 @@ server.registerTool('generate-image', {
         const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
         const outlineSheetImagePath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'materials', 'outline_sheet.png');
         const hasOutlineSheet = (0, node_fs_1.existsSync)(outlineSheetImagePath);
-        // 检查 storyboard 标志
-        if (!hasOutlineSheet &&
-            !checkStoryboardFlag &&
-            (0, node_fs_1.existsSync)(storyBoardPath)) {
-            checkStoryboardFlag = true;
-            return createErrorResponse('必须先审查生成的 storyboard.json 内容，确保每个场景中的stage_atmosphere内容按照规则被正确融合到start_frame和video_prompt中，不得遗漏，检查完成后先汇报，如果有问题，应当先修改 storyboard.json 内容，然后再调用 generate-image 生成图片。注意修改 storyboard 内容时，仅修改相应字段的字符串值，不要破坏JSON格式！', 'generate-image');
-        }
-        // 校验 prompt 与 storyboard.json 中场景设定的一致性
+        // 校验 prompt 与 storyboard.json 中分镜设定的一致性
         if (sceneIndex && !skipConsistencyCheck) {
             try {
                 if ((0, node_fs_1.existsSync)(storyBoardPath)) {
@@ -1226,73 +1221,6 @@ server.registerTool('generate-image', {
         // 检查并替换英文单引号包裹的中文内容为中文双引号
         // 这样才能让 seedream 生成更好的中文文字
         let processedPrompt = prompt.replace(/'([^']*[\u4e00-\u9fff][^']*)'/g, '“$1”');
-        try {
-            const ai = currentSession.ai;
-            const promptOptimizer = await (0, promises_1.readFile)((0, node_path_1.resolve)(__dirname, './prompts/image-prompt-optimizer.md'), 'utf8');
-            if (!hasOutlineSheet) {
-                const schema = {
-                    name: 'optimize_image_prompt',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            prompt_optimized: {
-                                type: 'string',
-                                description: '优化后的提示词',
-                            },
-                            metaphor_modifiers: {
-                                type: 'array',
-                                description: '从 prompt_optimized 中抽取的所有比喻修饰词（字符串数组）',
-                                items: {
-                                    type: 'string',
-                                    description: '比喻性修饰词，例如 “如羽毛般轻盈”、“像晨雾一样柔和”',
-                                },
-                            },
-                        },
-                        required: ['prompt_optimized', 'metaphor_modifiers'],
-                    },
-                };
-                const completion = await ai.getCompletions({
-                    model: 'Doubao-Seed-1.6',
-                    messages: [
-                        {
-                            role: 'system',
-                            content: promptOptimizer,
-                        },
-                        {
-                            role: 'user',
-                            content: `## 用户指令
-
-  ${processedPrompt.trim()}
-
-  ## 参考图
-
-  ${referenceImages?.map((ref, index) => `图${index + 1}：${ref.image}`).join('\n') || '无'}`,
-                        },
-                    ],
-                    response_format: {
-                        type: 'json_schema',
-                        json_schema: schema,
-                    },
-                });
-                const optimizedPrompt = completion.choices[0]?.message?.content.trim();
-                if (optimizedPrompt) {
-                    try {
-                        const { prompt_optimized, metaphor_modifiers } = JSON.parse(optimizedPrompt);
-                        processedPrompt = `${prompt_optimized}`;
-                        if (metaphor_modifiers?.length) {
-                            processedPrompt += `\n\n注意：下面这些是形象比喻，并不是输出内容。\n${metaphor_modifiers}`;
-                        }
-                    }
-                    catch (ex) {
-                        console.error('Failed to parse optimized prompt:', ex);
-                        processedPrompt = optimizedPrompt;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error('Failed to optimize prompt:', error);
-        }
         if (imageCount > 1) {
             processedPrompt = `请生成${imageCount}张${size}大小的关联图片，每张图分别生成，不要拼接为大图 ${processedPrompt}`;
         }
@@ -1365,7 +1293,7 @@ server.registerTool('generate-image', {
             if (objectPrefix.length > 0) {
                 processedPrompt = `${objectPrefix.join('\n')}
 
-${turnaroundMessage}参考以上图片，执行以下场景绘图：
+${turnaroundMessage}参考以上图片，执行以下绘图指令：
 ${processedPrompt}`.trim();
             }
         }
@@ -1402,7 +1330,7 @@ ${processedPrompt}`.trim();
                 ];
             }
             else {
-                // 多图场景
+                // 多图
                 uris = await Promise.all(res.urls.map((url, i) => {
                     if (!url)
                         return '';
@@ -2026,695 +1954,6 @@ server.registerTool('text-to-speech', {
         return createErrorResponse(error, 'text-to-speech');
     }
 });
-// server.registerTool(
-//   'generate-scene-tts',
-//   {
-//     title: 'Generate Scene TTS',
-//     description: `生成场景配音`,
-//     inputSchema: {
-//       text: z.string().describe('The text to generate.'),
-//       sceneIndex: z
-//         .number()
-//         .min(1)
-//         .optional()
-//         .describe(
-//           '场景索引，从1开始的下标，如果非场景对应素材，则可不传，场景素材必传'
-//         ),
-//       storyBoardFile: z
-//         .string()
-//         .optional()
-//         .default('storyboard.json')
-//         .describe('故事板文件路径'),
-//       skipConsistencyCheck: z
-//         .boolean()
-//         .optional()
-//         .default(false)
-//         .describe('是否跳过一致性检查，默认为false（即默认进行一致性检查）'),
-//       skipCheckWithSceneReason: z
-//         .string()
-//         .optional()
-//         .describe(
-//           '跳过校验的理由，如果skipConsistencyCheck设为true，必须要传这个参数'
-//         ),
-//       saveToFileName: z
-//         .string()
-//         .describe('The filename to save. 应该是mp3文件'),
-//       speed: z
-//         .number()
-//         .min(0.5)
-//         .max(2)
-//         .optional()
-//         .default(1)
-//         .describe('The speed of the tts.'),
-//       pitch: z
-//         .number()
-//         .min(-12)
-//         .max(12)
-//         .optional()
-//         .default(0)
-//         .describe('The pitch of the tts.'),
-//       volume: z
-//         .number()
-//         .min(0)
-//         .max(10)
-//         .optional()
-//         .default(1.0)
-//         .describe('The volume of the tts.'),
-//       voiceID: z
-//         .string()
-//         .describe(
-//           `适合作为视频配音的音色ID，除非用户指定，否则你必须确保已通过 pick-voice 工具挑选出真实存在的音色。`
-//         ),
-//       context_texts: z
-//         .array(z.string())
-//         .default([])
-//         .describe(
-//           `语音合成的辅助信息，用于模型对话式合成，能更好的体现语音情感
-// 可以探索，比如常见示例有以下几种：
-// 1. 语速调整
-//   - context_texts: ["你可以说慢一点吗？"]
-// 2. 情绪/语气调整
-//   - context_texts=["你可以用特别特别痛心的语气说话吗?"]
-//   - context_texts=["嗯，你的语气再欢乐一点"]
-// 3. 音量调整
-//   - context_texts=["你嗓门再小点。"]
-// 4. 音感调整
-//   - context_texts=["你能用骄傲的语气来说话吗？"]
-// `
-//         ),
-//       explicit_language: z.enum(['zh', 'en', 'ja']).optional().default('zh'),
-//     },
-//   },
-//   async ({
-//     text,
-//     sceneIndex,
-//     storyBoardFile,
-//     skipConsistencyCheck,
-//     voiceID,
-//     saveToFileName,
-//     speed,
-//     pitch,
-//     volume,
-//     context_texts,
-//     explicit_language,
-//   }) => {
-//     try {
-//       // 验证session状态
-//       const currentSession = await validateSession('generate-scene-tts');
-//       const validatedFileName = validateFileName(saveToFileName);
-//       const finalSpeed = speed ?? 1;
-//       volume = volume ?? 1;
-//       const ai = currentSession.ai;
-//       let scene = null;
-//       // 校验 text 与 storyboard.json 中场景设定的一致性
-//       if (sceneIndex && !skipConsistencyCheck) {
-//         try {
-//           const voice = (await ai.listVoices()).find(v => v.id === voiceID);
-//           if (!voice) {
-//             return createErrorResponse(
-//               `Voice ${voiceID} not found in voice-list. Use pick-voice tool to pick an available voice. 若用户坚持要使用该音色，需跳过一致性检查。`,
-//               'generate-scene-tts'
-//             );
-//           }
-//           const storyBoardPath = resolve(
-//             process.env.ZEROCUT_PROJECT_CWD || process.cwd(),
-//             projectLocalDir,
-//             storyBoardFile
-//           );
-//           if (existsSync(storyBoardPath)) {
-//             const storyBoardContent = await readFile(storyBoardPath, 'utf8');
-//             // 检查 storyBoard JSON 语法合法性
-//             let storyBoard;
-//             try {
-//               storyBoard = JSON.parse(storyBoardContent);
-//             } catch (jsonError) {
-//               return createErrorResponse(
-//                 `storyBoard 文件 ${storyBoardFile} 存在 JSON 语法错误，请修复后重试。错误详情: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`,
-//                 'generate-scene-tts'
-//               );
-//             }
-//             if (storyBoard.scenes && Array.isArray(storyBoard.scenes)) {
-//               scene = storyBoard.scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
-//               if (scene) {
-//                 const script = scene.script;
-//                 let isValidText = false;
-//                 // 检查 text 是否严格等于 script
-//                 if (script && text === script) {
-//                   isValidText = true;
-//                 }
-//                 // 检查 text 是否严格等于 dialog 数组中某个元素的 script
-//                 if (
-//                   !isValidText &&
-//                   scene.dialog &&
-//                   Array.isArray(scene.dialog)
-//                 ) {
-//                   for (const dialogItem of scene.dialog) {
-//                     if (dialogItem.script && text === dialogItem.script) {
-//                       isValidText = true;
-//                       break;
-//                     }
-//                   }
-//                 }
-//                 if (!isValidText) {
-//                   return createErrorResponse(
-//                     '配音文本必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用',
-//                     'generate-scene-tts'
-//                   );
-//                 }
-//               } else {
-//                 console.warn(
-//                   `Scene index ${sceneIndex} not found in storyboard.json`
-//                 );
-//               }
-//             }
-//           } else {
-//             console.warn(`Story board file not found: ${storyBoardPath}`);
-//           }
-//         } catch (error) {
-//           console.error('Failed to validate text with story board:', error);
-//           // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
-//         }
-//       }
-//       console.log(
-//         `Generating TTS with voice: ${voiceID}, speed: ${finalSpeed}, text: ${text.substring(0, 100)}...`
-//       );
-//       if (voiceID.startsWith('BV0')) {
-//         throw new Error(
-//           `BV0* 系列音色已弃用，你必须通过 pick-voice 工具挑选一个真实存在的音色。`
-//         );
-//       }
-//       const type =
-//         voiceID.startsWith('zh_') ||
-//         voiceID.startsWith('en_') ||
-//         voiceID.startsWith('multi_') ||
-//         voiceID.startsWith('saturn_') ||
-//         voiceID.startsWith('ICL_')
-//           ? 'volcano'
-//           : 'minimax';
-//       let res;
-//       let emotion = 'auto';
-//       if (type === 'volcano') {
-//         volume = Math.max(Math.min(volume, 2.0), 0.5);
-//         res = await ai.textToSpeechVolc({
-//           text: text.trim(),
-//           speaker: voiceID,
-//           speed: Math.floor(100 * (finalSpeed - 1)),
-//           volume: Math.floor(100 * (volume - 1)),
-//           context_texts,
-//           explicit_language,
-//           voice_to_caption:
-//             explicit_language === 'zh' || explicit_language === 'en',
-//         });
-//       } else {
-//         emotion = 'neutral';
-//         if (context_texts.length > 0) {
-//           const prompt = `根据用户输入语音内容和上下文内容，从文字判断语音合理的情感，然后选择以下情感**之一**返回结果：
-// "happy", "sad", "angry", "fearful", "disgusted", "surprised", "calm", "fluent", "whisper", "neutral"
-// ## 要求
-// 输出 JSON 格式，包含一个 emotion 字段，值为以上情感之一。
-// `;
-//           const schema = {
-//             name: 'emotion_schema',
-//             schema: {
-//               type: 'object',
-//               properties: {
-//                 emotion: {
-//                   type: 'string',
-//                   enum: [
-//                     'neutral',
-//                     'happy',
-//                     'sad',
-//                     'angry',
-//                     'fearful',
-//                     'disgusted',
-//                     'surprised',
-//                     'calm',
-//                     'fluent',
-//                     'whisper',
-//                   ],
-//                   description: '用户输入语音的情感',
-//                 },
-//               },
-//               required: ['emotion'],
-//             },
-//           };
-//           const payload: any = {
-//             model: 'Doubao-Seed-1.6',
-//             messages: [
-//               {
-//                 role: 'system',
-//                 content: prompt,
-//               },
-//               {
-//                 role: 'user',
-//                 content: `## 语音内容：
-// ${text.trim()}
-// ## 语音上下文
-// ${context_texts.join('\n')}
-// `,
-//               },
-//             ],
-//             response_format: {
-//               type: 'json_schema',
-//               json_schema: schema,
-//             },
-//           };
-//           const completion = await ai.getCompletions(payload);
-//           const emotionObj = JSON.parse(
-//             completion.choices[0]?.message?.content ?? '{}'
-//           );
-//           emotion = emotionObj.emotion ?? 'neutral';
-//         }
-//         res = await ai.textToSpeech({
-//           text: text.trim(),
-//           voiceName: voiceID,
-//           speed: finalSpeed,
-//           pitch,
-//           volume,
-//           emotion,
-//           voice_to_caption:
-//             explicit_language === 'zh' || explicit_language === 'en',
-//         });
-//       }
-//       if (!res) {
-//         throw new Error('Failed to generate TTS: no response from AI service');
-//       }
-//       if (res.url) {
-//         console.log('TTS generated successfully, saving to materials...');
-//         const { url, duration, ...opts } = res;
-//         if (!skipConsistencyCheck && duration > 16) {
-//           return createErrorResponse(
-//             'TTS duration exceeds 16 seconds, 建议调整文本长度、提升语速或拆分场景...，⚠️如简化文本内容或拆分文本，需要立即更新 storyboard 以保持内容同步！如仍要生成，可设置 skipConsistencyCheck 为 true，跳过一致性检查。',
-//             'generate-scene-tts'
-//           );
-//         }
-//         if (!duration) {
-//           return createErrorResponse(
-//             'TTS duration not returned from AI service',
-//             'generate-scene-tts'
-//           );
-//         }
-//         const uri = await saveMaterial(currentSession, url, validatedFileName);
-//         let warn = '';
-//         if (scene) {
-//           const minDur = Math.ceil(duration);
-//           if (scene.audio_mode === 'vo_sync' && scene.duration !== minDur) {
-//             warn = `场景${sceneIndex}设定的时长${scene.duration}秒与实际生成的语音时长${minDur}秒不一致，音画同步将有问题，建议修改场景时长为${minDur}秒`;
-//           } else if (scene.duration < minDur) {
-//             warn = `场景${sceneIndex}设定的时长${scene.duration}秒小于实际生成的语音时长${duration}秒，可能会导致场景结束时音频未播放完成，建议修改场景时长为${minDur}秒`;
-//           }
-//         }
-//         const result = {
-//           success: true,
-//           warn,
-//           source: url, // 方便调试
-//           uri,
-//           durationMs: Math.floor((duration || 0) * 1000),
-//           text,
-//           emotion,
-//           context_texts,
-//           voiceName: voiceID,
-//           speed: finalSpeed,
-//           timestamp: new Date().toISOString(),
-//           ...opts,
-//         };
-//         // Update media_logs.json
-//         try {
-//           await updateMediaLogs(
-//             currentSession,
-//             validatedFileName,
-//             result,
-//             'audio'
-//           );
-//         } catch (error) {
-//           console.warn(
-//             `Failed to update media_logs.json for ${validatedFileName}:`,
-//             error
-//           );
-//         }
-//         return {
-//           content: [
-//             {
-//               type: 'text' as const,
-//               text: JSON.stringify(result),
-//             },
-//           ],
-//         };
-//       } else {
-//         console.warn('TTS generation completed but no URL returned');
-//         return {
-//           content: [
-//             {
-//               type: 'text' as const,
-//               text: JSON.stringify({
-//                 success: false,
-//                 error:
-//                   'No TTS URL returned from AI service. You should use pick-voice tool to pick an available voice.',
-//                 response: res,
-//                 timestamp: new Date().toISOString(),
-//               }),
-//             },
-//           ],
-//         };
-//       }
-//     } catch (error) {
-//       return createErrorResponse(error, 'generate-scene-tts');
-//     }
-//   }
-// );
-// server.registerTool(
-//   'compile-and-run',
-//   {
-//     title: 'Compile And Run',
-//     description: 'Compile project to ffmpeg command and run it.',
-//     inputSchema: {
-//       projectFileName: z
-//         .string()
-//         .describe('The VideoProject configuration object.'),
-//       outputFileName: z
-//         .string()
-//         .optional()
-//         .describe('Output video filename (optional, defaults to output.mp4).'),
-//     },
-//   },
-//   async ({ projectFileName, outputFileName }) => {
-//     try {
-//       // 验证session状态
-//       const currentSession = await validateSession('compile-and-run');
-//       // 检查字幕内容匹配标记
-//       if (!checkStoryboardSubtitlesFlag) {
-//         checkStoryboardSubtitlesFlag = true;
-//         return createErrorResponse(
-//           `请先对 draft_content 进行以下一致性检查：
-// 1. 检查字幕文字内容是否与 storyboard 中各个场景的 script 或 dialog 内容完全一致（⚠️ 允许字幕分段展示，只要最终文本保持一致就行）
-// 2. 检查视频 resolution 设定是否与 storyboard 的 orientation 设置一致，默认 720p 情况下视频尺寸应为横屏 1280x720，竖屏 720x1280，若视频为 1080p 则尺寸应分别为横屏 1920x1080 和竖屏 1080x1920，切勿设反
-// 3. 除非用户明确表示不要背景音乐，否则应检查是否有生成并配置了 BGM，若无，则生成 BGM 并将其加入素材和轨道配置
-// 以上检查任何一项有问题，先修复 draft_content 使其符合要求后再进行合成`,
-//           'compile-and-run'
-//         );
-//       }
-//       console.log('Starting video compilation and rendering...');
-//       // 验证terminal可用性
-//       const terminal = currentSession.terminal;
-//       if (!terminal) {
-//         throw new Error('Terminal not available in current session');
-//       }
-//       const localProjectFile = resolve(
-//         projectLocalDir,
-//         basename(projectFileName)
-//       );
-//       const project = JSON.parse(await readFile(localProjectFile, 'utf-8'));
-//       // 验证输出文件名安全性
-//       const outFile = outputFileName || project.export.outFile || 'output.mp4';
-//       const validatedFileName = validateFileName(outFile);
-//       console.log(`Output file: ${validatedFileName}`);
-//       // 构建工作目录路径
-//       const workDir = `/home/user/cerevox-zerocut/projects/${terminal.id}`;
-//       const outputDir = `${workDir}/output`;
-//       const outputPath = `${outputDir}/${validatedFileName}`;
-//       // Project已经通过zVideoProject schema验证
-//       const validated = { ...project };
-//       // 更新导出配置
-//       validated.export = {
-//         ...validated.export,
-//         outFile: outputPath,
-//       };
-//       console.log('Compiling VideoProject to FFmpeg command...');
-//       // 编译为FFmpeg命令
-//       let compiled: CompileResult;
-//       try {
-//         compiled = await compileToFfmpeg(validated, {
-//           workingDir: outputDir,
-//           subtitleStrategy: 'ass',
-//           subtitlesFileName: `${outFile.replace(/\.mp4$/, '')}.subtitles.ass`,
-//         });
-//       } catch (compileError) {
-//         console.error('Failed to compile VideoProject:', compileError);
-//         throw new Error(`Failed to compile VideoProject: ${compileError}`);
-//       }
-//       console.log(`FFmpeg command generated (${compiled.cmd.length} chars)`);
-//       console.log('FFmpeg Command:', compiled.cmd.substring(0, 200) + '...');
-//       // 执行FFmpeg命令
-//       console.log('Executing FFmpeg command...');
-//       const result = await runFfmpeg(currentSession, compiled);
-//       if (result.exitCode === 0) {
-//         console.log('Video compilation completed successfully');
-//         // 自动下载输出文件
-//         console.log('Starting automatic download of output files...');
-//         let downloadResult = null;
-//         try {
-//           const workDir = `/home/user/cerevox-zerocut/projects/${terminal.id}/output`;
-//           let outputs: string[] = [];
-//           try {
-//             outputs = (await currentSession.files.listFiles(workDir)) || [];
-//           } catch (listError) {
-//             console.warn('Failed to list output files:', listError);
-//             outputs = [];
-//           }
-//           if (outputs.length > 0) {
-//             const outputDir = resolve(
-//               process.env.ZEROCUT_PROJECT_CWD || process.cwd(),
-//               projectLocalDir,
-//               'output'
-//             );
-//             await mkdir(outputDir, { recursive: true });
-//             const downloadErrors: string[] = [];
-//             const successfulDownloads: string[] = [];
-//             const promises = outputs.map(async output => {
-//               try {
-//                 await currentSession.files.download(
-//                   `${workDir}/${output}`,
-//                   `${outputDir}/${output}`
-//                 );
-//                 successfulDownloads.push(output);
-//                 return output;
-//               } catch (downloadError) {
-//                 const errorMsg = `Failed to download ${output}: ${downloadError}`;
-//                 console.error(errorMsg);
-//                 downloadErrors.push(errorMsg);
-//                 return null;
-//               }
-//             });
-//             const results = await Promise.all(promises);
-//             const sources = results.filter(
-//               output => output !== null
-//             ) as string[];
-//             downloadResult = {
-//               totalFiles: outputs.length,
-//               successfulDownloads: sources.length,
-//               failedDownloads: downloadErrors.length,
-//               downloadErrors:
-//                 downloadErrors.length > 0 ? downloadErrors : undefined,
-//               downloadPath: outputDir,
-//               sources,
-//             };
-//             console.log(
-//               `Download completed: ${sources.length}/${outputs.length} files successful`
-//             );
-//           } else {
-//             console.log('No output files found to download');
-//             downloadResult = {
-//               totalFiles: 0,
-//               successfulDownloads: 0,
-//               failedDownloads: 0,
-//               message: 'No output files found to download',
-//             };
-//           }
-//         } catch (downloadError) {
-//           console.error('Download process failed:', downloadError);
-//           downloadResult = {
-//             error: `Download failed: ${downloadError}`,
-//             totalFiles: 0,
-//             successfulDownloads: 0,
-//             failedDownloads: 1,
-//           };
-//         }
-//         const successResult = {
-//           success: true,
-//           outputPath,
-//           outputFileName: validatedFileName,
-//           command: compiled.cmd,
-//           message: 'Video compilation and download completed successfully',
-//           download: downloadResult,
-//           timestamp: new Date().toISOString(),
-//         };
-//         return {
-//           content: [
-//             {
-//               type: 'text' as const,
-//               text: JSON.stringify(successResult),
-//             },
-//           ],
-//         };
-//       } else {
-//         console.error(`FFmpeg failed with exit code: ${result.exitCode}`);
-//         const failureResult = {
-//           success: false,
-//           exitCode: result.exitCode,
-//           outputPath,
-//           // command: compiled.cmd,
-//           stderr: result.stderr,
-//           message: `FFmpeg exited with code ${result.exitCode}`,
-//           timestamp: new Date().toISOString(),
-//         };
-//         if (result.exitCode === 254) {
-//           failureResult.message =
-//             'FFmpeg failed with code 254. Close current session immediately (inMinutes = 0) and re-open a new session to try again.';
-//         }
-//         return {
-//           content: [
-//             {
-//               type: 'text' as const,
-//               text: JSON.stringify(failureResult),
-//             },
-//           ],
-//         };
-//       }
-//     } catch (error) {
-//       return createErrorResponse(error, 'compile-and-run');
-//     }
-//   }
-// );
-// server.registerTool(
-//   'get-schema',
-//   {
-//     title: 'Get Storyboard Schema or Draft Content Schema',
-//     description:
-//       'Get the complete Storyboard or Draft Content JSON Schema definition. Use this schema to validate storyboard.json or draft_content.json files.',
-//     inputSchema: {
-//       type: z
-//         .enum(['storyboard', 'draft_content'])
-//         .describe(
-//           'The type of schema to retrieve. Must be either "storyboard" or "draft_content". 用 type: storyboard 的 schema 生成 storyboard.json；用 type: draft_content 的 schema 生成 draft_content.json'
-//         ),
-//     },
-//   },
-//   async ({ type }) => {
-//     try {
-//       const schemaPath = resolve(__dirname, `./prompts/${type}-schema.json`);
-//       const schemaContent = await readFile(schemaPath, 'utf-8');
-//       const schema = JSON.parse(schemaContent);
-//       let important_guidelines = '';
-//       if (type === 'draft_content') {
-//         important_guidelines = `⚠️ 生成文件时请严格遵守输出规范，字幕文本内容必须与 storyboard.json 中的 script（或dialog） 字段的文本内容完全一致。
-// ** 字幕优化 **
-//   * 在保证字幕文本内容与 storyboard.json 中的 script（或dialog） 字段的文本内容完全一致的前提下，可根据 tts 返回的 \`captions.utterances\` 字段对字幕的显示进行优化，将过长的字幕分段显示，在 draft_content.json 中使用分段字幕，captions 的内容在 media_logs.json 中可查询到。
-//   * 如用户未特殊指定，字幕样式（字体及大小）务必遵守输出规范
-// `;
-//       }
-//       return {
-//         content: [
-//           {
-//             type: 'text' as const,
-//             text: JSON.stringify({
-//               success: true,
-//               schema,
-//               important_guidelines,
-//               timestamp: new Date().toISOString(),
-//             }),
-//           },
-//         ],
-//       };
-//     } catch (error) {
-//       return createErrorResponse(error, 'get-schema');
-//     }
-//   }
-// );
-// server.registerTool(
-//   'pick-voice',
-//   {
-//     title: 'Pick Voice',
-//     description:
-//       '根据用户需求，选择尽可能符合要求的语音，在合适的情况下，优先采用 volcano_tts_2 类型的语音',
-//     inputSchema: {
-//       prompt: z
-//         .string()
-//         .describe('用户需求描述，例如：一个有亲和力的，适合给孩子讲故事的语音'),
-//       custom_design: z
-//         .boolean()
-//         .optional()
-//         .describe(
-//           '是否自定义语音，由于要消耗较多积分，因此**只有用户明确要求自己设计语音**，才将该参数设为true'
-//         ),
-//       custom_design_preview: z
-//         .string()
-//         .optional()
-//         .describe(
-//           '用户自定义语音的预览文本，用于展示自定义语音的效果，只有 custom_design 为 true 时才需要'
-//         ),
-//       custom_design_save_to: z
-//         .string()
-//         .optional()
-//         .describe(
-//           '自定义语音的保存路径，例如：custom_voice.mp3 custom_voice_{id}.mp3'
-//         ),
-//     },
-//   },
-//   async ({
-//     prompt,
-//     custom_design,
-//     custom_design_preview,
-//     custom_design_save_to,
-//   }) => {
-//     try {
-//       // 验证session状态
-//       const currentSession = await validateSession('pick-voice');
-//       const ai = currentSession.ai;
-//       if (custom_design) {
-//         if (!custom_design_preview) {
-//           throw new Error(
-//             'custom_design_preview is required when custom_design is true'
-//           );
-//         }
-//         const data = await currentSession.ai.voiceDesign({
-//           prompt,
-//           previewText: custom_design_preview,
-//         });
-//         if (data.voice_id) {
-//           const trial_audio = data.trial_audio;
-//           let uri = '';
-//           if (trial_audio) {
-//             uri = await saveMaterial(
-//               currentSession,
-//               trial_audio,
-//               custom_design_save_to || `custom_voice_${data.voice_id}.mp3`
-//             );
-//           }
-//           return {
-//             content: [
-//               {
-//                 type: 'text' as const,
-//                 text: JSON.stringify({
-//                   success: true,
-//                   ...data,
-//                   uri,
-//                   timestamp: new Date().toISOString(),
-//                 }),
-//               },
-//             ],
-//           };
-//         } else {
-//           throw new Error(`Voice design failed, ${JSON.stringify(data)}`);
-//         }
-//       }
-//       const data = await ai.pickVoice({ prompt });
-//       return {
-//         content: [
-//           {
-//             type: 'text' as const,
-//             text: JSON.stringify({
-//               success: true,
-//               ...data,
-//               timestamp: new Date().toISOString(),
-//             }),
-//           },
-//         ],
-//       };
-//     } catch (error) {
-//       return createErrorResponse(error, 'pick-voice');
-//     }
-//   }
-// );
 let lastEffect = '';
 server.registerTool('generate-video', {
     title: 'Generate Video',
@@ -2722,12 +1961,12 @@ server.registerTool('generate-video', {
     inputSchema: {
         prompt: zod_1.z
             .string()
-            .describe('The prompt to generate. 一般要严格对应 storyboard 中当前场景的 video_prompt 字段描述；传这个参数时，若跳过了一致性检查，记得保留镜头切换语言，如“切镜至第二镜头”这样的指令不应当省略。'),
+            .describe('The prompt to generate. 一般要严格对应 storyboard 中当前分镜的 video_prompt 字段描述；传这个参数时，若跳过了一致性检查，记得保留镜头切换语言，如“切镜至第二镜头”这样的指令不应当省略。'),
         sceneIndex: zod_1.z
             .number()
             .min(1)
             .optional()
-            .describe('场景索引，从1开始的下标，如果非场景对应素材，则可不传，场景素材必传'),
+            .describe('分镜索引，从1开始的下标，如果非分镜对应素材，则可不传，分镜素材必传'),
         storyBoardFile: zod_1.z
             .string()
             .optional()
@@ -2823,7 +2062,7 @@ server.registerTool('generate-video', {
             console.warn(`zero 模型的视频仅支持 1080p 分辨率，用户指定的分辨率为 %s，已自动将 ${resolution} 转换为 1080p`, resolution);
             resolution = '1080p';
         }
-        // 校验 prompt 与 storyboard.json 中场景设定的一致性以及视频时长与 timeline_analysis.json 中 proposed_video_scenes 的匹配
+        // 校验 prompt 与 storyboard.json 中分镜设定的一致性
         if (sceneIndex && !skipConsistencyCheck) {
             try {
                 const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
@@ -2845,7 +2084,7 @@ server.registerTool('generate-video', {
                                 return createErrorResponse('视频提示词必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
                             }
                             if (scene.is_continuous && !end_frame) {
-                                return createErrorResponse('连续场景必须指定end_frame参数，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
+                                return createErrorResponse('连续分镜必须指定end_frame参数，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
                             }
                             if (scene.video_duration != null &&
                                 duration !== scene.video_duration) {
@@ -2854,14 +2093,14 @@ server.registerTool('generate-video', {
                             if (storyBoard.voice_type &&
                                 storyBoard.voice_type !== 'slient') {
                                 if (mute) {
-                                    return createErrorResponse('有对话和旁白的场景不能静音，请将mute设为false再重新使用工具。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
+                                    return createErrorResponse('有对话和旁白的分镜不能静音，请将mute设为false再重新使用工具。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
                                 }
                             }
                             // 检查 use_video_model 与 type 参数的一致性
                             if (scene.use_video_model &&
                                 type &&
                                 scene.use_video_model !== type) {
-                                return createErrorResponse(`场景建议的视频模型(${scene.use_video_model})与传入的type参数(${type})不一致。请确保use_video_model与type参数值相同，或将skipConsistencyCheck设置为true后再次调用`, 'generate-video');
+                                return createErrorResponse(`分镜建议的视频模型(${scene.use_video_model})与传入的type参数(${type})不一致。请确保use_video_model与type参数值相同，或将skipConsistencyCheck设置为true后再次调用`, 'generate-video');
                             }
                         }
                         else {
@@ -2877,60 +2116,6 @@ server.registerTool('generate-video', {
                 console.error('Failed to validate prompt with story board:', error);
                 // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
             }
-            // 校验视频时长与 timeline_analysis.json 中 proposed_video_scenes 的匹配
-            try {
-                const timelineAnalysisPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'timeline_analysis.json');
-                if ((0, node_fs_1.existsSync)(timelineAnalysisPath)) {
-                    const timelineAnalysisContent = await (0, promises_1.readFile)(timelineAnalysisPath, 'utf8');
-                    const timelineAnalysis = JSON.parse(timelineAnalysisContent);
-                    if (timelineAnalysis.proposed_video_scenes &&
-                        Array.isArray(timelineAnalysis.proposed_video_scenes)) {
-                        const videoScene = timelineAnalysis.proposed_video_scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
-                        if (videoScene && videoScene.video_duration_s) {
-                            const expectedDuration = videoScene.video_duration_s;
-                            if (duration !== expectedDuration) {
-                                return createErrorResponse(`视频时长必须与timeline_analysis中的设定匹配。当前场景${videoScene.scene_id}要求时长为${expectedDuration}秒，但传入的duration为${duration}秒。请调整duration参数为${expectedDuration}秒后重试。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用。`, 'generate-video');
-                            }
-                        }
-                        else {
-                            console.warn(`Scene ${sceneIndex} (scene_${sceneIndex.toString().padStart(2, '0')}) not found in timeline_analysis.json proposed_video_scenes`);
-                        }
-                    }
-                }
-                else {
-                    // 检查音频时长标志
-                    try {
-                        const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
-                        if ((0, node_fs_1.existsSync)(storyBoardPath)) {
-                            const storyBoardContent = await (0, promises_1.readFile)(storyBoardPath, 'utf8');
-                            const storyBoard = JSON.parse(storyBoardContent);
-                            if (storyBoard.scenes && Array.isArray(storyBoard.scenes)) {
-                                const scene = storyBoard.scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
-                                if (scene &&
-                                    ((scene.script && scene.script.trim() !== '') ||
-                                        scene.dialog)) {
-                                    if (!checkAudioVideoDurationFlag) {
-                                        checkAudioVideoDurationFlag = true;
-                                        if (scene.audio_mode === 'vo_sync') {
-                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 storyboard 中视频时长为音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
-                                        }
-                                        else if (scene.audio_mode === 'dialogue') {
-                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 storyboard 中视频时长**不小于**音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    catch (error) {
-                        console.error('Failed to check audio duration flag:', error);
-                    }
-                }
-            }
-            catch (error) {
-                console.error('Failed to validate duration with timeline analysis:', error);
-                // 如果读取或解析 timeline_analysis.json 失败，继续执行但记录警告
-            }
         }
         const validatedFileName = validateFileName(saveToFileName);
         console.log(`Generating video with prompt: ${prompt.substring(0, 100)}...`);
@@ -3652,7 +2837,7 @@ server.registerTool('generate-video-by-ref', {
     inputSchema: {
         prompt: zod_1.z
             .string()
-            .describe('The prompt to generate video with or without reference images. 一般要严格对应 storyboard 中当前场景的 video_prompt 字段描述；传这个参数时，若跳过了一致性检查，记得保留镜头切换语言，如“切镜至第二镜头”这样的指令不应当省略。'),
+            .describe('The prompt to generate video with or without reference images. 一般要严格对应 storyboard 中当前分镜的 video_prompt 字段描述；传这个参数时，若跳过了一致性检查，记得保留镜头切换语言，如“切镜至第二镜头”这样的指令不应当省略。'),
         rewritePrompt: zod_1.z
             .boolean()
             .optional()
@@ -3713,7 +2898,7 @@ server.registerTool('generate-video-by-ref', {
             .number()
             .min(1)
             .optional()
-            .describe('场景索引，从1开始的下标，如果非场景对应素材，则可不传，场景素材必传'),
+            .describe('分镜索引，从1开始的下标，如果非分镜对应素材，则可不传，分镜素材必传'),
         storyBoardFile: zod_1.z
             .string()
             .optional()
@@ -3745,24 +2930,9 @@ server.registerTool('generate-video-by-ref', {
         const outlineSheetImagePath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'materials', 'outline_sheet.png');
         const hasOutlineSheet = (0, node_fs_1.existsSync)(outlineSheetImagePath);
         if (hasOutlineSheet && !skipConsistencyCheck) {
-            return createErrorResponse('如果提供了 outline_sheet.png，应采用 generate-video 图生视频。若用户明确要用参考生视频，则跳过一致性检查。', 'generate-video');
-        }
-        // 检查 storyboard 标志
-        if (!hasOutlineSheet &&
-            !checkStoryboardFlag &&
-            (0, node_fs_1.existsSync)(storyBoardPath)) {
-            checkStoryboardFlag = true;
-            return createErrorResponse(`必须先审查生成的 storyboard.json 内容，按照如下步骤：
-
-1. 确保每个场景中的stage_atmosphere内容按照规则被正确融合到video_prompt中，不得遗漏
-2. 如有main_characters设定且包含了reference_image，或有reference_objects，需确保video_prompt描述已包含该场景相关main_characters和所有reference_objects中的物品或背景，并确保参考图具体内容已经在video_prompt中有明确描述，如果没有，可忽略。
-3. 如有配音，先自我检查 media_logs 中的查音频时长，确保以匹配音频时长来生成视频
-
-检查完上述问题后先汇报，如果有需要，应当先修改 storyboard.json 内容，然后再调用 generate-video-by-ref 生成视频。注意修改 storyboard 内容时，仅修改相应字段的字符串值，不要破坏JSON格式！
-
-再次调用 generate-video-by-ref 时，如需要参考图，要确保referenceImages使用正确（main_characters中的reference_image作为参考人物，reference_objects中的image作为参考物品或参考背景）`, 'generate-image');
+            return createErrorResponse('监测到素材中存在outline_sheet.png这张图（由outline工具生成的），应采用 generate-video 图生视频。若用户明确要用参考生视频，则跳过一致性检查。', 'generate-video');
         }
-        // 校验 prompt 与 storyboard.json 中场景设定的一致性（如果提供了 sceneIndex）
+        // 校验 prompt 与 storyboard.json 中分镜设定的一致性（如果提供了 sceneIndex）
         if (!skipConsistencyCheck && sceneIndex) {
             try {
                 if ((0, node_fs_1.existsSync)(storyBoardPath)) {
@@ -3784,16 +2954,16 @@ server.registerTool('generate-video-by-ref', {
                             }
                             // 检查 scene.is_continuous 是否为 true
                             if (scene.is_continuous === true) {
-                                return createErrorResponse('连续镜头应使用首尾帧，请修改连续镜头设置，或将本场景改为首尾帧方式实现', 'generate-video-by-ref');
+                                return createErrorResponse('连续镜头应使用首尾帧，请修改连续镜头设置，或将本分镜改为首尾帧方式实现', 'generate-video-by-ref');
                             }
                             if (scene.video_type !== 'references') {
-                                return createErrorResponse(`场景 ${sceneIndex} 中的 video_type (${scene.video_type}) 未设置为 'references'，不应当使用参考生视频，请使用图生视频 generate-video 方式生成`, 'generate-video-by-ref');
+                                return createErrorResponse(`分镜 ${sceneIndex} 中的 video_type (${scene.video_type}) 未设置为 'references'，不应当使用参考生视频，请使用图生视频 generate-video 方式生成`, 'generate-video-by-ref');
                             }
                             // 检查 use_video_model 与 type 参数的一致性
                             if (scene.use_video_model &&
                                 type &&
                                 scene.use_video_model !== type) {
-                                return createErrorResponse(`场景 ${sceneIndex} 中的 use_video_model (${scene.use_video_model}) 必须与 type 参数 (${type}) 保持一致`, 'generate-video-by-ref');
+                                return createErrorResponse(`分镜 ${sceneIndex} 中的 use_video_model (${scene.use_video_model}) 必须与 type 参数 (${type}) 保持一致`, 'generate-video-by-ref');
                             }
                             // 检查 scene.references 的一致性
                             if (scene.references &&
@@ -3809,7 +2979,7 @@ server.registerTool('generate-video-by-ref', {
                                     const character = mainCharacters.find((char) => char.name === referenceName);
                                     if (character) {
                                         if (!character.reference_image) {
-                                            return createErrorResponse(`场景 ${sceneIndex} 中引用的角色 "${referenceName}" 在 main_characters 中没有 reference_image 属性`, 'generate-video-by-ref');
+                                            return createErrorResponse(`分镜 ${sceneIndex} 中引用的角色 "${referenceName}" 在 main_characters 中没有 reference_image 属性`, 'generate-video-by-ref');
                                         }
                                         requiredImage = character.reference_image;
                                         found = true;
@@ -3819,7 +2989,7 @@ server.registerTool('generate-video-by-ref', {
                                         const refObject = referenceObjects.find((obj) => obj.name === referenceName);
                                         if (refObject) {
                                             if (!refObject.image) {
-                                                return createErrorResponse(`场景 ${sceneIndex} 中引用的物品/背景 "${referenceName}" 在 reference_objects 中没有 image 属性`, 'generate-video-by-ref');
+                                                return createErrorResponse(`分镜 ${sceneIndex} 中引用的物品/背景 "${referenceName}" 在 reference_objects 中没有 image 属性`, 'generate-video-by-ref');
                                             }
                                             requiredImage = refObject.image;
                                             found = true;
@@ -3827,11 +2997,11 @@ server.registerTool('generate-video-by-ref', {
                                     }
                                     // 如果既不在 main_characters 也不在 reference_objects 中
                                     if (!found) {
-                                        return createErrorResponse(`场景 ${sceneIndex} 中引用的 "${referenceName}" 在 main_characters 或 reference_objects 中都找不到对应的定义`, 'generate-video-by-ref');
+                                        return createErrorResponse(`分镜 ${sceneIndex} 中引用的 "${referenceName}" 在 main_characters 或 reference_objects 中都找不到对应的定义`, 'generate-video-by-ref');
                                     }
                                     // 检查对应的图片是否在 referenceImages 参数中
                                     if (!referenceImages.some(ref => ref.fileName === requiredImage)) {
-                                        return createErrorResponse(`场景 ${sceneIndex} 中引用的 "${referenceName}" 对应的图片 "${requiredImage}" 不在 referenceImages 参数中，请确保传入正确的参考图片`, 'generate-video-by-ref');
+                                        return createErrorResponse(`分镜 ${sceneIndex} 中引用的 "${referenceName}" 对应的图片 "${requiredImage}" 不在 referenceImages 参数中，请确保传入正确的参考图片`, 'generate-video-by-ref');
                                     }
                                 }
                             }