cerevox 2.15.2 → 2.16.0

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":";AAy1HA,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) {
@@ -3046,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();