mulmocast 0.0.1

package/lib/actions/images.js

@@ -0,0 +1,211 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.images = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const graphai_1 = require("graphai");
+const agents = __importStar(require("@graphai/vanilla"));
+const vanilla_node_agents_1 = require("@graphai/vanilla_node_agents");
+const file_1 = require("../utils/file");
+const filters_1 = require("../utils/filters");
+const markdown_1 = require("../utils/markdown");
+const image_google_agent_1 = __importDefault(require("../agents/image_google_agent"));
+const image_openai_agent_1 = __importDefault(require("../agents/image_openai_agent"));
+const methods_1 = require("../methods");
+dotenv_1.default.config();
+// const openai = new OpenAI();
+const google_auth_library_1 = require("google-auth-library");
+const preprocess_agent = async (namedInputs) => {
+    const { context, beat, index, suffix, imageDirPath } = namedInputs;
+    const imageParams = { ...context.studio.script.imageParams, ...beat.imageParams };
+    const prompt = (beat.imagePrompt || beat.text) + "\n" + (imageParams.style || "");
+    const imagePath = `${imageDirPath}/${context.studio.filename}/${index}${suffix}.png`;
+    const aspectRatio = methods_1.MulmoScriptMethods.getAspectRatio(context.studio.script);
+    if (beat.image) {
+        if (beat.image.type === "textSlide") {
+            const slide = beat.image.slide;
+            const markdown = `# ${slide.title}` + slide.bullets.map((text) => `- ${text}`).join("\n");
+            await (0, markdown_1.convertMarkdownToImage)(markdown, methods_1.MulmoScriptMethods.getTextSlideStyle(context.studio.script, beat), imagePath);
+        }
+        else if (beat.image.type === "markdown") {
+            const markdown = Array.isArray(beat.image.markdown) ? beat.image.markdown.join("\n") : beat.image.markdown;
+            await (0, markdown_1.convertMarkdownToImage)(markdown, methods_1.MulmoScriptMethods.getTextSlideStyle(context.studio.script, beat), imagePath);
+        }
+        else if (beat.image.type === "image") {
+            if (beat.image.source.kind === "url") {
+                // undefined prompt indicates "no need to generate image"
+                return { path: beat.image.source.url, prompt: undefined, imageParams, aspectRatio };
+            }
+            else if (beat.image.source.kind === "path") {
+                const path = methods_1.MulmoStudioContextMethods.resolveAssetPath(context, beat.image.source.path);
+                return { path, prompt: undefined, imageParams, aspectRatio };
+            }
+        }
+    }
+    return { path: imagePath, prompt, imageParams, aspectRatio };
+};
+const graph_data = {
+    version: 0.5,
+    concurrency: 2,
+    nodes: {
+        context: {},
+        imageDirPath: {},
+        text2imageAgent: {},
+        outputStudioFilePath: {},
+        map: {
+            agent: "mapAgent",
+            inputs: { rows: ":context.studio.beats", context: ":context", text2imageAgent: ":text2imageAgent", imageDirPath: ":imageDirPath" },
+            isResult: true,
+            params: {
+                rowKey: "beat",
+                compositeResult: true,
+            },
+            graph: {
+                nodes: {
+                    preprocessor: {
+                        agent: preprocess_agent,
+                        inputs: {
+                            context: ":context",
+                            beat: ":beat",
+                            index: ":__mapIndex",
+                            suffix: "p",
+                            imageDirPath: ":imageDirPath",
+                        },
+                    },
+                    imageGenerator: {
+                        if: ":preprocessor.prompt",
+                        agent: ":text2imageAgent",
+                        params: {
+                            model: ":preprocessor.imageParams.model",
+                            size: ":preprocessor.imageParams.size",
+                            moderation: ":preprocessor.imageParams.moderation",
+                            aspectRatio: ":preprocessor.aspectRatio",
+                        },
+                        inputs: {
+                            prompt: ":preprocessor.prompt",
+                            file: ":preprocessor.path", // only for fileCacheAgentFilter
+                            text: ":preprocessor.prompt", // only for fileCacheAgentFilter
+                        },
+                        defaultValue: {},
+                    },
+                    output: {
+                        agent: "copyAgent",
+                        inputs: {
+                            result: ":imageGenerator",
+                            image: ":preprocessor.path",
+                        },
+                        output: {
+                            imageFile: ".image",
+                        },
+                        isResult: true,
+                    },
+                },
+            },
+        },
+        mergeResult: {
+            agent: (namedInputs) => {
+                const { array, context } = namedInputs;
+                const { studio } = context;
+                array.forEach((update, index) => {
+                    const beat = studio.beats[index];
+                    studio.beats[index] = { ...beat, ...update };
+                });
+                // console.log(namedInputs);
+                return { studio };
+            },
+            inputs: {
+                array: ":map.output",
+                context: ":context",
+            },
+        },
+        writeOutout: {
+            // console: { before: true },
+            agent: "fileWriteAgent",
+            inputs: {
+                file: ":outputStudioFilePath",
+                text: ":mergeResult.studio.toJSON()",
+            },
+        },
+    },
+};
+const googleAuth = async () => {
+    const auth = new google_auth_library_1.GoogleAuth({
+        scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+    });
+    const client = await auth.getClient();
+    const accessToken = await client.getAccessToken();
+    return accessToken.token;
+};
+const images = async (context) => {
+    const { studio, fileDirs } = context;
+    const { outDirPath, imageDirPath } = fileDirs;
+    (0, file_1.mkdir)(`${imageDirPath}/${studio.filename}`);
+    const agentFilters = [
+        {
+            name: "fileCacheAgentFilter",
+            agent: filters_1.fileCacheAgentFilter,
+            nodeIds: ["imageGenerator"],
+        },
+    ];
+    const options = {
+        agentFilters,
+    };
+    // We need to get google's auth token only if the google is the text2image provider.
+    if (methods_1.MulmoScriptMethods.getImageProvider(studio.script) === "google") {
+        console.log("google was specified as text2image engine");
+        const token = await googleAuth();
+        options.config = {
+            imageGoogleAgent: {
+                projectId: process.env.GOOGLE_PROJECT_ID,
+                token,
+            },
+        };
+    }
+    const injections = {
+        context,
+        text2imageAgent: methods_1.MulmoScriptMethods.getText2imageAgent(studio.script),
+        outputStudioFilePath: (0, file_1.getOutputStudioFilePath)(outDirPath, studio.filename),
+        imageDirPath,
+    };
+    const graph = new graphai_1.GraphAI(graph_data, { ...agents, imageGoogleAgent: image_google_agent_1.default, imageOpenaiAgent: image_openai_agent_1.default, fileWriteAgent: vanilla_node_agents_1.fileWriteAgent }, options);
+    Object.keys(injections).forEach((key) => {
+        graph.injectValue(key, injections[key]);
+    });
+    await graph.run();
+};
+exports.images = images;

package/lib/actions/movie.d.ts

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

package/lib/actions/movie.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.movie = void 0;
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const methods_1 = require("../methods");
+const file_1 = require("../utils/file");
+const createVideo = (audioPath, outputVideoPath, studio) => {
+    const start = performance.now();
+    let command = (0, fluent_ffmpeg_1.default)();
+    if (studio.beats.some((beat) => !beat.imageFile)) {
+        console.error("beat.imageFile is not set. Please run `yarn run images ${file}` ");
+        return;
+    }
+    // Add each image input
+    studio.beats.forEach((beat) => {
+        command = command.input(beat.imageFile); // HACK
+    });
+    const imageCount = studio.beats.length;
+    const canvasInfo = methods_1.MulmoScriptMethods.getCanvasSize(studio.script);
+    const filterComplexParts = [];
+    studio.beats.forEach((beat, index) => {
+        // Resize background image to match canvas dimensions
+        const duration = beat.duration + (index === 0 ? methods_1.MulmoScriptMethods.getPadding(studio.script) / 1000 : 0);
+        const parts = `[${index}:v]loop=loop=-1:size=1:start=0,` +
+            `trim=duration=${duration},` +
+            `fps=30,` +
+            `setpts=PTS-STARTPTS,` +
+            `scale=${canvasInfo.width}:${canvasInfo.height},` +
+            `setsar=1,format=yuv420p` +
+            `[v${index}]`;
+        // console.log(parts);
+        filterComplexParts.push(parts);
+    });
+    // Concatenate the trimmed images
+    const concatInput = studio.beats.map((_, index) => `[v${index}]`).join("");
+    filterComplexParts.push(`${concatInput}concat=n=${imageCount}:v=1:a=0[v]`);
+    // Apply the filter complex for concatenation and map audio input
+    command
+        .complexFilter(filterComplexParts)
+        .input(audioPath) // Add audio input
+        .outputOptions([
+        "-preset veryfast", // Faster encoding
+        "-map [v]", // Map the video stream
+        `-map ${imageCount /* + captionCount*/}:a`, // Map the audio stream (audio is the next input after all images)
+        "-c:v h264_videotoolbox", // Set video codec
+        "-threads 8",
+        "-filter_threads 8",
+        "-b:v 5M", // bitrate (only for videotoolbox)
+        "-bufsize",
+        "10M", // Add buffer size for better quality
+        "-maxrate",
+        "7M", // Maximum bitrate
+        "-r 30", // Set frame rate
+        "-pix_fmt yuv420p", // Set pixel format for better compatibility
+    ])
+        .on("start", (__cmdLine) => {
+        console.log("Started FFmpeg ..."); // with command:', cmdLine);
+    })
+        .on("error", (err, stdout, stderr) => {
+        console.error("Error occurred:", err);
+        console.error("FFmpeg stdout:", stdout);
+        console.error("FFmpeg stderr:", stderr);
+    })
+        .on("end", () => {
+        const end = performance.now();
+        console.log(`Video created successfully! ${Math.round(end - start) / 1000} sec`);
+    })
+        .output(outputVideoPath)
+        .run();
+};
+const movie = async (context) => {
+    const { studio, fileDirs } = context;
+    const { outDirPath } = fileDirs;
+    const audioPath = (0, file_1.getOutputBGMFilePath)(outDirPath, studio.filename);
+    const outputVideoPath = (0, file_1.getOutputVideoFilePath)(outDirPath, studio.filename);
+    createVideo(audioPath, outputVideoPath, studio);
+};
+exports.movie = movie;

package/lib/actions/translate.d.ts

@@ -0,0 +1,3 @@
+import "dotenv/config";
+import { MulmoStudioContext } from "../types";
+export declare const translate: (context: MulmoStudioContext) => Promise<void>;

package/lib/actions/translate.js

@@ -0,0 +1,236 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translate = void 0;
+require("dotenv/config");
+const graphai_1 = require("graphai");
+const agents = __importStar(require("@graphai/vanilla"));
+const openai_agent_1 = require("@graphai/openai_agent");
+const vanilla_node_agents_1 = require("@graphai/vanilla_node_agents");
+const string_1 = require("../utils/string");
+const file_1 = require("../utils/file");
+const translateGraph = {
+    version: 0.5,
+    nodes: {
+        studio: {},
+        defaultLang: {},
+        outDirPath: {},
+        outputStudioFilePath: {},
+        lang: {
+            agent: "stringUpdateTextAgent",
+            inputs: {
+                newText: ":studio.script.lang",
+                oldText: ":defaultLang",
+            },
+        },
+        targetLangs: {}, // TODO
+        mergeStudioResult: {
+            isResult: true,
+            agent: "mergeObjectAgent",
+            inputs: {
+                items: [":studio", { beats: ":beatsMap.mergeBeatData" }],
+            },
+        },
+        beatsMap: {
+            agent: "mapAgent",
+            inputs: {
+                targetLangs: ":targetLangs",
+                rows: ":studio.beats",
+                lang: ":lang",
+            },
+            params: {
+                rowKey: "beat",
+                compositeResult: true,
+            },
+            graph: {
+                version: 0.5,
+                nodes: {
+                    preprocessBeats: {
+                        agent: "mapAgent",
+                        inputs: {
+                            beat: ":beat",
+                            rows: ":targetLangs",
+                            lang: ":lang.text",
+                        },
+                        params: {
+                            compositeResult: true,
+                            rowKey: "targetLang",
+                        },
+                        graph: {
+                            version: 0.5,
+                            nodes: {
+                                localizedTexts: {
+                                    inputs: {
+                                        targetLang: ":targetLang",
+                                        beat: ":beat",
+                                        lang: ":lang",
+                                        system: "Please translate the given text into the language specified in language (in locale format, like en, ja, fr, ch).",
+                                        prompt: ["## Original Language", ":lang", "", "## Language", ":targetLang", "", "## Target", ":beat.text"],
+                                    },
+                                    passThrough: {
+                                        lang: ":targetLang",
+                                    },
+                                    output: {
+                                        text: ".text",
+                                    },
+                                    // return { lang, text } <- localizedText
+                                    agent: "openAIAgent",
+                                },
+                                splitText: {
+                                    agent: (namedInputs) => {
+                                        const { localizedText, targetLang } = namedInputs;
+                                        // Cache
+                                        if (localizedText.texts) {
+                                            return localizedText;
+                                        }
+                                        if (targetLang === "ja") {
+                                            return {
+                                                ...localizedText,
+                                                texts: (0, string_1.recursiveSplitJa)(localizedText.text),
+                                            };
+                                        }
+                                        // not split
+                                        return {
+                                            ...localizedText,
+                                            texts: [localizedText.text],
+                                        };
+                                        // return { lang, text, texts }
+                                    },
+                                    inputs: {
+                                        targetLang: ":targetLang",
+                                        localizedText: ":localizedTexts",
+                                    },
+                                },
+                                ttsTexts: {
+                                    agent: (namedInputs) => {
+                                        const { localizedText, targetLang } = namedInputs;
+                                        // cache
+                                        if (localizedText.ttsTexts) {
+                                            return localizedText;
+                                        }
+                                        if (targetLang === "ja") {
+                                            return {
+                                                ...localizedText,
+                                                ttsTexts: localizedText?.texts?.map((text) => (0, string_1.replacePairsJa)(text, string_1.replacementsJa)),
+                                            };
+                                        }
+                                        return {
+                                            ...localizedText,
+                                            ttsTexts: localizedText.texts,
+                                        };
+                                    },
+                                    inputs: {
+                                        targetLang: ":targetLang",
+                                        localizedText: ":splitText",
+                                    },
+                                    isResult: true,
+                                },
+                            },
+                        },
+                    },
+                    mergeLocalizedText: {
+                        agent: "arrayToObjectAgent",
+                        inputs: {
+                            items: ":preprocessBeats.ttsTexts",
+                        },
+                        params: {
+                            key: "lang",
+                        },
+                    },
+                    mergeBeatData: {
+                        isResult: true,
+                        agent: "mergeObjectAgent",
+                        inputs: {
+                            items: [":beat", { multiLingualTexts: ":mergeLocalizedText" }],
+                        },
+                    },
+                },
+            },
+        },
+        writeOutout: {
+            // console: { before: true },
+            agent: "fileWriteAgent",
+            inputs: {
+                file: ":outputStudioFilePath",
+                text: ":mergeStudioResult.toJSON()",
+            },
+        },
+    },
+};
+const localizedTextCacheAgentFilter = async (context, next) => {
+    const { namedInputs } = context;
+    const { targetLang, beat, lang } = namedInputs;
+    // The original text is unchanged and the target language text is present
+    if (beat.multiLingualTexts &&
+        beat.multiLingualTexts[lang] &&
+        beat.multiLingualTexts[lang].text === beat.text &&
+        beat.multiLingualTexts[targetLang] &&
+        beat.multiLingualTexts[targetLang].text) {
+        return { text: beat.multiLingualTexts[targetLang].text };
+    }
+    // same language
+    if (targetLang === lang) {
+        return { text: beat.text };
+    }
+    return await next(context);
+};
+const agentFilters = [
+    {
+        name: "localizedTextCacheAgentFilter",
+        agent: localizedTextCacheAgentFilter,
+        nodeIds: ["localizedTexts"],
+    },
+];
+const defaultLang = "en";
+const targetLangs = ["ja", "en"];
+const translate = async (context) => {
+    const { studio, fileDirs } = context;
+    const { outDirPath } = fileDirs;
+    const outputStudioFilePath = (0, file_1.getOutputStudioFilePath)(outDirPath, studio.filename);
+    (0, file_1.mkdir)(outDirPath);
+    (0, graphai_1.assert)(!!process.env.OPENAI_API_KEY, "The OPENAI_API_KEY environment variable is missing or empty");
+    const graph = new graphai_1.GraphAI(translateGraph, { ...agents, fileWriteAgent: vanilla_node_agents_1.fileWriteAgent, openAIAgent: openai_agent_1.openAIAgent }, { agentFilters });
+    graph.injectValue("studio", studio);
+    graph.injectValue("defaultLang", defaultLang);
+    graph.injectValue("targetLangs", targetLangs);
+    graph.injectValue("outDirPath", outDirPath);
+    graph.injectValue("outputStudioFilePath", outputStudioFilePath);
+    await graph.run();
+    (0, file_1.writingMessage)(outputStudioFilePath);
+    // const results = await graph.run();
+    // const mulmoDataResult = results.mergeResult;
+    // console.log(JSON.stringify(mulmoDataResult, null, 2));
+};
+exports.translate = translate;

package/lib/agents/add_bgm_agent.d.ts

@@ -0,0 +1,3 @@
+import { AgentFunctionInfo } from "graphai";
+declare const addBGMAgentInfo: AgentFunctionInfo;
+export default addBGMAgentInfo;

package/lib/agents/add_bgm_agent.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const methods_1 = require("../methods");
+const addBGMAgent = async ({ namedInputs, params, }) => {
+    const { voiceFile, outputFile, script } = namedInputs;
+    const { musicFile } = params;
+    const promise = new Promise((resolve, reject) => {
+        fluent_ffmpeg_1.default.ffprobe(voiceFile, (err, metadata) => {
+            if (err) {
+                console.error("Error getting metadata: " + err.message);
+                reject(err);
+            }
+            const speechDuration = metadata.format.duration;
+            const padding = methods_1.MulmoScriptMethods.getPadding(script);
+            const totalDuration = (padding * 2) / 1000 + Math.round(speechDuration ?? 0);
+            console.log("totalDucation:", speechDuration, totalDuration);
+            const command = (0, fluent_ffmpeg_1.default)();
+            command
+                .input(musicFile)
+                .input(voiceFile)
+                .complexFilter([
+                // Add a 2-second delay to the speech
+                `[1:a]adelay=${padding}|${padding}, volume=4[a1]`, // 4000ms delay for both left and right channels
+                // Set the background music volume to 0.2
+                `[0:a]volume=0.2[a0]`,
+                // Mix the delayed speech and the background music
+                `[a0][a1]amix=inputs=2:duration=longest:dropout_transition=3[amixed]`,
+                // Trim the output to the length of speech + 8 seconds
+                `[amixed]atrim=start=0:end=${totalDuration}[trimmed]`,
+                // Add fade out effect for the last 4 seconds
+                `[trimmed]afade=t=out:st=${totalDuration - padding / 1000}:d=${padding}`,
+            ])
+                .on("error", (err) => {
+                console.error("Error: " + err.message);
+                reject(err);
+            })
+                .on("end", () => {
+                resolve(0);
+            })
+                .save(outputFile);
+        });
+    });
+    await promise;
+    return outputFile;
+};
+const addBGMAgentInfo = {
+    name: "addBGMAgent",
+    agent: addBGMAgent,
+    mock: addBGMAgent,
+    samples: [],
+    description: "addBGMAgent",
+    category: ["ffmpeg"],
+    author: "satoshi nakajima",
+    repository: "https://github.com/snakajima/ai-podcaster",
+    license: "MIT",
+};
+exports.default = addBGMAgentInfo;

package/lib/agents/combine_audio_files_agent.d.ts

@@ -0,0 +1,3 @@
+import { AgentFunctionInfo } from "graphai";
+declare const combineAudioFilesAgentInfo: AgentFunctionInfo;
+export default combineAudioFilesAgentInfo;

package/lib/agents/combine_audio_files_agent.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const file_1 = require("../utils/file");
+const methods_1 = require("../methods");
+const combineAudioFilesAgent = async ({ namedInputs }) => {
+    const { context, combinedFileName, scratchpadDirPath } = namedInputs;
+    const command = (0, fluent_ffmpeg_1.default)();
+    context.studio.beats.forEach((mulmoBeat, index) => {
+        const audioPath = mulmoBeat.audio?.type === "audio" &&
+            ((mulmoBeat.audio?.source.kind === "path" && methods_1.MulmoStudioContextMethods.resolveAssetPath(context, mulmoBeat.audio.source.path)) ||
+                (mulmoBeat.audio?.source.kind === "url" && mulmoBeat.audio.source.url));
+        const filePath = audioPath || (0, file_1.getScratchpadFilePath)(scratchpadDirPath, mulmoBeat.audioFile ?? "");
+        const isLast = index === context.studio.beats.length - 2;
+        command.input(filePath);
+        command.input(isLast ? file_1.silentLastPath : file_1.silentPath);
+        // Measure and log the timestamp of each section
+        fluent_ffmpeg_1.default.ffprobe(filePath, (err, metadata) => {
+            if (err) {
+                console.error("Error while getting metadata:", err);
+            }
+            else {
+                context.studio.beats[index]["duration"] = metadata.format.duration + (isLast ? 0.8 : 0.3);
+            }
+        });
+    });
+    const promise = new Promise((resolve, reject) => {
+        command
+            .on("end", () => {
+            resolve(0);
+        })
+            .on("error", (err) => {
+            console.error("Error while combining MP3 files:", err);
+            reject(err);
+        })
+            .mergeToFile(combinedFileName, scratchpadDirPath);
+    });
+    await promise;
+    return {
+        studio: context.studio,
+    };
+};
+const combineAudioFilesAgentInfo = {
+    name: "combineAudioFilesAgent",
+    agent: combineAudioFilesAgent,
+    mock: combineAudioFilesAgent,
+    samples: [],
+    description: "combineAudioFilesAgent",
+    category: ["ffmpeg"],
+    author: "satoshi nakajima",
+    repository: "https://github.com/snakajima/ai-podcaster",
+    license: "MIT",
+};
+exports.default = combineAudioFilesAgentInfo;