slidemind 0.0.27

package/src/bridge/client.mjs

@@ -0,0 +1,338 @@
+// Client for the slidemind PowerPoint add-in's local bridge.
+//
+// The add-in's Express middle-tier (port 3001 by default) exposes a localhost-
+// only, token-gated `/local/*` surface that lets a sibling local process —
+// this CLI, the bundled MCP server, anything running on the same machine —
+// enumerate the open PowerPoint windows and push slides into a specific one.
+//
+// The shared token is generated on add-in start and written to a state file.
+// Reading it is sufficient auth; the add-in's middleware also rejects any
+// non-loopback caller, so this is intentionally a same-machine-only surface.
+
+import fs from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import https from "node:https";
+
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 3001;
+const TOKEN_HEADER = "x-slidemind-bridge-token";
+
+export function bridgeStateDir() {
+  if (process.platform === "win32") {
+    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    return path.join(base, "slidemind");
+  }
+  const base = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+  return path.join(base, "slidemind");
+}
+
+export function bridgeTokenPath() {
+  return path.join(bridgeStateDir(), "bridge-token");
+}
+
+export function readBridgeToken() {
+  const file = bridgeTokenPath();
+  let raw;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error(
+        `slidemind bridge token not found at ${file}. ` +
+          `Start the slidemind PowerPoint add-in first — it generates the token on first run.`,
+      );
+    }
+    throw err;
+  }
+  const token = raw.trim();
+  if (!token) {
+    throw new Error(`slidemind bridge token at ${file} is empty.`);
+  }
+  return token;
+}
+
+function bridgeBaseUrl() {
+  const host = process.env.SLIDEMIND_BRIDGE_HOST || DEFAULT_HOST;
+  const port = parseInt(process.env.SLIDEMIND_BRIDGE_PORT || `${DEFAULT_PORT}`, 10);
+  // The add-in's dev backend uses HTTPS with self-signed certs; production
+  // (Azure Container Apps) terminates TLS upstream and exposes HTTP. Default
+  // to HTTPS but allow override.
+  const scheme = process.env.SLIDEMIND_BRIDGE_SCHEME || "https";
+  return `${scheme}://${host}:${port}`;
+}
+
+async function bridgeFetch(pathPart, init = {}) {
+  const url = `${bridgeBaseUrl()}${pathPart}`;
+  const token = readBridgeToken();
+  const headers = {
+    accept: "application/json",
+    ...init.headers,
+    [TOKEN_HEADER]: token,
+  };
+
+  let response;
+  try {
+    response = await nodeRequest(url, { ...init, headers });
+  } catch (err) {
+    if (err && /ECONNREFUSED|ECONNRESET|ENOTFOUND|self-signed|fetch failed/i.test(String(err.message || err))) {
+      throw new Error(
+        `slidemind bridge unreachable at ${url}. ` +
+          `Is the slidemind PowerPoint add-in running? (npm run dev:backend in src/ui)`,
+      );
+    }
+    throw err;
+  }
+  if (response.status < 200 || response.status >= 300) {
+    let parsed = null;
+    try {
+      parsed = response.body ? JSON.parse(response.body) : null;
+    } catch {
+      /* non-JSON error body — fall back to the raw text */
+    }
+    // Prefer the machine-readable `code` (e.g. "pane_suspended",
+    // "engine_auth_expired"); fall back to the human `error` string for routes
+    // that don't emit a discrete code yet. Keep the human text in the message.
+    const machineCode =
+      parsed && typeof parsed.code === "string" ? parsed.code : null;
+    const humanError =
+      parsed && typeof parsed.error === "string" ? parsed.error : null;
+    const detail =
+      humanError ?? (response.body ? response.body.slice(0, 400) : "");
+    const err = new Error(
+      `slidemind bridge ${response.status} ${response.statusText} for ${pathPart}` +
+        (detail ? `: ${detail}` : ""),
+    );
+    err.status = response.status;
+    const code = machineCode ?? humanError;
+    if (code) err.code = code;
+    if (parsed) err.body = parsed;
+    throw err;
+  }
+  return {
+    json: async () => (response.body ? JSON.parse(response.body) : null),
+    text: async () => response.body,
+  };
+}
+
+function nodeRequest(urlString, init = {}) {
+  const url = new URL(urlString);
+  const isHttps = url.protocol === "https:";
+  const transport = isHttps ? https : http;
+  const body = init.body ?? null;
+  const headers = { ...(init.headers ?? {}) };
+  if (body && headers["content-length"] === undefined && headers["Content-Length"] === undefined) {
+    headers["content-length"] = Buffer.byteLength(body);
+  }
+
+  const timeoutMs =
+    parseInt(process.env.SLIDEMIND_BRIDGE_TIMEOUT_MS || "35000", 10) || 35000;
+  return new Promise((resolve, reject) => {
+    const req = transport.request(
+      url,
+      {
+        method: init.method ?? "GET",
+        headers,
+        rejectUnauthorized: isHttps ? false : undefined,
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        res.on("end", () => {
+          resolve({
+            status: res.statusCode ?? 0,
+            statusText: res.statusMessage ?? "",
+            body: Buffer.concat(chunks).toString("utf8"),
+          });
+        });
+      },
+    );
+    // Default 35s > the add-in's 30s emitWithAck, so a suspended pane surfaces a
+    // typed `pane_suspended` rather than a client timeout. A real timeout is
+    // tagged `bridge_timeout` so non-idempotent callers (insert) know the request
+    // may already have been delivered and must NOT auto-retry it.
+    req.setTimeout(timeoutMs, () => {
+      const err = new Error(
+        `slidemind bridge request timed out after ${timeoutMs}ms`,
+      );
+      err.code = "bridge_timeout";
+      req.destroy(err);
+    });
+    req.on("error", reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+export async function listOpenPresentations() {
+  const res = await bridgeFetch("/local/presentations");
+  const data = await res.json();
+  return Array.isArray(data?.presentations) ? data.presentations : [];
+}
+
+// Probe the bridge for an open PowerPoint host. Returns the live registry, or
+// throws a single actionable message — the shared precondition for every
+// author/render command now that the design truth lives in the add-in.
+export async function requireHost() {
+  let registry;
+  try {
+    registry = await listOpenPresentations();
+  } catch (err) {
+    throw new Error(
+      "Open PowerPoint with the slidemind add-in and an active corporate design, then retry.\n" +
+        `  (bridge: ${err.message})`,
+    );
+  }
+  if (!Array.isArray(registry) || registry.length === 0) {
+    throw new Error(
+      "No PowerPoint window is registered with the slidemind add-in.\n" +
+        "Open PowerPoint with the slidemind add-in and an active corporate design, then retry.",
+    );
+  }
+  return registry;
+}
+
+// GET the full design bundle (tokens, css, layouts, designRules, signed asset
+// URLs, engines) for the presentation's active corporate design.
+export async function getDesignBundle(presId) {
+  if (!presId) throw new Error("getDesignBundle: presId is required");
+  const res = await bridgeFetch(
+    `/local/presentations/${encodeURIComponent(presId)}/design-bundle`,
+  );
+  return res.json();
+}
+
+// Server-side OOXML render: ship authored slide JSX (+ deck-local assets) and
+// get back a native .pptx (base64) rendered against the presentation's own CD.
+// `slides`: { "<file>.jsx": "<jsx source>" }. `deckAssets`: { "assets/<f>": "<base64>" }.
+export async function renderPptx({
+  presId,
+  slides,
+  deckAssets = null,
+  etag = null,
+}) {
+  if (!presId) throw new Error("renderPptx: presId is required");
+  if (!slides || Object.keys(slides).length === 0) {
+    throw new Error("renderPptx: slides is required");
+  }
+  const body = { slides };
+  if (deckAssets && Object.keys(deckAssets).length > 0) {
+    body.deckAssets = deckAssets;
+  }
+  if (etag) body.etag = etag;
+  const res = await bridgeFetch(
+    `/local/presentations/${encodeURIComponent(presId)}/render-pptx`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    },
+  );
+  return res.json(); // { ok, base64, slideCount, warnings, skippedSlides }
+}
+
+// Brand-engine search, proxied through the open task pane. Engine-agnostic
+// (image/icon engines today; slide engines later). Returns a searchId + a
+// numbered set of result thumbnails for the agent to choose from.
+export async function engineSearch({ presId, engineId, query }) {
+  if (!presId) throw new Error("engineSearch: presId is required");
+  if (!engineId) throw new Error("engineSearch: engineId is required");
+  if (!query) throw new Error("engineSearch: query is required");
+  const res = await bridgeFetch(
+    `/local/presentations/${encodeURIComponent(presId)}/engine/search`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ engineId, query }),
+    },
+  );
+  return res.json(); // { ok, searchId, resultCount, gridDataUri, thumbnails }
+}
+
+// Fetch a chosen engine result's bytes (proxied through the task pane). For
+// image engines this returns SVG/PNG bytes (+ optional recoloured svgMarkup)
+// WITHOUT inserting onto a slide.
+export async function engineDownload({
+  presId,
+  searchId,
+  selection,
+  iconColor = null,
+}) {
+  if (!presId) throw new Error("engineDownload: presId is required");
+  if (typeof searchId !== "number") {
+    throw new Error("engineDownload: searchId (number) is required");
+  }
+  if (typeof selection !== "number") {
+    throw new Error("engineDownload: selection (number) is required");
+  }
+  const body = { searchId, selection };
+  if (iconColor) body.iconColor = iconColor;
+  const res = await bridgeFetch(
+    `/local/presentations/${encodeURIComponent(presId)}/engine/download`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    },
+  );
+  return res.json(); // { ok, base64, mimeType, svgMarkup }
+}
+
+export async function insertSlides({ presId, base64, insertAt = null, sourceSlideIds = null }) {
+  if (!presId) throw new Error("insertSlides: presId is required");
+  if (!base64) throw new Error("insertSlides: base64 is required");
+  const body = { base64, insertAt, sourceSlideIds };
+  const res = await bridgeFetch(
+    `/local/presentations/${encodeURIComponent(presId)}/insert`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    },
+  );
+  return res.json().catch(() => ({}));
+}
+
+export async function replaceSlides({ presId, base64 }) {
+  if (!presId) throw new Error("replaceSlides: presId is required");
+  if (!base64) throw new Error("replaceSlides: base64 is required");
+  const res = await bridgeFetch(
+    `/local/presentations/${encodeURIComponent(presId)}/replace`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ base64 }),
+    },
+  );
+  return res.json().catch(() => ({}));
+}
+
+// Pick a target presentation given the live registry and an optional explicit
+// presId. Returns the presId to push to, or throws with a helpful message if
+// the choice is ambiguous.
+export function pickPresentation(registry, explicitPresId) {
+  if (explicitPresId) {
+    const match = registry.find((p) => p.presId === explicitPresId);
+    if (!match) {
+      const ids = registry.map((p) => p.presId).join(", ") || "(none registered)";
+      throw new Error(
+        `No open PowerPoint window registered with presId='${explicitPresId}'. Live: ${ids}`,
+      );
+    }
+    return match.presId;
+  }
+  if (registry.length === 0) {
+    throw new Error(
+      "No PowerPoint windows registered with the slidemind add-in. " +
+        "Open a presentation, ensure the add-in is loaded, and try again.",
+    );
+  }
+  if (registry.length === 1) return registry[0].presId;
+  const list = registry
+    .map((p) => `  ${p.presId}\t${p.title || p.fileName || "(untitled)"}`)
+    .join("\n");
+  throw new Error(
+    `Multiple PowerPoint windows are open. Pick one with --to <presId>:\n${list}`,
+  );
+}