mulmocast 0.0.14 → 0.0.15

package/lib/actions/pdf.js

@@ -1,231 +1,161 @@
 import fs from "fs";
 import path from "path";
-import { rgb, PDFDocument } from "pdf-lib";
-import fontkit from "@pdf-lib/fontkit";
-import { chunkArray, isHttp, localizedText } from "../utils/utils.js";
-import { getOutputPdfFilePath, writingMessage } from "../utils/file.js";
+import puppeteer from "puppeteer";
 import { MulmoScriptMethods } from "../methods/index.js";
-import { fontSize, textMargin, drawSize, wrapText } from "../utils/pdf.js";
+import { localizedText, isHttp } from "../utils/utils.js";
+import { getOutputPdfFilePath, writingMessage, getHTMLFile } from "../utils/file.js";
+import { interpolate } from "../utils/markdown.js";
 import { MulmoStudioContextMethods } from "../methods/mulmo_studio_context.js";
-const imagesPerPage = 4;
-const offset = 10;
-const handoutImageRatio = 0.5;
-const readImage = async (imagePath, pdfDoc) => {
-    const imageBytes = await (async () => {
-        if (isHttp(imagePath)) {
-            const res = await fetch(imagePath);
-            const arrayBuffer = await res.arrayBuffer();
-            return Buffer.from(arrayBuffer);
-        }
-        return fs.readFileSync(imagePath);
-    })();
-    const ext = path.extname(imagePath).toLowerCase();
-    if (ext === ".jpg" || ext === ".jpeg") {
-        return await pdfDoc.embedJpg(imageBytes);
-    }
-    if (ext === ".png") {
-        return await pdfDoc.embedPng(imageBytes);
-    }
-    // workaround. TODO: movie, image should convert to png/jpeg image
-    return await pdfDoc.embedPng(fs.readFileSync("assets/images/mulmocast_credit.png"));
+const isCI = process.env.CI === "true";
+const getPdfSize = (pdfSize) => {
+    return pdfSize === "a4" ? "A4" : "Letter";
 };
-const pdfSlide = async (pageWidth, pageHeight, imagePaths, pdfDoc) => {
-    const cellRatio = pageHeight / pageWidth;
-    for (const imagePath of imagePaths) {
-        const image = await readImage(imagePath, pdfDoc);
-        const { width: origWidth, height: origHeight } = image.scale(1);
-        const originalRatio = origHeight / origWidth;
-        const fitWidth = originalRatio / cellRatio < 1;
-        const { drawWidth, drawHeight } = drawSize(fitWidth, pageWidth, pageHeight, origWidth, origHeight);
-        const page = pdfDoc.addPage([pageWidth, pageHeight]);
-        page.drawImage(image, {
-            x: 0,
-            y: 0,
-            width: drawWidth,
-            height: drawHeight,
-        });
+const loadImage = async (imagePath) => {
+    try {
+        const imageData = isHttp(imagePath) ? Buffer.from(await (await fetch(imagePath)).arrayBuffer()) : fs.readFileSync(imagePath);
+        const ext = path.extname(imagePath).toLowerCase().replace(".", "");
+        const mimeType = ext === "jpg" ? "jpeg" : ext;
+        return `data:image/${mimeType};base64,${imageData.toString("base64")}`;
     }
-};
-const pdfTalk = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc, font) => {
-    const imageRatio = 0.7;
-    const textMargin = 8;
-    const textY = pageHeight * (1 - imageRatio) - textMargin;
-    const targetWidth = pageWidth - offset;
-    const targetHeight = pageHeight * imageRatio - offset;
-    const cellRatio = targetHeight / targetWidth;
-    for (const [index, imagePath] of imagePaths.entries()) {
-        const text = texts[index];
-        const image = await readImage(imagePath, pdfDoc);
-        const { width: origWidth, height: origHeight } = image.scale(1);
-        const originalRatio = origHeight / origWidth;
-        const fitWidth = originalRatio / cellRatio < 1;
-        const { drawWidth, drawHeight } = drawSize(fitWidth, targetWidth, targetHeight, origWidth, origHeight);
-        const x = (pageWidth - drawWidth) / 2;
-        const y = pageHeight - drawHeight - offset;
-        const page = pdfDoc.addPage([pageWidth, pageHeight]);
-        const pos = {
-            x,
-            y,
-            width: drawWidth,
-            height: drawHeight,
-        };
-        page.drawImage(image, pos);
-        page.drawRectangle({
-            ...pos,
-            borderColor: rgb(0, 0, 0),
-            borderWidth: 1,
-        });
-        const lines = wrapText(text, font, fontSize, pageWidth - textMargin * 2);
-        for (const [index, line] of lines.entries()) {
-            page.drawText(line, {
-                x: textMargin,
-                y: textY - fontSize - (fontSize + 2) * index,
-                size: fontSize,
-                color: rgb(0, 0, 0),
-                maxWidth: pageWidth - 2 * textMargin,
-                font,
-            });
-        }
+    catch (__error) {
+        const placeholderData = fs.readFileSync("assets/images/mulmocast_credit.png");
+        return `data:image/png;base64,${placeholderData.toString("base64")}`;
     }
 };
-const pdfHandout = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc, font, isLandscapeImage) => {
-    const cellRatio = (pageHeight / imagesPerPage - offset) / (pageWidth * handoutImageRatio - offset);
-    let index = 0;
-    for (const chunkPaths of chunkArray(imagePaths, imagesPerPage)) {
-        const page = pdfDoc.addPage([pageWidth, pageHeight]);
-        for (let i = 0; i < chunkPaths.length; i++) {
-            const imagePath = chunkPaths[i];
-            const image = await readImage(imagePath, pdfDoc);
-            const { width: origWidth, height: origHeight } = image.scale(1);
-            const originalRatio = origHeight / origWidth;
-            const fitWidth = originalRatio / cellRatio < 1;
-            const pos = (() => {
-                if (isLandscapeImage) {
-                    const cellHeight = pageHeight / imagesPerPage - offset;
-                    const { drawWidth, drawHeight, containerWidth } = drawSize(fitWidth, (pageWidth - offset) * handoutImageRatio, cellHeight - offset, origWidth, origHeight);
-                    const x = offset + (containerWidth - drawWidth) / 2;
-                    const y = pageHeight - (i + 1) * cellHeight + (cellHeight - drawHeight) * handoutImageRatio;
-                    return {
-                        x,
-                        y,
-                        width: drawWidth,
-                        height: drawHeight,
-                        containerWidth,
-                    };
-                }
-                else {
-                    const cellWidth = pageWidth / imagesPerPage;
-                    const { drawWidth, drawHeight, containerWidth } = drawSize(fitWidth, cellWidth - offset, (pageHeight - offset) * handoutImageRatio, origWidth, origHeight);
-                    const x = pageWidth - (imagesPerPage - i) * cellWidth + (cellWidth - drawWidth) * handoutImageRatio;
-                    const y = pageHeight - drawHeight - offset;
-                    return {
-                        x,
-                        y,
-                        width: drawWidth,
-                        height: drawHeight,
-                        containerWidth,
-                    };
-                }
-            })();
-            page.drawRectangle({
-                ...pos,
-                borderColor: rgb(0, 0, 0),
-                borderWidth: 1,
-            });
-            page.drawImage(image, pos);
-            if (isLandscapeImage) {
-                const lines = wrapText(texts[index], font, fontSize, pos.width - textMargin * 2);
-                for (const [index, line] of lines.entries()) {
-                    page.drawText(line, {
-                        ...pos,
-                        x: offset + pos.containerWidth + textMargin,
-                        y: pos.y + pos.height - fontSize - (fontSize + 2) * index,
-                        size: fontSize,
-                        font,
-                    });
-                }
-                /*
-                page.drawRectangle({
-                  ...pos,
-                  x: pos.x +  pos.width ,
-                  borderColor: rgb(0, 0, 0),
-                  borderWidth: 1,
-                  });
-                */
+const formatTextAsParagraphs = (text) => text
+    .split("\n")
+    .map((line) => `<p>${line}</p>`)
+    .join("");
+const generateSlideHTML = (imageDataUrls) => imageDataUrls
+    .map((imageUrl) => `
+      <div class="page">
+        <img src="${imageUrl}" alt="">
+      </div>`)
+    .join("");
+const generateTalkHTML = (imageDataUrls, texts) => imageDataUrls
+    .map((imageUrl, index) => `
+      <div class="page">
+        <div class="image-container">
+          <img src="${imageUrl}" alt="">
+        </div>
+        <div class="text-container">
+          ${formatTextAsParagraphs(texts[index])}
+        </div>
+      </div>`)
+    .join("");
+const generateHandoutHTML = (imageDataUrls, texts) => {
+    const itemsPerPage = 4;
+    const pages = [];
+    for (let i = 0; i < imageDataUrls.length; i += itemsPerPage) {
+        const pageItems = Array.from({ length: itemsPerPage }, (_, j) => {
+            const index = i + j;
+            const hasContent = index < imageDataUrls.length;
+            if (hasContent) {
+                return `
+          <div class="handout-item">
+            <div class="handout-image">
+              <img src="${imageDataUrls[index]}" alt="">
+            </div>
+            <div class="handout-text">
+              ${formatTextAsParagraphs(texts[index])}
+            </div>
+          </div>`;
             }
             else {
-                const lines = wrapText(texts[index], font, fontSize, pos.width - textMargin * 2);
-                for (const [index, line] of lines.entries()) {
-                    page.drawText(line, {
-                        ...pos,
-                        x: pos.x,
-                        y: textMargin + pos.height - fontSize - (fontSize + textMargin) * index - 2 * textMargin,
-                        size: fontSize,
-                        font,
-                    });
-                }
-                /*
-                page.drawRectangle({
-                  ...pos,
-                  x: pos.x,
-                  y: textMargin,
-                  height: pos.height - 2 * textMargin,
-                  borderColor: rgb(0, 0, 0),
-                  borderWidth: 1,
-                });
-                */
+                // Empty slot to maintain 4-item grid layout
+                return `
+          <div class="handout-item">
+            <div class="handout-image"></div>
+            <div class="handout-text"></div>
+          </div>`;
             }
-            index = index + 1;
-        }
+        }).join("");
+        pages.push(`<div class="page">${pageItems}</div>`);
     }
+    return pages.join("");
 };
-const outputSize = (pdfSize, isLandscapeImage, isRotate) => {
-    if (pdfSize === "a4") {
-        if (isLandscapeImage !== isRotate) {
-            return { width: 841.89, height: 595.28 };
-        }
-        return { width: 595.28, height: 841.89 };
-    }
-    // letter
-    if (isLandscapeImage !== isRotate) {
-        return { width: 792, height: 612 };
+const generatePagesHTML = (pdfMode, imageDataUrls, texts) => {
+    switch (pdfMode) {
+        case "slide":
+            return generateSlideHTML(imageDataUrls);
+        case "talk":
+            return generateTalkHTML(imageDataUrls, texts);
+        case "handout":
+            return generateHandoutHTML(imageDataUrls, texts);
+        default:
+            return "";
     }
-    return { width: 612, height: 792 };
 };
-const generatePdf = async (context, pdfMode, pdfSize) => {
-    const { studio, fileDirs, lang } = context;
+const getHandoutTemplateData = (isLandscapeImage) => ({
+    page_layout: isLandscapeImage ? "flex" : "grid",
+    page_direction: isLandscapeImage ? "flex-direction: column;" : "grid-template-columns: repeat(4, 1fr);",
+    flex_direction: isLandscapeImage ? "row" : "column",
+    image_size: isLandscapeImage ? "width: 45%;" : "height: 60%;",
+    text_size: isLandscapeImage ? "width: 55%;" : "height: 40%;",
+    item_flex: isLandscapeImage ? "flex: 1;" : "",
+});
+const generatePDFHTML = async (context, pdfMode, pdfSize) => {
+    const { studio, lang = "en" } = context;
     const { multiLingual } = studio;
-    const { outDirPath } = fileDirs;
     const { width: imageWidth, height: imageHeight } = MulmoScriptMethods.getCanvasSize(studio.script);
     const isLandscapeImage = imageWidth > imageHeight;
-    const isRotate = pdfMode === "handout";
-    const { width: pageWidth, height: pageHeight } = outputSize(pdfSize, isLandscapeImage, isRotate);
     const imagePaths = studio.beats.map((beat) => beat.imageFile);
-    const texts = studio.script.beats.map((beat, index) => {
-        return localizedText(beat, multiLingual?.[index], lang);
+    const texts = studio.script.beats.map((beat, index) => localizedText(beat, multiLingual?.[index], lang));
+    const imageDataUrls = await Promise.all(imagePaths.map(loadImage));
+    const pageSize = pdfMode === "handout" ? `${getPdfSize(pdfSize)} portrait` : `${getPdfSize(pdfSize)} ${isLandscapeImage ? "landscape" : "portrait"}`;
+    const pagesHTML = generatePagesHTML(pdfMode, imageDataUrls, texts);
+    const template = getHTMLFile(`pdf_${pdfMode}`);
+    const baseTemplateData = {
+        lang,
+        title: studio.script.title || "MulmoCast PDF",
+        page_size: pageSize,
+        pages: pagesHTML,
+    };
+    const templateData = pdfMode === "handout" ? { ...baseTemplateData, ...getHandoutTemplateData(isLandscapeImage) } : baseTemplateData;
+    return interpolate(template, templateData);
+};
+const createPDFOptions = (pdfSize, pdfMode) => {
+    const baseOptions = {
+        format: getPdfSize(pdfSize),
+        margin: {
+            top: "0",
+            bottom: "0",
+            left: "0",
+            right: "0",
+        },
+    };
+    // handout mode always uses portrait orientation
+    return pdfMode === "handout" ? { ...baseOptions, landscape: false } : baseOptions;
+};
+export const pdfFilePath = (context, pdfMode) => {
+    const { studio, fileDirs, lang = "en" } = context;
+    return getOutputPdfFilePath(fileDirs.outDirPath, studio.filename, pdfMode, lang);
+};
+const generatePDF = async (context, pdfMode, pdfSize) => {
+    const outputPdfPath = pdfFilePath(context, pdfMode);
+    const html = await generatePDFHTML(context, pdfMode, pdfSize);
+    const pdfOptions = createPDFOptions(pdfSize, pdfMode);
+    const browser = await puppeteer.launch({
+        args: isCI ? ["--no-sandbox"] : [],
     });
-    const outputPdfPath = getOutputPdfFilePath(outDirPath, studio.filename, pdfMode, lang);
-    const pdfDoc = await PDFDocument.create();
-    pdfDoc.registerFontkit(fontkit);
-    const fontBytes = fs.readFileSync("assets/font/NotoSansJP-Regular.ttf");
-    const customFont = await pdfDoc.embedFont(fontBytes);
-    if (pdfMode === "handout") {
-        await pdfHandout(pageWidth, pageHeight, imagePaths, texts, pdfDoc, customFont, isLandscapeImage);
-    }
-    if (pdfMode === "slide") {
-        await pdfSlide(pageWidth, pageHeight, imagePaths, pdfDoc);
+    try {
+        const page = await browser.newPage();
+        await page.setContent(html, { waitUntil: "networkidle0" });
+        await page.pdf({
+            path: outputPdfPath,
+            printBackground: true,
+            ...pdfOptions,
+        });
+        writingMessage(outputPdfPath);
     }
-    if (pdfMode === "talk") {
-        await pdfTalk(pageWidth, pageHeight, imagePaths, texts, pdfDoc, customFont);
+    finally {
+        await browser.close();
     }
-    const pdfBytes = await pdfDoc.save();
-    fs.writeFileSync(outputPdfPath, pdfBytes);
-    writingMessage(outputPdfPath);
 };
 export const pdf = async (context, pdfMode, pdfSize) => {
     try {
         MulmoStudioContextMethods.setSessionState(context, "pdf", true);
-        await generatePdf(context, pdfMode, pdfSize);
+        await generatePDF(context, pdfMode, pdfSize);
     }
     finally {
         MulmoStudioContextMethods.setSessionState(context, "pdf", false);

package/lib/agents/combine_audio_files_agent.js

@@ -11,6 +11,13 @@ const combineAudioFilesAgent = async ({ namedInputs, }) => {
     const inputIds = (await Promise.all(context.studio.beats.map(async (studioBeat, index) => {
         const beat = context.studio.script.beats[index];
         const isClosingGap = index === context.studio.beats.length - 2;
+        const movieDuration = await (() => {
+            if (beat.image?.type === "movie" && (beat.image.source.kind === "url" || beat.image.source.kind === "path")) {
+                const pathOrUrl = beat.image.source.kind === "url" ? beat.image.source.url : beat.image.source.path;
+                return ffmpegGetMediaDuration(pathOrUrl);
+            }
+            return 0;
+        })();
         if (studioBeat.audioFile) {
             const audioId = FfmpegContextInputFormattedAudio(ffmpegContext, studioBeat.audioFile);
             const padding = (() => {
@@ -24,13 +31,8 @@ const combineAudioFilesAgent = async ({ namedInputs, }) => {
             })();
             const audioDuration = await ffmpegGetMediaDuration(studioBeat.audioFile);
             const totalPadding = await (async () => {
-                if (beat.image?.type === "movie" && (beat.image.source.kind === "url" || beat.image.source.kind === "path")) {
-                    const pathOrUrl = beat.image.source.kind === "url" ? beat.image.source.url : beat.image.source.path;
-                    // NOTE: We respect the duration of the movie, only if the movie is specified as a madia source, NOT generated.
-                    const movieDuration = await ffmpegGetMediaDuration(pathOrUrl);
-                    if (movieDuration > audioDuration) {
-                        return padding + (movieDuration - audioDuration);
-                    }
+                if (movieDuration > 0) {
+                    return padding + (movieDuration - audioDuration);
                 }
                 else if (beat.duration && beat.duration > audioDuration) {
                     return padding + (beat.duration - audioDuration);
@@ -49,7 +51,7 @@ const combineAudioFilesAgent = async ({ namedInputs, }) => {
         }
         else {
             // NOTE: We come here when the text is empty and no audio property is specified.
-            studioBeat.duration = beat.duration ?? 1.0;
+            studioBeat.duration = beat.duration ?? (movieDuration > 0 ? movieDuration : 1.0);
             const silentId = silentIds.pop();
             ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${studioBeat.duration}[silent_${index}]`);
             return [`[silent_${index}]`];

package/lib/agents/image_mock_agent.d.ts

@@ -0,0 +1,4 @@
+import { AgentFunction, AgentFunctionInfo } from "graphai";
+export declare const imageMockAgent: AgentFunction;
+declare const imageMockAgentInfo: AgentFunctionInfo;
+export default imageMockAgentInfo;

package/lib/agents/image_mock_agent.js

@@ -0,0 +1,18 @@
+import { GraphAILogger } from "graphai";
+export const imageMockAgent = async () => {
+    GraphAILogger.debug("agent dryRun");
+    return { buffer: Buffer.from([]) };
+};
+const imageMockAgentInfo = {
+    name: "imageMockAgent",
+    agent: imageMockAgent,
+    mock: imageMockAgent,
+    samples: [],
+    description: "Image mock agent",
+    category: ["image"],
+    author: "Receptron Team",
+    repository: "https://github.com/receptron/mulmocast-cli/",
+    license: "MIT",
+    environmentVariables: [],
+};
+export default imageMockAgentInfo;

package/lib/agents/index.d.ts

@@ -2,6 +2,8 @@ import addBGMAgent from "./add_bgm_agent.js";
 import combineAudioFilesAgent from "./combine_audio_files_agent.js";
 import imageGoogleAgent from "./image_google_agent.js";
 import imageOpenaiAgent from "./image_openai_agent.js";
+import movieGoogleAgent from "./movie_google_agent.js";
+import mediaMockAgent from "./media_mock_agent.js";
 import ttsElevenlabsAgent from "./tts_elevenlabs_agent.js";
 import ttsNijivoiceAgent from "./tts_nijivoice_agent.js";
 import ttsOpenaiAgent from "./tts_openai_agent.js";
@@ -10,4 +12,4 @@ import { browserlessAgent } from "@graphai/browserless_agent";
 import { textInputAgent } from "@graphai/input_agents";
 import { openAIAgent } from "@graphai/openai_agent";
 import { fileWriteAgent } from "@graphai/vanilla_node_agents";
-export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, ttsElevenlabsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };
+export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, movieGoogleAgent, mediaMockAgent, ttsElevenlabsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };

package/lib/agents/index.js

@@ -2,6 +2,8 @@ import addBGMAgent from "./add_bgm_agent.js";
 import combineAudioFilesAgent from "./combine_audio_files_agent.js";
 import imageGoogleAgent from "./image_google_agent.js";
 import imageOpenaiAgent from "./image_openai_agent.js";
+import movieGoogleAgent from "./movie_google_agent.js";
+import mediaMockAgent from "./media_mock_agent.js";
 import ttsElevenlabsAgent from "./tts_elevenlabs_agent.js";
 import ttsNijivoiceAgent from "./tts_nijivoice_agent.js";
 import ttsOpenaiAgent from "./tts_openai_agent.js";
@@ -11,4 +13,4 @@ import { textInputAgent } from "@graphai/input_agents";
 import { openAIAgent } from "@graphai/openai_agent";
 // import * as vanilla from "@graphai/vanilla";
 import { fileWriteAgent } from "@graphai/vanilla_node_agents";
-export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, ttsElevenlabsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };
+export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, movieGoogleAgent, mediaMockAgent, ttsElevenlabsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };

package/lib/agents/media_mock_agent.d.ts

@@ -0,0 +1,4 @@
+import { AgentFunction, AgentFunctionInfo } from "graphai";
+export declare const mediaMockAgent: AgentFunction;
+declare const mediaMockAgentInfo: AgentFunctionInfo;
+export default mediaMockAgentInfo;

package/lib/agents/media_mock_agent.js

@@ -0,0 +1,18 @@
+import { GraphAILogger } from "graphai";
+export const mediaMockAgent = async () => {
+    GraphAILogger.debug("agent dryRun");
+    return { buffer: Buffer.from([]) };
+};
+const mediaMockAgentInfo = {
+    name: "mediaMockAgent",
+    agent: mediaMockAgent,
+    mock: mediaMockAgent,
+    samples: [],
+    description: "Image mock agent",
+    category: ["image"],
+    author: "Receptron Team",
+    repository: "https://github.com/receptron/mulmocast-cli/",
+    license: "MIT",
+    environmentVariables: [],
+};
+export default mediaMockAgentInfo;

package/lib/agents/tts_openai_agent.js

@@ -24,7 +24,15 @@ export const ttsOpenaiAgent = async ({ namedInputs, params }) => {
                 error: e,
             };
         }
-        GraphAILogger.info(e);
+        GraphAILogger.error(e);
+        if (e && typeof e === "object" && "error" in e) {
+            GraphAILogger.info("tts_openai_agent: ");
+            GraphAILogger.info(e.error);
+        }
+        else if (e instanceof Error) {
+            GraphAILogger.info("tts_openai_agent: ");
+            GraphAILogger.info(e.message);
+        }
         throw new Error("TTS OpenAI Error");
     }
 };

package/lib/cli/commands/audio/builder.d.ts

@@ -7,6 +7,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
+} & {
+    dryRun: boolean;
 } & {
     file: string | undefined;
 } & {

package/lib/cli/commands/image/builder.d.ts

@@ -7,6 +7,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
+} & {
+    dryRun: boolean;
 } & {
     file: string | undefined;
 } & {

package/lib/cli/commands/movie/builder.d.ts

@@ -7,6 +7,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
+} & {
+    dryRun: boolean;
 } & {
     file: string | undefined;
 } & {

package/lib/cli/commands/pdf/builder.d.ts

@@ -7,6 +7,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
+} & {
+    dryRun: boolean;
 } & {
     file: string | undefined;
 } & {

package/lib/cli/commands/translate/builder.d.ts

@@ -7,6 +7,8 @@ export declare const builder: (yargs: Argv) => Argv<import("yargs").Omit<{
     l: string | undefined;
 } & {
     f: boolean;
+} & {
+    dryRun: boolean;
 } & {
     file: string | undefined;
 }, "file"> & {

package/lib/cli/common.d.ts

@@ -7,6 +7,8 @@ export declare const commonOptions: (yargs: Argv) => Argv<{
     l: string | undefined;
 } & {
     f: boolean;
+} & {
+    dryRun: boolean;
 } & {
     file: string | undefined;
 }>;

package/lib/cli/common.js

@@ -25,6 +25,11 @@ export const commonOptions = (yargs) => {
         describe: "Force regenerate",
         type: "boolean",
         default: false,
+    })
+        .option("dryRun", {
+        describe: "Dry run",
+        type: "boolean",
+        default: false,
     })
         .positional("file", {
         describe: "Mulmo Script File",

package/lib/cli/helpers.js

@@ -100,6 +100,7 @@ export const initializeContext = async (argv) => {
             studio,
             fileDirs: files,
             force: Boolean(argv.f),
+            dryRun: Boolean(argv.dryRun),
             lang: argv.l,
             caption: argv.c,
             sessionState: {

package/lib/methods/mulmo_script.d.ts

@@ -6,6 +6,6 @@ export declare const MulmoScriptMethods: {
     getAllSpeechProviders(script: MulmoScript): Set<Text2SpeechProvider>;
     getTextSlideStyle(script: MulmoScript, beat: MulmoBeat): string;
     getSpeechOptions(script: MulmoScript, beat: MulmoBeat): SpeechOptions | undefined;
-    getImageAgentInfo(script: MulmoScript): Text2ImageAgentInfo;
+    getImageAgentInfo(script: MulmoScript, dryRun?: boolean): Text2ImageAgentInfo;
     getImageType(_: MulmoScript, beat: MulmoBeat): BeatMediaType;
 };

package/lib/methods/mulmo_script.js

@@ -40,7 +40,7 @@ export const MulmoScriptMethods = {
     getSpeechOptions(script, beat) {
         return { ...script.speechParams.speakers[beat.speaker].speechOptions, ...beat.speechOptions };
     },
-    getImageAgentInfo(script) {
+    getImageAgentInfo(script, dryRun = false) {
         // Notice that we copy imageParams from script and update
         // provider and model appropriately.
         const provider = text2ImageProviderSchema.parse(script.imageParams?.provider);
@@ -49,7 +49,7 @@ export const MulmoScriptMethods = {
         };
         return {
             provider,
-            agent: provider === "google" ? "imageGoogleAgent" : "imageOpenaiAgent",
+            agent: dryRun ? "mediaMockAgent" : provider === "google" ? "imageGoogleAgent" : "imageOpenaiAgent",
             imageParams: { ...defaultImageParams, ...script.imageParams },
         };
     },

package/lib/types/type.d.ts

@@ -45,6 +45,7 @@ export type MulmoStudioContext = {
     fileDirs: FileDirs;
     studio: MulmoStudio;
     lang?: string;
+    dryRun?: boolean;
     force: boolean;
     caption?: string;
     sessionState: MulmoSessionState;

package/lib/utils/filters.js

@@ -22,6 +22,7 @@ export const fileCacheAgentFilter = async (context, next) => {
         }
     };
     if (await shouldUseCache()) {
+        GraphAILogger.debug("cache");
         return true;
     }
     try {

package/lib/utils/markdown.js

@@ -24,7 +24,7 @@ export const renderHTMLToImage = async (html, outputPath, width, height, isMerma
 export const renderMarkdownToImage = async (markdown, style, outputPath, width, height) => {
     const header = `<head><style>${style}</style></head>`;
     const body = await marked(markdown);
-    const html = `<htlm>${header}<body>${body}</body></html>`;
+    const html = `<html>${header}<body>${body}</body></html>`;
     await renderHTMLToImage(html, outputPath, width, height);
 };
 export const interpolate = (template, data) => {