mulmocast 0.0.24 → 0.0.26

package/README.md

@@ -103,6 +103,14 @@ GOOGLE_PROJECT_ID=your_google_project_id
 
 See also [pre-requisites for Google's image generation model](./docs/pre-requisites-google.md)
 
+#### (Optional) For AI providers
+```bash
+# For Anthropic Claude (htmlPrompt feature)
+ANTHROPIC_API_TOKEN=your_anthropic_api_token
+```
+
+For htmlPrompt configuration, see [docs/image.md](./docs/image.md#2-htmlprompt).
+
 #### (Optional) For Movie models
 ```bash
 REPLICATE_API_TOKEN=your_replicate_api_key

package/lib/actions/images.js

@@ -77,6 +77,9 @@ export const imagePluginAgent = async (namedInputs) => {
 };
 const htmlImageGeneratorAgent = async (namedInputs) => {
     const { html, file, canvasSize } = namedInputs;
+    // Save HTML file
+    const htmlFile = file.replace(/\.[^/.]+$/, ".html");
+    await fs.promises.writeFile(htmlFile, html, "utf8");
     await renderHTMLToImage(html, file, canvasSize.width, canvasSize.height);
 };
 const beat_graph_data = {
@@ -115,12 +118,13 @@ const beat_graph_data = {
             if: ":preprocessor.htmlPrompt",
             defaultValue: {},
             agent: ":htmlImageAgentInfo.agent",
-            params: {
-                mode: ":htmlImageAgentInfo.model",
-            },
             inputs: {
                 prompt: ":preprocessor.htmlPrompt",
                 system: ":preprocessor.htmlImageSystemPrompt",
+                params: {
+                    model: ":htmlImageAgentInfo.model",
+                    max_tokens: ":htmlImageAgentInfo.max_tokens",
+                },
             },
         },
         htmlImageGenerator: {

package/lib/cli/commands/tool/scripting/builder.d.ts

@@ -16,7 +16,7 @@ export declare const builder: (yargs: Argv) => Argv<{
 } & {
     s: string;
 } & {
-    llm: "anthropic" | "openAI" | "gemini" | "groq" | undefined;
+    llm: "openai" | "anthropic" | "gemini" | "groq" | undefined;
 } & {
     llm_model: string | undefined;
 }>;

package/lib/cli/commands/tool/story_to_script/builder.d.ts

@@ -10,7 +10,7 @@ export declare const builder: (yargs: Argv) => Argv<{
 } & {
     beats_per_scene: number;
 } & {
-    llm: "anthropic" | "openAI" | "gemini" | "groq" | undefined;
+    llm: "openai" | "anthropic" | "gemini" | "groq" | undefined;
 } & {
     llm_model: string | undefined;
 } & {

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/methods/mulmo_presentation_style.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { userAssert } from "../utils/utils.js";
+import { userAssert, llmConfig } from "../utils/utils.js";
 import { text2ImageProviderSchema, text2HtmlImageProviderSchema, text2SpeechProviderSchema, mulmoCanvasDimensionSchema } from "../types/schema.js";
 import { defaultOpenAIImageModel } from "../utils/const.js";
 const defaultTextSlideStyles = [
@@ -72,16 +72,13 @@ export const MulmoPresentationStyleMethods = {
     },
     getHtmlImageAgentInfo(presentationStyle) {
         const provider = text2HtmlImageProviderSchema.parse(presentationStyle.htmlImageParams?.provider);
-        const agent = provider === "anthropic" ? "anthropicAgent" : "openAIAgent";
-        const model = presentationStyle.htmlImageParams?.model
-            ? presentationStyle.htmlImageParams?.model
-            : provider === "anthropic"
-                ? "claude-3-7-sonnet-20250219"
-                : "gpt-4o-mini";
+        const defaultConfig = llmConfig[provider];
+        const model = presentationStyle.htmlImageParams?.model ? presentationStyle.htmlImageParams?.model : defaultConfig.defaultModel;
         return {
             provider,
-            agent,
+            agent: defaultConfig.agent,
             model,
+            max_tokens: defaultConfig.max_tokens,
         };
     },
     getImageType(_, beat) {

package/lib/types/type.d.ts

@@ -83,6 +83,7 @@ export type Text2HtmlAgentInfo = {
     provider: Text2HtmlImageProvider;
     agent: string;
     model: string;
+    max_tokens: number;
 };
 export type BeatMediaType = "movie" | "image";
 export type StoryToScriptGenerateMode = (typeof storyToScriptGenerateMode)[keyof typeof storyToScriptGenerateMode];

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/lib/utils/prompt.js

@@ -128,7 +128,7 @@ export const htmlImageSystemPrompt = (canvasSize) => {
     return [
         "Based on the provided information, create a single slide HTML page using Tailwind CSS.",
         `The view port size is ${canvasSize.width}x${canvasSize.height}. Make sure the HTML fits within the view port.`,
-        "If charts are needed, use Chart.js to present them in a clean and visually appealing way.",
+        "If charts are needed, use Chart.js to present them in a clean and visually appealing way (with animation:false to disable animation).",
         "Include a balanced mix of comments, graphs, and illustrations to enhance visual impact.",
         "Output only the HTML code. Do not include any comments, explanations, or additional information outside the HTML.",
         "If data is provided, use it effectively to populate the slide.",

package/lib/utils/utils.d.ts

@@ -1,6 +1,6 @@
 import { MulmoBeat, MulmoStudioMultiLingualData } from "../types/index.js";
 import type { ConfigDataDictionary, DefaultConfigData } from "graphai";
-export declare const llm: readonly ["openAI", "anthropic", "gemini", "groq"];
+export declare const llm: readonly ["openai", "anthropic", "gemini", "groq"];
 export type LLM = (typeof llm)[number];
 export declare const llmConfig: Record<LLM, {
     agent: string;

package/lib/utils/utils.js

@@ -1,7 +1,7 @@
 import * as crypto from "crypto";
-export const llm = ["openAI", "anthropic", "gemini", "groq"];
+export const llm = ["openai", "anthropic", "gemini", "groq"];
 export const llmConfig = {
-    openAI: {
+    openai: {
         agent: "openAIAgent",
         defaultModel: "gpt-4o",
         max_tokens: 8192,
@@ -23,10 +23,10 @@ export const llmConfig = {
     },
 };
 export const llmPair = (_llm, _model) => {
-    const llmKey = _llm ?? "openAI";
-    const agent = llmConfig[llmKey]?.agent ?? llmConfig.openAI.agent;
-    const model = _model ?? llmConfig[llmKey]?.defaultModel ?? llmConfig.openAI.defaultModel;
-    const max_tokens = llmConfig[llmKey]?.max_tokens ?? llmConfig.openAI.max_tokens;
+    const llmKey = _llm ?? "openai";
+    const agent = llmConfig[llmKey]?.agent ?? llmConfig.openai.agent;
+    const model = _model ?? llmConfig[llmKey]?.defaultModel ?? llmConfig.openai.defaultModel;
+    const max_tokens = llmConfig[llmKey]?.max_tokens ?? llmConfig.openai.max_tokens;
     return { agent, model, max_tokens };
 };
 export const chunkArray = (array, size = 3) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mulmocast",
-  "version": "0.0.24",
+  "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,22 +69,23 @@
     "@graphai/stream_agent_filter": "^2.0.2",
     "@graphai/vanilla": "^2.0.4",
     "@graphai/vanilla_node_agents": "^2.0.1",
-    "@tavily/core": "^0.5.7",
-    "canvas": "^3.1.0",
+    "@modelcontextprotocol/sdk": "^1.13.1",
+    "@tavily/core": "^0.5.8",
+    "canvas": "^3.1.2",
     "clipboardy": "^4.0.0",
-    "dotenv": "^16.4.7",
+    "dotenv": "^17.0.0",
     "fluent-ffmpeg": "^2.1.3",
     "google-auth-library": "^9.15.1",
     "graphai": "^2.0.9",
-    "inquirer": "^12.6.1",
+    "inquirer": "^12.6.3",
     "marked": "^15.0.12",
     "ora": "^8.2.0",
-    "puppeteer": "^24.10.2",
+    "puppeteer": "^24.11.0",
     "replicate": "^1.0.1",
     "yaml": "^2.8.0",
     "yargs": "^17.7.2",
     "zod": "^3.25.67",
-    "zod-to-json-schema": "^3.24.5"
+    "zod-to-json-schema": "^3.24.6"
   },
   "devDependencies": {
     "@anatine/zod-mock": "^3.14.0",
@@ -91,14 +93,14 @@
     "@receptron/test_utils": "^2.0.0",
     "@types/fluent-ffmpeg": "^2.1.26",
     "@types/yargs": "^17.0.33",
-    "eslint": "^9.29.0",
+    "eslint": "^9.30.0",
     "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-prettier": "^5.5.0",
-    "prettier": "^3.3.3",
+    "eslint-plugin-prettier": "^5.5.1",
+    "prettier": "^3.6.2",
     "ts-node": "^10.9.2",
     "tsx": "^4.20.3",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.34.1"
+    "typescript-eslint": "^8.35.0"
   },
   "engines": {
     "node": ">=18.0.0"