@erdemtuna/doc-review 0.7.0

package/src/serialize.js

@@ -0,0 +1,46 @@
+/**
+ * Document serialization, shared by the in-page SDK and Node tests.
+ *
+ * Everything doc-review adds to a live page — the overlay, highlight marks, the
+ * injected style/script, contenteditable — must vanish on the way back to disk,
+ * so the saved file renders exactly as it does standalone.
+ */
+
+export const UI_ATTR = "data-eh-ui";
+export const MARK_ATTR = "data-eh-mark";
+
+/** Keep a hydrated app editable even if its framework removes the attribute. */
+export function keepBodyEditable(body) {
+  const enforce = () => {
+    if (body.getAttribute("contenteditable") !== "true") {
+      body.setAttribute("contenteditable", "true");
+    }
+  };
+  enforce();
+  const Observer = body.ownerDocument.defaultView.MutationObserver;
+  const observer = new Observer(enforce);
+  observer.observe(body, { attributes: true, attributeFilter: ["contenteditable"] });
+  return observer;
+}
+
+/** Serialize a document to the HTML that should live on disk. */
+export function serializeDocument(doc) {
+  const clone = doc.documentElement.cloneNode(true);
+  clone.querySelectorAll(`[${UI_ATTR}]`).forEach((n) => n.remove());
+  clone.querySelectorAll("script[data-eh-sdk], style[data-eh-sdk]").forEach((n) => n.remove());
+  clone.querySelectorAll(`mark[${MARK_ATTR}]`).forEach((mark) => {
+    const parent = mark.parentNode;
+    if (!parent) return;
+    while (mark.firstChild) parent.insertBefore(mark.firstChild, mark);
+    parent.removeChild(mark);
+  });
+  clone.querySelectorAll("[data-eh-el]").forEach((n) => n.removeAttribute("data-eh-el"));
+  const body = clone.querySelector("body");
+  if (body) {
+    body.removeAttribute("contenteditable");
+    body.removeAttribute("spellcheck");
+  }
+  clone.normalize();
+  const doctype = doc.doctype ? `<!DOCTYPE ${doc.doctype.name}>\n` : "";
+  return `${doctype}${clone.outerHTML}\n`;
+}

package/src/server-entry.js

@@ -0,0 +1,26 @@
+import { start } from "./server.js";
+
+const port = Number(process.env.DOC_REVIEW_PORT || 0);
+let review;
+try {
+  review = await start(port);
+} catch (err) {
+  if (err.code !== "SERVER_LOCKED") {
+    console.error(`doc-review server could not start: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+// The detached server exits on its own once idle (see IDLE_SHUTDOWN_MS).
+async function shutdown() {
+  if (!review) return;
+  try {
+    await review.dispose();
+  } catch (err) {
+    console.error(`doc-review server shutdown failed: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+process.once("SIGTERM", shutdown);
+process.once("SIGINT", shutdown);

package/src/server-lock.js

@@ -0,0 +1,101 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { ensureStateDir, serverLockPath, serverPath } from "./paths.js";
+
+const sameOwner = (left, right) =>
+  !!left &&
+  !!right &&
+  Number(left.pid) === Number(right.pid) &&
+  String(left.instance_id || "") === String(right.instance_id || "");
+
+export function readServerLock() {
+  try {
+    return JSON.parse(fs.readFileSync(serverLockPath(), "utf8"));
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+export function isProcessAlive(pid) {
+  if (!Number.isInteger(Number(pid)) || Number(pid) <= 0) return false;
+  try {
+    process.kill(Number(pid), 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    if (err.code === "ESRCH") return false;
+    throw err;
+  }
+}
+
+export function acquireServerLock({ pid = process.pid, instanceId = crypto.randomBytes(16).toString("hex") } = {}) {
+  ensureStateDir();
+  const owner = { pid, instance_id: instanceId };
+  const lockFile = serverLockPath();
+
+  for (;;) {
+    try {
+      fs.writeFileSync(lockFile, JSON.stringify(owner), { flag: "wx", mode: 0o600 });
+      return owner;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+
+    const existing = readServerLock();
+    if (!existing || !existing.instance_id || !Number.isInteger(Number(existing.pid))) {
+      const invalid = new Error("The doc-review server lock is malformed and cannot be reclaimed safely.");
+      invalid.code = "SERVER_LOCK_INVALID";
+      throw invalid;
+    }
+    if (isProcessAlive(Number(existing.pid))) {
+      const locked = new Error(`Doc Review state is already owned by server PID ${existing.pid}.`);
+      locked.code = "SERVER_LOCKED";
+      locked.owner = existing;
+      throw locked;
+    }
+
+    const quarantine = `${lockFile}.${existing.instance_id}.${crypto.randomBytes(6).toString("hex")}.stale`;
+    try {
+      fs.renameSync(lockFile, quarantine);
+    } catch (err) {
+      if (err.code === "ENOENT") continue;
+      throw err;
+    }
+    const moved = JSON.parse(fs.readFileSync(quarantine, "utf8"));
+    if (!sameOwner(moved, existing)) {
+      throw new Error("The doc-review server lock changed while reclaiming it.");
+    }
+    fs.unlinkSync(quarantine);
+  }
+}
+
+export function releaseServerLock(owner) {
+  const existing = readServerLock();
+  if (!sameOwner(existing, owner)) return false;
+  try {
+    fs.unlinkSync(serverLockPath());
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+
+export function removeOwnedServerRecord(owner) {
+  let record;
+  try {
+    record = JSON.parse(fs.readFileSync(serverPath(), "utf8"));
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+  if (!sameOwner(record, owner)) return false;
+  try {
+    fs.unlinkSync(serverPath());
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+}