reelkit-cli 0.1.3 → 0.3.0

package/src/testing/fake-api.ts

@@ -1,11 +1,17 @@
+import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { createServer } from "node:http";
 import type { AddressInfo } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { MAX_UPLOAD_BYTES, routes, type ErrorCode, type LibraryItem, type RouteName, type Voice } from "../contract";
 import { PIXEL_PNG, silentWav } from "./fixtures";
 
 type Blob = { filename: string; contentType: string; bytes: Uint8Array };
 // owner is the uploader's user id; a seeded item has none. An upload is not an item for anyone until it is committed.
+// A clip of ten seconds or less is previewed by its own file, like a picture or a sound effect.
+const shortClip = (item: LibraryItem) => item.kind === "clip" && typeof item.meta.durationSec === "number" && item.meta.durationSec <= 10;
 type Stored = { item: LibraryItem; file?: Blob; filename: string; contentType: string; owner?: string; committed: boolean };
 
 export const FAKE_VOICES: Voice[] = [
@@ -37,10 +43,48 @@ function parseBody(raw: Buffer): unknown {
   catch { throw new Fail(400, "invalid_request", "The request body is not valid JSON."); }
 }
 
+// A clip job: pending for its first status call, then done (or failed, when the prompt says so). `charged` is whether it still holds its reservation.
+type ClipJob = { owner: string; prompt: string; aspect: string; greenScreen: boolean; durationSec: number; shareable: boolean; tags: string[]; asks: number; charged: boolean; libraryId?: string };
+const CLIP_FAIL = "clip-fail";
+// A prompt with this never finishes, so a test can see a client give up waiting.
+const CLIP_STALL = "clip-stall";
+
+// A real one-second MP4, made with ffmpeg. A green-screen one is pure green with a small red box, so keying it out has something to show.
+function makeClip(greenScreen: boolean): Blob {
+  const dir = mkdtempSync(join(tmpdir(), "rk-fakeclip-"));
+  const out = join(dir, "clip.mp4");
+  try {
+    const source = greenScreen ? "color=c=0x00FF00:s=320x180:r=10:d=1,drawbox=x=120:y=50:w=80:h=80:color=0xFF0000:t=fill" : "testsrc=s=320x180:r=10:d=1";
+    execFileSync("ffmpeg", ["-v", "error", "-f", "lavfi", "-i", source, "-c:v", "libx264", "-pix_fmt", "yuv420p", "-movflags", "+faststart", out], { stdio: "pipe" });
+    return { filename: "clip.mp4", contentType: "video/mp4", bytes: new Uint8Array(readFileSync(out)) };
+  } catch (e) {
+    throw new Error(`The fake API could not make its test clip: ffmpeg is needed (${e instanceof Error ? e.message : String(e)}).`);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
+// A cutout job: the file arrives at the upload URL, `run` reserves the seconds, and then it is pending for its first status call and done for
+// the second (or failed, when the file name says so). `seconds` is what it holds of the quota, 0 once given back.
+type CutoutJob = { owner: string; filename: string; contentType: string; bytes: number; durationSec: number; file?: Uint8Array; started: boolean; asks: number; seconds: number };
+const CUTOUT_FAIL = "cutout-fail";
+const NO_GPU = "Background removal is not available on this server yet.";
+
+// A real one-second WebM, made with ffmpeg: VP9 with an alpha channel, a transparent background and an opaque box.
+function makeCutout(): Blob {
+  const dir = mkdtempSync(join(tmpdir(), "rk-fakecut-"));
+  const out = join(dir, "cutout.webm");
+  try {
+    execFileSync("ffmpeg", ["-v", "error", "-f", "lavfi", "-i", "color=c=black@0:s=160x90:r=10:d=1,format=yuva420p,drawbox=x=50:y=20:w=60:h=50:color=red@1:t=fill:replace=1",
+      "-c:v", "libvpx-vp9", "-pix_fmt", "yuva420p", "-b:v", "0", "-crf", "35", out], { stdio: "pipe" });
+    return { filename: "cutout.webm", contentType: "video/webm", bytes: new Uint8Array(readFileSync(out)) };
+  } catch (e) {
+    throw new Error(`The fake API could not make its test cutout: ffmpeg is needed (${e instanceof Error ? e.message : String(e)}).`);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
 export type FakeApi = Awaited<ReturnType<typeof startFakeApi>>;
 
 // An in-memory stand-in for the Reelkit API. It implements every route in the contract.
-export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLimit?: number; autoApprove?: boolean } = {}) {
+export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLimit?: number; clipLimit?: number; noClipProvider?: boolean; cutoutSecondsLimit?: number; noCutoutService?: boolean; autoApprove?: boolean } = {}) {
   // token -> the user it belongs to
   const tokens = new Map<string, string>();
   const devices = new Map<string, { userCode: string; approved: boolean; userId: string }>();
@@ -49,17 +93,26 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
   const blobs = new Map<string, Blob>();
   // An unguessable token -> the one upload it accepts. `used` is set by the first PUT, accepted or not: the fake is stricter than a
   // real server needs to be, so a client that retries a PUT, or sends a second one, fails here instead of working by luck.
-  const uploads = new Map<string, { id: string; contentType: string; bytes: number; used: boolean }>();
+  // `sink` is where the accepted bytes go: a library item, or a cutout job.
+  const uploads = new Map<string, { contentType: string; bytes: number; used: boolean; sink: { has(): boolean; put(bytes: Uint8Array): void } | undefined }>();
   // Totals over every user (for tests of the CLI), and the same counts per user (what a quota is measured against).
-  const usage = { chars: 0, images: 0, pulls: 0, uploads: 0 };
-  const meters = new Map<string, { chars: number; images: number; uploads: number }>();
+  const usage = { chars: 0, images: 0, clips: 0, cutoutSeconds: 0, pulls: 0, uploads: 0 };
+  const meters = new Map<string, { chars: number; images: number; clips: number; cutoutSeconds: number; uploads: number }>();
   const meter = (userId: string | undefined) => {
     const id = userId ?? "u-test";
-    if (!meters.has(id)) meters.set(id, { chars: 0, images: 0, uploads: 0 });
+    if (!meters.has(id)) meters.set(id, { chars: 0, images: 0, clips: 0, cutoutSeconds: 0, uploads: 0 });
     return meters.get(id)!;
   };
   const resetDate = () => nextMonthStart().toISOString();
-  const limits = { chars: opts.voiceoverCharLimit ?? 10_000, images: opts.imageLimit ?? 30 };
+  const limits = { chars: opts.voiceoverCharLimit ?? 10_000, images: opts.imageLimit ?? 30, clips: opts.clipLimit ?? 5, cutoutSeconds: opts.cutoutSecondsLimit ?? 120 };
+  const jobs = new Map<string, ClipJob>();
+  const cutouts = new Map<string, CutoutJob>();
+  let cutoutFile: Blob | undefined;
+  // While held, no cutout job finishes: every status call says pending. For a test that sees a client give up waiting and come back.
+  let cutoutsHeld = false;
+  // Made on first use and kept for the life of this instance.
+  const clipFiles: Partial<Record<"plain" | "green", Blob>> = {};
+  const clipFile = (green: boolean) => (clipFiles[green ? "green" : "plain"] ??= makeClip(green));
   const ALNUM = "abcdefghijklmnopqrstuvwxyz0123456789";
   const nextId = (prefix: string) => `${prefix}-${Array.from(randomBytes(12), (b) => ALNUM[b % ALNUM.length]).join("")}`;
   const secret = () => randomBytes(16).toString("hex");
@@ -88,7 +141,7 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
       const m = meter(userId);
       return {
         userId: userId ?? "u-test", handle: handleOf(userId ?? "u-test"),
-        quota: { voiceoverChars: { used: m.chars, limit: limits.chars }, images: { used: m.images, limit: limits.images }, resetsAt: resetDate() },
+        quota: { voiceoverChars: { used: m.chars, limit: limits.chars }, images: { used: m.images, limit: limits.images }, clips: { used: m.clips, limit: limits.clips }, cutoutSeconds: { used: m.cutoutSeconds, limit: limits.cutoutSeconds }, resetsAt: resetDate() },
         // What the user gave the shared library that was accepted: their own items that are published. One waiting for review does not count.
         contributions: [...store.values()].filter((x) => x.owner === userId && x.committed && x.item.visibility === "published").length,
       };
@@ -122,7 +175,10 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
       const item: LibraryItem = { id, kind: input.kind, title: input.title, description: input.description, tags: input.tags, meta: input.meta, visibility: input.shareable ? "review" : "private" };
       store.set(id, { item, filename, contentType: input.contentType, owner: userId, committed: false });
       const token = secret();
-      uploads.set(token, { id, contentType: input.contentType, bytes: input.bytes, used: false });
+      uploads.set(token, {
+        contentType: input.contentType, bytes: input.bytes, used: false,
+        sink: { has: () => Boolean(store.get(id)?.file), put: (bytes) => { const s = store.get(id)!; s.file = { filename: s.filename, contentType: s.contentType, bytes }; } },
+      });
       return { id, uploadUrl: `${origin}/upload/${token}` };
     },
     libraryCommit: ({ id }, { userId }) => {
@@ -155,6 +211,76 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
       if (shareable) store.set(id, { item: { id, kind: "image", title: cut(prompt, 60), description: prompt, tags, meta: { aspect }, visibility: "review" }, file, filename: file.filename, contentType: file.contentType, owner: userId, committed: true });
       return { url: fileUrl(file), ext: "png", contentType: "image/png", ...(shareable ? { libraryId: id } : {}) };
     },
+    clipStart: (input, { userId }) => {
+      if (opts.noClipProvider) throw new Fail(400, "invalid_request", "Clip generation is not available on this server yet.");
+      const m = meter(userId);
+      if (m.clips + 1 > limits.clips) throw new Fail(429, "quota_exceeded", `Clip quota used up. It resets on ${resetDate().slice(0, 10)}.`);
+      m.clips++;
+      usage.clips++;
+      const id = nextId("clip");
+      jobs.set(id, { owner: userId ?? "u-test", prompt: input.prompt, aspect: input.aspect, greenScreen: input.greenScreen, durationSec: input.durationSec, shareable: input.shareable, tags: input.tags, asks: 0, charged: true });
+      return { id, status: "pending" };
+    },
+    clipStatus: ({ id }, { userId }) => {
+      const job = jobs.get(id);
+      if (!job || job.owner !== (userId ?? "u-test")) throw new Fail(404, "not_found", `No clip with id ${id}.`);
+      // The first ask finds it still working; from the second it has ended.
+      if (++job.asks === 1 || job.prompt.includes(CLIP_STALL)) return { id, status: "pending" };
+      if (job.prompt.includes(CLIP_FAIL)) {
+        // A failed clip is not charged: the reservation is given back, once.
+        if (job.charged) { job.charged = false; meter(userId).clips--; usage.clips--; }
+        return { id, status: "failed", message: "The video provider could not make this clip. Change the prompt and try again." };
+      }
+      const file = clipFile(job.greenScreen);
+      if (job.shareable && !job.libraryId) {
+        job.libraryId = nextId("clip");
+        const meta = { aspect: job.aspect, durationSec: job.durationSec, ...(job.greenScreen ? { greenScreen: true } : {}) };
+        store.set(job.libraryId, { item: { id: job.libraryId, kind: "clip", title: cut(job.prompt, 60), description: job.prompt, tags: job.tags, meta, visibility: "review" }, file, filename: file.filename, contentType: file.contentType, owner: userId, committed: true });
+      }
+      return {
+        id, status: "done", url: fileUrl(file), ext: "mp4", contentType: file.contentType, durationSec: job.durationSec, greenScreen: job.greenScreen,
+        ...(job.libraryId ? { libraryId: job.libraryId } : {}),
+      };
+    },
+    cutoutStart: (input, { userId }) => {
+      if (opts.noCutoutService) throw new Fail(400, "invalid_request", NO_GPU);
+      const id = nextId("cutout");
+      const job: CutoutJob = { owner: userId ?? "u-test", filename: input.filename, contentType: input.contentType, bytes: input.bytes, durationSec: input.durationSec, started: false, asks: 0, seconds: 0 };
+      cutouts.set(id, job);
+      const token = secret();
+      uploads.set(token, { contentType: input.contentType, bytes: input.bytes, used: false, sink: { has: () => Boolean(job.file), put: (bytes) => { job.file = bytes; } } });
+      return { id, uploadUrl: `${origin}/upload/${token}` };
+    },
+    cutoutRun: ({ id }, { userId }) => {
+      const job = cutouts.get(id);
+      if (!job || job.owner !== (userId ?? "u-test")) throw new Fail(404, "not_found", `No cutout with id ${id}.`);
+      // A job already started just answers where it is, without a second charge.
+      if (job.started) return { id, status: "pending" };
+      if (opts.noCutoutService) throw new Fail(400, "invalid_request", NO_GPU);
+      if (!job.file) throw new Fail(400, "invalid_request", `Nothing was uploaded for ${id}. Send the video to the upload URL first.`);
+      const seconds = Math.ceil(job.durationSec);
+      const m = meter(userId);
+      if (m.cutoutSeconds + seconds > limits.cutoutSeconds) throw new Fail(429, "quota_exceeded", `Cutout quota used up. It resets on ${resetDate().slice(0, 10)}.`);
+      m.cutoutSeconds += seconds;
+      usage.cutoutSeconds += seconds;
+      job.started = true;
+      job.seconds = seconds;
+      return { id, status: "pending" };
+    },
+    cutoutStatus: ({ id }, { userId }) => {
+      const job = cutouts.get(id);
+      if (!job || job.owner !== (userId ?? "u-test")) throw new Fail(404, "not_found", `No cutout with id ${id}.`);
+      if (!job.started) throw new Fail(400, "invalid_request", `Cutout ${id} has not been run yet.`);
+      if (++job.asks === 1 || cutoutsHeld) return { id, status: "pending" };
+      // The uploaded video is deleted when the job ends, whatever the result.
+      job.file = undefined;
+      if (job.filename.includes(CUTOUT_FAIL)) {
+        // A failed cutout is not charged: the seconds are given back, once.
+        if (job.seconds) { meter(userId).cutoutSeconds -= job.seconds; usage.cutoutSeconds -= job.seconds; job.seconds = 0; }
+        return { id, status: "failed", message: "The video could not be processed. Try a different video." };
+      }
+      return { id, status: "done", url: fileUrl((cutoutFile ??= makeCutout())), ext: "webm", contentType: "video/webm" };
+    },
     publicLibrary: ({ q, kind, page }) => {
       // Published items only. Newest first; with a query, best match first and equal matches newest first.
       const want = q ? words(q) : undefined;
@@ -164,7 +290,7 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
         .filter((x) => x.s.item.visibility === "published" && (!kind || x.s.item.kind === kind) && (!want || x.score > 0))
         .sort((a, b) => b.score - a.score || b.order - a.order).map((x) => x.s);
       const p = page ?? 1, size = 24;
-      const items = all.slice((p - 1) * size, p * size).map((s) => (s.file && PREVIEW_OF_ORIGINAL.includes(s.item.kind) ? { ...s.item, previewUrl: fileUrl(s.file) } : s.item));
+      const items = all.slice((p - 1) * size, p * size).map((s) => (s.file && (PREVIEW_OF_ORIGINAL.includes(s.item.kind) || shortClip(s.item)) ? { ...s.item, previewUrl: fileUrl(s.file) } : s.item));
       return { items, page: p, hasMore: all.length > p * size };
     },
   };
@@ -185,15 +311,14 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
       }
       if (req.method === "PUT" && url.pathname.startsWith("/upload/")) {
         const up = uploads.get(url.pathname.slice("/upload/".length));
-        const s = up && store.get(up.id);
-        if (!up || !s) return send(404, { error: { code: "not_found", message: "No such upload." } });
+        if (!up?.sink) return send(404, { error: { code: "not_found", message: "No such upload." } });
         // The URL is good for one PUT. Whether that PUT is accepted or refused, a second one is dead, and so is any PUT after commit.
         // (A real server may be kinder; the contract promises clients no more than this.)
-        if (up.used || s.file) throw new Fail(400, "invalid_request", "This upload URL has already been used.");
+        if (up.used || up.sink.has()) throw new Fail(400, "invalid_request", "This upload URL has already been used.");
         up.used = true;
         if (req.headers["content-type"] !== up.contentType) throw new Fail(400, "invalid_request", `The upload must be sent as ${up.contentType}.`);
         if (raw.length !== up.bytes) throw new Fail(400, "invalid_request", `The upload must be exactly ${up.bytes} bytes.`);
-        s.file = { filename: s.filename, contentType: s.contentType, bytes: new Uint8Array(raw) };
+        up.sink.put(new Uint8Array(raw));
         return send(200, {});
       }
 
@@ -219,6 +344,12 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
   return {
     baseUrl: `${origin}/api/v1`,
     usage,
+    // Changes how many clips a user may start from now on, as `clipLimit` does at the start.
+    setClipLimit(n: number) { limits.clips = n; },
+    // The same for the seconds of video a user may have cut out.
+    setCutoutLimit(n: number) { limits.cutoutSeconds = n; },
+    // Stops cutout jobs from finishing (true) or lets them finish again (false).
+    holdCutouts(hold: boolean) { cutoutsHeld = hold; },
     approve(userCode: string, userId = "u-test") { for (const d of devices.values()) if (d.userCode === userCode) { d.approved = true; d.userId = userId; } },
     // A ready token, for tests that are not about logging in.
     login(userId = "u-test") { const t = nextId("tok"); tokens.set(t, userId); return t; },