agent-companion 0.1.4 → 0.1.5

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.5",
   "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);
@@ -82,6 +83,12 @@ app.get("/health", (_req, res) => {
   });
 });
 
+app.get("/api/admin/analytics", requireAdminToken, (_req, res) => {
+  cleanupExpiredPairings();
+  cleanupExpiredPreviews();
+  res.json(buildAdminAnalytics());
+});
+
 app.get("/pair", (req, res) => {
   const code = normalizePairCode(req.query?.code);
   const pairing = code ? findPairingByCode(code) : null;
@@ -1870,6 +1877,301 @@ 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 snapshotRollup = collectSnapshotAnalytics(state.laptops, onlineLaptopIds, now);
+  const uniquePairedDeviceIds = new Set(
+    state.laptops.map((item) => safeText(item.deviceId, 200)).filter(Boolean)
+  );
+
+  return {
+    ok: true,
+    generatedAt: now,
+    summary: {
+      totalUsers: uniquePairedDeviceIds.size,
+      totalPairs: claimedPairings.length,
+      newUsers24h: countUniqueRecentPairings(claimedPairings, now, 24 * 60 * 60 * 1000),
+      newUsers7d: countUniqueRecentPairings(claimedPairings, now, 7 * 24 * 60 * 60 * 1000),
+      onlineDevices: onlineLaptopIds.size,
+      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 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) => isObject(item))
+        : [];
+      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) {
+        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) 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();
+        if (!sessionId || role !== "USER") continue;
+        if (source === "MESSAGE_API" || source === "LAUNCH") {
+          appSessionIds.add(sessionId);
+        }
+      }
+
+      for (const sessionId of appSessionIds) {
+        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: appSessionIds.size,
+        activeSessionCount: [...appSessionIds]
+          .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: [],