@higgsfield/video-editor-mcp 1.0.2 → 1.0.4

package/node_modules/@higgsfield/higgsedit/dist/media-upload.mjs

@@ -0,0 +1,381 @@
+import { randomUUID } from "node:crypto";
+import {
+  constants,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  readdirSync,
+  renameSync,
+  rmdirSync,
+  statSync
+} from "node:fs";
+import { open, rm } from "node:fs/promises";
+import { extname, join } from "node:path";
+const json = (res, status, body) => {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(body));
+};
+const MEDIA_UPLOAD_PART_BYTES = 2 << 20;
+const MEDIA_UPLOAD_TEMP_PREFIX = ".higgsedit-upload-";
+function isPrivateMediaUploadPath(path) {
+  return path.split(/[/\\]/).some((part) => part.toUpperCase().startsWith(MEDIA_UPLOAD_TEMP_PREFIX.toUpperCase()));
+}
+const defaults = {
+  maxBytes: 8 * 1024 ** 3,
+  idleMs: 6e4,
+  totalMs: 30 * 6e4,
+  maxConcurrent: 4
+};
+const envKeys = {
+  maxBytes: "HIGGSEDIT_MEDIA_MAX_BYTES",
+  idleMs: "HIGGSEDIT_MEDIA_IDLE_MS",
+  totalMs: "HIGGSEDIT_MEDIA_TOTAL_MS",
+  maxConcurrent: "HIGGSEDIT_MEDIA_MAX_CONCURRENT"
+};
+class UploadError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+}
+class MediaUploads {
+  active = /* @__PURE__ */ new Map();
+  root;
+  rootIdentity;
+  closed = false;
+  limits;
+  constructor(dir, limits = {}) {
+    this.root = realpathSync(dir);
+    this.rootIdentity = lstatSync(this.root);
+    this.limits = { ...defaults };
+    for (const key of Object.keys(defaults)) {
+      const value = limits[key] ?? (process.env[envKeys[key]] ? Number(process.env[envKeys[key]]) : defaults[key]);
+      if (!Number.isSafeInteger(value) || value <= 0)
+        throw new Error(`${envKeys[key]} must be a positive safe integer`);
+      this.limits[key] = value;
+    }
+  }
+  get busy() {
+    return this.active.size > 0;
+  }
+  async close() {
+    this.closed = true;
+    await Promise.all(
+      [...this.active.values()].map((u) => this.dispose(u, new UploadError("editor closed", 503)))
+    );
+  }
+  checkMedia() {
+    const root = lstatSync(this.root);
+    if (root.isSymbolicLink() || root.dev !== this.rootIdentity.dev || root.ino !== this.rootIdentity.ino)
+      throw new UploadError("project directory changed during upload", 400);
+    const media = join(this.root, "media");
+    mkdirSync(media, { recursive: true });
+    const st = lstatSync(media);
+    if (!st.isDirectory() || st.isSymbolicLink() || realpathSync(media) !== media)
+      throw new UploadError("media must be a real project directory, not a symlink", 400);
+    return media;
+  }
+  async begin(name) {
+    if (!name || name.startsWith(".") || /[/\\]/.test(name) || [...name].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127) || Buffer.byteLength(name) > 240)
+      throw new UploadError("invalid media filename", 400);
+    if (this.closed) throw new UploadError("editor closed", 503);
+    if (this.active.size >= this.limits.maxConcurrent)
+      throw new UploadError("too many active media uploads; try again after one finishes", 429);
+    const directory = lstatSync(this.checkMedia());
+    const temp = mkdtempSync(join(this.checkMedia(), MEDIA_UPLOAD_TEMP_PREFIX));
+    const u = {
+      id: randomUUID(),
+      name,
+      temp,
+      directory,
+      staging: lstatSync(temp),
+      bytes: 0,
+      busy: true,
+      abort: new AbortController()
+    };
+    this.active.set(u.id, u);
+    try {
+      u.file = await open(
+        join(temp, "body"),
+        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+        384
+      );
+      if (u.abort.signal.aborted) {
+        await u.file.close();
+        u.abort.signal.throwIfAborted();
+      }
+      u.total = setTimeout(() => {
+        void this.dispose(u, new UploadError("media upload exceeded its total time limit", 408));
+      }, this.limits.totalMs);
+      u.total.unref();
+      u.busy = false;
+      this.touch(u);
+      return u;
+    } catch (error) {
+      await this.dispose(u, error);
+      throw error;
+    }
+  }
+  touch(u) {
+    clearTimeout(u.idle);
+    u.idle = setTimeout(() => {
+      void this.dispose(u, new UploadError("media upload stalled", 408));
+    }, this.limits.idleMs);
+    u.idle.unref();
+  }
+  dispose(u, reason = new UploadError("media upload cancelled", 499)) {
+    if (u.cleanup) return u.cleanup;
+    u.abort.abort(reason);
+    clearTimeout(u.idle);
+    clearTimeout(u.total);
+    u.cleanup = (async () => {
+      let failure;
+      try {
+        await u.file?.close();
+      } catch (error) {
+        failure = error;
+      }
+      try {
+        let current;
+        try {
+          current = lstatSync(u.temp);
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+        if (current?.isDirectory() && !current.isSymbolicLink() && current.dev === u.staging.dev && current.ino === u.staging.ino)
+          await rm(u.temp, { recursive: true, force: true });
+      } catch (error) {
+        failure ??= error;
+      }
+      this.active.delete(u.id);
+      if (failure) throw failure;
+    })();
+    void u.cleanup.catch(() => {
+    });
+    return u.cleanup;
+  }
+  declared(req, maximum) {
+    const length = req.headers["content-length"];
+    if (length !== void 0 && (!/^\d+$/.test(length) || !Number.isSafeInteger(Number(length)) || Number(length) > maximum)) {
+      throw new UploadError(`media upload exceeds the ${maximum} byte limit`, 413);
+    }
+  }
+  async append(u, req, maxPart) {
+    this.declared(req, Math.min(maxPart, this.limits.maxBytes - u.bytes));
+    let partBytes = 0;
+    const signal = u.abort.signal;
+    while (true) {
+      signal.throwIfAborted();
+      if (req.aborted || req.destroyed && !req.complete)
+        throw new UploadError("media upload disconnected", 499);
+      const bytes = req.read();
+      if (bytes === null) {
+        if (req.readableEnded) break;
+        await new Promise((resolve, reject) => {
+          const clean = () => {
+            req.off("readable", ready);
+            req.off("end", ready);
+            req.off("error", fail);
+            req.off("aborted", disconnected);
+            signal.removeEventListener("abort", aborted);
+          };
+          const ready = () => {
+            clean();
+            resolve();
+          };
+          const fail = (error) => {
+            clean();
+            reject(error);
+          };
+          const disconnected = () => fail(new UploadError("media upload disconnected", 499));
+          const aborted = () => fail(signal.reason);
+          req.once("readable", ready);
+          req.once("end", ready);
+          req.once("error", fail);
+          req.once("aborted", disconnected);
+          signal.addEventListener("abort", aborted, { once: true });
+          if (signal.aborted) aborted();
+        });
+        continue;
+      }
+      partBytes += bytes.byteLength;
+      if (partBytes > maxPart || u.bytes + bytes.byteLength > this.limits.maxBytes)
+        throw new UploadError(`media upload exceeds the ${this.limits.maxBytes} byte limit`, 413);
+      this.touch(u);
+      for (let offset = 0; offset < bytes.byteLength; ) {
+        signal.throwIfAborted();
+        const { bytesWritten } = await u.file.write(bytes, offset, bytes.byteLength - offset);
+        if (!bytesWritten) throw new Error("could not write media upload");
+        offset += bytesWritten;
+      }
+      u.bytes += bytes.byteLength;
+      this.touch(u);
+    }
+    signal.throwIfAborted();
+  }
+  async publish(u) {
+    await u.file.sync();
+    u.abort.signal.throwIfAborted();
+    const written = await u.file.stat();
+    u.abort.signal.throwIfAborted();
+    const media = this.checkMedia();
+    const directory = lstatSync(media);
+    const staging = lstatSync(u.temp);
+    const current = lstatSync(join(u.temp, "body"));
+    if (directory.dev !== u.directory.dev || directory.ino !== u.directory.ino || staging.isSymbolicLink() || staging.dev !== u.staging.dev || staging.ino !== u.staging.ino || !current.isFile() || current.isSymbolicLink() || current.dev !== written.dev || current.ino !== written.ino || current.size !== u.bytes)
+      throw new UploadError("media upload destination changed", 409);
+    const ext = extname(u.name);
+    const stem = u.name.slice(0, u.name.length - ext.length);
+    for (let suffix = 1; suffix <= 1e4; suffix++) {
+      const name = suffix === 1 ? u.name : `${stem}-${suffix}${ext}`;
+      try {
+        linkSync(join(u.temp, "body"), join(media, name));
+      } catch (error) {
+        const code = error.code;
+        if (code === "EEXIST") continue;
+        if (!["ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV", "ENOSYS"].includes(code ?? ""))
+          throw error;
+        const reserved = mkdtempSync(join(media, "import-"));
+        try {
+          renameSync(join(u.temp, "body"), join(reserved, u.name));
+        } catch (failure) {
+          try {
+            rmdirSync(reserved);
+          } catch {
+          }
+          throw failure;
+        }
+        return { src: `./media/${reserved.slice(media.length + 1)}/${u.name}`, byteSize: u.bytes };
+      }
+      return { src: `./media/${name}`, byteSize: u.bytes };
+    }
+    throw new UploadError("too many media files with this name", 409);
+  }
+  async handle(req, res, url) {
+    if (isPrivateMediaUploadPath(decodeURIComponent(url.pathname))) {
+      json(res, 403, { error: "private upload" });
+      return true;
+    }
+    if (url.pathname === "/api/media/capabilities" && req.method === "GET") {
+      json(res, 200, {
+        streaming: true,
+        version: 1,
+        maxBytes: this.limits.maxBytes,
+        partBytes: MEDIA_UPLOAD_PART_BYTES,
+        maxConcurrent: this.limits.maxConcurrent
+      });
+      return true;
+    }
+    const direct = (url.pathname === "/api/media" || url.pathname === "/api/media/stream") && req.method === "POST";
+    const begin = url.pathname === "/api/media/uploads" && req.method === "POST";
+    const part = /^\/api\/media\/uploads\/([a-f0-9-]{36})$/.exec(url.pathname);
+    if (!direct && !begin && !part) return false;
+    let u;
+    let owns = false;
+    const disconnected = () => {
+      if (u && !res.writableFinished)
+        void this.dispose(u, new UploadError("media upload disconnected", 499));
+    };
+    res.once("close", disconnected);
+    try {
+      if (direct || begin) {
+        this.declared(req, direct ? this.limits.maxBytes : 0);
+        if (begin && req.headers["transfer-encoding"])
+          throw new UploadError("upload session creation takes no body", 400);
+        u = await this.begin(url.searchParams.get("name") ?? "");
+        if (res.destroyed) throw new UploadError("media upload disconnected", 499);
+        if (begin) {
+          json(res, 201, {
+            id: u.id,
+            maxBytes: this.limits.maxBytes,
+            partBytes: MEDIA_UPLOAD_PART_BYTES
+          });
+          return true;
+        }
+      } else {
+        u = this.active.get(part[1]);
+        if (req.method !== "PUT") {
+          this.declared(req, 0);
+          if (req.headers["transfer-encoding"])
+            throw new UploadError("upload finalization and cancellation take no body", 400);
+        }
+        if (!u) throw new UploadError("media upload not found or expired", 404);
+        if (req.method === "DELETE") {
+          await this.dispose(u);
+          json(res, 200, { ok: true });
+          return true;
+        }
+        if (u.busy) throw new UploadError("media upload already has a request in progress", 409);
+        if (req.method !== "PUT" && req.method !== "POST")
+          throw new UploadError("unsupported upload method", 405);
+        if (req.method === "PUT" && (!/^\d+$/.test(url.searchParams.get("offset") ?? "") || Number(url.searchParams.get("offset")) !== u.bytes))
+          throw new UploadError("media upload offset does not match", 409);
+      }
+      u.busy = true;
+      owns = true;
+      if (direct || req.method === "PUT")
+        await this.append(u, req, direct ? this.limits.maxBytes : MEDIA_UPLOAD_PART_BYTES);
+      if (direct || req.method === "POST") {
+        const result = await this.publish(u);
+        await this.dispose(u);
+        json(res, 200, result);
+      } else {
+        u.busy = false;
+        this.touch(u);
+        json(res, 200, { offset: u.bytes });
+      }
+    } catch (error) {
+      if (u && (owns || direct || begin)) await this.dispose(u, error);
+      if (!res.destroyed) {
+        if (!req.complete) {
+          res.setHeader("connection", "close");
+          res.once("finish", () => req.destroy());
+        }
+        json(res, error instanceof UploadError ? error.status : 500, {
+          error: error instanceof Error ? error.message : "media upload failed"
+        });
+      }
+    } finally {
+      res.off("close", disconnected);
+    }
+    return true;
+  }
+}
+function listMediaFiles(media) {
+  let entries;
+  try {
+    entries = readdirSync(media, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.isFile() && !entry.name.startsWith("."))
+      files.push({
+        src: `./media/${entry.name}`,
+        byteSize: statSync(join(media, entry.name)).size
+      });
+    else if (entry.isDirectory() && /^import-[a-zA-Z0-9]{6}$/.test(entry.name)) {
+      for (const child of readdirSync(join(media, entry.name), { withFileTypes: true })) {
+        if (child.isFile() && !child.name.startsWith("."))
+          files.push({
+            src: `./media/${entry.name}/${child.name}`,
+            byteSize: statSync(join(media, entry.name, child.name)).size
+          });
+      }
+    }
+  }
+  return files.toSorted((a, b) => a.src.localeCompare(b.src));
+}
+export {
+  MEDIA_UPLOAD_PART_BYTES,
+  MEDIA_UPLOAD_TEMP_PREFIX,
+  MediaUploads,
+  isPrivateMediaUploadPath,
+  listMediaFiles
+};

package/node_modules/@higgsfield/higgsedit/dist/proxy.mjs

@@ -0,0 +1,170 @@
+import { execFile } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { ffmpeg, requireTool } from "./chunk-EKFC4S4M.mjs";
+const run = promisify(execFile);
+const VIDEO = /\.(mp4|mov|m4v|mkv|webm)$/i;
+const SKIP = /(^|\/)(node_modules|\.git|\.higgsedit-cache|\.higgsedit|renders|dist)(\/|$)/;
+const LONG_SIDE = 1920;
+const DECODABLE = /* @__PURE__ */ new Set(["h264", "hevc", "vp9", "av1"]);
+const needsProxy = (p) => p.width * p.height > LONG_SIDE * 1088 || !DECODABLE.has(p.codec);
+const even = (n) => Math.max(2, Math.round(n / 2) * 2);
+const QUIET_MS = 400;
+const TRACKED_LIMIT = 1024;
+class Proxies {
+  constructor(dir, onReady, log = () => {
+  }) {
+    this.dir = dir;
+    this.onReady = onReady;
+    this.log = log;
+    this.root = join(dir, ".higgsedit-cache", "proxies");
+  }
+  dir;
+  onReady;
+  log;
+  root;
+  // Recent actual preview requests bound both pending work and cached no-proxy decisions.
+  candidates = /* @__PURE__ */ new Map();
+  active;
+  timer;
+  abort = new AbortController();
+  current;
+  stopped = false;
+  version(rel) {
+    try {
+      const st = statSync(join(this.dir, rel));
+      if (!st.isFile()) return void 0;
+      return { key: createHash("sha1").update(`${rel}\0${st.size}\0${st.mtimeMs}\0${st.ctimeMs}\0${st.ino}`).digest("hex").slice(0, 20), mtime: st.mtimeMs };
+    } catch {
+      return void 0;
+    }
+  }
+  /** The finished proxy for a project-relative video path, if there is one. */
+  lookup(rel) {
+    const key = this.version(rel)?.key;
+    const file = key && join(this.root, `${key}.mp4`);
+    return file && existsSync(file) ? file : void 0;
+  }
+  /** Only /preview/ demand starts work; watcher events refresh previously requested footage. */
+  consider(rel, requested = false) {
+    if (this.stopped || !VIDEO.test(rel) || SKIP.test(rel)) return;
+    const prior = this.candidates.get(rel);
+    if (!requested && !prior) return;
+    const version = this.version(rel);
+    if (!version) {
+      this.candidates.delete(rel);
+      return;
+    }
+    const now = Date.now();
+    const candidate = prior?.key === version.key ? prior : { ...version, readyAt: now + Math.min(QUIET_MS, Math.max(0, QUIET_MS - (now - version.mtime))), done: existsSync(join(this.root, `${version.key}.mp4`)) };
+    if (requested && candidate.retryAt !== void 0 && now >= candidate.retryAt) {
+      candidate.done = false;
+      candidate.retryAt = void 0;
+    }
+    if (requested) this.candidates.delete(rel);
+    this.candidates.set(rel, candidate);
+    while (this.candidates.size > TRACKED_LIMIT) {
+      for (const path of this.candidates.keys()) {
+        if (path !== this.active) {
+          this.candidates.delete(path);
+          break;
+        }
+      }
+    }
+    this.schedule();
+  }
+  schedule() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    if (this.stopped || this.active) return;
+    let next = Infinity;
+    for (const [rel, candidate] of this.candidates) {
+      if (candidate.done) continue;
+      if (candidate.readyAt > Date.now()) {
+        next = Math.min(next, candidate.readyAt);
+        continue;
+      }
+      const version = this.version(rel);
+      if (!version) {
+        this.candidates.delete(rel);
+        continue;
+      }
+      if (version.key !== candidate.key) {
+        Object.assign(candidate, version, { readyAt: Date.now() + QUIET_MS });
+        next = Math.min(next, candidate.readyAt);
+        continue;
+      }
+      this.active = rel;
+      void this.make(rel, candidate.key).then(() => {
+        if (this.candidates.get(rel)?.key === candidate.key) candidate.done = true;
+      }, (error) => {
+        if (this.stopped) return;
+        candidate.done = true;
+        candidate.retryAt = Date.now() + 5e3;
+        this.log(`proxy for ${rel} failed: ${error instanceof Error ? error.message : String(error)}`);
+      }).finally(() => {
+        this.active = void 0;
+        this.consider(rel);
+        this.schedule();
+      });
+      return;
+    }
+    if (Number.isFinite(next)) this.timer = setTimeout(() => this.schedule(), Math.max(0, next - Date.now()));
+  }
+  async make(rel, key) {
+    const file = join(this.dir, rel);
+    if (this.lookup(rel)) return;
+    const { stdout } = await run(requireTool("ffprobe"), ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height,codec_name,time_base", "-of", "json", file], { maxBuffer: 1 << 20, timeout: 3e4, signal: this.abort.signal });
+    if (this.stopped || this.version(rel)?.key !== key) return;
+    const data = JSON.parse(stdout);
+    const stream = data?.streams?.[0];
+    if (!stream || typeof stream.width !== "number" || stream.width <= 0 || typeof stream.height !== "number" || stream.height <= 0 || typeof stream.codec_name !== "string") throw new Error("invalid video stream metadata");
+    const facts = { width: stream.width, height: stream.height, codec: stream.codec_name };
+    if (!needsProxy(facts)) return;
+    const timescale = Number(String(stream.time_base).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)];
+    mkdirSync(this.root, { recursive: true });
+    const out = join(this.root, `${key}.mp4`);
+    const part = join(this.root, `${key}.${randomUUID()}.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);
+    try {
+      await new Promise((resolve, reject) => {
+        const p = ffmpeg(args);
+        this.current = p;
+        let err = "";
+        p.stderr.on("data", (d) => {
+          err = (err + d.toString()).slice(-16384);
+        });
+        p.on("error", reject);
+        p.on("close", (code) => {
+          if (this.current === p) this.current = void 0;
+          if (code === 0) resolve();
+          else reject(new Error(err.trim() || `ffmpeg exited with ${code}`));
+        });
+      });
+      if (this.stopped || this.version(rel)?.key !== key) return;
+      renameSync(part, out);
+      this.log(`proxy for ${rel} ready in ${((performance.now() - t0) / 1e3).toFixed(1)} s`);
+      this.onReady(`./${rel}`);
+    } finally {
+      rmSync(part, { force: true });
+    }
+  }
+  stop() {
+    this.stopped = true;
+    clearTimeout(this.timer);
+    this.candidates.clear();
+    this.abort.abort();
+    this.current?.kill("SIGKILL");
+  }
+}
+export {
+  Proxies,
+  needsProxy
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@higgsfield/video-editor-mcp",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Higgsfield Video Editor as a local MCP server over stdio: edits TSX video projects on this machine with the higgsedit CLI and serves the editor panel.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "higgsfield-video-editor-local",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Edit and render video projects on your Mac with Higgsfield. Arrange clips, add text, audio and motion graphics, preview your timeline in the interactive editor, and render finished videos. Generate images and videos in the editor by connecting your Higgsfield account.",
   "author": {
     "name": "Higgsfield AI, Inc."

package/plugin/plugin.json

@@ -37,5 +37,5 @@
       }
     }
   },
-  "version": "1.0.2"
+  "version": "1.0.4"
 }

package/plugin/skills/video-editing/references/local-setup.md

@@ -6,7 +6,7 @@ Requires Node.js 22.12 or later.
 
 ```sh
 dir="$HOME/.higgsfield/video-editor-mcp"
-npm install --prefix "$dir" --registry=https://registry.npmjs.org/ --ignore-scripts --no-audit --no-fund @higgsfield/video-editor-mcp@next
+npm install --prefix "$dir" --registry=https://registry.npmjs.org/ --ignore-scripts --no-audit --no-fund @higgsfield/video-editor-mcp@latest
 cli="$dir/node_modules/@higgsfield/video-editor-mcp/dist/cli.mjs"
 node "$cli" doctor
 node "$cli" install-plugin