forge-remote 0.1.22 → 0.1.24

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.22",
+  "version": "0.1.24",
   "description": "Desktop relay for Forge Remote — monitor and control Claude Code sessions from your phone",
   "type": "module",
   "license": "UNLICENSED",

package/src/session-manager.js

@@ -570,6 +570,9 @@ export async function startNewSession(desktopId, payload) {
     startTime: Date.now(),
     messageCount: 0,
     toolCallCount: 0,
+    turnToolCalls: 0, // Tool calls this turn (reset on each prompt)
+    turnTokensInput: 0, // Input tokens this turn
+    turnTokensOutput: 0, // Output tokens this turn
     isFirstPrompt: true,
     lastToolCall: null, // Last tool_use block (for permission requests)
     permissionNeeded: false, // True when Claude reports permission denial
@@ -690,10 +693,13 @@ async function runClaudeProcess(sessionId, prompt) {
   const session = activeSessions.get(sessionId);
   if (!session) return;
 
-  // Reset permission state for this new turn.
+  // Reset permission state and per-turn stats for this new turn.
   session.permissionNeeded = false;
   session.deniedToolCall = null;
   session.lastToolCall = null;
+  session.turnToolCalls = 0;
+  session.turnTokensInput = 0;
+  session.turnTokensOutput = 0;
 
   const db = getDb();
   const sessionRef = db.collection("sessions").doc(sessionId);
@@ -1031,6 +1037,17 @@ async function runClaudeProcess(sessionId, prompt) {
             timestamp: FieldValue.serverTimestamp(),
           });
 
+        // Award XP for completed turn.
+        awardSessionXp(sessionId, {
+          toolCalls: sess?.turnToolCalls || 0,
+          tokensUsed:
+            (sess?.turnTokensInput || 0) + (sess?.turnTokensOutput || 0),
+        }).catch((e) =>
+          log.warn(
+            `Failed to award XP for ${sessionId.slice(0, 8)}: ${e.message}`,
+          ),
+        );
+
         // Push notification for idle.
         notifySessionIdle(sess.desktopId, sessionId, {
           projectName: sess.projectName || "Unknown",
@@ -1162,6 +1179,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({
@@ -1238,6 +1266,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({
@@ -1288,7 +1327,12 @@ async function handleStreamEvent(sessionId, sessionRef, event) {
       lastActivity: FieldValue.serverTimestamp(),
     });
 
-    if (session) session.tokenUsage = tokenUsage;
+    if (session) {
+      session.tokenUsage = tokenUsage;
+      // Track per-turn tokens for XP calculation.
+      session.turnTokensInput = tokenUsage.input;
+      session.turnTokensOutput = tokenUsage.output;
+    }
 
     log.session(
       sessionId,
@@ -1487,7 +1531,10 @@ const toolCallDocIds = new Map();
 async function storeToolCall(sessionId, block) {
   const db = getDb();
   const session = activeSessions.get(sessionId);
-  if (session) session.toolCallCount = (session.toolCallCount || 0) + 1;
+  if (session) {
+    session.toolCallCount = (session.toolCallCount || 0) + 1;
+    session.turnToolCalls = (session.turnToolCalls || 0) + 1;
+  }
 
   const toolName = block.name || "unknown";
   const toolInput =
@@ -1803,6 +1850,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",
@@ -2108,6 +2166,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);