@agent-live/cli 0.0.1

package/server/real/data.mjs

@@ -0,0 +1,170 @@
+import { openDb, createSqliteStore, subscribeAll } from '@agent-live/sdk'
+
+const CHANNELS = new Set(['whatsapp', 'email', 'web', 'api'])
+const DEGRADED_FAILURE_RATE = 0.2
+const STALE_BUSY_WINDOW_MS = 5 * 60_000
+
+function coerceChannel(channel) {
+  return CHANNELS.has(channel) ? channel : 'api'
+}
+
+function coerceStatus(status) {
+  // The contract has no 'stale' status — a run orphaned by a server
+  // restart reads most truthfully as cancelled, not completed/failed.
+  return status === 'stale' ? 'cancelled' : status
+}
+
+function customerAliasFor(sessionKey) {
+  return sessionKey ? `Session ${sessionKey.slice(0, 8)}` : 'Unknown session'
+}
+
+function toRun(row) {
+  return {
+    id: row.id,
+    agentId: row.agentId || 'unassigned',
+    customerId: row.sessionKey,
+    channel: coerceChannel(row.channel),
+    status: coerceStatus(row.status),
+    startedAt: row.startedAt,
+    completedAt: row.completedAt,
+    durationMs: row.durationMs,
+    summary: row.outputPreview || row.inputPreview || '',
+    agentName: row.agentName || row.agentId || 'Unassigned agent',
+    customerAlias: customerAliasFor(row.sessionKey),
+    customerHint: coerceChannel(row.channel),
+  }
+}
+
+function isRunningRecently(run) {
+  return run.status === 'running' && Date.now() - Date.parse(run.startedAt) < STALE_BUSY_WINDOW_MS
+}
+
+/** Opens the SDK's SQLite store and exposes the console's `/api/*` shapes from real recorded data. */
+export function createRealData({ dbPath }) {
+  const db = openDb(dbPath)
+  const store = createSqliteStore(db)
+  store.markStaleRunsOnStartup()
+
+  function allRuns() {
+    return store.listRunsAll({ limit: 500 })
+  }
+
+  function agentGroups() {
+    const groups = new Map()
+    for (const run of allRuns()) {
+      const agentId = run.agentId || 'unassigned'
+      if (!groups.has(agentId)) groups.set(agentId, [])
+      groups.get(agentId).push(run)
+    }
+    return groups
+  }
+
+  function agentSummary(agentId, runs) {
+    const today = Date.now() - 24 * 60 * 60_000
+    const runsToday = runs.filter((r) => Date.parse(r.startedAt) >= today)
+    const terminal = runs.filter((r) => r.status === 'completed' || r.status === 'failed')
+    const failureRate = terminal.length ? terminal.filter((r) => r.status === 'failed').length / terminal.length : 0
+    const busy = runs.some(isRunningRecently)
+    const status = busy ? 'busy' : failureRate >= DEGRADED_FAILURE_RATE ? 'degraded' : 'idle'
+    const latest = runs.slice().sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt))[0]
+    const name = latest?.agentName || agentId
+    const channels = [...new Set(runs.map((r) => coerceChannel(r.channel)))]
+    return {
+      id: agentId,
+      name,
+      description: '',
+      status,
+      channels,
+      runsToday: runsToday.length,
+      failureRate,
+      lastActivityAt: latest?.startedAt ?? new Date(0).toISOString(),
+    }
+  }
+
+  function listAgents() {
+    const groups = agentGroups()
+    const agents = [...groups.entries()]
+      .filter(([agentId]) => agentId && agentId !== 'unassigned')
+      .map(([agentId, runs]) => agentSummary(agentId, runs))
+    return { agents }
+  }
+
+  function channelBreakdown() {
+    const runs = allRuns()
+    const counts = {}
+    for (const run of runs) {
+      const channel = coerceChannel(run.channel)
+      counts[channel] = (counts[channel] || 0) + 1
+    }
+    const total = runs.length || 1
+    return Object.entries(counts)
+      .map(([channel, count]) => ({ channel, count, pct: Math.round((count / total) * 100) }))
+      .sort((a, b) => b.count - a.count)
+  }
+
+  function listTouchpoints() {
+    // Not tracked by the recorder yet — see plan decision on empty vs. derived state.
+    return { breakdown: channelBreakdown(), recent: [] }
+  }
+
+  function listRuns(agentId) {
+    return { runs: allRuns().filter((r) => !agentId || r.agentId === agentId).map(toRun) }
+  }
+
+  function listApprovals() {
+    return { approvals: [] }
+  }
+
+  function listDeliveries() {
+    return { deliveries: [] }
+  }
+
+  function buildOverview() {
+    const runs = allRuns()
+    const { agents } = listAgents()
+    return {
+      org: { id: 'self-hosted', name: 'Self-hosted', mode: 'self-hosted' },
+      stats: {
+        activeAgents: agents.filter((a) => a.status === 'busy' || a.status === 'degraded').length,
+        agentCount: agents.length,
+        openApprovals: 0,
+        failedDeliveries: 0,
+        touchesToday: runs.filter((r) => Date.now() - Date.parse(r.startedAt) < 24 * 60 * 60_000).length,
+        runningRuns: runs.filter((r) => r.status === 'running').length,
+      },
+      recentRuns: runs
+        .slice()
+        .sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt))
+        .slice(0, 6)
+        .map(toRun),
+      channelBreakdown: channelBreakdown(),
+      attention: [],
+    }
+  }
+
+  /** Bridges the SDK's cross-tenant event bus into the console's SSE `run-event` shape. */
+  function subscribe(broadcast) {
+    return subscribeAll((event) => {
+      const run = store.getRun(event.runId)
+      broadcast('run-event', {
+        ...event,
+        agentId: run?.agentId ?? null,
+        agentName: run?.agentName ?? run?.agentId ?? null,
+        customerAlias: run ? customerAliasFor(run.sessionKey) : null,
+      })
+    })
+  }
+
+  return {
+    buildOverview,
+    listAgents,
+    listTouchpoints,
+    listRuns,
+    listApprovals,
+    listDeliveries,
+    subscribe,
+    dispose() {
+      db.close()
+    },
+  }
+}