mulmocast 0.0.13 → 0.0.15

package/lib/actions/movie.js

@@ -110,7 +110,14 @@ const createVideo = async (audioArtifactFilePath, outputVideoPath, studio, capti
             const sourceId = filterComplexVideoIds.pop();
             ffmpegContext.filterComplex.push(`[${sourceId}]split=2[${sourceId}_0][${sourceId}_1]`);
             filterComplexVideoIds.push(`${sourceId}_0`);
-            transitionVideoIds.push(`${sourceId}_1`);
+            if (mediaType === "movie") {
+                // For movie beats, extract the last frame for transition
+                ffmpegContext.filterComplex.push(`[${sourceId}_1]reverse,select='eq(n,0)',reverse,tpad=stop_mode=clone:stop_duration=${duration},fps=30,setpts=PTS-STARTPTS[${sourceId}_2]`);
+                transitionVideoIds.push(`${sourceId}_2`);
+            }
+            else {
+                transitionVideoIds.push(`${sourceId}_1`);
+            }
         }
         if (beat.image?.type == "movie" && beat.image.mixAudio > 0.0) {
             const { audioId, audioPart } = getAudioPart(inputIndex, duration, timestamp, beat.image.mixAudio);
@@ -133,7 +140,6 @@ const createVideo = async (audioArtifactFilePath, outputVideoPath, studio, capti
             return transitionVideoIds.reduce((acc, transitionVideoId, index) => {
                 const transitionStartTime = beatTimestamps[index + 1] - 0.05; // 0.05 is to avoid flickering
                 const processedVideoId = `${transitionVideoId}_f`;
-                // TODO: This mechanism does not work for video beats yet. It works only with image beats.
                 // If we can to add other transition types than fade, we need to add them here.
                 ffmpegContext.filterComplex.push(`[${transitionVideoId}]format=yuva420p,fade=t=out:d=${transition.duration}:alpha=1,setpts=PTS-STARTPTS+${transitionStartTime}/TB[${processedVideoId}]`);
                 const outputId = `${transitionVideoId}_o`;
@@ -156,6 +162,7 @@ const createVideo = async (audioArtifactFilePath, outputVideoPath, studio, capti
         }
         return artifactAudioId;
     })();
+    // GraphAILogger.debug("filterComplex", ffmpegContext.filterComplex);
     await FfmpegContextGenerateOutput(ffmpegContext, outputVideoPath, getOutputOption(ffmpegContextAudioId, mixedVideoId));
     const end = performance.now();
     GraphAILogger.info(`Video created successfully! ${Math.round(end - start) / 1000} sec`);
@@ -163,13 +170,17 @@ const createVideo = async (audioArtifactFilePath, outputVideoPath, studio, capti
     GraphAILogger.info((studio.script.references ?? []).map((reference) => `${reference.title} (${reference.url})`).join("\n"));
     return true;
 };
+export const movieFilePath = (context) => {
+    const { studio, fileDirs, caption } = context;
+    return getOutputVideoFilePath(fileDirs.outDirPath, studio.filename, context.lang, caption);
+};
 export const movie = async (context) => {
     MulmoStudioContextMethods.setSessionState(context, "video", true);
     try {
         const { studio, fileDirs, caption } = context;
         const { outDirPath } = fileDirs;
         const audioArtifactFilePath = getAudioArtifactFilePath(outDirPath, studio.filename);
-        const outputVideoPath = getOutputVideoFilePath(outDirPath, studio.filename, context.lang, caption);
+        const outputVideoPath = movieFilePath(context);
         if (await createVideo(audioArtifactFilePath, outputVideoPath, studio, caption)) {
             writingMessage(outputVideoPath);
         }

package/lib/actions/pdf.d.ts

@@ -1,2 +1,3 @@
 import { MulmoStudioContext, PDFMode, PDFSize } from "../types/index.js";
+export declare const pdfFilePath: (context: MulmoStudioContext, pdfMode: PDFMode) => string;
 export declare const pdf: (context: MulmoStudioContext, pdfMode: PDFMode, pdfSize: PDFSize) => Promise<void>;

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: {