slidemind 0.1.3 → 0.1.4

package/src/bridge/capture.mjs

@@ -0,0 +1,187 @@
+// Local slide capture — run the add-in's shipped capture engine on THIS
+// machine's Chrome.
+//
+// The slow half of a render (headless-Chrome DOM capture) used to run in the
+// cloud and die at the 240s ingress cap. Now the add-in ships its capture
+// engine on the bundle wire (materialized as `<bundleDir>/capture-engine.mjs`,
+// like the lint engine); we dynamic-import it and run it locally with a
+// puppeteer Chrome pinned to the SAME version the add-in uses (identical
+// Chromium ⇒ identical text measurement). The result — a serializable
+// CapturedDeck — is POSTed to the server's `/translate` route, which keeps the
+// IP-sensitive boxes→OOXML half. This repo owns NO capture/translate source.
+
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+// Same launch profile as the add-in's chrome-launcher.ts, so the client browser
+// behaves identically to the server's during capture.
+const LAUNCH_ARGS = [
+  "--no-sandbox",
+  "--disable-gpu",
+  "--hide-scrollbars",
+  "--disable-features=AppShimRemoteCocoa,AppShimNewCloseBehavior,WebAppSystemMediaControls",
+  "--disable-default-apps",
+  "--disable-extensions",
+  "--no-first-run",
+  "--no-default-browser-check",
+];
+
+/** True when the materialized bundle carries a capture engine to run locally. */
+export function bundleHasCaptureEngine(bundleDir) {
+  if (!bundleDir) return false;
+  return fs.existsSync(path.join(bundleDir, "capture-engine.mjs"));
+}
+
+function readBundleMeta(bundleDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(bundleDir, "bundle.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function readJsxDir(dir) {
+  const out = {};
+  if (!fs.existsSync(dir)) return out;
+  for (const name of fs.readdirSync(dir)) {
+    if (!name.endsWith(".jsx")) continue;
+    out[name] = fs.readFileSync(path.join(dir, name), "utf8");
+  }
+  return out;
+}
+
+// Walk a directory into { "<rel>": "<base64>" }, rel relative to `dir` with
+// forward slashes (the keys the capture engine maps under assets/).
+function readAssetsAsBase64(dir, out, prefix = "") {
+  if (!fs.existsSync(dir)) return out;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const abs = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      readAssetsAsBase64(abs, out, rel);
+    } else if (!(rel in out)) {
+      // First writer wins → bundle assets (added first) shadow deck assets on a
+      // name clash, matching the server's "brand asset wins" rule.
+      out[rel] = fs.readFileSync(abs).toString("base64");
+    }
+  }
+  return out;
+}
+
+// Build the in-memory workspace the capture engine renders: the deck's slides +
+// the materialized bundle's layouts / css / assets / fonts / primitives.
+// Exported for tests (pure: filesystem in, plain JSON out).
+export function buildCaptureInput(deckDir, bundleDir) {
+  const meta = readBundleMeta(bundleDir);
+
+  const slides = readJsxDir(path.join(deckDir, "slides"));
+  const layouts = readJsxDir(path.join(bundleDir, "layouts"));
+
+  const layoutsCssPath = path.join(bundleDir, "layouts", "layouts.css");
+  const layoutsCss = fs.existsSync(layoutsCssPath)
+    ? fs.readFileSync(layoutsCssPath, "utf8")
+    : "";
+
+  const corporateCssPath = path.join(bundleDir, "corporate-design.css");
+  const corporateCss = fs.existsSync(corporateCssPath)
+    ? fs.readFileSync(corporateCssPath, "utf8")
+    : "";
+
+  // Bundle (brand) assets first so they win a name clash, then deck-local.
+  const assets = {};
+  readAssetsAsBase64(path.join(bundleDir, "assets"), assets);
+  readAssetsAsBase64(path.join(deckDir, "assets"), assets);
+
+  // Fonts: role/family from the bundle meta manifest, bytes from fonts/<file>.
+  const fonts = [];
+  for (const f of Array.isArray(meta.fonts) ? meta.fonts : []) {
+    const fontPath = path.join(bundleDir, "fonts", path.basename(f.filename));
+    if (!fs.existsSync(fontPath)) continue;
+    fonts.push({
+      role: f.role,
+      family: f.family,
+      filename: path.basename(f.filename),
+      bytesB64: fs.readFileSync(fontPath).toString("base64"),
+    });
+  }
+
+  let primitives = { version: 2, primitives: [] };
+  try {
+    primitives = JSON.parse(
+      fs.readFileSync(path.join(bundleDir, "primitives.json"), "utf8"),
+    );
+  } catch {
+    /* empty registry is fine */
+  }
+
+  return {
+    slides,
+    layouts,
+    layoutsCss,
+    corporateCss,
+    assets,
+    fonts,
+    primitives,
+    deckName: path.basename(deckDir),
+  };
+}
+
+// Launch a headless Chrome, run `fn`, then tear it down — mirrors the add-in's
+// withBrowser (waits for the process to fully exit before cleanup).
+async function withBrowser(fn) {
+  // Test hook: run the engine with no real browser. Only safe with a fake
+  // engine that ignores its `browser` argument — never set in production.
+  if (process.env.SLIDEMIND_CAPTURE_BROWSERLESS === "1") {
+    return fn(null);
+  }
+  const puppeteer = (await import("puppeteer")).default;
+  const browser = await puppeteer.launch({
+    headless: true,
+    protocolTimeout: 600_000,
+    args: LAUNCH_ARGS,
+  });
+  try {
+    return await fn(browser);
+  } finally {
+    const proc = browser.process();
+    await browser.close().catch(() => {});
+    if (proc && proc.exitCode == null) {
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, 5000);
+        proc.once("exit", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+/**
+ * Capture a deck locally with the shipped engine. Returns a serializable
+ * CapturedDeck (every image byte inlined) ready to POST to `/translate`.
+ * Throws if the engine is missing/corrupt or the local browser can't launch —
+ * the caller decides whether to fall back to the server render path.
+ */
+export async function captureDeckLocally({ deckDir, bundleDir, onProgress }) {
+  const enginePath = path.join(bundleDir, "capture-engine.mjs");
+  if (!fs.existsSync(enginePath)) {
+    throw new Error(`no capture engine in bundle ${bundleDir}`);
+  }
+  const meta = readBundleMeta(bundleDir);
+  const version = meta.captureEngineVersion ?? "0";
+  // `?v=` busts Node's module cache so a long-lived process (the MCP server)
+  // picks up a refreshed engine at the same path after a bundle sync.
+  const engine = await import(
+    `${pathToFileURL(enginePath).href}?v=${encodeURIComponent(version)}`
+  );
+  if (typeof engine.captureDeck !== "function") {
+    throw new Error(
+      `cached capture engine is corrupt (no captureDeck export) — re-run 'slidemind download-bundle'`,
+    );
+  }
+
+  const input = buildCaptureInput(deckDir, bundleDir);
+  return withBrowser((browser) => engine.captureDeck(browser, input, { onProgress }));
+}