pi-repoprompt-mcp 0.5.1 → 0.5.2

package/README.md

@@ -219,6 +219,8 @@ 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.
+
 ### "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/index.ts

@@ -557,6 +557,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 +1227,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 +1249,27 @@ 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;
+      if (initPromise === pendingInit) {
+        initPromise = null;
+      }
+      if (shutdownRequested) {
+        return;
+      }
+      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 +1279,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 +1352,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 +1599,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 +1667,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 +2210,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`;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-repoprompt-mcp",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "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",