@higgsfield/video-editor-mcp 1.0.7 → 1.1.1-dev.0

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

@@ -1,381 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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
-};