slidemind 0.1.4 → 0.1.6

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).
@@ -353,15 +445,20 @@ server.registerTool(
         engineId = pick.id;
         subtype = "image";
       }
-      const res = await client.engineSearch({
-        presId,
+      // Window-agnostic: tries the picked pane, then fails over to any other
+      // live window on the same backend if it's suspended/frozen. res.presId is
+      // the window that actually answered — echo THAT back (the searchId is
+      // bound to it) so follow-up view/insert/add target the right pane.
+      const res = await client.engineSearchAnyPane({
+        registry,
+        explicitPresId: presentation_id ?? null,
         engineId,
         query,
         subtype,
         intent: intent ?? null,
         top: top ?? null,
-        backendURL,
       });
+      const ranPresId = res?.presId ?? presId;
       const content = [];
       const grid = imageContentFromDataUri(res?.gridDataUri);
       if (grid) content.push(grid);
@@ -385,9 +482,10 @@ server.registerTool(
           {
             ok: res?.ok ?? false,
             // The window the search ran on (auto-attached when the caller didn't
-            // pin one). The searchId is bound to it — pass this presentation_id
-            // to slidemind_view_slide / _insert_slide / _add_slide_to_deck.
-            presentation_id: presId,
+            // pin one; may have failed over from the picked pane). The searchId
+            // is bound to it — pass this presentation_id to slidemind_view_slide
+            // / _insert_slide / _add_slide_to_deck.
+            presentation_id: ranPresId,
             engineId,
             subtype: res?.subtype ?? null,
             intent: res?.intent ?? null,
@@ -406,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",
   {
@@ -473,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,
@@ -526,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,
@@ -584,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 });
@@ -748,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 });