@effectnode/media 0.1.0

package/dist/backend/routes/health.d.ts

@@ -0,0 +1 @@
+export declare const healthRouter: import("express-serve-static-core").Router;

package/dist/backend/routes/health.js

@@ -0,0 +1,9 @@
+import { Router } from "express";
+export const healthRouter = Router();
+healthRouter.get("/health", (_req, res) => {
+    res.json({
+        ok: true,
+        uptime: process.uptime(),
+        timestamp: new Date().toISOString(),
+    });
+});

package/dist/backend/routes/index.d.ts

@@ -0,0 +1 @@
+export declare const router: import("express-serve-static-core").Router;

package/dist/backend/routes/index.js

@@ -0,0 +1,11 @@
+import { Router } from "express";
+import { healthRouter } from "./health.js";
+import { mediaRouter } from "./media.js";
+import { projectsRouter } from "./projects.js";
+import { voiceRouter } from "./voice.js";
+// Combined REST API router, mounted at /api.
+export const router = Router();
+router.use(healthRouter);
+router.use(mediaRouter);
+router.use(projectsRouter);
+router.use(voiceRouter);

package/dist/backend/routes/media.d.ts

@@ -0,0 +1 @@
+export declare const mediaRouter: import("express-serve-static-core").Router;

package/dist/backend/routes/media.js

@@ -0,0 +1,13 @@
+import { Router } from "express";
+export const mediaRouter = Router();
+const media = [
+    { id: 1, title: "Sintel", type: "film" },
+    { id: 2, title: "Big Buck Bunny", type: "animation" },
+    { id: 3, title: "Tears of Steel", type: "short" },
+];
+mediaRouter.get("/media", (_req, res) => {
+    res.json({ media });
+});
+mediaRouter.post("/media", (req, res) => {
+    res.status(201).json({ ok: true, received: req.body ?? {} });
+});

package/dist/backend/routes/projects.d.ts

@@ -0,0 +1,8 @@
+export declare const projectsRouter: import("express-serve-static-core").Router;
+export interface Project {
+    id: string;
+    name: string;
+    description: string;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/backend/routes/projects.js

@@ -0,0 +1,68 @@
+import { Router } from "express";
+import { randomUUID } from "node:crypto";
+import { readJson, writeJson } from "../workspace.js";
+export const projectsRouter = Router();
+const FILE = "projects.json";
+const EMPTY = { projects: [] };
+async function loadProjects() {
+    const data = await readJson(FILE, EMPTY);
+    return data.projects ?? [];
+}
+async function saveProjects(projects) {
+    await writeJson(FILE, { projects });
+}
+projectsRouter.get("/projects", async (_req, res) => {
+    const projects = await loadProjects();
+    projects.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    res.json({ projects });
+});
+projectsRouter.post("/projects", async (req, res) => {
+    const { name, description } = req.body ?? {};
+    const now = new Date().toISOString();
+    const project = {
+        id: randomUUID(),
+        name: typeof name === "string" && name.trim() ? name.trim() : "Untitled",
+        description: typeof description === "string" ? description : "",
+        createdAt: now,
+        updatedAt: now,
+    };
+    const projects = await loadProjects();
+    projects.push(project);
+    await saveProjects(projects);
+    res.status(201).json({ project });
+});
+projectsRouter.get("/projects/:id", async (req, res) => {
+    const projects = await loadProjects();
+    const project = projects.find((p) => p.id === req.params.id);
+    if (!project) {
+        res.status(404).json({ error: "Project not found" });
+        return;
+    }
+    res.json({ project });
+});
+projectsRouter.put("/projects/:id", async (req, res) => {
+    const projects = await loadProjects();
+    const project = projects.find((p) => p.id === req.params.id);
+    if (!project) {
+        res.status(404).json({ error: "Project not found" });
+        return;
+    }
+    const { name, description } = req.body ?? {};
+    if (typeof name === "string" && name.trim())
+        project.name = name.trim();
+    if (typeof description === "string")
+        project.description = description;
+    project.updatedAt = new Date().toISOString();
+    await saveProjects(projects);
+    res.json({ project });
+});
+projectsRouter.delete("/projects/:id", async (req, res) => {
+    const projects = await loadProjects();
+    const next = projects.filter((p) => p.id !== req.params.id);
+    if (next.length === projects.length) {
+        res.status(404).json({ error: "Project not found" });
+        return;
+    }
+    await saveProjects(next);
+    res.status(204).end();
+});

package/dist/backend/routes/voice.d.ts

@@ -0,0 +1 @@
+export declare const voiceRouter: import("express-serve-static-core").Router;

package/dist/backend/routes/voice.js

@@ -0,0 +1,39 @@
+import { Router } from "express";
+export const voiceRouter = Router();
+const VOICE_API_URL = process.env.VOICE_API_URL ?? "http://127.0.0.1:11234";
+const DEFAULT_MODEL = "mlx-community/Qwen3-TTS-12Hz-1.7B-Base-bf16";
+/**
+ * Proxy to the mlx-serve OpenAI-compatible TTS endpoint so the browser never
+ * talks to it directly (avoids CORS and keeps the URL configurable via
+ * VOICE_API_URL). Expects { model?, input, ref_audio? } and returns WAV bytes.
+ */
+voiceRouter.post("/voice/speech", async (req, res) => {
+    const { model, input, ref_audio } = req.body ?? {};
+    if (typeof input !== "string" || !input.trim()) {
+        res.status(400).json({ error: "'input' is required" });
+        return;
+    }
+    const payload = {
+        model: typeof model === "string" && model ? model : DEFAULT_MODEL,
+        input: input.trim(),
+        ...(typeof ref_audio === "string" && ref_audio ? { ref_audio } : {}),
+    };
+    try {
+        const upstream = await fetch(`${VOICE_API_URL}/v1/audio/speech`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        if (!upstream.ok) {
+            const text = await upstream.text();
+            res.status(upstream.status).json({ error: text });
+            return;
+        }
+        const audio = Buffer.from(await upstream.arrayBuffer());
+        res.set("Content-Type", "audio/wav");
+        res.send(audio);
+    }
+    catch (e) {
+        res.status(502).json({ error: e.message });
+    }
+});

package/dist/backend/routes.d.ts

@@ -0,0 +1 @@
+export declare const router: import("express-serve-static-core").Router;

package/dist/backend/routes.js

@@ -0,0 +1,20 @@
+import { Router } from "express";
+export const router = Router();
+const media = [
+    { id: 1, title: "Sintel", type: "film" },
+    { id: 2, title: "Big Buck Bunny", type: "animation" },
+    { id: 3, title: "Tears of Steel", type: "short" },
+];
+router.get("/health", (_req, res) => {
+    res.json({
+        ok: true,
+        uptime: process.uptime(),
+        timestamp: new Date().toISOString(),
+    });
+});
+router.get("/media", (_req, res) => {
+    res.json({ media });
+});
+router.post("/media", (req, res) => {
+    res.status(201).json({ ok: true, received: req.body ?? {} });
+});

package/dist/backend/server.d.ts

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

package/dist/backend/server.js

@@ -0,0 +1,23 @@
+import { createBackendServer } from "./index.js";
+// Standalone backend entry for `bun run dev`. The frontend (Vite) runs as a
+// separate process (see vite.config.ts), so nodemon can restart this on
+// backend edits without disturbing the browser's HMR connection.
+const port = Number(process.env.BACKEND_PORT ?? 4000);
+async function main() {
+    //
+    const server = await createBackendServer({ port });
+    const shutdown = () => {
+        try {
+            server.close(() => process.exit(0));
+        }
+        catch (e) {
+            console.error(e);
+        }
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+}
+main().catch((err) => {
+    console.error(`[backend] failed to start: ${err.message}`);
+    process.exit(1);
+});

package/dist/backend/workspace.d.ts

@@ -0,0 +1,5 @@
+export declare const WORKSPACE_DIR: string;
+/** Read a JSON file from the workspace, returning `fallback` if missing/invalid. */
+export declare function readJson<T>(file: string, fallback: T): Promise<T>;
+/** Write JSON to the workspace atomically (temp file + rename). */
+export declare function writeJson(file: string, data: unknown): Promise<void>;

package/dist/backend/workspace.js

@@ -0,0 +1,27 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+// Local JSON database root: ~/media-workspace.
+export const WORKSPACE_DIR = path.join(os.homedir(), "effectnode-media");
+async function ensureWorkspace() {
+    await fs.mkdir(WORKSPACE_DIR, { recursive: true });
+}
+/** Read a JSON file from the workspace, returning `fallback` if missing/invalid. */
+export async function readJson(file, fallback) {
+    await ensureWorkspace();
+    const full = path.join(WORKSPACE_DIR, file);
+    try {
+        return JSON.parse(await fs.readFile(full, "utf-8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Write JSON to the workspace atomically (temp file + rename). */
+export async function writeJson(file, data) {
+    await ensureWorkspace();
+    const full = path.join(WORKSPACE_DIR, file);
+    const tmp = `${full}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(data, null, 2), "utf-8");
+    await fs.rename(tmp, full);
+}

package/dist/backend/ws/index.d.ts

@@ -0,0 +1,3 @@
+import type { Server } from "node:http";
+import { WebSocket } from "ws";
+export declare function createWsServer(server: Server): import("ws").Server<typeof WebSocket, typeof import("http").IncomingMessage>;

package/dist/backend/ws/index.js

@@ -0,0 +1,27 @@
+import { WebSocketServer, WebSocket } from "ws";
+import { handleMessage } from "./messages.js";
+export function createWsServer(server) {
+    const wss = new WebSocketServer({ server, path: "/ws" });
+    const broadcast = (text) => {
+        for (const client of wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(text);
+            }
+        }
+    };
+    wss.on("connection", (socket) => {
+        console.log("[ws] client connected");
+        socket.on("message", (data) => {
+            const text = data.toString();
+            console.log("[ws] received:", text);
+            handleMessage(text, { broadcast });
+        });
+        socket.on("close", () => console.log("[ws] client disconnected"));
+    });
+    // Broadcast a clock tick to every connected client every 5 seconds.
+    const tick = setInterval(() => {
+        broadcast(`clock: ${new Date().toISOString()}`);
+    }, 5000);
+    wss.on("close", () => clearInterval(tick));
+    return wss;
+}

package/dist/backend/ws/messages.d.ts

@@ -0,0 +1,8 @@
+export interface MessageContext {
+    broadcast: (text: string) => void;
+}
+/**
+ * Route an incoming WebSocket message by its JSON `type`, falling back to a
+ * plain echo for non-JSON or untyped input.
+ */
+export declare function handleMessage(raw: string, ctx: MessageContext): void;

package/dist/backend/ws/messages.js

@@ -0,0 +1,21 @@
+/**
+ * Route an incoming WebSocket message by its JSON `type`, falling back to a
+ * plain echo for non-JSON or untyped input.
+ */
+export function handleMessage(raw, ctx) {
+    let text = raw;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.type === "ping") {
+            ctx.broadcast("pong");
+            return;
+        }
+        if (parsed.type === "chat" && typeof parsed.message === "string") {
+            text = parsed.message;
+        }
+    }
+    catch {
+        // Non-JSON input — treat as a plain chat string.
+    }
+    ctx.broadcast(`echo: ${text}`);
+}

package/dist/backend/ws.d.ts

@@ -0,0 +1,3 @@
+import type { Server } from "node:http";
+import { WebSocket } from "ws";
+export declare function createWsServer(server: Server): import("ws").Server<typeof WebSocket, typeof import("http").IncomingMessage>;

package/dist/backend/ws.js

@@ -0,0 +1,29 @@
+import { WebSocketServer, WebSocket } from "ws";
+export function createWsServer(server) {
+    const wss = new WebSocketServer({ server, path: "/ws" });
+    wss.on("connection", (socket) => {
+        console.log("[ws] client connected");
+        socket.on("message", (data) => {
+            const text = data.toString();
+            console.log("[ws] received:", text);
+            // Broadcast back to all connected clients.
+            for (const client of wss.clients) {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.send(`echo: ${text}`);
+                }
+            }
+        });
+        socket.on("close", () => console.log("[ws] client disconnected"));
+    });
+    // Broadcast a clock tick to every connected client every 5 seconds.
+    const tick = setInterval(() => {
+        const now = new Date().toISOString();
+        for (const client of wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(`clock: ${now}`);
+            }
+        }
+    }, 5000);
+    wss.on("close", () => clearInterval(tick));
+    return wss;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import chalk from "chalk";
+import open from "open";
+import { createServer as createViteServer } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import { createBackendServer } from "./backend/index.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// The Vite app source lives at the package root, next to dist/ (shipped in
+// "files"), so this resolves correctly from both src/ (tsx) and dist/ (build).
+const FRONTEND_ROOT = path.resolve(__dirname, "..", "frontend");
+const program = new Command();
+program
+    .name("effectnode-media")
+    .description("Start the effectnode-media services — a Vite + React + TypeScript frontend " +
+    "and an Express backend (REST + WebSocket) — then open the browser.")
+    .version("0.1.0")
+    .option("--host <host>", "Host to bind", "localhost")
+    .option("--frontend-port <port>", "Frontend (Vite) port", "5177")
+    .option("--backend-port <port>", "Backend (Express) port", "4000")
+    .option("--no-open", "Do not open the browser")
+    .action(async (options) => {
+    const host = options.host;
+    const frontendPort = Number(options.frontendPort);
+    const backendPort = Number(options.backendPort);
+    // 1. Backend service — Express (REST + WebSocket) on :backendPort.
+    const backend = await createBackendServer({ port: backendPort });
+    // 2. Frontend service — Vite dev server on :frontendPort, proxying
+    //    /api and /ws to the backend so browser calls are same-origin.
+    const vite = await createViteServer({
+        root: FRONTEND_ROOT,
+        plugins: [react(), tailwindcss()],
+        env: {
+            PORT: backendPort,
+        },
+        server: {
+            host,
+            port: frontendPort,
+            strictPort: true,
+            proxy: {
+                "/api": {
+                    target: `http://localhost:${backendPort}`,
+                    changeOrigin: true,
+                },
+                "/ws": {
+                    target: `ws://localhost:${backendPort}`,
+                    ws: true,
+                },
+            },
+        },
+    });
+    await vite.listen();
+    const url = `http://${host}:${frontendPort}`;
+    console.log("");
+    console.log(chalk.green("effectnode-media is running:"));
+    console.log(chalk.cyan(`  Frontend  → ${url}`));
+    console.log(chalk.cyan(`  REST API  → http://localhost:${backendPort}/api`));
+    console.log(chalk.cyan(`  WebSocket → ws://localhost:${backendPort}/ws`));
+    console.log(chalk.dim("  Press Ctrl+C to stop."));
+    console.log("");
+    // 3. Open the frontend in the browser (skip when disabled or headless).
+    if (options.open !== false &&
+        process.env.EFFECTNODE_MEDIA_NO_OPEN !== "1") {
+        await open(url);
+    }
+    const shutdown = () => {
+        void vite.close();
+        backend.close();
+        process.exit(0);
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+});
+program.parseAsync().catch((err) => {
+    console.error(chalk.red(`\n✖ Failed to start effectnode-media: ${err.message}`));
+    process.exit(1);
+});

package/frontend/index.html

@@ -0,0 +1,22 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>effectnode-media</title>
+</head>
+
+<body>
+  <div id="root"></div>
+  <script>
+    // The backend (src/backend/movie-backend/core.ts) binds to the first free
+    // port starting at BACKEND_PORT_START = 4000. Previously this was injected
+    // by an Electron `preload` script; with the Bun → Node.js migration it must
+    // be set here, before any module reads `window.PORT`.
+    window.PORT = "4000";
+  </script>
+  <script type="module" src="/src/main.tsx"></script>
+</body>
+
+</html>