gutterpress 0.11.10-alpha.2 → 0.11.10-alpha.6

package/dist/cli-kkzka31p.js

@@ -0,0 +1,261 @@
+import {
+  requireChromiumExecutable
+} from "./cli-7fkhgtfn.js";
+
+// src/engine/shared/cdp.ts
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import WebSocket from "ws";
+var REQUIRED_MILESTONE = 148;
+function assertMilestone(product, origin, hint = "") {
+  const milestone = Number(/Chrome\/(\d+)/.exec(product)?.[1] ?? 0);
+  if (milestone < REQUIRED_MILESTONE) {
+    throw new Error(`The Gutterpress engine requires Chromium ${REQUIRED_MILESTONE}+; found ${product} ${origin}.` + (hint ? `
+${hint}` : ""));
+  }
+}
+function readyProbeExpr(timeoutMs) {
+  return `(async () => {
+      await document.fonts.ready;
+      if (window.__gpReadyPending) {
+        await new Promise((res) => {
+          const t = setTimeout(res, ${timeoutMs});
+          document.addEventListener('gp:ready', () => { clearTimeout(t); res(); }, { once: true });
+        });
+      }
+      // two rAFs: let layout settle after fonts swap
+      await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
+      return true;
+    })()`;
+}
+var DEFAULT_PRINT_OPTS = {
+  printBackground: true,
+  preferCSSPageSize: true,
+  generateTaggedPDF: true,
+  generateDocumentOutline: true
+};
+var DEFAULT_ARGS = [
+  "--headless=new",
+  "--no-first-run",
+  "--no-default-browser-check",
+  "--disable-gpu",
+  "--no-sandbox",
+  "--hide-scrollbars",
+  "--allow-file-access-from-files",
+  "--font-render-hinting=none"
+];
+async function launchChromium(opts = {}) {
+  const bin = await requireChromiumExecutable();
+  const userDataDir = mkdtempSync(join(tmpdir(), "gp-cdp-"));
+  const envArgs = (process.env.GUTTERPRESS_CHROMIUM_ARGS ?? "").split(/\s+/).filter(Boolean);
+  const ignored = new Set(opts.ignoreDefaultArgs ?? []);
+  const args = [
+    "--remote-debugging-port=0",
+    `--user-data-dir=${userDataDir}`,
+    ...DEFAULT_ARGS.filter((a) => !ignored.has(a)),
+    ...envArgs,
+    ...opts.args ?? [],
+    "about:blank"
+  ];
+  const proc = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+  const wsUrl = await readDevToolsUrl(proc);
+  const conn = await Connection.open(wsUrl);
+  const teardown = async () => {
+    const exited = new Promise((r) => proc.once("exit", () => r()));
+    try {
+      await Promise.race([
+        conn.send("Browser.close").then(() => exited),
+        new Promise((_, rej) => setTimeout(() => rej(new Error("Browser.close timed out")), 5000))
+      ]);
+    } catch {
+      proc.kill("SIGKILL");
+      await exited;
+    }
+    conn.close();
+    rmSync(userDataDir, { recursive: true, force: true });
+  };
+  const version = await conn.send("Browser.getVersion", {});
+  try {
+    assertMilestone(version.product, `at ${bin}`, `Install a newer Chrome, Chromium, or Edge, or point CHROMIUM_PATH at a ${REQUIRED_MILESTONE}+ binary.`);
+  } catch (e) {
+    await teardown();
+    throw e;
+  }
+  const milestone = Number(/Chrome\/(\d+)/.exec(version.product)?.[1] ?? 0);
+  return {
+    wsUrl,
+    version: version.product,
+    milestone,
+    async newPage() {
+      const { targetId } = await conn.send("Target.createTarget", { url: "about:blank" });
+      const { sessionId } = await conn.send("Target.attachToTarget", { targetId, flatten: true });
+      const s = new SessionImpl(conn, sessionId, targetId);
+      await s.send("Page.enable");
+      await s.send("Runtime.enable");
+      return s;
+    },
+    close: teardown
+  };
+}
+function readDevToolsUrl(proc) {
+  return new Promise((resolve, reject) => {
+    let buf = "";
+    const timer = setTimeout(() => reject(new Error(`Chromium did not report a DevTools URL:
+${buf}`)), 60000);
+    proc.stderr.on("data", (d) => {
+      buf += String(d);
+      const m = /ws:\/\/[^\s]+/.exec(buf);
+      if (m) {
+        clearTimeout(timer);
+        resolve(m[0]);
+      }
+    });
+    proc.once("exit", (code) => {
+      clearTimeout(timer);
+      reject(new Error(`Chromium exited (${code}) before listening:
+${buf}`));
+    });
+  });
+}
+
+class Connection {
+  ws;
+  id = 0;
+  pending = new Map;
+  listeners = new Map;
+  constructor(ws) {
+    this.ws = ws;
+    ws.on("message", (raw) => this.dispatch(JSON.parse(String(raw))));
+  }
+  static async open(url) {
+    const ws = new WebSocket(url, { maxPayload: 512 * 1024 * 1024 });
+    await new Promise((res, rej) => {
+      ws.once("open", () => res());
+      ws.once("error", rej);
+    });
+    return new Connection(ws);
+  }
+  dispatch(msg) {
+    if (msg.id !== undefined) {
+      const p = this.pending.get(msg.id);
+      if (!p)
+        return;
+      this.pending.delete(msg.id);
+      if (msg.error)
+        p.reject(new Error(`${msg.error.message} (${msg.error.code})`));
+      else
+        p.resolve(msg.result);
+      return;
+    }
+    const key = msg.sessionId ? `${msg.sessionId}:${msg.method}` : msg.method;
+    for (const fn of this.listeners.get(key) ?? [])
+      fn(msg.params);
+    for (const fn of this.listeners.get(msg.method) ?? [])
+      fn(msg.params);
+  }
+  send(method, params = {}, sessionId) {
+    const id = ++this.id;
+    const payload = { id, method, params };
+    if (sessionId)
+      payload.sessionId = sessionId;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+  on(key, fn) {
+    let set = this.listeners.get(key);
+    if (!set)
+      this.listeners.set(key, set = new Set);
+    set.add(fn);
+    return () => set.delete(fn);
+  }
+  close() {
+    this.ws.close();
+  }
+}
+
+class SessionImpl {
+  conn;
+  sessionId;
+  targetId;
+  constructor(conn, sessionId, targetId) {
+    this.conn = conn;
+    this.sessionId = sessionId;
+    this.targetId = targetId;
+  }
+  send(method, params = {}) {
+    return this.conn.send(method, params, this.sessionId);
+  }
+  on(event, fn) {
+    return this.conn.on(`${this.sessionId}:${event}`, fn);
+  }
+  async evaluate(expression) {
+    const res = await this.send("Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+      awaitPromise: true
+    });
+    if (res.exceptionDetails) {
+      const e = res.exceptionDetails;
+      throw new Error(`evaluate failed: ${e.exception?.description ?? e.text}`);
+    }
+    return res.result.value;
+  }
+  async waitForLoad(fn) {
+    const done = new Promise((resolve) => {
+      const off = this.on("Page.loadEventFired", () => {
+        off();
+        resolve();
+      });
+    });
+    await fn();
+    await done;
+  }
+  async setContent(html, baseUrl = "http://gutterpress.spike/") {
+    await this.waitForLoad(async () => {
+      const { frameTree } = await this.send("Page.getFrameTree");
+      await this.send("Page.setDocumentContent", {
+        frameId: frameTree.frame.id,
+        html
+      });
+    });
+  }
+  async navigate(url) {
+    await this.waitForLoad(async () => {
+      await this.send("Page.navigate", { url });
+    });
+  }
+  async waitForReady(timeoutMs = 15000) {
+    await this.evaluate(readyProbeExpr(timeoutMs));
+  }
+  async printToPDF(opts = {}) {
+    const res = await this.send("Page.printToPDF", {
+      ...DEFAULT_PRINT_OPTS,
+      transferMode: "ReturnAsStream",
+      ...opts
+    });
+    if (!res.stream)
+      return Uint8Array.from(Buffer.from(res.data, "base64"));
+    const chunks = [];
+    try {
+      for (;; ) {
+        const c = await this.send("IO.read", { handle: res.stream, size: 8 * 1024 * 1024 });
+        if (c.data)
+          chunks.push(Buffer.from(c.data, c.base64Encoded ? "base64" : "binary"));
+        if (c.eof)
+          break;
+      }
+    } finally {
+      await this.send("IO.close", { handle: res.stream }).catch(() => {});
+    }
+    return new Uint8Array(Buffer.concat(chunks));
+  }
+  async close() {
+    await this.conn.send("Target.closeTarget", { targetId: this.targetId });
+  }
+}
+
+export { REQUIRED_MILESTONE, assertMilestone, readyProbeExpr, DEFAULT_PRINT_OPTS, launchChromium };

package/dist/{cli-p679pvce.js → cli-vbzkkcbv.js}

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "./cli-k2hwrp7s.js";
+} from "./cli-97bdz5k0.js";
 import {
   execCapture,
   findTool,
@@ -8,7 +8,7 @@ import {
   isToolAvailable,
   resolveChromiumExecutable,
   run
-} from "./cli-c41yr7he.js";
+} from "./cli-7fkhgtfn.js";
 import {
   __require
 } from "./cli-37x76zdn.js";