@hasna/logs 0.0.1 → 0.2.0

package/dist/server/index.js

@@ -1,31 +1,52 @@
 #!/usr/bin/env bun
 // @bun
 import {
+  deletePageAuth,
+  runRetentionForProject,
+  setPageAuth,
+  setRetentionPolicy,
   startScheduler
-} from "../index-dh02dp7n.js";
+} from "../index-2p6ynjet.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-77ss2sf4.js";
 import {
   createJob,
   deleteJob,
   listJobs,
   updateJob
-} from "../index-4mnved04.js";
+} from "../jobs-124e878j.js";
+import {
+  getLogContext,
+  searchLogs,
+  tailLogs
+} from "../query-0qv7fvzt.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) => {
@@ -1650,6 +1671,277 @@ var cors = (options) => {
   };
 };
 
+// node_modules/hono/dist/adapter/bun/serve-static.js
+import { stat } from "fs/promises";
+import { join } from "path";
+
+// node_modules/hono/dist/utils/compress.js
+var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+
+// node_modules/hono/dist/utils/mime.js
+var getMimeType = (filename, mimes = baseMimes) => {
+  const regexp = /\.([a-zA-Z0-9]+?)$/;
+  const match2 = filename.match(regexp);
+  if (!match2) {
+    return;
+  }
+  let mimeType = mimes[match2[1].toLowerCase()];
+  if (mimeType && mimeType.startsWith("text")) {
+    mimeType += "; charset=utf-8";
+  }
+  return mimeType;
+};
+var _baseMimes = {
+  aac: "audio/aac",
+  avi: "video/x-msvideo",
+  avif: "image/avif",
+  av1: "video/av1",
+  bin: "application/octet-stream",
+  bmp: "image/bmp",
+  css: "text/css",
+  csv: "text/csv",
+  eot: "application/vnd.ms-fontobject",
+  epub: "application/epub+zip",
+  gif: "image/gif",
+  gz: "application/gzip",
+  htm: "text/html",
+  html: "text/html",
+  ico: "image/x-icon",
+  ics: "text/calendar",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  js: "text/javascript",
+  json: "application/json",
+  jsonld: "application/ld+json",
+  map: "application/json",
+  mid: "audio/x-midi",
+  midi: "audio/x-midi",
+  mjs: "text/javascript",
+  mp3: "audio/mpeg",
+  mp4: "video/mp4",
+  mpeg: "video/mpeg",
+  oga: "audio/ogg",
+  ogv: "video/ogg",
+  ogx: "application/ogg",
+  opus: "audio/opus",
+  otf: "font/otf",
+  pdf: "application/pdf",
+  png: "image/png",
+  rtf: "application/rtf",
+  svg: "image/svg+xml",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  ts: "video/mp2t",
+  ttf: "font/ttf",
+  txt: "text/plain",
+  wasm: "application/wasm",
+  webm: "video/webm",
+  weba: "audio/webm",
+  webmanifest: "application/manifest+json",
+  webp: "image/webp",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  xhtml: "application/xhtml+xml",
+  xml: "application/xml",
+  zip: "application/zip",
+  "3gp": "video/3gpp",
+  "3g2": "video/3gpp2",
+  gltf: "model/gltf+json",
+  glb: "model/gltf-binary"
+};
+var baseMimes = _baseMimes;
+
+// node_modules/hono/dist/middleware/serve-static/path.js
+var defaultJoin = (...paths) => {
+  let result = paths.filter((p) => p !== "").join("/");
+  result = result.replace(/(?<=\/)\/+/g, "");
+  const segments = result.split("/");
+  const resolved = [];
+  for (const segment of segments) {
+    if (segment === ".." && resolved.length > 0 && resolved.at(-1) !== "..") {
+      resolved.pop();
+    } else if (segment !== ".") {
+      resolved.push(segment);
+    }
+  }
+  return resolved.join("/") || ".";
+};
+
+// node_modules/hono/dist/middleware/serve-static/index.js
+var ENCODINGS = {
+  br: ".br",
+  zstd: ".zst",
+  gzip: ".gz"
+};
+var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+var DEFAULT_DOCUMENT = "index.html";
+var serveStatic = (options) => {
+  const root = options.root ?? "./";
+  const optionPath = options.path;
+  const join = options.join ?? defaultJoin;
+  return async (c, next) => {
+    if (c.finalized) {
+      return next();
+    }
+    let filename;
+    if (options.path) {
+      filename = options.path;
+    } else {
+      try {
+        filename = tryDecodeURI(c.req.path);
+        if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
+          throw new Error;
+        }
+      } catch {
+        await options.onNotFound?.(c.req.path, c);
+        return next();
+      }
+    }
+    let path = join(root, !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename);
+    if (options.isDir && await options.isDir(path)) {
+      path = join(path, DEFAULT_DOCUMENT);
+    }
+    const getContent = options.getContent;
+    let content = await getContent(path, c);
+    if (content instanceof Response) {
+      return c.newResponse(content.body, content);
+    }
+    if (content) {
+      const mimeType = options.mimes && getMimeType(path, options.mimes) || getMimeType(path);
+      c.header("Content-Type", mimeType || "application/octet-stream");
+      if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+        const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim()));
+        for (const encoding of ENCODINGS_ORDERED_KEYS) {
+          if (!acceptEncodingSet.has(encoding)) {
+            continue;
+          }
+          const compressedContent = await getContent(path + ENCODINGS[encoding], c);
+          if (compressedContent) {
+            content = compressedContent;
+            c.header("Content-Encoding", encoding);
+            c.header("Vary", "Accept-Encoding", { append: true });
+            break;
+          }
+        }
+      }
+      await options.onFound?.(path, c);
+      return c.body(content);
+    }
+    await options.onNotFound?.(path, c);
+    await next();
+    return;
+  };
+};
+
+// node_modules/hono/dist/adapter/bun/serve-static.js
+var serveStatic2 = (options) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      const file = Bun.file(path);
+      return await file.exists() ? file : null;
+    };
+    const isDir = async (path) => {
+      let isDir2;
+      try {
+        const stats = await stat(path);
+        isDir2 = stats.isDirectory();
+      } catch {}
+      return isDir2;
+    };
+    return serveStatic({
+      ...options,
+      getContent,
+      join,
+      isDir
+    })(c, next);
+  };
+};
+
+// node_modules/hono/dist/helper/ssg/middleware.js
+var X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
+var SSG_DISABLED_RESPONSE = (() => {
+  try {
+    return new Response("SSG is disabled", {
+      status: 404,
+      headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
+    });
+  } catch {
+    return null;
+  }
+})();
+// node_modules/hono/dist/adapter/bun/ssg.js
+var { write } = Bun;
+
+// node_modules/hono/dist/helper/websocket/index.js
+var WSContext = class {
+  #init;
+  constructor(init) {
+    this.#init = init;
+    this.raw = init.raw;
+    this.url = init.url ? new URL(init.url) : null;
+    this.protocol = init.protocol ?? null;
+  }
+  send(source, options) {
+    this.#init.send(source, options ?? {});
+  }
+  raw;
+  binaryType = "arraybuffer";
+  get readyState() {
+    return this.#init.readyState;
+  }
+  url;
+  protocol;
+  close(code, reason) {
+    this.#init.close(code, reason);
+  }
+};
+var defineWebSocketHelper = (handler) => {
+  return (...args) => {
+    if (typeof args[0] === "function") {
+      const [createEvents, options] = args;
+      return async function upgradeWebSocket(c, next) {
+        const events = await createEvents(c);
+        const result = await handler(c, events, options);
+        if (result) {
+          return result;
+        }
+        await next();
+      };
+    } else {
+      const [c, events, options] = args;
+      return (async () => {
+        const upgraded = await handler(c, events, options);
+        if (!upgraded) {
+          throw new Error("Failed to upgrade WebSocket");
+        }
+        return upgraded;
+      })();
+    }
+  };
+};
+
+// node_modules/hono/dist/adapter/bun/server.js
+var getBunServer = (c) => ("server" in c.env) ? c.env.server : c.env;
+
+// node_modules/hono/dist/adapter/bun/websocket.js
+var upgradeWebSocket = defineWebSocketHelper((c, events) => {
+  const server = getBunServer(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  const upgradeResult = server.upgrade(c.req.raw, {
+    data: {
+      events,
+      url: new URL(c.req.url),
+      protocol: c.req.url
+    }
+  });
+  if (upgradeResult) {
+    return new Response(null);
+  }
+  return;
+});
+
 // src/lib/browser-script.ts
 function getBrowserScript(serverUrl) {
   return `(function(){
@@ -1674,6 +1966,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 +2104,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 +2197,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 +2229,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,10 +2426,16 @@ 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("/", (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/*", serveStatic2({ 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/` }));
 startScheduler(db);
 console.log(`@hasna/logs server running on http://localhost:${PORT}`);
 var server_default = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/logs",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Log aggregation + browser script + headless page scanner + performance monitoring for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,6 +12,8 @@
   },
   "scripts": {
     "build": "bun build src/cli/index.ts src/mcp/index.ts src/server/index.ts --outdir dist --target bun --splitting --external playwright --external playwright-core --external electron --external chromium-bidi --external lighthouse",
+    "build:dashboard": "cd dashboard && bun run build",
+    "build:all": "bun run build:dashboard && bun run build",
     "dev": "bun run src/server/index.ts",
     "test": "bun test",
     "test:coverage": "bun test --coverage",
@@ -21,7 +23,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": {