mulmocast 0.0.25 → 0.0.26

package/lib/cli/helpers.js

@@ -2,7 +2,7 @@ import { GraphAILogger } from "graphai";
 import fs from "fs";
 import path from "path";
 import clipboardy from "clipboardy";
-import { getBaseDirPath, getFullPath, readMulmoScriptFile, fetchMulmoScriptFile, getOutputStudioFilePath, resolveDirPath, mkdir, getOutputMultilingualFilePath, } from "../utils/file.js";
+import { getBaseDirPath, getFullPath, readMulmoScriptFile, fetchMulmoScriptFile, getOutputStudioFilePath, resolveDirPath, mkdir, getOutputMultilingualFilePath, generateTimestampedFileName, } from "../utils/file.js";
 import { isHttp } from "../utils/utils.js";
 import { createOrUpdateStudioData } from "../utils/preprocess.js";
 import { outDirName, imageDirName, audioDirName } from "../utils/const.js";
@@ -29,9 +29,7 @@ export const getFileObject = (args) => {
     const { fileOrUrl, fileName } = (() => {
         if (file === "__clipboard") {
             // We generate a new unique script file from clipboard text in the output directory
-            const now = new Date();
-            const pad = (n) => n.toString().padStart(2, "0");
-            const fileName = `script_${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}_${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+            const fileName = generateTimestampedFileName("script");
             const clipboardText = clipboardy.readSync();
             const fileOrUrl = resolveDirPath(outDirPath, `${fileName}.json`);
             mkdir(outDirPath);

package/lib/mcp/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/lib/mcp/server.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { GraphAILogger } from "graphai";
+import { audio, images, movie, captions, pdf } from "../actions/index.js";
+import { initializeContext, runTranslateIfNeeded } from "../cli/helpers.js";
+import { outDirName } from "../utils/const.js";
+import { resolveDirPath, mkdir, generateTimestampedFileName } from "../utils/file.js";
+import { mulmoScriptSchema } from "../types/schema.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Load MulmoScript JSON Schema from file
+const MULMO_SCRIPT_JSON_SCHEMA = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../../assets/schemas/html_prompt.json"), "utf8"));
+const server = new Server({
+    name: "mulmocast-mcp",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Helper function to save MulmoScript content to output directory
+const saveMulmoScriptToOutput = async (mulmoScript) => {
+    const baseDirPath = process.cwd();
+    const outputDirPath = path.resolve(baseDirPath, outDirName);
+    // Create timestamp-based filename similar to __clipboard handling
+    const fileName = generateTimestampedFileName("mcp_script");
+    // Ensure output directory exists
+    mkdir(outputDirPath);
+    // Save MulmoScript to file
+    const filePath = resolveDirPath(outputDirPath, `${fileName}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(mulmoScript, null, 2), "utf8");
+    return filePath;
+};
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "generate",
+                description: "Generate movie or PDF from MulmoScript content",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cmd: {
+                            type: "string",
+                            enum: ["movie", "pdf"],
+                            description: "Command to execute: 'movie' to generate video, 'pdf' to generate PDF",
+                        },
+                        mulmoScript: MULMO_SCRIPT_JSON_SCHEMA,
+                        options: {
+                            type: "object",
+                            description: "Optional generation parameters",
+                            properties: {
+                                pdfMode: { type: "string", enum: ["slide", "talk", "handout"], description: "PDF generation mode (for PDF only)" },
+                                pdfSize: { type: "string", enum: ["A4", "Letter", "Legal"], description: "PDF page size (for PDF only)" },
+                                lang: { type: "string", description: "Language for translation" },
+                                caption: { type: "string", description: "Caption language" },
+                                force: { type: "boolean", description: "Force regeneration" },
+                                verbose: { type: "boolean", description: "Enable verbose logging" },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                    required: ["cmd", "mulmoScript"],
+                    additionalProperties: false,
+                },
+            },
+        ],
+    };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        if (name !== "generate") {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        const { cmd, mulmoScript, options = {}, } = args;
+        // Validate MulmoScript schema
+        const validatedScript = mulmoScriptSchema.parse(mulmoScript);
+        // Save MulmoScript to output directory
+        const filePath = await saveMulmoScriptToOutput(validatedScript);
+        // Create argv-like object for CLI compatibility
+        const argv = {
+            file: filePath,
+            l: options.lang,
+            c: options.caption,
+            f: options.force || false,
+            v: options.verbose || false,
+            pdf_mode: options.pdfMode || "handout",
+            pdf_size: options.pdfSize || "Letter",
+            _: [],
+            $0: "mcp-server",
+        };
+        // Initialize context using the saved file
+        const context = await initializeContext(argv);
+        if (!context) {
+            throw new Error("Failed to initialize context from MulmoScript");
+        }
+        // Run translation if needed
+        await runTranslateIfNeeded(context, argv);
+        // Execute the requested command
+        switch (cmd) {
+            case "movie":
+                // Generate movie (audio + images + captions + movie)
+                await audio(context).then(images).then(captions).then(movie);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Movie generated successfully from MulmoScript. Output saved to: ${context.fileDirs.outDirPath}`,
+                        },
+                    ],
+                };
+            case "pdf":
+                // Generate images first, then PDF
+                await images(context);
+                await pdf(context, options.pdfMode || "handout", options.pdfSize || "Letter");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `PDF generated successfully from MulmoScript. Output saved to: ${context.fileDirs.outDirPath}`,
+                        },
+                    ],
+                };
+            default:
+                throw new Error(`Unknown command: ${cmd}. Supported commands: movie, pdf`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    GraphAILogger.error("MulmoCast MCP Server running on stdio");
+}
+main().catch((error) => {
+    GraphAILogger.error("Failed to start MCP server:", error);
+    process.exit(1);
+});

package/lib/utils/file.d.ts

@@ -41,3 +41,4 @@ export declare const readTemplatePrompt: (templateName: string) => string;
 export declare const getAvailableTemplates: () => MulmoScriptTemplateFile[];
 export declare const writingMessage: (filePath: string) => void;
 export declare const readAndParseJson: <S extends ZodSchema<any>>(filePath: string, schema: S) => ReturnType<S["parse"]>;
+export declare const generateTimestampedFileName: (prefix: string) => string;

package/lib/utils/file.js

@@ -182,3 +182,8 @@ export const readAndParseJson = (filePath, schema) => {
     const json = JSON.parse(fileContent);
     return schema.parse(json);
 };
+export const generateTimestampedFileName = (prefix) => {
+    const now = new Date();
+    const pad = (n) => n.toString().padStart(2, "0");
+    return `${prefix}_${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}_${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mulmocast",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "",
   "type": "module",
   "main": "lib/index.js",
@@ -48,7 +48,8 @@
     "latest": "yarn upgrade-interactive  --latest",
     "format": "prettier --write '{src,scripts,assets/templates,assets/styles,draft,ideason,scripts_mag2,proto,test,graphai,output,docs/scripts}/**/*.{ts,json,yaml}'",
     "deep_research": "npx tsx ./src/tools/deep_research.ts",
-    "fake_data": "npx tsx test/fake/sample.ts"
+    "fake_data": "npx tsx test/fake/sample.ts",
+    "mcp_server": "npx tsx ./src/mcp/server.ts"
   },
   "repository": "git+ssh://git@github.com/receptron/mulmocast-cli.git",
   "author": "snakajima",
@@ -68,6 +69,7 @@
     "@graphai/stream_agent_filter": "^2.0.2",
     "@graphai/vanilla": "^2.0.4",
     "@graphai/vanilla_node_agents": "^2.0.1",
+    "@modelcontextprotocol/sdk": "^1.13.1",
     "@tavily/core": "^0.5.8",
     "canvas": "^3.1.2",
     "clipboardy": "^4.0.0",