slidemind 0.3.13 → 0.3.14

package/src/cli/designs.mjs

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import path from "node:path";
+import { envTag } from "../bridge/config.mjs";
+
+// Best-effort human name of a materialized design. Prefers the live `name`
+// the wire carries (persisted into bundle.json by materializeBundle) — the
+// owner-set brand name, which survives renames. Falls back to the first `# `
+// heading in design.md (frozen at authoring time, so it may still show the
+// original auto codename), with the " — design rules" suffix stripped.
+// Returns null on any failure so callers fall back to the raw presFP.
+// Shared by `ready` and `new`'s auto-bind.
+export function readDesignName(bundleDir) {
+  if (!bundleDir) return null;
+  try {
+    const meta = JSON.parse(
+      fs.readFileSync(path.join(bundleDir, "bundle.json"), "utf8"),
+    );
+    if (typeof meta.name === "string" && meta.name.trim()) {
+      return meta.name.trim();
+    }
+  } catch {
+    /* no meta or unreadable — fall through to the design.md heading */
+  }
+  try {
+    const md = fs.readFileSync(path.join(bundleDir, "design.md"), "utf8");
+    for (const raw of md.split("\n")) {
+      const line = raw.trim();
+      if (line.startsWith("# ")) {
+        const name = line
+          .slice(2)
+          .trim()
+          .replace(/\s+[—-]\s+design rules\s*$/i, "")
+          .trim();
+        return name || null;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// The slide master's theme colours, from the one line design.md carries them
+// on (`Theme colors: dk1=#000000, lt1=#FFFFFF, …, accent1=#0000FF, …`). This
+// is what lets the agent SHOW a design to the user instead of naming it —
+// {dk1, lt1, dk2, lt2, accent1..6} → "#RRGGBB", or null when the bundle has
+// no such line.
+export function readThemeColors(bundleDir) {
+  if (!bundleDir) return null;
+  try {
+    const md = fs.readFileSync(path.join(bundleDir, "design.md"), "utf8");
+    const line = md.split("\n").find((l) => /^\s*Theme colors:/i.test(l));
+    if (!line) return null;
+    const colors = {};
+    for (const [, key, hex] of line.matchAll(/(\w+)=(#[0-9a-fA-F]{6})/g)) {
+      colors[key] = hex.toUpperCase();
+    }
+    return Object.keys(colors).length ? colors : null;
+  } catch {
+    return null;
+  }
+}
+
+// Every design materialized on this machine, the way `ready` reports it: name
+// + theme colours per design so the agent can put the choice to the user when
+// more than one is at hand. `current` marks the one this run resolved.
+export function cachedDesigns(bundle, currentPresFP) {
+  return bundle.listCachedBundles().map((b) => ({
+    presFP: b.presFP,
+    name: readDesignName(b.dir),
+    colors: readThemeColors(b.dir),
+    current: b.presFP === currentPresFP,
+  }));
+}
+
+// One menu row per design: id, name, theme swatch, and the verified windows
+// open on it. `(not cached)` marks a design only a window or the backend knows.
+export function designRows(designs) {
+  return designs.map((d) => {
+    const c = d.colors ?? {};
+    const swatch = ["accent1", "accent2", "dk1", "lt1"]
+      .filter((k) => c[k])
+      .map((k) => `${k} ${c[k]}`)
+      .join(", ");
+    const open = (d.windows ?? [])
+      .map((w) => `${w.title || w.fileName || "(untitled)"}${envTag(w.env)}`)
+      .join(", ");
+    return (
+      `  ${d.current ? "*" : " "} ${d.presFP}  ${d.name ?? "(unnamed)"}` +
+      `${swatch ? `  [${swatch}]` : ""}` +
+      `${d.cached === false ? "  (not cached)" : ""}` +
+      `${open ? `  open: ${open}` : ""}`
+    );
+  });
+}
+
+export function designsHumanLines(designs) {
+  if (designs.length < 2) return "";
+  return (
+    `  ${designs.length} designs at hand — ask the user which to build against (* = current):\n` +
+    `${designRows(designs).join("\n")}\n` +
+    "  Switch with: slidemind ready [deck] --brand <presFP>\n"
+  );
+}
+
+export function windowsHumanLine(windows) {
+  if (windows.length === 0) return "";
+  const rows = windows.map(
+    (w) =>
+      `${w.title || w.fileName || "(untitled)"}${envTag(w.env)}${w.paneReady ? "" : " (suspended)"}`,
+  );
+  return `  windows: ${rows.join(", ")}\n`;
+}

package/src/cli/diagnose.mjs

@@ -0,0 +1,141 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { fail, loadBridgeModule, SRC_DIR } from "./common.mjs";
+import { publicConnectionStatus, backendBlocker, paneBlocker, connectionNextAction } from "./connection.mjs";
+
+export async function runDiagnose(rest) {
+  const asJson = rest.includes("--json");
+  const cfg = await loadBridgeModule("config");
+  const sessions = cfg.readSessions();
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+  // The diagnostic reports skew — it must never be killed BY skew. The version floor
+  // still reaches the reader, as the `cli_update_required` rung of the ladder.
+  client.setDiagnosticMode(true);
+  if (sessions.length === 0) {
+    const blocker = backendBlocker({ paired: false });
+    const pub = {
+      paired: false,
+      backendCount: 0,
+      backends: [],
+      presentations: [],
+      authoring: { ready: false, blocker, degraded: null, engines: null },
+      host: { ready: false, blocker: paneBlocker({ presentations: [] }) },
+      nextAction: connectionNextAction({ paired: false }),
+    };
+    process[asJson ? "stdout" : "stderr"].write(
+      asJson ? `${JSON.stringify(pub, null, 2)}\n` : `${pub.nextAction}\n`,
+    );
+    return;
+  }
+  const statusRaw = await client.connectionStatus();
+  const status = publicConnectionStatus(statusRaw, client);
+  // The two ladders are INDEPENDENT: authoring (session → reachable backend →
+  // CLI version → engine reachability) is what render, bundle and the pane-free
+  // engine routes ride on, while the live-PowerPoint ladder only governs
+  // push/insert-slide and reading an open presentation. Reporting them
+  // separately is the point — a dead pane is not "cannot work".
+  const authoringBlocker = backendBlocker(status);
+  let engines = { available: false, envs: [] };
+  if (!authoringBlocker) {
+    try {
+      engines = await client.engineReachability({ backends: statusRaw.backends });
+    } catch {
+      /* leave it as unavailable — never fail a diagnosis on a probe */
+    }
+  }
+  status.authoring = {
+    ready: !authoringBlocker,
+    blocker: authoringBlocker,
+    engines,
+  };
+  const hostBlocker = paneBlocker(status);
+  status.host = { ready: !hostBlocker, blocker: hostBlocker };
+  status.nextAction = connectionNextAction(status);
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`Paired backends: ${status.backendCount}\n`);
+  for (const b of status.backends) {
+    process.stdout.write(
+      `  ${b.env}: ${b.ok ? "reachable" : `unreachable — ${b.error}`}` +
+        (b.readinessV1 ? " (readiness)" : " (legacy)") +
+        `\n`,
+    );
+  }
+  process.stdout.write(
+    `Backend authoring ready: ${status.authoring.ready ? "yes" : "no"}` +
+      `${status.authoring.ready ? "" : ` — ${authoringBlocker.message}`}\n`,
+  );
+  process.stdout.write(
+    `  engine search (no window needed): ${
+      engines.available
+        ? `yes [${engines.envs.join(", ")}]`
+        : "no — relayed through an open pane"
+    }\n`,
+  );
+  // Human output only — the --json shape is a contract and the m365 state
+  // already rides `ready --json`. Printed only when a backend can actually
+  // spend a sign-in (graphDelegated), so old deployments stay noise-free.
+  const graphAdvertising = (statusRaw.backends ?? []).filter(
+    (b) => b.ok && b.capabilities?.graphDelegated === true && b.backendURL,
+  );
+  if (graphAdvertising.length > 0) {
+    const graph = await loadBridgeModule("graph-auth");
+    const signedOut = graphAdvertising.filter(
+      (b) => !graph.hasGraphSession(b.backendURL),
+    );
+    const signedOutEnvs = signedOut.map((b) => cfg.deriveEnvLabel(b.backendURL));
+    process.stdout.write(
+      signedOut.length === 0
+        ? "  Microsoft 365: signed in\n"
+        : `  Microsoft 365: not signed in [${signedOutEnvs.join(", ")}] — engine search and ` +
+          "downloads run as the user; the next engine command opens a browser " +
+          "sign-in for them to complete (or run 'slidemind login' now)\n",
+    );
+  }
+  process.stdout.write(
+    `Live PowerPoint ready: ${status.host.ready ? "yes" : "no"}` +
+      `${status.host.ready ? "" : ` — ${hostBlocker.message}`}\n`,
+  );
+  if (status.presentations.length === 0) {
+    process.stdout.write("Open presentations: none\n");
+  } else {
+    process.stdout.write("Open presentations:\n");
+    // Pane-ready windows first, then suspended/stale ones (stable sort keeps
+    // each group's incoming order) — a reader picking a target wants the
+    // windows that can take live ops at the top.
+    const rows = [...status.presentations].sort(
+      (a, b) =>
+        (client.isPaneReadyPresentation(b) ? 1 : 0) -
+        (client.isPaneReadyPresentation(a) ? 1 : 0),
+    );
+    for (const p of rows) {
+      const label = p.title || p.fileName || "(untitled)";
+      const state =
+        p.connectionState ||
+        (p.connected === false || p.suspendedAt ? "suspended" : "connected");
+      const design = p.designState || (p.brandId ? "ready" : "unknown");
+      const caps = p.capabilities
+        ? ` render:${p.capabilities.render === true ? "yes" : "no"} pane:${p.capabilities.paneOps === true ? "yes" : "no"}`
+        : "";
+      process.stdout.write(
+        `  ${p.presId}\t${p.env ? `[${p.env}] ` : ""}${label}\t${state}\tcd:${design}${caps}\n`,
+      );
+      // A window whose pane can't take live ops yet is still listed — with the
+      // one actionable line to wake it, so the reader sees an honest state.
+      if (!client.isPaneReadyPresentation(p)) {
+        process.stdout.write(
+          `\t${
+            p.nextAction && typeof p.nextAction.message === "string"
+              ? p.nextAction.message
+              : "bring PowerPoint forward and click the slidemind pane"
+          }\n`,
+        );
+      }
+    }
+  }
+  process.stdout.write(`Next action: ${status.nextAction}\n`);
+}

package/src/cli/download-bundle.mjs

@@ -0,0 +1,144 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { fail, resolveDeckArg, SRC_DIR } from "./common.mjs";
+import { readDesignName } from "./designs.mjs";
+
+export async function cmdDownloadBundle(rest) {
+  let to = null;
+  let brand = null;
+  let force = false;
+  let all = false;
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--to") {
+      to = rest[++i];
+      if (!to) fail("--to expects a presId");
+    } else if (a === "--brand") {
+      brand = rest[++i];
+      if (!brand) fail("--brand expects a design fingerprint (presFP)");
+    } else if (a === "--force") {
+      force = true;
+    } else if (a === "--all") {
+      all = true;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else {
+      positional.push(a);
+    }
+  }
+  if (all && (to || brand || positional.length > 0)) {
+    fail("--all refreshes every cached design — not with a deck, --brand or --to");
+  }
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+  const bundle = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
+  );
+  // --all: refresh every design already materialized here, over the pane-free
+  // brand route — the "update my bundles" half of bundle management, so a
+  // corporate-design change lands locally without opening PowerPoint or naming
+  // each design. One failure (a design the connected backends no longer serve)
+  // never stops the rest.
+  if (all) {
+    const cached = bundle.listCachedBundles();
+    if (cached.length === 0) {
+      fail(
+        "No design bundle is cached here yet. Run `slidemind ready` (PowerPoint open) or `slidemind download-bundle --brand <presFP>` first.",
+      );
+    }
+    let ok = 0;
+    for (const entry of cached) {
+      const name = readDesignName(entry.dir) ?? entry.presFP;
+      try {
+        const res = await bundle.materializeBundle(null, {
+          force,
+          brandId: entry.presFP,
+        });
+        ok += 1;
+        process.stdout.write(
+          `${name} (${res.presFP}) — etag ${res.etag ?? "?"}, ${res.downloaded} downloaded, ${res.pruned} pruned\n`,
+        );
+        for (const w of res.warnings ?? []) {
+          process.stderr.write(`  warning: ${w}\n`);
+        }
+      } catch (err) {
+        process.stderr.write(
+          `  ${name} (${entry.presFP}) — not refreshed: ${err?.message || err}\n`,
+        );
+      }
+    }
+    if (ok === 0) {
+      fail(
+        `No cached design could be refreshed (${cached.length} tried) — check the connection with \`slidemind ready --diagnose\`.`,
+      );
+    }
+    process.stdout.write(
+      `Refreshed ${ok} of ${cached.length} cached design${cached.length === 1 ? "" : "s"}.\n`,
+    );
+    return;
+  }
+
+  // When a deck is being (re-)bound, its existing bundle ref breaks ties for
+  // a presId open on several paired backends (prefer the one whose connected
+  // pane has THIS corporate design active).
+  const deckRef = positional[0]
+    ? bundle.readDeckBundleRef(resolveDeckArg(positional[0]))
+    : null;
+  // A design we can already name — `--brand`, or the deck's own binding —
+  // materializes over the pane-free brand route, same as `ready` does. Only an
+  // explicit `--to` (the user named a window) or a nameless design still needs
+  // the registry. A miss (old add-in, revoked design) falls through.
+  const brandId = to
+    ? null
+    : (brand ??
+      deckRef?.presFP ??
+      (positional[0] ? await bundle.resolveWindowlessBrand(resolveDeckArg(positional[0])) : null));
+  let result = brandId
+    ? await bundle
+        .materializeBundle(null, { force, brandId })
+        .catch(() => null)
+    : null;
+  if (!result) {
+    if (brand) {
+      fail(
+        `No connected slidemind add-in serves design '${brand}'. Run 'slidemind ready' to see which designs are available.`,
+      );
+    }
+    const registry = await client.requireRenderHost();
+    const entry = client.pickPresentationEntry(registry, to, {
+      preferBrandId: deckRef?.presFP ?? null,
+    });
+    result = await bundle.materializeBundle(entry.presId, {
+      force,
+      backendURL: entry.backendURL ?? null,
+    });
+  }
+
+  // Optionally bind a deck to this bundle so build-pptx/push pass the right
+  // etag and the local HTML/editor read the right design files.
+  const deckArg = positional[0];
+  if (deckArg) {
+    const deckDir = resolveDeckArg(deckArg);
+    bundle.writeDeckBundleRef(deckDir, {
+      presFP: result.presFP,
+      etag: result.etag,
+    });
+  }
+  process.stdout.write(
+    `Synced bundle for ${result.presFP} (etag ${result.etag ?? "?"}) — ` +
+      `${result.downloaded} downloaded, ${result.pruned} pruned\n  ${result.dir}\n`,
+  );
+  if (result.engineUpdated) {
+    process.stdout.write("  lint engine updated\n");
+  }
+  if (result.captureEngineUpdated) {
+    process.stdout.write("  capture engine updated\n");
+  }
+  // Asset downloads are best-effort (a signed URL may have expired); surface any
+  // failures so the user knows the local preview bundle is incomplete.
+  for (const w of result.warnings ?? []) {
+    process.stderr.write(`  warning: ${w}\n`);
+  }
+}