forge-remote 0.1.10 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-remote",
-  "version": "0.1.10",
+  "version": "0.1.13",
   "description": "Desktop relay for Forge Remote — monitor and control Claude Code sessions from your phone",
   "type": "module",
   "license": "UNLICENSED",

package/src/init.js

@@ -2,7 +2,7 @@
 // Copyright (c) 2025-2026 Iron Forge Apps
 // Created by Daniel Wendel, CEO/Founder of Iron Forge Apps
 
-import { execSync, execFileSync } from "child_process";
+import { execSync, execFileSync, spawn } from "child_process";
 import { createInterface } from "readline";
 import { hostname, platform, homedir } from "os";
 import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "fs";
@@ -119,14 +119,24 @@ function waitForEnter(message) {
 
 /**
  * Open a URL in the default browser (best-effort, no throw).
+ * Uses spawn + detach to avoid blocking or suspending the terminal.
  */
 function openBrowser(url) {
   const p = platform();
   try {
-    if (p === "darwin") execFileSync("open", [url], { stdio: "pipe" });
-    else if (p === "win32")
-      execFileSync("cmd", ["/c", "start", "", url], { stdio: "pipe" });
-    else execFileSync("xdg-open", [url], { stdio: "pipe" });
+    let cmd, args;
+    if (p === "darwin") {
+      cmd = "open";
+      args = [url];
+    } else if (p === "win32") {
+      cmd = "cmd";
+      args = ["/c", "start", "", url];
+    } else {
+      cmd = "xdg-open";
+      args = [url];
+    }
+    const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+    child.unref();
   } catch {
     // Silently fail — URL is always printed for manual opening.
   }

package/src/session-manager.js

@@ -597,6 +597,7 @@ async function sendFollowUpPrompt(sessionId, prompt) {
     session.permissionWatcher = null;
   }
   session.permissionNeeded = false;
+  session.deniedToolCall = null;
 
   // Store the user's message in Firestore.
   const db = getDb();
@@ -625,6 +626,7 @@ async function runClaudeProcess(sessionId, prompt) {
 
   // Reset permission state for this new turn.
   session.permissionNeeded = false;
+  session.deniedToolCall = null;
   session.lastToolCall = null;
 
   const db = getDb();
@@ -719,7 +721,11 @@ async function runClaudeProcess(sessionId, prompt) {
   // ── Parse stdout (stream-json) ──
   let stdoutBuffer = "";
 
-  claudeProcess.stdout.on("data", async (data) => {
+  // Track pending async data processing so the close handler can wait for it.
+  // Without this, the close event can fire before permission detection completes.
+  let pendingDataProcessing = Promise.resolve();
+
+  claudeProcess.stdout.on("data", (data) => {
     if (!receivedOutput) {
       receivedOutput = true;
       clearTimeout(watchdog);
@@ -727,40 +733,50 @@ async function runClaudeProcess(sessionId, prompt) {
       log.session(sessionId, "First output received from Claude");
     }
 
-    stdoutBuffer += data.toString();
-    const lines = stdoutBuffer.split("\n");
-    stdoutBuffer = lines.pop();
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const event = JSON.parse(line);
-        await handleStreamEvent(sessionId, sessionRef, event);
-      } catch {
-        if (line.trim()) {
-          const text = line.trim();
-          log.claudeOutput(sessionId, text);
-
-          // Detect auth / login errors that come as plain text.
-          if (/not logged in|please run.*login/i.test(text)) {
-            log.error(
-              `[${sessionId.slice(0, 8)}] Claude CLI auth error: ${text}`,
-            );
-            await db
-              .collection("sessions")
-              .doc(sessionId)
-              .collection("messages")
-              .add({
-                type: "system",
-                content: `Auth error: ${text}. Run "claude /login" in your terminal, then restart the relay.`,
-                timestamp: FieldValue.serverTimestamp(),
-              });
-          } else {
-            await storeAssistantMessage(sessionId, text);
+    // Chain onto the pending processing promise to ensure sequential handling
+    // AND to let the close handler wait for all processing to finish.
+    pendingDataProcessing = pendingDataProcessing
+      .then(async () => {
+        stdoutBuffer += data.toString();
+        const lines = stdoutBuffer.split("\n");
+        stdoutBuffer = lines.pop();
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            await handleStreamEvent(sessionId, sessionRef, event);
+          } catch {
+            if (line.trim()) {
+              const text = line.trim();
+              log.claudeOutput(sessionId, text);
+
+              // Detect auth / login errors that come as plain text.
+              if (/not logged in|please run.*login/i.test(text)) {
+                log.error(
+                  `[${sessionId.slice(0, 8)}] Claude CLI auth error: ${text}`,
+                );
+                await db
+                  .collection("sessions")
+                  .doc(sessionId)
+                  .collection("messages")
+                  .add({
+                    type: "system",
+                    content: `Auth error: ${text}. Run "claude /login" in your terminal, then restart the relay.`,
+                    timestamp: FieldValue.serverTimestamp(),
+                  });
+              } else {
+                await storeAssistantMessage(sessionId, text);
+              }
+            }
           }
         }
-      }
-    }
+      })
+      .catch((err) => {
+        log.error(
+          `[${sessionId.slice(0, 8)}] Error processing stdout: ${err.message}`,
+        );
+      });
   });
 
   // ── Stderr ──
@@ -800,6 +816,12 @@ async function runClaudeProcess(sessionId, prompt) {
   claudeProcess.on("close", async (code, signal) => {
     clearTimeout(watchdog);
     clearTimeout(killTimer);
+
+    // Wait for all pending stdout data processing to complete before checking
+    // permission state. Without this, the close event can race ahead of the
+    // async data handler, causing permissionNeeded to still be false.
+    await pendingDataProcessing;
+
     log.session(
       sessionId,
       `Process exited — code: ${code}, signal: ${signal}, PID: ${claudeProcess.pid}`,
@@ -826,11 +848,14 @@ async function runClaudeProcess(sessionId, prompt) {
     if (sess) sess.process = null; // Clear process so follow-ups can spawn.
 
     if (code === 0) {
-      if (sess?.permissionNeeded && sess?.lastToolCall) {
+      // Use deniedToolCall (frozen at detection time) so subsequent tool calls
+      // don't overwrite the permission target. Fall back to lastToolCall.
+      const toolForPermission = sess?.deniedToolCall || sess?.lastToolCall;
+      if (sess?.permissionNeeded && toolForPermission) {
         // Claude was denied a tool call — create a permission request and wait.
         const permDocId = await createPermissionRequest(
           sessionId,
-          sess.lastToolCall,
+          toolForPermission,
         );
         await sessionRef.update({
           status: "waiting_permission",
@@ -1218,15 +1243,21 @@ async function handleStreamEvent(sessionId, sessionRef, event) {
 
 // Patterns that indicate Claude was denied permission for a tool call.
 const PERMISSION_PATTERNS = [
-  /need your approval/i,
-  /permission (?:required|denied|blocked)/i,
-  /could you approve/i,
+  /need(?:s|ing)? your approval/i,
+  /awaiting your approval/i,
+  /permission (?:required|denied|blocked|pending)/i,
+  /could you.{0,10}approve/i,
+  /please.{0,10}approve/i,
   /keeps? getting blocked/i,
   /permission system/i,
   /being blocked by/i,
-  /approve the command/i,
+  /approve the (?:command|tool|action|edit)/i,
   /blocked by.+permission/i,
   /can'?t (?:execute|run).+(?:permission|approval)/i,
+  /stuck on permission/i,
+  /permission.{0,20}(?:is |still )?pending/i,
+  /waiting for.{0,15}(?:permission|approval)/i,
+  /need(?:s|ed)? (?:to be )?approv/i,
 ];
 
 async function storeAssistantMessage(sessionId, text) {
@@ -1241,10 +1272,13 @@ async function storeAssistantMessage(sessionId, text) {
   });
 
   // Check if Claude's message indicates a permission denial.
+  // Save the denied tool call separately so subsequent tool calls don't
+  // overwrite it — the permission request must be for the denied tool.
   if (session?.lastToolCall && !session.permissionNeeded) {
     for (const pattern of PERMISSION_PATTERNS) {
       if (pattern.test(text)) {
         session.permissionNeeded = true;
+        session.deniedToolCall = { ...session.lastToolCall };
         log.info(
           `[${sessionId.slice(0, 8)}] Permission denial detected for ${session.lastToolCall.name}`,
         );
@@ -1817,8 +1851,9 @@ async function handlePermissionApproved(sessionId, permData) {
   const session = activeSessions.get(sessionId);
   if (!session) return;
 
-  const toolCall = session.lastToolCall;
+  const toolCall = session.deniedToolCall || session.lastToolCall;
   session.permissionNeeded = false;
+  session.deniedToolCall = null;
 
   log.success(
     `[${sessionId.slice(0, 8)}] Permission approved for ${permData.toolName}`,
@@ -1863,6 +1898,7 @@ async function handlePermissionDenied(sessionId) {
   if (!session) return;
 
   session.permissionNeeded = false;
+  session.deniedToolCall = null;
   session.lastToolCall = null;
 
   log.info(`[${sessionId.slice(0, 8)}] Permission denied`);