@effectnode/media 0.1.0

package/dist/backend/movie-backend/agent/tools/read-file.js

@@ -0,0 +1,28 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolveWorkspacePath, classifyFile } from "../workspace";
+const tool = {
+    name: "read_file",
+    description: "Read the text content of a file in the workspace.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: {
+                type: "string",
+                description: "File path relative to the workspace (e.g. memories/foo.md)",
+            },
+        },
+        required: ["path"],
+    },
+    run: (args, ctx) => {
+        const path = typeof args.path === "string" ? args.path : "";
+        const abs = resolveWorkspacePath(ctx.projectId, path);
+        if (!abs || !existsSync(abs))
+            return `File not found: ${path}`;
+        const kind = classifyFile(path);
+        if (kind === "image" || kind === "video") {
+            return `Cannot read binary file: ${path}`;
+        }
+        return readFileSync(abs, "utf-8");
+    },
+};
+export default tool;

package/dist/backend/movie-backend/agent/tools/remove-file.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "./types";
+declare const tool: AgentTool;
+export default tool;

package/dist/backend/movie-backend/agent/tools/remove-file.js

@@ -0,0 +1,22 @@
+import { existsSync, rmSync } from "node:fs";
+import { resolveWorkspacePath } from "../workspace";
+const tool = {
+    name: "remove_file",
+    description: "Delete a file (or directory) in the workspace.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path relative to the workspace" },
+        },
+        required: ["path"],
+    },
+    run: (args, ctx) => {
+        const path = typeof args.path === "string" ? args.path : "";
+        const abs = resolveWorkspacePath(ctx.projectId, path);
+        if (!abs || !existsSync(abs))
+            return `File not found: ${path}`;
+        rmSync(abs, { recursive: true, force: true });
+        return `Removed ${path}`;
+    },
+};
+export default tool;

package/dist/backend/movie-backend/agent/tools/rename-file.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "./types";
+declare const tool: AgentTool;
+export default tool;

package/dist/backend/movie-backend/agent/tools/rename-file.js

@@ -0,0 +1,37 @@
+import { existsSync, renameSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveWorkspacePath } from "../workspace";
+const tool = {
+    name: "rename_file",
+    description: "Rename a file in the workspace.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: {
+                type: "string",
+                description: "Current file path relative to the workspace",
+            },
+            new_name: {
+                type: "string",
+                description: "New file name (no directory separators)",
+            },
+        },
+        required: ["path", "new_name"],
+    },
+    run: (args, ctx) => {
+        const path = typeof args.path === "string" ? args.path.trim() : "";
+        if (!path)
+            return "rename_file requires a path.";
+        const newName = typeof args.new_name === "string" ? args.new_name.trim() : "";
+        // Only bare filenames — no separators, `..`, or leading dots.
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(newName)) {
+            return `Invalid new name: ${newName}`;
+        }
+        const abs = resolveWorkspacePath(ctx.projectId, path);
+        if (!abs || !existsSync(abs))
+            return `File not found: ${path}`;
+        renameSync(abs, join(dirname(abs), newName));
+        return `Renamed ${path} to ${newName}`;
+    },
+};
+export default tool;

package/dist/backend/movie-backend/agent/tools/show-image.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "./types";
+declare const tool: AgentTool;
+export default tool;

package/dist/backend/movie-backend/agent/tools/show-image.js

@@ -0,0 +1,28 @@
+import { existsSync } from "node:fs";
+import { resolveWorkspacePath, classifyFile } from "../workspace";
+const tool = {
+    name: "show_image",
+    description: "Display an image from the workspace to the user.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: {
+                type: "string",
+                description: "Path of the image file relative to the workspace",
+            },
+        },
+        required: ["path"],
+    },
+    run: (args, ctx) => {
+        const path = typeof args.path === "string" ? args.path : "";
+        const abs = resolveWorkspacePath(ctx.projectId, path);
+        if (!abs || !existsSync(abs))
+            return `Image not found: ${path}`;
+        if (classifyFile(path) !== "image")
+            return `Not an image file: ${path}`;
+        const url = `/api/agent/file/preview?projectId=${encodeURIComponent(ctx.projectId)}&path=${encodeURIComponent(path)}`;
+        ctx.emit?.("image", { url, path });
+        return `Displayed image "${path}" to the user.`;
+    },
+};
+export default tool;

package/dist/backend/movie-backend/agent/tools/stitch-videos.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "./types";
+declare const tool: AgentTool;
+export default tool;

package/dist/backend/movie-backend/agent/tools/stitch-videos.js

@@ -0,0 +1,96 @@
+import { FFmpeg } from "@ffmpeg/ffmpeg";
+import { toBlobURL } from "@ffmpeg/util";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { isValidProjectId, resolveWorkspacePath, classifyFile, workspaceDir, } from "../workspace";
+const CORE_BASE = "https://unpkg.com/@ffmpeg/core@0.12.10/dist/esm";
+const tool = {
+    name: "stitch_videos",
+    description: "Concatenate multiple videos in the workspace into a single video file.",
+    parameters: {
+        type: "object",
+        properties: {
+            videos: {
+                type: "array",
+                items: { type: "string" },
+                description: "List of workspace video paths, in order",
+            },
+            output: {
+                type: "string",
+                description: "Output filename (default stitched-<timestamp>.mp4)",
+            },
+        },
+        required: ["videos"],
+    },
+    run: async (args, ctx) => {
+        if (!isValidProjectId(ctx.projectId))
+            return "Invalid project ID.";
+        const videos = (Array.isArray(args.videos) ? args.videos : [])
+            .filter((v) => typeof v === "string" && v.trim().length > 0)
+            .map((v) => v.trim());
+        if (videos.length < 2)
+            return "stitch_videos requires at least two videos.";
+        // Resolve and validate each input video.
+        const resolved = [];
+        for (const v of videos) {
+            const abs = resolveWorkspacePath(ctx.projectId, v);
+            if (!abs || !existsSync(abs) || classifyFile(v) !== "video") {
+                return `Video not found or not a video: ${v}`;
+            }
+            resolved.push(abs);
+        }
+        const outputName = (typeof args.output === "string" && args.output.trim()
+            ? args.output.trim()
+            : `stitched-${Date.now()}.mp4`).replace(/[^a-zA-Z0-9._-]/g, "_");
+        ctx.emit?.("notice", { text: "Loading ffmpeg..." });
+        const ffmpeg = new FFmpeg();
+        try {
+            await ffmpeg.load({
+                coreURL: await toBlobURL(`${CORE_BASE}/ffmpeg-core.js`, "text/javascript"),
+                wasmURL: await toBlobURL(`${CORE_BASE}/ffmpeg-core.wasm`, "application/wasm"),
+            });
+            // Stream stitching progress via SSE.
+            let lastPct = -1;
+            ffmpeg.on("progress", ({ progress }) => {
+                if (typeof progress !== "number")
+                    return;
+                const pct = Math.round(progress * 100);
+                if (pct >= lastPct + 5) {
+                    lastPct = pct;
+                    ctx.emit?.("notice", { text: `Stitching: ${pct}%` });
+                }
+            });
+            // Write inputs and a concat list into ffmpeg's virtual filesystem.
+            const listLines = [];
+            for (let i = 0; i < resolved.length; i++) {
+                const name = `input${i}.mp4`;
+                await ffmpeg.writeFile(name, readFileSync(resolved[i]));
+                listLines.push(`file '${name}'`);
+            }
+            await ffmpeg.writeFile("list.txt", listLines.join("\n"));
+            await ffmpeg.exec([
+                "-f",
+                "concat",
+                "-safe",
+                "0",
+                "-i",
+                "list.txt",
+                "-c",
+                "copy",
+                outputName,
+            ]);
+            const outData = await ffmpeg.readFile(outputName);
+            const outDir = workspaceDir(ctx.projectId);
+            if (!existsSync(outDir))
+                mkdirSync(outDir, { recursive: true });
+            writeFileSync(join(outDir, outputName), Buffer.from(outData));
+            const url = `/api/agent/file/preview?projectId=${encodeURIComponent(ctx.projectId)}&path=${encodeURIComponent(outputName)}`;
+            ctx.emit?.("video", { url });
+            return `Stitched ${videos.length} videos into ${outputName}.`;
+        }
+        finally {
+            ffmpeg.terminate();
+        }
+    },
+};
+export default tool;

package/dist/backend/movie-backend/agent/tools/text-to-video-generation.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "./types";
+declare const tool: AgentTool;
+export default tool;

package/dist/backend/movie-backend/agent/tools/text-to-video-generation.js

@@ -0,0 +1,125 @@
+import { isValidProjectId, workspaceDir } from "../workspace";
+async function readSSE(response, onEvent) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            let eventType = "message";
+            for (const line of lines) {
+                if (line.startsWith("event: ")) {
+                    eventType = line.slice(7).trim();
+                }
+                else if (line.startsWith("data: ")) {
+                    try {
+                        onEvent(eventType, JSON.parse(line.slice(6)));
+                    }
+                    catch {
+                        // skip malformed lines
+                    }
+                    eventType = "message";
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+const tool = {
+    name: "text_to_video_generation",
+    description: "Generate a video from a text prompt.",
+    parameters: {
+        type: "object",
+        properties: {
+            prompt: { type: "string", description: "The video prompt" },
+            duration: {
+                type: "number",
+                description: "Video duration in seconds (default 5)",
+            },
+            mode: {
+                type: "string",
+                enum: ["distilled", "one-stage", "two-stage"],
+                description: "Generation mode: distilled (default), one-stage, or two-stage",
+            },
+        },
+        required: ["prompt"],
+    },
+    run: async (args, ctx) => {
+        if (!isValidProjectId(ctx.projectId))
+            return "Invalid project ID.";
+        const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
+        if (!prompt)
+            return "text_to_video_generation requires a prompt.";
+        if (!ctx.backendPort)
+            return "Video backend not available.";
+        const duration = typeof args.duration === "number" && args.duration > 0
+            ? args.duration
+            : 5;
+        const frames = Math.round(duration * 24 + 1);
+        ctx.emit?.("notice", { text: `Generating video from prompt...` });
+        try {
+            const body = {
+                prompt,
+                projectId: ctx.projectId,
+                outputDir: workspaceDir(ctx.projectId),
+                width: 448,
+                height: 448,
+                frames,
+                frameRate: 24,
+            };
+            if (typeof args.mode === "string" &&
+                ["distilled", "one-stage", "two-stage"].includes(args.mode)) {
+                body.mode = args.mode;
+            }
+            const res = await fetch(`http://localhost:${ctx.backendPort}/api/render/text-to-video`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: ctx.signal,
+            });
+            if (!res.ok) {
+                return `Video generation failed: ${await res.text()}`;
+            }
+            let resultPath = null;
+            let resultFilename = null;
+            let error = null;
+            await readSSE(res, (event, data) => {
+                switch (event) {
+                    case "log":
+                        ctx.emit?.("notice", { text: data.text });
+                        break;
+                    case "complete":
+                        resultPath = data.path;
+                        resultFilename = data.filename;
+                        break;
+                    case "error":
+                        error = data.error || "Video generation failed";
+                        break;
+                }
+            });
+            if (error)
+                return error;
+            if (!resultPath)
+                return "Video generation did not produce a result.";
+            const relPath = resultFilename ||
+                resultPath.split("/").pop() ||
+                "video.mp4";
+            const url = `/api/agent/file/preview?projectId=${encodeURIComponent(ctx.projectId)}&path=${encodeURIComponent(relPath)}`;
+            ctx.emit?.("video", { url });
+            return `Generated video: ${resultPath}`;
+        }
+        catch (e) {
+            return `Video generation error: ${String(e)}`;
+        }
+    },
+};
+export default tool;

package/dist/backend/movie-backend/agent/tools/types.d.ts

@@ -0,0 +1,15 @@
+export interface ToolRunContext {
+    projectId: string;
+    /** Optional SSE emit function so tools can stream events to the client. */
+    emit?: (event: string, data: Record<string, unknown>) => void;
+    /** The app backend port, for tools that call internal endpoints. */
+    backendPort?: number;
+    /** Abort signal derived from the incoming request, for cancellable calls. */
+    signal?: AbortSignal;
+}
+export interface AgentTool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    run: (args: Record<string, unknown>, ctx: ToolRunContext) => string | Promise<string>;
+}

package/dist/backend/movie-backend/agent/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/backend/movie-backend/agent/tools/update-file.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "./types";
+declare const tool: AgentTool;
+export default tool;

package/dist/backend/movie-backend/agent/tools/update-file.js

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { resolveWorkspacePath, ensureDir } from "../workspace";
+const tool = {
+    name: "update_file",
+    description: "Append text to the end of a file in the workspace.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path relative to the workspace" },
+            content: { type: "string", description: "Text content to append" },
+        },
+        required: ["path", "content"],
+    },
+    run: (args, ctx) => {
+        const path = typeof args.path === "string" ? args.path : "";
+        const content = typeof args.content === "string" ? args.content : "";
+        const abs = resolveWorkspacePath(ctx.projectId, path);
+        if (!abs)
+            return `Invalid path: ${path}`;
+        ensureDir(dirname(abs));
+        const existing = existsSync(abs) ? readFileSync(abs, "utf-8") : "";
+        writeFileSync(abs, existing + content, "utf-8");
+        return `Appended ${content.length} chars to ${path}`;
+    },
+};
+export default tool;

package/dist/backend/movie-backend/agent/tools/write-file.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "./types";
+declare const tool: AgentTool;
+export default tool;

package/dist/backend/movie-backend/agent/tools/write-file.js

@@ -0,0 +1,26 @@
+import { writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { resolveWorkspacePath, ensureDir } from "../workspace";
+const tool = {
+    name: "write_file",
+    description: "Write (create or overwrite) a file with the given text content.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path relative to the workspace" },
+            content: { type: "string", description: "Text content to write" },
+        },
+        required: ["path", "content"],
+    },
+    run: (args, ctx) => {
+        const path = typeof args.path === "string" ? args.path : "";
+        const content = typeof args.content === "string" ? args.content : "";
+        const abs = resolveWorkspacePath(ctx.projectId, path);
+        if (!abs)
+            return `Invalid path: ${path}`;
+        ensureDir(dirname(abs));
+        writeFileSync(abs, content, "utf-8");
+        return `Wrote ${content.length} chars to ${path}`;
+    },
+};
+export default tool;

package/dist/backend/movie-backend/agent/workspace.d.ts

@@ -0,0 +1,25 @@
+export declare const AGENTS_DIR: string;
+export declare const UPLOAD_DIR: string;
+export declare const AGENT_UPLOAD_DIR: string;
+export declare const MEMORIES_DIR_NAME = "memories";
+export declare const PROJECTS_FILE: string;
+export declare const STUDIO_DIR: string;
+export declare function ensureDir(dir: string): void;
+export declare function workspaceDir(projectId: string): string;
+export declare function movieStudioDataDir(projectId: string): string;
+export declare function movieStudioStateFile(projectId: string): string;
+export declare function memoriesDir(projectId: string): string;
+export declare function isValidProjectId(id: string): boolean;
+/** Resolve a workspace-relative path safely (no traversal / absolute paths). */
+export declare function resolveWorkspacePath(projectId: string, relativePath: string): string | null;
+export type FileKind = "image" | "video" | "text" | "other";
+export declare function classifyFile(name: string): FileKind;
+export interface WorkspaceFile {
+    path: string;
+    name: string;
+    ext: string;
+    size: number;
+    mtime: number;
+    kind: FileKind;
+}
+export declare function walkFiles(base: string, prefix?: string): WorkspaceFile[];

package/dist/backend/movie-backend/agent/workspace.js

@@ -0,0 +1,124 @@
+import { existsSync, mkdirSync, readdirSync, statSync, realpathSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join, sep } from "node:path";
+const APP_DATA_DIR = join(homedir(), "media-studio");
+const JSON_DIR = join(APP_DATA_DIR, "json");
+export const AGENTS_DIR = join(APP_DATA_DIR, "agents");
+export const UPLOAD_DIR = join(APP_DATA_DIR, "upload");
+export const AGENT_UPLOAD_DIR = join(APP_DATA_DIR, "agent-upload");
+export const MEMORIES_DIR_NAME = "memories";
+export const PROJECTS_FILE = join(JSON_DIR, "projects.json");
+export const STUDIO_DIR = join(APP_DATA_DIR, "studio");
+export function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+export function workspaceDir(projectId) {
+    return join(AGENTS_DIR, projectId);
+}
+export function movieStudioDataDir(projectId) {
+    return join(STUDIO_DIR, projectId, "data");
+}
+export function movieStudioStateFile(projectId) {
+    return join(STUDIO_DIR, projectId, "state.json");
+}
+export function memoriesDir(projectId) {
+    return join(AGENTS_DIR, projectId, MEMORIES_DIR_NAME);
+}
+const PROJECT_ID_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+export function isValidProjectId(id) {
+    return PROJECT_ID_RE.test(id);
+}
+/** Resolve a workspace-relative path safely (no traversal / absolute paths). */
+export function resolveWorkspacePath(projectId, relativePath) {
+    if (!isValidProjectId(projectId))
+        return null;
+    if (typeof relativePath !== "string" || !relativePath)
+        return null;
+    if (relativePath.includes("..") || relativePath.includes("\0"))
+        return null;
+    const normalized = relativePath.replace(/\\/g, "/");
+    if (normalized.startsWith("/"))
+        return null;
+    const base = workspaceDir(projectId);
+    const resolved = join(base, normalized);
+    if (resolved !== base && !resolved.startsWith(base + sep))
+        return null;
+    // Defense in depth: if the target exists, ensure its real path (symlinks
+    // resolved) is still inside the real agent workspace.
+    if (existsSync(resolved)) {
+        try {
+            const realResolved = realpathSync(resolved);
+            const realAgents = realpathSync(AGENTS_DIR);
+            if (!realResolved.startsWith(realAgents + sep))
+                return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return resolved;
+}
+const IMAGE_EXTS = [".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp"];
+const VIDEO_EXTS = [".mp4", ".mov", ".m4v", ".webm", ".mkv", ".avi"];
+const TEXT_EXTS = [
+    ".md",
+    ".txt",
+    ".json",
+    ".csv",
+    ".log",
+    ".html",
+    ".js",
+    ".ts",
+    ".tsx",
+    ".jsx",
+    ".py",
+    ".css",
+    ".yml",
+    ".yaml",
+];
+export function classifyFile(name) {
+    const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
+    if (IMAGE_EXTS.includes(ext))
+        return "image";
+    if (VIDEO_EXTS.includes(ext))
+        return "video";
+    if (TEXT_EXTS.includes(ext))
+        return "text";
+    return "other";
+}
+export function walkFiles(base, prefix = "") {
+    const results = [];
+    let entries;
+    try {
+        entries = readdirSync(base);
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const full = join(base, entry);
+        const rel = prefix ? `${prefix}/${entry}` : entry;
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            results.push(...walkFiles(full, rel));
+        }
+        else {
+            results.push({
+                path: rel,
+                name: entry,
+                ext: entry.slice(entry.lastIndexOf(".")).toLowerCase(),
+                size: st.size,
+                mtime: st.mtimeMs,
+                kind: classifyFile(entry),
+            });
+        }
+    }
+    return results;
+}

package/dist/backend/movie-backend/core.d.ts

@@ -0,0 +1,4 @@
+export declare function runSetup({ port, }: {
+    port: number;
+}): Promise<any>;
+export declare function getUvPath(): Promise<string>;