pi-repoprompt-mcp 0.5.1 → 0.5.3

package/README.md

@@ -196,6 +196,8 @@ Options:
 | `diffViewMode` | `"auto"` | Diff layout for RepoPrompt `git` / `apply_edits` fenced diff output (`auto`, `split`, `unified`) |
 | `diffSplitMinWidth` | `120` | Minimum render width before `diffViewMode: "auto"` uses split diff layout |
 | `suppressHostDisconnectedLog` | `true` | Filter noisy stderr from macOS `repoprompt-mcp` (disconnect/retry bootstrap logs) |
+| `autoLaunchApp` | `false` | Auto-launch the RepoPrompt app when the MCP server is unreachable at startup |
+| `appPath` | inferred | Explicit path to `Repo Prompt.app`; if omitted, inferred from the `.app` ancestor of `command` |
 
 Automatic tab restoration and provisioning is driven by `autoBindOnStart` and `persistBinding`; there is no separate tab-only configuration surface. Adaptive diff layout applies only to RepoPrompt `git` and `apply_edits` outputs that arrive as fenced `diff` blocks; other rendered output stays on the existing text-based path.
 
@@ -219,6 +221,10 @@ but this is best-effort
 ### Pi becomes unresponsive after closing/restarting RepoPrompt
 If the RepoPrompt MCP server stops responding (for example, if the RepoPrompt app is closed while Pi stays open), tool calls may time out. When that happens, the extension will drop the connection and you can recover with `/rp reconnect`.
 
+If RepoPrompt is not running when Pi starts, the extension auto-pauses itself after a quick connection timeout.  While paused, the `rp` tool returns a short error directing the agent to use native tools.  Run `/rp reconnect` once RepoPrompt is open to resume, and the agent will be notified that `rp` is available again.
+
+If `autoLaunchApp` is enabled, the extension will try to open the RepoPrompt app automatically before pausing.  The app path is inferred from the `command` config (e.g. `/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp` → `/Applications/Repo Prompt.app`), or you can set `appPath` explicitly.  After launching, the extension waits a few seconds and retries the connection once; if that also fails, it auto-pauses as usual.
+
 ### "No matching window found"
 - Your `cwd` may not match any RepoPrompt workspace root
 - Use `/rp windows` to list windows

package/extensions/repoprompt-mcp/src/client.ts

@@ -15,12 +15,32 @@ const CLIENT_INFO = {
   version: "1.0.0",
 };
 
+const DEFAULT_CONNECT_TIMEOUT_MS = 6_000;
 const DEFAULT_LIST_TOOLS_TIMEOUT_MS = 10_000;
 
 // Keep parity with the rp-cli integration default (15 minutes). Some RepoPrompt tools
 // (notably context_builder and chat_send) can legitimately take longer than 10s
 const DEFAULT_TOOL_CALL_TIMEOUT_MS = 15 * 60 * 1000;
 
+async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<T>((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(message));
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
 
 /**
  * Manages the MCP connection to RepoPrompt server
@@ -31,23 +51,23 @@ export class RpClient {
   private _status: ConnectionStatus = "disconnected";
   private _tools: RpToolMeta[] = [];
   private _error: string | undefined;
-  
+
   get status(): ConnectionStatus {
     return this._status;
   }
-  
+
   get tools(): RpToolMeta[] {
     return this._tools;
   }
-  
+
   get error(): string | undefined {
     return this._error;
   }
-  
+
   get isConnected(): boolean {
     return this._status === "connected" && this.client !== null;
   }
-  
+
   /**
    * Connect to the RepoPrompt MCP server
    */
@@ -59,13 +79,13 @@ export class RpClient {
     if (this._status === "connecting") {
       throw new Error("Connection already in progress");
     }
-    
+
     // Close existing connection if any
     await this.close();
-    
+
     this._status = "connecting";
     this._error = undefined;
-    
+
     try {
       // Create transport
       const mergedEnv: Record<string, string> = {};
@@ -77,36 +97,40 @@ export class RpClient {
       if (env) {
         Object.assign(mergedEnv, env);
       }
-      
+
       this.transport = new StdioClientTransport({
         command,
         args,
         env: Object.keys(mergedEnv).length > 0 ? mergedEnv : undefined,
       });
-      
+
       // Create client
       this.client = new Client(CLIENT_INFO, {
         capabilities: {},
       });
-      
+
       // Connect
-      await this.client.connect(this.transport);
-      
+      await withTimeout(
+        this.client.connect(this.transport),
+        DEFAULT_CONNECT_TIMEOUT_MS,
+        `Timed out connecting to RepoPrompt MCP server after ${DEFAULT_CONNECT_TIMEOUT_MS}ms`
+      );
+
       // Fetch available tools
       await this.refreshTools();
-      
+
       this._status = "connected";
     } catch (error) {
       this._status = "error";
       this._error = error instanceof Error ? error.message : String(error);
-      
+
       // Clean up on error
       await this.close();
-      
+
       throw error;
     }
   }
-  
+
   /**
    * Refresh the list of available tools
    */
@@ -125,7 +149,7 @@ export class RpClient {
 
     return this._tools;
   }
-  
+
   /**
    * Call a tool on the RepoPrompt MCP server
    */
@@ -187,33 +211,38 @@ export class RpClient {
       isError: Boolean(result.isError),
     };
   }
-  
+
   /**
    * Close the connection
    */
   async close(): Promise<void> {
-    if (this.client) {
+    const client = this.client;
+    const transport = this.transport;
+    const wasConnecting = this._status === "connecting";
+
+    this.client = null;
+    this.transport = null;
+    this._status = "disconnected";
+    this._tools = [];
+
+    // If connect() never completed, skip the graceful MCP close and tear down the transport directly
+    if (client && !wasConnecting) {
       try {
-        await this.client.close();
+        await client.close();
       } catch {
         // Ignore close errors
       }
-      this.client = null;
     }
 
-    if (this.transport) {
+    if (transport) {
       try {
-        await this.transport.close();
+        await transport.close();
       } catch {
         // Ignore close errors
       }
-      this.transport = null;
     }
-
-    this._status = "disconnected";
-    this._tools = [];
   }
-  
+
   /**
    * Get connection info for debugging
    */
@@ -221,7 +250,7 @@ export class RpClient {
     if (!this.client || !this.transport) {
       return null;
     }
-    
+
     return {
       client: this.client,
       transport: this.transport,

package/extensions/repoprompt-mcp/src/config.ts

@@ -250,6 +250,21 @@ function maybeWrapServerCommand(
   };
 }
 
+/**
+ * Infer the .app bundle path from an MCP server command that lives inside a .app bundle.
+ * e.g. "/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp" → "/Applications/Repo Prompt.app"
+ */
+export function inferAppPath(config: RpConfig): string | null {
+  if (config.appPath) {
+    return config.appPath;
+  }
+  if (!config.command) {
+    return null;
+  }
+  const appMatch = config.command.match(/^(.+\.app)\//i);
+  return appMatch ? appMatch[1] : null;
+}
+
 /**
  * Get the server command and args, or return null if not found
  *

package/extensions/repoprompt-mcp/src/index.ts

@@ -9,6 +9,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { execFile } from "node:child_process";
 
 import type {
   ExtensionAPI,
@@ -32,7 +33,7 @@ import type {
   AutoSelectionEntryRangeData,
 } from "./types.js";
 import { AUTO_SELECTION_ENTRY_TYPE } from "./types.js";
-import { loadConfig, getServerCommand } from "./config.js";
+import { loadConfig, getServerCommand, inferAppPath } from "./config.js";
 import { getRpClient, resetRpClient } from "./client.js";
 import {
   getBinding,
@@ -557,6 +558,8 @@ const RpToolSchema = Type.Object({
 export default function repopromptMcp(pi: ExtensionAPI) {
   let config: RpConfig = loadConfig();
   let initPromise: Promise<void> | null = null;
+  let shutdownRequested = false;
+  let extensionPaused = false;
 
   pi.on("before_agent_start", async () => {
     // Reload config so display knobs (collapsedMaxLines etc.) apply without requiring /reload
@@ -1225,6 +1228,9 @@ export default function repopromptMcp(pi: ExtensionAPI) {
   // ───────────────────────────────────────────────────────────────────────────
 
   pi.on("session_start", async (_event, ctx) => {
+    shutdownRequested = false;
+    extensionPaused = false;
+
     if (ctx.hasUI) {
       // This extension used to set a status bar item; clear it to avoid persisting stale UI state
       ctx.ui.setStatus("rp", undefined);
@@ -1244,16 +1250,45 @@ export default function repopromptMcp(pi: ExtensionAPI) {
     }
 
     // Non-blocking initialization
-    initPromise = initializeExtension(pi, ctx, config);
+    const pendingInit = initializeExtension(pi, ctx, config);
+    initPromise = pendingInit;
 
-    initPromise.then(async () => {
-      initPromise = null;
+    pendingInit.then(async () => {
+      if (initPromise === pendingInit) {
+        initPromise = null;
+      }
+      if (shutdownRequested) {
+        return;
+      }
       await syncAutoSelectionToCurrentBranch(ctx);
-    }).catch((err) => {
-      console.error("RepoPrompt MCP initialization failed:", err);
-      initPromise = null;
+    }).catch(async (err) => {
+      if (initPromise === pendingInit) {
+        initPromise = null;
+      }
+      if (shutdownRequested) {
+        return;
+      }
+      // If autoLaunchApp is enabled, try opening the app and retrying once
+      if (config.autoLaunchApp) {
+        const appPath = inferAppPath(config);
+        if (appPath) {
+          const launched = await tryLaunchApp(appPath);
+          if (launched && !shutdownRequested) {
+            try {
+              await resetRpClient();
+              await initializeExtension(pi, ctx, config);
+              await syncAutoSelectionToCurrentBranch(ctx);
+              return;
+            } catch {
+              // Fall through to pause
+            }
+          }
+        }
+      }
+
+      extensionPaused = true;
       if (ctx.hasUI) {
-        ctx.ui.notify(`RepoPrompt: ${err.message}`, "error");
+        ctx.ui.notify("RepoPrompt unavailable — extension paused. Use /rp reconnect when ready.", "warning");
       }
     });
   });
@@ -1263,14 +1298,10 @@ export default function repopromptMcp(pi: ExtensionAPI) {
   });
 
   pi.on("session_shutdown", async () => {
-    if (initPromise) {
-      try {
-        await initPromise;
-      } catch {
-        // Ignore
-      }
-    }
+    shutdownRequested = true;
+    initPromise = null;
 
+    // Never block Pi shutdown on an MCP startup handshake that may be stuck waiting on the app
     clearReadcacheCaches();
     activeAutoSelectionState = null;
     await resetRpClient();
@@ -1340,15 +1371,15 @@ export default function repopromptMcp(pi: ExtensionAPI) {
       const parts = args?.trim().split(/\s+/) ?? [];
       const subcommand = parts[0]?.toLowerCase() ?? "status";
 
-      // Allow status/readcache-status/readcache-refresh/reconnect while disconnected
-      if (
-        subcommand !== "reconnect" &&
-        subcommand !== "status" &&
-        subcommand !== "readcache-status" &&
-        subcommand !== "readcache_status" &&
-        subcommand !== "readcache-refresh" &&
-        subcommand !== "readcache_refresh"
-      ) {
+      // Allow status/reconnect while disconnected or paused
+      const alwaysAllowed = new Set(["reconnect", "status", "readcache-status", "readcache_status", "readcache-refresh", "readcache_refresh"]);
+
+      if (extensionPaused && !alwaysAllowed.has(subcommand)) {
+        ctx.ui.notify("RepoPrompt extension is paused. Use /rp reconnect to resume.", "warning");
+        return;
+      }
+
+      if (!alwaysAllowed.has(subcommand)) {
         await ensureConnected(ctx);
       }
 
@@ -1587,16 +1618,31 @@ export default function repopromptMcp(pi: ExtensionAPI) {
           break;
         }
 
-        case "reconnect":
+        case "reconnect": {
+          const wasPaused = extensionPaused;
           try {
             await resetRpClient();
+            extensionPaused = false;
             await initializeExtension(pi, ctx, config);
             await syncAutoSelectionToCurrentBranch(ctx);
             ctx.ui.notify("RepoPrompt reconnected", "info");
+
+            if (wasPaused) {
+              pi.sendMessage(
+                {
+                  customType: "rp-availability",
+                  content: "RepoPrompt (`rp` tool) is now available.",
+                  display: false,
+                },
+                { triggerTurn: false },
+              );
+            }
           } catch (err) {
+            extensionPaused = true;
             ctx.ui.notify(`Reconnection failed: ${err instanceof Error ? err.message : err}`, "error");
           }
           break;
+        }
 
         default:
           ctx.ui.notify(
@@ -1640,6 +1686,13 @@ Mode priority: call > describe > search > windows > bind > status`,
     parameters: RpToolSchema,
 
     async execute(_toolCallId, params: RpToolParams, _signal, onUpdate, _ctx) {
+      if (extensionPaused) {
+        throw new Error(
+          "The rp tool is not currently available due to a connection issue. " +
+          "The user can run /rp reconnect when the RepoPrompt app is running."
+        );
+      }
+
       // Provide a no-op if onUpdate is undefined
       const safeOnUpdate = onUpdate ?? (() => {});
 
@@ -2176,6 +2229,9 @@ Mode priority: call > describe > search > windows > bind > status`,
 
     let msg = `RepoPrompt Status\n`;
     msg += `─────────────────\n`;
+    if (extensionPaused) {
+      msg += `Extension: ⏸ paused (use /rp reconnect to resume)\n`;
+    }
     msg += `Connection: ${client.isConnected ? "✓ connected" : "✗ disconnected"}\n`;
     msg += `Tools: ${client.tools.length}\n`;
 
@@ -2919,6 +2975,26 @@ async function promptForWindowSelection(
   );
 }
 
+/**
+ * Try to launch the RepoPrompt app via `open`. Returns true if the app was launched
+ * and appears to have started (the MCP server binary exists inside the bundle).
+ */
+async function tryLaunchApp(appPath: string): Promise<boolean> {
+  if (process.platform !== "darwin") {
+    return false;
+  }
+  try {
+    await new Promise<void>((resolve, reject) => {
+      execFile("open", ["-a", appPath], (err) => (err ? reject(err) : resolve()));
+    });
+    // Give the app time to start its MCP server
+    await new Promise((resolve) => setTimeout(resolve, 4000));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function initializeExtension(
   pi: ExtensionAPI,
   ctx: ExtensionContext,

package/extensions/repoprompt-mcp/src/types.ts

@@ -124,8 +124,12 @@ export interface RpConfig {
   // (tracks read slices/full files so chat_send/"Oracle" has context without manual selection)
   autoSelectReadSlices?: boolean;  // When true, read_file calls add slices/full selection (default: true)
 
-  // /rp oracle behavior
-  oracleDefaultMode?: "chat" | "plan" | "edit" | "review"; // Default mode when /rp oracle omits --mode (default: "chat")
+    // App launch
+    autoLaunchApp?: boolean;         // Auto-launch RepoPrompt.app on connection failure (default: false)
+    appPath?: string;                // Explicit path to RepoPrompt.app (inferred from command if omitted)
+
+    // /rp oracle behavior
+    oracleDefaultMode?: "chat" | "plan" | "edit" | "review"; // Default mode when /rp oracle omits --mode (default: "chat")
 }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-repoprompt-mcp",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "A token-efficient RepoPrompt integration for Pi with automated and branch-safe workspace management",
   "keywords": ["pi-package", "pi", "pi-coding-agent", "repoprompt", "mcp"],
   "license": "MIT",