forge-remote 0.1.21 → 0.1.23

package/firestore.rules

@@ -91,6 +91,15 @@ service cloud.firestore {
                     && request.resource.data.claimedBy == request.auth.uid;
     }
 
+    // ---- Characters (RPG character system) ----
+    // BYOF: single-player, so 'player' is the only document.
+    // The relay writes XP awards; the mobile app reads + creates.
+    match /characters/{characterId} {
+      allow read: if isSignedIn();
+      allow create: if isSignedIn();
+      allow update: if isSignedIn() && isValidSize();
+    }
+
     // ---- User profiles (for preferences) ----
     match /users/{userId} {
       allow read, write: if request.auth != null && request.auth.uid == userId;

package/package.json

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

package/src/cli.js

@@ -140,7 +140,12 @@ program
     // Clean up any orphaned sessions from a previous relay run.
     await cleanupOrphanedSessions(desktopId);
 
-    const heartbeat = startHeartbeat(desktopId);
+    const heartbeat = startHeartbeat(desktopId, {
+      onConnectionLost: () => {
+        log.info("Re-establishing Firestore listeners...");
+        listenForCommands(desktopId);
+      },
+    });
 
     listenForCommands(desktopId);
 

package/src/desktop.js

@@ -54,17 +54,45 @@ export async function markOffline(desktopId) {
 
 /**
  * Start a heartbeat interval that updates lastHeartbeat every 30s.
+ * Also monitors Firestore connectivity — if heartbeats fail consecutively,
+ * it signals the relay to restart listeners.
  */
-export function startHeartbeat(desktopId) {
+export function startHeartbeat(desktopId, { onConnectionLost } = {}) {
+  let consecutiveFailures = 0;
+  const MAX_FAILURES = 5; // ~2.5 minutes of failures before action
+
   const interval = setInterval(async () => {
     try {
       const db = getDb();
-      await db.collection("desktops").doc(desktopId).update({
+
+      // Use a timeout to detect hung Firestore connections (e.g., stale TCP).
+      const heartbeatPromise = db.collection("desktops").doc(desktopId).update({
         lastHeartbeat: FieldValue.serverTimestamp(),
       });
+      const timeoutPromise = new Promise((_, reject) =>
+        setTimeout(
+          () => reject(new Error("Heartbeat timed out (15s)")),
+          15_000,
+        ),
+      );
+      await Promise.race([heartbeatPromise, timeoutPromise]);
+
+      if (consecutiveFailures > 0) {
+        log.info(`Heartbeat recovered after ${consecutiveFailures} failure(s)`);
+      }
+      consecutiveFailures = 0;
       log.heartbeat();
     } catch (e) {
-      log.error(`Heartbeat failed: ${e.message}`);
+      consecutiveFailures++;
+      log.error(
+        `Heartbeat failed (${consecutiveFailures}/${MAX_FAILURES}): ${e.message}`,
+      );
+
+      if (consecutiveFailures >= MAX_FAILURES && onConnectionLost) {
+        log.error("Firestore connection appears dead — triggering reconnect");
+        consecutiveFailures = 0; // Reset so it doesn't fire again immediately.
+        onConnectionLost();
+      }
     }
   }, 30_000);
 

package/src/session-manager.js

@@ -224,11 +224,26 @@ function isRateLimited() {
 // Command listeners
 // ---------------------------------------------------------------------------
 
+// Track active listener unsubscribe functions so we can tear them down
+// before re-subscribing (e.g., after a Firestore reconnect).
+let activeListenerUnsubs = [];
+
 export function listenForCommands(desktopId) {
+  // Clean up previous listeners to avoid duplicate command handling.
+  for (const unsub of activeListenerUnsubs) {
+    try {
+      unsub();
+    } catch {
+      /* already dead */
+    }
+  }
+  activeListenerUnsubs = [];
+
   const db = getDb();
 
   // Desktop-level commands (start_session, etc.).
-  db.collection("desktops")
+  const unsub1 = db
+    .collection("desktops")
     .doc(desktopId)
     .collection("commands")
     .where("status", "==", "pending")
@@ -239,15 +254,18 @@ export function listenForCommands(desktopId) {
         }
       }
     });
+  activeListenerUnsubs.push(unsub1);
 
   // Watch for existing sessions → subscribe to their commands.
-  db.collection("sessions")
+  const unsub2 = db
+    .collection("sessions")
     .where("desktopId", "==", desktopId)
     .onSnapshot((snap) => {
       for (const doc of snap.docs) {
         watchSessionCommands(doc.id);
       }
     });
+  activeListenerUnsubs.push(unsub2);
 }
 
 // ---------------------------------------------------------------------------
@@ -1144,6 +1162,17 @@ async function stopSession(sessionId) {
     : 0;
   const durationStr = formatDuration(duration);
 
+  // Award XP before deleting session from the map.
+  if (session) {
+    awardSessionXp(sessionId, {
+      toolCalls: session.toolCallCount || 0,
+      tokensUsed:
+        (session.tokenUsage?.input || 0) + (session.tokenUsage?.output || 0),
+    }).catch((e) =>
+      log.warn(`Failed to award XP for ${sessionId.slice(0, 8)}: ${e.message}`),
+    );
+  }
+
   activeSessions.delete(sessionId);
 
   await sessionRef.update({
@@ -1220,6 +1249,17 @@ async function killSession(sessionId) {
     : 0;
   const durationStr = formatDuration(duration);
 
+  // Award XP before deleting session from the map.
+  if (session) {
+    awardSessionXp(sessionId, {
+      toolCalls: session.toolCallCount || 0,
+      tokensUsed:
+        (session.tokenUsage?.input || 0) + (session.tokenUsage?.output || 0),
+    }).catch((e) =>
+      log.warn(`Failed to award XP for ${sessionId.slice(0, 8)}: ${e.message}`),
+    );
+  }
+
   activeSessions.delete(sessionId);
 
   await sessionRef.update({
@@ -1785,6 +1825,17 @@ export async function shutdownAllSessions() {
 
     const duration = Math.round((Date.now() - session.startTime) / 1000);
 
+    // Award XP before deleting session from the map.
+    try {
+      await awardSessionXp(sessionId, {
+        toolCalls: session.toolCallCount || 0,
+        tokensUsed:
+          (session.tokenUsage?.input || 0) + (session.tokenUsage?.output || 0),
+      });
+    } catch (e) {
+      log.warn(`Failed to award XP for ${sessionId.slice(0, 8)}: ${e.message}`);
+    }
+
     try {
       await db.collection("sessions").doc(sessionId).update({
         status: "completed",
@@ -2090,6 +2141,109 @@ async function handlePermissionDenied(sessionId) {
 // Helpers
 // ---------------------------------------------------------------------------
 
+// ---------------------------------------------------------------------------
+// Character XP — award XP when a session completes
+// ---------------------------------------------------------------------------
+
+const XP_SESSION_COMPLETED = 50;
+const XP_PER_TOOL_CALL = 2;
+const XP_PER_1K_TOKENS = 3;
+const XP_DAILY_STREAK = 25;
+const XP_FIRST_SESSION = 15;
+
+function xpForLevel(level) {
+  if (level <= 1) return 0;
+  return Math.round(100 * Math.pow(level, 1.5));
+}
+
+function levelForXp(totalXp) {
+  if (totalXp <= 0) return 1;
+  let level = 1;
+  while (xpForLevel(level + 1) <= totalXp && level < 99) {
+    level++;
+  }
+  return level;
+}
+
+/**
+ * Award XP for a completed session.
+ *
+ * @param {string} sessionId — for logging only
+ * @param {{ toolCalls: number, tokensUsed: number }} stats — session stats
+ */
+async function awardSessionXp(sessionId, { toolCalls = 0, tokensUsed = 0 }) {
+  const db = getDb();
+  const charRef = db.collection("characters").doc("player");
+
+  await db.runTransaction(async (txn) => {
+    const charDoc = await txn.get(charRef);
+    if (!charDoc.exists) {
+      log.warn(
+        `[${sessionId.slice(0, 8)}] No character doc — skipping XP award`,
+      );
+      return;
+    }
+
+    const data = charDoc.data();
+    const currentXp = data.totalXp || 0;
+    const sessions = data.sessionsCompleted || 0;
+    const totalTools = data.totalToolCalls || 0;
+    const totalTokens = data.totalTokensUsed || 0;
+    const currentStreak = data.currentStreak || 0;
+    const longestStreak = data.longestStreak || 0;
+    const lastSessionDate = data.lastSessionDate?.toDate?.() || null;
+
+    // Calculate XP.
+    let xpEarned = XP_SESSION_COMPLETED;
+    xpEarned += toolCalls * XP_PER_TOOL_CALL;
+    xpEarned += Math.round((tokensUsed / 1000) * XP_PER_1K_TOKENS);
+
+    // Streak calculation.
+    const now = new Date();
+    let newStreak = currentStreak;
+    if (lastSessionDate) {
+      const lastDay = new Date(
+        lastSessionDate.getFullYear(),
+        lastSessionDate.getMonth(),
+        lastSessionDate.getDate(),
+      );
+      const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      const daysDiff = Math.round((today - lastDay) / 86400000);
+
+      if (daysDiff === 1) {
+        newStreak = currentStreak + 1;
+        xpEarned += XP_DAILY_STREAK;
+      } else if (daysDiff > 1) {
+        newStreak = 1;
+      }
+    } else {
+      newStreak = 1;
+      xpEarned += XP_FIRST_SESSION;
+    }
+
+    const newXp = currentXp + xpEarned;
+    const newLevel = levelForXp(newXp);
+    const newLongest = Math.max(newStreak, longestStreak);
+
+    txn.update(charRef, {
+      totalXp: newXp,
+      level: newLevel,
+      sessionsCompleted: sessions + 1,
+      totalToolCalls: totalTools + toolCalls,
+      totalTokensUsed: totalTokens + tokensUsed,
+      currentStreak: newStreak,
+      longestStreak: newLongest,
+      lastSessionDate: FieldValue.serverTimestamp(),
+    });
+
+    log.info(
+      `[${sessionId.slice(0, 8)}] Awarded ${xpEarned} XP — ` +
+        `tools: ${toolCalls}, tokens: ${tokensUsed}, ` +
+        `level: ${newLevel}, streak: ${newStreak}`,
+    );
+  });
+}
+
 function formatDuration(seconds) {
   if (seconds < 60) return `${seconds}s`;
   const mins = Math.floor(seconds / 60);