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

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

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { createRequire as __higgseditRequire } from "node:module";
+import { fileURLToPath as __higgseditPath } from "node:url";
+const require = __higgseditRequire(import.meta.url);
+const __filename = __higgseditPath(import.meta.url);
+const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
+import {
+  BUILTIN_COMPONENTS,
+  LOOP_COMPONENTS,
+  SourceProject,
+  analyze,
+  applyEdit,
+  applyEdits,
+  attributeOf,
+  elementOf,
+  idAllocator,
+  idOf,
+  initializerText,
+  inspectVariables,
+  isComponentTag,
+  isIntrinsicTag,
+  isLiteral,
+  listSources,
+  literalText,
+  literalValue,
+  locateConst,
+  parseKey,
+  sourceFacts,
+  stampProject,
+  tagName,
+  tagsIn
+} from "./chunk-MV2JTTBQ.mjs";
+import "./chunk-F7YUKEI5.mjs";
+import "./chunk-75WO2NOF.mjs";
+export {
+  BUILTIN_COMPONENTS,
+  LOOP_COMPONENTS,
+  SourceProject,
+  analyze,
+  applyEdit,
+  applyEdits,
+  attributeOf,
+  elementOf,
+  idAllocator,
+  idOf,
+  initializerText,
+  inspectVariables,
+  isComponentTag,
+  isIntrinsicTag,
+  isLiteral,
+  listSources,
+  literalText,
+  literalValue,
+  locateConst,
+  parseKey,
+  sourceFacts,
+  stampProject,
+  tagName,
+  tagsIn
+};

package/node_modules/@higgsfield/higgsedit/dist/{chunk-3AIM3THH.mjs → chunk-VLM5EOWJ.mjs}

@@ -10,11 +10,11 @@ import {
   requireWhisper,
   runTranscribe,
   transcribe
-} from "./chunk-L6QDNSL3.mjs";
-import "./chunk-MCVD2ZQV.mjs";
-import "./chunk-WZR5PZM7.mjs";
+} from "./chunk-L5LWBA6A.mjs";
+import "./chunk-PAHMD6SU.mjs";
+import "./chunk-BV5COOQZ.mjs";
 import "./chunk-F7YUKEI5.mjs";
-import "./chunk-EKFC4S4M.mjs";
+import "./chunk-MCVD2ZQV.mjs";
 import "./chunk-75WO2NOF.mjs";
 export {
   DEFAULT_MODEL,

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

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+import { createRequire as __higgseditRequire } from "node:module";
+import { fileURLToPath as __higgseditPath } from "node:url";
+const require = __higgseditRequire(import.meta.url);
+const __filename = __higgseditPath(import.meta.url);
+const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
+import {
+  decodeFrame,
+  encodePng,
+  frameAt,
+  frameTime,
+  videoSource
+} from "./chunk-QJTILFBS.mjs";
+import {
+  ffmpeg,
+  probe
+} from "./chunk-PAHMD6SU.mjs";
+import {
+  MaskFile,
+  decodeMaskRuns
+} from "./chunk-BV5COOQZ.mjs";
+import {
+  flag,
+  flags
+} from "./chunk-MCVD2ZQV.mjs";
+
+// src/select.ts
+import { existsSync, mkdirSync, mkdtempSync, openAsBlob, renameSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+var SelectError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "SelectError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var MAX_CONCEPTS = 8;
+var MAX_CONCEPT_CHARS = 64;
+var MAX_POINTS = 16;
+var MAX_TRACK_SECONDS = 60;
+var SHORT_SIDE = 1008;
+var SELECT_TIMEOUT_MS = 12e4;
+var POLL_TIMEOUT_MS = 6e4;
+function selectBackend(env = process.env) {
+  const url = env.HIGGSEDIT_SELECT_URL || void 0;
+  if (!url) return void 0;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new SelectError(`HIGGSEDIT_SELECT_URL ${url}: not a URL`, 503, "unconfigured");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new SelectError(`HIGGSEDIT_SELECT_URL ${url}: must be http(s)`, 503, "unconfigured");
+  const token = env.HIGGSEDIT_SELECT_TOKEN || void 0;
+  return { url: url.replace(/\/+$/, ""), ...token ? { token } : {} };
+}
+function requireSelectBackend() {
+  const backend = selectBackend();
+  if (!backend) throw new SelectError("HIGGSEDIT_SELECT_URL is not set: point it at a select server (docs/select.md)", 503, "unconfigured");
+  return backend;
+}
+var bad = (message) => new SelectError(message, 400);
+function unit(v, what) {
+  if (typeof v !== "number" || !(v >= 0 && v <= 1)) throw bad(`${what} must be a number in 0..1 of the frame, not ${JSON.stringify(v)}`);
+  return v;
+}
+function points(raw, what) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (!Array.isArray(raw) || raw.length > MAX_POINTS) throw bad(`${what} must be a list of at most ${MAX_POINTS} {x, y} points`);
+  return raw.map((p, i) => {
+    if (typeof p !== "object" || p === null) throw bad(`${what}[${i}] must be {x, y}`);
+    const { x, y } = p;
+    return { x: unit(x, `${what}[${i}].x`), y: unit(y, `${what}[${i}].y`) };
+  });
+}
+var conceptsOf = (text) => text.split(",").map((c) => c.trim()).filter(Boolean);
+function parsePrompt(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw bad("prompt must be an object: {text} or {points, exclude, box}");
+  const r = raw;
+  const unknown = Object.keys(r).filter((k) => !["text", "points", "exclude", "box"].includes(k));
+  if (unknown.length) throw bad(`prompt has unknown fields: ${unknown.toSorted().join(", ")}`);
+  const include = points(r.points, "prompt.points");
+  const exclude = points(r.exclude, "prompt.exclude");
+  let box;
+  if (r.box !== void 0 && r.box !== null) {
+    if (!Array.isArray(r.box) || r.box.length !== 4) throw bad("prompt.box must be [x0, y0, x1, y1] in 0..1");
+    box = r.box.map((v) => unit(v, "prompt.box"));
+    if (!(box[2] > box[0] && box[3] > box[1])) throw bad("prompt.box must have x1 > x0 and y1 > y0");
+  }
+  if (r.text !== void 0 && r.text !== null) {
+    if (typeof r.text !== "string") throw bad("prompt.text must be a string");
+    const concepts = conceptsOf(r.text);
+    if (!concepts.length) throw bad("prompt.text is empty");
+    if (concepts.length > MAX_CONCEPTS) throw bad(`prompt.text names ${concepts.length} concepts; the limit is ${MAX_CONCEPTS}`);
+    const long = concepts.find((c) => c.length > MAX_CONCEPT_CHARS);
+    if (long) throw bad(`concept "${long.slice(0, 20)}\u2026" is over ${MAX_CONCEPT_CHARS} characters`);
+    if (include?.length || exclude?.length || box) throw bad("prompt.text selects every instance of a concept and cannot be combined with points or a box");
+    return { text: r.text };
+  }
+  if (!include?.length && !box) throw bad("prompt needs text, a point on the object or a box around it");
+  return { ...include ? { points: include } : {}, ...exclude?.length ? { exclude } : {}, ...box ? { box } : {} };
+}
+async function failure(r) {
+  let detail = r.statusText;
+  try {
+    const body = await r.json();
+    if (typeof body.error === "string") detail = body.error;
+  } catch {
+  }
+  return new SelectError(`select server: ${r.status} ${detail}`, r.status);
+}
+async function call(backend, path, init = {}, timeoutMs) {
+  const base = `${backend.url}/`;
+  const url = new URL(path, base);
+  const headers = new Headers(init.headers);
+  if (backend.token && url.origin === new URL(base).origin) headers.set("authorization", `Bearer ${backend.token}`);
+  const signals = [init.signal, timeoutMs ? AbortSignal.timeout(timeoutMs) : void 0].filter((s) => Boolean(s));
+  let r;
+  try {
+    r = await fetch(url, { ...init, headers, ...signals.length ? { signal: AbortSignal.any(signals) } : {} });
+  } catch (error) {
+    if (error instanceof Error && error.name === "TimeoutError") throw new SelectError(`select server: no answer from ${url.href} within ${Math.round(timeoutMs / 1e3)} s`, 504);
+    if (error instanceof Error && error.name === "AbortError") throw error;
+    throw new SelectError(`select server: ${url.href} is unreachable: ${error instanceof Error ? error.cause instanceof Error ? error.cause.message : error.message : String(error)}`, 502);
+  }
+  if (!r.ok) throw await failure(r);
+  return r;
+}
+async function selectStatus(env = process.env) {
+  let backend;
+  try {
+    backend = selectBackend(env);
+  } catch (error) {
+    return { url: env.HIGGSEDIT_SELECT_URL ?? "", answers: false, detail: error.message };
+  }
+  if (!backend) return { url: null };
+  try {
+    const info = await (await call(backend, "v1", {}, 1e4)).json();
+    return { url: backend.url, answers: true, detail: `${String(info.model)}, contract ${String(info.contract)}` };
+  } catch (error) {
+    return { url: backend.url, answers: false, detail: error.message.replace(/^select server: /, "") };
+  }
+}
+var round = (v, places = 6) => Math.round(v * 10 ** places) / 10 ** places;
+function sentSize([w, h]) {
+  const k = Math.min(w, h) >= SHORT_SIDE ? SHORT_SIDE / Math.min(w, h) : 1;
+  return [Math.round(w * k), Math.round(h * k)];
+}
+async function source(media) {
+  const file = resolve(media);
+  if (!existsSync(file)) throw new SelectError(`${media}: no such file`, 404);
+  const [src, info] = await Promise.all([videoSource(file), probe(file)]);
+  return { file, src, display: info.display };
+}
+function checkTime(src, t, what) {
+  if (!(t >= 0 && t <= src.duration)) throw bad(`${what} ${t} s is outside ${src.file} (0..${round(src.duration, 3)} s)`);
+}
+async function output(proc, what, input) {
+  const out = [];
+  let stderr = "";
+  proc.stdout.on("data", (d) => out.push(d));
+  proc.stderr.on("data", (d) => stderr += String(d));
+  if (input) proc.stdin.end(input);
+  const code = await new Promise((done) => proc.on("close", done));
+  if (code !== 0) throw new Error(`ffmpeg could not ${what}: ${stderr.trim() || `exit ${String(code)}`}`);
+  return Buffer.concat(out);
+}
+async function grabFrame(media, time) {
+  const { src, display } = await source(media);
+  checkTime(src, time, "time");
+  const index = frameAt(src, time);
+  const [width, height] = sentSize(display);
+  const rgba = await decodeFrame(src, index, width, height);
+  const jpeg = await output(ffmpeg(["-f", "rawvideo", "-pix_fmt", "rgba", "-s", `${width}x${height}`, "-i", "-", "-frames:v", "1", "-q:v", "2", "-f", "mjpeg", "-"], "pipe"), "encode the frame as JPEG", rgba);
+  return { jpeg, rgba, width, height, time: round(frameTime(src, index)) };
+}
+async function selectFrame(frame, prompt, backend = requireSelectBackend()) {
+  const r = await call(backend, "v1/select", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ image: frame.jpeg.toString("base64"), prompt }) }, SELECT_TIMEOUT_MS);
+  const body = await r.json();
+  if (!Array.isArray(body.objects) || typeof body.width !== "number" || typeof body.height !== "number") throw new SelectError("select server: the answer is not a selection", 502);
+  return { width: body.width, height: body.height, objects: body.objects, time: frame.time };
+}
+async function select(media, time, prompt) {
+  const backend = requireSelectBackend();
+  return selectFrame(await grabFrame(media, time), prompt, backend);
+}
+async function pickObject(media, time, prompt, index) {
+  if (!("text" in prompt)) {
+    if (index !== 0) throw bad(`a click prompt selects one object, so the pick is 0, not ${index}`);
+    return { prompt };
+  }
+  const selection = await select(media, time, prompt);
+  const object = selection.objects[index];
+  if (!object) throw bad(`nothing to pick as object ${index}: "${prompt.text}" found ${selection.objects.length} at ${selection.time} s`);
+  return { prompt: { text: object.label }, ...object.box ? { pick: object.box } : {} };
+}
+async function encodeSpan(src, first, last, size, out) {
+  const half = 0.5 / src.fps;
+  const from = src.timestamps[first] - half;
+  const to = last < src.timestamps.length ? `*lt(t\\,${(src.timestamps[last] - half).toFixed(6)})` : "";
+  const seek = Math.max(0, src.timestamps[first] - src.origin - 2);
+  await output(
+    ffmpeg([
+      "-copyts",
+      "-ss",
+      seek.toFixed(6),
+      "-noaccurate_seek",
+      "-i",
+      src.file,
+      "-map",
+      "0:v:0",
+      "-an",
+      "-sn",
+      "-dn",
+      "-vf",
+      `select=gte(t\\,${from.toFixed(6)})${to},setpts=PTS-STARTPTS,scale=${size[0]}:${size[1]}:flags=area,format=yuv420p`,
+      "-fps_mode",
+      "passthrough",
+      "-c:v",
+      "libx264",
+      "-preset",
+      "veryfast",
+      "-crf",
+      "20",
+      "-movflags",
+      "+faststart",
+      "-f",
+      "mp4",
+      "-y",
+      out
+    ]),
+    `cut ${src.file} for upload`
+  );
+}
+function withHeader(bytes, header) {
+  const length = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(4, true);
+  const json = new TextEncoder().encode(JSON.stringify({ version: 1, ...header }));
+  const out = new Uint8Array(8 + json.length + bytes.length - 8 - length);
+  out.set(bytes.subarray(0, 4), 0);
+  new DataView(out.buffer).setUint32(4, json.length, true);
+  out.set(json, 8);
+  out.set(bytes.subarray(8 + length), 8 + json.length);
+  return out;
+}
+var sleep = (ms, signal) => new Promise((done, fail) => {
+  const timer = setTimeout(done, ms);
+  signal?.addEventListener("abort", () => {
+    clearTimeout(timer);
+    fail(signal.reason);
+  }, { once: true });
+});
+async function track(media, options) {
+  const backend = requireSelectBackend();
+  if (!options.out.endsWith(".mask")) throw bad(`${options.out}: a mask file ends in .mask`);
+  if ("text" in options.prompt && conceptsOf(options.prompt.text).length > 1) throw bad("a track follows one concept; send the picked object's label as prompt.text");
+  const { file, src, display } = await source(media);
+  const n = src.timestamps.length;
+  if (n < 2) throw bad(`${media} is a still image; only a video can be tracked`);
+  checkTime(src, options.time, "time");
+  const start = options.start ?? Math.max(0, options.time - 2.5);
+  const end = Math.min(options.end ?? options.time + 2.5, src.duration);
+  checkTime(src, start, "start");
+  if (!(end > start)) throw bad(`end ${end} s must come after start ${start} s`);
+  if (end - start > MAX_TRACK_SECONDS) throw bad(`a track spans at most ${MAX_TRACK_SECONDS} s, not ${round(end - start, 3)} s`);
+  const first = frameAt(src, start);
+  const last = end >= src.duration - 1e-6 ? n : frameAt(src, end);
+  const seed = frameAt(src, options.time);
+  if (!(seed >= first && seed < last)) throw bad(`the prompted frame (${options.time} s) must lie in the tracked span ${start}..${end} s`);
+  const frames = last - first;
+  const [w, h] = sentSize(display);
+  const size = [Math.round(w / 2) * 2, Math.round(h / 2) * 2];
+  const work = mkdtempSync(join(tmpdir(), "higgsedit-select-"));
+  let id;
+  try {
+    const video = join(work, "span.mp4");
+    await encodeSpan(src, first, last, size, video);
+    const sent = (await probe(video)).timestamps.length;
+    if (sent !== frames) throw new Error(`the span of ${media} came out as ${sent} frames, not ${frames}`);
+    const form = new FormData();
+    form.set("video", await openAsBlob(video, { type: "video/mp4" }), "span.mp4");
+    form.set("prompt", JSON.stringify(options.prompt));
+    form.set("at", String(round(src.timestamps[seed] - src.timestamps[first])));
+    if (options.pick) form.set("pick", JSON.stringify(options.pick));
+    const posted = await (await call(backend, "v1/tracks", { method: "POST", body: form, ...options.signal ? { signal: options.signal } : {} })).json();
+    if (typeof posted.id !== "string" || !posted.id) throw new SelectError("select server: the track was accepted without an id", 502);
+    id = posted.id;
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+  const deadline = Date.now() + 2 * 36e5;
+  let job;
+  for (; ; ) {
+    await sleep(1e3, options.signal);
+    job = await (await call(backend, `v1/tracks/${encodeURIComponent(id)}`, options.signal ? { signal: options.signal } : {}, POLL_TIMEOUT_MS)).json();
+    if (job.progress) options.onProgress?.(job.progress.done, job.progress.total);
+    if (job.status === "succeeded") break;
+    if (job.status === "failed") throw new SelectError(`select track ${id} failed: ${job.error ?? "no reason given"}`, 502);
+    if (job.status !== "queued" && job.status !== "running") throw new SelectError(`select track ${id}: unknown status "${String(job.status)}"`, 502);
+    if (Date.now() > deadline) throw new SelectError(`select track ${id}: still ${job.status} after 2 h`, 504);
+  }
+  if (!job.mask_url) throw new SelectError(`select track ${id} succeeded without a mask_url`, 502);
+  const bytes = new Uint8Array(await (await call(backend, job.mask_url, options.signal ? { signal: options.signal } : {}, POLL_TIMEOUT_MS)).arrayBuffer());
+  const mask = MaskFile.parse(bytes).header;
+  if (mask.frames !== frames) throw new SelectError(`select track ${id}: the mask has ${mask.frames} frames for ${frames} sent`, 502);
+  const startTime = round(frameTime(src, first));
+  const recipe = { media: file, at: round(frameTime(src, seed)), prompt: options.prompt, ...options.pick ? { pick: options.pick } : {}, span: [round(start, 3), round(end, 3)], server: backend.url, job: id };
+  const { version: _version, frames: _frames, ...rest } = mask;
+  const out = resolve(options.out);
+  mkdirSync(dirname(out), { recursive: true });
+  const part = `${out}.${process.pid}.part`;
+  writeFileSync(part, withHeader(bytes, { ...rest, source: display, frameRate: src.fps, start: startTime, frames, recipe }));
+  renameSync(part, out);
+  return { path: out, job: id, frames, frameRate: src.fps, start: startTime, end: round(startTime + frames / src.fps, 3), grid: mask.grid, source: display };
+}
+function cellsOf(mask) {
+  const out = new Uint8Array(mask.size[0] * mask.size[1]);
+  decodeMaskRuns(Buffer.from(mask.rle, "base64"), out);
+  return out;
+}
+var TINT = [209, 254, 23];
+function overlay(frame, selection) {
+  const rgba = new Uint8Array(frame.rgba);
+  for (const object of selection.objects) {
+    const cells = cellsOf(object.mask);
+    for (let i = 0; i < cells.length; i++) {
+      if (!cells[i]) continue;
+      for (let c = 0; c < 3; c++) rgba[i * 4 + c] = Math.round((rgba[i * 4 + c] + TINT[c]) / 2);
+    }
+  }
+  return encodePng(rgba, frame.width, frame.height);
+}
+function point(value, what) {
+  const [x, y, extra] = value.split(",").map(Number);
+  if (x === void 0 || y === void 0 || extra !== void 0 || Number.isNaN(x) || Number.isNaN(y)) throw bad(`${what} "${value}" must be x,y`);
+  return { x, y };
+}
+var SELECT_USAGE = `usage: higgsedit select <media> --at t (--text "a, b" | --point x,y [--exclude x,y] [--box x0,y0,x1,y1]) [--json] [--overlay sel.png] [--pick n --start t --end t -o out.mask]`;
+async function runSelect(args, print) {
+  const media = args.positional[0];
+  if (!media) throw new Error(SELECT_USAGE);
+  const box = flag(args, "box", "b")?.split(",").map(Number);
+  if (box && (box.length !== 4 || box.some(Number.isNaN))) throw bad("--box must be x0,y0,x1,y1");
+  const include = flags(args, "point", "p").map((v) => point(v, "--point"));
+  const exclude = flags(args, "exclude", "x").map((v) => point(v, "--exclude"));
+  const text = flag(args, "text");
+  const prompt = parsePrompt({ ...text !== void 0 ? { text } : {}, ...include.length ? { points: include } : {}, ...exclude.length ? { exclude } : {}, ...box ? { box } : {} });
+  requireSelectBackend();
+  const { mediaSeconds } = await import("./chunk-KIWGVAPJ.mjs");
+  const fps = await mediaSeconds.fps(media);
+  const time = mediaSeconds.parse(flag(args, "at", "t"), fps, "--at") ?? 0;
+  const out = flag(args, "o", "out");
+  if (out) {
+    const index = Number(flag(args, "pick") ?? 0);
+    if (!Number.isInteger(index) || index < 0) throw bad(`--pick must be an object's index (0, 1, \u2026)`);
+    const start = mediaSeconds.parse(flag(args, "start", "s"), fps, "--start");
+    const end = mediaSeconds.parse(flag(args, "end", "e"), fps, "--end");
+    const picked = await pickObject(media, time, prompt, index);
+    const r = await track(media, {
+      time,
+      ...picked,
+      ...start !== void 0 ? { start } : {},
+      ...end !== void 0 ? { end } : {},
+      out,
+      onProgress: (done, total) => process.stderr.write(`tracking ${done}/${total}
+`)
+    });
+    print(r, () => [`wrote ${r.path}`, `  ${r.frames} frames @ ${round(r.frameRate, 3)} fps, ${r.start}..${r.end} s, job ${r.job}`, `  use it as mask={{ src: "<path to it in the project>" }} on the clip`].join("\n"));
+    return 0;
+  }
+  const frame = await grabFrame(media, time);
+  const selection = await selectFrame(frame, prompt);
+  const overlayPath = flag(args, "overlay");
+  if (overlayPath) writeFileSync(overlayPath, overlay(frame, selection));
+  const pad = Math.max(0, ...selection.objects.map((o) => o.label.length));
+  print(
+    selection,
+    () => [
+      `${media} at ${selection.time} s (${selection.width}x${selection.height}): ${selection.objects.length} object${selection.objects.length === 1 ? "" : "s"}`,
+      ...selection.objects.map((o) => `  ${o.id}  ${o.label.padEnd(pad)}  ${o.score.toFixed(2)}  box ${o.box ? o.box.join(",") : "none"}  area ${o.area}`),
+      ...overlayPath ? [`  overlay ${overlayPath}`] : []
+    ].join("\n")
+  );
+  return 0;
+}
+
+export {
+  SelectError,
+  selectBackend,
+  requireSelectBackend,
+  parsePrompt,
+  selectStatus,
+  grabFrame,
+  selectFrame,
+  select,
+  pickObject,
+  track,
+  SELECT_USAGE,
+  runSelect
+};