slidemind 0.1.4 → 0.1.5

package/bin/slidemind.mjs

@@ -336,15 +336,20 @@ async function cmdSearch(rest) {
     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. The answering window
+  // (res.presId) is what reuse must target — the searchId is bound to it.
+  const res = await client.engineSearchAnyPane({
+    registry,
+    explicitPresId: to,
     engineId,
     query,
     subtype,
     intent: intent ?? null,
     top: top ?? null,
-    backendURL,
   });
+  const ranPresId = res?.presId ?? presId;
+  const ranEntry = registry.find((p) => p.presId === ranPresId) ?? entry;
   if (asJson) {
     process.stdout.write(`${JSON.stringify(res, null, 2)}\n`);
     return;
@@ -387,14 +392,14 @@ async function cmdSearch(rest) {
   // add-ins that don't echo a top-level subtype.
   const isSlideResults =
     res.subtype === "slide" || results.some((r) => r.kind === "slide");
-  const envTag = entry.env ? ` [${entry.env}]` : "";
+  const envTag = ranEntry.env ? ` [${ranEntry.env}]` : "";
   if (isSlideResults) {
     // The searchId is bound to the window the search ran on — reuse must target
     // that same window, so spell out its presId in the next-step commands.
     process.stdout.write(
-      `searchId ${res.searchId} ran on window ${presId}${envTag} — reuse from THIS window:\n` +
-        `  slidemind insert-slide --search ${res.searchId} --pick <n> --to ${presId}\n` +
-        `  slidemind add-slide --search ${res.searchId} --pick <n> --deck <deck> --to ${presId}\n`,
+      `searchId ${res.searchId} ran on window ${ranPresId}${envTag} — reuse from THIS window:\n` +
+        `  slidemind insert-slide --search ${res.searchId} --pick <n> --to ${ranPresId}\n` +
+        `  slidemind add-slide --search ${res.searchId} --pick <n> --deck <deck> --to ${ranPresId}\n`,
     );
   } else {
     process.stdout.write(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slidemind",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Connect Claude Code, Codex & opencode to the slidemind PowerPoint add-in — let your coding agent build and edit native, on-brand PowerPoint decks against your active corporate design, from the terminal.",
   "type": "module",
   "bin": {

package/src/bridge/client.mjs

@@ -28,6 +28,19 @@ function listTimeoutMs() {
   );
 }
 
+// Engine ops (list / search / download / extract) are RELAYED through the task
+// pane: the server waits up to ~25s for a suspended pane to reconnect, then up
+// to 60s for the pane's ack. Budget above that sum so a typed pane error
+// (pane_suspended / pane_timeout) wins over a client timeout. Note `ls engines`
+// is pane-relayed too — using the 8s list timeout there masked the real
+// pane_suspended as a bare "timed out after 8000ms".
+function engineTimeoutMs() {
+  return (
+    parseInt(process.env.SLIDEMIND_BRIDGE_ENGINE_TIMEOUT_MS || "90000", 10) ||
+    90000
+  );
+}
+
 const NOT_PAIRED_MESSAGE =
   'slidemind is not paired. In the slidemind add-in, click "Connect CLI" ' +
   "and run the shown `slidemind pair …` command, then retry.";
@@ -483,7 +496,9 @@ async function listEnginesForBackend(backendURL, { type = null, subtype = null }
     const qs = params.toString();
     const res = await bridgeFetch(
       `/api/cli/engines${qs ? `?${qs}` : ""}`,
-      { timeoutMs: listTimeoutMs() },
+      // Pane-relayed on the add-in side — needs the engine budget, not the 8s
+      // list timeout (which bailed before the pane could ever answer).
+      { timeoutMs: engineTimeoutMs() },
       backendURL,
     );
     const data = await res.json();
@@ -837,6 +852,11 @@ export async function engineSearch({
   intent = null,
   top = null,
   backendURL = null,
+  // When the chosen pane is suspended, wait CLIENT-side for THIS window to wake
+  // (the single-window default). engineSearchAnyPane sets this false for all but
+  // the last candidate so it can fail over to another live window instead.
+  waitOnSuspend = true,
+  timeoutMs = null,
 }) {
   if (!presId) throw new Error("engineSearch: presId is required");
   if (!engineId) throw new Error("engineSearch: engineId is required");
@@ -846,24 +866,96 @@ export async function engineSearch({
   if (subtype) body.subtype = subtype;
   if (intent) body.intent = intent;
   if (typeof top === "number") body.top = top;
-  return engineOpWithPaneWait(presId, be, async (pid, b) => {
+  const run = async (pid, b) => {
     const res = await bridgeFetch(
       `/api/cli/presentations/${encodeURIComponent(pid)}/engine/search`,
       {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify(body),
-        // Engine ops relay through the pane: the server may wait up to ~25s for
-        // a suspended pane to reconnect, then up to 60s for the pane's ack —
-        // stay above that sum so typed errors win over client timeouts.
-        timeoutMs:
-          parseInt(process.env.SLIDEMIND_BRIDGE_ENGINE_TIMEOUT_MS || "90000", 10) ||
-          90000,
+        timeoutMs: timeoutMs ?? engineTimeoutMs(),
       },
       b,
     );
     return res.json(); // { ok, searchId, engineId, subtype, intent, resultCount, gridDataUri?, results }
-  });
+  };
+  return waitOnSuspend ? engineOpWithPaneWait(presId, be, run) : run(presId, be);
+}
+
+// A suspended/throttled background webview must not strand a window-AGNOSTIC
+// engine search: the catalog is per-user, so any connected pane can answer it.
+// Try the picked pane first, then every other connected pane on the same
+// backend (non-suspended first), failing fast past each unresponsive one; the
+// LAST candidate keeps the normal "click the pane to wake it" wait so a genuine
+// single-window/all-asleep case still surfaces the actionable prompt. Returns
+// the search result tagged with the presId/backendURL that actually answered —
+// the searchId is bound to THAT window, so callers must thread it into
+// follow-up view/insert/add-slide. An explicit presId pins the window (no
+// failover — the caller asked for that specific one).
+export async function engineSearchAnyPane({
+  registry,
+  explicitPresId = null,
+  engineId,
+  query,
+  subtype = null,
+  intent = null,
+  top = null,
+}) {
+  const primary = pickAnyPresentationEntry(registry, explicitPresId);
+  const primaryBackend = primary.backendURL ?? null;
+  let candidates;
+  if (explicitPresId) {
+    candidates = [primary];
+  } else {
+    const others = (Array.isArray(registry) ? registry : [])
+      .filter(
+        (p) =>
+          p.presId !== primary.presId &&
+          p.connected !== false &&
+          (p.backendURL ?? null) === primaryBackend,
+      )
+      .sort((a, b) => (a.suspendedAt ? 1 : 0) - (b.suspendedAt ? 1 : 0));
+    candidates = [primary, ...others];
+  }
+  const failoverTimeout = envInt(
+    "SLIDEMIND_BRIDGE_ENGINE_FAILOVER_TIMEOUT_MS",
+    25000,
+  );
+  let lastErr = null;
+  for (let i = 0; i < candidates.length; i++) {
+    const cand = candidates[i];
+    const isLast = i === candidates.length - 1;
+    try {
+      const res = await engineSearch({
+        presId: cand.presId,
+        engineId,
+        query,
+        subtype,
+        intent,
+        top,
+        backendURL: cand.backendURL ?? primaryBackend,
+        waitOnSuspend: isLast,
+        timeoutMs: isLast ? null : failoverTimeout,
+      });
+      return {
+        ...res,
+        presId: cand.presId,
+        backendURL: cand.backendURL ?? primaryBackend,
+      };
+    } catch (err) {
+      lastErr = err;
+      // A suspended/frozen/slow pane is recoverable by trying the next window;
+      // anything else (bad engineId, auth, 4xx) is real — surface it now.
+      const recoverable =
+        err?.code === "pane_suspended" ||
+        err?.code === "pane_timeout" ||
+        err?.code === "bridge_timeout" ||
+        err?.status === 503 ||
+        err?.status === 504;
+      if (isLast || !recoverable) throw err;
+    }
+  }
+  throw lastErr ?? new Error("engineSearchAnyPane: no candidate panes");
 }
 
 // Fetch a chosen engine result's bytes through the local bridge. For image

package/src/mcp/server.mjs

@@ -353,15 +353,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 +390,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,