@hasna/logs 0.0.1 → 0.1.0

package/src/mcp/index.ts

@@ -9,28 +9,47 @@ 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 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)",
+  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 +58,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 +90,110 @@ 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("get_health", {}, () => ({
+  content: [{ type: "text", text: JSON.stringify(getHealth(db)) }]
+}))
 
 const transport = new StdioServerTransport()
 await server.connect(transport)

package/src/server/index.ts

@@ -3,11 +3,15 @@ import { Hono } from "hono"
 import { cors } from "hono/cors"
 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,10 +29,14 @@ 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("/health", (c) => c.json(getHealth(db)))
 app.get("/", (c) => c.json({ service: "@hasna/logs", port: PORT, status: "ok" }))
 
 // Start scheduler

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)

package/src/server/routes/stream.ts

@@ -0,0 +1,43 @@
+import { Hono } from "hono"
+import { streamSSE } from "hono/streaming"
+import type { Database } from "bun:sqlite"
+import type { LogLevel, LogRow } from "../../types/index.ts"
+
+export function streamRoutes(db: Database) {
+  const app = new Hono()
+
+  // GET /api/logs/stream?project_id=&level=&service=
+  app.get("/", (c) => {
+    const { project_id, level, service } = c.req.query()
+
+    return streamSSE(c, async (stream) => {
+      let lastId: string | null = null
+
+      // Seed lastId with the most recent log so we only stream new ones
+      const latest = db.prepare("SELECT id FROM logs ORDER BY timestamp DESC LIMIT 1").get() as { id: string } | null
+      lastId = latest?.id ?? null
+
+      while (true) {
+        const conditions: string[] = []
+        const params: Record<string, unknown> = {}
+
+        if (lastId) { conditions.push("rowid > (SELECT rowid FROM logs WHERE id = $lastId)"); params.$lastId = lastId }
+        if (project_id) { conditions.push("project_id = $project_id"); params.$project_id = project_id }
+        if (level) { conditions.push("level IN (" + level.split(",").map((l, i) => `$l${i}`).join(",") + ")"); level.split(",").forEach((l, i) => { params[`$l${i}`] = l }) }
+        if (service) { conditions.push("service = $service"); params.$service = service }
+
+        const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
+        const rows = db.prepare(`SELECT * FROM logs ${where} ORDER BY timestamp ASC LIMIT 50`).all(params) as LogRow[]
+
+        for (const row of rows) {
+          await stream.writeSSE({ data: JSON.stringify(row), id: row.id, event: row.level })
+          lastId = row.id
+        }
+
+        await stream.sleep(500)
+      }
+    })
+  })
+
+  return app
+}