@hasna/logs 0.0.1 → 0.1.0

package/dist/server/index.js

@@ -1,31 +1,50 @@
 #!/usr/bin/env bun
 // @bun
 import {
+  deletePageAuth,
+  runRetentionForProject,
+  setPageAuth,
+  setRetentionPolicy,
   startScheduler
-} from "../index-dh02dp7n.js";
+} from "../index-4x090f69.js";
 import {
+  createAlertRule,
   createPage,
   createProject,
+  deleteAlertRule,
   getDb,
+  getIssue,
   getLatestSnapshot,
   getLogContext,
   getPerfTrend,
   getProject,
   ingestBatch,
   ingestLog,
+  listAlertRules,
+  listIssues,
   listPages,
   listProjects,
   searchLogs,
   summarizeLogs,
   tailLogs,
+  updateAlertRule,
+  updateIssueStatus,
   updateProject
-} from "../index-zj6ymcv7.js";
+} from "../index-qmsvtxax.js";
 import {
   createJob,
   deleteJob,
   listJobs,
   updateJob
-} from "../index-4mnved04.js";
+} from "../jobs-124e878j.js";
+import {
+  exportToCsv,
+  exportToJson
+} from "../export-yjaw2sr3.js";
+import {
+  getHealth
+} from "../health-f2qrebqc.js";
+import"../index-g8dczzvv.js";
 
 // node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
@@ -1674,6 +1693,71 @@ window.__logs={push:push,flush:flush,config:cfg};
 })();`;
 }
 
+// src/server/routes/alerts.ts
+function alertsRoutes(db) {
+  const app = new Hono2;
+  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;
+}
+
+// src/server/routes/issues.ts
+function issuesRoutes(db) {
+  const app = new Hono2;
+  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);
+    const rows = searchLogs(db, {
+      project_id: issue.project_id ?? undefined,
+      level: issue.level,
+      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();
+    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;
+}
+
 // src/server/routes/jobs.ts
 function jobsRoutes(db) {
   const app = new Hono2;
@@ -1747,6 +1831,23 @@ function logsRoutes(db) {
     const rows = getLogContext(db, c.req.param("trace_id"));
     return c.json(rows);
   });
+  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 chunks2 = [];
+      exportToCsv(db, opts, (s) => chunks2.push(s));
+      return c.text(chunks2.join(""));
+    }
+    c.header("Content-Type", "application/json");
+    c.header("Content-Disposition", "attachment; filename=logs.json");
+    const chunks = [];
+    exportToJson(db, opts, (s) => chunks.push(s));
+    return c.text(chunks.join(`
+`));
+  });
   return app;
 }
 
@@ -1823,6 +1924,26 @@ function projectsRoutes(db) {
     return c.json(page, 201);
   });
   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)
@@ -1835,6 +1956,191 @@ function projectsRoutes(db) {
   return app;
 }
 
+// node_modules/hono/dist/utils/stream.js
+var StreamingApi = class {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
+  aborted = false;
+  closed = false;
+  constructor(writable, _readable) {
+    this.writable = writable;
+    this.writer = writable.getWriter();
+    this.encoder = new TextEncoder;
+    const reader = _readable.getReader();
+    this.abortSubscribers.push(async () => {
+      await reader.cancel();
+    });
+    this.responseReadable = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        done ? controller.close() : controller.enqueue(value);
+      },
+      cancel: () => {
+        this.abort();
+      }
+    });
+  }
+  async write(input) {
+    try {
+      if (typeof input === "string") {
+        input = this.encoder.encode(input);
+      }
+      await this.writer.write(input);
+    } catch {}
+    return this;
+  }
+  async writeln(input) {
+    await this.write(input + `
+`);
+    return this;
+  }
+  sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async close() {
+    try {
+      await this.writer.close();
+    } catch {}
+    this.closed = true;
+  }
+  async pipe(body) {
+    this.writer.releaseLock();
+    await body.pipeTo(this.writable, { preventClose: true });
+    this.writer = this.writable.getWriter();
+  }
+  onAbort(listener) {
+    this.abortSubscribers.push(listener);
+  }
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => subscriber());
+    }
+  }
+};
+
+// node_modules/hono/dist/helper/streaming/utils.js
+var isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : undefined;
+  if (version === undefined) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+
+// node_modules/hono/dist/helper/streaming/sse.js
+var SSEStreamingApi = class extends StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const data = await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {});
+    const dataLines = data.split(/\r\n|\r|\n/).map((line) => {
+      return `data: ${line}`;
+    }).join(`
+`);
+    for (const key of ["event", "id", "retry"]) {
+      if (message[key] && /[\r\n]/.test(message[key])) {
+        throw new Error(`${key} must not contain "\\r" or "\\n"`);
+      }
+    }
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id && `id: ${message.id}`,
+      message.retry && `retry: ${message.retry}`
+    ].filter(Boolean).join(`
+`) + `
+
+`;
+    await this.write(sseData);
+  }
+};
+var run = async (stream, cb, onError) => {
+  try {
+    await cb(stream);
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream);
+      await stream.writeSSE({
+        event: "error",
+        data: e.message
+      });
+    } else {
+      console.error(e);
+    }
+  } finally {
+    stream.close();
+  }
+};
+var contextStash = /* @__PURE__ */ new WeakMap;
+var streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream;
+  const stream = new SSEStreamingApi(writable, readable);
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream.closed) {
+        stream.abort();
+      }
+    });
+  }
+  contextStash.set(stream.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream, cb, onError);
+  return c.newResponse(stream.responseReadable);
+};
+
+// src/server/routes/stream.ts
+function streamRoutes(db) {
+  const app = new Hono2;
+  app.get("/", (c) => {
+    const { project_id, level, service } = c.req.query();
+    return streamSSE(c, async (stream2) => {
+      let lastId = null;
+      const latest = db.prepare("SELECT id FROM logs ORDER BY timestamp DESC LIMIT 1").get();
+      lastId = latest?.id ?? null;
+      while (true) {
+        const conditions = [];
+        const params = {};
+        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);
+        for (const row of rows) {
+          await stream2.writeSSE({ data: JSON.stringify(row), id: row.id, event: row.level });
+          lastId = row.id;
+        }
+        await stream2.sleep(500);
+      }
+    });
+  });
+  return app;
+}
+
 // src/server/index.ts
 var PORT = Number(process.env.LOGS_PORT ?? 3460);
 var db = getDb();
@@ -1847,9 +2153,13 @@ app.get("/script.js", (c) => {
   return c.text(getBrowserScript(host));
 });
 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" }));
 startScheduler(db);
 console.log(`@hasna/logs server running on http://localhost:${PORT}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/logs",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Log aggregation + browser script + headless page scanner + performance monitoring for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,7 +21,15 @@
     "access": "restricted",
     "registry": "https://registry.npmjs.org/"
   },
-  "keywords": ["logs", "monitoring", "mcp", "ai-agents", "sentry", "performance", "lighthouse"],
+  "keywords": [
+    "logs",
+    "monitoring",
+    "mcp",
+    "ai-agents",
+    "sentry",
+    "performance",
+    "lighthouse"
+  ],
   "author": "Andrei Hasna <andrei@hasna.com>",
   "license": "MIT",
   "dependencies": {

package/src/cli/index.ts

@@ -151,6 +151,50 @@ program.command("scan")
     console.log("Scan complete.")
   })
 
+// ── logs export ───────────────────────────────────────────
+program.command("export")
+  .description("Export logs to JSON or CSV")
+  .option("--project <id>")
+  .option("--since <time>", "Relative time or ISO")
+  .option("--level <level>")
+  .option("--service <name>")
+  .option("--format <fmt>", "json or csv", "json")
+  .option("--output <file>", "Output file (default: stdout)")
+  .option("--limit <n>", "Max rows", "100000")
+  .action(async (opts) => {
+    const { exportToCsv, exportToJson } = await import("../lib/export.ts")
+    const { createWriteStream } = await import("node:fs")
+    const db = getDb()
+    const options = {
+      project_id: opts.project,
+      since: parseRelativeTime(opts.since),
+      level: opts.level,
+      service: opts.service,
+      limit: Number(opts.limit),
+    }
+    let count = 0
+    if (opts.output) {
+      const stream = createWriteStream(opts.output)
+      const write = (s: string) => stream.write(s)
+      count = opts.format === "csv" ? exportToCsv(db, options, write) : exportToJson(db, options, write)
+      stream.end()
+      console.error(`Exported ${count} log(s) to ${opts.output}`)
+    } else {
+      const write = (s: string) => process.stdout.write(s)
+      count = opts.format === "csv" ? exportToCsv(db, options, write) : exportToJson(db, options, write)
+      process.stderr.write(`\nExported ${count} log(s)\n`)
+    }
+  })
+
+// ── logs health ───────────────────────────────────────────
+program.command("health")
+  .description("Show server health and DB stats")
+  .action(async () => {
+    const { getHealth } = await import("../lib/health.ts")
+    const h = getHealth(getDb())
+    console.log(JSON.stringify(h, null, 2))
+  })
+
 // ── logs mcp / logs serve ─────────────────────────────────
 program.command("mcp")
   .description("Start the MCP server")

package/src/db/index.ts

@@ -1,6 +1,10 @@
 import { Database } from "bun:sqlite"
 import { join } from "node:path"
 import { existsSync, mkdirSync } from "node:fs"
+import { migrateAlertRules } from "./migrations/001_alert_rules.ts"
+import { migrateIssues } from "./migrations/002_issues.ts"
+import { migrateRetention } from "./migrations/003_retention.ts"
+import { migratePageAuth } from "./migrations/004_page_auth.ts"
 
 const DATA_DIR = process.env.LOGS_DATA_DIR ?? join(process.env.HOME ?? "~", ".logs")
 const DB_PATH = process.env.LOGS_DB_PATH ?? join(DATA_DIR, "logs.db")
@@ -150,4 +154,10 @@ function migrate(db: Database): void {
 
   db.run(`CREATE INDEX IF NOT EXISTS idx_perf_project_ts ON performance_snapshots(project_id, timestamp DESC)`)
   db.run(`CREATE INDEX IF NOT EXISTS idx_perf_page ON performance_snapshots(page_id)`)
+
+  // QoL migrations
+  migrateAlertRules(db)
+  migrateIssues(db)
+  migrateRetention(db)
+  migratePageAuth(db)
 }

package/src/db/migrations/001_alert_rules.ts

@@ -0,0 +1,21 @@
+import type { Database } from "bun:sqlite"
+
+export function migrateAlertRules(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS alert_rules (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      service TEXT,
+      level TEXT NOT NULL DEFAULT 'error' CHECK(level IN ('debug','info','warn','error','fatal')),
+      threshold_count INTEGER NOT NULL DEFAULT 10,
+      window_seconds INTEGER NOT NULL DEFAULT 60,
+      action TEXT NOT NULL DEFAULT 'webhook' CHECK(action IN ('webhook','log')),
+      webhook_url TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_fired_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    )
+  `)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_alert_rules_project ON alert_rules(project_id)`)
+}

package/src/db/migrations/002_issues.ts

@@ -0,0 +1,21 @@
+import type { Database } from "bun:sqlite"
+
+export function migrateIssues(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS issues (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+      fingerprint TEXT NOT NULL,
+      level TEXT NOT NULL,
+      service TEXT,
+      message_template TEXT NOT NULL,
+      first_seen TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      last_seen TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      count INTEGER NOT NULL DEFAULT 1,
+      status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open','resolved','ignored')),
+      UNIQUE(project_id, fingerprint)
+    )
+  `)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_issues_project ON issues(project_id, status)`)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_issues_fingerprint ON issues(fingerprint)`)
+}

package/src/db/migrations/003_retention.ts

@@ -0,0 +1,15 @@
+import type { Database } from "bun:sqlite"
+
+const RETENTION_COLUMNS = [
+  "max_rows INTEGER NOT NULL DEFAULT 100000",
+  "debug_ttl_hours INTEGER NOT NULL DEFAULT 24",
+  "info_ttl_hours INTEGER NOT NULL DEFAULT 168",
+  "warn_ttl_hours INTEGER NOT NULL DEFAULT 720",
+  "error_ttl_hours INTEGER NOT NULL DEFAULT 2160",
+]
+
+export function migrateRetention(db: Database): void {
+  for (const col of RETENTION_COLUMNS) {
+    try { db.run(`ALTER TABLE projects ADD COLUMN ${col}`) } catch { /* already exists */ }
+  }
+}

package/src/db/migrations/004_page_auth.ts

@@ -0,0 +1,13 @@
+import type { Database } from "bun:sqlite"
+
+export function migratePageAuth(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS page_auth (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      page_id TEXT NOT NULL UNIQUE REFERENCES pages(id) ON DELETE CASCADE,
+      type TEXT NOT NULL CHECK(type IN ('cookie','bearer','basic')),
+      credentials TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    )
+  `)
+}

package/src/lib/alerts.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it, mock } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { createAlertRule, deleteAlertRule, evaluateAlerts, listAlertRules, updateAlertRule } from "./alerts.ts"
+import { ingestBatch } from "./ingest.ts"
+
+function seedProject(db: ReturnType<typeof createTestDb>) {
+  return db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
+}
+
+describe("alert rules CRUD", () => {
+  it("creates an alert rule", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const rule = createAlertRule(db, { project_id: p.id, name: "High errors", level: "error", threshold_count: 5, window_seconds: 60 })
+    expect(rule.id).toBeTruthy()
+    expect(rule.name).toBe("High errors")
+    expect(rule.threshold_count).toBe(5)
+    expect(rule.enabled).toBe(1)
+  })
+
+  it("lists rules for a project", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    createAlertRule(db, { project_id: p.id, name: "r1" })
+    createAlertRule(db, { project_id: p.id, name: "r2" })
+    expect(listAlertRules(db, p.id)).toHaveLength(2)
+  })
+
+  it("updates a rule", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const rule = createAlertRule(db, { project_id: p.id, name: "r1" })
+    const updated = updateAlertRule(db, rule.id, { enabled: 0, threshold_count: 99 })
+    expect(updated?.enabled).toBe(0)
+    expect(updated?.threshold_count).toBe(99)
+  })
+
+  it("deletes a rule", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const rule = createAlertRule(db, { project_id: p.id, name: "r1" })
+    deleteAlertRule(db, rule.id)
+    expect(listAlertRules(db, p.id)).toHaveLength(0)
+  })
+})
+
+describe("alert evaluation", () => {
+  it("does not fire when under threshold", async () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    createAlertRule(db, { project_id: p.id, name: "r", level: "error", threshold_count: 10, window_seconds: 60, action: "log" })
+    ingestBatch(db, Array.from({ length: 5 }, () => ({ level: "error" as const, message: "e", project_id: p.id })))
+    // No throw = passes
+    await expect(evaluateAlerts(db, p.id, null, "error")).resolves.toBeUndefined()
+  })
+
+  it("fires when threshold exceeded (log action)", async () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    createAlertRule(db, { project_id: p.id, name: "r", level: "error", threshold_count: 3, window_seconds: 3600, action: "log" })
+    ingestBatch(db, Array.from({ length: 5 }, () => ({ level: "error" as const, message: "e", project_id: p.id })))
+    await expect(evaluateAlerts(db, p.id, null, "error")).resolves.toBeUndefined()
+    // Verify last_fired_at was set
+    const rule = db.prepare("SELECT last_fired_at FROM alert_rules WHERE project_id = ?").get(p.id) as { last_fired_at: string | null }
+    expect(rule.last_fired_at).toBeTruthy()
+  })
+})