@hasna/logs 0.0.1

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@hasna/logs",
+  "version": "0.0.1",
+  "description": "Log aggregation + browser script + headless page scanner + performance monitoring for AI agents",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "logs": "./dist/cli/index.js",
+    "logs-mcp": "./dist/mcp/index.js",
+    "logs-serve": "./dist/server/index.js"
+  },
+  "scripts": {
+    "build": "bun build src/cli/index.ts src/mcp/index.ts src/server/index.ts --outdir dist --target bun --splitting --external playwright --external playwright-core --external electron --external chromium-bidi --external lighthouse",
+    "dev": "bun run src/server/index.ts",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage",
+    "lint": "biome check src/"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": ["logs", "monitoring", "mcp", "ai-agents", "sentry", "performance", "lighthouse"],
+  "author": "Andrei Hasna <andrei@hasna.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "commander": "^14.0.0",
+    "hono": "^4.7.11",
+    "ink": "^5.1.0",
+    "node-cron": "^3.0.3",
+    "playwright": "^1.52.0",
+    "react": "^19.1.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/bun": "latest",
+    "@types/node-cron": "^3.0.11",
+    "@types/react": "^19.1.4",
+    "typescript": "^5.9.3"
+  }
+}

package/sdk/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@hasna/logs-sdk",
+  "version": "0.0.1",
+  "description": "Zero-dependency fetch client for @hasna/logs",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./browser": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target browser"
+  },
+  "author": "Andrei Hasna <andrei@hasna.com>",
+  "license": "MIT"
+}

package/sdk/src/index.ts

@@ -0,0 +1,143 @@
+import type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob } from "../../src/types/index.ts"
+
+export type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob }
+
+export interface LogsClientOptions {
+  url?: string
+  projectId?: string
+  apiKey?: string
+}
+
+const DEFAULT_URL = "http://localhost:3460"
+
+export class LogsClient {
+  private url: string
+  private projectId?: string
+  private headers: Record<string, string>
+
+  constructor(opts: LogsClientOptions = {}) {
+    this.url = (opts.url ?? DEFAULT_URL).replace(/\/$/, "")
+    this.projectId = opts.projectId
+    this.headers = { "Content-Type": "application/json" }
+    if (opts.apiKey) this.headers["Authorization"] = `Bearer ${opts.apiKey}`
+  }
+
+  async push(entry: LogEntry): Promise<LogRow> {
+    const res = await fetch(`${this.url}/api/logs`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ project_id: this.projectId, ...entry }),
+    })
+    return res.json() as Promise<LogRow>
+  }
+
+  async pushBatch(entries: LogEntry[]): Promise<{ inserted: number }> {
+    const res = await fetch(`${this.url}/api/logs`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(entries.map(e => ({ project_id: this.projectId, ...e }))),
+    })
+    return res.json() as Promise<{ inserted: number }>
+  }
+
+  async search(query: LogQuery = {}): Promise<LogRow[]> {
+    const params = new URLSearchParams()
+    if (query.project_id ?? this.projectId) params.set("project_id", query.project_id ?? this.projectId!)
+    if (query.page_id) params.set("page_id", query.page_id)
+    if (query.level) params.set("level", Array.isArray(query.level) ? query.level.join(",") : query.level)
+    if (query.service) params.set("service", query.service)
+    if (query.since) params.set("since", query.since)
+    if (query.until) params.set("until", query.until)
+    if (query.text) params.set("text", query.text)
+    if (query.limit) params.set("limit", String(query.limit))
+    if (query.offset) params.set("offset", String(query.offset))
+    if (query.fields) params.set("fields", query.fields.join(","))
+    const res = await fetch(`${this.url}/api/logs?${params}`, { headers: this.headers })
+    return res.json() as Promise<LogRow[]>
+  }
+
+  async tail(projectId?: string, n = 50): Promise<LogRow[]> {
+    const params = new URLSearchParams({ n: String(n) })
+    const pid = projectId ?? this.projectId
+    if (pid) params.set("project_id", pid)
+    const res = await fetch(`${this.url}/api/logs/tail?${params}`, { headers: this.headers })
+    return res.json() as Promise<LogRow[]>
+  }
+
+  async summary(projectId?: string, since?: string): Promise<LogSummary[]> {
+    const params = new URLSearchParams()
+    const pid = projectId ?? this.projectId
+    if (pid) params.set("project_id", pid)
+    if (since) params.set("since", since)
+    const res = await fetch(`${this.url}/api/logs/summary?${params}`, { headers: this.headers })
+    return res.json() as Promise<LogSummary[]>
+  }
+
+  async context(traceId: string): Promise<LogRow[]> {
+    const res = await fetch(`${this.url}/api/logs/${traceId}/context`, { headers: this.headers })
+    return res.json() as Promise<LogRow[]>
+  }
+
+  async registerProject(name: string, githubRepo?: string, baseUrl?: string): Promise<Project> {
+    const res = await fetch(`${this.url}/api/projects`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ name, github_repo: githubRepo, base_url: baseUrl }),
+    })
+    return res.json() as Promise<Project>
+  }
+
+  async registerPage(projectId: string, url: string, path?: string, name?: string): Promise<Page> {
+    const res = await fetch(`${this.url}/api/projects/${projectId}/pages`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ url, path, name }),
+    })
+    return res.json() as Promise<Page>
+  }
+
+  async createScanJob(projectId: string, schedule: string, pageId?: string): Promise<ScanJob> {
+    const res = await fetch(`${this.url}/api/jobs`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ project_id: projectId, schedule, page_id: pageId }),
+    })
+    return res.json() as Promise<ScanJob>
+  }
+
+  async perfSnapshot(projectId: string, pageId?: string): Promise<PerformanceSnapshot | null> {
+    const params = new URLSearchParams({ project_id: projectId })
+    if (pageId) params.set("page_id", pageId)
+    const res = await fetch(`${this.url}/api/perf?${params}`, { headers: this.headers })
+    return res.json() as Promise<PerformanceSnapshot | null>
+  }
+
+  async perfTrend(projectId: string, pageId?: string, since?: string, limit?: number): Promise<PerformanceSnapshot[]> {
+    const params = new URLSearchParams({ project_id: projectId })
+    if (pageId) params.set("page_id", pageId)
+    if (since) params.set("since", since)
+    if (limit) params.set("limit", String(limit))
+    const res = await fetch(`${this.url}/api/perf/trend?${params}`, { headers: this.headers })
+    return res.json() as Promise<PerformanceSnapshot[]>
+  }
+}
+
+// Browser auto-capture init
+export function initLogs(opts: { projectId: string; url?: string }): void {
+  if (typeof window === "undefined") return
+  const serverUrl = (opts.url ?? DEFAULT_URL).replace(/\/$/, "")
+  const client = new LogsClient({ url: serverUrl, projectId: opts.projectId })
+  const q: LogEntry[] = []
+  const flush = () => { if (q.length) client.pushBatch(q.splice(0)).catch(() => {}) }
+  setInterval(flush, 2000)
+
+  const _ce = console.error.bind(console)
+  console.error = (...args: unknown[]) => { _ce(...args); q.push({ level: "error", message: args.map(String).join(" "), source: "script", url: location.href }) }
+
+  const _cw = console.warn.bind(console)
+  console.warn = (...args: unknown[]) => { _cw(...args); q.push({ level: "warn", message: args.map(String).join(" "), source: "script", url: location.href }) }
+
+  window.addEventListener("error", (e) => { q.push({ level: "error", message: e.message, stack_trace: e.error?.stack, source: "script", url: location.href }) })
+  window.addEventListener("unhandledrejection", (e) => { q.push({ level: "error", message: `Unhandled: ${e.reason?.message ?? e.reason}`, stack_trace: e.reason?.stack, source: "script", url: location.href }) })
+  window.addEventListener("beforeunload", flush)
+}

package/src/cli/index.ts

@@ -0,0 +1,193 @@
+#!/usr/bin/env bun
+import { Command } from "commander"
+import { getDb } from "../db/index.ts"
+import { ingestLog } from "../lib/ingest.ts"
+import { searchLogs, tailLogs } from "../lib/query.ts"
+import { summarizeLogs } from "../lib/summarize.ts"
+import { createJob, listJobs } from "../lib/jobs.ts"
+import { createPage, createProject, listPages, listProjects } from "../lib/projects.ts"
+import { runJob } from "../lib/scheduler.ts"
+import type { LogLevel } from "../types/index.ts"
+
+const program = new Command()
+  .name("logs")
+  .description("@hasna/logs — log aggregation and monitoring")
+  .version("0.0.1")
+
+// ── logs list ──────────────────────────────────────────────
+program.command("list")
+  .description("Search and list logs")
+  .option("--project <id>", "Filter by project ID")
+  .option("--page <id>", "Filter by page ID")
+  .option("--level <levels>", "Comma-separated levels (error,warn,info,debug,fatal)")
+  .option("--service <name>", "Filter by service")
+  .option("--since <iso>", "Since timestamp or relative (1h, 24h, 7d)")
+  .option("--text <query>", "Full-text search")
+  .option("--limit <n>", "Max results", "100")
+  .option("--format <fmt>", "Output format: table|json|compact", "table")
+  .action((opts) => {
+    const db = getDb()
+    const since = parseRelativeTime(opts.since)
+    const rows = searchLogs(db, {
+      project_id: opts.project,
+      page_id: opts.page,
+      level: opts.level ? (opts.level.split(",") as LogLevel[]) : undefined,
+      service: opts.service,
+      since,
+      text: opts.text,
+      limit: Number(opts.limit),
+    })
+    if (opts.format === "json") { console.log(JSON.stringify(rows, null, 2)); return }
+    if (opts.format === "compact") {
+      for (const r of rows) console.log(`${r.timestamp} [${r.level.toUpperCase()}] ${r.service ?? "-"} ${r.message}`)
+      return
+    }
+    for (const r of rows) {
+      const meta = r.metadata ? ` ${r.metadata}` : ""
+      console.log(`${r.timestamp}  ${pad(r.level.toUpperCase(), 5)}  ${pad(r.service ?? "-", 12)}  ${r.message}${meta}`)
+    }
+    console.log(`\n${rows.length} log(s)`)
+  })
+
+// ── logs tail ──────────────────────────────────────────────
+program.command("tail")
+  .description("Show most recent logs")
+  .option("--project <id>")
+  .option("--n <count>", "Number of logs", "50")
+  .action((opts) => {
+    const rows = tailLogs(getDb(), opts.project, Number(opts.n))
+    for (const r of rows) console.log(`${r.timestamp}  ${pad(r.level.toUpperCase(), 5)}  ${r.message}`)
+  })
+
+// ── logs summary ──────────────────────────────────────────
+program.command("summary")
+  .description("Error/warn summary by service")
+  .option("--project <id>")
+  .option("--since <time>", "Relative time (1h, 24h, 7d)", "24h")
+  .action((opts) => {
+    const summary = summarizeLogs(getDb(), opts.project, parseRelativeTime(opts.since))
+    if (!summary.length) { console.log("No errors/warnings in this window."); return }
+    for (const s of summary) console.log(`${pad(s.level.toUpperCase(), 5)} ${pad(s.service ?? "-", 15)} count=${s.count} latest=${s.latest}`)
+  })
+
+// ── logs push ─────────────────────────────────────────────
+program.command("push <message>")
+  .description("Push a log entry")
+  .option("--level <level>", "Log level", "info")
+  .option("--service <name>")
+  .option("--project <id>")
+  .option("--trace <id>", "Trace ID")
+  .action((message, opts) => {
+    const row = ingestLog(getDb(), { level: opts.level as LogLevel, message, service: opts.service, project_id: opts.project, trace_id: opts.trace })
+    console.log(`Logged: ${row.id}`)
+  })
+
+// ── logs project ──────────────────────────────────────────
+const projectCmd = program.command("project").description("Manage projects")
+
+projectCmd.command("create")
+  .option("--name <name>", "Project name")
+  .option("--repo <url>", "GitHub repo")
+  .option("--url <url>", "Base URL")
+  .action((opts) => {
+    if (!opts.name) { console.error("--name is required"); process.exit(1) }
+    const p = createProject(getDb(), { name: opts.name, github_repo: opts.repo, base_url: opts.url })
+    console.log(`Created project: ${p.id} — ${p.name}`)
+  })
+
+projectCmd.command("list").action(() => {
+  const projects = listProjects(getDb())
+  for (const p of projects) console.log(`${p.id}  ${p.name}  ${p.base_url ?? ""}  ${p.github_repo ?? ""}`)
+})
+
+// ── logs page ─────────────────────────────────────────────
+const pageCmd = program.command("page").description("Manage pages")
+
+pageCmd.command("add")
+  .option("--project <id>")
+  .option("--url <url>")
+  .option("--name <name>")
+  .action((opts) => {
+    if (!opts.project || !opts.url) { console.error("--project and --url required"); process.exit(1) }
+    const p = createPage(getDb(), { project_id: opts.project, url: opts.url, name: opts.name })
+    console.log(`Page registered: ${p.id} — ${p.url}`)
+  })
+
+pageCmd.command("list").option("--project <id>").action((opts) => {
+  if (!opts.project) { console.error("--project required"); process.exit(1) }
+  const pages = listPages(getDb(), opts.project)
+  for (const p of pages) console.log(`${p.id}  ${p.url}  last=${p.last_scanned_at ?? "never"}`)
+})
+
+// ── logs job ──────────────────────────────────────────────
+const jobCmd = program.command("job").description("Manage scan jobs")
+
+jobCmd.command("create")
+  .option("--project <id>")
+  .option("--schedule <cron>", "Cron expression", "*/30 * * * *")
+  .action((opts) => {
+    if (!opts.project) { console.error("--project required"); process.exit(1) }
+    const j = createJob(getDb(), { project_id: opts.project, schedule: opts.schedule })
+    console.log(`Job created: ${j.id} — ${j.schedule}`)
+  })
+
+jobCmd.command("list").option("--project <id>").action((opts) => {
+  const jobs = listJobs(getDb(), opts.project)
+  for (const j of jobs) console.log(`${j.id}  ${j.schedule}  enabled=${j.enabled}  last=${j.last_run_at ?? "never"}`)
+})
+
+// ── logs scan ─────────────────────────────────────────────
+program.command("scan")
+  .description("Run an immediate scan for a job")
+  .option("--job <id>")
+  .option("--project <id>")
+  .action(async (opts) => {
+    if (!opts.job) { console.error("--job required"); process.exit(1) }
+    const db = getDb()
+    const job = (await import("../lib/jobs.ts")).getJob(db, opts.job)
+    if (!job) { console.error("Job not found"); process.exit(1) }
+    console.log("Running scan...")
+    await runJob(db, job.id, job.project_id, job.page_id ?? undefined)
+    console.log("Scan complete.")
+  })
+
+// ── logs mcp / logs serve ─────────────────────────────────
+program.command("mcp")
+  .description("Start the MCP server")
+  .option("--claude", "Install into Claude Code")
+  .option("--codex", "Install into Codex")
+  .option("--gemini", "Install into Gemini")
+  .action(async (opts) => {
+    if (opts.claude || opts.codex || opts.gemini) {
+      const bin = process.execPath
+      const script = new URL(import.meta.url).pathname
+      if (opts.claude) {
+        const { execSync } = await import("node:child_process")
+        execSync(`claude mcp add --transport stdio --scope user logs -- ${bin} ${script} mcp`, { stdio: "inherit" })
+      }
+      return
+    }
+    await import("../mcp/index.ts")
+  })
+
+program.command("serve")
+  .description("Start the REST API server")
+  .option("--port <n>", "Port", "3460")
+  .action(async (opts) => {
+    process.env.LOGS_PORT = opts.port
+    await import("../server/index.ts")
+  })
+
+// ── helpers ───────────────────────────────────────────────
+function pad(s: string, n: number) { return s.padEnd(n) }
+
+function parseRelativeTime(val?: string): string | undefined {
+  if (!val) return undefined
+  const m = val.match(/^(\d+)(h|d|m)$/)
+  if (!m) return val
+  const [, n, unit] = m
+  const ms = Number(n) * (unit === "h" ? 3600 : unit === "d" ? 86400 : 60) * 1000
+  return new Date(Date.now() - ms).toISOString()
+}
+
+program.parse()

package/src/db/index.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "./index.ts"
+
+describe("db migrations", () => {
+  it("creates all tables", () => {
+    const db = createTestDb()
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all() as { name: string }[]
+    const names = tables.map(t => t.name)
+    expect(names).toContain("projects")
+    expect(names).toContain("pages")
+    expect(names).toContain("logs")
+    expect(names).toContain("scan_jobs")
+    expect(names).toContain("scan_runs")
+    expect(names).toContain("performance_snapshots")
+    expect(names).toContain("logs_fts")
+  })
+
+  it("creates indexes", () => {
+    const db = createTestDb()
+    const indexes = db.prepare("SELECT name FROM sqlite_master WHERE type='index'").all() as { name: string }[]
+    const names = indexes.map(i => i.name)
+    expect(names).toContain("idx_logs_project_level_ts")
+    expect(names).toContain("idx_logs_trace")
+    expect(names).toContain("idx_logs_service")
+  })
+
+  it("is idempotent (migrate twice)", () => {
+    const db = createTestDb()
+    expect(() => {
+      db.run("CREATE TABLE IF NOT EXISTS projects (id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, github_repo TEXT, base_url TEXT, description TEXT, github_description TEXT, github_branch TEXT, github_sha TEXT, last_synced_at TEXT, created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')))")
+    }).not.toThrow()
+  })
+})

package/src/db/index.ts

@@ -0,0 +1,153 @@
+import { Database } from "bun:sqlite"
+import { join } from "node:path"
+import { existsSync, mkdirSync } from "node:fs"
+
+const DATA_DIR = process.env.LOGS_DATA_DIR ?? join(process.env.HOME ?? "~", ".logs")
+const DB_PATH = process.env.LOGS_DB_PATH ?? join(DATA_DIR, "logs.db")
+
+let _db: Database | null = null
+
+export function getDb(): Database {
+  if (_db) return _db
+  if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true })
+  _db = new Database(DB_PATH)
+  _db.run("PRAGMA journal_mode=WAL")
+  _db.run("PRAGMA foreign_keys=ON")
+  migrate(_db)
+  return _db
+}
+
+export function closeDb(): void {
+  _db?.close()
+  _db = null
+}
+
+export function createTestDb(): Database {
+  const db = new Database(":memory:")
+  db.run("PRAGMA journal_mode=WAL")
+  db.run("PRAGMA foreign_keys=ON")
+  migrate(db)
+  return db
+}
+
+function migrate(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      name TEXT NOT NULL UNIQUE,
+      github_repo TEXT,
+      base_url TEXT,
+      description TEXT,
+      github_description TEXT,
+      github_branch TEXT,
+      github_sha TEXT,
+      last_synced_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    )
+  `)
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS pages (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      url TEXT NOT NULL,
+      path TEXT NOT NULL DEFAULT '/',
+      name TEXT,
+      last_scanned_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      UNIQUE(project_id, url)
+    )
+  `)
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS logs (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+      page_id TEXT REFERENCES pages(id) ON DELETE SET NULL,
+      level TEXT NOT NULL CHECK(level IN ('debug','info','warn','error','fatal')),
+      source TEXT NOT NULL DEFAULT 'sdk' CHECK(source IN ('sdk','script','scanner')),
+      service TEXT,
+      message TEXT NOT NULL,
+      trace_id TEXT,
+      session_id TEXT,
+      agent TEXT,
+      url TEXT,
+      stack_trace TEXT,
+      metadata TEXT
+    )
+  `)
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_logs_project_level_ts ON logs(project_id, level, timestamp DESC)`)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_logs_trace ON logs(trace_id)`)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_logs_service ON logs(service)`)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_logs_page ON logs(page_id)`)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_logs_timestamp ON logs(timestamp DESC)`)
+
+  db.run(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS logs_fts USING fts5(
+      message, service, stack_trace,
+      content=logs, content_rowid=rowid
+    )
+  `)
+
+  db.run(`
+    CREATE TRIGGER IF NOT EXISTS logs_fts_insert AFTER INSERT ON logs BEGIN
+      INSERT INTO logs_fts(rowid, message, service, stack_trace)
+      VALUES (new.rowid, new.message, new.service, new.stack_trace);
+    END
+  `)
+
+  db.run(`
+    CREATE TRIGGER IF NOT EXISTS logs_fts_delete AFTER DELETE ON logs BEGIN
+      INSERT INTO logs_fts(logs_fts, rowid, message, service, stack_trace)
+      VALUES ('delete', old.rowid, old.message, old.service, old.stack_trace);
+    END
+  `)
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS scan_jobs (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      page_id TEXT REFERENCES pages(id) ON DELETE SET NULL,
+      schedule TEXT NOT NULL DEFAULT '*/30 * * * *',
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_run_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    )
+  `)
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS scan_runs (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      job_id TEXT NOT NULL REFERENCES scan_jobs(id) ON DELETE CASCADE,
+      page_id TEXT REFERENCES pages(id) ON DELETE SET NULL,
+      started_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      finished_at TEXT,
+      status TEXT NOT NULL DEFAULT 'running' CHECK(status IN ('running','completed','failed')),
+      logs_collected INTEGER NOT NULL DEFAULT 0,
+      errors_found INTEGER NOT NULL DEFAULT 0,
+      perf_score REAL
+    )
+  `)
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS performance_snapshots (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      page_id TEXT REFERENCES pages(id) ON DELETE SET NULL,
+      url TEXT NOT NULL,
+      lcp REAL,
+      fcp REAL,
+      cls REAL,
+      tti REAL,
+      ttfb REAL,
+      score REAL,
+      raw_audit TEXT
+    )
+  `)
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_perf_project_ts ON performance_snapshots(project_id, timestamp DESC)`)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_perf_page ON performance_snapshots(page_id)`)
+}

package/src/lib/browser-script.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "bun:test"
+import { getBrowserScript } from "./browser-script.ts"
+
+describe("getBrowserScript", () => {
+  it("returns a non-empty string", () => {
+    const script = getBrowserScript("http://localhost:3460")
+    expect(typeof script).toBe("string")
+    expect(script.length).toBeGreaterThan(100)
+  })
+
+  it("embeds the server URL", () => {
+    const script = getBrowserScript("http://localhost:3460")
+    expect(script).toContain("http://localhost:3460")
+  })
+
+  it("hooks console.error", () => {
+    const script = getBrowserScript("http://localhost:3460")
+    expect(script).toContain("console.error")
+  })
+
+  it("hooks window.onerror / unhandledrejection", () => {
+    const script = getBrowserScript("http://localhost:3460")
+    expect(script).toContain("unhandledrejection")
+  })
+
+  it("pushes to /api/logs", () => {
+    const script = getBrowserScript("http://localhost:3460")
+    expect(script).toContain("/api/logs")
+  })
+
+  it("uses data-project attribute", () => {
+    const script = getBrowserScript("http://localhost:3460")
+    expect(script).toContain("data-project")
+  })
+})

package/src/lib/browser-script.ts

@@ -0,0 +1,31 @@
+/** Returns the minified browser tracking script served at GET /script.js */
+export function getBrowserScript(serverUrl: string): string {
+  return `(function(){
+var cfg={url:'${serverUrl}',projectId:null};
+var el=document.currentScript;
+if(el){cfg.projectId=el.getAttribute('data-project')||null;}
+var q=[];
+function flush(){if(!q.length)return;var b=q.splice(0);fetch(cfg.url+'/api/logs',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(b),keepalive:true}).catch(function(){});}
+setInterval(flush,2000);
+function push(level,msg,extra){
+  q.push(Object.assign({level:level,message:String(msg),source:'script',url:location.href,timestamp:new Date().toISOString()},cfg.projectId?{project_id:cfg.projectId}:{},extra||{}));
+  if(q.length>=10)flush();
+}
+var _ce=console.error.bind(console);
+console.error=function(){_ce.apply(console,arguments);push('error',Array.from(arguments).join(' '));};
+var _cw=console.warn.bind(console);
+console.warn=function(){_cw.apply(console,arguments);push('warn',Array.from(arguments).join(' '));};
+window.addEventListener('error',function(e){push('error',e.message,{stack_trace:e.error?e.error.stack:null,url:e.filename});});
+window.addEventListener('unhandledrejection',function(e){push('error','Unhandled promise rejection: '+(e.reason&&e.reason.message||String(e.reason)),{stack_trace:e.reason&&e.reason.stack||null});});
+window.addEventListener('beforeunload',flush);
+window.__logs={push:push,flush:flush,config:cfg};
+})();`
+}
+
+export function initLogsScript(config: { projectId: string; url: string }): void {
+  if (typeof window === "undefined") return
+  const script = document.createElement("script")
+  script.src = `${config.url}/script.js`
+  script.setAttribute("data-project", config.projectId)
+  document.head.appendChild(script)
+}