forge-remote 2.1.5 → 2.2.0

package/src/mobile-ai-watcher.js

@@ -0,0 +1,147 @@
+// Forge Remote — Mobile AI request watcher
+// Copyright (c) 2025-2026 Iron Forge Apps
+//
+// Listens for `mobile_ai_requests` documents owned by this user, runs
+// each prompt through Claude Code's headless mode (`claude -p`), and
+// streams stdout back into Firestore as ordered chunks.
+//
+// The user's existing Claude.ai subscription pays for these calls — no
+// separate Anthropic API key required.
+
+import { spawn } from "child_process";
+
+import { getDb, FieldValue } from "./firebase.js";
+import * as log from "./logger.js";
+
+const inFlight = new Set();
+
+/**
+ * Subscribe to queued mobile AI requests for `ownerUid`. Returns the
+ * unsubscribe function so the caller can stop watching on shutdown.
+ */
+export function watchMobileAiRequests(ownerUid) {
+  const db = getDb();
+  const q = db
+    .collection("mobile_ai_requests")
+    .where("ownerUid", "==", ownerUid)
+    .where("status", "==", "queued");
+
+  return q.onSnapshot((snap) => {
+    snap.docChanges().forEach((change) => {
+      if (change.type !== "added") return;
+      const id = change.doc.id;
+      if (inFlight.has(id)) return;
+      inFlight.add(id);
+      runRequest(id, change.doc.data())
+        .catch((err) =>
+          log.error(`Mobile AI request ${id} failed: ${err.message}`),
+        )
+        .finally(() => inFlight.delete(id));
+    });
+  });
+}
+
+async function runRequest(requestId, data) {
+  const db = getDb();
+  const ref = db.collection("mobile_ai_requests").doc(requestId);
+  await ref.update({
+    status: "running",
+    startedAt: FieldValue.serverTimestamp(),
+  });
+
+  const prompt = String(data.prompt ?? "");
+  const system = data.system ? String(data.system) : null;
+  const modelKey = String(data.model ?? "sonnet");
+  const model = resolveModel(modelKey);
+
+  // `claude -p` is the official non-interactive mode. Pass the user
+  // prompt via stdin so we don't run into argv length limits and so
+  // shell-quoting issues can't bite us.
+  const args = ["-p", "--model", model];
+  if (system) args.push("--append-system-prompt", system);
+
+  log.info(`Mobile AI: claude ${args.join(" ")}`);
+
+  const child = spawn("claude", args, {
+    env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  child.stdin.write(prompt);
+  child.stdin.end();
+
+  let seq = 0;
+  let buffer = "";
+  let lastFlush = Date.now();
+  const FLUSH_INTERVAL_MS = 250;
+  const FLUSH_BYTES = 256;
+
+  async function flush(force = false) {
+    if (!buffer) return;
+    const dueByTime = Date.now() - lastFlush > FLUSH_INTERVAL_MS;
+    if (!force && !dueByTime && buffer.length < FLUSH_BYTES) return;
+    const text = buffer;
+    buffer = "";
+    lastFlush = Date.now();
+    const n = seq++;
+    try {
+      await ref.collection("chunks").doc(String(n).padStart(6, "0")).set({
+        seq: n,
+        text,
+        ts: FieldValue.serverTimestamp(),
+      });
+    } catch (e) {
+      log.warn(`Chunk write failed (${requestId}/${n}): ${e.message}`);
+    }
+  }
+
+  let stderrBuf = "";
+
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk.toString();
+    flush();
+  });
+  child.stderr.on("data", (chunk) => {
+    stderrBuf += chunk.toString();
+  });
+
+  await new Promise((resolve) => {
+    child.on("close", async (code) => {
+      await flush(true);
+      if (code === 0) {
+        await ref.update({
+          status: "completed",
+          completedAt: FieldValue.serverTimestamp(),
+        });
+      } else {
+        await ref.update({
+          status: "failed",
+          error:
+            stderrBuf.trim().slice(-500) || `claude exited with code ${code}`,
+          completedAt: FieldValue.serverTimestamp(),
+        });
+      }
+      resolve();
+    });
+    child.on("error", async (err) => {
+      await ref.update({
+        status: "failed",
+        error: err.message,
+        completedAt: FieldValue.serverTimestamp(),
+      });
+      resolve();
+    });
+  });
+}
+
+function resolveModel(modelKey) {
+  switch (modelKey) {
+    case "opus":
+      return "opus";
+    case "haiku":
+      return "haiku";
+    case "sonnet":
+    default:
+      return "sonnet";
+  }
+}

package/src/session-manager.js

@@ -41,6 +41,9 @@ import {
   listFirebaseProjects,
   initFirebaseHosting,
   startFirebaseLogin,
+  deployToCloudflarePages,
+  saveCloudflareCreds,
+  slugifyForCloudflarePages,
 } from "./build-manager.js";
 
 // ---------------------------------------------------------------------------
@@ -179,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.
@@ -485,6 +508,8 @@ const VALID_SESSION_COMMANDS = new Set([
   "build_project",
   "deploy_hosting",
   "deploy_app_dist",
+  "deploy_cloudflare_pages",
+  "save_cloudflare_creds",
   "check_adb",
   "install_adb",
   "check_deploy_ready",
@@ -589,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)
@@ -602,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,
           "_",
@@ -620,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)
@@ -854,6 +883,74 @@ async function handleSessionCommand(sessionId, commandDoc) {
         break;
       }
 
+      case "deploy_cloudflare_pages": {
+        log.command("deploy_cloudflare_pages", sessionId.slice(0, 8));
+        const sess = await getSessionInfo();
+
+        const deployRef = db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("deploys")
+          .doc();
+        await deployRef.set({
+          type: "cloudflare_pages",
+          status: "deploying",
+          startedAt: FieldValue.serverTimestamp(),
+        });
+
+        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 result = await deployToCloudflarePages(buildPath, slug);
+
+          await deployRef.update({
+            status: "success",
+            url: result.url,
+            projectSlug: result.projectSlug,
+            completedAt: FieldValue.serverTimestamp(),
+          });
+
+          if (sess.desktopId) {
+            notifySessionComplete(sess.desktopId, sessionId, {
+              projectName: sess.projectName || "Unknown",
+              customTitle: "Deploy Complete",
+              customBody: result.url
+                ? `Live at: ${result.url}`
+                : "Cloudflare Pages deployed",
+            }).catch(() => {});
+          }
+        } catch (err) {
+          await deployRef.update({
+            status: "failed",
+            error: err.message,
+            completedAt: FieldValue.serverTimestamp(),
+          });
+          throw err;
+        }
+        break;
+      }
+
+      case "save_cloudflare_creds": {
+        log.command("save_cloudflare_creds", sessionId.slice(0, 8));
+        try {
+          const token = data.payload?.token;
+          const accountId = data.payload?.accountId;
+          if (!token) throw new Error("token is required");
+          saveCloudflareCreds({ token, accountId });
+
+          // 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_app_dist": {
         log.command("deploy_app_dist", sessionId.slice(0, 8));
         const sess = await getSessionInfo();
@@ -1093,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";
@@ -1133,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.
@@ -1157,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/task-orchestrator.js

@@ -0,0 +1,119 @@
+// Forge Remote — Async Task Orchestrator
+// Copyright (c) 2025-2026 Iron Forge Apps
+//
+// Watches `async_tasks/{id}` documents, executes each step's prompt
+// against a transient Claude Code session, and streams progress back
+// to Firestore so the mobile UI updates live.
+
+import {
+  collection,
+  doc,
+  getDoc,
+  onSnapshot,
+  query,
+  serverTimestamp,
+  Timestamp,
+  updateDoc,
+  where,
+} from "firebase/firestore";
+
+import * as log from "./logger.js";
+import { db } from "./firebase.js";
+import { startSessionForTask } from "./session-manager.js";
+
+/** Subscribes to async tasks bound for this desktop. */
+export function watchAsyncTasks(desktopId) {
+  const q = query(
+    collection(db, "async_tasks"),
+    where("desktopId", "==", desktopId),
+    where("status", "==", "awaitingApproval"),
+  );
+
+  return onSnapshot(q, (snap) => {
+    snap.docChanges().forEach((change) => {
+      if (change.type === "added" || change.type === "modified") {
+        runTask(change.doc.id).catch((e) =>
+          log.error(`Task ${change.doc.id} failed: ${e.message}`),
+        );
+      }
+    });
+  });
+}
+
+async function runTask(taskId) {
+  const ref = doc(db, "async_tasks", taskId);
+  const initial = await getDoc(ref);
+  if (!initial.exists()) return;
+  const data = initial.data();
+  if (data.status !== "awaitingApproval") return;
+
+  log.info(`Starting async task ${taskId}: ${data.prompt}`);
+  await updateDoc(ref, {
+    status: "running",
+    updatedAt: serverTimestamp(),
+  });
+
+  const steps = [...(data.steps || [])];
+  let totalTokens = 0;
+  let totalCostUsd = 0;
+  let resultUrl = null;
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    steps[i] = {
+      ...step,
+      status: "running",
+      startedAt: Timestamp.now(),
+    };
+    await updateDoc(ref, { steps, updatedAt: serverTimestamp() });
+
+    try {
+      const result = await startSessionForTask({
+        taskId,
+        prompt: `${step.title}\n\n${step.description}`,
+      });
+      totalTokens += result.tokens || 0;
+      totalCostUsd += result.costUsd || 0;
+      if (result.resultUrl) resultUrl = result.resultUrl;
+
+      steps[i] = {
+        ...steps[i],
+        status: "completed",
+        output: result.summary || "",
+        completedAt: Timestamp.now(),
+      };
+    } catch (e) {
+      log.error(`Step ${step.id} failed: ${e.message}`);
+      steps[i] = {
+        ...steps[i],
+        status: "failed",
+        output: e.message,
+        completedAt: Timestamp.now(),
+      };
+      await updateDoc(ref, {
+        steps,
+        status: "failed",
+        totalTokens,
+        totalCostUsd,
+        updatedAt: serverTimestamp(),
+      });
+      return;
+    }
+
+    await updateDoc(ref, {
+      steps,
+      totalTokens,
+      totalCostUsd,
+      updatedAt: serverTimestamp(),
+    });
+  }
+
+  await updateDoc(ref, {
+    status: "completed",
+    resultUrl,
+    totalTokens,
+    totalCostUsd,
+    updatedAt: serverTimestamp(),
+  });
+  log.success(`Task ${taskId} complete (${totalTokens} tokens)`);
+}

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;
 }