agent-relay-server 0.19.3 → 0.21.0

package/src/db.ts

@@ -74,6 +74,7 @@ import type {
   WorkspaceStatus,
 } from "./types";
 import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "./config";
+import { matchAgents } from "./agent-ref";
 
 let db: Database;
 const CONTEXT_SNAPSHOT_DEBOUNCE_MS = 60_000;
@@ -210,6 +211,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
       provider_capabilities TEXT,
       context_state TEXT,
       meta TEXT NOT NULL DEFAULT '{}',
+      spawned_by TEXT,
       last_seen INTEGER NOT NULL,
       created_at INTEGER NOT NULL
     );
@@ -1047,6 +1049,9 @@ export function initDb(path: string = "agent-relay.db"): Database {
   if (!agentColNames.includes("context_state")) {
     db.run("ALTER TABLE agents ADD COLUMN context_state TEXT");
   }
+  if (!agentColNames.includes("spawned_by")) {
+    db.run("ALTER TABLE agents ADD COLUMN spawned_by TEXT");
+  }
   db.run(`
     CREATE TABLE IF NOT EXISTS context_snapshots (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1245,6 +1250,7 @@ function rowToAgent(row: any): AgentCard {
     providerCapabilities: parseJson<ProviderCapabilities | undefined>(row.provider_capabilities, undefined),
     context: parseJson<ContextState | undefined>(row.context_state, undefined),
     meta: parseJson(row.meta, {}),
+    spawnedBy: row.spawned_by ?? undefined,
     lastSeen: row.last_seen,
     createdAt: row.created_at,
   };
@@ -1747,8 +1753,8 @@ export function upsertAgent(input: RegisterAgentInput): AgentCard {
   const readyProvided = Object.prototype.hasOwnProperty.call(input, "ready");
   const instanceProvided = Boolean(input.instanceId);
   const stmt = db.query(`
-    INSERT INTO agents (id, name, kind, label, tags, machine, rig, capabilities, ready, status, instance_id, epoch, provider_capabilities, context_state, meta, last_seen, created_at)
-    VALUES ($id, $name, $kind, $label, $tags, $machine, $rig, $capabilities, $ready, $status, $instanceId, $initialEpoch, $providerCapabilities, $contextState, $meta, $now, $now)
+    INSERT INTO agents (id, name, kind, label, tags, machine, rig, capabilities, ready, status, instance_id, epoch, provider_capabilities, context_state, meta, spawned_by, last_seen, created_at)
+    VALUES ($id, $name, $kind, $label, $tags, $machine, $rig, $capabilities, $ready, $status, $instanceId, $initialEpoch, $providerCapabilities, $contextState, $meta, $spawnedBy, $now, $now)
     ON CONFLICT(id) DO UPDATE SET
       name = $name,
       kind = $kind,
@@ -1767,6 +1773,7 @@ export function upsertAgent(input: RegisterAgentInput): AgentCard {
       provider_capabilities = coalesce($providerCapabilities, agents.provider_capabilities),
       context_state = coalesce($contextState, agents.context_state),
       meta = $meta,
+      spawned_by = coalesce($spawnedBy, agents.spawned_by),
       last_seen = $now
   `);
 
@@ -1789,6 +1796,7 @@ export function upsertAgent(input: RegisterAgentInput): AgentCard {
     $providerCapabilities: input.providerCapabilities ? JSON.stringify(input.providerCapabilities) : null,
     $contextState: input.context ? JSON.stringify(input.context) : null,
     $meta: JSON.stringify(input.meta ?? {}),
+    $spawnedBy: input.spawnedBy ?? null,
     $now: now,
   });
   if (input.context) recordContextSnapshot(input.id, input.context, now);
@@ -1858,6 +1866,106 @@ export function listAgents(filter?: {
   return (db.query(sql).all(...params) as any[]).map(rowToAgent);
 }
 
+export interface AgentSearchFilter {
+  /** Substring match on label OR name (case-insensitive). */
+  label?: string;
+  /** One or more capabilities (OR within the field), via json_each(capabilities). */
+  capability?: string | string[];
+  /** One or more tags (OR within the field), via json_each(tags). */
+  tag?: string | string[];
+  /** Real model provider — providerCapabilities.model.provider (e.g. "claude", "codex"). */
+  provider?: string | string[];
+  machine?: string | string[];
+  /** provider/orchestrator/channel/etc. */
+  kind?: string | string[];
+  /** Specific status(es), the "running" shorthand (live + ready + fresh), or "all". */
+  status?: string | string[];
+  /** Exact parent agent id — backs the `spawnedBy:` / `spawnedBy:me` fleet filter (#221). */
+  spawnedBy?: string;
+}
+
+export interface AgentSearchSort {
+  sortBy?: "lastActive" | "created" | "label";
+  order?: "asc" | "desc";
+  limit?: number;
+}
+
+const AGENT_SEARCH_MAX_LIMIT = 200;
+
+function searchValues(value: string | string[] | undefined): string[] {
+  if (value == null) return [];
+  return (Array.isArray(value) ? value : [value]).filter((v): v is string => typeof v === "string" && v.length > 0);
+}
+
+// Unified fleet search: all filters optional and AND-combined; array values OR within a
+// field. One parameterized query (no JS post-filter, no injection). Backs relay_find_agents
+// (#219) and the running-only relay_agent_status default (#218). "running" mirrors the
+// canonical liveness predicate (see db.ts delivery/steward checks + isAgentOnline).
+export function searchAgents(filter: AgentSearchFilter = {}, sort: AgentSearchSort = {}): AgentCard[] {
+  const clauses: string[] = ["1=1"];
+  const params: any[] = [];
+  const inList = (column: string, values: string[]) => {
+    clauses.push(`${column} IN (${values.map(() => "?").join(",")})`);
+    params.push(...values);
+  };
+
+  if (filter.label) {
+    clauses.push("(label LIKE ? OR name LIKE ?)");
+    params.push(`%${filter.label}%`, `%${filter.label}%`);
+  }
+  const caps = searchValues(filter.capability);
+  if (caps.length) {
+    clauses.push(`EXISTS (SELECT 1 FROM json_each(capabilities) WHERE value IN (${caps.map(() => "?").join(",")}))`);
+    params.push(...caps);
+  }
+  const tags = searchValues(filter.tag);
+  if (tags.length) {
+    clauses.push(`EXISTS (SELECT 1 FROM json_each(tags) WHERE value IN (${tags.map(() => "?").join(",")}))`);
+    params.push(...tags);
+  }
+  const providers = searchValues(filter.provider);
+  if (providers.length) {
+    clauses.push(`json_extract(provider_capabilities, '$.model.provider') IN (${providers.map(() => "?").join(",")})`);
+    params.push(...providers);
+  }
+  const machines = searchValues(filter.machine);
+  if (machines.length) inList("machine", machines);
+  const kinds = searchValues(filter.kind);
+  if (kinds.length) inList("kind", kinds);
+  if (filter.spawnedBy) {
+    clauses.push("spawned_by = ?");
+    params.push(filter.spawnedBy);
+  }
+
+  const statuses = searchValues(filter.status);
+  if (!statuses.includes("all")) {
+    if (statuses.includes("running")) {
+      clauses.push("status NOT IN ('offline', 'stale') AND ready = 1 AND last_seen > ?");
+      params.push(Date.now() - STALE_TTL_MS);
+    }
+    const explicit = statuses.filter((s) => s !== "running" && s !== "all");
+    if (explicit.length) inList("status", explicit);
+  }
+
+  const sortColumn = sort.sortBy === "created" ? "created_at" : sort.sortBy === "label" ? "label COLLATE NOCASE" : "last_seen";
+  const order = sort.order === "asc" ? "ASC" : "DESC";
+  const limit = Math.max(1, Math.min(sort.limit ?? 50, AGENT_SEARCH_MAX_LIMIT));
+  params.push(limit);
+
+  const sql = `SELECT * FROM agents WHERE ${clauses.join(" AND ")} ORDER BY ${sortColumn} ${order} LIMIT ?`;
+  return (db.query(sql).all(...params) as any[]).map(rowToAgent);
+}
+
+// Count of a parent's currently-LIVE children — the spawn quota numerator (#221). "Live"
+// mirrors the running predicate (not offline/stale, ready, fresh); a child that exits frees
+// a slot. Uncapped COUNT (unlike searchAgents' LIMIT) so the quota is exact at any fleet size.
+export function countLiveSpawnedAgents(parentId: string, now: number = Date.now()): number {
+  const row = db.query(
+    "SELECT count(*) AS n FROM agents WHERE spawned_by = ? AND status NOT IN ('offline', 'stale') AND ready = 1 AND last_seen > ?",
+  ).get(parentId, now - STALE_TTL_MS) as { n: number };
+  return row.n;
+}
+
 export function setStatus(id: string, status: AgentCard["status"], guard?: AgentSessionGuard): boolean {
   if (!validateAgentSession(id, guard).ok) return false;
   const now = Date.now();
@@ -2350,17 +2458,6 @@ export function pruneOfflineAgents(maxOfflineMs: number = DAY_MS): string[] {
   })();
 }
 
-export function findAgentsByCapability(capability: string, onlineOnly = true): AgentCard[] {
-  let sql = `SELECT * FROM agents WHERE EXISTS (SELECT 1 FROM json_each(capabilities) WHERE value = ?)`;
-  const params: any[] = [capability];
-  if (onlineOnly) {
-    sql += ` AND status != 'offline' AND last_seen > ?`;
-    params.push(Date.now() - STALE_TTL_MS);
-  }
-  sql += " ORDER BY last_seen DESC";
-  return (db.query(sql).all(...params) as any[]).map(rowToAgent);
-}
-
 export function deleteAgent(id: string): { ok: boolean; error?: string } {
   if (id === "user" || id === "system") {
     return { ok: false, error: "built-in agent cannot be deleted" };
@@ -3023,21 +3120,6 @@ function pairPeer(pair: PairSession, agentId: string): string {
   return pair.requesterId === agentId ? pair.targetId : pair.requesterId;
 }
 
-function agentMatchesPairTarget(agent: AgentCard, target: string): boolean {
-  if (target.startsWith("id:")) return agent.id === target.slice(3);
-  if (target.startsWith("label:")) return agent.label === target.slice(6);
-  if (target.startsWith("tag:")) return agent.tags.includes(target.slice(4));
-  if (target.startsWith("cap:")) return agent.capabilities.includes(target.slice(4));
-  if (target.startsWith("rig:")) return agent.rig === target.slice(4);
-  if (target.startsWith("machine:")) return agent.machine === target.slice(8);
-  return agent.id === target ||
-    agent.label === target ||
-    agent.tags.includes(target) ||
-    agent.capabilities.includes(target) ||
-    agent.rig === target ||
-    agent.name === target;
-}
-
 function resolvePairTarget(target: string, requesterId: string): {
   ok: true;
   agent: AgentCard;
@@ -3048,7 +3130,7 @@ function resolvePairTarget(target: string, requesterId: string): {
   matches?: AgentCard[];
   busy?: Array<{ agent: AgentCard; pair: PairSession }>;
 } {
-  const matches = listAgents().filter((agent) => agent.id !== requesterId && agentMatchesPairTarget(agent, target));
+  const matches = matchAgents(target, listAgents(), { excludeId: requesterId });
   if (matches.length === 0) return { ok: false, code: "not_found", error: `no agent matches ${target}` };
 
   const live = matches.filter((agent) => agent.status !== "offline" && agent.ready);
@@ -4678,6 +4760,113 @@ export function getStats(): {
   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];
+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;
+}
+
+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 = db
+    .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 = db
+    .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 = (
+    db
+      .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[] = [];
 

package/src/managed-policy.ts

@@ -1,4 +1,4 @@
-import { getAgentProfile } from "./config-store";
+import { getAgentProfile, spawnGrantForProfile } from "./config-store";
 import { runnerRuntimeTokenEnv } from "./runtime-tokens";
 import { buildSpawnCommand, resolveSpawnModelParams } from "./spawn-command";
 import type { SpawnPolicy, WorkspaceMode } from "./types";
@@ -29,6 +29,7 @@ export function buildManagedSpawnParams(policy: SpawnPolicy, requestId: string,
   const providerArgs = managedPolicyProviderArgs(policy);
   const prompt = managedPolicyLaunchPrompt(policy);
   const agentProfile = policy.profile ? getAgentProfile(policy.profile)?.value : undefined;
+  const grant = spawnGrantForProfile(policy.profile);
   return buildSpawnCommand({
     provider: policy.provider,
     cwd: policy.cwd,
@@ -55,6 +56,8 @@ export function buildManagedSpawnParams(policy: SpawnPolicy, requestId: string,
       policyName: policy.name,
       spawnRequestId: requestId,
       createdBy: ctx.createdBy,
+      canSpawn: grant.canSpawn,
+      maxSpawnedAgents: grant.maxSpawnedAgents,
     }),
     requestedBy: ctx.createdBy,
     requestedAt: ctx.requestedAt ?? Date.now(),