@higgsfield/video-editor-mcp 1.0.5 → 1.0.7

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

@@ -0,0 +1,295 @@
+import { randomUUID } from "node:crypto";
+import { closeSync, constants, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const MAX_BYTES = 16 * 1024 * 1024;
+const MAX_ENTRIES = 100;
+const STALE = "edit history changed in another editor; reopen the project before editing or undoing";
+const message = (error) => error instanceof Error ? error.message : String(error);
+const missing = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const safePath = (path) => !/[\\\0]/.test(path) && path.split("/").every((part) => part !== "" && part !== "." && part !== ".." && part !== ".higgsedit-cache") && !/^[A-Za-z]:/.test(path);
+const identity = (stat) => `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+function encode(undo, redo, revision, text = (entry) => JSON.stringify(entryValue(entry))) {
+  return `{"version":1,"revision":${JSON.stringify(revision)},"undo":[${undo.map(text).join(",")}],"redo":[${redo.map(text).join(",")}]}`;
+}
+const entryValue = ({ name, files }) => ({ name, files: [...files].map(([path, texts]) => ({ path, ...texts })) });
+function decode(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return;
+  }
+  if (!record(value) || value.version !== 1 || typeof value.revision !== "string" || !Array.isArray(value.undo) || !Array.isArray(value.redo) || value.undo.length + value.redo.length > MAX_ENTRIES) return;
+  const entries = (stack) => {
+    const result = [];
+    for (const entry of stack) {
+      if (!record(entry) || typeof entry.name !== "string" || !Array.isArray(entry.files) || !entry.files.length) return;
+      const files = /* @__PURE__ */ new Map();
+      for (const file of entry.files) {
+        if (!record(file) || typeof file.path !== "string" || !safePath(file.path) || typeof file.before !== "string" || typeof file.after !== "string" || files.has(file.path)) return;
+        files.set(file.path, { before: file.before, after: file.after });
+      }
+      result.push({ name: entry.name, files });
+    }
+    return result;
+  };
+  const undo = entries(value.undo), redo = entries(value.redo);
+  return undo && redo ? { undo, redo } : void 0;
+}
+class EditHistory {
+  constructor(dir, onWrite, limits = {}) {
+    this.dir = dir;
+    this.onWrite = onWrite;
+    this.maxBytes = Math.min(MAX_BYTES, limits.maxBytes ?? MAX_BYTES);
+    this.maxEntries = Math.min(MAX_ENTRIES, limits.maxEntries ?? MAX_ENTRIES);
+    if (!Number.isSafeInteger(this.maxBytes) || this.maxBytes < 100 || !Number.isSafeInteger(this.maxEntries) || this.maxEntries < 1) throw new Error("invalid edit history limits");
+    try {
+      const saved = this.readJournal();
+      this.revision = saved.revision;
+      const parsed = saved.text === void 0 ? void 0 : decode(saved.text);
+      if (parsed) {
+        const bounded = this.bound(parsed.undo, parsed.redo);
+        this.undoStack = bounded.undo;
+        this.redoStack = bounded.redo;
+      }
+    } catch {
+    }
+  }
+  dir;
+  onWrite;
+  undoStack = [];
+  redoStack = [];
+  revision = "missing";
+  maxBytes;
+  maxEntries;
+  // Committed entries never change. Weak keys release evicted history and abandoned transactions.
+  encoded = /* @__PURE__ */ new WeakMap();
+  begin(name) {
+    if (typeof name !== "string") throw new Error("edit history name must be a string");
+    this.assertCurrent();
+    const entry = { name, files: /* @__PURE__ */ new Map() };
+    const previousWrites = /* @__PURE__ */ new Map();
+    const fileBytes = /* @__PURE__ */ new Map();
+    let entryBytes = Buffer.byteLength(encode([entry], [], randomUUID()));
+    let finished = false;
+    return {
+      onWrite: (path, text) => {
+        if (finished) throw new Error("edit history transaction already finished");
+        const prior = entry.files.get(path);
+        const current = this.readSource(path);
+        if (prior && current !== prior.after) throw new Error(`${path} changed outside the editor since ${entry.name}`);
+        const texts = { before: prior?.before ?? current, after: text };
+        const bytes = Buffer.byteLength(JSON.stringify({ path, ...texts }));
+        const nextBytes = entryBytes - (fileBytes.get(path) ?? 0) + bytes + (!prior && entry.files.size ? 1 : 0);
+        if (nextBytes > this.maxBytes) throw new Error(`edit history size limit exceeded (${this.maxBytes} bytes); split the edit or reduce the affected source files`);
+        entryBytes = nextBytes;
+        fileBytes.set(path, bytes);
+        previousWrites.set(path, current);
+        entry.files.set(path, texts);
+        this.encoded.delete(entry);
+        this.onWrite?.(path, text);
+      },
+      commit: () => {
+        if (finished) throw new Error("edit history transaction already finished");
+        if (entry.files.size) {
+          this.checkSources(entry, "after");
+          this.publish([...this.undoStack, entry], []);
+        }
+        finished = true;
+      },
+      rollback: () => {
+        if (finished) return;
+        this.restore(entry, "after", "before", previousWrites);
+        finished = true;
+      }
+    };
+  }
+  state() {
+    return {
+      canUndo: this.undoStack.length > 0,
+      canRedo: this.redoStack.length > 0,
+      undoName: this.undoStack.at(-1)?.name ?? null,
+      redoName: this.redoStack.at(-1)?.name ?? null
+    };
+  }
+  undo() {
+    return this.step(this.undoStack, this.redoStack, "after", "before");
+  }
+  redo() {
+    return this.step(this.redoStack, this.undoStack, "before", "after");
+  }
+  step(from, to, expect, write) {
+    const entry = from.at(-1);
+    if (!entry) return { ok: false, reason: `nothing to ${write === "before" ? "undo" : "redo"}` };
+    try {
+      this.assertCurrent();
+      this.checkSources(entry, expect);
+    } catch (error) {
+      return { ok: false, reason: message(error) };
+    }
+    try {
+      for (const [path, texts] of entry.files) this.write(path, texts[write]);
+      const remaining = from.slice(0, -1), moved = [...to, entry];
+      this.publish(write === "before" ? remaining : moved, write === "before" ? moved : remaining);
+    } catch (error) {
+      try {
+        this.restore(entry, write, expect);
+      } catch (rollbackError) {
+        return { ok: false, reason: `${message(error)}; rollback failed: ${message(rollbackError)}` };
+      }
+      return { ok: false, reason: message(error) };
+    }
+    return { ok: true, written: [...entry.files.keys()] };
+  }
+  checkSources(entry, expect) {
+    for (const [path, texts] of entry.files) {
+      if (this.readSource(path) !== texts[expect]) throw new Error(`${path} changed outside the editor since ${entry.name}`);
+    }
+  }
+  /** A failed write may still contain the original text. Never roll back someone else's version. */
+  restore(entry, expect, restore, previousWrites) {
+    const pending = [];
+    for (const [path, texts] of entry.files) {
+      const current = this.readSource(path);
+      if (current === texts[restore]) continue;
+      if (current !== texts[expect] && current !== previousWrites?.get(path)) throw new Error(`${path} changed outside the editor since ${entry.name}`);
+      pending.push([path, texts[restore]]);
+    }
+    for (const [path, text] of pending) this.write(path, text);
+  }
+  readSource(path) {
+    if (!safePath(path)) throw new Error("unsafe edit history source path");
+    let target = this.dir;
+    for (const part of path.split("/")) {
+      target = join(target, part);
+      try {
+        if (lstatSync(target).isSymbolicLink()) throw new Error(`${path} is a symlink; cannot restore edit history`);
+      } catch (error) {
+        if (missing(error)) throw new Error(`${path} no longer exists`, { cause: error });
+        throw error;
+      }
+    }
+    return readFileSync(target, "utf8");
+  }
+  write(path, text) {
+    const target = join(this.dir, path);
+    this.onWrite?.(path, text);
+    this.atomicWrite(target, text, lstatSync(target).mode & 511);
+  }
+  cacheDir() {
+    const cache = join(this.dir, ".higgsedit-cache");
+    try {
+      const stat = lstatSync(cache);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("unsafe edit history cache directory");
+    } catch (error) {
+      if (!missing(error)) throw error;
+    }
+    return cache;
+  }
+  readJournal() {
+    const file = join(this.cacheDir(), "history.json");
+    let fd;
+    try {
+      if (!lstatSync(file).isFile()) throw new Error("edit history journal is not a regular file");
+      fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    } catch (error) {
+      if (missing(error)) return { revision: "missing" };
+      throw new Error(`cannot read edit history: ${message(error)}`, { cause: error });
+    }
+    try {
+      const stat = fstatSync(fd, { bigint: true });
+      if (!stat.isFile()) throw new Error("edit history journal is not a regular file");
+      const revision = identity(stat);
+      if (stat.size > BigInt(this.maxBytes)) return { revision };
+      const bytes = Buffer.alloc(Number(stat.size) + 1);
+      let length = 0, count = 0;
+      do {
+        count = readSync(fd, bytes, length, bytes.length - length, null);
+        length += count;
+      } while (count && length < bytes.length);
+      if (BigInt(length) !== stat.size || identity(fstatSync(fd, { bigint: true })) !== revision) throw new Error("edit history changed while reading");
+      const data = bytes.subarray(0, length);
+      return { revision, text: data.toString("utf8") };
+    } finally {
+      closeSync(fd);
+    }
+  }
+  assertCurrent() {
+    let revision;
+    try {
+      const stat = lstatSync(join(this.cacheDir(), "history.json"), { bigint: true });
+      if (!stat.isFile()) throw new Error("edit history journal is not a regular file");
+      revision = identity(stat);
+    } catch (error) {
+      if (!missing(error)) throw error;
+      revision = "missing";
+    }
+    if (revision !== this.revision) throw new Error(STALE);
+  }
+  serialized(entry) {
+    let saved = this.encoded.get(entry);
+    if (!saved) {
+      const text = JSON.stringify(entryValue(entry));
+      saved = { text, bytes: Buffer.byteLength(text) };
+      this.encoded.set(entry, saved);
+    }
+    return saved;
+  }
+  bound(undo, redo) {
+    const revision = randomUUID();
+    const sized = (stack) => stack.map((entry) => ({ entry, bytes: this.serialized(entry).bytes }));
+    const keepUndo = sized(undo), keepRedo = sized(redo);
+    let bytes = Buffer.byteLength(encode([], [], revision)) + [...keepUndo, ...keepRedo].reduce((sum, entry) => sum + entry.bytes, 0);
+    const separators = () => Math.max(0, keepUndo.length - 1) + Math.max(0, keepRedo.length - 1);
+    while (keepUndo.length + keepRedo.length > this.maxEntries || bytes + separators() > this.maxBytes) {
+      const removed = keepUndo.length > 1 || !keepRedo.length ? keepUndo.shift() : keepRedo.shift();
+      if (!removed) throw new Error("edit history size limit exceeded");
+      bytes -= removed.bytes;
+    }
+    undo = keepUndo.map(({ entry }) => entry);
+    redo = keepRedo.map(({ entry }) => entry);
+    return { undo, redo, text: encode(undo, redo, revision, (entry) => this.serialized(entry).text) };
+  }
+  publish(undo, redo) {
+    const next = this.bound(undo, redo);
+    this.assertCurrent();
+    const cache = this.cacheDir();
+    mkdirSync(cache, { recursive: true, mode: 448 });
+    const target = join(cache, "history.json");
+    try {
+      this.revision = this.atomicWrite(target, next.text, 384);
+    } catch (error) {
+      throw new Error(`cannot save edit history: ${message(error)}`, { cause: error });
+    }
+    this.undoStack = next.undo;
+    this.redoStack = next.redo;
+  }
+  atomicWrite(target, text, mode) {
+    const tmp = `${target}.higgsedit-${process.pid}-${randomUUID()}.tmp`;
+    let published = false;
+    let fd;
+    try {
+      fd = openSync(tmp, "wx", mode);
+      writeFileSync(fd, text);
+      fsyncSync(fd);
+      renameSync(tmp, target);
+      published = true;
+      return identity(fstatSync(fd, { bigint: true }));
+    } finally {
+      try {
+        if (fd !== void 0) closeSync(fd);
+      } finally {
+        if (!published) {
+          try {
+            unlinkSync(tmp);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+}
+export {
+  EditHistory
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@higgsfield/video-editor-mcp",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "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.5",
+  "version": "1.0.7",
   "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.5"
+  "version": "1.0.7"
 }