fix(studio): reject invalid media uploads

Author: miguel-heygen

packages/core/src/studio-api/helpers/mediaValidation.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { validateUploadedMedia } from "./mediaValidation.js";
+
+describe("validateUploadedMedia", () => {
+  it("passes through non-media files", () => {
+    expect(
+      validateUploadedMedia("/tmp/test.svg", () => ({ status: 0, stdout: "", stderr: "" })),
+    ).toEqual({
+      ok: true,
+    });
+  });
+
+  it("accepts video files with a video stream", () => {
+    expect(
+      validateUploadedMedia("/tmp/test.mp4", () => ({
+        status: 0,
+        stdout: JSON.stringify({ streams: [{ codec_type: "video" }] }),
+        stderr: "",
+      })),
+    ).toEqual({ ok: true });
+  });
+
+  it("rejects video files with no supported video stream", () => {
+    expect(
+      validateUploadedMedia("/tmp/test.mp4", () => ({
+        status: 0,
+        stdout: JSON.stringify({ streams: [] }),
+        stderr: "",
+      })),
+    ).toEqual({ ok: false, reason: "no supported video stream found" });
+  });
+
+  it("accepts audio files with an audio stream", () => {
+    expect(
+      validateUploadedMedia("/tmp/test.wav", () => ({
+        status: 0,
+        stdout: JSON.stringify({ streams: [{ codec_type: "audio" }] }),
+        stderr: "",
+      })),
+    ).toEqual({ ok: true });
+  });
+
+  it("does not block upload when ffprobe is unavailable", () => {
+    expect(
+      validateUploadedMedia("/tmp/test.mp4", () => ({
+        status: null,
+        stdout: "",
+        stderr: "",
+        error: { code: "ENOENT" } as NodeJS.ErrnoException,
+      })),
+    ).toEqual({ ok: true });
+  });
+});

packages/core/src/studio-api/helpers/mediaValidation.ts

@@ -0,0 +1,61 @@
+import { spawnSync } from "node:child_process";
+
+const VIDEO_EXT = /\.(mp4|webm|mov)$/i;
+const AUDIO_EXT = /\.(mp3|wav|ogg|m4a|aac)$/i;
+
+type FfprobeRunner = (
+  command: string,
+  args: string[],
+) => {
+  status: number | null;
+  stdout: string | Buffer;
+  stderr: string | Buffer;
+  error?: NodeJS.ErrnoException;
+};
+
+export function validateUploadedMedia(
+  filePath: string,
+  runner: FfprobeRunner = spawnSync as unknown as FfprobeRunner,
+): { ok: true } | { ok: false; reason: string } {
+  const isVideo = VIDEO_EXT.test(filePath);
+  const isAudio = AUDIO_EXT.test(filePath);
+  if (!isVideo && !isAudio) {
+    return { ok: true };
+  }
+
+  const result = runner("ffprobe", [
+    "-v",
+    "error",
+    "-show_entries",
+    "stream=codec_type",
+    "-of",
+    "json",
+    filePath,
+  ]);
+
+  if (result.error?.code === "ENOENT") {
+    return { ok: true };
+  }
+  if (result.status !== 0) {
+    return { ok: false, reason: "ffprobe failed to read the media file" };
+  }
+
+  try {
+    const parsed = JSON.parse(String(result.stdout || "{}")) as {
+      streams?: Array<{ codec_type?: string }>;
+    };
+    const streams = parsed.streams ?? [];
+    const hasVideo = streams.some((stream) => stream.codec_type === "video");
+    const hasAudio = streams.some((stream) => stream.codec_type === "audio");
+
+    if (isVideo && !hasVideo) {
+      return { ok: false, reason: "no supported video stream found" };
+    }
+    if (isAudio && !hasAudio) {
+      return { ok: false, reason: "no supported audio stream found" };
+    }
+    return { ok: true };
+  } catch {
+    return { ok: false, reason: "ffprobe returned unreadable media metadata" };
+  }
+}

packages/core/src/studio-api/routes/files.ts

@@ -13,6 +13,7 @@ import {
 } from "node:fs";
 import { resolve, dirname, join } from "node:path";
 import type { StudioApiAdapter } from "../types.js";
+import { validateUploadedMedia } from "../helpers/mediaValidation.js";
 import { isSafePath } from "../helpers/safePath.js";
 import { removeElementFromHtml } from "../helpers/sourceMutation.js";
 
@@ -301,6 +302,7 @@ export function registerFileRoutes(api: Hono, adapter: StudioApiAdapter): void {
       const formData = await c.req.formData();
       const uploaded: string[] = [];
       const skipped: string[] = [];
+      const invalid: Array<{ name: string; reason: string }> = [];
 
       for (const [, value] of formData.entries()) {
         if (!(value instanceof File)) continue;
@@ -338,10 +340,16 @@ export function registerFileRoutes(api: Hono, adapter: StudioApiAdapter): void {
 
         const buffer = Buffer.from(await value.arrayBuffer());
         writeFileSync(finalPath, buffer);
+        const validation = validateUploadedMedia(finalPath);
+        if (!validation.ok) {
+          unlinkSync(finalPath);
+          invalid.push({ name: finalName, reason: validation.reason });
+          continue;
+        }
         uploaded.push(subDir ? join(subDir, finalName) : finalName);
       }
 
-      return c.json({ ok: true, files: uploaded, skipped }, 201);
+      return c.json({ ok: true, files: uploaded, skipped, invalid }, 201);
     },
   );
 }

packages/studio/src/App.tsx

@@ -936,6 +936,10 @@ export function StudioApp() {
           if (data.skipped?.length) {
             showToast(`Skipped (too large): ${data.skipped.join(", ")}`);
           }
+          if (data.invalid?.length) {
+            const names = data.invalid.map((entry: { name: string }) => entry.name).join(", ");
+            showToast(`Unsupported media skipped: ${names}`);
+          }
           await refreshFileTree();
           setRefreshKey((k) => k + 1);
           return Array.isArray(data.files) ? data.files : [];

packages/studio/vite.config.ts

@@ -99,6 +99,7 @@ function createViteAdapter(dataDir: string, server: ViteDevServer): StudioApiAda
 
   return {
     listProjects() {
+      if (!existsSync(dataDir)) return [];
       const sessionsDir = resolve(dataDir, "../sessions");
       const sessionMap = new Map<string, { sessionId: string; title: string }>();
       if (existsSync(sessionsDir)) {