agent-companion 0.1.4 → 0.1.6

package/README.md

@@ -22,19 +22,6 @@ npm i -g agent-companion
 agent-companion
 ```
 
-## Options
-Use your hosted relay:
-
-```bash
-agent-companion --relay https://agent-companion-relay.onrender.com
-```
-
-Run with a local relay for development:
-
-```bash
-agent-companion --with-local-relay
-```
-
 ## Pairing flow
 1. Run `agent-companion` on your computer
 2. Copy the pairing code shown in the terminal

package/bridge/defaultState.mjs

@@ -6,6 +6,7 @@ const SESSION_STATES = new Set(["RUNNING", "WAITING_INPUT", "COMPLETED", "FAILED
 const EVENT_CATEGORIES = new Set(["INFO", "ACTION", "INPUT", "ERROR"]);
 const TURN_ROLES = new Set(["USER", "ASSISTANT"]);
 const TURN_KINDS = new Set(["MESSAGE", "FINAL_OUTPUT", "APPROVAL_ACTION"]);
+const SEEDED_SAMPLE_SESSION_IDS = new Set(["s_codex_live_01", "s_claude_live_01", "s_codex_live_02"]);
 
 function safeNumber(value, fallback = 0) {
   const parsed = Number(value);
@@ -290,93 +291,6 @@ function buildDefaultThreads(sessions) {
 }
 
 export function buildDefaultState() {
-  const now = Date.now();
-
-  const sessions = [
-    createSession(
-      "s_codex_live_01",
-      "CODEX",
-      "Refactor notification pipeline",
-      "agent-control-plane",
-      "feature/queue-replay",
-      "RUNNING",
-      16_000,
-      64,
-      {
-        promptTokens: 27120,
-        completionTokens: 18340,
-        totalTokens: 45460,
-        costUsd: 0.62
-      }
-    ),
-    createSession(
-      "s_claude_live_01",
-      "CLAUDE",
-      "Fix websocket reconnect",
-      "agent-bridge",
-      "bugfix/retry-loop",
-      "WAITING_INPUT",
-      75_000,
-      79,
-      {
-        promptTokens: 18110,
-        completionTokens: 11040,
-        totalTokens: 29150,
-        costUsd: 0.43
-      }
-    ),
-    createSession(
-      "s_codex_live_02",
-      "CODEX",
-      "Token analytics API",
-      "agent-api",
-      "feat/token-metrics",
-      "COMPLETED",
-      4_300_000,
-      100,
-      {
-        promptTokens: 32002,
-        completionTokens: 22994,
-        totalTokens: 54996,
-        costUsd: 0.78
-      }
-    )
-  ];
-
-  const pendingInputs = [
-    sanitizePendingInput({
-      id: "p_live_01",
-      sessionId: "s_claude_live_01",
-      prompt: "Can I cap backoff at 45s and ship this patch?",
-      requestedAt: now - 75_000,
-      priority: "HIGH"
-    })
-  ].filter(Boolean);
-
-  const events = [
-    sanitizeEvent({
-      id: "e_live_101",
-      sessionId: "s_codex_live_01",
-      summary: "Running integration tests on queue replay logic.",
-      timestamp: now - 16_000,
-      category: "INFO"
-    }),
-    sanitizeEvent({
-      id: "e_live_201",
-      sessionId: "s_claude_live_01",
-      summary: "Input requested: confirm retry cap before patch.",
-      timestamp: now - 75_000,
-      category: "INPUT"
-    }),
-    sanitizeEvent({
-      id: "e_live_301",
-      sessionId: "s_codex_live_02",
-      summary: "Session completed: endpoint + tests merged.",
-      timestamp: now - 4_300_000,
-      category: "ACTION"
-    })
-  ].filter(Boolean);
-
   const settings = {
     criticalRealtime: true,
     digest: true,
@@ -387,26 +301,13 @@ export function buildDefaultState() {
     workspaceRoot: resolveDefaultWorkspaceRoot()
   };
 
-  const sessionThreads = buildDefaultThreads(sessions);
-  const chatTurns = [
-    sanitizeChatTurn({
-      id: "turn_live_01",
-      sessionId: "s_claude_live_01",
-      role: "ASSISTANT",
-      kind: "FINAL_OUTPUT",
-      text: "Can I cap backoff at 45s and ship this patch?",
-      createdAt: now - 75_000,
-      source: "LEGACY"
-    })
-  ].filter(Boolean);
-
   return {
     source: "bridge",
-    sessions,
-    sessionThreads,
-    chatTurns,
-    pendingInputs,
-    events,
+    sessions: [],
+    sessionThreads: [],
+    chatTurns: [],
+    pendingInputs: [],
+    events: [],
     pendingHandledAt: {},
     settings
   };
@@ -438,23 +339,24 @@ export function sanitizeState(raw) {
     Array.isArray(candidate.sessions) ? candidate.sessions : fallback.sessions
   )
     .map((session) => sanitizeSession(session))
-    .filter(Boolean);
+    .filter((session) => Boolean(session && !SEEDED_SAMPLE_SESSION_IDS.has(session.id)));
 
   const pendingInputs = (
     Array.isArray(candidate.pendingInputs) ? candidate.pendingInputs : fallback.pendingInputs
   )
     .map((item) => sanitizePendingInput(item))
-    .filter(Boolean);
+    .filter((item) => Boolean(item && !SEEDED_SAMPLE_SESSION_IDS.has(item.sessionId)));
 
   const events = (Array.isArray(candidate.events) ? candidate.events : fallback.events)
     .map((event) => sanitizeEvent(event))
-    .filter(Boolean);
+    .filter((event) => Boolean(event && !SEEDED_SAMPLE_SESSION_IDS.has(event.sessionId)));
 
   const sessionThreadMap = new Map();
   const rawThreads = Array.isArray(candidate.sessionThreads) ? candidate.sessionThreads : [];
   for (const item of rawThreads) {
     const sanitized = sanitizeSessionThread(item);
     if (!sanitized) continue;
+    if (SEEDED_SAMPLE_SESSION_IDS.has(sanitized.id)) continue;
     sessionThreadMap.set(sanitized.id, sanitized);
   }
 
@@ -481,7 +383,7 @@ export function sanitizeState(raw) {
 
   const chatTurns = (Array.isArray(candidate.chatTurns) ? candidate.chatTurns : fallback.chatTurns)
     .map((turn) => sanitizeChatTurn(turn))
-    .filter((turn) => Boolean(turn && knownSessionIds.has(turn.sessionId)))
+    .filter((turn) => Boolean(turn && knownSessionIds.has(turn.sessionId) && !SEEDED_SAMPLE_SESSION_IDS.has(turn.sessionId)))
     .sort((a, b) => a.createdAt - b.createdAt);
 
   return {

package/bridge/server.mjs

@@ -1244,12 +1244,8 @@ function createWorkspaceFolder(input) {
     return { statusCode: 500, error: String(error?.message || error) };
   }
 
-  const normalizedPath = normalizeExistingDirectoryPath(targetPath);
-  if (!normalizedPath) {
-    return { statusCode: 500, error: "workspace path could not be resolved" };
-  }
-
-  const workspace = describeWorkspaceCandidate(normalizedPath);
+  const normalizedPath = normalizeExistingDirectoryPath(targetPath) || path.resolve(targetPath);
+  const workspace = describeWorkspaceCandidate(normalizedPath) || buildWorkspaceFallback(normalizedPath);
   if (!workspace) {
     return { statusCode: 500, error: "workspace could not be indexed" };
   }
@@ -1262,6 +1258,26 @@ function createWorkspaceFolder(input) {
   };
 }
 
+function buildWorkspaceFallback(workspacePath) {
+  const normalized = safeTrimmedText(workspacePath, 2000);
+  if (!normalized) return null;
+
+  try {
+    const stat = fs.statSync(normalized);
+    if (!stat.isDirectory()) return null;
+
+    return {
+      path: normalized,
+      name: path.basename(normalized),
+      hasGit: fs.existsSync(path.join(normalized, ".git")),
+      score: 0,
+      lastModified: stat.mtimeMs || Date.now()
+    };
+  } catch {
+    return null;
+  }
+}
+
 function detectWorkspaceMeta(workspacePath) {
   const repo = path.basename(workspacePath);
   const branch = detectGitBranch(workspacePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-companion",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "private": false,
   "type": "module",
   "description": "Phone-to-computer companion for Codex and Claude Code.",
@@ -54,6 +54,7 @@
   },
   "dependencies": {
     "@radix-ui/react-switch": "^1.2.6",
+    "@vercel/analytics": "^1.6.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cors": "^2.8.6",

package/relay/server.mjs

@@ -17,6 +17,7 @@ const RELAY_PUBLIC_URL = trimTrailingSlash(
   process.env.RELAY_PUBLIC_URL || process.env.RENDER_EXTERNAL_URL || `http://localhost:${RELAY_PORT}`
 );
 const RELAY_TOKEN_SECRET = resolveRelayTokenSecret();
+const RELAY_ADMIN_TOKEN = safeText(process.env.RELAY_ADMIN_TOKEN || process.env.ADMIN_TOKEN || "", 500);
 const RELAY_WAKE_PROXY_URL = trimTrailingSlash(process.env.RELAY_WAKE_PROXY_URL || process.env.WAKE_PROXY_URL || "");
 const RELAY_WAKE_PROXY_TOKEN = safeText(process.env.RELAY_WAKE_PROXY_TOKEN || process.env.WAKE_PROXY_TOKEN || "", 500);
 const RELAY_WAKE_TIMEOUT_MS = clamp(toInt(process.env.RELAY_WAKE_TIMEOUT_MS, 90_000), 5_000, 5 * 60 * 1000);
@@ -38,6 +39,7 @@ const MAX_PHONE_TOKENS = 2_000;
 const MAX_PREVIEW_RECORDS = 4_000;
 const PHONE_TOKEN_HEADER = "x-agent-companion-phone-token";
 const LAPTOP_TOKEN_HEADER = "x-agent-companion-laptop-token";
+const SEEDED_SAMPLE_SESSION_IDS = new Set(["s_codex_live_01", "s_claude_live_01", "s_codex_live_02"]);
 
 const STATE_FILE = path.resolve(PROJECT_ROOT, "relay", "state.json");
 const app = express();
@@ -82,6 +84,13 @@ app.get("/health", (_req, res) => {
   });
 });
 
+app.get("/api/admin/analytics", requireAdminToken, (_req, res) => {
+  cleanupExpiredPairings();
+  cleanupExpiredPreviews();
+  res.setHeader("Cache-Control", "no-store");
+  res.json(buildAdminAnalytics());
+});
+
 app.get("/pair", (req, res) => {
   const code = normalizePairCode(req.query?.code);
   const pairing = code ? findPairingByCode(code) : null;
@@ -281,6 +290,16 @@ app.post("/api/pairings/claim", (req, res) => {
   mutateState(() => {
     pairing.claimedAt = now;
     pairing.phoneToken = phoneToken;
+    if (!isObject(state.revokedPhoneDevices)) {
+      state.revokedPhoneDevices = {};
+    }
+    delete state.revokedPhoneDevices[pairing.deviceId];
+    if (!isObject(state.analytics)) {
+      state.analytics = {
+        totalPairClaims: 0
+      };
+    }
+    state.analytics.totalPairClaims = toInt(state.analytics.totalPairClaims, 0) + 1;
 
     state.phones.push({
       phoneToken,
@@ -304,6 +323,37 @@ app.post("/api/pairings/claim", (req, res) => {
   });
 });
 
+app.delete("/api/devices/:id/pairing", requirePhoneToken, (req, res) => {
+  const deviceId = safeText(req.params.id, 200);
+  const phone = req.phoneSession;
+  if (!deviceId) {
+    return res.status(400).json({ ok: false, error: "device id is required" });
+  }
+  if (!phone || safeText(phone.deviceId, 200) !== deviceId) {
+    return res.status(403).json({ ok: false, error: "token cannot access this device" });
+  }
+
+  mutateState(() => {
+    if (!isObject(state.revokedPhoneDevices)) {
+      state.revokedPhoneDevices = {};
+    }
+    state.revokedPhoneDevices[deviceId] = Date.now();
+    state.phones = state.phones.filter((item) => safeText(item.deviceId, 200) !== deviceId);
+    state.pairings = state.pairings.filter((item) => safeText(item.deviceId, 200) !== deviceId);
+    for (const laptop of state.laptops) {
+      if (safeText(laptop.deviceId, 200) !== deviceId) continue;
+      laptop.pairedAt = null;
+      laptop.pairCode = null;
+      laptop.pairingExpiresAt = null;
+      laptop.pairingUrl = null;
+      laptop.pairingPayload = null;
+      laptop.updatedAt = Date.now();
+    }
+  });
+
+  return res.json({ ok: true, deviceId });
+});
+
 app.use("/api/devices/:id", requirePhoneToken, requireDeviceAccess);
 
 app.get("/api/devices/:id/status", (req, res) => {
@@ -1486,6 +1536,9 @@ function findPhoneByToken(token) {
 function resolvePhoneSession(token) {
   const exact = findPhoneByToken(token);
   if (exact) {
+    if (isPhoneDeviceRevoked(exact.deviceId)) {
+      return null;
+    }
     const refreshedToken = issuePhoneToken(exact.deviceId);
     return {
       phone: exact,
@@ -1498,6 +1551,7 @@ function resolvePhoneSession(token) {
 
   const deviceId = safeText(claims.deviceId, 200);
   if (!deviceId) return null;
+  if (isPhoneDeviceRevoked(deviceId)) return null;
 
   const restored = {
     phoneToken: token,
@@ -1855,6 +1909,10 @@ function loadState() {
     pairings: [],
     phones: [],
     previews: [],
+    revokedPhoneDevices: {},
+    analytics: {
+      totalPairClaims: 0
+    },
     updatedAt: Date.now()
   };
 
@@ -1870,12 +1928,376 @@ function loadState() {
   }
 }
 
+function requireAdminToken(req, res, next) {
+  if (!RELAY_ADMIN_TOKEN) {
+    return res.status(503).json({
+      ok: false,
+      error: "admin analytics not configured"
+    });
+  }
+
+  const incoming = extractAdminToken(req);
+  if (!incoming || !secureTokenMatch(incoming, RELAY_ADMIN_TOKEN)) {
+    return res.status(401).json({
+      ok: false,
+      error: "unauthorized"
+    });
+  }
+
+  next();
+}
+
+function extractAdminToken(req) {
+  const authHeader = safeText(req.headers?.authorization || "", 4000);
+  if (authHeader.toLowerCase().startsWith("bearer ")) {
+    return safeText(authHeader.slice(7), 4000);
+  }
+
+  const headerToken = safeText(req.headers?.["x-admin-token"] || "", 4000);
+  if (headerToken) return headerToken;
+
+  return safeText(req.query?.token || "", 4000);
+}
+
+function secureTokenMatch(left, right) {
+  const actual = Buffer.from(String(left || ""), "utf8");
+  const expected = Buffer.from(String(right || ""), "utf8");
+  if (actual.length !== expected.length || actual.length === 0) return false;
+  return timingSafeEqual(actual, expected);
+}
+
+function buildAdminAnalytics() {
+  const now = Date.now();
+  const onlineLaptopIds = new Set(
+    [...laptopSockets.entries()]
+      .filter(([, ws]) => ws && ws.readyState === WebSocket.OPEN)
+      .map(([laptopId]) => laptopId)
+  );
+  const claimedPairings = state.pairings.filter((item) => item.claimedAt);
+  const activePreviews = state.previews.filter((item) => item.expiresAt > now);
+  const uniqueCurrentPairedDeviceIds = new Set(state.phones.map((item) => safeText(item.deviceId, 200)).filter(Boolean));
+  const uniqueKnownDeviceIds = new Set([
+    ...uniqueCurrentPairedDeviceIds,
+    ...claimedPairings.map((item) => safeText(item.deviceId, 200)).filter(Boolean)
+  ]);
+  const totalPairs = Math.max(
+    toInt(state.analytics?.totalPairClaims, 0),
+    uniqueCurrentPairedDeviceIds.size,
+    claimedPairings.length
+  );
+  const analyticsLaptops = listCurrentPairedLaptops(uniqueCurrentPairedDeviceIds);
+  const snapshotRollup = collectSnapshotAnalytics(analyticsLaptops, onlineLaptopIds, now);
+
+  return {
+    ok: true,
+    generatedAt: now,
+    summary: {
+      totalUsers: uniqueKnownDeviceIds.size,
+      currentPairs: uniqueCurrentPairedDeviceIds.size,
+      totalPairs,
+      newUsers24h: countUniqueRecentPairings(claimedPairings, now, 24 * 60 * 60 * 1000),
+      newUsers7d: countUniqueRecentPairings(claimedPairings, now, 7 * 24 * 60 * 60 * 1000),
+      onlineDevices: analyticsLaptops.filter((item) => onlineLaptopIds.has(item.laptopId)).length,
+      activeSessions: snapshotRollup.summary.activeSessions,
+      appSessionsTotal: snapshotRollup.summary.appSessionsTotal,
+      appRunsTotal: snapshotRollup.summary.appRunsTotal,
+      appRuns24h: snapshotRollup.summary.appRuns24h,
+      appRuns7d: snapshotRollup.summary.appRuns7d
+    },
+    agentUsage: snapshotRollup.agentUsage,
+    sessionStates: snapshotRollup.sessionStates,
+    runStates: snapshotRollup.runStates,
+    daily: buildDailyActivitySeries({
+      pairings: claimedPairings.map((item) => item.claimedAt),
+      runs: snapshotRollup.dailyRuns
+    }),
+    devices: snapshotRollup.devices
+  };
+}
+
+function listCurrentPairedLaptops(currentPairDeviceIds) {
+  const byDeviceId = new Map();
+
+  for (const laptop of state.laptops) {
+    const deviceId = safeText(laptop.deviceId, 200);
+    if (!deviceId || !currentPairDeviceIds.has(deviceId)) continue;
+
+    const previous = byDeviceId.get(deviceId) || null;
+    if (!previous) {
+      byDeviceId.set(deviceId, laptop);
+      continue;
+    }
+
+    const previousScore = Math.max(
+      toInt(previous.lastConnectedAt, 0),
+      toInt(previous.lastSnapshotAt, 0),
+      toInt(previous.updatedAt, 0),
+      toInt(previous.createdAt, 0)
+    );
+    const nextScore = Math.max(
+      toInt(laptop.lastConnectedAt, 0),
+      toInt(laptop.lastSnapshotAt, 0),
+      toInt(laptop.updatedAt, 0),
+      toInt(laptop.createdAt, 0)
+    );
+
+    if (nextScore >= previousScore) {
+      byDeviceId.set(deviceId, laptop);
+    }
+  }
+
+  return [...byDeviceId.values()];
+}
+
+function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
+  const sessionStates = {
+    RUNNING: 0,
+    WAITING_INPUT: 0,
+    COMPLETED: 0,
+    FAILED: 0,
+    CANCELLED: 0
+  };
+  const runStates = {
+    STARTING: 0,
+    RUNNING: 0,
+    COMPLETED: 0,
+    FAILED: 0,
+    STOPPED: 0
+  };
+  const agentUsage = {
+    codexRuns: 0,
+    claudeRuns: 0,
+    codexSessionsFromApp: 0,
+    claudeSessionsFromApp: 0
+  };
+  const dailyRuns = [];
+
+  const devices = laptops
+    .map((laptop) => {
+      const snapshot = isObject(laptop.latestSnapshot) ? laptop.latestSnapshot : {};
+      const runs = Array.isArray(snapshot.runs) ? snapshot.runs.filter((item) => isObject(item)) : [];
+      const sessionSummaries = Array.isArray(snapshot.sessionSummaries)
+        ? snapshot.sessionSummaries.filter((item) => {
+            if (!isObject(item)) return false;
+            const sessionId = safeText(item.id || item?.session?.id, 200);
+            return !SEEDED_SAMPLE_SESSION_IDS.has(sessionId);
+          })
+        : [];
+      const sessions = Array.isArray(snapshot.sessions)
+        ? snapshot.sessions.filter((item) => {
+            if (!isObject(item)) return false;
+            const sessionId = safeText(item.id || item?.session?.id, 200);
+            return !SEEDED_SAMPLE_SESSION_IDS.has(sessionId);
+          })
+        : [];
+      const chatTurns = Array.isArray(snapshot.chatTurns)
+        ? snapshot.chatTurns.filter((item) => {
+            if (!isObject(item)) return false;
+            const sessionId = safeText(item.sessionId, 200);
+            return sessionId && !SEEDED_SAMPLE_SESSION_IDS.has(sessionId);
+          })
+        : [];
+      const sessionList = sessionSummaries.length > 0 ? sessionSummaries : sessions;
+      const sessionLookup = new Map();
+      for (const session of sessionList) {
+        const sessionId = safeText(session.id || session?.session?.id, 200);
+        if (sessionId) {
+          sessionLookup.set(sessionId, session);
+        }
+      }
+      const appSessionIds = new Set();
+
+      for (const run of runs) {
+        const status = safeText(run.status, 40).toUpperCase();
+        if (Object.prototype.hasOwnProperty.call(runStates, status)) {
+          runStates[status] += 1;
+        }
+
+        const agentType = safeText(run.agentType, 20).toUpperCase();
+        if (agentType === "CODEX") agentUsage.codexRuns += 1;
+        if (agentType === "CLAUDE") agentUsage.claudeRuns += 1;
+
+        const sessionId = safeText(run.sessionId, 200);
+        if (sessionId && !SEEDED_SAMPLE_SESSION_IDS.has(sessionId)) appSessionIds.add(sessionId);
+
+        const createdAt = toInt(run.createdAt, 0);
+        if (createdAt) {
+          dailyRuns.push(createdAt);
+        }
+      }
+
+      for (const turn of chatTurns) {
+        const sessionId = safeText(turn.sessionId, 200);
+        const role = safeText(turn.role, 20).toUpperCase();
+        const source = safeText(turn.source, 40).toUpperCase();
+        const text = safeText(turn.text || turn.content, 20_000);
+        if (!sessionId || role !== "USER") continue;
+        if (source === "MESSAGE_API" && text && !SEEDED_SAMPLE_SESSION_IDS.has(sessionId)) {
+          appSessionIds.add(sessionId);
+        }
+      }
+
+      const activeAppSessionIds = [...appSessionIds].filter((sessionId) => {
+        if (sessionLookup.has(sessionId)) return true;
+        return runs.some((run) => safeText(run.sessionId, 200) === sessionId);
+      });
+
+      for (const sessionId of activeAppSessionIds) {
+        const session = sessionLookup.get(sessionId);
+        if (!session) continue;
+
+        const sessionState =
+          safeText(session?.session?.state, 40).toUpperCase() ||
+          safeText(session.state, 40).toUpperCase();
+        if (Object.prototype.hasOwnProperty.call(sessionStates, sessionState)) {
+          sessionStates[sessionState] += 1;
+        }
+
+        const agentType =
+          safeText(session?.thread?.agentType, 20).toUpperCase() ||
+          safeText(session?.session?.agentType, 20).toUpperCase() ||
+          safeText(session.agentType, 20).toUpperCase();
+        if (agentType === "CODEX") agentUsage.codexSessionsFromApp += 1;
+        if (agentType === "CLAUDE") agentUsage.claudeSessionsFromApp += 1;
+      }
+
+      const lastSeenAt =
+        laptop.lastSnapshotAt ||
+        laptop.lastConnectedAt ||
+        laptop.lastDisconnectedAt ||
+        laptop.pairedAt ||
+        laptop.createdAt ||
+        now;
+
+      return {
+        laptopId: laptop.laptopId,
+        deviceId: laptop.deviceId,
+        name: laptop.name || "Unnamed computer",
+        online: onlineLaptopIds.has(laptop.laptopId),
+        createdAt: laptop.createdAt,
+        pairedAt: laptop.pairedAt || null,
+        lastSeenAt,
+        sessionCount: activeAppSessionIds.length,
+        activeSessionCount: activeAppSessionIds
+          .map((sessionId) => sessionLookup.get(sessionId))
+          .filter(Boolean)
+          .filter((session) => {
+            const stateValue =
+              safeText(session?.session?.state, 40).toUpperCase() ||
+              safeText(session.state, 40).toUpperCase();
+            return stateValue === "RUNNING" || stateValue === "WAITING_INPUT";
+          }).length,
+        runCount: runs.length,
+        codexRuns: runs.filter((item) => safeText(item.agentType, 20).toUpperCase() === "CODEX").length,
+        claudeRuns: runs.filter((item) => safeText(item.agentType, 20).toUpperCase() === "CLAUDE").length
+      };
+    })
+    .sort((a, b) => {
+      if (a.online !== b.online) return a.online ? -1 : 1;
+      return (b.lastSeenAt || 0) - (a.lastSeenAt || 0);
+    });
+
+  return {
+    summary: {
+      activeSessions:
+        sessionStates.RUNNING + sessionStates.WAITING_INPUT,
+      appSessionsTotal: devices.reduce((sum, item) => sum + item.sessionCount, 0),
+      appRunsTotal: devices.reduce((sum, item) => sum + item.runCount, 0),
+      appRuns24h: countRecentTimestamps(dailyRuns, now, 24 * 60 * 60 * 1000),
+      appRuns7d: countRecentTimestamps(dailyRuns, now, 7 * 24 * 60 * 60 * 1000)
+    },
+    sessionStates,
+    runStates,
+    agentUsage,
+    devices,
+    dailyRuns
+  };
+}
+
+function countRecentDevices(laptops, now, windowMs) {
+  return laptops.filter((item) => {
+    const lastSeenAt =
+      item.lastSnapshotAt ||
+      item.lastConnectedAt ||
+      item.lastDisconnectedAt ||
+      item.pairedAt ||
+      item.createdAt ||
+      0;
+    return lastSeenAt > 0 && now - lastSeenAt <= windowMs;
+  }).length;
+}
+
+function countUniqueRecentPairings(pairings, now, windowMs) {
+  const deviceIds = new Set();
+  for (const pairing of pairings) {
+    const claimedAt = toInt(pairing?.claimedAt, 0);
+    const deviceId = safeText(pairing?.deviceId, 200);
+    if (!claimedAt || !deviceId) continue;
+    if (now - claimedAt > windowMs) continue;
+    deviceIds.add(deviceId);
+  }
+  return deviceIds.size;
+}
+
+function countRecentTimestamps(values, now, windowMs) {
+  return values.filter((value) => {
+    const timestamp = toInt(value, 0);
+    return timestamp > 0 && now - timestamp <= windowMs;
+  }).length;
+}
+
+function buildDailyActivitySeries({ pairings, runs }, days = 14) {
+  const dayMs = 24 * 60 * 60 * 1000;
+  const startOfToday = new Date();
+  startOfToday.setHours(0, 0, 0, 0);
+  const startTime = startOfToday.getTime() - (days - 1) * dayMs;
+  const buckets = new Map();
+
+  for (let offset = 0; offset < days; offset += 1) {
+    const ts = startTime + offset * dayMs;
+    const key = formatDayKey(ts);
+    buckets.set(key, {
+      date: key,
+      pairings: 0,
+      runs: 0
+    });
+  }
+
+  for (const ts of pairings) {
+    const value = toInt(ts, 0);
+    if (!value || value < startTime) continue;
+    const bucket = buckets.get(formatDayKey(value));
+    if (bucket) bucket.pairings += 1;
+  }
+
+  for (const ts of runs) {
+    const value = toInt(ts, 0);
+    if (!value || value < startTime) continue;
+    const bucket = buckets.get(formatDayKey(value));
+    if (bucket) bucket.runs += 1;
+  }
+
+  return [...buckets.values()];
+}
+
+function formatDayKey(timestamp) {
+  const date = new Date(timestamp);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
 function sanitizeState(raw) {
   const fallback = {
     laptops: [],
     pairings: [],
     phones: [],
     previews: [],
+    revokedPhoneDevices: {},
+    analytics: {
+      totalPairClaims: 0
+    },
     updatedAt: Date.now()
   };
 
@@ -1957,11 +2379,30 @@ function sanitizeState(raw) {
         .filter((item) => item.previewId && item.accessToken && item.laptopId && item.deviceId && item.target)
     : [];
 
+  const revokedPhoneDevices = isObject(raw.revokedPhoneDevices)
+    ? Object.fromEntries(
+        Object.entries(raw.revokedPhoneDevices)
+          .map(([deviceId, revokedAt]) => [safeText(deviceId, 200), toInt(revokedAt, 0)])
+          .filter(([deviceId, revokedAt]) => deviceId && revokedAt > 0)
+      )
+    : {};
+
+  const totalPairClaims = Math.max(
+    toInt(raw?.analytics?.totalPairClaims, 0),
+    phones.length,
+    new Set(laptops.filter((item) => item.pairedAt).map((item) => item.deviceId).filter(Boolean)).size,
+    pairings.filter((item) => item.claimedAt).length
+  );
+
   return {
     laptops,
     pairings,
     phones,
     previews,
+    revokedPhoneDevices,
+    analytics: {
+      totalPairClaims
+    },
     updatedAt: toInt(raw.updatedAt, Date.now())
   };
 }
@@ -1989,6 +2430,11 @@ function trimStateCollections() {
   }
 }
 
+function isPhoneDeviceRevoked(deviceId) {
+  if (!deviceId || !isObject(state.revokedPhoneDevices)) return false;
+  return toInt(state.revokedPhoneDevices[deviceId], 0) > 0;
+}
+
 function gracefulShutdown(signal) {
   if (shuttingDown) return;
   shuttingDown = true;