@hasna/logs 0.0.1 → 0.2.0

package/src/lib/retention.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { runRetentionForProject, setRetentionPolicy } from "./retention.ts"
+
+function seedProject(db: ReturnType<typeof createTestDb>, name = "app") {
+  return db.prepare("INSERT INTO projects (name) VALUES (?) RETURNING id").get(name) as { id: string }
+}
+
+describe("retention", () => {
+  it("does nothing when under max_rows", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    ingestBatch(db, Array.from({ length: 5 }, () => ({ level: "info" as const, message: "x", project_id: p.id })))
+    const result = runRetentionForProject(db, p.id)
+    expect(result.deleted).toBe(0)
+  })
+
+  it("enforces max_rows", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    setRetentionPolicy(db, p.id, { max_rows: 3 })
+    ingestBatch(db, Array.from({ length: 10 }, () => ({ level: "info" as const, message: "x", project_id: p.id })))
+    runRetentionForProject(db, p.id)
+    const count = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = ?").get(p.id) as { c: number }).c
+    expect(count).toBeLessThanOrEqual(3)
+  })
+
+  it("returns 0 for unknown project", () => {
+    const db = createTestDb()
+    expect(runRetentionForProject(db, "nope").deleted).toBe(0)
+  })
+
+  it("setRetentionPolicy updates project config", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    setRetentionPolicy(db, p.id, { max_rows: 500, debug_ttl_hours: 1 })
+    const proj = db.prepare("SELECT max_rows, debug_ttl_hours FROM projects WHERE id = ?").get(p.id) as { max_rows: number; debug_ttl_hours: number }
+    expect(proj.max_rows).toBe(500)
+    expect(proj.debug_ttl_hours).toBe(1)
+  })
+})

package/src/lib/retention.ts

@@ -0,0 +1,62 @@
+import type { Database } from "bun:sqlite"
+
+interface RetentionConfig {
+  max_rows: number
+  debug_ttl_hours: number
+  info_ttl_hours: number
+  warn_ttl_hours: number
+  error_ttl_hours: number
+}
+
+const TTL_BY_LEVEL: Record<string, keyof RetentionConfig> = {
+  debug: "debug_ttl_hours",
+  info: "info_ttl_hours",
+  warn: "warn_ttl_hours",
+  error: "error_ttl_hours",
+  fatal: "error_ttl_hours",
+}
+
+export function runRetentionForProject(db: Database, projectId: string): { deleted: number } {
+  const project = db.prepare("SELECT * FROM projects WHERE id = $id").get({ $id: projectId }) as (RetentionConfig & { id: string }) | null
+  if (!project) return { deleted: 0 }
+
+  let deleted = 0
+
+  // TTL enforcement per level
+  for (const [level, configKey] of Object.entries(TTL_BY_LEVEL)) {
+    const ttlHours = project[configKey] as number
+    const cutoff = new Date(Date.now() - ttlHours * 3600 * 1000).toISOString()
+    const before = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = $p AND level = $level AND timestamp < $cutoff").get({ $p: projectId, $level: level, $cutoff: cutoff }) as { c: number }).c
+    if (before > 0) {
+      db.prepare("DELETE FROM logs WHERE project_id = $p AND level = $level AND timestamp < $cutoff").run({ $p: projectId, $level: level, $cutoff: cutoff })
+      deleted += before
+    }
+  }
+
+  // max_rows enforcement
+  const total = (db.prepare("SELECT COUNT(*) as c FROM logs WHERE project_id = $p").get({ $p: projectId }) as { c: number }).c
+  if (total > project.max_rows) {
+    const toDelete = total - project.max_rows
+    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 })
+    deleted += toDelete
+  }
+
+  return { deleted }
+}
+
+export function runRetentionAll(db: Database): { deleted: number; projects: number } {
+  const projects = db.prepare("SELECT id FROM projects").all() as { id: string }[]
+  let deleted = 0
+  for (const p of projects) {
+    deleted += runRetentionForProject(db, p.id).deleted
+  }
+  return { deleted, projects: projects.length }
+}
+
+export function setRetentionPolicy(db: Database, projectId: string, config: Partial<RetentionConfig>): void {
+  const fields = Object.keys(config).map(k => `${k} = $${k}`).join(", ")
+  if (!fields) return
+  const params = Object.fromEntries(Object.entries(config).map(([k, v]) => [`$${k}`, v]))
+  params.$id = projectId
+  db.prepare(`UPDATE projects SET ${fields} WHERE id = $id`).run(params)
+}

package/src/lib/scanner.ts

@@ -1,5 +1,6 @@
 import type { Database } from "bun:sqlite"
 import { ingestBatch } from "./ingest.ts"
+import { getPageAuth } from "./page-auth.ts"
 import { saveSnapshot } from "./perf.ts"
 import { getPage, touchPage } from "./projects.ts"
 import type { LogEntry } from "../types/index.ts"
@@ -17,9 +18,27 @@ export async function scanPage(db: Database, projectId: string, pageId: string,
 
   const { chromium } = await import("playwright")
   const browser = await chromium.launch({ headless: true })
-  const context = await browser.newContext({
+
+  // Apply page auth if configured
+  const auth = getPageAuth(db, pageId)
+  const contextOptions: Parameters<typeof browser.newContext>[0] = {
     userAgent: "Mozilla/5.0 (@hasna/logs scanner) AppleWebKit/537.36",
-  })
+  }
+  if (auth?.type === "cookie") {
+    try { contextOptions.storageState = JSON.parse(auth.credentials) } catch { /* invalid */ }
+  } else if (auth?.type === "basic") {
+    const [username, password] = auth.credentials.split(":")
+    contextOptions.httpCredentials = { username: username ?? "", password: password ?? "" }
+  }
+
+  const context = await browser.newContext(contextOptions)
+
+  if (auth?.type === "bearer") {
+    await context.route("**/*", (route) => {
+      route.continue({ headers: { ...route.request().headers(), Authorization: `Bearer ${auth.credentials}` } })
+    })
+  }
+
   const browserPage = await context.newPage()
 
   const collected: LogEntry[] = []

package/src/lib/scheduler.ts

@@ -2,6 +2,7 @@ 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 { runRetentionAll } from "./retention.ts"
 import { scanPage } from "./scanner.ts"
 
 const tasks = new Map<string, cron.ScheduledTask>()
@@ -11,6 +12,11 @@ export function startScheduler(db: Database): void {
   for (const job of jobs) {
     scheduleJob(db, job.id, job.schedule, job.project_id, job.page_id ?? undefined)
   }
+  // Hourly retention runner
+  cron.schedule("0 * * * *", () => {
+    const result = runRetentionAll(db)
+    if (result.deleted > 0) console.log(`Retention: deleted ${result.deleted} logs across ${result.projects} project(s)`)
+  })
   console.log(`Scheduler started: ${tasks.size} job(s) active`)
 }
 

package/src/lib/session-context.ts

@@ -0,0 +1,28 @@
+import type { Database } from "bun:sqlite"
+import type { LogRow } from "../types/index.ts"
+
+export interface SessionContext {
+  session_id: string
+  logs: LogRow[]
+  session?: Record<string, unknown>
+  error?: string
+}
+
+export async function getSessionContext(db: Database, sessionId: string): Promise<SessionContext> {
+  const logs = db.prepare("SELECT * FROM logs WHERE session_id = $s ORDER BY timestamp ASC")
+    .all({ $s: sessionId }) as LogRow[]
+
+  const sessionsUrl = process.env.SESSIONS_URL
+  if (!sessionsUrl) {
+    return { session_id: sessionId, logs }
+  }
+
+  try {
+    const res = await fetch(`${sessionsUrl.replace(/\/$/, "")}/api/sessions/${sessionId}`)
+    if (!res.ok) return { session_id: sessionId, logs }
+    const session = await res.json() as Record<string, unknown>
+    return { session_id: sessionId, logs, session }
+  } catch (err) {
+    return { session_id: sessionId, logs, error: String(err) }
+  }
+}

package/src/mcp/index.ts

@@ -9,28 +9,49 @@ 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"
+import { createAlertRule, deleteAlertRule, listAlertRules } from "../lib/alerts.ts"
+import { listIssues, updateIssueStatus } from "../lib/issues.ts"
+import { diagnose } from "../lib/diagnose.ts"
+import { compare } from "../lib/compare.ts"
+import { getHealth } from "../lib/health.ts"
+import { getSessionContext } from "../lib/session-context.ts"
+import type { LogLevel, LogRow } from "../types/index.ts"
 
 const db = getDb()
-const server = new McpServer({ name: "logs", version: "0.0.1" })
+const server = new McpServer({ name: "logs", version: "0.1.0" })
+
+const BRIEF_FIELDS: (keyof LogRow)[] = ["id", "timestamp", "level", "message", "service"]
+
+function applyBrief(rows: LogRow[], brief = true): unknown[] {
+  if (!brief) return rows
+  return rows.map(r => ({ id: r.id, timestamp: r.timestamp, level: r.level, message: r.message, service: r.service }))
+}
 
-// 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?)",
+  register_page: "Register a page URL (project_id, url, path?, name?)",
+  create_scan_job: "Schedule 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",
+  log_search: "Search logs (project_id?, level?, since?, text?, brief?=true, limit?)",
+  log_tail: "Recent logs (project_id?, n?, brief?=true)",
+  log_summary: "Error/warn counts by service (project_id?, since?)",
+  log_context: "All logs for a trace_id (trace_id, brief?=true)",
+  log_diagnose: "Full diagnosis: top errors, failing pages, perf regressions (project_id, since?)",
+  log_compare: "Compare two time windows for new/resolved errors and perf delta",
+  perf_snapshot: "Latest perf snapshot (project_id, page_id?)",
+  perf_trend: "Perf over time (project_id, page_id?, since?, limit?)",
+  scan_status: "Last scan jobs (project_id?)",
+  list_projects: "List all 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",
+  list_issues: "List grouped error issues (project_id?, status?, limit?)",
+  resolve_issue: "Update issue status (id, status: open|resolved|ignored)",
+  create_alert_rule: "Create alert rule (project_id, name, level, threshold_count, window_seconds, webhook_url?)",
+  list_alert_rules: "List alert rules (project_id?)",
+  delete_alert_rule: "Delete alert rule (id)",
+  log_session_context: "Logs + session metadata for a session_id (requires SESSIONS_URL env)",
+  get_health: "Server health + DB stats",
+  search_tools: "Search tools by keyword (query)",
+  describe_tools: "List all tools",
 }
 
 server.tool("search_tools", { query: z.string() }, ({ query }) => {
@@ -39,39 +60,21 @@ server.tool("search_tools", { query: z.string() }, ({ query }) => {
   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("describe_tools", {}, () => ({
+  content: [{ type: "text", text: Object.entries(TOOLS).map(([k, v]) => `${k}: ${v}`).join("\n") }]
+}))
 
 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) }] }
-})
+  name: z.string(), github_repo: z.string().optional(), base_url: z.string().optional(), description: z.string().optional(),
+}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createProject(db, args)) }] }))
 
 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) }] }
-})
+  project_id: z.string(), url: z.string(), path: z.string().optional(), name: z.string().optional(),
+}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createPage(db, args)) }] }))
 
 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) }] }
-})
+  project_id: z.string(), schedule: z.string(), page_id: z.string().optional(),
+}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createJob(db, args)) }] }))
 
 server.tool("log_push", {
   level: z.enum(["debug", "info", "warn", "error", "fatal"]),
@@ -89,77 +92,118 @@ server.tool("log_push", {
 })
 
 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(),
+  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(), brief: z.boolean().optional(),
 }, (args) => {
-  const rows = searchLogs(db, {
-    ...args,
-    level: args.level ? (args.level.split(",") as LogLevel[]) : undefined,
-  })
-  return { content: [{ type: "text", text: JSON.stringify(rows) }] }
+  const rows = searchLogs(db, { ...args, level: args.level ? (args.level.split(",") as LogLevel[]) : undefined })
+  return { content: [{ type: "text", text: JSON.stringify(applyBrief(rows, args.brief !== false)) }] }
 })
 
 server.tool("log_tail", {
-  project_id: z.string().optional(),
-  n: z.number().optional(),
-}, ({ project_id, n }) => {
+  project_id: z.string().optional(), n: z.number().optional(), brief: z.boolean().optional(),
+}, ({ project_id, n, brief }) => {
   const rows = tailLogs(db, project_id, n ?? 50)
-  return { content: [{ type: "text", text: JSON.stringify(rows) }] }
+  return { content: [{ type: "text", text: JSON.stringify(applyBrief(rows, brief !== false)) }] }
 })
 
 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 }) => {
+  project_id: z.string().optional(), since: z.string().optional(),
+}, ({ project_id, since }) => ({
+  content: [{ type: "text", text: JSON.stringify(summarizeLogs(db, project_id, since)) }]
+}))
+
+server.tool("log_context", {
+  trace_id: z.string(), brief: z.boolean().optional(),
+}, ({ trace_id, brief }) => {
   const rows = getLogContext(db, trace_id)
-  return { content: [{ type: "text", text: JSON.stringify(rows) }] }
+  return { content: [{ type: "text", text: JSON.stringify(applyBrief(rows, brief !== false)) }] }
 })
 
-server.tool("perf_snapshot", {
+server.tool("log_diagnose", {
+  project_id: z.string(), since: z.string().optional(),
+}, ({ project_id, since }) => ({
+  content: [{ type: "text", text: JSON.stringify(diagnose(db, project_id, since)) }]
+}))
+
+server.tool("log_compare", {
   project_id: z.string(),
-  page_id: z.string().optional(),
+  a_since: z.string(), a_until: z.string(),
+  b_since: z.string(), b_until: z.string(),
+}, ({ project_id, a_since, a_until, b_since, b_until }) => ({
+  content: [{ type: "text", text: JSON.stringify(compare(db, project_id, a_since, a_until, b_since, b_until)) }]
+}))
+
+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 }) }] }
+  return { content: [{ type: "text", text: JSON.stringify(snap ? { ...snap, label: scoreLabel(snap.score) } : null) }] }
 })
 
 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) }] }
-})
+  project_id: z.string(), page_id: z.string().optional(), since: z.string().optional(), limit: z.number().optional(),
+}, ({ project_id, page_id, since, limit }) => ({
+  content: [{ type: "text", text: JSON.stringify(getPerfTrend(db, project_id, page_id, since, limit ?? 50)) }]
+}))
 
 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) }] }
-})
+}, ({ project_id }) => ({
+  content: [{ type: "text", text: JSON.stringify(listJobs(db, project_id)) }]
+}))
+
+server.tool("list_projects", {}, () => ({
+  content: [{ type: "text", text: JSON.stringify(listProjects(db)) }]
+}))
+
+server.tool("list_pages", { project_id: z.string() }, ({ project_id }) => ({
+  content: [{ type: "text", text: JSON.stringify(listPages(db, project_id)) }]
+}))
+
+server.tool("list_issues", {
+  project_id: z.string().optional(), status: z.string().optional(), limit: z.number().optional(),
+}, ({ project_id, status, limit }) => ({
+  content: [{ type: "text", text: JSON.stringify(listIssues(db, project_id, status, limit ?? 50)) }]
+}))
+
+server.tool("resolve_issue", {
+  id: z.string(), status: z.enum(["open", "resolved", "ignored"]),
+}, ({ id, status }) => ({
+  content: [{ type: "text", text: JSON.stringify(updateIssueStatus(db, id, status)) }]
+}))
+
+server.tool("create_alert_rule", {
+  project_id: z.string(), name: z.string(),
+  level: z.string().optional(), service: z.string().optional(),
+  threshold_count: z.number().optional(), window_seconds: z.number().optional(),
+  action: z.enum(["webhook", "log"]).optional(), webhook_url: z.string().optional(),
+}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createAlertRule(db, args)) }] }))
+
+server.tool("list_alert_rules", {
+  project_id: z.string().optional(),
+}, ({ project_id }) => ({
+  content: [{ type: "text", text: JSON.stringify(listAlertRules(db, project_id)) }]
+}))
 
-server.tool("list_projects", {}, () => {
-  return { content: [{ type: "text", text: JSON.stringify(listProjects(db)) }] }
+server.tool("delete_alert_rule", { id: z.string() }, ({ id }) => {
+  deleteAlertRule(db, id)
+  return { content: [{ type: "text", text: "deleted" }] }
 })
 
-server.tool("list_pages", { project_id: z.string() }, ({ project_id }) => {
-  return { content: [{ type: "text", text: JSON.stringify(listPages(db, project_id)) }] }
+server.tool("log_session_context", {
+  session_id: z.string(),
+  brief: z.boolean().optional(),
+}, async ({ session_id, brief }) => {
+  const ctx = await getSessionContext(db, session_id)
+  return { content: [{ type: "text", text: JSON.stringify({ ...ctx, logs: applyBrief(ctx.logs, brief !== false) }) }] }
 })
 
+server.tool("get_health", {}, () => ({
+  content: [{ type: "text", text: JSON.stringify(getHealth(db)) }]
+}))
+
 const transport = new StdioServerTransport()
 await server.connect(transport)

package/src/server/index.ts

@@ -1,13 +1,18 @@
 #!/usr/bin/env bun
 import { Hono } from "hono"
 import { cors } from "hono/cors"
+import { serveStatic } from "hono/bun"
 import { getDb } from "../db/index.ts"
 import { getBrowserScript } from "../lib/browser-script.ts"
+import { getHealth } from "../lib/health.ts"
 import { startScheduler } from "../lib/scheduler.ts"
+import { alertsRoutes } from "./routes/alerts.ts"
+import { issuesRoutes } from "./routes/issues.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"
+import { streamRoutes } from "./routes/stream.ts"
 
 const PORT = Number(process.env.LOGS_PORT ?? 3460)
 const db = getDb()
@@ -25,11 +30,17 @@ app.get("/script.js", (c) => {
 
 // API routes
 app.route("/api/logs", logsRoutes(db))
+app.route("/api/logs/stream", streamRoutes(db))
 app.route("/api/projects", projectsRoutes(db))
 app.route("/api/jobs", jobsRoutes(db))
+app.route("/api/alerts", alertsRoutes(db))
+app.route("/api/issues", issuesRoutes(db))
 app.route("/api/perf", perfRoutes(db))
 
-app.get("/", (c) => c.json({ service: "@hasna/logs", port: PORT, status: "ok" }))
+app.get("/health", (c) => c.json(getHealth(db)))
+app.get("/dashboard", (c) => c.redirect("/dashboard/"))
+app.use("/dashboard/*", serveStatic({ root: "./dashboard/dist", rewriteRequestPath: (p) => p.replace(/^\/dashboard/, "") }))
+app.get("/", (c) => c.json({ service: "@hasna/logs", port: PORT, status: "ok", dashboard: `http://localhost:${PORT}/dashboard/` }))
 
 // Start scheduler
 startScheduler(db)

package/src/server/routes/alerts.ts

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

package/src/server/routes/issues.ts

@@ -0,0 +1,43 @@
+import { Hono } from "hono"
+import type { Database } from "bun:sqlite"
+import { getIssue, listIssues, updateIssueStatus } from "../../lib/issues.ts"
+import { searchLogs } from "../../lib/query.ts"
+
+export function issuesRoutes(db: Database) {
+  const app = new Hono()
+
+  app.get("/", (c) => {
+    const { project_id, status, limit } = c.req.query()
+    return c.json(listIssues(db, project_id || undefined, status || undefined, limit ? Number(limit) : 50))
+  })
+
+  app.get("/:id", (c) => {
+    const issue = getIssue(db, c.req.param("id"))
+    if (!issue) return c.json({ error: "not found" }, 404)
+    return c.json(issue)
+  })
+
+  app.get("/:id/logs", (c) => {
+    const issue = getIssue(db, c.req.param("id"))
+    if (!issue) return c.json({ error: "not found" }, 404)
+    // Search logs matching this issue's fingerprint via service+level
+    const rows = searchLogs(db, {
+      project_id: issue.project_id ?? undefined,
+      level: issue.level as "error",
+      service: issue.service ?? undefined,
+      text: issue.message_template.slice(0, 50),
+      limit: 50,
+    })
+    return c.json(rows)
+  })
+
+  app.put("/:id", async (c) => {
+    const { status } = await c.req.json() as { status: "open" | "resolved" | "ignored" }
+    if (!["open", "resolved", "ignored"].includes(status)) return c.json({ error: "invalid status" }, 422)
+    const updated = updateIssueStatus(db, c.req.param("id"), status)
+    if (!updated) return c.json({ error: "not found" }, 404)
+    return c.json(updated)
+  })
+
+  return app
+}

package/src/server/routes/logs.ts

@@ -3,6 +3,7 @@ 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 { exportToCsv, exportToJson } from "../../lib/export.ts"
 import type { LogEntry, LogLevel } from "../../types/index.ts"
 
 export function logsRoutes(db: Database) {
@@ -61,5 +62,25 @@ export function logsRoutes(db: Database) {
     return c.json(rows)
   })
 
+  // GET /api/logs/export?format=json|csv&project_id=&since=&level=
+  app.get("/export", (c) => {
+    const { project_id, since, until, level, service, format, limit } = c.req.query()
+    const opts = { project_id: project_id || undefined, since: since || undefined, until: until || undefined, level: level || undefined, service: service || undefined, limit: limit ? Number(limit) : undefined }
+
+    if (format === "csv") {
+      c.header("Content-Type", "text/csv")
+      c.header("Content-Disposition", "attachment; filename=logs.csv")
+      const chunks: string[] = []
+      exportToCsv(db, opts, s => chunks.push(s))
+      return c.text(chunks.join(""))
+    }
+
+    c.header("Content-Type", "application/json")
+    c.header("Content-Disposition", "attachment; filename=logs.json")
+    const chunks: string[] = []
+    exportToJson(db, opts, s => chunks.push(s))
+    return c.text(chunks.join("\n"))
+  })
+
   return app
 }

package/src/server/routes/projects.ts

@@ -2,6 +2,8 @@ import { Hono } from "hono"
 import type { Database } from "bun:sqlite"
 import { createPage, createProject, getProject, listPages, listProjects } from "../../lib/projects.ts"
 import { syncGithubRepo } from "../../lib/github.ts"
+import { runRetentionForProject, setRetentionPolicy } from "../../lib/retention.ts"
+import { deletePageAuth, setPageAuth } from "../../lib/page-auth.ts"
 
 export function projectsRoutes(db: Database) {
   const app = new Hono()
@@ -30,6 +32,29 @@ export function projectsRoutes(db: Database) {
 
   app.get("/:id/pages", (c) => c.json(listPages(db, c.req.param("id"))))
 
+  app.put("/:id/retention", async (c) => {
+    const body = await c.req.json()
+    setRetentionPolicy(db, c.req.param("id"), body)
+    return c.json({ updated: true })
+  })
+
+  app.post("/:id/retention/run", (c) => {
+    const result = runRetentionForProject(db, c.req.param("id"))
+    return c.json(result)
+  })
+
+  app.post("/:id/pages/:page_id/auth", async (c) => {
+    const { type, credentials } = await c.req.json()
+    if (!type || !credentials) return c.json({ error: "type and credentials required" }, 422)
+    const result = setPageAuth(db, c.req.param("page_id"), type, credentials)
+    return c.json({ id: result.id, type: result.type, created_at: result.created_at }, 201)
+  })
+
+  app.delete("/:id/pages/:page_id/auth", (c) => {
+    deletePageAuth(db, c.req.param("page_id"))
+    return c.json({ deleted: true })
+  })
+
   app.post("/:id/sync-repo", async (c) => {
     const project = getProject(db, c.req.param("id"))
     if (!project) return c.json({ error: "not found" }, 404)