cerevox 2.15.1 → 2.16.0

package/dist/mcp/servers/prompts/image-prompt-optimizer.md

@@ -7,7 +7,7 @@
   - 微距镜头 -> Macro lens shot
   - 颗粒感 -> Grain
 - 提升文字准确率：如果提示词中有涉及要绘制的文字符号，确保它们使用中文引号“”引用。
-- 运用画面美学技巧时，优先使用词典中的技巧，但不要采用过度，对画面要表达的最核心内容有限采用2-3条画面美学技巧即可。
+- 运用画面美学技巧时，优先使用词典中的技巧，但不要采用过度，对画面要表达的最核心内容有限采用1、2条画面美学技巧即可。
 
 ## 有效词典
 
@@ -40,4 +40,29 @@ sisal | 亚麻绳 | 灯芯绒 | 亚麻布 | wicker | 竹编 | 棉花 | 草编 |
 ## 示例
 
 - 用户输入：一个穿着华丽服装的女孩，撑伞，林荫街道，油画般的细腻笔触使画面生动美好
-- 输出：一个女孩穿着华丽的服装，撑着遮阳伞走在林荫道上，莫奈油画风格
+- 输出：一个女孩穿着华丽的服装，撑着遮阳伞走在林荫道上，莫奈油画风格
+
+## 提取比喻
+
+你需要提取出提示词中用于比喻修辞的形容或主体、姿势动作描述，例如：
+  - "如晨曦般温柔",
+  - "像流星划过夜空",
+  - "似春风拂面",
+  - "像糖果梦境一样甜美",
+  - "如光影流转的诗"
+  - "呈抱球状"
+  - "呈弓步"
+  - "站如松"
+将它们放到metaphor_modifiers数组中输出
+
+## 输出
+
+输出 JSON 格式
+
+{
+  prompt_optimized: "优化后的提示词",
+  "metaphor_modifiers": [
+    "prompt_optimized中的比喻修饰词",
+    ...
+  ]
+}

package/dist/mcp/servers/prompts/rules/anime-series.md

@@ -67,6 +67,7 @@
 * 音色选择：使用`search-voices`筛选配音音色，匹配场景情感
 * 配音优先：先生成配音确定时长，再生成视频(视频时长=ceil(配音秒数)，3-16秒)
 * 时长控制：配音超16秒需简化台词或拆分场景
+  - 如简化台词，请务必先修改 story_board.json 中的 script 或 dialog 字段，确保生成语音时的一致性
 * 视频生成策略：
   - 默认优先使用`generate-video`生成动态视频
   - 除非用户指定使用kenburns方案，否则仅在`generate-video`多次失败时使用`generate-video-kenburns`作为回退方案

package/dist/mcp/servers/prompts/rules/general-video.md

@@ -67,6 +67,7 @@
 * 音色选择：使用`search-voices`筛选配音音色，匹配场景情感
 * 配音优先：先生成配音确定时长，再生成视频(视频时长=ceil(配音秒数)，3-16秒)
 * 时长控制：配音超16秒需简化台词或拆分场景
+  - 如简化台词，请务必先修改 story_board.json 中的 script 或 dialog 字段，确保生成语音时的一致性
 * 视频生成策略：
   - 默认优先使用`generate-video`生成动态视频
   - 除非用户指定使用kenburns方案，否则仅在`generate-video`多次失败时使用`generate-video-kenburns`作为回退方案

package/dist/mcp/servers/prompts/zerocut-core.md

@@ -285,6 +285,8 @@ projects/<id>/
 
 3. 镜头自然延伸：这是一种和“一镜到底”不同的连续画面技术，当用户说“镜头自然延伸”时，你应当在生成视频时，设置saveLastFrameAs参数，将其返回的图片作为下一场景的首帧图片，不断延伸直至所有场景生成完成。如果你采用镜头自然延伸，那么你只需要设置第一个场景的start_frame，在story_board中其余场景可标记不需要start_frame，后续不断生成各场景视频，同时保存下一场景start_frame即可。
 
+4. 手工修改草稿：在 draft_content 生成后，如果用户要求自行修改草稿，可运行 `custom-edit-draft` 工具（这个工具是本地工具，不需要先启动会话），启动服务让用户自行修改草稿。
+
 ---
 
 ## 工具优先级

package/dist/mcp/servers/zerocut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zerocut.d.ts","sourceRoot":"","sources":["../../../src/mcp/servers/zerocut.ts"],"names":[],"mappings":";AAm0HA,wBAAsB,GAAG,kBAKxB"}
+{"version":3,"file":"zerocut.d.ts","sourceRoot":"","sources":["../../../src/mcp/servers/zerocut.ts"],"names":[],"mappings":";AAukIA,wBAAsB,GAAG,kBAKxB"}

package/dist/mcp/servers/zerocut.js

@@ -53,7 +53,51 @@ const node_path_1 = __importStar(require("node:path"));
 const doubao_voices_full_1 = require("./helper/doubao_voices_full");
 const node_fs_1 = require("node:fs");
 const coze_1 = require("../../utils/coze");
+const node_http_1 = __importDefault(require("node:http"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
 // 错误处理工具函数
+const handleError = (error) => {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+};
+// 检查端口是否被占用
+const isPortInUse = async (port) => {
+    try {
+        const { stdout } = await execAsync(`lsof -ti:${port}`);
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+};
+// 停止占用端口的进程
+const killPortProcess = async (port) => {
+    try {
+        const { stdout } = await execAsync(`lsof -ti:${port}`);
+        const pids = stdout
+            .trim()
+            .split('\n')
+            .filter(pid => pid);
+        for (const pid of pids) {
+            try {
+                await execAsync(`kill -9 ${pid}`);
+                console.log(`Killed process ${pid} on port ${port}`);
+            }
+            catch (error) {
+                console.warn(`Failed to kill process ${pid}:`, error);
+            }
+        }
+        // 等待一下确保进程被杀死
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    catch (error) {
+        console.warn(`Failed to kill processes on port ${port}:`, error);
+    }
+};
 function createErrorResponse(error, operation) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     console.error(`[${operation}] Error:`, error);
@@ -841,13 +885,13 @@ server.registerTool('generate-image', {
     },
 }, async ({ prompt, sceneIndex, storyBoardFile = 'story_board.json', skipConsistencyCheck = false, size, saveToFileName, watermark, referenceImages, optimizePrompt, }) => {
     try {
+        // 验证session状态
+        const currentSession = await validateSession('generate-image');
         // 检查 storyboard 标志
         if (!checkStoryboardFlag) {
             checkStoryboardFlag = true;
             return createErrorResponse('必须先审查生成的 story_board.json 内容，确保每个场景中的stage_atmosphere内容按照规则被正确融合到start_frame和video_prompt中，不得遗漏，检查完成后先汇报，如果有问题，应当先修改 story_board.json 内容，然后再调用 generate-image 生成图片', 'generate-image');
         }
-        // 验证session状态
-        const currentSession = await validateSession('generate-image');
         const validatedFileName = validateFileName(saveToFileName);
         // 校验 prompt 与 story_board.json 中场景设定的一致性
         if (!skipConsistencyCheck) {
@@ -888,7 +932,7 @@ server.registerTool('generate-image', {
                 const ai = currentSession.ai;
                 const promptOptimizer = await (0, promises_1.readFile)((0, node_path_1.resolve)(__dirname, './prompts/image-prompt-optimizer.md'), 'utf8');
                 const completion = await ai.getCompletions({
-                    model: 'Doubao-Seed-1.6',
+                    model: 'Doubao-Seed-1.6-flash',
                     messages: [
                         {
                             role: 'system',
@@ -900,9 +944,30 @@ server.registerTool('generate-image', {
                         },
                     ],
                 });
-                const optimizedPrompt = completion.choices[0]?.message?.content;
+                let optimizedPrompt = completion.choices[0]?.message?.content.trim();
                 if (optimizedPrompt) {
-                    processedPrompt = optimizedPrompt;
+                    if (optimizedPrompt.startsWith('```json')) {
+                        // 提取 JSON 代码块中的内容
+                        const jsonMatch = optimizedPrompt.match(/```json\s*([\s\S]*?)\s*```/);
+                        if (jsonMatch && jsonMatch[1]) {
+                            optimizedPrompt = jsonMatch[1];
+                        }
+                    }
+                    if (optimizedPrompt.startsWith('{')) {
+                        try {
+                            const { prompt_optimized, metaphor_modifiers } = JSON.parse(optimizedPrompt);
+                            processedPrompt = `${prompt_optimized}`;
+                            if (metaphor_modifiers?.length) {
+                                processedPrompt += `\n\n注意：下面这些是形象比喻，并不是输出内容。\n${metaphor_modifiers}`;
+                            }
+                        }
+                        catch (ex) {
+                            processedPrompt = optimizedPrompt;
+                        }
+                    }
+                    else {
+                        processedPrompt = optimizedPrompt;
+                    }
                 }
             }
             catch (error) {
@@ -3025,6 +3090,160 @@ server.registerTool('run-ffmpeg-command', {
         return createErrorResponse(error, 'run-ffmpeg-command');
     }
 });
+server.registerTool('custom-edit-draft', {
+    title: 'Custom Edit Draft',
+    description: 'Launch timeline editor server for custom draft editing. Starts a local server at specified port with draft file configuration.',
+    inputSchema: {
+        draftContentFileName: zod_1.z
+            .string()
+            .optional()
+            .default('draft_content.json')
+            .describe('Draft content filename (default: draft_content.json)'),
+        port: zod_1.z
+            .number()
+            .optional()
+            .default(6789)
+            .describe('Server port (default: 6789)'),
+    },
+}, async ({ draftContentFileName = 'draft_content.json', port = 6789 }) => {
+    try {
+        // 使用项目本地目录
+        const workDir = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir);
+        // 检查 draft_content.json 文件是否存在
+        const draftFilePath = (0, node_path_1.resolve)(workDir, draftContentFileName);
+        if (!(0, node_fs_1.existsSync)(draftFilePath)) {
+            return createErrorResponse(new Error(`Draft content file not found: ${draftContentFileName}. Please generate draft content first using the generate-draft-content tool.`), 'custom-edit-draft');
+        }
+        // 备份原始的 draft_content.json 文件
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupFileName = `${draftContentFileName}.backup.${timestamp}`;
+        const backupFilePath = (0, node_path_1.resolve)(workDir, backupFileName);
+        try {
+            const { copyFileSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+            copyFileSync(draftFilePath, backupFilePath);
+            console.log(`Draft file backed up to: ${backupFileName}`);
+        }
+        catch (backupError) {
+            console.warn(`Failed to backup draft file: ${backupError}`);
+            // 继续执行，不因备份失败而中断
+        }
+        // 构建启动命令参数
+        const timelineEditorPath = (0, node_path_1.resolve)(__dirname, '../../../dist/timeline-editor/index.js');
+        console.log(`Starting timeline editor server...`);
+        console.log(`Working directory: ${workDir}`);
+        console.log(`Draft file: ${draftContentFileName}`);
+        console.log(`Server port: ${port}`);
+        console.log(`Timeline editor path: ${timelineEditorPath}`);
+        // 检查端口是否被占用，如果被占用则停止占用的进程
+        if (await isPortInUse(port)) {
+            console.log(`Port ${port} is in use, killing existing processes...`);
+            await killPortProcess(port);
+        }
+        // 直接启动服务器进程
+        const serverProcess = (0, node_child_process_1.spawn)('node', [
+            timelineEditorPath,
+            '--draft-file',
+            draftContentFileName,
+            '--project-dir',
+            workDir,
+            '--port',
+            port.toString(),
+        ], {
+            cwd: workDir,
+            stdio: 'pipe',
+        });
+        const serverUrl = `http://localhost:${port}`;
+        // 等待服务器启动 - 使用健康检查 API 轮询
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Server startup timeout'));
+            }, 30000); // 增加超时时间到30秒
+            const checkHealth = async () => {
+                try {
+                    const healthUrl = `${serverUrl}/health`;
+                    const req = node_http_1.default.get(healthUrl, (res) => {
+                        let data = '';
+                        res.on('data', (chunk) => {
+                            data += chunk;
+                        });
+                        res.on('end', () => {
+                            try {
+                                const healthData = JSON.parse(data);
+                                if (healthData.status === 'ok') {
+                                    clearTimeout(timeout);
+                                    console.log('Server health check passed');
+                                    resolve(void 0);
+                                }
+                                else {
+                                    // 继续轮询
+                                    setTimeout(checkHealth, 1000);
+                                }
+                            }
+                            catch (parseError) {
+                                // 继续轮询
+                                setTimeout(checkHealth, 1000);
+                            }
+                        });
+                    });
+                    req.on('error', () => {
+                        // 服务器还未启动，继续轮询
+                        setTimeout(checkHealth, 1000);
+                    });
+                    req.setTimeout(2000, () => {
+                        req.destroy();
+                        // 继续轮询
+                        setTimeout(checkHealth, 1000);
+                    });
+                }
+                catch (error) {
+                    // 继续轮询
+                    setTimeout(checkHealth, 1000);
+                }
+            };
+            serverProcess.stdout?.on('data', (data) => {
+                console.log('Server output:', data.toString());
+            });
+            serverProcess.stderr?.on('data', (data) => {
+                console.error('Server error:', data.toString());
+            });
+            serverProcess.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+            // 开始健康检查轮询
+            setTimeout(checkHealth, 2000); // 2秒后开始第一次检查
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        message: 'Timeline editor server started successfully',
+                        serverUrl: serverUrl,
+                        draftFile: draftContentFileName,
+                        backupFile: backupFileName,
+                        projectDirectory: workDir,
+                        port: port,
+                        pid: serverProcess.pid,
+                        instructions: [
+                            `Timeline editor is now running at: ${serverUrl}`,
+                            'Open the URL in your browser to edit the draft',
+                            'The server will automatically save changes to the draft file',
+                            `Original draft file has been backed up as: ${backupFileName}`,
+                            `Server process ID: ${serverProcess.pid}`,
+                            'The server will continue running in the background',
+                        ],
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error('Error starting timeline editor:', error);
+        return createErrorResponse(error, 'custom-edit-draft');
+    }
+});
 async function run() {
     // Start receiving messages on stdin and sending messages on stdout
     const transport = new stdio_js_1.StdioServerTransport();