mulmocast 1.2.63 → 1.2.65

package/lib/actions/audio.d.ts

@@ -1,6 +1,5 @@
 import type { GraphData } from "graphai";
 import { MulmoStudioContext, MulmoBeat, PublicAPIArgs } from "../types/index.js";
-export declare const getBeatAudioPath: (text: string, context: MulmoStudioContext, beat: MulmoBeat, lang?: string) => string | undefined;
 export declare const getBeatAudioPathOrUrl: (text: string, context: MulmoStudioContext, beat: MulmoBeat, lang?: string) => string | undefined;
 export declare const localizedPath: (context: MulmoStudioContext, beat: MulmoBeat, index: number, lang: string) => string | undefined;
 export declare const listLocalizedAudioPaths: (context: MulmoStudioContext) => (string | undefined)[];

package/lib/actions/audio.js

@@ -27,10 +27,6 @@ const getAudioPathOrUrl = (context, beat, maybeAudioFile) => {
     }
     return maybeAudioFile;
 };
-// for back forward compatible
-export const getBeatAudioPath = (text, context, beat, lang) => {
-    return getBeatAudioPathOrUrl(text, context, beat, lang);
-};
 export const getBeatAudioPathOrUrl = (text, context, beat, lang) => {
     const audioDirPath = MulmoStudioContextMethods.getAudioDirPath(context);
     const { voiceId, provider, speechOptions, model } = MulmoStudioContextMethods.getAudioParam(context, beat, lang);

package/lib/actions/bundle.d.ts

@@ -0,0 +1,2 @@
+import { type MulmoStudioContext } from "../types/index.js";
+export declare const mulmoViewerBundle: (context: MulmoStudioContext) => Promise<void>;

package/lib/actions/bundle.js

@@ -0,0 +1,79 @@
+import path from "path";
+import fs from "fs";
+import { GraphAILogger } from "graphai";
+import { listLocalizedAudioPaths } from "./audio.js";
+import { imagePreprocessAgent } from "./image_agents.js";
+import { mkdir } from "../utils/file.js";
+import { ZipBuilder } from "../utils/zip.js";
+import { bundleTargetLang } from "../utils/const.js";
+const beatImage = (context) => {
+    return async (beat, index) => {
+        try {
+            const res = await imagePreprocessAgent({ context, beat, index, imageRefs: {} });
+            if ("htmlPrompt" in res) {
+                return { htmlImageSource: res.htmlImageFile, imageSource: res.imagePath };
+            }
+            const { imagePath, movieFile, lipSyncFile } = res;
+            return { imageSource: imagePath, videoSource: movieFile, videoWithAudioSource: lipSyncFile };
+        }
+        catch (e) {
+            GraphAILogger.log(e);
+            return {};
+        }
+    };
+};
+// TODO reference
+const viewJsonFileName = "mulmo_view.json";
+const zipFileName = "mulmo.zip";
+export const mulmoViewerBundle = async (context) => {
+    const isZip = true;
+    const dir = path.resolve(context.fileDirs.fileName);
+    mkdir(dir);
+    const zipper = new ZipBuilder(path.resolve(dir, zipFileName));
+    const resultJson = [];
+    context.studio.script.beats.forEach((beat) => {
+        resultJson.push({ text: beat.text, duration: beat.duration, audioSources: {}, multiLinguals: {} });
+    });
+    for (const lang of bundleTargetLang) {
+        const audios = listLocalizedAudioPaths({ ...context, lang });
+        audios.forEach((audio, index) => {
+            if (audio) {
+                const fileName = path.basename(audio ?? "");
+                if (resultJson[index] && resultJson[index].audioSources) {
+                    resultJson[index].audioSources[lang] = fileName;
+                }
+                if (fs.existsSync(audio)) {
+                    fs.copyFileSync(audio, path.resolve(dir, fileName));
+                    zipper.addFile(audio, fileName);
+                }
+            }
+        });
+    }
+    const images = await Promise.all(context.studio.script.beats.map(beatImage(context)));
+    images.forEach((image, index) => {
+        const data = resultJson[index];
+        const keys = ["htmlImageSource", "imageSource", "videoSource", "videoWithAudioSource"];
+        keys.forEach((key) => {
+            const value = image[key];
+            if (value) {
+                data[key] = path.basename(value);
+                if (fs.existsSync(value)) {
+                    fs.copyFileSync(value, path.resolve(dir, path.basename(value)));
+                    zipper.addFile(value);
+                }
+            }
+        });
+    });
+    context.multiLingual.forEach((beat, index) => {
+        bundleTargetLang.forEach((lang) => {
+            if (resultJson[index] && resultJson[index].multiLinguals) {
+                resultJson[index].multiLinguals[lang] = beat.multiLingualTexts[lang].text;
+            }
+        });
+    });
+    fs.writeFileSync(path.resolve(dir, viewJsonFileName), JSON.stringify({ beats: resultJson, bgmSource: context.studio?.script.audioParams?.bgm }, null, 2));
+    zipper.addFile(path.resolve(dir, viewJsonFileName));
+    if (isZip) {
+        await zipper.finalize();
+    }
+};

package/lib/actions/image_agents.d.ts

@@ -1,51 +1,8 @@
-import { MulmoStudioContext, MulmoBeat, MulmoCanvasDimension, MulmoImageParams, MulmoMovieParams } from "../types/index.js";
-export declare const imagePreprocessAgent: (namedInputs: {
-    context: MulmoStudioContext;
-    beat: MulmoBeat;
-    index: number;
-    imageRefs: Record<string, string>;
-}) => Promise<{
-    imagePath: string;
-    htmlPrompt: string | undefined;
-    htmlImageFile: string;
-    htmlPath: string;
-    htmlImageSystemPrompt: string;
-} | {
-    imagePath: string | undefined;
-    movieFile: string | undefined;
-    referenceImageForMovie: string | undefined;
-    imageParams: MulmoImageParams;
-    soundEffectFile?: string;
-    soundEffectPrompt?: string;
-    soundEffectModel?: string;
-    soundEffectAgentInfo?: {
-        agentName: string;
-        defaultModel: string;
-    };
-    lipSyncFile?: string;
-    lipSyncModel?: string;
-    lipSyncAgentName?: string;
-    lipSyncTrimAudio?: boolean;
-    bgmFile?: string | null;
-    startAt?: number;
-    duration?: number;
-    audioFile?: string;
+import { MulmoStudioContext, MulmoBeat, MulmoCanvasDimension, MulmoImageParams, MulmoMovieParams, Text2ImageAgentInfo } from "../types/index.js";
+type ImagePreprocessAgentReturnValue = {
+    imageParams?: MulmoImageParams;
+    movieFile?: string;
     beatDuration?: number;
-    movieAgentInfo?: {
-        agent: string;
-        movieParams: MulmoMovieParams;
-    };
-    markdown?: string;
-    html?: string;
-    htmlPrompt?: undefined;
-    htmlImageFile?: undefined;
-    htmlPath?: undefined;
-    htmlImageSystemPrompt?: undefined;
-} | {
-    imagePath: string;
-    imageFromMovie: boolean;
-    imageParams: MulmoImageParams;
-    movieFile: string | undefined;
     soundEffectFile?: string;
     soundEffectPrompt?: string;
     soundEffectModel?: string;
@@ -57,56 +14,46 @@ export declare const imagePreprocessAgent: (namedInputs: {
     lipSyncModel?: string;
     lipSyncAgentName?: string;
     lipSyncTrimAudio?: boolean;
-    bgmFile?: string | null;
     startAt?: number;
     duration?: number;
+    bgmFile?: string | null;
     audioFile?: string;
-    beatDuration?: number;
     movieAgentInfo?: {
         agent: string;
         movieParams: MulmoMovieParams;
     };
-    markdown?: string;
-    html?: string;
-    htmlPrompt?: undefined;
-    htmlImageFile?: undefined;
-    htmlPath?: undefined;
-    htmlImageSystemPrompt?: undefined;
-} | {
-    imagePath: string;
-    referenceImageForMovie: string;
-    imageAgentInfo: import("../types/type.js").Text2ImageAgentInfo;
+};
+type ImagePreprocessAgentResponseBase = ImagePreprocessAgentReturnValue & {
+    imagePath?: string;
+};
+type ImageGenearalPreprocessAgentResponse = ImagePreprocessAgentResponseBase & {
+    imageAgentInfo: Text2ImageAgentInfo;
     prompt: string;
     referenceImages: string[];
-    imageParams: MulmoImageParams;
-    movieFile: string | undefined;
-    soundEffectFile?: string;
-    soundEffectPrompt?: string;
-    soundEffectModel?: string;
-    soundEffectAgentInfo?: {
-        agentName: string;
-        defaultModel: string;
-    };
-    lipSyncFile?: string;
-    lipSyncModel?: string;
-    lipSyncAgentName?: string;
-    lipSyncTrimAudio?: boolean;
-    bgmFile?: string | null;
-    startAt?: number;
-    duration?: number;
-    audioFile?: string;
-    beatDuration?: number;
-    movieAgentInfo?: {
-        agent: string;
-        movieParams: MulmoMovieParams;
-    };
-    markdown?: string;
-    html?: string;
-    htmlPrompt?: undefined;
-    htmlImageFile?: undefined;
-    htmlPath?: undefined;
-    htmlImageSystemPrompt?: undefined;
-}>;
+    referenceImageForMovie: string;
+};
+type ImageHtmlPreprocessAgentResponse = {
+    imagePath: string;
+    htmlPrompt: string;
+    htmlPath: string;
+    htmlImageSystemPrompt: string;
+    htmlImageFile: string;
+};
+type ImageOnlyMoviePreprocessAgentResponse = ImagePreprocessAgentResponseBase & {
+    imageFromMovie: boolean;
+};
+type ImagePluginPreprocessAgentResponse = ImagePreprocessAgentResponseBase & {
+    referenceImageForMovie: string;
+    markdown: string;
+    html: string;
+};
+type ImagePreprocessAgentResponse = ImagePreprocessAgentResponseBase | ImageHtmlPreprocessAgentResponse | ImagePluginPreprocessAgentResponse | ImageOnlyMoviePreprocessAgentResponse | ImageGenearalPreprocessAgentResponse;
+export declare const imagePreprocessAgent: (namedInputs: {
+    context: MulmoStudioContext;
+    beat: MulmoBeat;
+    index: number;
+    imageRefs: Record<string, string>;
+}) => Promise<ImagePreprocessAgentResponse>;
 export declare const imagePluginAgent: (namedInputs: {
     context: MulmoStudioContext;
     beat: MulmoBeat;
@@ -117,3 +64,4 @@ export declare const htmlImageGeneratorAgent: (namedInputs: {
     canvasSize: MulmoCanvasDimension;
     htmlText: string;
 }) => Promise<void>;
+export {};

package/lib/actions/image_agents.js

@@ -17,6 +17,7 @@ export const imagePreprocessAgent = async (namedInputs) => {
     if (beat.htmlPrompt) {
         const htmlPrompt = MulmoBeatMethods.getHtmlPrompt(beat);
         const htmlPath = imagePath.replace(/\.[^/.]+$/, ".html");
+        // ImageHtmlPreprocessAgentResponse
         return { imagePath, htmlPrompt, htmlImageFile, htmlPath, htmlImageSystemPrompt: htmlImageSystemPrompt(context.presentationStyle.canvasSize) };
     }
     const imageAgentInfo = MulmoPresentationStyleMethods.getImageAgentInfo(context.presentationStyle, beat);
@@ -62,27 +63,30 @@ export const imagePreprocessAgent = async (namedInputs) => {
     if (beat.image) {
         const plugin = MulmoBeatMethods.getPlugin(beat);
         const pluginPath = plugin.path({ beat, context, imagePath, ...htmlStyle(context, beat) });
-        if (plugin.markdown) {
-            returnValue.markdown = plugin.markdown({ beat, context, imagePath, ...htmlStyle(context, beat) });
-        }
-        if (plugin.html) {
-            returnValue.html = await plugin.html({ beat, context, imagePath, ...htmlStyle(context, beat) });
-        }
+        const markdown = plugin.markdown ? plugin.markdown({ beat, context, imagePath, ...htmlStyle(context, beat) }) : undefined;
+        const html = plugin.html ? await plugin.html({ beat, context, imagePath, ...htmlStyle(context, beat) }) : undefined;
         const isTypeMovie = beat.image.type === "movie";
         // undefined prompt indicates that image generation is not needed
+        // ImagePluginPreprocessAgentResponse
         return {
             ...returnValue,
-            imagePath: isTypeMovie ? undefined : pluginPath,
+            // imagePath: isTypeMovie ? undefined : pluginPath,
+            imagePath: isTypeMovie ? imagePath : pluginPath,
             movieFile: isTypeMovie ? pluginPath : undefined,
+            imageFromMovie: isTypeMovie,
             referenceImageForMovie: pluginPath,
+            markdown,
+            html,
         };
     }
     if (beat.moviePrompt && !beat.imagePrompt) {
+        // ImageOnlyMoviePreprocessAgentResponse
         return { ...returnValue, imagePath, imageFromMovie: true }; // no image prompt, only movie prompt
     }
     // referenceImages for "edit_image", openai agent.
     const referenceImages = MulmoBeatMethods.getImageReferenceForImageGenerator(beat, imageRefs);
     const prompt = imagePrompt(beat, imageAgentInfo.imageParams.style);
+    // ImageGenearalPreprocessAgentResponse
     return { ...returnValue, imagePath, referenceImageForMovie: imagePath, imageAgentInfo, prompt, referenceImages };
 };
 export const imagePluginAgent = async (namedInputs) => {

package/lib/actions/images.d.ts

@@ -27,17 +27,10 @@ export declare const beat_graph_data: {
                 beat: import("../types/type.js").MulmoBeat;
                 index: number;
                 imageRefs: Record<string, string>;
-            }) => Promise<{
-                imagePath: string;
-                htmlPrompt: string | undefined;
-                htmlImageFile: string;
-                htmlPath: string;
-                htmlImageSystemPrompt: string;
-            } | {
-                imagePath: string | undefined;
-                movieFile: string | undefined;
-                referenceImageForMovie: string | undefined;
-                imageParams: MulmoImageParams;
+            }) => Promise<({
+                imageParams?: MulmoImageParams;
+                movieFile?: string;
+                beatDuration?: number;
                 soundEffectFile?: string;
                 soundEffectPrompt?: string;
                 soundEffectModel?: string;
@@ -49,26 +42,20 @@ export declare const beat_graph_data: {
                 lipSyncModel?: string;
                 lipSyncAgentName?: string;
                 lipSyncTrimAudio?: boolean;
-                bgmFile?: string | null;
                 startAt?: number;
                 duration?: number;
+                bgmFile?: string | null;
                 audioFile?: string;
-                beatDuration?: number;
                 movieAgentInfo?: {
                     agent: string;
                     movieParams: import("../types/type.js").MulmoMovieParams;
                 };
-                markdown?: string;
-                html?: string;
-                htmlPrompt?: undefined;
-                htmlImageFile?: undefined;
-                htmlPath?: undefined;
-                htmlImageSystemPrompt?: undefined;
-            } | {
-                imagePath: string;
-                imageFromMovie: boolean;
-                imageParams: MulmoImageParams;
-                movieFile: string | undefined;
+            } & {
+                imagePath?: string;
+            }) | ({
+                imageParams?: MulmoImageParams;
+                movieFile?: string;
+                beatDuration?: number;
                 soundEffectFile?: string;
                 soundEffectPrompt?: string;
                 soundEffectModel?: string;
@@ -80,29 +67,31 @@ export declare const beat_graph_data: {
                 lipSyncModel?: string;
                 lipSyncAgentName?: string;
                 lipSyncTrimAudio?: boolean;
-                bgmFile?: string | null;
                 startAt?: number;
                 duration?: number;
+                bgmFile?: string | null;
                 audioFile?: string;
-                beatDuration?: number;
                 movieAgentInfo?: {
                     agent: string;
                     movieParams: import("../types/type.js").MulmoMovieParams;
                 };
-                markdown?: string;
-                html?: string;
-                htmlPrompt?: undefined;
-                htmlImageFile?: undefined;
-                htmlPath?: undefined;
-                htmlImageSystemPrompt?: undefined;
-            } | {
-                imagePath: string;
-                referenceImageForMovie: string;
+            } & {
+                imagePath?: string;
+            } & {
                 imageAgentInfo: import("../types/type.js").Text2ImageAgentInfo;
                 prompt: string;
                 referenceImages: string[];
-                imageParams: MulmoImageParams;
-                movieFile: string | undefined;
+                referenceImageForMovie: string;
+            }) | {
+                imagePath: string;
+                htmlPrompt: string;
+                htmlPath: string;
+                htmlImageSystemPrompt: string;
+                htmlImageFile: string;
+            } | ({
+                imageParams?: MulmoImageParams;
+                movieFile?: string;
+                beatDuration?: number;
                 soundEffectFile?: string;
                 soundEffectPrompt?: string;
                 soundEffectModel?: string;
@@ -114,22 +103,48 @@ export declare const beat_graph_data: {
                 lipSyncModel?: string;
                 lipSyncAgentName?: string;
                 lipSyncTrimAudio?: boolean;
-                bgmFile?: string | null;
                 startAt?: number;
                 duration?: number;
+                bgmFile?: string | null;
                 audioFile?: string;
+                movieAgentInfo?: {
+                    agent: string;
+                    movieParams: import("../types/type.js").MulmoMovieParams;
+                };
+            } & {
+                imagePath?: string;
+            } & {
+                imageFromMovie: boolean;
+            }) | ({
+                imageParams?: MulmoImageParams;
+                movieFile?: string;
                 beatDuration?: number;
+                soundEffectFile?: string;
+                soundEffectPrompt?: string;
+                soundEffectModel?: string;
+                soundEffectAgentInfo?: {
+                    agentName: string;
+                    defaultModel: string;
+                };
+                lipSyncFile?: string;
+                lipSyncModel?: string;
+                lipSyncAgentName?: string;
+                lipSyncTrimAudio?: boolean;
+                startAt?: number;
+                duration?: number;
+                bgmFile?: string | null;
+                audioFile?: string;
                 movieAgentInfo?: {
                     agent: string;
                     movieParams: import("../types/type.js").MulmoMovieParams;
                 };
-                markdown?: string;
-                html?: string;
-                htmlPrompt?: undefined;
-                htmlImageFile?: undefined;
-                htmlPath?: undefined;
-                htmlImageSystemPrompt?: undefined;
-            }>;
+            } & {
+                imagePath?: string;
+            } & {
+                referenceImageForMovie: string;
+                markdown: string;
+                html: string;
+            })>;
             inputs: {
                 context: string;
                 beat: string;

package/lib/actions/index.d.ts

@@ -8,3 +8,4 @@ export * from "./pdf.js";
 export * from "./translate.js";
 export * from "./markdown.js";
 export * from "./html.js";
+export * from "./bundle.js";

package/lib/actions/index.js

@@ -8,3 +8,4 @@ export * from "./pdf.js";
 export * from "./translate.js";
 export * from "./markdown.js";
 export * from "./html.js";
+export * from "./bundle.js";

package/lib/actions/pdf.js

@@ -4,14 +4,14 @@ import puppeteer from "puppeteer";
 import { GraphAILogger, sleep } from "graphai";
 import { MulmoPresentationStyleMethods } from "../methods/index.js";
 import { localizedText, isHttp } from "../utils/utils.js";
-import { getOutputPdfFilePath, writingMessage, getHTMLFile } from "../utils/file.js";
+import { getOutputPdfFilePath, writingMessage, getHTMLFile, mulmoCreditPath } from "../utils/file.js";
 import { interpolate } from "../utils/markdown.js";
 import { MulmoStudioContextMethods } from "../methods/mulmo_studio_context.js";
 const isCI = process.env.CI === "true";
 const getPdfSize = (pdfSize) => {
     return pdfSize === "a4" ? "A4" : "Letter";
 };
-const loadImage = async (imagePath) => {
+const loadImage = async (imagePath, index) => {
     try {
         const imageData = isHttp(imagePath) ? Buffer.from(await (await fetch(imagePath)).arrayBuffer()) : fs.readFileSync(imagePath);
         const ext = path.extname(imagePath).toLowerCase().replace(".", "");
@@ -19,8 +19,8 @@ const loadImage = async (imagePath) => {
         return `data:image/${mimeType};base64,${imageData.toString("base64")}`;
     }
     catch (error) {
-        GraphAILogger.info("loadImage failed", error);
-        const placeholderData = fs.readFileSync("assets/images/mulmocast_credit.png");
+        GraphAILogger.info(`loadImage failed: file: ${imagePath} index: ${index}`, error);
+        const placeholderData = fs.readFileSync(mulmoCreditPath());
         return `data:image/png;base64,${placeholderData.toString("base64")}`;
     }
 };
@@ -100,9 +100,9 @@ const generatePDFHTML = async (context, pdfMode, pdfSize) => {
     const { studio, multiLingual, lang = "en" } = context;
     const { width: imageWidth, height: imageHeight } = MulmoPresentationStyleMethods.getCanvasSize(context.presentationStyle);
     const isLandscapeImage = imageWidth > imageHeight;
-    const imagePaths = studio.beats.map((beat) => beat.imageFile);
+    const imageFiles = studio.beats.map((beat) => beat.htmlImageFile ?? beat.imageFile);
     const texts = studio.script.beats.map((beat, index) => localizedText(beat, multiLingual?.[index], lang));
-    const imageDataUrls = await Promise.all(imagePaths.map(loadImage));
+    const imageDataUrls = await Promise.all(imageFiles.map(loadImage));
     const defaultPageSize = `${getPdfSize(pdfSize)} ${isLandscapeImage ? "landscape" : "portrait"}`;
     const pageSize = pdfMode === "handout" ? `${getPdfSize(pdfSize)} portrait` : defaultPageSize;
     const pagesHTML = generatePagesHTML(pdfMode, imageDataUrls, texts);

package/lib/agents/image_openai_agent.js

@@ -1,9 +1,9 @@
 import fs from "fs";
 import path from "path";
 import { GraphAILogger } from "graphai";
-import OpenAI, { toFile, AuthenticationError, RateLimitError } from "openai";
+import OpenAI, { toFile, AuthenticationError, RateLimitError, APIError } from "openai";
 import { provider2ImageAgent } from "../utils/provider2agent.js";
-import { apiKeyMissingError, agentGenerationError, agentIncorrectAPIKeyError, agentAPIRateLimitError, agentInvalidResponseError, imageAction, imageFileTarget, } from "../utils/error_cause.js";
+import { apiKeyMissingError, agentGenerationError, openAIAgentGenerationError, agentIncorrectAPIKeyError, agentAPIRateLimitError, agentInvalidResponseError, imageAction, imageFileTarget, } from "../utils/error_cause.js";
 // https://platform.openai.com/docs/guides/image-generation
 export const imageOpenaiAgent = async ({ namedInputs, params, config, }) => {
     const { prompt, referenceImages } = namedInputs;
@@ -80,6 +80,18 @@ export const imageOpenaiAgent = async ({ namedInputs, params, config, }) => {
                     cause: agentAPIRateLimitError("imageOpenaiAgent", imageAction, imageFileTarget),
                 });
             }
+            if (error instanceof APIError) {
+                if (error.code && error.type) {
+                    throw new Error("Failed to generate image with OpenAI", {
+                        cause: openAIAgentGenerationError("imageOpenaiAgent", imageAction, error.code, error.type),
+                    });
+                }
+                if (error.type === "invalid_request_error" && error?.error?.message?.includes("Your organization must be verified")) {
+                    throw new Error("Failed to generate image with OpenAI", {
+                        cause: openAIAgentGenerationError("imageOpenaiAgent", imageAction, "need_verified_organization", error.type),
+                    });
+                }
+            }
             throw new Error("Failed to generate image with OpenAI", {
                 cause: agentGenerationError("imageOpenaiAgent", imageAction, imageFileTarget),
             });

package/lib/cli/bin.js

@@ -11,6 +11,7 @@ import * as imagesCmd from "./commands/image/index.js";
 import * as movieCmd from "./commands/movie/index.js";
 import * as pdfCmd from "./commands/pdf/index.js";
 import * as markdownCmd from "./commands/markdown/index.js";
+import * as bundleCmd from "./commands/bundle/index.js";
 import * as htmlCmd from "./commands/html/index.js";
 import * as toolCmd from "./commands/tool/index.js";
 import { GraphAILogger } from "graphai";
@@ -36,6 +37,7 @@ export const main = async () => {
         .command(movieCmd)
         .command(pdfCmd)
         .command(markdownCmd)
+        .command(bundleCmd)
         .command(htmlCmd)
         .command(toolCmd)
         .demandCommand()

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

@@ -0,0 +1,14 @@
+import type { Argv } from "yargs";
+export declare const builder: (yargs: Argv) => Argv<{
+    o: string | undefined;
+} & {
+    b: string | undefined;
+} & {
+    l: string | undefined;
+} & {
+    f: boolean;
+} & {
+    p: string | undefined;
+} & {
+    file: string | undefined;
+}>;

package/lib/cli/commands/bundle/builder.js

@@ -0,0 +1,4 @@
+import { commonOptions } from "../../common.js";
+export const builder = (yargs) => 
+// zip
+commonOptions(yargs);

package/lib/cli/commands/bundle/handler.d.ts

@@ -0,0 +1,4 @@
+import { CliArgs } from "../../../types/cli_types.js";
+export declare const handler: (argv: CliArgs<{
+    image_width?: string;
+}>) => Promise<void>;

package/lib/cli/commands/bundle/handler.js

@@ -0,0 +1,14 @@
+import { mulmoViewerBundle, audio, images, translate } from "../../../actions/index.js";
+import { initializeContext } from "../../helpers.js";
+import { bundleTargetLang } from "../../../utils/const.js";
+export const handler = async (argv) => {
+    const context = await initializeContext(argv);
+    if (!context) {
+        process.exit(1);
+    }
+    await translate(context, { targetLangs: bundleTargetLang });
+    for (const lang of bundleTargetLang.filter((_lang) => _lang !== context.lang)) {
+        await audio({ ...context, lang });
+    }
+    await audio(context).then(images).then(mulmoViewerBundle);
+};

package/lib/cli/commands/bundle/index.d.ts

@@ -0,0 +1,4 @@
+export declare const command = "bundle <file>";
+export declare const desc = "Generate bundle files";
+export { builder } from "./builder.js";
+export { handler } from "./handler.js";

package/lib/cli/commands/bundle/index.js

@@ -0,0 +1,4 @@
+export const command = "bundle <file>";
+export const desc = "Generate bundle files";
+export { builder } from "./builder.js";
+export { handler } from "./handler.js";

package/lib/utils/const.d.ts

@@ -10,3 +10,4 @@ export declare const storyToScriptGenerateMode: {
     stepWise: string;
     oneStep: string;
 };
+export declare const bundleTargetLang: string[];

package/lib/utils/const.js

@@ -10,3 +10,4 @@ export const storyToScriptGenerateMode = {
     stepWise: "step_wise",
     oneStep: "one_step",
 };
+export const bundleTargetLang = ["ja", "en"];

package/lib/utils/error_cause.d.ts

@@ -159,6 +159,14 @@ export declare const agentGenerationError: (agentName: string, action: string, t
     target: string;
     agentName: string;
 };
+export declare const openAIAgentGenerationError: (agentName: string, action: string, errorCode: string, errorType: string, beatIndex?: number) => {
+    beatIndex?: number | undefined;
+    type: string;
+    action: string;
+    agentName: string;
+    errorCode: string;
+    errorType: string;
+};
 export declare const agentIncorrectAPIKeyError: (agentName: string, action: string, target: string, beatIndex?: number) => {
     beatIndex?: number | undefined;
     type: string;

package/lib/utils/error_cause.js

@@ -173,6 +173,17 @@ export const agentGenerationError = (agentName, action, target, beatIndex) => {
         ...(beatIndex !== undefined && { beatIndex }),
     };
 };
+// OpenAI Agent API/Generation Errors
+export const openAIAgentGenerationError = (agentName, action, errorCode, errorType, beatIndex) => {
+    return {
+        type: apiErrorType,
+        action,
+        agentName,
+        errorCode,
+        errorType,
+        ...(beatIndex !== undefined && { beatIndex }),
+    };
+};
 // Agent API/Incorrect Key Errors
 export const agentIncorrectAPIKeyError = (agentName, action, target, beatIndex) => {
     return {

package/lib/utils/zip.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Promise-based ZIP archive builder
+ *
+ * @example
+ * const zipper = new ZipBuilder("output.zip");
+ * zipper.addFile("file1.txt", "renamed.txt");
+ * zipper.addFile("file2.txt");
+ * await zipper.finalize();
+ */
+export declare class ZipBuilder {
+    private archive;
+    private output;
+    private outputPath;
+    private finalized;
+    constructor(outputPath: string);
+    /**
+     * Add a file to the archive
+     * @param filePath - Path to the file to add
+     * @param nameInZip - Optional name for the file inside the ZIP (defaults to basename)
+     */
+    addFile(filePath: string, nameInZip?: string): void;
+    /**
+     * Add multiple files to the archive
+     * @param files - Array of file paths or objects with path and name
+     */
+    addFiles(files: Array<string | {
+        path: string;
+        name?: string;
+    }>): void;
+    /**
+     * Add a directory to the archive
+     * @param dirPath - Path to the directory to add
+     * @param destPath - Optional destination path inside the ZIP
+     */
+    addDirectory(dirPath: string, destPath?: string): void;
+    /**
+     * Add content from a string or buffer
+     * @param content - String or Buffer content
+     * @param nameInZip - Name for the file inside the ZIP
+     */
+    addContent(content: string | Buffer, nameInZip: string): void;
+    /**
+     * Finalize the archive and return a promise that resolves when complete
+     * @returns Promise that resolves with the output file path
+     */
+    finalize(): Promise<string>;
+    /**
+     * Get the output file path
+     */
+    getOutputPath(): string;
+}

package/lib/utils/zip.js

@@ -0,0 +1,119 @@
+import fs from "fs";
+import archiver from "archiver";
+import path from "path";
+/**
+ * Promise-based ZIP archive builder
+ *
+ * @example
+ * const zipper = new ZipBuilder("output.zip");
+ * zipper.addFile("file1.txt", "renamed.txt");
+ * zipper.addFile("file2.txt");
+ * await zipper.finalize();
+ */
+export class ZipBuilder {
+    archive;
+    output;
+    outputPath;
+    finalized = false;
+    constructor(outputPath) {
+        this.outputPath = outputPath;
+        this.output = fs.createWriteStream(outputPath);
+        this.archive = archiver("zip", {
+            zlib: { level: 9 }, // Maximum compression level
+        });
+        // Pipe archive data to the file
+        this.archive.pipe(this.output);
+        // Error handling
+        this.archive.on("error", (err) => {
+            throw err;
+        });
+        this.archive.on("warning", (err) => {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+            // console.warn("ZIP warning:", err);
+        });
+    }
+    /**
+     * Add a file to the archive
+     * @param filePath - Path to the file to add
+     * @param nameInZip - Optional name for the file inside the ZIP (defaults to basename)
+     */
+    addFile(filePath, nameInZip) {
+        if (this.finalized) {
+            throw new Error("Cannot add files after finalize() has been called");
+        }
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const name = nameInZip ?? path.basename(filePath);
+        this.archive.file(filePath, { name });
+    }
+    /**
+     * Add multiple files to the archive
+     * @param files - Array of file paths or objects with path and name
+     */
+    addFiles(files) {
+        files.forEach((file) => {
+            if (typeof file === "string") {
+                this.addFile(file);
+            }
+            else {
+                this.addFile(file.path, file.name);
+            }
+        });
+    }
+    /**
+     * Add a directory to the archive
+     * @param dirPath - Path to the directory to add
+     * @param destPath - Optional destination path inside the ZIP
+     */
+    addDirectory(dirPath, destPath) {
+        if (this.finalized) {
+            throw new Error("Cannot add directory after finalize() has been called");
+        }
+        if (!fs.existsSync(dirPath)) {
+            throw new Error(`Directory not found: ${dirPath}`);
+        }
+        const dest = destPath ?? path.basename(dirPath);
+        this.archive.directory(dirPath, dest);
+    }
+    /**
+     * Add content from a string or buffer
+     * @param content - String or Buffer content
+     * @param nameInZip - Name for the file inside the ZIP
+     */
+    addContent(content, nameInZip) {
+        if (this.finalized) {
+            throw new Error("Cannot add content after finalize() has been called");
+        }
+        this.archive.append(content, { name: nameInZip });
+    }
+    /**
+     * Finalize the archive and return a promise that resolves when complete
+     * @returns Promise that resolves with the output file path
+     */
+    async finalize() {
+        if (this.finalized) {
+            throw new Error("Archive has already been finalized");
+        }
+        this.finalized = true;
+        return new Promise((resolve, reject) => {
+            this.output.on("close", () => {
+                // const bytes = this.archive.pointer();
+                // console.log(`ZIP archive created: ${this.outputPath} (${bytes} bytes)`);
+                resolve(this.outputPath);
+            });
+            this.output.on("error", reject);
+            this.archive.on("error", reject);
+            // Finalize the archive
+            this.archive.finalize();
+        });
+    }
+    /**
+     * Get the output file path
+     */
+    getOutputPath() {
+        return this.outputPath;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mulmocast",
-  "version": "1.2.63",
+  "version": "1.2.65",
   "description": "",
   "type": "module",
   "main": "lib/index.node.js",
@@ -71,8 +71,8 @@
   },
   "homepage": "https://github.com/receptron/mulmocast-cli#readme",
   "dependencies": {
-    "@google-cloud/text-to-speech": "^6.3.0",
-    "@google/genai": "^1.22.0",
+    "@google-cloud/text-to-speech": "^6.3.1",
+    "@google/genai": "^1.25.0",
     "@graphai/anthropic_agent": "^2.0.11",
     "@graphai/browserless_agent": "^2.0.1",
     "@graphai/gemini_agent": "^2.0.1",
@@ -82,21 +82,22 @@
     "@graphai/stream_agent_filter": "^2.0.2",
     "@graphai/vanilla": "^2.0.12",
     "@graphai/vanilla_node_agents": "^2.0.4",
-    "@inquirer/input": "^4.2.4",
-    "@inquirer/select": "^4.3.4",
-    "@modelcontextprotocol/sdk": "^1.19.1",
+    "@inquirer/input": "^4.2.5",
+    "@inquirer/select": "^4.4.0",
+    "@modelcontextprotocol/sdk": "^1.20.1",
     "@mozilla/readability": "^0.6.0",
     "@tavily/core": "^0.5.11",
+    "archiver": "^7.0.1",
     "clipboardy": "^4.0.0",
     "dotenv": "^17.2.3",
     "fluent-ffmpeg": "^2.1.3",
     "graphai": "^2.0.16",
     "jsdom": "^27.0.0",
-    "marked": "^16.3.0",
+    "marked": "^16.4.1",
     "mulmocast-vision": "^1.0.4",
     "ora": "^9.0.0",
-    "puppeteer": "^24.23.0",
-    "replicate": "^1.2.0",
+    "puppeteer": "^24.25.0",
+    "replicate": "^1.3.0",
     "yaml": "^2.8.1",
     "yargs": "^18.0.0",
     "zod": "^3.25.76",
@@ -104,17 +105,18 @@
   },
   "devDependencies": {
     "@receptron/test_utils": "^2.0.3",
+    "@types/archiver": "^6.0.3",
     "@types/fluent-ffmpeg": "^2.1.26",
     "@types/jsdom": "^27.0.0",
     "@types/yargs": "^17.0.33",
-    "eslint": "^9.37.0",
+    "eslint": "^9.38.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-sonarjs": "^3.0.5",
     "prettier": "^3.6.2",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.0"
+    "typescript-eslint": "^8.46.1"
   },
   "engines": {
     "node": ">=20.0.0"