agent-companion 0.1.5 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-companion",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "private": false,
   "type": "module",
   "description": "Phone-to-computer companion for Codex and Claude Code.",

package/relay/server.mjs

@@ -39,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();
@@ -86,6 +87,7 @@ app.get("/health", (_req, res) => {
 app.get("/api/admin/analytics", requireAdminToken, (_req, res) => {
   cleanupExpiredPairings();
   cleanupExpiredPreviews();
+  res.setHeader("Cache-Control", "no-store");
   res.json(buildAdminAnalytics());
 });
 
@@ -288,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,
@@ -311,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) => {
@@ -1493,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,
@@ -1505,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,
@@ -1862,6 +1909,10 @@ function loadState() {
     pairings: [],
     phones: [],
     previews: [],
+    revokedPhoneDevices: {},
+    analytics: {
+      totalPairClaims: 0
+    },
     updatedAt: Date.now()
   };
 
@@ -1924,20 +1975,29 @@ function buildAdminAnalytics() {
   );
   const claimedPairings = state.pairings.filter((item) => item.claimedAt);
   const activePreviews = state.previews.filter((item) => item.expiresAt > now);
-  const snapshotRollup = collectSnapshotAnalytics(state.laptops, onlineLaptopIds, now);
-  const uniquePairedDeviceIds = new Set(
-    state.laptops.map((item) => safeText(item.deviceId, 200)).filter(Boolean)
+  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: uniquePairedDeviceIds.size,
-      totalPairs: claimedPairings.length,
+      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: onlineLaptopIds.size,
+      onlineDevices: analyticsLaptops.filter((item) => onlineLaptopIds.has(item.laptopId)).length,
       activeSessions: snapshotRollup.summary.activeSessions,
       appSessionsTotal: snapshotRollup.summary.appSessionsTotal,
       appRunsTotal: snapshotRollup.summary.appRunsTotal,
@@ -1955,6 +2015,40 @@ function buildAdminAnalytics() {
   };
 }
 
+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,
@@ -1983,10 +2077,26 @@ function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
       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) => isObject(item))
+        ? 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 sessions = Array.isArray(snapshot.sessions) ? snapshot.sessions.filter((item) => isObject(item)) : [];
-      const chatTurns = Array.isArray(snapshot.chatTurns) ? snapshot.chatTurns.filter((item) => isObject(item)) : [];
       const sessionList = sessionSummaries.length > 0 ? sessionSummaries : sessions;
       const sessionLookup = new Map();
       for (const session of sessionList) {
@@ -2008,7 +2118,7 @@ function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
         if (agentType === "CLAUDE") agentUsage.claudeRuns += 1;
 
         const sessionId = safeText(run.sessionId, 200);
-        if (sessionId) appSessionIds.add(sessionId);
+        if (sessionId && !SEEDED_SAMPLE_SESSION_IDS.has(sessionId)) appSessionIds.add(sessionId);
 
         const createdAt = toInt(run.createdAt, 0);
         if (createdAt) {
@@ -2020,13 +2130,19 @@ function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
         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" || source === "LAUNCH") {
+        if (source === "MESSAGE_API" && text && !SEEDED_SAMPLE_SESSION_IDS.has(sessionId)) {
           appSessionIds.add(sessionId);
         }
       }
 
-      for (const sessionId of appSessionIds) {
+      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;
 
@@ -2061,8 +2177,8 @@ function collectSnapshotAnalytics(laptops, onlineLaptopIds, now) {
         createdAt: laptop.createdAt,
         pairedAt: laptop.pairedAt || null,
         lastSeenAt,
-        sessionCount: appSessionIds.size,
-        activeSessionCount: [...appSessionIds]
+        sessionCount: activeAppSessionIds.length,
+        activeSessionCount: activeAppSessionIds
           .map((sessionId) => sessionLookup.get(sessionId))
           .filter(Boolean)
           .filter((session) => {
@@ -2178,6 +2294,10 @@ function sanitizeState(raw) {
     pairings: [],
     phones: [],
     previews: [],
+    revokedPhoneDevices: {},
+    analytics: {
+      totalPairClaims: 0
+    },
     updatedAt: Date.now()
   };
 
@@ -2259,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())
   };
 }
@@ -2291,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;