forge-remote 0.1.29 → 2.1.1

package/firestore.rules

@@ -54,12 +54,14 @@ service cloud.firestore {
                     && request.resource.data.keys().hasAll(['ownerUid', 'desktopId', 'status']);
       allow update: if isSignedIn()
                     && isValidSize();
+      allow delete: if isSignedIn();
 
       // ---- Messages (subcollection) ----
       match /messages/{messageId} {
         allow read: if isSignedIn();
         allow create: if isSignedIn()
-                      && request.resource.data.size() < 500000; // 500KB max per message
+                      && request.resource.data.size() < 500000;
+        allow delete: if isSignedIn();
       }
 
       // ---- Commands (subcollection) ----
@@ -67,22 +69,49 @@ service cloud.firestore {
         allow read: if isSignedIn();
         allow create: if isSignedIn();
         allow update: if isSignedIn();
+        allow delete: if isSignedIn();
       }
 
       // ---- Permissions (subcollection) ----
       match /permissions/{permId} {
         allow read: if isSignedIn();
         allow update: if isSignedIn();
+        allow delete: if isSignedIn();
       }
 
       // ---- Tool calls (subcollection) ----
       match /toolCalls/{toolCallId} {
         allow read: if isSignedIn();
+        allow delete: if isSignedIn();
       }
 
       // ---- Git data (subcollection) ----
       match /gitData/{docId} {
         allow read: if isSignedIn();
+        allow delete: if isSignedIn();
+      }
+
+      // ---- Builds (subcollection) ----
+      match /builds/{buildId} {
+        allow read: if isSignedIn();
+        allow delete: if isSignedIn();
+      }
+
+      // ---- Deploys (subcollection) ----
+      match /deploys/{deployId} {
+        allow read: if isSignedIn();
+        allow delete: if isSignedIn();
+      }
+
+      // ---- Build data (subcollection — project info, ADB status, deploy readiness) ----
+      match /buildData/{docId} {
+        allow read: if isSignedIn();
+      }
+
+      // ---- Session summary (subcollection) ----
+      match /summary/{docId} {
+        allow read: if isSignedIn();
+        allow delete: if isSignedIn();
       }
     }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "forge-remote",
-  "version": "0.1.29",
-  "description": "Desktop relay for Forge Remote — monitor and control Claude Code sessions from your phone",
+  "version": "2.1.1",
+  "description": "Desktop relay for Forge Remote — mobile command center for AI coding agents",
   "type": "module",
   "license": "UNLICENSED",
   "author": "Daniel Wendel <daniel@ironforgeapps.com> (https://ironforgeapps.com)",

package/src/build-manager.js

@@ -4,9 +4,52 @@
 
 import { execSync, spawn } from "child_process";
 import path from "node:path";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  statSync,
+} from "node:fs";
 import * as log from "./logger.js";
 
+/**
+ * Resolve a path that may contain glob patterns (e.g., *.ipa) to an actual file.
+ * Returns the resolved absolute path, or the original if no glob.
+ */
+function resolveGlobPath(basePath, filePath) {
+  const fullPath = path.isAbsolute(filePath)
+    ? filePath
+    : path.join(basePath, filePath);
+
+  if (!fullPath.includes("*")) {
+    return fullPath;
+  }
+
+  // Manual glob resolution for simple *.ext patterns
+  const dir = path.dirname(fullPath);
+  const pattern = path.basename(fullPath);
+
+  if (!existsSync(dir)) return fullPath;
+
+  const ext = pattern.replace("*", "");
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(ext));
+    if (files.length > 0) {
+      // Return the most recently modified file
+      const resolved = files
+        .map((f) => {
+          const p = path.join(dir, f);
+          return { name: f, path: p, mtime: statSync(p).mtimeMs };
+        })
+        .sort((a, b) => b.mtime - a.mtime)[0];
+      return resolved.path;
+    }
+  } catch {}
+
+  return fullPath;
+}
+
 // ---------------------------------------------------------------------------
 // Project Detection
 // ---------------------------------------------------------------------------
@@ -179,14 +222,40 @@ export async function runBuild(projectPath, platform, onOutput) {
   const outputLines = [];
 
   return new Promise((resolve, reject) => {
-    const [cmd, ...args] = buildCmd.split(" ");
-    const proc = spawn(cmd, args, {
+    // Use login shell with full Xcode environment for iOS builds.
+    const shell = process.env.SHELL || "/bin/zsh";
+    const buildEnv = {
+      ...process.env,
+      // Ensure Xcode tools are available
+      DEVELOPER_DIR:
+        process.env.DEVELOPER_DIR ||
+        "/Applications/Xcode.app/Contents/Developer",
+    };
+    // For iOS builds, run flutter clean first to avoid stale storyboard caches
+    const fullCmd =
+      platform === "ios"
+        ? `flutter clean > /dev/null 2>&1; ${buildCmd}`
+        : buildCmd;
+    const proc = spawn(shell, ["-l", "-c", fullCmd], {
       cwd: projectPath,
-      shell: true,
-      env: { ...process.env },
+      env: buildEnv,
       stdio: ["pipe", "pipe", "pipe"],
     });
 
+    // Timeout: 10 minutes max for any build
+    const buildTimeout = setTimeout(() => {
+      log.warn(`Build timed out after 10 minutes: ${buildCmd}`);
+      try {
+        proc.kill("SIGTERM");
+      } catch {}
+      setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {}
+      }, 5000);
+      reject(new Error(`Build timed out after 10 minutes`));
+    }, 600000);
+
     proc.stdout.on("data", (data) => {
       const text = data.toString();
       for (const line of text.split("\n")) {
@@ -209,7 +278,13 @@ export async function runBuild(projectPath, platform, onOutput) {
       }
     });
 
+    proc.on("error", (err) => {
+      clearTimeout(buildTimeout);
+      reject(new Error(`Build process error: ${err.message}`));
+    });
+
     proc.on("close", (code) => {
+      clearTimeout(buildTimeout);
       const duration = Math.round((Date.now() - startTime) / 1000);
       const outputPath =
         projectInfo.outputPaths[platform] ||
@@ -307,11 +382,59 @@ export async function deployToAppDistribution(
   buildPath,
   options = {},
 ) {
-  const { projectId, groups, testers, releaseNotes } = options;
+  const { projectId, appId, groups, testers, releaseNotes } = options;
 
   assertCliAvailable("firebase");
 
-  let cmd = `firebase appdistribution:distribute "${buildPath}"`;
+  // Resolve glob patterns (e.g., build/ios/ipa/*.ipa → actual filename)
+  const resolvedPath = resolveGlobPath(projectPath, buildPath);
+  if (!existsSync(resolvedPath)) {
+    throw new Error(`Build artifact not found: ${resolvedPath}`);
+  }
+  log.info(`Resolved build path: ${resolvedPath}`);
+
+  // Auto-detect Firebase App ID if not provided
+  let detectedAppId = appId;
+  if (!detectedAppId) {
+    // Try GoogleService-Info.plist (iOS)
+    if (resolvedPath.endsWith(".ipa")) {
+      const plistPath = path.join(
+        projectPath,
+        "ios/Runner/GoogleService-Info.plist",
+      );
+      if (existsSync(plistPath)) {
+        try {
+          const plist = readFileSync(plistPath, "utf-8");
+          const match = plist.match(
+            /<key>GOOGLE_APP_ID<\/key>\s*<string>([^<]+)<\/string>/,
+          );
+          if (match) detectedAppId = match[1];
+        } catch {}
+      }
+    }
+    // Try google-services.json (Android)
+    if (resolvedPath.endsWith(".apk") || resolvedPath.endsWith(".aab")) {
+      const jsonPath = path.join(
+        projectPath,
+        "android/app/google-services.json",
+      );
+      if (existsSync(jsonPath)) {
+        try {
+          const gs = JSON.parse(readFileSync(jsonPath, "utf-8"));
+          detectedAppId = gs.client?.[0]?.client_info?.mobilesdk_app_id;
+        } catch {}
+      }
+    }
+  }
+
+  if (!detectedAppId) {
+    throw new Error(
+      "Firebase App ID not found. Add GoogleService-Info.plist (iOS) or google-services.json (Android) to the project, or pass appId in the command payload.",
+    );
+  }
+
+  log.info(`Using Firebase App ID: ${detectedAppId}`);
+  let cmd = `firebase appdistribution:distribute "${resolvedPath}" --app "${detectedAppId}"`;
 
   if (projectId) cmd += ` --project ${projectId}`;
   if (groups) cmd += ` --groups "${groups}"`;
@@ -321,17 +444,52 @@ export async function deployToAppDistribution(
     cmd += ` --release-notes "${escaped}"`;
   }
 
-  log.info(`Distributing build via App Distribution: ${buildPath}`);
+  // Auto-add the device owner as a tester if no testers/groups specified
+  if (!groups && !testers) {
+    // Try to get the Firebase auth email
+    try {
+      const authEmail = execSync("firebase login:list 2>/dev/null", {
+        timeout: 5000,
+        encoding: "utf-8",
+      });
+      const emailMatch = authEmail.match(/[\w.-]+@[\w.-]+\.\w+/);
+      if (emailMatch) {
+        cmd += ` --testers "${emailMatch[0]}"`;
+        log.info(`Auto-adding tester: ${emailMatch[0]}`);
+      }
+    } catch {}
+  }
+
+  log.info(`Distributing build via App Distribution: ${resolvedPath}`);
 
   const result = execSync(cmd, {
     cwd: projectPath,
-    timeout: 300_000, // 5 min for large APKs/IPAs
+    timeout: 300_000,
     encoding: "utf-8",
     env: { ...process.env },
   });
 
+  // Try to extract the testing URI from the output
+  // Firebase CLI outputs: "View this release in the Firebase console: <url>"
+  const consoleUrlMatch = result.match(
+    /(?:View this release.*?|Firebase console.*?)(https:\/\/console\.firebase\.google\.com[^\s]+)/i,
+  );
+  // Also look for the tester download link
+  const testerUrlMatch = result.match(
+    /(https:\/\/appdistribution\.firebase\.google\.com[^\s]+)/i,
+  );
+  // Firebase App Tester — the user needs to open the App Tester app
+  // on their device to download. The console URL lets them manage releases.
+  const appTesterUrl = "https://appdistribution.firebase.google.com/testerapps";
+
   log.info("App Distribution upload complete");
-  return { output: result };
+  return {
+    output: result,
+    consoleUrl: consoleUrlMatch?.[1] || null,
+    testerUrl: testerUrlMatch?.[1] || null,
+    appTesterUrl,
+    appId: detectedAppId,
+  };
 }
 
 // ---------------------------------------------------------------------------

package/src/session-manager.js

@@ -447,13 +447,22 @@ function watchSessionCommands(sessionId) {
   activeSessions.set(`cmd-watcher-${sessionId}`, true);
 
   const db = getDb();
+  console.log(
+    `[DEBUG] watchSessionCommands: watching session ${sessionId.slice(0, 8)}`,
+  );
   db.collection("sessions")
     .doc(sessionId)
     .collection("commands")
     .where("status", "==", "pending")
     .onSnapshot((snap) => {
+      console.log(
+        `[DEBUG] commands snapshot for ${sessionId.slice(0, 8)}: ${snap.docChanges().length} changes`,
+      );
       for (const change of snap.docChanges()) {
         if (change.type === "added") {
+          console.log(
+            `[DEBUG] pending command: ${change.doc.data().type} for ${sessionId.slice(0, 8)}`,
+          );
           handleSessionCommand(sessionId, change.doc);
         }
       }
@@ -492,6 +501,10 @@ async function handleSessionCommand(sessionId, commandDoc) {
   const data = commandDoc.data();
   if (data.status !== "pending") return;
 
+  console.log(
+    `[DEBUG] handleSessionCommand: type=${data.type} session=${sessionId.slice(0, 8)} cmdId=${commandDoc.id.slice(0, 8)}`,
+  );
+
   const db = getDb();
   const cmdRef = db
     .collection("sessions")
@@ -533,6 +546,21 @@ async function handleSessionCommand(sessionId, commandDoc) {
 
   await cmdRef.update({ status: "processing" });
 
+  // Helper: get session info from activeSessions or fall back to Firestore.
+  // Needed for build/deploy/git commands that can run on non-relay sessions.
+  async function getSessionInfo() {
+    const local = activeSessions.get(sessionId);
+    if (local) return local;
+    const doc = await db.collection("sessions").doc(sessionId).get();
+    if (!doc.exists) throw new Error("Session not found");
+    const d = doc.data();
+    return {
+      projectPath: d.projectPath,
+      projectName: d.projectName,
+      desktopId: d.desktopId,
+    };
+  }
+
   try {
     switch (data.type) {
       case "send_prompt":
@@ -689,9 +717,15 @@ async function handleSessionCommand(sessionId, commandDoc) {
 
       case "detect_project": {
         log.command("detect_project", sessionId.slice(0, 8));
-        const sess = activeSessions.get(sessionId);
-        if (!sess) throw new Error("Session not found");
+        const sess = await getSessionInfo();
+        console.log(
+          `[DEBUG] detect_project: projectPath="${sess.projectPath}"`,
+        );
         const projectInfo = detectProjectType(sess.projectPath);
+        console.log(
+          `[DEBUG] detect_project: result=`,
+          JSON.stringify(projectInfo),
+        );
         await db
           .collection("sessions")
           .doc(sessionId)
@@ -707,8 +741,7 @@ async function handleSessionCommand(sessionId, commandDoc) {
       case "build_project": {
         const platform = data.payload?.platform || "web";
         log.command("build_project", `${sessionId.slice(0, 8)} [${platform}]`);
-        const sess = activeSessions.get(sessionId);
-        if (!sess) throw new Error("Session not found");
+        const sess = await getSessionInfo();
 
         // Create a build record with status: building
         const buildRef = db
@@ -727,7 +760,10 @@ async function handleSessionCommand(sessionId, commandDoc) {
           const result = await runBuild(
             sess.projectPath,
             platform,
-            (line, _stream) => {
+            (line, stream) => {
+              // Log build output to relay console
+              const prefix = stream === "stderr" ? "⚠" : "▸";
+              console.log(`  ${prefix} [build] ${line}`);
               // Stream latest output line to Firestore (best-effort)
               buildRef
                 .update({
@@ -767,8 +803,7 @@ async function handleSessionCommand(sessionId, commandDoc) {
 
       case "deploy_hosting": {
         log.command("deploy_hosting", sessionId.slice(0, 8));
-        const sess = activeSessions.get(sessionId);
-        if (!sess) throw new Error("Session not found");
+        const sess = await getSessionInfo();
 
         const deployRef = db
           .collection("sessions")
@@ -821,8 +856,7 @@ async function handleSessionCommand(sessionId, commandDoc) {
 
       case "deploy_app_dist": {
         log.command("deploy_app_dist", sessionId.slice(0, 8));
-        const sess = activeSessions.get(sessionId);
-        if (!sess) throw new Error("Session not found");
+        const sess = await getSessionInfo();
 
         const deployRef = db
           .collection("sessions")
@@ -844,15 +878,23 @@ async function handleSessionCommand(sessionId, commandDoc) {
           const testers = data.payload?.testers;
           const releaseNotes = data.payload?.releaseNotes;
 
-          await deployToAppDistribution(sess.projectPath, buildPath, {
-            projectId,
-            groups,
-            testers,
-            releaseNotes,
-          });
+          const distResult = await deployToAppDistribution(
+            sess.projectPath,
+            buildPath,
+            {
+              projectId,
+              groups,
+              testers,
+              releaseNotes,
+            },
+          );
 
           await deployRef.update({
             status: "success",
+            consoleUrl: distResult.consoleUrl || null,
+            testerUrl: distResult.testerUrl || null,
+            appTesterUrl: distResult.appTesterUrl || null,
+            appId: distResult.appId || null,
             completedAt: FieldValue.serverTimestamp(),
           });
 
@@ -930,8 +972,7 @@ async function handleSessionCommand(sessionId, commandDoc) {
 
       case "check_deploy_ready": {
         log.command("check_deploy_ready", sessionId.slice(0, 8));
-        const sess = activeSessions.get(sessionId);
-        if (!sess) throw new Error("Session not found");
+        const sess = await getSessionInfo();
         const report = checkDeployReadiness(sess.projectPath);
         await db
           .collection("sessions")
@@ -962,8 +1003,7 @@ async function handleSessionCommand(sessionId, commandDoc) {
 
       case "init_firebase_hosting": {
         log.command("init_firebase_hosting", sessionId.slice(0, 8));
-        const sess = activeSessions.get(sessionId);
-        if (!sess) throw new Error("Session not found");
+        const sess = await getSessionInfo();
         const projectId = data.payload?.projectId;
         const publicDir = data.payload?.publicDir || "build/web";
         if (!projectId) throw new Error("projectId is required");