agent-relay-server 0.33.0 → 0.34.0

package/src/db/stats.ts

@@ -0,0 +1,337 @@
+import { Database } from "bun:sqlite";
+import { randomUUID } from "node:crypto";
+import { isRecord, stringValue, isMechanicalMessageKind } from "agent-relay-sdk";
+import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "../config.ts";
+import { parseJson } from "../utils";
+import { isLiveIsolatedWorkspace } from "../workspace-phase";
+import {
+  CONTRACT_REQUIREMENTS,
+  contractCompatibility,
+  parseRuntimeCapabilities,
+  parseRuntimeContracts,
+  parseRuntimePackage,
+  type RuntimeContracts,
+} from "../contracts";
+import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
+import { matchAgents } from "../agent-ref";
+import { listAgents } from "./agents.ts";
+import { listChannels } from "./channels.ts";
+import { getDb } from "./connection.ts";
+import type {
+  AgentCard,
+  ActivityEvent,
+  ActivityEventInput,
+  AgentKind,
+  AgentSessionGuard,
+  Artifact,
+  ArtifactBlob,
+  ArtifactKind,
+  ArtifactLink,
+  ArtifactSensitivity,
+  ArtifactVisibility,
+  AttachmentRef,
+  ChannelBinding,
+  ChannelBindingMode,
+  ChannelRouteTarget,
+  ChatHistoryImport,
+  ChatHistoryImportEntry,
+  ChannelSummary,
+  ChannelTargetHealth,
+  CreatePairInput,
+  HealthCheck,
+  HealthReport,
+  ManagedAgent,
+  ManagedSessionExitDiagnostics,
+  Message,
+  MessageDeliveryAttempt,
+  MessageDeliveryStatus,
+  Orchestrator,
+  OrchestratorHealth,
+  OrchestratorRuntimeInput,
+  OrchestratorStatus,
+  OrchestratorUpgradeState,
+  PairActionInput,
+  PairMessageInput,
+  PairSession,
+  PairStatus,
+  RegisterAgentInput,
+  ReplyObligation,
+  RegisterOrchestratorInput,
+  SendMessageInput,
+  PollQuery,
+  SpawnApprovalMode,
+  SpawnProvider,
+  Task,
+  TaskEvent,
+  TaskSeverity,
+  TaskStatus,
+  IntegrationEventInput,
+  IntegrationSummary,
+  IntegrationTaskStats,
+  InboxDraft,
+  InboxState,
+  InboxThreadState,
+  ContextSnapshot,
+  ContextState,
+  ProviderCapabilities,
+  TaskStatusInput,
+  WorkspaceMetadata,
+  WorkspaceRecord,
+  WorkspaceStatus,
+} from "../types";
+
+export function getStats(): {
+  version: string;
+  agents: number;
+  online: number;
+  messages: number;
+  messagesLast24h: number;
+  tasks: number;
+  openTasks: number;
+} {
+  const agents = (
+    getDb().query("SELECT COUNT(*) as c FROM agents").get() as any
+  ).c;
+  const online = (
+    getDb()
+      .query(
+        "SELECT COUNT(*) as c FROM agents WHERE status != 'offline' AND last_seen > ?"
+      )
+      .get(Date.now() - STALE_TTL_MS) as any
+  ).c;
+  const messages = (
+    getDb().query("SELECT COUNT(*) as c FROM messages").get() as any
+  ).c;
+  const messagesLast24h = (
+    getDb()
+      .query("SELECT COUNT(*) as c FROM messages WHERE created_at > ?")
+      .get(Date.now() - DAY_MS) as any
+  ).c;
+  const tasks = (
+    getDb().query("SELECT COUNT(*) as c FROM tasks").get() as any
+  ).c;
+  const openTasks = (
+    getDb().query("SELECT COUNT(*) as c FROM tasks WHERE status NOT IN ('done', 'failed', 'canceled')").get() as any
+  ).c;
+
+  return { version: VERSION, agents, online, messages, messagesLast24h, tasks, openTasks };
+}
+
+// Analytics aggregation periods. Bucket counts mirror the dashboard chart
+// granularity so the client renders pre-aggregated buckets directly. This is the
+// single source of truth — the dashboard no longer windows raw messages (which
+// capped it at the last ~100 rows ≈ 3h on a busy relay; the data was always
+// retained server-side per RETENTION_DAYS). See issue #212 for the Layer-2 rollup
+// that will let stats outlive the message-retention window.
+export const ANALYTICS_PERIODS = {
+  "1h": { ms: 3_600_000, buckets: 12 },
+  "6h": { ms: 21_600_000, buckets: 12 },
+  "24h": { ms: 86_400_000, buckets: 24 },
+  "7d": { ms: 604_800_000, buckets: 14 },
+  "14d": { ms: 1_209_600_000, buckets: 14 },
+  "30d": { ms: 2_592_000_000, buckets: 15 },
+} as const;
+
+export type AnalyticsPeriod = keyof typeof ANALYTICS_PERIODS;
+
+// Message → category, the ONE place this mapping lives (server-side SQL). Order is
+// significant: a claimable/system/pair/channel message is classified as such even
+// when it is also a reply; only an otherwise-plain reply counts as "Replies".
+export const ANALYTICS_CATEGORIES = ["Messages", "Replies", "Work items", "System", "Pair", "Channel"] as const;
+export type AnalyticsCategory = (typeof ANALYTICS_CATEGORIES)[number];
+export const ANALYTICS_CATEGORY_SQL = `
+  CASE
+    WHEN claimable = 1 THEN 'Work items'
+    WHEN kind = 'system' OR from_agent = 'system' THEN 'System'
+    WHEN kind = 'pair' THEN 'Pair'
+    WHEN kind = 'channel.event' THEN 'Channel'
+    WHEN reply_to IS NOT NULL THEN 'Replies'
+    ELSE 'Messages'
+  END`;
+
+export interface AnalyticsData {
+  period: AnalyticsPeriod;
+  start: number;
+  now: number;
+  bucketMs: number;
+  bucketCount: number;
+  // Per-bucket category counts, oldest → newest, length === bucketCount.
+  buckets: Array<{ start: number; counts: Record<AnalyticsCategory, number> }>;
+  // Category totals over the whole period (powers the breakdown donut).
+  categories: Record<AnalyticsCategory, number>;
+  // Busiest-hours grid: heatmap[dayOfWeek 0=Sun][hour 0-23], in server-local time.
+  heatmap: number[][];
+  totalMessages: number;
+  totalReactions: number;
+}
+
+export function emptyCategoryCounts(): Record<AnalyticsCategory, number> {
+  return { Messages: 0, Replies: 0, "Work items": 0, System: 0, Pair: 0, Channel: 0 };
+}
+
+export function getAnalytics(period: AnalyticsPeriod, now: number = Date.now()): AnalyticsData {
+  const { ms, buckets: bucketCount } = ANALYTICS_PERIODS[period] ?? ANALYTICS_PERIODS["24h"];
+  const start = now - ms;
+  const bucketMs = ms / bucketCount;
+
+  const buckets = Array.from({ length: bucketCount }, (_, i) => ({
+    start: start + i * bucketMs,
+    counts: emptyCategoryCounts(),
+  }));
+  const categories = emptyCategoryCounts();
+
+  // One pass: bucket index × category counts. CAST floors toward zero; created_at
+  // in (start, now] keeps the index in [0, bucketCount).
+  const volumeRows = getDb()
+    .query(
+      `SELECT CAST((created_at - ?) / ? AS INTEGER) AS bucket, ${ANALYTICS_CATEGORY_SQL} AS category, COUNT(*) AS c
+       FROM messages WHERE created_at > ? AND created_at <= ? GROUP BY bucket, category`,
+    )
+    .all(start, bucketMs, start, now) as Array<{ bucket: number; category: AnalyticsCategory; c: number }>;
+  for (const row of volumeRows) {
+    const idx = Math.min(Math.max(row.bucket, 0), bucketCount - 1);
+    const bucket = buckets[idx];
+    if (bucket && row.category in bucket.counts) {
+      bucket.counts[row.category] += row.c;
+      categories[row.category] += row.c;
+    }
+  }
+  const totalMessages = Object.values(categories).reduce((sum, v) => sum + v, 0);
+
+  // Busiest-hours heatmap (day-of-week × hour), server-local time.
+  const heatmap: number[][] = Array.from({ length: 7 }, () => new Array(24).fill(0));
+  const heatRows = getDb()
+    .query(
+      `SELECT CAST(strftime('%w', created_at / 1000, 'unixepoch', 'localtime') AS INTEGER) AS dow,
+              CAST(strftime('%H', created_at / 1000, 'unixepoch', 'localtime') AS INTEGER) AS hour, COUNT(*) AS c
+       FROM messages WHERE created_at > ? AND created_at <= ? GROUP BY dow, hour`,
+    )
+    .all(start, now) as Array<{ dow: number; hour: number; c: number }>;
+  for (const row of heatRows) {
+    const day = heatmap[row.dow];
+    if (day && row.hour >= 0 && row.hour < 24) day[row.hour] = row.c;
+  }
+
+  const totalReactions = (
+    getDb()
+      .query(
+        `SELECT COUNT(*) AS c FROM message_reactions r
+         JOIN messages m ON m.id = r.message_id WHERE m.created_at > ? AND m.created_at <= ?`,
+      )
+      .get(start, now) as { c: number }
+  ).c;
+
+  return { period, start, now, bucketMs, bucketCount, buckets, categories, heatmap, totalMessages, totalReactions };
+}
+
+export function getHealth(now: number = Date.now()): HealthReport {
+  const checks: HealthCheck[] = [];
+
+  try {
+    getDb().query("SELECT 1").get();
+    checks.push({ name: "database", status: "ok" });
+  } catch (e) {
+    checks.push({ name: "database", status: "error", detail: e instanceof Error ? e.message : "database check failed" });
+  }
+
+  const staleLiveAgents = (getDb()
+    .query("SELECT COUNT(*) as c FROM agents WHERE status != 'offline' AND last_seen <= ? AND id NOT IN ('user', 'system')")
+    .get(now - STALE_TTL_MS) as any).c as number;
+  checks.push({
+    name: "stale-live-agents",
+    status: staleLiveAgents > 0 ? "warn" : "ok",
+    count: staleLiveAgents,
+    detail: staleLiveAgents > 0 ? `${staleLiveAgents} non-offline agent(s) missed heartbeat TTL` : undefined,
+  });
+
+  const expiredMessageClaims = (getDb()
+    .query("SELECT COUNT(*) as c FROM messages WHERE claimed_by IS NOT NULL AND (claim_expires_at IS NULL OR claim_expires_at <= ?) AND NOT EXISTS (SELECT 1 FROM tasks t WHERE t.message_id = messages.id AND t.status IN ('done', 'failed', 'canceled'))")
+    .get(now) as any).c as number;
+  checks.push({
+    name: "expired-message-claims",
+    status: expiredMessageClaims > 0 ? "warn" : "ok",
+    count: expiredMessageClaims,
+    detail: expiredMessageClaims > 0 ? `${expiredMessageClaims} message claim(s) are expired or missing a lease` : undefined,
+  });
+
+  const expiredTaskClaims = (getDb()
+    .query("SELECT COUNT(*) as c FROM tasks WHERE claimed_by IS NOT NULL AND (claim_expires_at IS NULL OR claim_expires_at <= ?) AND status IN ('claimed', 'in_progress', 'blocked')")
+    .get(now) as any).c as number;
+  checks.push({
+    name: "expired-task-claims",
+    status: expiredTaskClaims > 0 ? "warn" : "ok",
+    count: expiredTaskClaims,
+    detail: expiredTaskClaims > 0 ? `${expiredTaskClaims} active task claim(s) are expired or missing a lease` : undefined,
+  });
+
+  const offlineClaimedTasks = (getDb()
+    .query(`
+      SELECT COUNT(*) as c
+      FROM tasks t
+      JOIN agents a ON a.id = t.claimed_by
+      WHERE t.status IN ('claimed', 'in_progress', 'blocked') AND a.status = 'offline'
+    `)
+    .get() as any).c as number;
+  checks.push({
+    name: "offline-claimed-tasks",
+    status: offlineClaimedTasks > 0 ? "warn" : "ok",
+    count: offlineClaimedTasks,
+    detail: offlineClaimedTasks > 0 ? `${offlineClaimedTasks} active task(s) are claimed by offline agents` : undefined,
+  });
+
+  const unhealthyChannelTargets = listChannels().filter((channel) => channel.targetHealth && channel.targetHealth.status !== "ok");
+  const channelTargetErrors = unhealthyChannelTargets.filter((channel) => channel.targetHealth?.status === "error");
+  const channelTargetDetail = unhealthyChannelTargets
+    .slice(0, 3)
+    .map((channel) => `${channel.name}: ${channel.targetHealth?.detail}`)
+    .join("; ");
+  checks.push({
+    name: "channel-delivery-targets",
+    status: channelTargetErrors.length > 0 ? "error" : unhealthyChannelTargets.length > 0 ? "warn" : "ok",
+    count: unhealthyChannelTargets.length,
+    detail: unhealthyChannelTargets.length > 0
+      ? `${unhealthyChannelTargets.length} channel delivery target issue(s): ${channelTargetDetail}${unhealthyChannelTargets.length > 3 ? "; ..." : ""}`
+      : undefined,
+  });
+
+  const rootTokenRuntimeAgents = listAgents().filter((agent) => {
+    if (agent.status === "offline") return false;
+    if (agent.id === "user" || agent.id === "system") return false;
+    const meta = agent.meta ?? {};
+    if (meta.runnerManaged !== true) return false;
+    const auth = meta.auth && typeof meta.auth === "object" && !Array.isArray(meta.auth)
+      ? meta.auth as Record<string, unknown>
+      : {};
+    return auth.rootTokenFallback === true || typeof auth.profileId !== "string" || auth.profileId.length === 0;
+  });
+  checks.push({
+    name: "root-token-runtime-drift",
+    status: rootTokenRuntimeAgents.length > 0 ? "warn" : "ok",
+    count: rootTokenRuntimeAgents.length,
+    detail: rootTokenRuntimeAgents.length > 0
+      ? `${rootTokenRuntimeAgents.length} runtime agent(s) are using or missing scoped token metadata`
+      : undefined,
+    subjects: rootTokenRuntimeAgents.map((agent) => {
+      const auth = agent.meta?.auth && typeof agent.meta.auth === "object" && !Array.isArray(agent.meta.auth)
+        ? agent.meta.auth as Record<string, unknown>
+        : {};
+      const reason = auth.rootTokenFallback === true
+        ? "using root-token fallback"
+        : "missing scoped token profile metadata";
+      return {
+        id: agent.id,
+        label: agent.label || agent.name || agent.id,
+        status: agent.status,
+        detail: reason,
+      };
+    }),
+  });
+
+  const status = checks.some((check) => check.status === "error")
+    ? "error"
+    : checks.some((check) => check.status === "warn")
+      ? "degraded"
+      : "ok";
+  return { status, version: VERSION, generatedAt: now, checks };
+}
+