forge-remote 2.1.6 → 2.2.0

package/src/cli.js

@@ -12,7 +12,7 @@ import { hostname, homedir } from "os";
 import qrcode from "qrcode-terminal";
 
 import { runInit } from "./init.js";
-import { initFirebase, getDb } from "./firebase.js";
+import { initFirebase } from "./firebase.js";
 import {
   registerDesktop,
   markOffline,
@@ -32,19 +32,13 @@ import { stopAllCaptures } from "./screenshot-manager.js";
 import { scanProjects } from "./project-scanner.js";
 import { startWebhookServer, stopWebhookServer } from "./webhook-server.js";
 import { watchWebhookConfigs, stopWatching } from "./webhook-watcher.js";
+import {
+  startClaudeSessionWatcher,
+  stopClaudeSessionWatcher,
+} from "./claude-session-watcher.js";
 import * as log from "./logger.js";
 import { checkForUpdate } from "./update-checker.js";
 import { deployFirestoreRules } from "./google-auth.js";
-import { pairWithCloud } from "./cloud-mode.js";
-import { watchMobileAiRequests } from "./mobile-ai-watcher.js";
-import {
-  saveTestflightCreds,
-  openXcodeSigning,
-  checkIosReadiness,
-} from "./ios-setup.js";
-import { readFile as fsReadFile } from "node:fs/promises";
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
 // Channel auto-registration disabled — channels require
 // --dangerously-load-development-channels flag during research preview.
 // import { ensureChannelRegistered } from "./channel-setup.js";
@@ -174,30 +168,8 @@ program
   .description(
     "Start the desktop relay (register, heartbeat, listen for commands)",
   )
-  .option("--cloud", "Use Forge Remote Cloud (managed mode) instead of BYOF")
-  .action(async (opts) => {
+  .action(async () => {
     await checkForUpdate();
-
-    if (opts.cloud) {
-      // Managed mode — pair via 6-digit code, then run a minimal loop
-      // that streams sessions to the cloud project. The full cloud
-      // session-manager is wired up once auth + pairing land.
-      try {
-        const { userUid, desktopId } = await pairWithCloud();
-        log.success(`Cloud relay running for ${userUid} (${desktopId})`);
-        log.info(
-          "Cloud session-manager streaming is wired in a follow-up — " +
-            "pair-only mode for now.",
-        );
-        // Keep the process alive so the user can Ctrl+C to exit.
-        await new Promise(() => {});
-      } catch (e) {
-        log.error(e.message);
-        process.exit(1);
-      }
-      return;
-    }
-
     initFirebase();
     const desktopId = await registerDesktop();
 
@@ -225,25 +197,6 @@ program
 
     listenForCommands(desktopId);
 
-    // Start the Mobile AI watcher so the phone's "Ask Claude" features
-    // can route through this relay (using the local Claude subscription).
-    let stopMobileAi = () => {};
-    try {
-      const desktopDoc = await getDb()
-        .collection("desktops")
-        .doc(desktopId)
-        .get();
-      const ownerUid = desktopDoc.data()?.ownerUid;
-      if (ownerUid) {
-        stopMobileAi = watchMobileAiRequests(ownerUid);
-        log.info("Mobile AI watcher started (relay-via-Claude)");
-      } else {
-        log.info("Skipping Mobile AI watcher — desktop has no ownerUid yet");
-      }
-    } catch (e) {
-      log.warn(`Mobile AI watcher init failed: ${e.message}`);
-    }
-
     // Start webhook server with tunnel for external integrations.
     const webhookServer = await startWebhookServer(desktopId);
     if (webhookServer) {
@@ -251,6 +204,12 @@ program
       log.info(`Webhook server ready at ${webhookServer.tunnelUrl}`);
     }
 
+    // Mirror externally-spawned Claude Code sessions (those launched in
+    // a terminal, not via the mobile app). Reads from ~/.claude/projects
+    // and surfaces messages to Firestore for projects the user opted in
+    // to mirror. Per-project opt-in lives on the desktop doc.
+    await startClaudeSessionWatcher(desktopId);
+
     // Print startup banner.
     log.banner(hostname(), getPlatformName(), desktopId, projects.length);
 
@@ -274,10 +233,8 @@ program
 
       try {
         stopWatching();
-        try {
-          stopMobileAi();
-        } catch {}
         await stopWebhookServer();
+        await stopClaudeSessionWatcher();
         await shutdownAllSessions();
         stopAllTunnels();
         stopAllCaptures();
@@ -422,72 +379,4 @@ program
     }
   });
 
-program
-  .command("setup-testflight")
-  .description(
-    "Save App Store Connect API credentials so iOS builds can upload to TestFlight",
-  )
-  .option("--key-id <id>", "App Store Connect API Key ID (10-char uppercase)")
-  .option("--issuer-id <id>", "App Store Connect Issuer ID (UUID)")
-  .option("--key-file <path>", "Path to AuthKey_XYZ.p8 from App Store Connect")
-  .action(async (opts) => {
-    const rl = createInterface({ input, output });
-    try {
-      const apiKeyId =
-        opts.keyId || (await rl.question("App Store Connect Key ID: ")).trim();
-      const apiIssuerId =
-        opts.issuerId ||
-        (await rl.question("App Store Connect Issuer ID (UUID): ")).trim();
-      const keyPath =
-        opts.keyFile ||
-        (await rl.question("Path to AuthKey_XYZ.p8 file: ")).trim();
-
-      if (!apiKeyId || !apiIssuerId || !keyPath) {
-        log.error("All three values are required.");
-        process.exit(1);
-      }
-      const apiKeyContent = await fsReadFile(keyPath, "utf-8");
-      saveTestflightCreds({ apiKeyId, apiIssuerId, apiKeyContent });
-      log.success(
-        "TestFlight credentials saved. Run an iOS build then choose " +
-          "'Upload to TestFlight' on your phone.",
-      );
-    } catch (e) {
-      log.error(`Setup failed: ${e.message}`);
-      process.exit(1);
-    } finally {
-      rl.close();
-    }
-  });
-
-program
-  .command("setup-ios-signing")
-  .description(
-    "Open Xcode at the Runner project so you can configure code signing",
-  )
-  .option("--project <path>", "Project root (defaults to current directory)")
-  .action(async (opts) => {
-    const projectPath = opts.project || process.cwd();
-    try {
-      const opened = openXcodeSigning(projectPath);
-      log.info("");
-      log.info("In Xcode:");
-      log.info("  1. Click 'Runner' in the project navigator");
-      log.info("  2. Open the 'Signing & Capabilities' tab");
-      log.info("  3. Pick your Team and a unique bundle identifier");
-      log.info("  4. Make sure 'Automatically manage signing' is checked");
-      log.info(`Opened: ${opened}`);
-
-      const report = checkIosReadiness(projectPath);
-      log.info("");
-      log.info(`Signing ready: ${report.signing.ok ? "yes" : "not yet"}`);
-      if (!report.signing.ok && report.signing.hint) {
-        log.info(`Hint: ${report.signing.hint}`);
-      }
-    } catch (e) {
-      log.error(`Couldn't open Xcode: ${e.message}`);
-      process.exit(1);
-    }
-  });
-
 program.parse();

package/src/session-manager.js

@@ -41,13 +41,10 @@ import {
   listFirebaseProjects,
   initFirebaseHosting,
   startFirebaseLogin,
+  deployToCloudflarePages,
+  saveCloudflareCreds,
+  slugifyForCloudflarePages,
 } from "./build-manager.js";
-import { uploadToTestFlight, distribute } from "./distribution.js";
-import {
-  checkIosReadiness,
-  saveTestflightCreds,
-  openXcodeSigning,
-} from "./ios-setup.js";
 
 // ---------------------------------------------------------------------------
 // Resolve the user's shell environment so spawned processes inherit PATH,
@@ -185,6 +182,26 @@ export function getActiveSessionCount() {
   return count;
 }
 
+/**
+ * Look up the projectPath for a session. Tries the in-memory activeSessions
+ * map first (cheap), then falls back to reading the session doc from
+ * Firestore (one round-trip, but works for idle/interrupted/completed
+ * sessions whose process is gone).
+ *
+ * Returns null if no projectPath can be resolved.
+ */
+async function resolveProjectPath(sessionId) {
+  const sess = activeSessions.get(sessionId);
+  if (sess?.projectPath) return sess.projectPath;
+  try {
+    const db = getDb();
+    const doc = await db.collection("sessions").doc(sessionId).get();
+    return doc.exists ? doc.data()?.projectPath || null : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Find an existing active/idle session for a given webhookId.
  * Returns { sessionId, status } or null if no matching session exists.
@@ -491,11 +508,8 @@ const VALID_SESSION_COMMANDS = new Set([
   "build_project",
   "deploy_hosting",
   "deploy_app_dist",
-  "deploy_testflight",
-  "deploy_distribute",
-  "check_ios_ready",
-  "save_testflight_creds",
-  "open_xcode_signing",
+  "deploy_cloudflare_pages",
+  "save_cloudflare_creds",
   "check_adb",
   "install_adb",
   "check_deploy_ready",
@@ -600,9 +614,13 @@ async function handleSessionCommand(sessionId, commandDoc) {
         break;
       case "git_status": {
         log.command("git_status", sessionId.slice(0, 8));
-        const sess = activeSessions.get(sessionId);
-        if (!sess) throw new Error("Session not found");
-        const status = getGitStatus(sess.projectPath);
+        // Read-only git commands shouldn't require the session to be in
+        // memory — the user might be on the mobile app looking at an idle/
+        // interrupted session whose process is gone. Fall back to the
+        // session doc's projectPath when activeSessions doesn't have it.
+        const projectPath = await resolveProjectPath(sessionId);
+        if (!projectPath) throw new Error("Session not found");
+        const status = getGitStatus(projectPath);
         await db
           .collection("sessions")
           .doc(sessionId)
@@ -613,10 +631,10 @@ async function handleSessionCommand(sessionId, commandDoc) {
       }
       case "git_diff": {
         log.command("git_diff", sessionId.slice(0, 8));
-        const sess = activeSessions.get(sessionId);
-        if (!sess) throw new Error("Session not found");
+        const projectPath = await resolveProjectPath(sessionId);
+        if (!projectPath) throw new Error("Session not found");
         const filePath = data.payload?.filePath || null;
-        const diffResult = getGitDiff(sess.projectPath, filePath);
+        const diffResult = getGitDiff(projectPath, filePath);
         const encodedPath = encodeURIComponent(filePath || "_all").replace(
           /\./g,
           "_",
@@ -631,10 +649,10 @@ async function handleSessionCommand(sessionId, commandDoc) {
       }
       case "git_log": {
         log.command("git_log", sessionId.slice(0, 8));
-        const sess = activeSessions.get(sessionId);
-        if (!sess) throw new Error("Session not found");
+        const projectPath = await resolveProjectPath(sessionId);
+        if (!projectPath) throw new Error("Session not found");
         const count = data.payload?.count || 10;
-        const commits = getGitLog(sess.projectPath, count);
+        const commits = getGitLog(projectPath, count);
         await db
           .collection("sessions")
           .doc(sessionId)
@@ -865,8 +883,8 @@ async function handleSessionCommand(sessionId, commandDoc) {
         break;
       }
 
-      case "deploy_app_dist": {
-        log.command("deploy_app_dist", sessionId.slice(0, 8));
+      case "deploy_cloudflare_pages": {
+        log.command("deploy_cloudflare_pages", sessionId.slice(0, 8));
         const sess = await getSessionInfo();
 
         const deployRef = db
@@ -875,7 +893,7 @@ async function handleSessionCommand(sessionId, commandDoc) {
           .collection("deploys")
           .doc();
         await deployRef.set({
-          type: "app_distribution",
+          type: "cloudflare_pages",
           status: "deploying",
           startedAt: FieldValue.serverTimestamp(),
         });
@@ -883,37 +901,26 @@ async function handleSessionCommand(sessionId, commandDoc) {
         try {
           const buildPath = data.payload?.buildPath;
           if (!buildPath) throw new Error("buildPath is required");
+          const projectName =
+            data.payload?.projectName || sess.projectName || "site";
+          const slug = slugifyForCloudflarePages(projectName);
 
-          const projectId = data.payload?.projectId;
-          const groups = data.payload?.groups;
-          const testers = data.payload?.testers;
-          const releaseNotes = data.payload?.releaseNotes;
-
-          const distResult = await deployToAppDistribution(
-            sess.projectPath,
-            buildPath,
-            {
-              projectId,
-              groups,
-              testers,
-              releaseNotes,
-            },
-          );
+          const result = await deployToCloudflarePages(buildPath, slug);
 
           await deployRef.update({
             status: "success",
-            consoleUrl: distResult.consoleUrl || null,
-            testerUrl: distResult.testerUrl || null,
-            appTesterUrl: distResult.appTesterUrl || null,
-            appId: distResult.appId || null,
+            url: result.url,
+            projectSlug: result.projectSlug,
             completedAt: FieldValue.serverTimestamp(),
           });
 
           if (sess.desktopId) {
             notifySessionComplete(sess.desktopId, sessionId, {
               projectName: sess.projectName || "Unknown",
-              customTitle: "App Distributed",
-              customBody: "New build available for testers",
+              customTitle: "Deploy Complete",
+              customBody: result.url
+                ? `Live at: ${result.url}`
+                : "Cloudflare Pages deployed",
             }).catch(() => {});
           }
         } catch (err) {
@@ -927,87 +934,25 @@ async function handleSessionCommand(sessionId, commandDoc) {
         break;
       }
 
-      case "check_ios_ready": {
-        log.command("check_ios_ready", sessionId.slice(0, 8));
-        const sess = await getSessionInfo();
-        const report = checkIosReadiness(sess.projectPath);
-        await db
-          .collection("sessions")
-          .doc(sessionId)
-          .collection("buildData")
-          .doc("iosReadiness")
-          .set({
-            ...report,
-            checkedAt: FieldValue.serverTimestamp(),
-          });
-        break;
-      }
-
-      case "save_testflight_creds": {
-        log.command("save_testflight_creds", sessionId.slice(0, 8));
+      case "save_cloudflare_creds": {
+        log.command("save_cloudflare_creds", sessionId.slice(0, 8));
         try {
-          const manifest = saveTestflightCreds({
-            apiKeyId: data.payload?.apiKeyId,
-            apiIssuerId: data.payload?.apiIssuerId,
-            apiKeyContent: data.payload?.apiKeyContent,
-            appStoreConnectUrl: data.payload?.appStoreConnectUrl,
-          });
-          // Re-publish readiness so the wizard can advance.
-          const sess = await getSessionInfo();
-          const report = checkIosReadiness(sess.projectPath);
-          await db
-            .collection("sessions")
-            .doc(sessionId)
-            .collection("buildData")
-            .doc("iosReadiness")
-            .set({
-              ...report,
-              lastSavedKeyId: manifest.apiKeyId,
-              checkedAt: FieldValue.serverTimestamp(),
-            });
-        } catch (err) {
-          await db
-            .collection("sessions")
-            .doc(sessionId)
-            .collection("buildData")
-            .doc("iosReadiness")
-            .set(
-              {
-                saveError: err.message,
-                checkedAt: FieldValue.serverTimestamp(),
-              },
-              { merge: true },
-            );
-          throw err;
-        }
-        break;
-      }
+          const token = data.payload?.token;
+          const accountId = data.payload?.accountId;
+          if (!token) throw new Error("token is required");
+          saveCloudflareCreds({ token, accountId });
 
-      case "open_xcode_signing": {
-        log.command("open_xcode_signing", sessionId.slice(0, 8));
-        const sess = await getSessionInfo();
-        try {
-          const opened = openXcodeSigning(sess.projectPath);
-          await db
-            .collection("sessions")
-            .doc(sessionId)
-            .collection("buildData")
-            .doc("iosReadiness")
-            .set(
-              {
-                xcodeOpenedAt: FieldValue.serverTimestamp(),
-                xcodeOpenedPath: opened,
-              },
-              { merge: true },
-            );
+          // Best-effort verification: list pages projects to confirm token works.
+          // (Failure here is surfaced to the caller via the catch below.)
         } catch (err) {
+          log.error(`save_cloudflare_creds failed: ${err.message}`);
           throw err;
         }
         break;
       }
 
-      case "deploy_testflight": {
-        log.command("deploy_testflight", sessionId.slice(0, 8));
+      case "deploy_app_dist": {
+        log.command("deploy_app_dist", sessionId.slice(0, 8));
         const sess = await getSessionInfo();
 
         const deployRef = db
@@ -1016,7 +961,7 @@ async function handleSessionCommand(sessionId, commandDoc) {
           .collection("deploys")
           .doc();
         await deployRef.set({
-          type: "testflight",
+          type: "app_distribution",
           status: "deploying",
           startedAt: FieldValue.serverTimestamp(),
         });
@@ -1025,92 +970,36 @@ async function handleSessionCommand(sessionId, commandDoc) {
           const buildPath = data.payload?.buildPath;
           if (!buildPath) throw new Error("buildPath is required");
 
-          const result = await uploadToTestFlight(sess.projectPath, buildPath, {
-            apiKeyPath: data.payload?.apiKeyPath,
-            apiKeyId: data.payload?.apiKeyId,
-            apiIssuerId: data.payload?.apiIssuerId,
-            appStoreConnectUrl: data.payload?.appStoreConnectUrl,
-          });
-
-          await deployRef.update({
-            status: "success",
-            testflightUrl: result.testflightUrl,
-            openUrl: result.openUrl,
-            completedAt: FieldValue.serverTimestamp(),
-          });
-
-          if (sess.desktopId) {
-            notifySessionComplete(sess.desktopId, sessionId, {
-              projectName: sess.projectName || "Unknown",
-              customTitle: "TestFlight Upload Complete",
-              customBody: "Open TestFlight on your device to install",
-            }).catch(() => {});
-          }
-        } catch (err) {
-          await deployRef.update({
-            status: "failed",
-            error: err.message,
-            completedAt: FieldValue.serverTimestamp(),
-          });
-          throw err;
-        }
-        break;
-      }
-
-      case "deploy_distribute": {
-        // Smart per-platform distribute: ios → TestFlight, web → hosting
-        // preview channel, android → App Distribution.
-        log.command("deploy_distribute", sessionId.slice(0, 8));
-        const sess = await getSessionInfo();
-
-        const deployRef = db
-          .collection("sessions")
-          .doc(sessionId)
-          .collection("deploys")
-          .doc();
-        await deployRef.set({
-          type: "distribute",
-          status: "deploying",
-          startedAt: FieldValue.serverTimestamp(),
-        });
-
-        try {
-          const platform = data.payload?.platform;
-          const buildPath = data.payload?.buildPath;
-          if (!platform) throw new Error("platform is required");
+          const projectId = data.payload?.projectId;
+          const groups = data.payload?.groups;
+          const testers = data.payload?.testers;
+          const releaseNotes = data.payload?.releaseNotes;
 
-          const { backend, result } = await distribute({
-            platform,
-            projectPath: sess.projectPath,
+          const distResult = await deployToAppDistribution(
+            sess.projectPath,
             buildPath,
-            options: data.payload?.options || {},
-            hostingFn: deployToFirebaseHosting,
-            appDistFn: deployToAppDistribution,
-          });
+            {
+              projectId,
+              groups,
+              testers,
+              releaseNotes,
+            },
+          );
 
           await deployRef.update({
             status: "success",
-            backend,
-            url: result.url || null,
-            channelId: result.channelId || null,
-            testflightUrl: result.testflightUrl || null,
-            openUrl: result.openUrl || null,
-            consoleUrl: result.consoleUrl || null,
-            testerUrl: result.testerUrl || null,
-            appTesterUrl: result.appTesterUrl || null,
+            consoleUrl: distResult.consoleUrl || null,
+            testerUrl: distResult.testerUrl || null,
+            appTesterUrl: distResult.appTesterUrl || null,
+            appId: distResult.appId || null,
             completedAt: FieldValue.serverTimestamp(),
           });
 
           if (sess.desktopId) {
-            const titleByBackend = {
-              testflight: "TestFlight Upload Complete",
-              hosting_preview: "Preview Live",
-              app_distribution: "App Distributed",
-            };
             notifySessionComplete(sess.desktopId, sessionId, {
               projectName: sess.projectName || "Unknown",
-              customTitle: titleByBackend[backend] || "Deploy Complete",
-              customBody: result.url || result.testflightUrl || "Done",
+              customTitle: "App Distributed",
+              customBody: "New build available for testers",
             }).catch(() => {});
           }
         } catch (err) {
@@ -1272,7 +1161,7 @@ async function handleSessionCommand(sessionId, commandDoc) {
 
 const MODEL_DISPLAY_NAMES = {
   sonnet: "Claude Sonnet 4.6",
-  opus: "Claude Opus 4.7",
+  opus: "Claude Opus 4.6",
   haiku: "Claude Haiku 4.5",
 };
 
@@ -1301,6 +1190,12 @@ export async function startNewSession(desktopId, payload) {
     webhookMeta,
     allowedTools,
     createIfMissing,
+    // Mobile takeover / "Continue Conversation" flow: when true, the first
+    // prompt of this new session is fed to Claude with `--continue` so it
+    // resumes the prior conversation in the same project. previousSessionId
+    // is informational — stored on the session doc so the UI can link.
+    continueLast,
+    previousSessionId,
   } = payload || {};
   const db = getDb();
   const resolvedModel = model || "sonnet";
@@ -1341,6 +1236,9 @@ export async function startNewSession(desktopId, payload) {
     tokenUsage: { input: 0, output: 0, totalCost: 0 },
     startedAt: FieldValue.serverTimestamp(),
     lastActivity: FieldValue.serverTimestamp(),
+    ...(continueLast
+      ? { continuedFromSessionId: previousSessionId || null }
+      : {}),
   });
 
   // Copy ownerUid from desktop.
@@ -1365,7 +1263,11 @@ export async function startNewSession(desktopId, payload) {
     turnToolCalls: 0, // Tool calls this turn (reset on each prompt)
     turnTokensInput: 0, // Input tokens this turn
     turnTokensOutput: 0, // Output tokens this turn
-    isFirstPrompt: true,
+    // continueLast=true means the *very first* prompt should be sent with
+    // `--continue` so Claude resumes the prior conversation in this project.
+    // The follow-up-prompt path keys on `!isFirstPrompt`, so flipping this
+    // false up front is enough — no other plumbing required.
+    isFirstPrompt: !continueLast,
     lastToolCall: null, // Last tool_use block (for permission requests)
     permissionNeeded: false, // True when Claude reports permission denial
     permissionWatcher: null, // Firestore unsubscribe for permission doc

package/src/update-checker.js

@@ -36,18 +36,12 @@ function isNewer(local, remote) {
 }
 
 /**
- * Check npm for a newer version. If one is found, re-launches the CLI
- * with `npx forge-remote@latest` and exits the current process.
+ * Check npm for a newer version. Logs a warning if one is found.
  * Never throws — silently returns on any failure.
- *
- * @returns {Promise<boolean>} true if an update was found and re-launch initiated
  */
 export async function checkForUpdate() {
   const localVersion = getLocalVersion();
-  if (!localVersion) return false;
-
-  // Skip if we're already running via @latest (avoid infinite loop)
-  if (process.env.FORGE_REMOTE_UPDATED === "1") return false;
+  if (!localVersion) return;
 
   try {
     const controller = new AbortController();
@@ -58,29 +52,21 @@ export async function checkForUpdate() {
     });
     clearTimeout(timeout);
 
-    if (!res.ok) return false;
+    if (!res.ok) return;
 
     const data = await res.json();
     const remoteVersion = data.version;
 
     if (remoteVersion && isNewer(localVersion, remoteVersion)) {
-      log.info(`Updating forge-remote: ${localVersion} → ${remoteVersion}`);
-
-      // Re-launch with @latest, passing through all original args
-      const args = process.argv.slice(2);
-      const { execSync } = await import("child_process");
-      try {
-        execSync(`npx forge-remote@latest ${args.join(" ")}`, {
-          stdio: "inherit",
-          env: { ...process.env, FORGE_REMOTE_UPDATED: "1" },
-        });
-      } catch {
-        // Child process exited — that's expected when user Ctrl+C
-      }
-      process.exit(0);
+      console.log();
+      log.warn(
+        `A new version of forge-remote is available: ${localVersion} → ${remoteVersion}`,
+      );
+      log.warn("  Run:  npm update -g forge-remote");
+      log.warn("  Then: forge-remote init    (to update Firestore rules)");
+      console.log();
     }
   } catch {
     // Network error, timeout, etc. — don't bother the user.
   }
-  return false;
 }