@klars/agentobs 0.1.0

package/dist/core/queries.js

@@ -0,0 +1,143 @@
+/** Start of a range as an ISO string, or null for "all". */
+export function rangeStart(range) {
+    const now = new Date();
+    switch (range) {
+        case 'today': {
+            const d = new Date(now);
+            d.setHours(0, 0, 0, 0);
+            return d.toISOString();
+        }
+        case '7d':
+            return new Date(now.getTime() - 7 * 864e5).toISOString();
+        case '30d':
+            return new Date(now.getTime() - 30 * 864e5).toISOString();
+        default:
+            return null;
+    }
+}
+export function getSummary(db, range) {
+    const since = rangeStart(range);
+    const where = since ? 'WHERE started_at >= ?' : '';
+    const args = since ? [since] : [];
+    const calls = db
+        .prepare(`SELECT
+         COUNT(*) AS tool_calls,
+         COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
+         COALESCE(SUM(CASE WHEN status = 'blocked' THEN 1 ELSE 0 END), 0) AS blocked,
+         COALESCE(SUM(tokens_in), 0) AS tokens_in,
+         COALESCE(SUM(tokens_out), 0) AS tokens_out,
+         SUM(cost_usd) AS total_cost_usd,
+         COALESCE(SUM(CASE WHEN cost_usd IS NULL AND status <> 'pending' THEN 1 ELSE 0 END), 0) AS uncosted_calls,
+         AVG(duration_ms) AS avg_duration_ms
+       FROM tool_calls ${where}`)
+        .get(...args);
+    const sessions = db.prepare(`SELECT COUNT(*) AS n FROM sessions ${where}`).get(...args);
+    const toolCalls = Number(calls.tool_calls ?? 0);
+    const errors = Number(calls.errors ?? 0);
+    return {
+        range,
+        since,
+        total_cost_usd: calls.total_cost_usd === null ? null : Number(calls.total_cost_usd),
+        uncosted_calls: Number(calls.uncosted_calls ?? 0),
+        tool_calls: toolCalls,
+        sessions: Number(sessions.n ?? 0),
+        errors,
+        blocked: Number(calls.blocked ?? 0),
+        error_rate: toolCalls === 0 ? 0 : errors / toolCalls,
+        tokens_in: Number(calls.tokens_in ?? 0),
+        tokens_out: Number(calls.tokens_out ?? 0),
+        avg_duration_ms: calls.avg_duration_ms === null ? null : Number(calls.avg_duration_ms),
+    };
+}
+/**
+ * Activity/cost over time. Buckets hourly for `today` and daily otherwise so
+ * the chart keeps a readable number of points at every range.
+ */
+export function getTimeline(db, range) {
+    const since = rangeStart(range);
+    const fmt = range === 'today' ? '%Y-%m-%dT%H:00' : '%Y-%m-%d';
+    const where = since ? 'WHERE started_at >= ?' : '';
+    const args = since ? [since] : [];
+    return db
+        .prepare(`SELECT strftime(?, started_at) AS bucket,
+              COUNT(*) AS calls,
+              COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
+              SUM(cost_usd) AS cost_usd,
+              COALESCE(SUM(COALESCE(tokens_in, 0) + COALESCE(tokens_out, 0)), 0) AS tokens
+         FROM tool_calls ${where}
+        GROUP BY bucket
+        ORDER BY bucket ASC`)
+        .all(fmt, ...args);
+}
+export function getToolsBreakdown(db, range) {
+    const since = rangeStart(range);
+    const where = since ? 'WHERE started_at >= ?' : '';
+    const args = since ? [since] : [];
+    return db
+        .prepare(`SELECT tool_name,
+              COUNT(*) AS calls,
+              COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
+              COALESCE(SUM(CASE WHEN status = 'blocked' THEN 1 ELSE 0 END), 0) AS blocked,
+              SUM(cost_usd) AS cost_usd,
+              AVG(duration_ms) AS avg_duration_ms
+         FROM tool_calls ${where}
+        GROUP BY tool_name
+        ORDER BY calls DESC`)
+        .all(...args);
+}
+export function getRecentToolCalls(db, opts = {}) {
+    const limit = Math.min(Math.max(opts.limit ?? 50, 1), 500);
+    const clauses = [];
+    const args = [];
+    const since = opts.range ? rangeStart(opts.range) : null;
+    if (since) {
+        clauses.push('tc.started_at >= ?');
+        args.push(since);
+    }
+    if (opts.status) {
+        clauses.push('tc.status = ?');
+        args.push(opts.status);
+    }
+    if (opts.sessionId) {
+        clauses.push('tc.session_id = ?');
+        args.push(opts.sessionId);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(' AND ')}` : '';
+    return db
+        .prepare(`SELECT tc.id, tc.session_id, s.agent_name, tc.tool_name, tc.started_at,
+              tc.duration_ms, tc.status, tc.input_summary, tc.output_summary,
+              tc.cost_usd, tc.error_message,
+              (SELECT pd.rule_matched FROM policy_decisions pd
+                WHERE pd.tool_call_id = tc.id
+                ORDER BY pd.decided_at DESC LIMIT 1) AS rule_matched
+         FROM tool_calls tc
+         LEFT JOIN sessions s ON s.id = tc.session_id
+         ${where}
+        ORDER BY tc.started_at DESC
+        LIMIT ?`)
+        .all(...args, limit);
+}
+export function getSessions(db, opts = {}) {
+    const limit = Math.min(Math.max(opts.limit ?? 50, 1), 500);
+    const since = opts.range ? rangeStart(opts.range) : null;
+    const where = since ? 'WHERE started_at >= ?' : '';
+    const args = since ? [since] : [];
+    return db
+        .prepare(`SELECT id, agent_name, started_at, ended_at, cwd, fidelity, tool_call_count,
+              error_count, blocked_count, total_cost_usd, total_tokens_in,
+              total_tokens_out, exit_code
+         FROM sessions ${where}
+        ORDER BY started_at DESC
+        LIMIT ?`)
+        .all(...args, limit);
+}
+export function getPolicyDecisions(db, opts = {}) {
+    const limit = Math.min(Math.max(opts.limit ?? 100, 1), 500);
+    return db
+        .prepare(`SELECT id, tool_call_id, session_id, tool_name, rule_matched, decision, reason, decided_at
+         FROM policy_decisions
+        ORDER BY decided_at DESC
+        LIMIT ?`)
+        .all(limit);
+}
+//# sourceMappingURL=queries.js.map

package/dist/core/redact.js

@@ -0,0 +1,150 @@
+/**
+ * Secret redaction for anything that lands in input_summary/output_summary.
+ *
+ * This runs before a summary is written to disk or pushed to the cloud, and
+ * it is the single reason a hosted tier is trustworthy enough to use: an
+ * agent's tool calls routinely contain exactly the credentials that would be
+ * most damaging to leak (a `Bash` call exporting an API key, an `Edit`
+ * writing a .env file, a curl carrying an Authorization header).
+ *
+ * Design posture is deliberately over-eager. A false positive costs a user
+ * some readability in one dashboard row; a false negative writes a live
+ * credential to a database and possibly into a shared team view. Those costs
+ * are not symmetric, so when a token merely *looks* like a secret, it goes.
+ *
+ * Ordering matters: vendor-specific patterns run before the generic
+ * structural ones so a recognisable key is labelled by provider
+ * (`[REDACTED:aws-access-key-id]`) rather than the vague
+ * `[REDACTED:assignment]`. That makes an audit of "what did we nearly leak"
+ * far more actionable. The structural rules then skip any value that already
+ * carries a marker, so they can never relabel a precise hit.
+ */
+/**
+ * Vendor-specific credential shapes, matched on distinctive prefixes and so
+ * effectively free of false positives.
+ */
+const VENDOR_RULES = [
+    { name: 'aws-access-key-id', pattern: /\b(?:AKIA|ASIA|ABIA|ACCA)[0-9A-Z]{16}\b/g },
+    { name: 'anthropic-api-key', pattern: /\bsk-ant-[A-Za-z0-9_-]{20,}/g },
+    { name: 'openai-api-key', pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}/g },
+    { name: 'github-token', pattern: /\b(?:ghp|gho|ghu|ghs|ghr|github_pat)_[A-Za-z0-9_]{20,}/g },
+    { name: 'gitlab-token', pattern: /\bglpat-[A-Za-z0-9_-]{18,}/g },
+    { name: 'slack-token', pattern: /\bxox[abprs]-[A-Za-z0-9-]{10,}/g },
+    { name: 'stripe-key', pattern: /\b(?:sk|rk|pk)_(?:live|test)_[A-Za-z0-9]{16,}/g },
+    { name: 'resend-key', pattern: /\bre_[A-Za-z0-9_-]{16,}/g },
+    { name: 'google-api-key', pattern: /\bAIza[0-9A-Za-z_-]{30,}/g },
+    { name: 'sendgrid-key', pattern: /\bSG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}/g },
+    { name: 'npm-token', pattern: /\bnpm_[A-Za-z0-9]{30,}/g },
+    { name: 'jwt', pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g },
+    { name: 'private-key-block', pattern: /-----BEGIN[A-Z ]*PRIVATE KEY-----[\s\S]*?-----END[A-Z ]*PRIVATE KEY-----/g },
+];
+/**
+ * A secret-ish *name*. The structural rules below key off this rather than
+ * the value's shape, which is what catches the long tail no vendor list can
+ * (`DB_PASSWORD=hunter2`, `--token abc`, `"client_secret": "..."`).
+ */
+const SENSITIVE_NAME = String.raw `[A-Za-z0-9_.-]*(?:passwd|password|secret|token|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret|auth|credential|session[_-]?id|cookie|passphrase|signing[_-]?key|webhook[_-]?secret|dsn)[A-Za-z0-9_.-]*`;
+/** Value shapes: a quoted string, or a bare run of non-delimiter chars. */
+const QUOTED_OR_BARE = String.raw `"[^"\n]{4,}"|'[^'\n]{4,}'|[^\s,;"'\n})]{4,}`;
+/** Skips a value a vendor rule already replaced, so labels stay precise. */
+const NOT_ALREADY_REDACTED = String.raw `(?!\[REDACTED:)`;
+const STRUCTURAL_RULES = [
+    // Authorization: Bearer <token>. Must run BEFORE `assignment`: the header
+    // name "Authorization" itself matches SENSITIVE_NAME, so assignment would
+    // otherwise consume the scheme word `Bearer` as the value and leave the
+    // real credential sitting in the clear after it.
+    {
+        name: 'auth-header',
+        pattern: new RegExp(String.raw `\b(Bearer|Basic|Token)(\s+)${NOT_ALREADY_REDACTED}([A-Za-z0-9_\-.=+/]{8,})`, 'gi'),
+        group: 3,
+    },
+    // KEY=value, KEY: value, "key": "value"
+    {
+        name: 'assignment',
+        pattern: new RegExp(String.raw `("?\b${SENSITIVE_NAME}"?\s*[:=]\s*)${NOT_ALREADY_REDACTED}(${QUOTED_OR_BARE})`, 'gi'),
+        group: 2,
+    },
+    // CLI flags: --token abc, --api-key=abc
+    {
+        name: 'cli-flag',
+        pattern: new RegExp(String.raw `(--?${SENSITIVE_NAME}[=\s]+)${NOT_ALREADY_REDACTED}("[^"\n]{4,}"|'[^'\n]{4,}'|[^\s"'\n]{4,})`, 'gi'),
+        group: 2,
+    },
+    // Credentials embedded in a URL: proto://user:pass@host
+    //
+    // The userinfo halves exclude '[' and ']' so this cannot re-wrap a marker
+    // a vendor rule already inserted. A plain NOT_ALREADY_REDACTED lookahead
+    // is not enough here: "[REDACTED:github-token]" itself contains a ':',
+    // so the rule would read "[REDACTED" as the username and re-redact the
+    // rest into an unreadable "[REDACTED:[REDACTED:url-credentials]".
+    {
+        name: 'url-credentials',
+        pattern: new RegExp(String.raw `(:\/\/[^\s:@/\[\]]{1,64}:)${NOT_ALREADY_REDACTED}([^\s@/\[\]]{1,256})(?=@)`, 'g'),
+        group: 2,
+    },
+];
+const ALL_RULES = [...VENDOR_RULES, ...STRUCTURAL_RULES];
+/** Default summary cap: long enough to be useful, short enough to stay cheap. */
+export const DEFAULT_MAX_LENGTH = 500;
+/**
+ * Redact secrets from `input`, then truncate.
+ *
+ * Redaction runs before truncation deliberately: truncating first could slice
+ * a credential in half, leaving a fragment that matches no pattern but is
+ * still sensitive (and, for a short key, still brute-forceable).
+ */
+export function redact(input, maxLength = DEFAULT_MAX_LENGTH) {
+    if (input === null || input === undefined)
+        return { text: '', redactions: [] };
+    let text = typeof input === 'string' ? input : safeStringify(input);
+    const fired = new Set();
+    for (const rule of ALL_RULES) {
+        // These regexes carry /g and are module-level constants, so lastIndex
+        // must be reset: a stale value from a previous call would silently skip
+        // matches near the start of this string.
+        rule.pattern.lastIndex = 0;
+        text = text.replace(rule.pattern, (...args) => {
+            const match = args[0];
+            const groups = args.slice(1, -2);
+            fired.add(rule.name);
+            const secret = rule.group ? groups[rule.group - 1] : undefined;
+            if (secret === undefined)
+                return `[REDACTED:${rule.name}]`;
+            return match.replace(secret, `[REDACTED:${rule.name}]`);
+        });
+    }
+    if (text.length > maxLength) {
+        text = `${text.slice(0, maxLength)}… (+${text.length - maxLength} chars)`;
+    }
+    return { text, redactions: [...fired] };
+}
+/** Convenience wrapper for callers that only want the cleaned text. */
+export function redactText(input, maxLength) {
+    return redact(input, maxLength).text;
+}
+/**
+ * JSON.stringify that cannot throw. Tool payloads arrive from external
+ * processes and may contain cycles or BigInts; the logging layer must never
+ * be the thing that crashes the agent it is observing.
+ */
+function safeStringify(value) {
+    const seen = new WeakSet();
+    try {
+        return (JSON.stringify(value, (_key, val) => {
+            if (typeof val === 'bigint')
+                return val.toString();
+            if (typeof val === 'object' && val !== null) {
+                if (seen.has(val))
+                    return '[Circular]';
+                seen.add(val);
+            }
+            return val;
+        }) ?? String(value));
+    }
+    catch {
+        return String(value);
+    }
+}
+/** Exposed for tests and for `agentobs policy test` diagnostics. */
+export const __ruleNames = ALL_RULES.map((r) => r.name);
+//# sourceMappingURL=redact.js.map

package/dist/core/repo.js

@@ -0,0 +1,89 @@
+import { randomUUID } from 'node:crypto';
+import { redact } from './redact.js';
+import { computeCost } from './pricing.js';
+import { getMeta } from './db.js';
+const nowIso = () => new Date().toISOString();
+export function startSession(db, input) {
+    const id = input.id ?? randomUUID();
+    const ts = input.startedAt ?? nowIso();
+    db.prepare(`INSERT INTO sessions (id, agent_name, started_at, cwd, git_branch, fidelity, device_id, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO NOTHING`).run(id, input.agentName, ts, input.cwd ?? null, input.gitBranch ?? null, input.fidelity ?? 'rich', getMeta(db, 'device_id'), ts);
+    return id;
+}
+export function endSession(db, sessionId, opts = {}) {
+    db.prepare(`UPDATE sessions
+        SET ended_at = ?, exit_code = ?, updated_at = ?, synced_at = NULL
+      WHERE id = ?`).run(opts.endedAt ?? nowIso(), opts.exitCode ?? null, nowIso(), sessionId);
+}
+/**
+ * Ensures a session row exists before a tool call references it.
+ *
+ * Hooks can fire without a SessionStart ever reaching us - the agent may
+ * have been running before AgentObs was installed, or a SessionStart hook
+ * may not be configured. Dropping those tool calls would silently lose data,
+ * so we synthesise the parent session instead.
+ */
+export function ensureSession(db, sessionId, agentName, cwd) {
+    const exists = db.prepare('SELECT 1 FROM sessions WHERE id = ?').get(sessionId);
+    if (!exists)
+        startSession(db, { id: sessionId, agentName, cwd });
+}
+/** Inserts a `pending` tool call at PreToolUse time. Returns its id. */
+export function beginToolCall(db, input) {
+    const id = input.id ?? randomUUID();
+    const ts = input.startedAt ?? nowIso();
+    const summary = redact(input.input);
+    db.prepare(`INSERT INTO tool_calls (id, session_id, tool_name, started_at, status, input_summary, model, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO NOTHING`).run(id, input.sessionId, input.toolName, ts, input.status ?? 'pending', summary.text, input.model ?? null, ts);
+    return id;
+}
+/** Finalises a tool call at PostToolUse time, computing duration and cost. */
+export function completeToolCall(db, toolCallId, input) {
+    const row = db
+        .prepare('SELECT started_at, session_id, model FROM tool_calls WHERE id = ?')
+        .get(toolCallId);
+    if (!row)
+        return;
+    const endedAt = input.endedAt ?? nowIso();
+    const durationMs = Math.max(0, Date.parse(endedAt) - Date.parse(row.started_at));
+    const model = input.model ?? row.model;
+    const cost = computeCost(model, input.tokensIn, input.tokensOut);
+    const summary = redact(input.output);
+    db.prepare(`UPDATE tool_calls
+        SET ended_at = ?, duration_ms = ?, status = ?, output_summary = ?,
+            tokens_in = ?, tokens_out = ?, cost_usd = ?, model = ?,
+            error_message = ?, updated_at = ?, synced_at = NULL
+      WHERE id = ?`).run(endedAt, durationMs, input.status, summary.text, input.tokensIn ?? null, input.tokensOut ?? null, cost, model, input.errorMessage ? redact(input.errorMessage, 300).text : null, nowIso(), toolCallId);
+    rollUpSession(db, row.session_id);
+}
+/**
+ * Recomputes a session's aggregates from its tool calls.
+ *
+ * Deliberately a full re-aggregation rather than incremental counters: a
+ * hook that fires twice, or a crash between insert and update, would drift
+ * an incremental counter permanently, and these totals are what the whole
+ * dashboard reports. Cost is SUM over known-model rows only, so an unknown
+ * model leaves the total honest rather than silently under-reporting.
+ */
+export function rollUpSession(db, sessionId) {
+    db.prepare(`UPDATE sessions SET
+        tool_call_count  = (SELECT COUNT(*) FROM tool_calls WHERE session_id = ?),
+        error_count      = (SELECT COUNT(*) FROM tool_calls WHERE session_id = ? AND status = 'error'),
+        blocked_count    = (SELECT COUNT(*) FROM tool_calls WHERE session_id = ? AND status = 'blocked'),
+        total_tokens_in  = (SELECT COALESCE(SUM(tokens_in), 0) FROM tool_calls WHERE session_id = ?),
+        total_tokens_out = (SELECT COALESCE(SUM(tokens_out), 0) FROM tool_calls WHERE session_id = ?),
+        total_cost_usd   = (SELECT SUM(cost_usd) FROM tool_calls WHERE session_id = ?),
+        updated_at       = ?,
+        synced_at        = NULL
+      WHERE id = ?`).run(sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, nowIso(), sessionId);
+}
+/** Records a policy decision - the audit trail behind every block. */
+export function recordPolicyDecision(db, input) {
+    const id = randomUUID();
+    db.prepare(`INSERT INTO policy_decisions (id, tool_call_id, session_id, tool_name, rule_matched, decision, reason, decided_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.toolCallId ?? null, input.sessionId ?? null, input.toolName ?? null, input.ruleMatched ?? null, input.decision, input.reason ?? null, nowIso());
+    return id;
+}
+//# sourceMappingURL=repo.js.map

package/dist/core/schema.sql

@@ -0,0 +1,78 @@
+-- AgentObs local schema. Applied idempotently on every open() via
+-- migrations in db.ts, so a fresh install and an upgrade take the same
+-- path. Timestamps are ISO-8601 UTC strings throughout - SQLite has no
+-- native date type, and storing text keeps rows readable in a plain
+-- `sqlite3` shell during support/debugging.
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id                TEXT PRIMARY KEY,
+  agent_name        TEXT NOT NULL,
+  started_at        TEXT NOT NULL,
+  ended_at          TEXT,
+  cwd               TEXT,
+  git_branch        TEXT,
+  total_tokens_in   INTEGER NOT NULL DEFAULT 0,
+  total_tokens_out  INTEGER NOT NULL DEFAULT 0,
+  total_cost_usd    REAL,
+  tool_call_count   INTEGER NOT NULL DEFAULT 0,
+  error_count       INTEGER NOT NULL DEFAULT 0,
+  blocked_count     INTEGER NOT NULL DEFAULT 0,
+  -- Fidelity of this session's data, so the dashboard can be honest about
+  -- what it does and doesn't know rather than implying detail it lacks:
+  --   "rich"   - per-tool-call detail (hook-based adapters)
+  --   "coarse" - session duration/exit code only (process-wrap)
+  fidelity          TEXT NOT NULL DEFAULT 'rich',
+  exit_code         INTEGER,
+  -- Cloud-sync columns. Present from the start so the local schema never
+  -- needs a breaking migration when sync ships; null until logged in.
+  device_id         TEXT,
+  account_id        TEXT,
+  updated_at        TEXT NOT NULL,
+  synced_at         TEXT
+);
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id              TEXT PRIMARY KEY,
+  session_id      TEXT NOT NULL REFERENCES sessions(id),
+  tool_name       TEXT NOT NULL,
+  started_at      TEXT NOT NULL,
+  ended_at        TEXT,
+  duration_ms     INTEGER,
+  status          TEXT NOT NULL,          -- success | error | pending | blocked
+  input_summary   TEXT,                   -- truncated + secret-redacted
+  output_summary  TEXT,                   -- truncated + secret-redacted
+  tokens_in       INTEGER,
+  tokens_out      INTEGER,
+  cost_usd        REAL,
+  model           TEXT,
+  error_message   TEXT,
+  updated_at      TEXT NOT NULL,
+  synced_at       TEXT
+);
+
+CREATE TABLE IF NOT EXISTS policy_decisions (
+  id             TEXT PRIMARY KEY,
+  tool_call_id   TEXT REFERENCES tool_calls(id),
+  session_id     TEXT,
+  tool_name      TEXT,
+  rule_matched   TEXT,                    -- null when default_decision applied
+  decision       TEXT NOT NULL,           -- allow | block | needs_approval
+  reason         TEXT,
+  decided_at     TEXT NOT NULL,
+  synced_at      TEXT
+);
+
+-- Single-row table holding this install's identity and local settings.
+CREATE TABLE IF NOT EXISTS meta (
+  key    TEXT PRIMARY KEY,
+  value  TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_tool_calls_session   ON tool_calls(session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_started   ON tool_calls(started_at);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_status    ON tool_calls(status);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_unsynced  ON tool_calls(synced_at) WHERE synced_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_sessions_started     ON sessions(started_at);
+CREATE INDEX IF NOT EXISTS idx_sessions_unsynced    ON sessions(synced_at) WHERE synced_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_policy_tool_call     ON policy_decisions(tool_call_id);
+CREATE INDEX IF NOT EXISTS idx_policy_decided       ON policy_decisions(decided_at);

package/dist/server/index.js

@@ -0,0 +1,162 @@
+/**
+ * Local dashboard server.
+ *
+ * Uses node:http directly rather than express/fastify: the routing surface is
+ * a handful of GET endpoints, and a zero-dependency server keeps `npx
+ * agentobs` install-fast and shrinks the supply-chain surface of a tool that
+ * reads a developer's activity.
+ *
+ * Security posture: binds 127.0.0.1 by default, where same-machine access is
+ * the same trust boundary as the database file itself. Binding anywhere else
+ * requires a token (see requireToken), because the dashboard exposes tool
+ * inputs and file paths across the network.
+ */
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, extname, join, normalize } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { timingSafeEqual } from 'node:crypto';
+import { openDb } from '../core/db.js';
+import { getPolicyDecisions, getRecentToolCalls, getSessions, getSummary, getTimeline, getToolsBreakdown, } from '../core/queries.js';
+import { loadPolicy } from '../core/policy-engine.js';
+const PUBLIC_DIR = join(dirname(fileURLToPath(import.meta.url)), 'public');
+const MIME = {
+    '.html': 'text/html; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.json': 'application/json; charset=utf-8',
+    '.ico': 'image/x-icon',
+    '.woff2': 'font/woff2',
+};
+function parseRange(value) {
+    return value === 'today' || value === '7d' || value === '30d' || value === 'all' ? value : '7d';
+}
+function json(res, body, status = 200) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Length': Buffer.byteLength(payload),
+        // The dashboard renders tool inputs; never let a browser cache or a
+        // proxy hold on to them.
+        'Cache-Control': 'no-store',
+        'X-Content-Type-Options': 'nosniff',
+    });
+    res.end(payload);
+}
+export function isLoopback(host) {
+    return host === '127.0.0.1' || host === 'localhost' || host === '::1';
+}
+/**
+ * Constant-time token comparison.
+ *
+ * A plain `===` leaks the token's prefix through timing. That matters here
+ * precisely because the non-loopback mode is the one exposed to a network.
+ */
+function tokenMatches(expected, provided) {
+    if (!provided)
+        return false;
+    const a = Buffer.from(expected);
+    const b = Buffer.from(provided);
+    if (a.length !== b.length)
+        return false;
+    return timingSafeEqual(a, b);
+}
+export function createDashboardServer(opts) {
+    const db = opts.db ?? openDb();
+    const requireToken = !isLoopback(opts.host);
+    return createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+            if (req.method !== 'GET' && req.method !== 'HEAD') {
+                json(res, { error: 'method not allowed' }, 405);
+                return;
+            }
+            if (requireToken) {
+                const supplied = url.searchParams.get('token') ??
+                    (req.headers.authorization?.startsWith('Bearer ')
+                        ? req.headers.authorization.slice(7)
+                        : null);
+                if (!opts.token || !tokenMatches(opts.token, supplied)) {
+                    json(res, { error: 'unauthorized: pass ?token=<value> printed at startup' }, 401);
+                    return;
+                }
+            }
+            const range = parseRange(url.searchParams.get('range'));
+            switch (url.pathname) {
+                case '/api/summary':
+                    json(res, getSummary(db, range));
+                    return;
+                case '/api/timeline':
+                    json(res, getTimeline(db, range));
+                    return;
+                case '/api/tools-breakdown':
+                    json(res, getToolsBreakdown(db, range));
+                    return;
+                case '/api/tool-calls':
+                    json(res, {
+                        calls: getRecentToolCalls(db, {
+                            range,
+                            limit: Number(url.searchParams.get('limit') ?? 50),
+                            status: url.searchParams.get('status') ?? undefined,
+                            sessionId: url.searchParams.get('session') ?? undefined,
+                        }),
+                    });
+                    return;
+                case '/api/sessions':
+                    json(res, {
+                        sessions: getSessions(db, {
+                            range,
+                            limit: Number(url.searchParams.get('limit') ?? 50),
+                        }),
+                    });
+                    return;
+                case '/api/policy':
+                    json(res, {
+                        ...loadPolicy(),
+                        decisions: getPolicyDecisions(db, { limit: 100 }),
+                    });
+                    return;
+                case '/api/health':
+                    json(res, { ok: true, version: 1 });
+                    return;
+            }
+            await serveStatic(url.pathname, res);
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+    });
+}
+async function serveStatic(pathname, res) {
+    const rel = pathname === '/' ? 'index.html' : pathname.replace(/^\/+/, '');
+    // normalize + prefix check keeps a crafted "../.." from escaping the
+    // public directory and serving arbitrary files off the user's disk.
+    const target = normalize(join(PUBLIC_DIR, rel));
+    if (!target.startsWith(PUBLIC_DIR) || !existsSync(target)) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('not found');
+        return;
+    }
+    const body = await readFile(target);
+    res.writeHead(200, {
+        'Content-Type': MIME[extname(target)] ?? 'application/octet-stream',
+        'Content-Length': body.length,
+        'Cache-Control': 'no-store',
+        'X-Content-Type-Options': 'nosniff',
+    });
+    res.end(body);
+}
+export function startDashboard(opts) {
+    const server = createDashboardServer(opts);
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(opts.port, opts.host, () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : opts.port;
+            resolve({ port, close: () => server.close() });
+        });
+    });
+}
+//# sourceMappingURL=index.js.map