slidemind 0.1.5 → 0.1.6

package/src/installers/codex.mjs

@@ -23,6 +23,7 @@
 
 import fs from "node:fs";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import {
   expandHome,
   installDir,
@@ -40,7 +41,10 @@ const TOML_MARK_BEGIN = "# slidemind:begin";
 const TOML_MARK_END = "# slidemind:end";
 
 function codexRoot() {
-  return expandHome("~/.codex");
+  // Codex reads everything (skills, AGENTS.md, config.toml) from $CODEX_HOME
+  // when set, defaulting to ~/.codex — mirror that so our artifacts land where
+  // it actually looks.
+  return process.env.CODEX_HOME || expandHome("~/.codex");
 }
 
 function promptsDir() {
@@ -81,38 +85,102 @@ function configTomlFile() {
   return path.join(codexRoot(), "config.toml");
 }
 
-function writeMcpServerBlock(packageRoot) {
+// Register the slidemind MCP server. Prefer Codex's own `codex mcp add`, which
+// is TOML-aware and idempotent: it sets `[mcp_servers.slidemind]` by key, so a
+// re-install/upgrade — or a pre-existing entry added manually or by an earlier
+// `codex mcp add` — is REPLACED in place rather than duplicated, while unrelated
+// tables, top-level keys, and comments survive.
+//
+// The previous hand-rolled writer wrapped its block in `# slidemind:begin/end`
+// comment markers and deduped by them; a `[mcp_servers.slidemind]` table that
+// lacked those markers (manual edit, or a Codex-side config rewrite that dropped
+// the comments) was invisible to it, so it appended a SECOND table — a
+// duplicate-key TOML that broke config.toml. Delegating to Codex removes that
+// whole failure mode.
+//
+// `codex mcp` landed around Codex 0.128. If the binary is missing or too old
+// (spawn error / non-zero exit) we fall back to a minimal, non-destructive
+// writer that never duplicates.
+export function registerMcpServer(packageRoot) {
   const mcpServer = path.join(packageRoot, "src", "mcp", "server.mjs");
-  const block =
-    `${TOML_MARK_BEGIN}\n` +
-    `[mcp_servers.slidemind]\n` +
+  const viaCli = spawnSync(
+    "codex",
+    ["mcp", "add", NAMESPACE, "--", "node", mcpServer],
+    { stdio: "ignore", shell: process.platform === "win32" },
+  );
+  if (!viaCli.error && viaCli.status === 0) {
+    sweepLegacyMarkers();
+    return "registered via codex mcp";
+  }
+  return fallbackWriteMcpServerBlock(mcpServer);
+}
+
+export function unregisterMcpServer() {
+  const viaCli = spawnSync(
+    "codex",
+    ["mcp", "remove", NAMESPACE],
+    { stdio: "ignore", shell: process.platform === "win32" },
+  );
+  if (!viaCli.error && viaCli.status === 0) return "unregistered via codex mcp";
+  return fallbackClearMcpServerBlock();
+}
+
+function mcpServerBlock(mcpServer) {
+  return (
+    `[mcp_servers.${NAMESPACE}]\n` +
     `command = "node"\n` +
-    `args = ["${mcpServer.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]\n` +
-    `${TOML_MARK_END}\n`;
+    `args = ["${mcpServer.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]\n`
+  );
+}
 
+// Fallback for when `codex mcp` is unavailable. Minimal and non-destructive:
+// never append a second entry — if a `[mcp_servers.slidemind]` already exists
+// (ours or the user's) we leave it untouched; otherwise we append our block.
+export function fallbackWriteMcpServerBlock(mcpServer) {
   const file = configTomlFile();
-  let existing = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
-  const re = new RegExp(
-    `${TOML_MARK_BEGIN}[\\s\\S]*?${TOML_MARK_END}\\n?`,
-    "g",
-  );
-  if (re.test(existing)) {
-    existing = existing.replace(re, "");
+  const existing = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+  if (existing.includes(`[mcp_servers.${NAMESPACE}]`)) {
+    return "already registered (left as-is)";
   }
-  const sep = existing.length && !existing.endsWith("\n") ? "\n\n" : existing.length ? "\n" : "";
-  fs.writeFileSync(file, existing + sep + block);
+  const sep =
+    existing.length && !existing.endsWith("\n") ? "\n\n" : existing.length ? "\n" : "";
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, existing + sep + mcpServerBlock(mcpServer));
+  return "registered (fallback)";
 }
 
-function clearMcpServerBlock() {
+// Fallback uninstall: strip a legacy marker-wrapped block if one is present;
+// otherwise point the user at `codex mcp remove` (we won't guess at the bounds
+// of a marker-less table without Codex's TOML parser).
+export function fallbackClearMcpServerBlock() {
+  const file = configTomlFile();
+  if (!fs.existsSync(file)) return "unregistered";
+  const existing = fs.readFileSync(file, "utf8");
+  const re = new RegExp(`${TOML_MARK_BEGIN}[\\s\\S]*?${TOML_MARK_END}\\n?`, "g");
+  const stripped = existing.replace(re, "");
+  if (stripped !== existing) {
+    fs.writeFileSync(file, stripped);
+    return "unregistered (fallback)";
+  }
+  return "run `codex mcp remove slidemind` to remove the entry";
+}
+
+// After Codex rewrites the `[mcp_servers.slidemind]` table, an upgrader's old
+// slidemind block can leave orphan `# slidemind:begin` / `# slidemind:end`
+// comment lines behind. Drop just those literal lines (valid TOML either way —
+// purely cosmetic).
+function sweepLegacyMarkers() {
   const file = configTomlFile();
   if (!fs.existsSync(file)) return;
-  let existing = fs.readFileSync(file, "utf8");
-  const re = new RegExp(
-    `${TOML_MARK_BEGIN}[\\s\\S]*?${TOML_MARK_END}\\n?`,
-    "g",
-  );
-  existing = existing.replace(re, "");
-  fs.writeFileSync(file, existing);
+  const before = fs.readFileSync(file, "utf8");
+  const after = before
+    .split("\n")
+    .filter(
+      (line) =>
+        line.trim() !== TOML_MARK_BEGIN && line.trim() !== TOML_MARK_END,
+    )
+    .join("\n");
+  if (after !== before) fs.writeFileSync(file, after);
 }
 
 function writeAgentsBlock() {
@@ -194,8 +262,8 @@ export async function install({ packageRoot, flags }) {
 
   // Register the slidemind MCP server so agents can list/push into open
   // PowerPoint windows via slidemind_list_open_presentations / slidemind_push_deck.
-  writeMcpServerBlock(packageRoot);
-  ui.step({ status: "ok", label: "mcp server", value: configTomlFile() });
+  const mcpNote = registerMcpServer(packageRoot);
+  ui.step({ status: "ok", label: "mcp server", value: mcpNote });
 
   ui.note("restart Codex to pick up the skill + MCP server");
 }
@@ -224,6 +292,6 @@ export async function uninstall() {
   }
   clearAgentsBlock();
   ui.step({ status: "remove", label: "AGENTS.md", value: agentsFile() });
-  clearMcpServerBlock();
-  ui.step({ status: "info", label: "mcp server", value: "unregistered" });
+  const mcpNote = unregisterMcpServer();
+  ui.step({ status: "info", label: "mcp server", value: mcpNote });
 }

package/src/mcp/server.mjs

@@ -10,10 +10,20 @@
 //     Lists PowerPoint windows registered with the local bridge, including
 //     retained entries whose task-pane socket is temporarily disconnected.
 //
+//   slidemind_read_presentation
+//     Pulls the current content of an open PowerPoint window — a per-slide
+//     outline (summary) or each slide's full plain text (raw) — so the agent can
+//     inspect the live deck before editing it.
+//
 //   slidemind_push_deck
 //     Renders a deck server-side via the add-in and pushes its slides into one
 //     open PowerPoint window.
 //
+//   slidemind_view_draft
+//     Renders the deck's authored slides to per-slide preview images locally and
+//     returns them WITHOUT pushing — the agent's "look at my own draft" check
+//     before push / the human review gate.
+//
 //   slidemind_list_engines
 //     Lists the live engine catalog (image + slide) for the active corporate
 //     design, filterable by type/subtype.
@@ -151,6 +161,9 @@ const server = new McpServer(
       "with an active corporate design is required, and all brand rules come from that " +
       "design's bundle (design.md), never hardcoded here. " +
       "Always call slidemind_list_open_presentations first to learn which presentation_id to target. " +
+      "If connection/readiness is unclear, call slidemind_connection_status before asking the user for help. " +
+      "To inspect what's already in a window before editing, call slidemind_read_presentation (summary outline or raw plain text). " +
+      "After authoring or editing slides, call slidemind_view_draft to LOOK at your own draft (per-slide images, nothing pushed) and self-correct before slidemind_push_deck. " +
       "The CLI may be paired with several add-in environments (local/dev/prod) at once; the list spans " +
       "all of them and each entry is tagged with its env, and routing to the right backend is automatic — " +
       "just pass the presentation_id back. " +
@@ -183,6 +196,85 @@ server.registerTool(
   },
 );
 
+server.registerTool(
+  "slidemind_connection_status",
+  {
+    title: "Diagnose CLI/add-in connection readiness",
+    description:
+      "Return paired backend reachability and per-window readiness. Use this when a slidemind tool fails or before asking the user for manual action.",
+    inputSchema: {},
+  },
+  async () => {
+    try {
+      const client = await loadBridgeClient();
+      const status = await client.connectionStatus();
+      return textResult({
+        paired: status.paired,
+        backendCount: status.backendCount,
+        backends: (status.backends ?? []).map((b) => ({
+          env: b.env,
+          ok: b.ok,
+          readinessV1: b.readinessV1 === true,
+          capabilities: b.capabilities ?? null,
+          error: b.error,
+          summary: b.summary ?? null,
+          presentations: (b.presentations ?? []).map(client.toPublicPresentation),
+        })),
+        presentations: (status.presentations ?? []).map(client.toPublicPresentation),
+      });
+    } catch (err) {
+      return errorResult(err);
+    }
+  },
+);
+
+server.registerTool(
+  "slidemind_read_presentation",
+  {
+    title: "Read the current content of an open presentation",
+    description:
+      "Pull the CURRENT content of an open PowerPoint window so you can inspect the live deck before editing it. " +
+      "mode='summary' returns a per-slide outline (index, layout, title, subtitle); mode='raw' (default) returns each slide's full plain text. " +
+      "This is plain text content, NOT editing markup. " +
+      "presentation_id is the presId from slidemind_list_open_presentations; it's optional when exactly one window is open, but required to disambiguate when several are open.",
+    inputSchema: {
+      presentation_id: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("presId from slidemind_list_open_presentations. Optional when only one window is open; required to pick one when several are."),
+      mode: z
+        .enum(["summary", "raw"])
+        .nullable()
+        .optional()
+        .describe("'summary' = per-slide outline; 'raw' (default) = each slide's full plain text."),
+    },
+  },
+  async ({ presentation_id, mode }) => {
+    try {
+      const client = await loadBridgeClient();
+      const registry = await client.requirePaneHost();
+      const entry = client.pickPresentationEntry(registry, presentation_id ?? null);
+      const res = await client.getPresentationContent({
+        presId: entry.presId,
+        mode: mode ?? "raw",
+        backendURL: entry.backendURL ?? null,
+      });
+      if (!res?.ok) {
+        return errorResult(new Error(res?.error ?? "read presentation failed"));
+      }
+      return textResult({
+        presentation_id: entry.presId,
+        mode: res.mode,
+        slideCount: res.slideCount,
+        slides: res.slides ?? [],
+      });
+    } catch (err) {
+      return errorResult(err);
+    }
+  },
+);
+
 server.registerTool(
   "slidemind_push_deck",
   {
@@ -316,7 +408,7 @@ server.registerTool(
       const client = await loadBridgeClient();
       // All engine tools hard-require an open host (the truth lives in the
       // add-in); surface the actionable "open PowerPoint…" message up front.
-      const registry = await client.requireHost();
+      const registry = await client.requirePaneHost();
       // The engine is per-user, not window-bound: attach to any connected window
       // when the caller didn't pin one. The chosen presId is echoed back so the
       // agent threads it to the follow-up tools (the searchId is bound to it).
@@ -412,6 +504,62 @@ server.registerTool(
   },
 );
 
+server.registerTool(
+  "slidemind_view_draft",
+  {
+    title: "Look at a deck's draft slides (no push)",
+    description:
+      "Render the deck's authored slides/*.jsx to per-slide preview images and return them to you WITHOUT pushing anything — the 'look at my own draft before the user sees it' tool. " +
+      "Use this AFTER authoring/editing slides and BEFORE slidemind_push_deck (and before the human slidemind review gate): look at each screenshot, fix anything visibly wrong in the JSX, then view again until each slide is sound. " +
+      "Renders locally against the materialized bundle, so it needs no awake task pane (and no open host at all once the bundle has been downloaded once). " +
+      "Returns one image per freeform slide; purpose-built layout slides (covers/dividers) and reused native .pptx slides have no draft preview and report as a status line. Nothing is pushed, nothing is written to the deck.",
+    inputSchema: {
+      deck_path: z
+        .string()
+        .describe("Path to the deck folder (must contain slides/). Absolute or relative to CWD."),
+      presentation_id: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Optional presId — only used to fetch the corporate-design bundle if it isn't cached yet. Omit when the deck's bundle is already materialized (the normal case after authoring)."),
+    },
+  },
+  async ({ deck_path, presentation_id }) => {
+    try {
+      const { viewDraft } = await loadBuildAndPush();
+      const deckDir = path.resolve(process.cwd(), deck_path);
+      const result = await viewDraft(deckDir, {
+        presentationId: presentation_id ?? null,
+      });
+      const images = [];
+      const lines = [];
+      for (const slide of result.slides ?? []) {
+        const image = slide.dataUri ? imageContentFromDataUri(slide.dataUri) : null;
+        if (image) {
+          images.push(image);
+          lines.push(
+            `${slide.fileName} — preview attached (image ${images.length})` +
+              (slide.status === "degraded" && slide.note ? ` — ${slide.note}` : ""),
+          );
+        } else {
+          lines.push(`${slide.fileName} — ${slide.note ?? slide.status}`);
+        }
+      }
+      const header =
+        images.length > 0
+          ? `Rendered ${images.length} draft preview image(s) — NOT pushed to PowerPoint, nothing written to the deck. ` +
+            `Judge each screenshot with your eyes, fix what is visibly wrong in the slide JSX, view the draft again, ` +
+            `then push with slidemind_push_deck (or build-pptx) once each slide is visually sound.`
+          : `No draft preview images were produced — NOTHING was pushed.`;
+      const warnLines = (result.warnings ?? []).map((w) => `  warning: ${w}`);
+      const text = [header, ...lines, ...warnLines].join("\n");
+      return { content: [{ type: "text", text }, ...images] };
+    } catch (err) {
+      return errorResult(err);
+    }
+  },
+);
+
 server.registerTool(
   "slidemind_list_engines",
   {
@@ -479,7 +627,7 @@ server.registerTool(
   async ({ presentation_id, search_id, selection }) => {
     try {
       const client = await loadBridgeClient();
-      await client.requireHost();
+      await client.requirePaneHost();
       const res = await client.viewSlide({
         presId: presentation_id,
         searchId: search_id,
@@ -532,7 +680,7 @@ server.registerTool(
   async ({ presentation_id, search_id, selections, at }) => {
     try {
       const client = await loadBridgeClient();
-      await client.requireHost();
+      await client.requirePaneHost();
       const res = await client.insertSlideLive({
         presId: presentation_id,
         searchId: search_id,
@@ -590,7 +738,7 @@ server.registerTool(
   async ({ presentation_id, deck_path, search_id, selections, at }) => {
     try {
       const client = await loadBridgeClient();
-      await client.requireHost();
+      await client.requirePaneHost();
       const deckDir = path.resolve(process.cwd(), deck_path);
       const slidesDir = path.join(deckDir, "slides");
       fs.mkdirSync(slidesDir, { recursive: true });
@@ -754,7 +902,7 @@ server.registerTool(
       }
 
       const client = await loadBridgeClient();
-      await client.requireHost();
+      await client.requirePaneHost();
       const deckDir = path.resolve(process.cwd(), deck_path);
       const assetsDir = path.join(deckDir, "assets");
       fs.mkdirSync(assetsDir, { recursive: true });