forge-remote 0.1.22 → 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.22",
+  "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/session-manager.js

@@ -1162,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({
@@ -1238,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({
@@ -1803,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",
@@ -2108,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);