@hasna/logs 0.0.1

package/src/lib/query.ts

@@ -0,0 +1,56 @@
+import type { Database } from "bun:sqlite"
+import type { LogQuery, LogRow } from "../types/index.ts"
+
+export function searchLogs(db: Database, q: LogQuery): LogRow[] {
+  const conditions: string[] = []
+  const params: Record<string, unknown> = {}
+
+  if (q.project_id) { conditions.push("l.project_id = $project_id"); params.$project_id = q.project_id }
+  if (q.page_id) { conditions.push("l.page_id = $page_id"); params.$page_id = q.page_id }
+  if (q.service) { conditions.push("l.service = $service"); params.$service = q.service }
+  if (q.trace_id) { conditions.push("l.trace_id = $trace_id"); params.$trace_id = q.trace_id }
+  if (q.since) { conditions.push("l.timestamp >= $since"); params.$since = q.since }
+  if (q.until) { conditions.push("l.timestamp <= $until"); params.$until = q.until }
+
+  if (q.level) {
+    const levels = Array.isArray(q.level) ? q.level : [q.level]
+    const placeholders = levels.map((_, i) => `$level${i}`).join(",")
+    levels.forEach((lv, i) => { params[`$level${i}`] = lv })
+    conditions.push(`l.level IN (${placeholders})`)
+  }
+
+  const limit = q.limit ?? 100
+  const offset = q.offset ?? 0
+  params.$limit = limit
+  params.$offset = offset
+
+  if (q.text) {
+    // FTS search via subquery
+    params.$text = q.text
+    const where = conditions.length ? `WHERE ${conditions.join(" AND ")} AND` : "WHERE"
+    const sql = `
+      SELECT l.* FROM logs l
+      ${where} l.rowid IN (SELECT rowid FROM logs_fts WHERE logs_fts MATCH $text)
+      ORDER BY l.timestamp DESC
+      LIMIT $limit OFFSET $offset
+    `
+    return db.prepare(sql).all(params) as LogRow[]
+  }
+
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
+  const sql = `SELECT * FROM logs l ${where} ORDER BY l.timestamp DESC LIMIT $limit OFFSET $offset`
+  return db.prepare(sql).all(params) as LogRow[]
+}
+
+export function tailLogs(db: Database, projectId?: string, n = 50): LogRow[] {
+  if (projectId) {
+    return db.prepare("SELECT * FROM logs WHERE project_id = $p ORDER BY timestamp DESC LIMIT $n")
+      .all({ $p: projectId, $n: n }) as LogRow[]
+  }
+  return db.prepare("SELECT * FROM logs ORDER BY timestamp DESC LIMIT $n").all({ $n: n }) as LogRow[]
+}
+
+export function getLogContext(db: Database, traceId: string): LogRow[] {
+  return db.prepare("SELECT * FROM logs WHERE trace_id = $t ORDER BY timestamp ASC")
+    .all({ $t: traceId }) as LogRow[]
+}

package/src/lib/rotate.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { rotateLogs, rotateByProject } from "./rotate.ts"
+
+describe("rotateLogs", () => {
+  it("does nothing when under maxRows", () => {
+    const db = createTestDb()
+    ingestBatch(db, [{ level: "info", message: "a" }, { level: "info", message: "b" }])
+    const deleted = rotateLogs(db, 100)
+    expect(deleted).toBe(0)
+  })
+
+  it("deletes oldest when over maxRows", () => {
+    const db = createTestDb()
+    ingestBatch(db, Array.from({ length: 10 }, (_, i) => ({ level: "info" as const, message: `msg ${i}` })))
+    const deleted = rotateLogs(db, 5)
+    expect(deleted).toBe(5)
+    const remaining = (db.prepare("SELECT COUNT(*) as c FROM logs").get() as { c: number }).c
+    expect(remaining).toBe(5)
+  })
+})
+
+describe("rotateByProject", () => {
+  it("only rotates logs for the specified project", () => {
+    const db = createTestDb()
+    const p1 = db.prepare("INSERT INTO projects (name) VALUES ('p1') RETURNING id").get() as { id: string }
+    const p2 = db.prepare("INSERT INTO projects (name) VALUES ('p2') RETURNING id").get() as { id: string }
+    ingestBatch(db, Array.from({ length: 8 }, () => ({ level: "info" as const, message: "x", project_id: p1.id })))
+    ingestBatch(db, Array.from({ length: 5 }, () => ({ level: "info" as const, message: "y", project_id: p2.id })))
+    rotateByProject(db, p1.id, 3)
+    const p1count = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = ?").get(p1.id) as { c: number }).c
+    const p2count = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = ?").get(p2.id) as { c: number }).c
+    expect(p1count).toBe(3)
+    expect(p2count).toBe(5) // untouched
+  })
+})

package/src/lib/rotate.ts

@@ -0,0 +1,27 @@
+import type { Database } from "bun:sqlite"
+
+const DEFAULT_MAX_ROWS = 100_000
+
+export function rotateLogs(db: Database, maxRows = DEFAULT_MAX_ROWS): number {
+  const total = (db.prepare("SELECT COUNT(*) as c FROM logs").get() as { c: number }).c
+  if (total <= maxRows) return 0
+  const toDelete = total - maxRows
+  db.prepare(`
+    DELETE FROM logs WHERE id IN (
+      SELECT id FROM logs ORDER BY timestamp ASC LIMIT ${toDelete}
+    )
+  `).run()
+  return toDelete
+}
+
+export function rotateByProject(db: Database, projectId: string, maxRows = DEFAULT_MAX_ROWS): number {
+  const total = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = $p").get({ $p: projectId }) as { c: number }).c
+  if (total <= maxRows) return 0
+  const toDelete = total - maxRows
+  db.prepare(`
+    DELETE FROM logs WHERE id IN (
+      SELECT id FROM logs WHERE project_id = $p ORDER BY timestamp ASC LIMIT ${toDelete}
+    )
+  `).run({ $p: projectId })
+  return toDelete
+}

package/src/lib/scanner.ts

@@ -0,0 +1,112 @@
+import type { Database } from "bun:sqlite"
+import { ingestBatch } from "./ingest.ts"
+import { saveSnapshot } from "./perf.ts"
+import { getPage, touchPage } from "./projects.ts"
+import type { LogEntry } from "../types/index.ts"
+
+export interface ScanResult {
+  logsCollected: number
+  errorsFound: number
+  perfScore: number | null
+}
+
+export async function scanPage(db: Database, projectId: string, pageId: string, urlOverride?: string): Promise<ScanResult> {
+  const page = getPage(db, pageId)
+  const url = urlOverride || page?.url
+  if (!url) throw new Error(`No URL for page ${pageId}`)
+
+  const { chromium } = await import("playwright")
+  const browser = await chromium.launch({ headless: true })
+  const context = await browser.newContext({
+    userAgent: "Mozilla/5.0 (@hasna/logs scanner) AppleWebKit/537.36",
+  })
+  const browserPage = await context.newPage()
+
+  const collected: LogEntry[] = []
+  let errorsFound = 0
+
+  // Capture console output
+  browserPage.on("console", (msg) => {
+    const level = msg.type() === "error" ? "error" : msg.type() === "warning" ? "warn" : msg.type() === "info" ? "info" : "debug"
+    if (level === "error") errorsFound++
+    collected.push({
+      project_id: projectId,
+      page_id: pageId,
+      level: level as LogEntry["level"],
+      source: "scanner",
+      message: msg.text(),
+      url,
+    })
+  })
+
+  // Capture page errors (uncaught JS exceptions)
+  browserPage.on("pageerror", (err) => {
+    errorsFound++
+    collected.push({
+      project_id: projectId,
+      page_id: pageId,
+      level: "error",
+      source: "scanner",
+      message: err.message,
+      stack_trace: err.stack,
+      url,
+    })
+  })
+
+  // Capture network failures
+  browserPage.on("requestfailed", (req) => {
+    collected.push({
+      project_id: projectId,
+      page_id: pageId,
+      level: "warn",
+      source: "scanner",
+      message: `Network request failed: ${req.url()} — ${req.failure()?.errorText ?? "unknown"}`,
+      url,
+    })
+  })
+
+  let perfScore: number | null = null
+
+  try {
+    await browserPage.goto(url, { waitUntil: "networkidle", timeout: 30_000 })
+
+    // Try basic perf metrics via CDP
+    try {
+      const metrics = await browserPage.evaluate(() => {
+        const nav = performance.getEntriesByType("navigation")[0] as PerformanceNavigationTiming | undefined
+        const paint = performance.getEntriesByName("first-contentful-paint")[0]
+        return {
+          ttfb: nav ? nav.responseStart - nav.requestStart : null,
+          fcp: paint?.startTime ?? null,
+          domLoad: nav ? nav.domContentLoadedEventEnd - nav.startTime : null,
+        }
+      })
+      // Store what we can without full Lighthouse
+      if (metrics.fcp !== null || metrics.ttfb !== null) {
+        saveSnapshot(db, {
+          project_id: projectId,
+          page_id: pageId,
+          url,
+          fcp: metrics.fcp,
+          ttfb: metrics.ttfb,
+          lcp: null,
+          cls: null,
+          tti: metrics.domLoad,
+          score: null,
+          raw_audit: JSON.stringify(metrics),
+        })
+      }
+    } catch {
+      // perf metrics optional
+    }
+  } finally {
+    await browser.close()
+  }
+
+  if (collected.length > 0) {
+    ingestBatch(db, collected)
+    if (page) touchPage(db, pageId)
+  }
+
+  return { logsCollected: collected.length, errorsFound, perfScore }
+}

package/src/lib/scheduler.ts

@@ -0,0 +1,57 @@
+import type { Database } from "bun:sqlite"
+import cron from "node-cron"
+import { finishScanRun, createScanRun, listJobs, updateJob } from "./jobs.ts"
+import { listPages } from "./projects.ts"
+import { scanPage } from "./scanner.ts"
+
+const tasks = new Map<string, cron.ScheduledTask>()
+
+export function startScheduler(db: Database): void {
+  const jobs = listJobs(db).filter(j => j.enabled)
+  for (const job of jobs) {
+    scheduleJob(db, job.id, job.schedule, job.project_id, job.page_id ?? undefined)
+  }
+  console.log(`Scheduler started: ${tasks.size} job(s) active`)
+}
+
+export function scheduleJob(db: Database, jobId: string, schedule: string, projectId: string, pageId?: string): void {
+  if (tasks.has(jobId)) tasks.get(jobId)!.stop()
+  const task = cron.schedule(schedule, async () => {
+    await runJob(db, jobId, projectId, pageId)
+  })
+  tasks.set(jobId, task)
+}
+
+export function unscheduleJob(jobId: string): void {
+  tasks.get(jobId)?.stop()
+  tasks.delete(jobId)
+}
+
+export async function runJob(db: Database, jobId: string, projectId: string, pageId?: string): Promise<void> {
+  const pages = pageId
+    ? [{ id: pageId, url: "" }]  // will resolve url in scan
+    : listPages(db, projectId)
+
+  await Promise.all(pages.map(async (page) => {
+    const run = createScanRun(db, { job_id: jobId, page_id: page.id })
+    try {
+      const result = await scanPage(db, projectId, page.id, page.url)
+      finishScanRun(db, run.id, {
+        status: "completed",
+        logs_collected: result.logsCollected,
+        errors_found: result.errorsFound,
+        perf_score: result.perfScore ?? undefined,
+      })
+    } catch (err) {
+      finishScanRun(db, run.id, { status: "failed", logs_collected: 0, errors_found: 0 })
+      console.error(`Scan failed for page ${page.id}:`, err)
+    }
+  }))
+
+  updateJob(db, jobId, { last_run_at: new Date().toISOString() })
+}
+
+export function stopScheduler(): void {
+  for (const task of tasks.values()) task.stop()
+  tasks.clear()
+}

package/src/lib/summarize.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { summarizeLogs } from "./summarize.ts"
+
+describe("summarizeLogs", () => {
+  it("returns warn/error/fatal counts grouped by service", () => {
+    const db = createTestDb()
+    ingestBatch(db, [
+      { level: "error", message: "e1", service: "api" },
+      { level: "error", message: "e2", service: "api" },
+      { level: "warn", message: "w1", service: "db" },
+      { level: "info", message: "i1", service: "api" },  // excluded
+      { level: "debug", message: "d1", service: "api" }, // excluded
+    ])
+    const summary = summarizeLogs(db)
+    expect(summary.length).toBe(2)
+    const api = summary.find(s => s.service === "api" && s.level === "error")
+    expect(api?.count).toBe(2)
+    const db2 = summary.find(s => s.service === "db")
+    expect(db2?.count).toBe(1)
+  })
+
+  it("excludes info/debug from summary", () => {
+    const db = createTestDb()
+    ingestBatch(db, [
+      { level: "info", message: "ok" },
+      { level: "debug", message: "trace" },
+    ])
+    const summary = summarizeLogs(db)
+    expect(summary).toHaveLength(0)
+  })
+
+  it("returns empty for no logs", () => {
+    const db = createTestDb()
+    expect(summarizeLogs(db)).toHaveLength(0)
+  })
+})

package/src/lib/summarize.ts

@@ -0,0 +1,21 @@
+import type { Database } from "bun:sqlite"
+import type { LogSummary } from "../types/index.ts"
+
+export function summarizeLogs(db: Database, projectId?: string, since?: string): LogSummary[] {
+  const conditions: string[] = ["level IN ('warn','error','fatal')"]
+  const params: Record<string, unknown> = {}
+
+  if (projectId) { conditions.push("project_id = $project_id"); params.$project_id = projectId }
+  if (since) { conditions.push("timestamp >= $since"); params.$since = since }
+
+  const where = `WHERE ${conditions.join(" AND ")}`
+  const sql = `
+    SELECT project_id, service, page_id, level,
+           COUNT(*) as count,
+           MAX(timestamp) as latest
+    FROM logs ${where}
+    GROUP BY project_id, service, page_id, level
+    ORDER BY count DESC
+  `
+  return db.prepare(sql).all(params) as LogSummary[]
+}

package/src/mcp/index.ts

@@ -0,0 +1,165 @@
+#!/usr/bin/env bun
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import { z } from "zod"
+import { getDb } from "../db/index.ts"
+import { ingestLog } from "../lib/ingest.ts"
+import { getLogContext, 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 { getLatestSnapshot, getPerfTrend, scoreLabel } from "../lib/perf.ts"
+import type { LogLevel } from "../types/index.ts"
+
+const db = getDb()
+const server = new McpServer({ name: "logs", version: "0.0.1" })
+
+// Tool registry for search_tools / describe_tools pattern
+const TOOLS: Record<string, string> = {
+  register_project: "Register a project (name, github_repo?, base_url?, description?)",
+  register_page: "Register a page URL to a project (project_id, url, path?, name?)",
+  create_scan_job: "Schedule headless page scans (project_id, schedule, page_id?)",
+  log_push: "Push a log entry (level, message, project_id?, service?, trace_id?, metadata?)",
+  log_search: "Search logs (project_id?, page_id?, level?, since?, until?, text?, limit?)",
+  log_tail: "Get N most recent logs (project_id?, n?)",
+  log_summary: "Error/warn counts by service/page (project_id?, since?)",
+  log_context: "All logs for a trace_id",
+  perf_snapshot: "Latest performance snapshot for a project/page (project_id, page_id?)",
+  perf_trend: "Performance over time (project_id, page_id?, since?, limit?)",
+  scan_status: "Last scan runs per project (project_id?)",
+  list_projects: "List all registered projects",
+  list_pages: "List pages for a project (project_id)",
+  search_tools: "Search available tools by keyword (query)",
+  describe_tools: "List all tools with descriptions",
+}
+
+server.tool("search_tools", { query: z.string() }, ({ query }) => {
+  const q = query.toLowerCase()
+  const matches = Object.entries(TOOLS).filter(([k, v]) => k.includes(q) || v.toLowerCase().includes(q))
+  return { content: [{ type: "text", text: matches.map(([k, v]) => `${k}: ${v}`).join("\n") || "No matches" }] }
+})
+
+server.tool("describe_tools", {}, () => {
+  const text = Object.entries(TOOLS).map(([k, v]) => `${k}: ${v}`).join("\n")
+  return { content: [{ type: "text", text }] }
+})
+
+server.tool("register_project", {
+  name: z.string(),
+  github_repo: z.string().optional(),
+  base_url: z.string().optional(),
+  description: z.string().optional(),
+}, (args) => {
+  const project = createProject(db, args)
+  return { content: [{ type: "text", text: JSON.stringify(project) }] }
+})
+
+server.tool("register_page", {
+  project_id: z.string(),
+  url: z.string(),
+  path: z.string().optional(),
+  name: z.string().optional(),
+}, (args) => {
+  const page = createPage(db, args)
+  return { content: [{ type: "text", text: JSON.stringify(page) }] }
+})
+
+server.tool("create_scan_job", {
+  project_id: z.string(),
+  schedule: z.string(),
+  page_id: z.string().optional(),
+}, (args) => {
+  const job = createJob(db, args)
+  return { content: [{ type: "text", text: JSON.stringify(job) }] }
+})
+
+server.tool("log_push", {
+  level: z.enum(["debug", "info", "warn", "error", "fatal"]),
+  message: z.string(),
+  project_id: z.string().optional(),
+  service: z.string().optional(),
+  trace_id: z.string().optional(),
+  session_id: z.string().optional(),
+  agent: z.string().optional(),
+  url: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+}, (args) => {
+  const row = ingestLog(db, args)
+  return { content: [{ type: "text", text: `Logged: ${row.id}` }] }
+})
+
+server.tool("log_search", {
+  project_id: z.string().optional(),
+  page_id: z.string().optional(),
+  level: z.string().optional(),
+  service: z.string().optional(),
+  since: z.string().optional(),
+  until: z.string().optional(),
+  text: z.string().optional(),
+  trace_id: z.string().optional(),
+  limit: z.number().optional(),
+}, (args) => {
+  const rows = searchLogs(db, {
+    ...args,
+    level: args.level ? (args.level.split(",") as LogLevel[]) : undefined,
+  })
+  return { content: [{ type: "text", text: JSON.stringify(rows) }] }
+})
+
+server.tool("log_tail", {
+  project_id: z.string().optional(),
+  n: z.number().optional(),
+}, ({ project_id, n }) => {
+  const rows = tailLogs(db, project_id, n ?? 50)
+  return { content: [{ type: "text", text: JSON.stringify(rows) }] }
+})
+
+server.tool("log_summary", {
+  project_id: z.string().optional(),
+  since: z.string().optional(),
+}, ({ project_id, since }) => {
+  const summary = summarizeLogs(db, project_id, since)
+  return { content: [{ type: "text", text: JSON.stringify(summary) }] }
+})
+
+server.tool("log_context", { trace_id: z.string() }, ({ trace_id }) => {
+  const rows = getLogContext(db, trace_id)
+  return { content: [{ type: "text", text: JSON.stringify(rows) }] }
+})
+
+server.tool("perf_snapshot", {
+  project_id: z.string(),
+  page_id: z.string().optional(),
+}, ({ project_id, page_id }) => {
+  const snap = getLatestSnapshot(db, project_id, page_id)
+  const label = snap ? scoreLabel(snap.score) : "unknown"
+  return { content: [{ type: "text", text: JSON.stringify({ ...snap, label }) }] }
+})
+
+server.tool("perf_trend", {
+  project_id: z.string(),
+  page_id: z.string().optional(),
+  since: z.string().optional(),
+  limit: z.number().optional(),
+}, ({ project_id, page_id, since, limit }) => {
+  const trend = getPerfTrend(db, project_id, page_id, since, limit ?? 50)
+  return { content: [{ type: "text", text: JSON.stringify(trend) }] }
+})
+
+server.tool("scan_status", {
+  project_id: z.string().optional(),
+}, ({ project_id }) => {
+  const jobs = listJobs(db, project_id)
+  return { content: [{ type: "text", text: JSON.stringify(jobs) }] }
+})
+
+server.tool("list_projects", {}, () => {
+  return { content: [{ type: "text", text: JSON.stringify(listProjects(db)) }] }
+})
+
+server.tool("list_pages", { project_id: z.string() }, ({ project_id }) => {
+  return { content: [{ type: "text", text: JSON.stringify(listPages(db, project_id)) }] }
+})
+
+const transport = new StdioServerTransport()
+await server.connect(transport)

package/src/server/index.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+import { Hono } from "hono"
+import { cors } from "hono/cors"
+import { getDb } from "../db/index.ts"
+import { getBrowserScript } from "../lib/browser-script.ts"
+import { startScheduler } from "../lib/scheduler.ts"
+import { jobsRoutes } from "./routes/jobs.ts"
+import { logsRoutes } from "./routes/logs.ts"
+import { perfRoutes } from "./routes/perf.ts"
+import { projectsRoutes } from "./routes/projects.ts"
+
+const PORT = Number(process.env.LOGS_PORT ?? 3460)
+const db = getDb()
+const app = new Hono()
+
+app.use("*", cors())
+
+// Browser tracking script
+app.get("/script.js", (c) => {
+  const host = `${c.req.header("x-forwarded-proto") ?? "http"}://${c.req.header("host") ?? `localhost:${PORT}`}`
+  c.header("Content-Type", "application/javascript")
+  c.header("Cache-Control", "public, max-age=300")
+  return c.text(getBrowserScript(host))
+})
+
+// API routes
+app.route("/api/logs", logsRoutes(db))
+app.route("/api/projects", projectsRoutes(db))
+app.route("/api/jobs", jobsRoutes(db))
+app.route("/api/perf", perfRoutes(db))
+
+app.get("/", (c) => c.json({ service: "@hasna/logs", port: PORT, status: "ok" }))
+
+// Start scheduler
+startScheduler(db)
+
+console.log(`@hasna/logs server running on http://localhost:${PORT}`)
+
+export default {
+  port: PORT,
+  fetch: app.fetch,
+}

package/src/server/routes/jobs.ts

@@ -0,0 +1,32 @@
+import { Hono } from "hono"
+import type { Database } from "bun:sqlite"
+import { createJob, deleteJob, listJobs, updateJob } from "../../lib/jobs.ts"
+
+export function jobsRoutes(db: Database) {
+  const app = new Hono()
+
+  app.post("/", async (c) => {
+    const body = await c.req.json()
+    if (!body.project_id || !body.schedule) return c.json({ error: "project_id and schedule are required" }, 422)
+    return c.json(createJob(db, body), 201)
+  })
+
+  app.get("/", (c) => {
+    const { project_id } = c.req.query()
+    return c.json(listJobs(db, project_id || undefined))
+  })
+
+  app.put("/:id", async (c) => {
+    const body = await c.req.json()
+    const updated = updateJob(db, c.req.param("id"), body)
+    if (!updated) return c.json({ error: "not found" }, 404)
+    return c.json(updated)
+  })
+
+  app.delete("/:id", (c) => {
+    deleteJob(db, c.req.param("id"))
+    return c.json({ deleted: true })
+  })
+
+  return app
+}

package/src/server/routes/logs.ts

@@ -0,0 +1,65 @@
+import { Hono } from "hono"
+import type { Database } from "bun:sqlite"
+import { ingestBatch, ingestLog } from "../../lib/ingest.ts"
+import { getLogContext, searchLogs, tailLogs } from "../../lib/query.ts"
+import { summarizeLogs } from "../../lib/summarize.ts"
+import type { LogEntry, LogLevel } from "../../types/index.ts"
+
+export function logsRoutes(db: Database) {
+  const app = new Hono()
+
+  // POST /api/logs — ingest single or batch
+  app.post("/", async (c) => {
+    const body = await c.req.json()
+    if (Array.isArray(body)) {
+      const rows = ingestBatch(db, body as LogEntry[])
+      return c.json({ inserted: rows.length }, 201)
+    }
+    const row = ingestLog(db, body as LogEntry)
+    return c.json(row, 201)
+  })
+
+  // GET /api/logs
+  app.get("/", (c) => {
+    const { project_id, page_id, level, service, since, until, text, trace_id, limit, offset, fields } = c.req.query()
+    const rows = searchLogs(db, {
+      project_id: project_id || undefined,
+      page_id: page_id || undefined,
+      level: level ? (level.split(",") as LogLevel[]) : undefined,
+      service: service || undefined,
+      since: since || undefined,
+      until: until || undefined,
+      text: text || undefined,
+      trace_id: trace_id || undefined,
+      limit: limit ? Number(limit) : 100,
+      offset: offset ? Number(offset) : 0,
+    })
+    if (fields) {
+      const keys = fields.split(",")
+      return c.json(rows.map(r => Object.fromEntries(keys.map(k => [k, (r as Record<string, unknown>)[k]]))))
+    }
+    return c.json(rows)
+  })
+
+  // GET /api/logs/tail
+  app.get("/tail", (c) => {
+    const { project_id, n } = c.req.query()
+    const rows = tailLogs(db, project_id || undefined, n ? Number(n) : 50)
+    return c.json(rows)
+  })
+
+  // GET /api/logs/summary
+  app.get("/summary", (c) => {
+    const { project_id, since } = c.req.query()
+    const summary = summarizeLogs(db, project_id || undefined, since || undefined)
+    return c.json(summary)
+  })
+
+  // GET /api/logs/:trace_id/context
+  app.get("/:trace_id/context", (c) => {
+    const rows = getLogContext(db, c.req.param("trace_id"))
+    return c.json(rows)
+  })
+
+  return app
+}

package/src/server/routes/perf.ts

@@ -0,0 +1,23 @@
+import { Hono } from "hono"
+import type { Database } from "bun:sqlite"
+import { getLatestSnapshot, getPerfTrend } from "../../lib/perf.ts"
+
+export function perfRoutes(db: Database) {
+  const app = new Hono()
+
+  app.get("/", (c) => {
+    const { project_id, page_id, since } = c.req.query()
+    if (!project_id) return c.json({ error: "project_id is required" }, 422)
+    const snap = getLatestSnapshot(db, project_id, page_id || undefined)
+    return c.json(snap)
+  })
+
+  app.get("/trend", (c) => {
+    const { project_id, page_id, since, limit } = c.req.query()
+    if (!project_id) return c.json({ error: "project_id is required" }, 422)
+    const trend = getPerfTrend(db, project_id, page_id || undefined, since || undefined, limit ? Number(limit) : 50)
+    return c.json(trend)
+  })
+
+  return app
+}