viteboard 0.1.8 → 0.2.0

package/bin/content-api-plugin.mjs

@@ -1,9 +1,11 @@
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
+import os from "node:os";
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { renderPdfFromHtml as renderPdfFromHtmlPortable, sanitizePdfFileName as sanitizePdfFileNamePortable } from "./pdf-export.mjs";
 
 const WORKSPACE_DIR = ".workspace";
 const WORKSPACE_FILE = "workspace.json";
@@ -53,6 +55,13 @@ export function createContentApiPlugin() {
     res.end(body);
   }
 
+  function sendBinary(res, status, body, type, fileName) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", type);
+    if (fileName) res.setHeader("Content-Disposition", `attachment; filename="${String(fileName).replace(/[\r\n\"]/g, "-")}"`);
+    res.end(body);
+  }
+
   function sendSse(res, event, body) {
     res.write(`event: ${event}\n`);
     res.write(`data: ${JSON.stringify(body)}\n\n`);
@@ -105,6 +114,133 @@ export function createContentApiPlugin() {
   setInterval(pruneEphemeral, 10000).unref?.();
 
   function revisionForText(content) { return createHash("sha1").update(content).digest("hex"); }
+  let chromiumBinaryPromise = null;
+  async function resolveChromiumBinary() {
+    if (chromiumBinaryPromise) return chromiumBinaryPromise;
+    chromiumBinaryPromise = (async () => {
+      for (const candidate of ["chromium-browser", "chromium", "google-chrome", "google-chrome-stable"]) {
+        try {
+          await execFileAsync("which", [candidate]);
+          return candidate;
+        } catch {
+          /* continue */
+        }
+      }
+      throw new Error("No Chromium-compatible browser is available for PDF export.");
+    })();
+    return chromiumBinaryPromise;
+  }
+  function sanitizePdfFileName(input) {
+    const cleaned = String(input ?? "").trim().replace(/[\\/:*?"<>|]+/g, "-").replace(/\s+/g, " ").slice(0, 120) || "export";
+    return cleaned.toLowerCase().endsWith(".pdf") ? cleaned : `${cleaned}.pdf`;
+  }
+  function mmToInches(mm) {
+    return Number(mm ?? 0) / 25.4;
+  }
+  async function openCdpPage(port) {
+    const res = await fetch(`http://127.0.0.1:${port}/json/new?about:blank`, { method: "PUT" });
+    const target = await res.json();
+    if (!target.webSocketDebuggerUrl) throw new Error("Could not open Chromium page target for PDF export.");
+    return target.webSocketDebuggerUrl;
+  }
+  async function printPdfViaCdp(wsUrl, url, pdf) {
+    const ws = new WebSocket(wsUrl);
+    let nextId = 0;
+    const pending = new Map();
+    let loadResolve = null;
+    const loaded = new Promise((resolve) => { loadResolve = resolve; });
+    ws.onmessage = (event) => {
+      const message = JSON.parse(String(event.data));
+      if (message.method === "Page.loadEventFired") {
+        if (loadResolve) loadResolve();
+        loadResolve = null;
+        return;
+      }
+      if (!message.id) return;
+      const entry = pending.get(message.id);
+      if (!entry) return;
+      pending.delete(message.id);
+      if (message.error) entry.reject(new Error(message.error.message || "CDP error"));
+      else entry.resolve(message.result);
+    };
+    const opened = new Promise((resolve, reject) => {
+      ws.onopen = resolve;
+      ws.onerror = () => reject(new Error("Could not connect to Chromium PDF export session."));
+    });
+    const send = (method, params = {}) => new Promise((resolve, reject) => {
+      const id = ++nextId;
+      pending.set(id, { resolve, reject });
+      ws.send(JSON.stringify({ id, method, params }));
+    });
+    await opened;
+    try {
+      await send("Page.enable");
+      await send("Runtime.enable");
+      await send("Page.navigate", { url });
+      await loaded;
+      await send("Runtime.evaluate", {
+        expression: "document.fonts ? document.fonts.ready.then(() => true) : true",
+        awaitPromise: true,
+        returnByValue: true,
+      });
+      const result = await send("Page.printToPDF", {
+        printBackground: true,
+        preferCSSPageSize: true,
+        displayHeaderFooter: Boolean(pdf.displayHeaderFooter),
+        headerTemplate: pdf.headerTemplate || "<div></div>",
+        footerTemplate: pdf.footerTemplate || "<div></div>",
+        marginTop: mmToInches(pdf.marginTopMm ?? 12),
+        marginBottom: mmToInches(pdf.marginBottomMm ?? 12),
+        marginLeft: mmToInches(pdf.marginLeftMm ?? 12),
+        marginRight: mmToInches(pdf.marginRightMm ?? 12),
+      });
+      return Buffer.from(result.data, "base64");
+    } finally {
+      try { ws.close(); } catch { /* ignore */ }
+    }
+  }
+  async function renderPdfFromHtml(html, fileName, pdf = {}) {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "viteboard-pdf-"));
+    const htmlPath = path.join(tmpDir, "publication.html");
+    const profileDir = path.join(tmpDir, "profile");
+    const browser = await resolveChromiumBinary();
+    let browserProcess = null;
+    try {
+      await fs.writeFile(htmlPath, html, "utf-8");
+      await fs.mkdir(profileDir, { recursive: true });
+      browserProcess = execFile(browser, [
+        "--headless",
+        "--disable-gpu",
+        "--no-sandbox",
+        `--user-data-dir=${profileDir}`,
+        "--remote-debugging-port=0",
+        "about:blank",
+      ], { windowsHide: true });
+      const activePortPath = path.join(profileDir, "DevToolsActivePort");
+      for (let attempt = 0; attempt < 100; attempt += 1) {
+        try {
+          const raw = await fs.readFile(activePortPath, "utf-8");
+          const port = raw.split(/\r?\n/)[0]?.trim();
+          if (!port) throw new Error("Chromium debugging port missing.");
+          const wsUrl = await openCdpPage(port);
+          return await printPdfViaCdp(wsUrl, pathToFileURL(htmlPath).href, pdf);
+        } catch {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+      }
+      throw new Error("Timed out starting Chromium PDF export session.");
+    } finally {
+      if (browserProcess) {
+        const exited = new Promise((resolve) => {
+          browserProcess?.once("exit", resolve);
+          browserProcess?.once("close", resolve);
+        });
+        try { browserProcess.kill(); } catch { /* ignore */ }
+        await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, 500))]);
+      }
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  }
   function hashPath(value) {
     let hash = 2166136261;
     for (let i = 0; i < value.length; i++) {
@@ -673,6 +809,12 @@ export function createContentApiPlugin() {
         if (removed > 0) broadcast("asset-changed", { rootId: resolved.root.id, action: "cleanup", removed, actorId: actor?.actorId ?? null });
         return send(res, 200, { ok: true, removed });
       }
+      if (route === "/__api/export/pdf" && method === "POST") {
+        const { html, fileName, pdf } = JSON.parse(await readBody(req));
+        if (typeof html !== "string" || !html.trim()) return send(res, 400, { error: "Missing HTML payload" });
+        const pdfBuffer = await renderPdfFromHtmlPortable(html, String(fileName ?? "export.pdf"), typeof pdf === "object" && pdf ? pdf : {});
+        return sendBinary(res, 200, pdfBuffer, "application/pdf", sanitizePdfFileNamePortable(String(fileName ?? "export.pdf")));
+      }
       if (route === "/__api/workspace-file" && method === "GET") {
         await ensureWorkspaceDir();
         const manifest = await loadManifest();

package/bin/pdf-export.mjs

@@ -0,0 +1,337 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import http from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { pathToFileURL } from "node:url";
+
+const execFileAsync = promisify(execFile);
+const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
+let browserBinaryPromise = null;
+
+export async function renderPdfFromHtml(html, fileName, pdf = {}) {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "viteboard-pdf-"));
+  const htmlPath = path.join(tmpDir, "publication.html");
+  const profileDir = path.join(tmpDir, "profile");
+  const browser = await resolveBrowserBinary();
+  let browserProcess = null;
+  try {
+    await fs.writeFile(htmlPath, html, "utf-8");
+    await fs.mkdir(profileDir, { recursive: true });
+    browserProcess = execFile(browser, [
+      "--headless",
+      "--disable-gpu",
+      "--no-sandbox",
+      `--user-data-dir=${profileDir}`,
+      "--remote-debugging-port=0",
+      "about:blank",
+    ], { windowsHide: true });
+
+    const activePortPath = path.join(profileDir, "DevToolsActivePort");
+    const port = await waitForDevToolsPort(activePortPath);
+    const wsUrl = await openCdpPage(port);
+    return await printPdfViaCdp(wsUrl, pathToFileURL(htmlPath).href, {
+      displayHeaderFooter: Boolean(pdf.displayHeaderFooter),
+      headerTemplate: pdf.headerTemplate,
+      footerTemplate: pdf.footerTemplate,
+      marginTopMm: pdf.marginTopMm,
+      marginBottomMm: pdf.marginBottomMm,
+      marginLeftMm: pdf.marginLeftMm,
+      marginRightMm: pdf.marginRightMm,
+    });
+  } finally {
+    if (browserProcess) {
+      const exited = new Promise((resolve) => {
+        browserProcess.once("exit", resolve);
+        browserProcess.once("close", resolve);
+      });
+      try { browserProcess.kill(); } catch { /* ignore */ }
+      await Promise.race([exited, delay(500)]);
+    }
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+
+export function sanitizePdfFileName(input) {
+  const cleaned = String(input ?? "").trim().replace(/[\\/:*?"<>|]+/g, "-").replace(/\s+/g, " ").slice(0, 120) || "export";
+  return cleaned.toLowerCase().endsWith(".pdf") ? cleaned : `${cleaned}.pdf`;
+}
+
+async function resolveBrowserBinary() {
+  if (browserBinaryPromise) return browserBinaryPromise;
+  browserBinaryPromise = (async () => {
+    const override = process.env.VITEBOARD_PDF_BROWSER || process.env.VITEBOARD_BROWSER || process.env.BROWSER || "";
+    if (override && await fileExists(override)) return override;
+
+    const commandCandidates = process.platform === "win32"
+      ? ["msedge.exe", "chrome.exe", "chromium.exe", "brave.exe"]
+      : ["microsoft-edge", "microsoft-edge-stable", "google-chrome", "google-chrome-stable", "chromium-browser", "chromium", "brave-browser"];
+    const lookupCommand = process.platform === "win32" ? "where" : "which";
+    for (const candidate of commandCandidates) {
+      try {
+        const { stdout } = await execFileAsync(lookupCommand, [candidate]);
+        const first = stdout.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+        if (first) return first;
+      } catch {
+        /* try next */
+      }
+    }
+
+    for (const candidate of absoluteBrowserCandidates()) {
+      if (await fileExists(candidate)) return candidate;
+    }
+
+    throw new Error("No supported Chromium-based browser was found for PDF export. Install Chrome, Edge, Chromium, or Brave, or set VITEBOARD_PDF_BROWSER.");
+  })();
+  return browserBinaryPromise;
+}
+
+function absoluteBrowserCandidates() {
+  if (process.platform === "darwin") {
+    return [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+      "/Applications/Chromium.app/Contents/MacOS/Chromium",
+      "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+      path.join(os.homedir(), "Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
+      path.join(os.homedir(), "Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"),
+    ];
+  }
+  if (process.platform === "win32") {
+    const roots = [process.env.PROGRAMFILES, process.env["PROGRAMFILES(X86)"], process.env.LOCALAPPDATA].filter(Boolean);
+    const suffixes = [
+      path.join("Google", "Chrome", "Application", "chrome.exe"),
+      path.join("Microsoft", "Edge", "Application", "msedge.exe"),
+      path.join("Chromium", "Application", "chrome.exe"),
+      path.join("BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+    ];
+    return roots.flatMap((root) => suffixes.map((suffix) => path.join(root, suffix)));
+  }
+  return [
+    "/usr/bin/chromium-browser",
+    "/usr/bin/chromium",
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/microsoft-edge",
+    "/snap/bin/chromium",
+  ];
+}
+
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForDevToolsPort(activePortPath) {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    try {
+      const raw = await fs.readFile(activePortPath, "utf-8");
+      const port = raw.split(/\r?\n/)[0]?.trim();
+      if (port) return port;
+    } catch {
+      /* wait */
+    }
+    await delay(100);
+  }
+  throw new Error("Timed out starting Chromium PDF export session.");
+}
+
+async function openCdpPage(port) {
+  const response = await fetch(`http://127.0.0.1:${port}/json/new?about:blank`, { method: "PUT" });
+  const target = await response.json();
+  if (!target.webSocketDebuggerUrl) throw new Error("Could not open Chromium page target for PDF export.");
+  return target.webSocketDebuggerUrl;
+}
+
+async function printPdfViaCdp(wsUrl, url, pdf) {
+  const ws = await connectWebSocket(wsUrl);
+  let nextId = 0;
+  const pending = new Map();
+  let loadResolve = null;
+  const loaded = new Promise((resolve) => { loadResolve = resolve; });
+
+  ws.onMessage = (text) => {
+    const message = JSON.parse(text);
+    if (message.method === "Page.loadEventFired") {
+      if (loadResolve) loadResolve();
+      loadResolve = null;
+      return;
+    }
+    if (!message.id) return;
+    const entry = pending.get(message.id);
+    if (!entry) return;
+    pending.delete(message.id);
+    if (message.error) entry.reject(new Error(message.error.message || "CDP error"));
+    else entry.resolve(message.result);
+  };
+
+  const send = (method, params = {}) => new Promise((resolve, reject) => {
+    const id = ++nextId;
+    pending.set(id, { resolve, reject });
+    ws.send(JSON.stringify({ id, method, params }));
+  });
+
+  try {
+    await send("Page.enable");
+    await send("Runtime.enable");
+    await send("Page.navigate", { url });
+    await loaded;
+    await send("Runtime.evaluate", {
+      expression: "document.fonts ? document.fonts.ready.then(() => true) : true",
+      awaitPromise: true,
+      returnByValue: true,
+    });
+    const result = await send("Page.printToPDF", {
+      printBackground: true,
+      preferCSSPageSize: true,
+      displayHeaderFooter: Boolean(pdf.displayHeaderFooter),
+      headerTemplate: pdf.headerTemplate || "<div></div>",
+      footerTemplate: pdf.footerTemplate || "<div></div>",
+      marginTop: mmToInches(pdf.marginTopMm ?? 12),
+      marginBottom: mmToInches(pdf.marginBottomMm ?? 12),
+      marginLeft: mmToInches(pdf.marginLeftMm ?? 12),
+      marginRight: mmToInches(pdf.marginRightMm ?? 12),
+    });
+    return Buffer.from(result.data, "base64");
+  } finally {
+    ws.close();
+  }
+}
+
+function mmToInches(mm) {
+  return Number(mm ?? 0) / 25.4;
+}
+
+async function connectWebSocket(wsUrl) {
+  const parsed = new URL(wsUrl);
+  if (parsed.protocol !== "ws:") throw new Error(`Unsupported DevTools protocol: ${parsed.protocol}`);
+
+  return new Promise((resolve, reject) => {
+    const key = randomBytes(16).toString("base64");
+    const req = http.request({
+      hostname: parsed.hostname,
+      port: parsed.port || 80,
+      path: `${parsed.pathname}${parsed.search}`,
+      headers: {
+        Connection: "Upgrade",
+        Upgrade: "websocket",
+        "Sec-WebSocket-Version": 13,
+        "Sec-WebSocket-Key": key,
+      },
+    });
+    req.once("upgrade", (res, socket) => {
+      const expectedAccept = createHash("sha1").update(key + WS_GUID).digest("base64");
+      if (res.headers["sec-websocket-accept"] !== expectedAccept) {
+        socket.destroy();
+        reject(new Error("Invalid DevTools WebSocket handshake."));
+        return;
+      }
+      resolve(new SimpleWebSocket(socket));
+    });
+    req.once("error", reject);
+    req.end();
+  });
+}
+
+class SimpleWebSocket {
+  constructor(socket) {
+    this.socket = socket;
+    this.buffer = Buffer.alloc(0);
+    this.onMessage = null;
+    socket.on("data", (chunk) => this.handleData(chunk));
+    socket.on("error", () => {});
+  }
+
+  send(text) {
+    const payload = Buffer.from(String(text));
+    const frame = encodeClientFrame(0x1, payload);
+    this.socket.write(frame);
+  }
+
+  close() {
+    try { this.socket.end(); } catch { /* ignore */ }
+  }
+
+  handleData(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    while (true) {
+      const frame = decodeFrame(this.buffer);
+      if (!frame) return;
+      this.buffer = this.buffer.slice(frame.byteLength);
+      if (frame.opcode === 0x1 && this.onMessage) this.onMessage(frame.payload.toString("utf-8"));
+      if (frame.opcode === 0x9) this.socket.write(encodeClientFrame(0xA, frame.payload));
+      if (frame.opcode === 0x8) {
+        this.close();
+        return;
+      }
+    }
+  }
+}
+
+function encodeClientFrame(opcode, payload) {
+  const payloadLength = payload.length;
+  const mask = randomBytes(4);
+  let header;
+  if (payloadLength < 126) {
+    header = Buffer.alloc(2);
+    header[1] = 0x80 | payloadLength;
+  } else if (payloadLength < 65536) {
+    header = Buffer.alloc(4);
+    header[1] = 0x80 | 126;
+    header.writeUInt16BE(payloadLength, 2);
+  } else {
+    header = Buffer.alloc(10);
+    header[1] = 0x80 | 127;
+    header.writeBigUInt64BE(BigInt(payloadLength), 2);
+  }
+  header[0] = 0x80 | (opcode & 0x0f);
+  const masked = Buffer.alloc(payloadLength);
+  for (let i = 0; i < payloadLength; i += 1) masked[i] = payload[i] ^ mask[i % 4];
+  return Buffer.concat([header, mask, masked]);
+}
+
+function decodeFrame(buffer) {
+  if (buffer.length < 2) return null;
+  const first = buffer[0];
+  const second = buffer[1];
+  let offset = 2;
+  let payloadLength = second & 0x7f;
+  if (payloadLength === 126) {
+    if (buffer.length < 4) return null;
+    payloadLength = buffer.readUInt16BE(2);
+    offset = 4;
+  } else if (payloadLength === 127) {
+    if (buffer.length < 10) return null;
+    payloadLength = Number(buffer.readBigUInt64BE(2));
+    offset = 10;
+  }
+  const masked = (second & 0x80) !== 0;
+  let mask = null;
+  if (masked) {
+    if (buffer.length < offset + 4) return null;
+    mask = buffer.slice(offset, offset + 4);
+    offset += 4;
+  }
+  if (buffer.length < offset + payloadLength) return null;
+  const payload = Buffer.from(buffer.slice(offset, offset + payloadLength));
+  if (masked && mask) {
+    for (let i = 0; i < payload.length; i += 1) payload[i] ^= mask[i % 4];
+  }
+  return {
+    fin: (first & 0x80) !== 0,
+    opcode: first & 0x0f,
+    payload,
+    byteLength: offset + payloadLength,
+  };
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/content/machine/viteboard.json

@@ -1,6 +1,6 @@
 {
   "name": "ViteBoard",
-  "appVersion": "0.1.8",
+  "appVersion": "0.2.0",
   "machineVersion": 1,
   "summary": "Local-first documentation and infinite-canvas boards stored as plain files.",
   "interactionModel": "human-directed-via-agent",