@higgsfield/video-editor-mcp 1.0.2 → 1.0.4

package/node_modules/@higgsfield/higgsedit/dist/chunk-C6SASQHE.mjs

@@ -34,9 +34,13 @@ import {
 import "./chunk-2VKQHJMM.mjs";
 import "./chunk-75WO2NOF.mjs";
 
+import { renderCapabilities, validateRenderRequest } from "./export-settings.mjs";
+import { MEDIA_UPLOAD_TEMP_PREFIX, MediaUploads, listMediaFiles } from "./media-upload.mjs";
+
 // src/dev.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3, watch, writeFileSync as writeFileSync2 } from "node:fs";
 import { extname, join as join4 } from "node:path";
+import { linkSync, lstatSync, mkdtempSync, rmSync as removeExportStage } from "node:fs";
 
 // src/editor-build.ts
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
@@ -158,132 +162,7 @@ var EditHistory = class {
   }
 };
 
-// src/proxy.ts
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, renameSync as renameSync2, rmSync, statSync as statSync2 } from "node:fs";
-import { join as join3 } from "node:path";
-import { promisify } from "node:util";
-var run = promisify(execFile);
-var VIDEO = /\.(mp4|mov|m4v|mkv|webm)$/i;
-var SKIP = /(^|\/)(node_modules|\.git|\.higgsedit-cache|renders|dist)(\/|$)/;
-var LONG_SIDE = 1920;
-var DECODABLE = /* @__PURE__ */ new Set(["h264", "hevc", "vp9", "av1"]);
-var needsProxy = (p) => p.width * p.height > LONG_SIDE * 1088 || !DECODABLE.has(p.codec);
-var even = (n) => Math.max(2, Math.round(n / 2) * 2);
-var Proxies = class {
-  constructor(dir, onReady, log = () => {
-  }) {
-    this.dir = dir;
-    this.onReady = onReady;
-    this.log = log;
-    this.root = join3(dir, ".higgsedit-cache", "proxies");
-  }
-  dir;
-  onReady;
-  log;
-  root;
-  queue = [];
-  pending = /* @__PURE__ */ new Set();
-  current;
-  stopped = false;
-  key(rel) {
-    try {
-      const st = statSync2(join3(this.dir, rel));
-      return createHash("sha1").update(`${rel}\0${st.size}\0${st.mtimeMs}`).digest("hex").slice(0, 20);
-    } catch {
-      return void 0;
-    }
-  }
-  /** The finished proxy for a project-relative video path, if there is one. */
-  lookup(rel) {
-    const key = this.key(rel);
-    const file = key && join3(this.root, `${key}.mp4`);
-    return file && existsSync2(file) ? file : void 0;
-  }
-  /** Queues every video in the project. */
-  scan(sub = "") {
-    let entries;
-    try {
-      entries = readdirSync2(join3(this.dir, sub), { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      const rel = sub ? `${sub}/${e.name}` : e.name;
-      if (e.name.startsWith(".") || SKIP.test(rel)) continue;
-      if (e.isDirectory()) this.scan(rel);
-      else this.consider(rel);
-    }
-  }
-  /** Queues `rel` if it is a video that needs a proxy and has none yet. */
-  consider(rel) {
-    if (this.stopped || !VIDEO.test(rel) || SKIP.test(rel) || this.pending.has(rel) || this.lookup(rel)) return;
-    this.pending.add(rel);
-    this.queue.push(rel);
-    if (this.queue.length === 1 && !this.current) void this.drain();
-  }
-  async drain() {
-    while (!this.stopped && this.queue.length) {
-      const rel = this.queue[0];
-      try {
-        await this.make(rel);
-      } catch (error) {
-        this.log(`proxy for ${rel} failed: ${error instanceof Error ? error.message : String(error)}`);
-      }
-      this.queue.shift();
-      this.pending.delete(rel);
-    }
-  }
-  async make(rel) {
-    const file = join3(this.dir, rel);
-    for (let size = -1; ; ) {
-      const now = statSync2(file).size;
-      if (now === size) break;
-      size = now;
-      await new Promise((r) => setTimeout(r, 400));
-    }
-    if (this.lookup(rel)) return;
-    const facts = await probe(file);
-    if (!needsProxy(facts)) return;
-    const { stdout } = await run(requireTool("ffprobe"), ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=time_base", "-of", "csv=p=0", file]);
-    const timescale = Number(stdout.trim().split("/")[1]) || 9e4;
-    const scale = LONG_SIDE / Math.max(facts.width, facts.height);
-    const [w, h] = scale < 1 ? [even(facts.width * scale), even(facts.height * scale)] : [even(facts.width), even(facts.height)];
-    const key = this.key(rel);
-    mkdirSync(this.root, { recursive: true });
-    const out = join3(this.root, `${key}.mp4`);
-    const part = join3(this.root, `${key}.part.mp4`);
-    const t0 = performance.now();
-    this.log(`making a preview proxy for ${rel} (${facts.width}\xD7${facts.height} \u2192 ${w}\xD7${h})\u2026`);
-    const args = ["-y", "-i", file, "-map", "0:v:0", "-map", "0:a:0?", "-vf", `scale=${w}:${h}`, "-c:v", "libx264", "-preset", "veryfast", "-crf", "20", "-bf", "0", "-g", "12", "-pix_fmt", "yuv420p"];
-    args.push("-fps_mode", "passthrough", "-video_track_timescale", String(timescale), "-c:a", "aac", "-b:a", "160k", "-movflags", "+faststart", part);
-    await new Promise((resolve, reject) => {
-      const p = ffmpeg(args);
-      this.current = p;
-      let err = "";
-      p.stderr.on("data", (d) => err += d.toString());
-      p.on("error", reject);
-      p.on("close", (code) => {
-        this.current = void 0;
-        if (code === 0) resolve();
-        else reject(new Error(err.trim() || `ffmpeg exited with ${code}`));
-      });
-    }).catch((error) => {
-      rmSync(part, { force: true });
-      throw error;
-    });
-    if (this.stopped) return rmSync(part, { force: true });
-    renameSync2(part, out);
-    this.log(`proxy for ${rel} ready in ${((performance.now() - t0) / 1e3).toFixed(1)} s`);
-    this.onReady(`./${rel}`);
-  }
-  stop() {
-    this.stopped = true;
-    this.queue.length = 0;
-    this.current?.kill("SIGKILL");
-  }
-};
+import { Proxies } from "./proxy.mjs";
 
 // src/dev.ts
 var escapeHtml = (s) => s.replace(/[&<>"]/g, (c) => `&#${c.charCodeAt(0)};`);
@@ -302,7 +181,8 @@ ${entry.styles.map((s) => `<link rel="stylesheet" href="/__higgsedit/editor/${s}
 <script type="module" src="/__higgsedit/editor/${entry.script}"></script>
 </body>
 </html>`;
-async function startDev(dir, port = 0) {
+async function startDev(dir, port = 0, options = {}) {
+  const mediaUploads = new MediaUploads(dir, options.mediaUploads);
   const clients = /* @__PURE__ */ new Set();
   const known = /* @__PURE__ */ new Map();
   for (const f of sourceFiles(dir)) known.set(f, readFileSync3(join4(dir, f), "utf8"));
@@ -347,19 +227,45 @@ async function startDev(dir, port = 0) {
     if (changed.length) broadcast({ type: "change", files: changed, origin, detectedAt: firstSeen, mtime, undo: history.state() });
   };
   const proxies = new Proxies(dir, (src) => broadcast({ type: "proxy", src }), (line) => console.log(line));
-  proxies.scan();
   const watcher = watch(dir, { recursive: true }, (_event, name) => {
     const file = (name ?? "").split("\\").join("/");
     if (/(^|\/)(node_modules|\.git|\.higgsedit-cache|renders)(\/|$)/.test(file)) return;
+    if (file.split("/").some((part) => part.startsWith(MEDIA_UPLOAD_TEMP_PREFIX))) return;
     proxies.consider(file);
+    if (file === "media" || file.startsWith("media/")) return;
     if (!timer) firstSeen = Date.now();
     if (!timer) timer = setTimeout(flush, 15);
   });
   const jobs = /* @__PURE__ */ new Map();
   let jobSeq = 0;
+  let stopping = false;
+  let mutations = 0;
+  let stopped;
+  const busy = () => mediaUploads.busy || mutations > 0 || [...jobs.values()].some((job) => job.state === "running");
   const server = await startServer(
     dir,
     [
+      (req, res, url) => {
+        if (stopping) { res.setHeader("retry-after", "1"); json(res, 503, { error: "editor is stopping" }); return true; }
+        if (url.pathname === "/api/idle-stop" && req.method === "POST") {
+          if (busy()) { json(res, 409, { busy: true }); return true; }
+          stopping = true;
+          res.once("finish", () => { options.onIdleStop?.(); void stop(); });
+          json(res, 200, { stopping: true }); return true;
+        }
+        if (req.method !== "GET" && req.method !== "HEAD") {
+          mutations++;
+          let released = false;
+          const release = () => { if (!released) { released = true; mutations--; } };
+          res.once("finish", release); res.once("close", release);
+        }
+        return false;
+      },
+      (req, res, url) => mediaUploads.handle(req, res, url),
+      (req, res, url) => {
+        if (url.pathname !== "/api/activity" || req.method !== "GET") return false;
+        json(res, 200, { busy: busy() }); return true;
+      },
       async (req, res, url) => {
         if (url.pathname !== "/" && url.pathname !== "/index.html") return false;
         const entry = await editorEntry((line) => console.log(line));
@@ -413,39 +319,93 @@ async function startDev(dir, port = 0) {
       },
       async (req, res, url) => {
         if (!url.pathname.startsWith("/api/render")) return false;
+        if (url.pathname === "/api/render/capabilities" && req.method === "GET") {
+          json(res, 200, await renderCapabilities());
+          return true;
+        }
         if (url.pathname === "/api/render" && req.method === "POST") {
+          let body;
+          try {
+            body = validateRenderRequest(JSON.parse((await readBody(req)).toString() || "{}"), await renderCapabilities());
+          } catch (error) {
+            json(res, 400, { error: error.message });
+            return true;
+          }
           if ([...jobs.values()].some((j) => j.state === "running")) {
             json(res, 409, { error: "a render is already running" });
             return true;
           }
-          const body = JSON.parse((await readBody(req)).toString() || "{}");
-          const name = (body.fileName ?? "render.mp4").replace(/[/\\]/g, "_");
-          const out = join4(dir, "renders", name.endsWith(".mp4") ? name : `${name}.mp4`);
-          mkdirSync2(join4(dir, "renders"), { recursive: true });
+          const requested = (body.fileName ?? "render.mp4").replace(/[/\\]/g, "_");
+          const name = requested.endsWith(".mp4") ? requested : `${requested}.mp4`;
+          const renders = join4(dir, "renders");
+          mkdirSync2(renders, { recursive: true });
+          const directory = lstatSync(renders);
+          if (!directory.isDirectory() || directory.isSymbolicLink()) {
+            json(res, 400, { error: "renders must be a project directory, not a symbolic link" });
+            return true;
+          }
+          const stage = mkdtempSync(join4(renders, ".export-"));
+          const stageIdentity = lstatSync(stage);
+          const out = join4(stage, "output.mp4");
           const id2 = String(++jobSeq);
-          const job2 = { state: "running", done: 0, total: 0, out: `renders/${out.split("/").at(-1)}`, abort: new AbortController() };
+          const job2 = { state: "running", done: 0, total: 0, abort: new AbortController() };
           jobs.set(id2, job2);
-          render(dir, {
-            out,
-            depth: body.depth ?? 8,
-            allowFontFallback: body.allowFontFallback === true,
-            ...body.from ? { from: body.from } : {},
-            ...body.to ? { to: body.to } : {},
-            signal: job2.abort.signal,
-            onProgress: (done, total) => {
-              job2.done = done;
-              job2.total = total;
-            }
-          }).then(
-            (report) => {
+          void (async () => {
+            try {
+              const report = await render(dir, {
+                out,
+                depth: body.depth ?? 8,
+                allowFontFallback: body.allowFontFallback === true,
+                ...body.from !== undefined ? { from: body.from } : {},
+                ...body.to !== undefined ? { to: body.to } : {},
+                ...body.spec ? { spec: body.spec } : {},
+                ...body.sceneId !== undefined ? { sceneId: body.sceneId } : {},
+                signal: job2.abort.signal,
+                onProgress: (done, total) => {
+                  job2.done = done;
+                  job2.total = total;
+                }
+              });
+              // Cancellation during remux/closing the capture page must not publish a result.
+              if (job2.abort.signal.aborted) throw Object.assign(new Error("render cancelled"), { name: "RenderCancelledError" });
+              const current = lstatSync(renders);
+              if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== directory.dev || current.ino !== directory.ino) throw new Error("renders directory changed during export");
+              const output = lstatSync(out);
+              if (!output.isFile() || output.isSymbolicLink() || output.size === 0) throw new Error("render did not produce a complete file");
+              const occupied = new Set(readdirSync3(renders));
+              for (let n = 1; ; n++) {
+                const candidate = n === 1 ? name : `${name.slice(0, -4)}-${n}.mp4`;
+                if (occupied.has(candidate)) continue;
+                try { linkSync(out, join4(renders, candidate)); }
+                catch (error) {
+                  if (error.code === "EEXIST") continue;
+                  if (!["ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV", "ENOSYS"].includes(error.code)) throw error;
+                  // Some removable/network volumes do not support hard links. A newly reserved
+                  // directory gives rename an exclusively owned, nonexistent destination there too.
+                  const reserved = mkdtempSync(join4(renders, `${name.slice(0, -4)}-`));
+                  try { renameSync(out, join4(reserved, name)); }
+                  catch (error) { removeExportStage(reserved, { recursive: true, force: true }); throw error; }
+                  job2.out = `renders/${reserved.slice(renders.length + 1)}/${name}`;
+                  break;
+                }
+                job2.out = `renders/${candidate}`;
+                break;
+              }
               job2.state = "done";
               job2.msPerFrame = report.msPerFrame;
-            },
-            (error) => {
-              job2.state = error.name === "RenderCancelledError" ? "cancelled" : "failed";
+            } catch (error) {
+              job2.state = job2.abort.signal.aborted || error.name === "RenderCancelledError" ? "cancelled" : "failed";
               job2.error = error.message;
+            } finally {
+              // Never delete a published file, or a directory substituted for this job's staging area.
+              try {
+                const current = lstatSync(stage);
+                if (current.dev === stageIdentity.dev && current.ino === stageIdentity.ino && !current.isSymbolicLink()) removeExportStage(stage, { recursive: true, force: true });
+              } catch (error) {
+                if (error.code !== "ENOENT") console.warn("Could not remove export staging directory:", error.message);
+              }
             }
-          );
+          })();
           json(res, 200, { id: id2 });
           return true;
         }
@@ -455,7 +415,7 @@ async function startDev(dir, port = 0) {
           json(res, 404, { error: `no render ${id}` });
           return true;
         }
-        if (url.pathname === "/api/render/cancel") job.abort.abort();
+        if (url.pathname === "/api/render/cancel" && job.state === "running") job.abort.abort();
         const { abort: _abort, ...status } = job;
         void _abort;
         json(res, 200, status);
@@ -470,6 +430,7 @@ async function startDev(dir, port = 0) {
           res.end();
           return true;
         }
+        proxies.consider(rel, true);
         const proxy = proxies.lookup(rel);
         if (proxy) res.setHeader("x-higgsedit-proxy", "1");
         sendFile(req, res, proxy ?? file);
@@ -484,23 +445,7 @@ async function startDev(dir, port = 0) {
       async (req, res, url) => {
         if (url.pathname !== "/api/media") return false;
         const media = join4(dir, "media");
-        if (req.method === "POST") {
-          const name = url.searchParams.get("name") ?? "";
-          if (!/^[^/\\]+$/.test(name) || name.startsWith(".")) {
-            json(res, 400, { error: `bad media name "${name}"` });
-            return true;
-          }
-          mkdirSync2(media, { recursive: true });
-          const ext = extname(name);
-          const stem = name.slice(0, name.length - ext.length);
-          let file = name;
-          for (let n = 2; existsSync3(join4(media, file)); n++) file = `${stem}-${n}${ext}`;
-          const bytes = await readBody(req);
-          writeFileSync2(join4(media, file), bytes);
-          json(res, 200, { src: `./media/${file}`, byteSize: bytes.length });
-          return true;
-        }
-        const files = existsSync3(media) ? readdirSync3(media, { withFileTypes: true }).filter((e) => e.isFile() && !e.name.startsWith(".")).map((e) => ({ src: `./media/${e.name}`, byteSize: statSync3(join4(media, e.name)).size })).toSorted((a, b) => a.src.localeCompare(b.src)) : [];
+        const files = listMediaFiles(media);
         json(res, 200, { files });
         return true;
       },
@@ -515,21 +460,30 @@ async function startDev(dir, port = 0) {
     ],
     port
   );
-  return {
-    ...server,
-    async stop() {
+  function stop() {
+    stopping = true;
+    return stopped ??= (async () => {
+      clearTimeout(timer);
       watcher.close();
+      await mediaUploads.close();
       proxies.stop();
       for (const c of clients) c.end();
       await server.close();
-    }
-  };
+    })();
+  }
+  return { ...server, stop };
 }
 async function dev(dir, port) {
-  const server = await startDev(dir, port);
-  console.log(`higgsedit dev  ${dir}
-  editor  ${server.origin}/`);
+  const server = await startDev(dir, port, { onIdleStop: () => quit() });
+  console.log(`higgsedit dev  ${dir}\n  editor  ${server.origin}/`);
+  const quit = () => {
+    setTimeout(() => process.exit(0), 3000).unref();
+    void server.stop().finally(() => process.exit(0));
+  };
+  process.once("SIGTERM", quit);
+  process.once("SIGINT", quit);
 }
+
 export {
   dev,
   startDev

package/node_modules/@higgsfield/higgsedit/dist/export-settings.mjs

@@ -0,0 +1,75 @@
+import { ffmpeg } from "./chunk-EKFC4S4M.mjs";
+import { parseTime } from "./chunk-F7YUKEI5.mjs";
+
+// This is the native renderer's contract; the iframe's encoders do not constrain it.
+const sampleRates = [44100, 48000, 96000];
+let capabilities;
+export function renderCapabilities() {
+  capabilities ??= new Promise((resolve, reject) => {
+    const child = ffmpeg(["-encoders"]);
+    let output = "";
+    child.stdout.on("data", (chunk) => output += chunk.toString());
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code !== 0) return reject(new Error("could not inspect native video encoders"));
+      const has = (name) => new RegExp(`^\\s*[A-Z.]{6}\\s+${name}\\s`, "m").test(output);
+      const videoCodecs = [...has("libx264") ? ["avc"] : [], ...has("libx265") ? ["hevc"] : []];
+      resolve({ containers: videoCodecs.length ? ["mp4"] : [], videoCodecs, audioCodecs: has("aac") ? ["aac"] : [], sampleRates, audioOnly: false });
+    });
+  }).catch((error) => { capabilities = undefined; throw error; });
+  return capabilities;
+}
+
+const object = (value, label) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+  return value;
+};
+const number = (value, label, min, max, integer = false) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max || integer && !Number.isInteger(value)) throw new Error(`${label} must be ${integer ? "an integer" : "a number"} between ${min} and ${max}`);
+  return value;
+};
+const member = (value, allowed, label) => {
+  if (!allowed.includes(value)) throw new Error(`unsupported ${label}: ${String(value)}`);
+  return value;
+};
+export function validateRenderRequest(input, supported) {
+  const body = object(input, "render request");
+  const out = {};
+  if (body.fileName !== undefined) {
+    if (typeof body.fileName !== "string" || !body.fileName.trim() || body.fileName.length > 180 || /[\x00-\x1f]/.test(body.fileName)) throw new Error("fileName must be a nonempty filename of at most 180 characters");
+    out.fileName = body.fileName;
+  }
+  if (body.sceneId !== undefined) {
+    if (typeof body.sceneId !== "string" || !body.sceneId || body.sceneId.length > 1024) throw new Error("sceneId must be a nonempty scene identifier");
+    out.sceneId = body.sceneId;
+  }
+  for (const key of ["from", "to"]) {
+    if (body[key] === undefined) continue;
+    const time = parseTime(body[key], 30);
+    if (time === undefined || !Number.isFinite(time) || time < 0 || typeof body[key] === "string" && body[key].length > 64) throw new Error(`${key} must be a nonnegative time`);
+    out[key] = body[key];
+  }
+  out.depth = body.depth === undefined ? 8 : member(body.depth, [8, 10], "bit depth");
+  out.allowFontFallback = body.allowFontFallback === true;
+  if (body.spec === undefined) return out;
+  const spec = object(body.spec, "spec");
+  const video = object(spec.video, "spec.video (audio-only export is unavailable)");
+  const width = number(video.width, "video width", 2, 8192, true);
+  const height = number(video.height, "video height", 2, 8192, true);
+  if (width % 2 || height % 2 || width * height > 35389440) throw new Error("video dimensions must be even and no larger than 8K");
+  const normalized = {
+    container: member(spec.container, supported.containers, "container"),
+    video: { width, height, fps: number(video.fps, "video fps", 1, 120), codec: member(video.codec, supported.videoCodecs, "video codec") },
+    audio: null
+  };
+  if (video.bitrate !== undefined) normalized.video.bitrate = number(video.bitrate, "video bitrate", 1000, 1000000000, true);
+  if (spec.audio !== null) {
+    const audio = object(spec.audio, "spec.audio");
+    normalized.audio = { codec: member(audio.codec, supported.audioCodecs, "audio codec"), sampleRate: member(audio.sampleRate, supported.sampleRates, "audio sample rate"), channels: member(audio.channels, [1, 2], "audio channels") };
+    if (audio.bitrate !== undefined) normalized.audio.bitrate = number(audio.bitrate, "audio bitrate", 16000, 1024000, true);
+  }
+  // The explicit codec selects its native encoder. Legacy --depth still applies without a spec.
+  out.depth = 8;
+  out.spec = normalized;
+  return out;
+}