@hasna/logs 0.3.25 → 0.3.27

package/src/lib/rotate.ts

@@ -1,27 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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"
-
-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 })
-
-  // 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[] = []
-  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

@@ -1,63 +0,0 @@
-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>()
-
-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)
-  }
-  // 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`)
-}
-
-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/session-context.ts

@@ -1,28 +0,0 @@
-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/lib/summarize.test.ts

@@ -1,38 +0,0 @@
-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

@@ -1,23 +0,0 @@
-import type { Database } from "bun:sqlite"
-import type { LogSummary } from "../types/index.ts"
-import { parseTime } from "./parse-time.ts"
-
-export function summarizeLogs(db: Database, projectId?: string, since?: string, until?: 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 = parseTime(since) ?? since }
-  if (until) { conditions.push("timestamp <= $until"); params.$until = parseTime(until) ?? until }
-
-  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/http.test.ts

@@ -1,92 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { buildServer } from "./index.ts";
-import {
-  DEFAULT_MCP_HTTP_PORT,
-  isHttpMode,
-  resolveMcpHttpPort,
-  startMcpHttpServer,
-} from "./http.ts";
-
-describe("logs MCP HTTP transport", () => {
-  test("defaults port to 8864", () => {
-    expect(DEFAULT_MCP_HTTP_PORT).toBe(8864);
-    expect(resolveMcpHttpPort(["node"], {})).toBe(8864);
-    expect(resolveMcpHttpPort(["node", "--port", "9001"], {})).toBe(9001);
-    expect(resolveMcpHttpPort(["node"], { MCP_HTTP_PORT: "9002" })).toBe(9002);
-  });
-
-  test("isHttpMode detects flag and env", () => {
-    expect(isHttpMode(["node"], {})).toBe(false);
-    expect(isHttpMode(["node", "--http"], {})).toBe(true);
-    expect(isHttpMode(["node"], { MCP_HTTP: "1" })).toBe(true);
-  });
-});
-
-describe("logs buildServer stdio registration", () => {
-  test("registers tools over in-memory transport", async () => {
-    const server = buildServer();
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-    await server.connect(serverTransport);
-
-    const client = new Client({ name: "test", version: "0.0.0" });
-    await client.connect(clientTransport);
-
-    const tools = await client.listTools();
-    expect(tools.tools.some((tool) => tool.name === "get_health")).toBe(true);
-
-    await client.close();
-    await server.close();
-  });
-});
-
-describe("logs streamable HTTP server", () => {
-  let handle: Awaited<ReturnType<typeof startMcpHttpServer>>;
-
-  beforeAll(async () => {
-    handle = await startMcpHttpServer(buildServer, { port: 0 });
-  });
-
-  afterAll(async () => {
-    await handle.close();
-  });
-
-  test("GET /health returns ok", async () => {
-    const res = await fetch(`http://${handle.host}:${handle.port}/health`);
-    expect(res.status).toBe(200);
-    expect(await res.json()).toEqual({ status: "ok", name: "logs" });
-  });
-
-  test("initialize and call get_health over streamable HTTP", async () => {
-    const transport = new StreamableHTTPClientTransport(
-      new URL(`http://${handle.host}:${handle.port}/mcp`),
-    );
-    const client = new Client({ name: "test", version: "0.0.0" });
-    await client.connect(transport);
-
-    const result = await client.callTool({ name: "get_health", arguments: {} });
-    expect(result.content).toBeDefined();
-    expect(Array.isArray(result.content)).toBe(true);
-
-    await client.close();
-  });
-
-  test("serves three concurrent clients from one process", async () => {
-    const clients = await Promise.all(
-      Array.from({ length: 3 }, async () => {
-        const transport = new StreamableHTTPClientTransport(
-          new URL(`http://${handle.host}:${handle.port}/mcp`),
-        );
-        const client = new Client({ name: "test", version: "0.0.0" });
-        await client.connect(transport);
-        const tools = await client.listTools();
-        return { client, count: tools.tools.length };
-      }),
-    );
-
-    expect(clients.every((entry) => entry.count > 0)).toBe(true);
-    await Promise.all(clients.map((entry) => entry.client.close()));
-  });
-});

package/src/mcp/http.ts

@@ -1,135 +0,0 @@
-import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-export const MCP_HTTP_SERVICE_NAME = "logs";
-export const DEFAULT_MCP_HTTP_PORT = 8864;
-
-export function isHttpMode(
-  argv: string[] = process.argv,
-  env: NodeJS.ProcessEnv = process.env,
-): boolean {
-  return argv.includes("--http") || env.MCP_HTTP === "1";
-}
-
-export function isStdioMode(
-  argv: string[] = process.argv,
-  env: NodeJS.ProcessEnv = process.env,
-): boolean {
-  return argv.includes("--stdio") || env.MCP_STDIO === "1";
-}
-
-export function resolveMcpHttpPort(
-  argv: string[] = process.argv,
-  env: NodeJS.ProcessEnv = process.env,
-): number {
-  const portIdx = argv.indexOf("--port");
-  if (portIdx !== -1 && argv[portIdx + 1]) {
-    return parsePort(argv[portIdx + 1]!, "--port");
-  }
-  if (env.MCP_HTTP_PORT) {
-    return parsePort(env.MCP_HTTP_PORT, "MCP_HTTP_PORT");
-  }
-  return DEFAULT_MCP_HTTP_PORT;
-}
-
-function parsePort(raw: string, source: string): number {
-  const parsed = Number(raw);
-  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
-    throw new Error(`Invalid ${source} value "${raw}". Expected 0-65535.`);
-  }
-  return parsed;
-}
-
-async function readJsonBody(req: IncomingMessage): Promise<unknown> {
-  const chunks: Buffer[] = [];
-  for await (const chunk of req) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-  }
-  const text = Buffer.concat(chunks).toString("utf8");
-  if (!text) return undefined;
-  return JSON.parse(text) as unknown;
-}
-
-export type McpHttpServerHandle = {
-  port: number;
-  host: string;
-  close: () => Promise<void>;
-};
-
-export async function startMcpHttpServer(
-  buildServer: () => McpServer,
-  options?: { port?: number; host?: string; serviceName?: string },
-): Promise<McpHttpServerHandle> {
-  const host = options?.host ?? "127.0.0.1";
-  const requestedPort = options?.port ?? resolveMcpHttpPort();
-  const serviceName = options?.serviceName ?? MCP_HTTP_SERVICE_NAME;
-
-  const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
-    try {
-      const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
-
-      if (req.method === "GET" && url.pathname === "/health") {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ status: "ok", name: serviceName }));
-        return;
-      }
-
-      if (url.pathname !== "/mcp") {
-        res.writeHead(404, { "Content-Type": "text/plain" });
-        res.end("Not Found");
-        return;
-      }
-
-      const server = buildServer();
-      const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: undefined,
-      });
-
-      await server.connect(transport);
-
-      let parsedBody: unknown;
-      if (req.method === "POST") {
-        parsedBody = await readJsonBody(req);
-      }
-
-      await transport.handleRequest(req, res, parsedBody);
-
-      res.on("close", () => {
-        void transport.close();
-        void server.close();
-      });
-    } catch (error) {
-      console.error(`[${serviceName}-mcp] HTTP error:`, error);
-      if (!res.headersSent) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(
-          JSON.stringify({
-            jsonrpc: "2.0",
-            error: { code: -32603, message: "Internal server error" },
-            id: null,
-          }),
-        );
-      }
-    }
-  });
-
-  await new Promise<void>((resolve, reject) => {
-    httpServer.once("error", reject);
-    httpServer.listen(requestedPort, host, () => resolve());
-  });
-
-  const addr = httpServer.address();
-  const port = typeof addr === "object" && addr ? addr.port : requestedPort;
-
-  console.error(`[${serviceName}-mcp] Streamable HTTP listening on http://${host}:${port}/mcp`);
-
-  return {
-    port,
-    host,
-    close: () =>
-      new Promise<void>((resolve, reject) => {
-        httpServer.close((err) => (err ? reject(err) : resolve()));
-      }),
-  };
-}

package/src/mcp/index.test.ts

@@ -1,27 +0,0 @@
-import { test, expect } from "bun:test"
-import { fileURLToPath } from "url"
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
-
-test("logs MCP lists tools over stdio", async () => {
-  const entry = fileURLToPath(new URL("./index.ts", import.meta.url))
-  const transport = new StdioClientTransport({
-    command: "bun",
-    args: ["run", entry],
-  })
-  const client = new Client({ name: "logs-mcp-test", version: "0.0.0" }, { capabilities: {} })
-
-  try {
-    await client.connect(transport)
-    const result = await client.listTools()
-    const toolNames = result.tools.map((tool) => tool.name)
-
-    expect(toolNames.length).toBeGreaterThan(0)
-    expect(toolNames).toContain("get_health")
-    expect(toolNames).toContain("log_export")
-    expect(toolNames).toContain("log_search")
-    expect(toolNames).toContain("log_stats")
-  } finally {
-    await client.close().catch(() => {})
-  }
-})