mulmocast 2.15.0 → 2.17.0

package/lib/utils/remotion/network_guard.js

@@ -0,0 +1,48 @@
+import { WEBRTC_REMOVAL_SCRIPT, isAllowedSceneRequest } from "./network_policy.js";
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isPausedRequest = (value) => isRecord(value) && typeof value.requestId === "string" && isRecord(value.request) && typeof value.request.url === "string";
+const isAttachedTarget = (value) => isRecord(value) && typeof value.sessionId === "string" && isRecord(value.targetInfo) && typeof value.targetInfo.type === "string";
+// Remotion types only the CDP commands it uses itself; Fetch and Runtime.runIfWaitingForDebugger
+// are sent through the same send(), which resolves on the reply and rejects on a CDP error.
+const sendCommand = async (channel, method, params = {}) => {
+    const send = Reflect.get(channel, "send");
+    if (typeof send !== "function")
+        throw new Error(`remotion: cannot send ${method}: the browser connection has no send()`);
+    await send.call(channel, method, params);
+};
+const FRAME_TARGET_TYPES = ["page", "iframe"];
+const answerRequest = async (connection, paused, serverPort, onBlocked) => {
+    if (isAllowedSceneRequest({ url: paused.request.url, isDocument: paused.resourceType === "Document" }, serverPort)) {
+        await sendCommand(connection, "Fetch.continueRequest", { requestId: paused.requestId });
+        return;
+    }
+    onBlocked(paused.request.url);
+    await sendCommand(connection, "Fetch.failRequest", { requestId: paused.requestId, errorReason: "BlockedByClient" });
+};
+// A target that could not be guarded stays paused, so its render fails instead of running unguarded.
+const guardTarget = async (browser, attached) => {
+    const session = browser.connection.session(attached.sessionId);
+    if (!session)
+        throw new Error(`remotion: no CDP session for a new ${attached.targetInfo.type}`);
+    if (FRAME_TARGET_TYPES.includes(attached.targetInfo.type)) {
+        await session.send("Page.enable");
+        await session.send("Page.addScriptToEvaluateOnNewDocument", { source: WEBRTC_REMOVAL_SCRIPT });
+    }
+    await sendCommand(session, "Runtime.runIfWaitingForDebugger");
+};
+export const guardSceneNetwork = async (browser, serverPort, onBlocked) => {
+    const guard = { failures: [] };
+    const fail = (error) => guard.failures.push(error instanceof Error ? error.message : String(error));
+    const connection = browser.connection;
+    connection.on("Fetch.requestPaused", (event) => {
+        if (isPausedRequest(event))
+            answerRequest(connection, event, serverPort, onBlocked).catch(fail);
+    });
+    connection.on("Target.attachedToTarget", (event) => {
+        if (isAttachedTarget(event))
+            guardTarget(browser, event).catch(fail);
+    });
+    await sendCommand(connection, "Fetch.enable", { patterns: [{ urlPattern: "*" }] });
+    await connection.send("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
+    return guard;
+};

package/lib/utils/remotion/network_policy.d.ts

@@ -0,0 +1,10 @@
+export type SceneRequest = {
+    url: string;
+    isDocument: boolean;
+};
+export declare const isAllowedSceneRequest: ({ url, isDocument }: SceneRequest, serverPort: number) => boolean;
+export declare const isAllowedMediaDownload: (src: string) => boolean;
+export declare const REMOTION_CONTENT_SECURITY_POLICY = "connect-src 'self' data: blob:";
+export declare const withContentSecurityPolicy: (html: string) => string;
+export declare const WEBRTC_GLOBALS: readonly ["RTCPeerConnection", "webkitRTCPeerConnection", "RTCDataChannel", "RTCIceCandidate", "RTCSessionDescription"];
+export declare const WEBRTC_REMOVAL_SCRIPT: string;

package/lib/utils/remotion/network_policy.js

@@ -0,0 +1,51 @@
+// What a remotion scene's browser may reach: only the bundle server started for that render, and
+// in-memory URLs. Kept free of I/O so the rules can be tested without a browser.
+const LOOPBACK_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+const IN_MEMORY_SCHEMES = ["data:", "blob:"];
+const parseUrl = (url) => {
+    try {
+        return new URL(url);
+    }
+    catch {
+        return undefined;
+    }
+};
+// Remotion's /proxy makes the bundle server download its `src` from Node, on the scene's behalf.
+const REMOTION_PROXY_PATH = "/proxy";
+// The only page that carries the CSP; any other HTML the server returns (a directory listing, a 404)
+// would run without it, so no other path may be loaded as a document.
+const SCENE_DOCUMENT_PATHS = ["/", "/index.html"];
+// Another port on localhost is another service, so only the render's own port counts as local.
+const isBundleServer = (parsed, serverPort) => parsed.protocol === "http:" && LOOPBACK_HOSTS.includes(parsed.hostname) && parsed.port === String(serverPort);
+export const isAllowedSceneRequest = ({ url, isDocument }, serverPort) => {
+    const parsed = parseUrl(url);
+    if (!parsed)
+        return false;
+    if (IN_MEMORY_SCHEMES.includes(parsed.protocol))
+        return true;
+    if (!isBundleServer(parsed, serverPort) || parsed.pathname.startsWith(REMOTION_PROXY_PATH))
+        return false;
+    return !isDocument || SCENE_DOCUMENT_PATHS.includes(parsed.pathname);
+};
+// Remotion downloads <Audio> / <Video> sources from Node while rendering, outside the browser;
+// a scene uses no media files, so only inline data survives.
+export const isAllowedMediaDownload = (src) => parseUrl(src)?.protocol === "data:";
+// The browser-level request block does not see WebSocket or EventSource connections; this does.
+export const REMOTION_CONTENT_SECURITY_POLICY = "connect-src 'self' data: blob:";
+const HEAD_TAG = /<head(\s[^>]*)?>/i;
+export const withContentSecurityPolicy = (html) => {
+    const match = HEAD_TAG.exec(html);
+    if (!match)
+        throw new Error("remotion: the bundle's index.html has no <head>, so the network policy cannot be applied");
+    const meta = `<meta http-equiv="Content-Security-Policy" content="${REMOTION_CONTENT_SECURITY_POLICY}">`;
+    const insertAt = match.index + match[0].length;
+    return [html.slice(0, insertAt), meta, html.slice(insertAt)].join("");
+};
+export const WEBRTC_GLOBALS = ["RTCPeerConnection", "webkitRTCPeerConnection", "RTCDataChannel", "RTCIceCandidate", "RTCSessionDescription"];
+// Run before any page script in every frame: WebRTC opens UDP connections that neither the request
+// block nor CSP covers. Non-configurable, so scene code cannot put the constructors back.
+export const WEBRTC_REMOVAL_SCRIPT = [
+    `for (const name of ${JSON.stringify(WEBRTC_GLOBALS)}) {`,
+    "  try { Object.defineProperty(globalThis, name, { value: undefined, writable: false, configurable: false }); } catch (_) {}",
+    "}",
+].join("\n");

package/lib/utils/remotion/render.js

@@ -1,10 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
+import net from "node:net";
 import { createRequire } from "node:module";
+import { GraphAILogger } from "graphai";
 import { REMOTION_COMPOSITION_ID, REMOTION_ENTRY_FILE, buildEntrySource } from "./claude_prompt.js";
 import { missingRemotionPackages, remotionInstallCommand } from "./packages.js";
+import { isAllowedMediaDownload, withContentSecurityPolicy } from "./network_policy.js";
+import { guardSceneNetwork } from "./network_guard.js";
 // WebGL (three.js scenes) needs the ANGLE backend; the default one cannot create a context headless.
 const CHROMIUM_OPTIONS = { gl: "angle" };
+const MAX_LOGGED_URL_LENGTH = 200;
 const loadRemotion = async () => {
     try {
         const [bundler, renderer] = await Promise.all([import("@remotion/bundler"), import("@remotion/renderer")]);
@@ -40,8 +45,7 @@ const remotionNodeModulesDir = () => {
     const remotionPackageJson = createRequire(import.meta.url).resolve("remotion/package.json");
     return path.dirname(path.dirname(remotionPackageJson));
 };
-export const renderRemotionScene = async ({ workDir, props, videoPath, stillPath, extraStills = [] }) => {
-    const { bundle, renderer } = await loadRemotion();
+const bundleScene = async (bundle, workDir) => {
     const entryPoint = path.join(workDir, REMOTION_ENTRY_FILE);
     fs.writeFileSync(entryPoint, buildEntrySource());
     const nodeModulesDir = remotionNodeModulesDir();
@@ -53,13 +57,53 @@ export const renderRemotionScene = async ({ workDir, props, videoPath, stillPath
             resolve: { ...config.resolve, modules: [...(config.resolve?.modules ?? ["node_modules"]), nodeModulesDir] },
         }),
     });
-    const composition = await renderer.selectComposition({ serveUrl, id: REMOTION_COMPOSITION_ID, inputProps: props, chromiumOptions: CHROMIUM_OPTIONS });
+    const indexHtml = path.join(serveUrl, "index.html");
+    fs.writeFileSync(indexHtml, withContentSecurityPolicy(fs.readFileSync(indexHtml, "utf8")));
+    return serveUrl;
+};
+const findFreePort = () => new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+        const address = server.address();
+        const port = typeof address === "object" && address ? address.port : 0;
+        server.close(() => (port > 0 ? resolve(port) : reject(new Error("remotion: could not pick a port for the bundle server"))));
+    });
+});
+const logBlockedRequest = (url) => GraphAILogger.info(`remotion: blocked a network request from the scene: ${url}`);
+// Throwing here stops remotion before it fetches, and fails the render.
+const rejectMediaDownload = (src) => {
+    if (!isAllowedMediaDownload(src))
+        throw new Error(`remotion: a scene may not load media files (${src.slice(0, MAX_LOGGED_URL_LENGTH)})`);
+    return undefined;
+};
+// The bundle server listens on the port given here, the only local origin the guard lets the scene reach.
+const renderOutputs = async (renderer, browser, serveUrl, port, outputs) => {
+    const { props, videoPath, stillPath, extraStills = [] } = outputs;
+    const shared = { serveUrl, inputProps: props, chromiumOptions: CHROMIUM_OPTIONS, puppeteerInstance: browser, port };
+    const downloadGuard = { onDownload: rejectMediaDownload };
+    const composition = await renderer.selectComposition({ ...shared, id: REMOTION_COMPOSITION_ID });
     if (videoPath) {
-        await renderer.renderMedia({ composition, serveUrl, codec: "h264", outputLocation: videoPath, inputProps: props, chromiumOptions: CHROMIUM_OPTIONS });
+        await renderer.renderMedia({ ...shared, ...downloadGuard, composition, codec: "h264", outputLocation: videoPath });
     }
     const stills = stillPath ? [...extraStills, { frame: composition.durationInFrames - 1, path: stillPath }] : extraStills;
     await stills.reduce(async (previous, still) => {
         await previous;
-        await renderer.renderStill({ composition, serveUrl, output: still.path, frame: still.frame, inputProps: props, chromiumOptions: CHROMIUM_OPTIONS });
+        await renderer.renderStill({ ...shared, ...downloadGuard, composition, output: still.path, frame: still.frame });
     }, Promise.resolve());
 };
+export const renderRemotionScene = async ({ workDir, ...outputs }) => {
+    const { bundle, renderer } = await loadRemotion();
+    const serveUrl = await bundleScene(bundle, workDir);
+    const port = await findFreePort();
+    const browser = await renderer.openBrowser("chrome", { chromiumOptions: CHROMIUM_OPTIONS });
+    try {
+        const guard = await guardSceneNetwork(browser, port, logBlockedRequest);
+        await renderOutputs(renderer, browser, serveUrl, port, outputs);
+        if (guard.failures.length > 0)
+            throw new Error(`remotion: the network guard failed: ${guard.failures.join("; ")}`);
+    }
+    finally {
+        await browser.close({ silent: true });
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mulmocast",
-  "version": "2.15.0",
+  "version": "2.17.0",
   "description": "",
   "type": "module",
   "main": "lib/index.node.js",
@@ -99,7 +99,7 @@
   "homepage": "https://github.com/receptron/mulmocast-cli#readme",
   "dependencies": {
     "@google-cloud/text-to-speech": "^6.4.1",
-    "@google/genai": "^2.17.1",
+    "@google/genai": "^2.24.0",
     "@graphai/anthropic_agent": "^2.1.0",
     "@graphai/browserless_agent": "^2.0.4",
     "@graphai/gemini_agent": "^2.1.0",

package/scripts/templates/html.json

@@ -13,7 +13,7 @@
   "title": "[TITLE: Brief, engaging title for the topic]",
   "htmlImageParams": {
     "provider": "anthropic",
-    "model": "claude-sonnet-4-5-20250929"
+    "model": "claude-sonnet-4-6"
   },
   "lang": "en",
   "beats": [

package/scripts/templates/presentation.json

@@ -5,7 +5,7 @@
   },
   "htmlImageParams": {
     "provider": "anthropic",
-    "model": "claude-sonnet-4-5-20250929"
+    "model": "claude-sonnet-4-6"
   },
   "title": "Sample Title",
   "references": [

package/scripts/test/test_genai.json

@@ -59,7 +59,7 @@
       "text": "movie generated by veo3",
       "moviePrompt": "a woman is walking through a busy Tokyo street at night, she is wearing dark sunglasses",
       "movieParams": {
-        "model": "veo-3.0-generate-001"
+        "model": "veo-3.1-lite-generate-preview"
       }
     },
     {
@@ -80,7 +80,7 @@
       },
       "moviePrompt": "a woman is walking through a busy Tokyo street at night, she is wearing dark sunglasses",
       "movieParams": {
-        "model": "veo-3.0-generate-001"
+        "model": "veo-3.1-lite-generate-preview"
       }
     }
   ]

package/scripts/test/test_gpt_image.json

@@ -7,7 +7,7 @@
   "title": "Testing OpenAI's new Image Generation",
   "description": "Hello",
   "imageParams": {
-    "model": "gpt-image-1",
+    "model": "gpt-image-2.5-sunburst",
     "style": "<style>Japanese animation with soft watercolor backgrounds, characters with simple rounded faces, large expressive eyes, small nose and mouth, soft jawlines, minimalist facial features, pastel color palette, detailed natural environments, whimsical magical elements, hand-drawn aesthetic, gentle lighting, flowing movement in hair and clothing, nostalgic countryside scenery with fantasy elements."
   },
   "speechParams": {

package/scripts/test/test_replicate.json

@@ -96,12 +96,12 @@
       }
     },
     {
-      "id": "kling-v1.6-pro",
-      "text": "kwaivgi/kling-v1.6-pro with gpt4-image",
+      "id": "kling-v2.1-start-image",
+      "text": "kwaivgi/kling-v2.1 with gpt4-image",
       "imagePrompt": "a woman is walking through a busy Tokyo street at night, she is wearing dark sunglasses",
       "moviePrompt": "a woman is walking through a busy Tokyo street at night, she is wearing dark sunglasses",
       "movieParams": {
-        "model": "kwaivgi/kling-v1.6-pro"
+        "model": "kwaivgi/kling-v2.1"
       }
     },
     {

package/scripts/test/test_vertexai.json

@@ -24,7 +24,7 @@
   },
   "movieParams": {
     "provider": "google",
-    "model": "veo-2.0-generate-001",
+    "model": "veo-3.1-generate-001",
     "vertexai_project": "YOUR_PROJECT_ID",
     "vertexai_location": "us-central1"
   },
@@ -76,7 +76,7 @@
       "text": "TTS: Gemini 2.5 Pro TTS Kore. Movie: Veo 3 override.",
       "moviePrompt": "Ocean waves crashing on a beach at sunset",
       "movieParams": {
-        "model": "veo-3.0-generate-001",
+        "model": "veo-3.1-generate-001",
         "vertexai_project": "YOUR_PROJECT_ID",
         "vertexai_location": "us-central1"
       }
@@ -101,7 +101,7 @@
       },
       "moviePrompt": "The robot turns its head and waves at the camera",
       "movieParams": {
-        "model": "veo-3.0-generate-001",
+        "model": "veo-3.1-generate-001",
         "vertexai_project": "YOUR_PROJECT_ID",
         "vertexai_location": "us-central1"
       },