@hasna/logs 0.1.0 → 0.2.0

package/sdk/src/index.ts

@@ -1,4 +1,4 @@
-import type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob } from "../../src/types/index.ts"
+import type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob } from "./types.ts"
 
 export type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob }
 

package/sdk/src/types.ts

@@ -0,0 +1,56 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal"
+export type LogSource = "sdk" | "script" | "scanner"
+
+export interface LogEntry {
+  level: LogLevel
+  message: string
+  project_id?: string
+  page_id?: string
+  source?: LogSource
+  service?: string
+  trace_id?: string
+  session_id?: string
+  agent?: string
+  url?: string
+  stack_trace?: string
+  metadata?: Record<string, unknown>
+}
+
+export interface LogRow {
+  id: string; timestamp: string; project_id: string | null; page_id: string | null
+  level: LogLevel; source: LogSource; service: string | null; message: string
+  trace_id: string | null; session_id: string | null; agent: string | null
+  url: string | null; stack_trace: string | null; metadata: string | null
+}
+
+export interface Project {
+  id: string; name: string; github_repo: string | null; base_url: string | null
+  description: string | null; created_at: string
+}
+
+export interface Page {
+  id: string; project_id: string; url: string; path: string
+  name: string | null; last_scanned_at: string | null; created_at: string
+}
+
+export interface ScanJob {
+  id: string; project_id: string; page_id: string | null
+  schedule: string; enabled: number; last_run_at: string | null; created_at: string
+}
+
+export interface PerformanceSnapshot {
+  id: string; timestamp: string; project_id: string; page_id: string | null
+  url: string; lcp: number | null; fcp: number | null; cls: number | null
+  tti: number | null; ttfb: number | null; score: number | null; raw_audit: string | null
+}
+
+export interface LogQuery {
+  project_id?: string; page_id?: string; level?: LogLevel | LogLevel[]
+  service?: string; since?: string; until?: string; text?: string
+  trace_id?: string; limit?: number; offset?: number; fields?: string[]
+}
+
+export interface LogSummary {
+  project_id: string | null; service: string | null; page_id: string | null
+  level: LogLevel; count: number; latest: string
+}

package/src/cli/index.ts

@@ -151,6 +151,58 @@ program.command("scan")
     console.log("Scan complete.")
   })
 
+// ── logs watch ────────────────────────────────────────────
+program.command("watch")
+  .description("Stream new logs in real time with color coding")
+  .option("--project <id>")
+  .option("--level <levels>", "Comma-separated levels")
+  .option("--service <name>")
+  .action(async (opts) => {
+    const db = getDb()
+    const { searchLogs } = await import("../lib/query.ts")
+
+    const COLORS: Record<string, string> = {
+      debug: "\x1b[90m", info: "\x1b[36m", warn: "\x1b[33m", error: "\x1b[31m", fatal: "\x1b[35m",
+    }
+    const RESET = "\x1b[0m"
+    const BOLD = "\x1b[1m"
+
+    let lastTimestamp = new Date().toISOString()
+    let errorCount = 0
+    let warnCount = 0
+
+    process.stdout.write(`\x1b[2J\x1b[H`) // clear screen
+    console.log(`${BOLD}@hasna/logs watch${RESET} — Ctrl+C to exit\n`)
+
+    const poll = () => {
+      const rows = searchLogs(db, {
+        project_id: opts.project,
+        level: opts.level ? (opts.level.split(",") as LogLevel[]) : undefined,
+        service: opts.service,
+        since: lastTimestamp,
+        limit: 100,
+      }).reverse()
+
+      for (const row of rows) {
+        if (row.timestamp <= lastTimestamp) continue
+        lastTimestamp = row.timestamp
+        if (row.level === "error" || row.level === "fatal") errorCount++
+        if (row.level === "warn") warnCount++
+        const color = COLORS[row.level] ?? ""
+        const ts = row.timestamp.slice(11, 19)
+        const svc = (row.service ?? "-").padEnd(12)
+        const lvl = row.level.toUpperCase().padEnd(5)
+        console.log(`${color}${ts}  ${BOLD}${lvl}${RESET}${color}  ${svc}  ${row.message}${RESET}`)
+      }
+
+      // Update terminal title with counts
+      process.stdout.write(`\x1b]2;logs: ${errorCount}E ${warnCount}W\x07`)
+    }
+
+    const interval = setInterval(poll, 500)
+    process.on("SIGINT", () => { clearInterval(interval); console.log(`\n\nErrors: ${errorCount}  Warnings: ${warnCount}`); process.exit(0) })
+  })
+
 // ── logs export ───────────────────────────────────────────
 program.command("export")
   .description("Export logs to JSON or CSV")
@@ -203,11 +255,25 @@ program.command("mcp")
   .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
+      const { execSync } = await import("node:child_process")
+      // Resolve the MCP binary path — works from both source and dist
+      const selfPath = process.argv[1] ?? new URL(import.meta.url).pathname
+      const mcpBin = selfPath.replace(/cli\/index\.(ts|js)$/, "mcp/index.$1")
+      const runtime = process.execPath  // bun or node
+
       if (opts.claude) {
-        const { execSync } = await import("node:child_process")
-        execSync(`claude mcp add --transport stdio --scope user logs -- ${bin} ${script} mcp`, { stdio: "inherit" })
+        const cmd = `claude mcp add --transport stdio --scope user logs -- ${runtime} ${mcpBin}`
+        console.log(`Running: ${cmd}`)
+        execSync(cmd, { stdio: "inherit" })
+        console.log("✓ Installed logs-mcp into Claude Code")
+      }
+      if (opts.codex) {
+        const config = `[mcp_servers.logs]\ncommand = "${runtime}"\nargs = ["${mcpBin}"]`
+        console.log("Add to ~/.codex/config.toml:\n\n" + config)
+      }
+      if (opts.gemini) {
+        const config = JSON.stringify({ mcpServers: { logs: { command: runtime, args: [mcpBin] } } }, null, 2)
+        console.log("Add to ~/.gemini/settings.json mcpServers:\n\n" + config)
       }
       return
     }

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

@@ -14,6 +14,7 @@ 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()
@@ -47,6 +48,7 @@ const TOOLS: Record<string, string> = {
   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",
@@ -191,6 +193,14 @@ server.tool("delete_alert_rule", { id: z.string() }, ({ id }) => {
   return { content: [{ type: "text", text: "deleted" }] }
 })
 
+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)) }]
 }))

package/src/server/index.ts

@@ -1,6 +1,7 @@
 #!/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"
@@ -37,7 +38,9 @@ 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" }))
+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)