npm - lduck - Versions diffs - 0.0.1 - Mend

lduck 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1131 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { createNodeWebSocket } from "@hono/node-ws";
+import { jsx, Fragment, jsxs } from "react/jsx-runtime";
+import { Hono } from "hono";
+import { renderToString } from "react-dom/server";
+import { zValidator } from "@hono/zod-validator";
+import { z } from "zod";
+import { DuckDBInstance, DuckDBTimestampValue } from "@duckdb/node-api";
+import { EventEmitter } from "node:events";
+import { createInterface } from "node:readline";
+const __vite_import_meta_env__ = {};
+var ViteClient = () => {
+  if (__vite_import_meta_env__ && true) return /* @__PURE__ */ jsx(Fragment, {});
+  return /* @__PURE__ */ jsx("script", { type: "module", src: "/@vite/client" });
+};
+var ReactRefresh = () => {
+  if (__vite_import_meta_env__ && true) return /* @__PURE__ */ jsx(Fragment, {});
+  const refreshScript = `
+    import RefreshRuntime from '/@react-refresh';
+    RefreshRuntime.injectIntoGlobalHook(window);
+    window.$RefreshReg$ = () => {};
+    window.$RefreshSig$ = () => (type) => type;
+    window.__vite_plugin_react_preamble_installed__ = true;
+  `;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("script", { type: "module", src: "/@react-refresh" }),
+    /* @__PURE__ */ jsx("script", { type: "module", dangerouslySetInnerHTML: { __html: refreshScript } })
+  ] });
+};
+function createApp(scriptSrc, setup) {
+  const app = new Hono();
+  setup?.(app);
+  app.get("*", (c) => {
+    const html = renderToString(
+      /* @__PURE__ */ jsxs("html", { lang: "en", style: { margin: 0, padding: 0, height: "100%" }, children: [
+        /* @__PURE__ */ jsxs("head", { children: [
+          /* @__PURE__ */ jsx("meta", { charSet: "UTF-8" }),
+          /* @__PURE__ */ jsx("meta", { name: "viewport", content: "width=device-width,initial-scale=1.0" }),
+          /* @__PURE__ */ jsx("title", { children: "lduck" }),
+          /* @__PURE__ */ jsx(ViteClient, {}),
+          /* @__PURE__ */ jsx(ReactRefresh, {})
+        ] }),
+        /* @__PURE__ */ jsxs("body", { style: { margin: 0, padding: 0, height: "100%" }, children: [
+          /* @__PURE__ */ jsx("div", { id: "root" }),
+          /* @__PURE__ */ jsx("script", { type: "module", src: scriptSrc })
+        ] })
+      ] })
+    );
+    return c.html(`<!DOCTYPE html>${html}`);
+  });
+  return app;
+}
+const logQuerySchema = z.object({
+  level: z.enum(["DEBUG", "INFO", "WARN", "ERROR", "FATAL"]).optional(),
+  service: z.string().optional(),
+  source: z.string().optional(),
+  search: z.string().optional(),
+  startTime: z.coerce.date().optional(),
+  endTime: z.coerce.date().optional(),
+  limit: z.coerce.number().int().min(1).max(1e4).default(200),
+  offset: z.coerce.number().int().min(0).default(0),
+  order: z.enum(["asc", "desc"]).default("desc"),
+  jsonFilters: z.string().optional()
+});
+const statsQuerySchema = z.object({
+  source: z.string().optional()
+});
+const sqlQuerySchema = z.object({
+  sql: z.string().min(1).max(1e4)
+});
+const exportSchema = z.object({
+  format: z.enum(["csv", "json"]),
+  level: z.enum(["DEBUG", "INFO", "WARN", "ERROR", "FATAL"]).optional(),
+  service: z.string().optional(),
+  source: z.string().optional(),
+  search: z.string().optional(),
+  startTime: z.coerce.date().optional(),
+  endTime: z.coerce.date().optional()
+});
+const ingestBodySchema = z.union([
+  z.record(z.string(), z.unknown()),
+  z.array(z.record(z.string(), z.unknown()))
+]);
+const facetQuerySchema = z.object({
+  field: z.string(),
+  jsonPath: z.string().optional(),
+  level: z.enum(["DEBUG", "INFO", "WARN", "ERROR", "FATAL"]).optional(),
+  service: z.string().optional(),
+  source: z.string().optional(),
+  search: z.string().optional(),
+  startTime: z.coerce.date().optional(),
+  endTime: z.coerce.date().optional(),
+  jsonFilters: z.string().optional()
+});
+function validationHook(result, c) {
+  if (!result.success) {
+    return c.json(
+      {
+        error: {
+          code: "VALIDATION_ERROR",
+          message: "Invalid request parameters",
+          details: result.error?.issues
+        }
+      },
+      400
+    );
+  }
+}
+function serializeLogEntry(log) {
+  return {
+    _id: String(log._id),
+    _ingested: log._ingested.toISOString(),
+    _raw: log._raw,
+    timestamp: log.timestamp?.toISOString() ?? null,
+    level: log.level,
+    message: log.message,
+    service: log.service,
+    trace_id: log.trace_id,
+    host: log.host,
+    duration_ms: log.duration_ms,
+    source: log.source
+  };
+}
+function serializeStats$1(stats) {
+  return {
+    total: stats.total,
+    byLevel: stats.byLevel,
+    errorRate: stats.errorRate,
+    timeRange: {
+      min: stats.timeRange.min?.toISOString() ?? null,
+      max: stats.timeRange.max?.toISOString() ?? null
+    }
+  };
+}
+function createApiApp(db, ingester) {
+  const startTime = Date.now();
+  const app = new Hono().basePath("/api").get("/health", (c) => {
+    const uptime = (Date.now() - startTime) / 1e3;
+    return c.json({ status: "ok", uptime });
+  }).get("/schema", async (c) => {
+    try {
+      const schema = await db.getSchema();
+      return c.json(schema);
+    } catch (err) {
+      return c.json(
+        {
+          error: {
+            code: "INTERNAL_ERROR",
+            message: err instanceof Error ? err.message : "Unknown error"
+          }
+        },
+        500
+      );
+    }
+  }).get("/stats", zValidator("query", statsQuerySchema, validationHook), async (c) => {
+    try {
+      const { source } = c.req.valid("query");
+      const stats = await db.getStats(source ? { source } : void 0);
+      return c.json(serializeStats$1(stats));
+    } catch (err) {
+      return c.json(
+        {
+          error: {
+            code: "INTERNAL_ERROR",
+            message: err instanceof Error ? err.message : "Unknown error"
+          }
+        },
+        500
+      );
+    }
+  }).get("/logs", zValidator("query", logQuerySchema, validationHook), async (c) => {
+    try {
+      const params = c.req.valid("query");
+      let jsonFilters;
+      if (params.jsonFilters) {
+        try {
+          jsonFilters = JSON.parse(params.jsonFilters);
+        } catch {
+        }
+      }
+      const queryParams = {
+        level: params.level,
+        service: params.service,
+        source: params.source,
+        search: params.search,
+        startTime: params.startTime,
+        endTime: params.endTime,
+        limit: params.limit,
+        offset: params.offset,
+        order: params.order,
+        jsonFilters
+      };
+      const result = await db.queryLogs(queryParams);
+      return c.json({
+        logs: result.logs.map(serializeLogEntry),
+        total: result.total
+      });
+    } catch (err) {
+      return c.json(
+        {
+          error: {
+            code: "QUERY_ERROR",
+            message: err instanceof Error ? err.message : "Unknown error"
+          }
+        },
+        500
+      );
+    }
+  }).post("/query", zValidator("json", sqlQuerySchema, validationHook), async (c) => {
+    try {
+      const { sql } = c.req.valid("json");
+      const result = await db.executeQuery(sql);
+      return c.json(result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      if (message.startsWith("Forbidden SQL:")) {
+        return c.json(
+          {
+            error: {
+              code: "FORBIDDEN_SQL",
+              message
+            }
+          },
+          403
+        );
+      }
+      return c.json(
+        {
+          error: {
+            code: "QUERY_ERROR",
+            message
+          }
+        },
+        500
+      );
+    }
+  }).post("/export", zValidator("json", exportSchema, validationHook), async (c) => {
+    try {
+      const params = c.req.valid("json");
+      const queryParams = {
+        level: params.level,
+        service: params.service,
+        source: params.source,
+        search: params.search,
+        startTime: params.startTime,
+        endTime: params.endTime,
+        limit: 1e4,
+        // Export up to max
+        offset: 0,
+        order: "desc"
+      };
+      const stream = await db.exportLogs(queryParams, params.format);
+      const contentType = params.format === "csv" ? "text/csv; charset=utf-8" : "application/json; charset=utf-8";
+      const ext = params.format === "csv" ? "csv" : "json";
+      return new Response(stream, {
+        status: 200,
+        headers: {
+          "Content-Type": contentType,
+          "Content-Disposition": `attachment; filename="logs-export.${ext}"`
+        }
+      });
+    } catch (err) {
+      return c.json(
+        {
+          error: {
+            code: "INTERNAL_ERROR",
+            message: err instanceof Error ? err.message : "Unknown error"
+          }
+        },
+        500
+      );
+    }
+  }).post("/ingest", zValidator("json", ingestBodySchema, validationHook), (c) => {
+    if (!ingester) {
+      return c.json(
+        {
+          error: {
+            code: "NOT_AVAILABLE",
+            message: "Ingestion not available"
+          }
+        },
+        503
+      );
+    }
+    const body = c.req.valid("json");
+    const items = Array.isArray(body) ? body : [body];
+    const lines = items.map((item) => JSON.stringify(item));
+    ingester.ingestLines(lines);
+    return c.json({ accepted: lines.length });
+  }).get("/facets", zValidator("query", facetQuerySchema, validationHook), async (c) => {
+    try {
+      const params = c.req.valid("query");
+      let jsonFilters;
+      if (params.jsonFilters) {
+        try {
+          jsonFilters = JSON.parse(params.jsonFilters);
+        } catch {
+        }
+      }
+      const filters = {
+        level: params.level,
+        service: params.service,
+        source: params.source,
+        search: params.search,
+        startTime: params.startTime,
+        endTime: params.endTime,
+        jsonFilters
+      };
+      const distribution = await db.getFacetDistribution(
+        params.field,
+        params.jsonPath ?? null,
+        filters
+      );
+      return c.json(distribution);
+    } catch (err) {
+      return c.json(
+        {
+          error: {
+            code: "QUERY_ERROR",
+            message: err instanceof Error ? err.message : "Unknown error"
+          }
+        },
+        500
+      );
+    }
+  });
+  return app;
+}
+new Hono().basePath("/api").get(
+  "/health",
+  (c) => c.json({ status: "ok", uptime: 0 })
+);
+const CREATE_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS logs (
+    _id         BIGINT PRIMARY KEY,
+    _ingested   TIMESTAMP DEFAULT current_timestamp,
+    _raw        JSON,
+    timestamp   TIMESTAMP,
+    level       VARCHAR,
+    message     VARCHAR,
+    service     VARCHAR,
+    trace_id    VARCHAR,
+    host        VARCHAR,
+    duration_ms DOUBLE,
+    source      VARCHAR DEFAULT 'default'
+);
+`;
+const CREATE_INDEXES_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_level   ON logs(level);",
+  "CREATE INDEX IF NOT EXISTS idx_ts      ON logs(timestamp DESC);",
+  "CREATE INDEX IF NOT EXISTS idx_service ON logs(service);",
+  "CREATE INDEX IF NOT EXISTS idx_source  ON logs(source);"
+];
+const LOG_COLUMNS = "_id, _ingested, _raw, timestamp, level, message, service, trace_id, host, duration_ms, source";
+const ALLOWED_SQL_KEYWORDS = ["SELECT", "WITH", "EXPLAIN"];
+class LogDatabase {
+  instance = null;
+  connection = null;
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  async initialize(dbPath) {
+    if (dbPath === ":memory:") {
+      this.instance = await DuckDBInstance.create();
+    } else {
+      this.instance = await DuckDBInstance.create(dbPath);
+    }
+    this.connection = await this.instance.connect();
+    await this.connection.run(CREATE_TABLE_SQL);
+    for (const sql of CREATE_INDEXES_SQL) {
+      await this.connection.run(sql);
+    }
+  }
+  async close() {
+    if (this.connection) {
+      this.connection.closeSync();
+      this.connection = null;
+    }
+    if (this.instance) {
+      this.instance.closeSync();
+      this.instance = null;
+    }
+  }
+  getConnection() {
+    if (!this.connection) {
+      throw new Error("Database is not initialized or has been closed");
+    }
+    return this.connection;
+  }
+  // -------------------------------------------------------------------------
+  // Batch INSERT
+  // -------------------------------------------------------------------------
+  async insertBatch(logs) {
+    if (logs.length === 0) return;
+    const conn = this.getConnection();
+    const appender = await conn.createAppender("logs");
+    for (const log of logs) {
+      appender.appendBigInt(log._id);
+      appender.appendTimestamp(dateToTimestamp(log._ingested));
+      appender.appendVarchar(log._raw);
+      appendNullableTimestamp(appender, log.timestamp);
+      appendNullableVarchar(appender, log.level);
+      appendNullableVarchar(appender, log.message);
+      appendNullableVarchar(appender, log.service);
+      appendNullableVarchar(appender, log.trace_id);
+      appendNullableVarchar(appender, log.host);
+      appendNullableDouble(appender, log.duration_ms);
+      appender.appendVarchar(log.source);
+      appender.endRow();
+    }
+    appender.flushSync();
+    appender.closeSync();
+  }
+  // -------------------------------------------------------------------------
+  // Eviction
+  // -------------------------------------------------------------------------
+  async evictOldRows(maxRows) {
+    const conn = this.getConnection();
+    await conn.run(
+      `DELETE FROM logs WHERE _id <= (SELECT MAX(_id) - ${maxRows} FROM logs)`
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Query
+  // -------------------------------------------------------------------------
+  async queryLogs(params) {
+    const conn = this.getConnection();
+    const whereClause = buildWhereClause(params);
+    const countReader = await conn.runAndReadAll(
+      `SELECT COUNT(*) FROM logs ${whereClause}`
+    );
+    const total = Number(countReader.getRowsJS()[0][0]);
+    const orderDir = params.order === "asc" ? "ASC" : "DESC";
+    const dataReader = await conn.runAndReadAll(
+      `SELECT ${LOG_COLUMNS} FROM logs ${whereClause}
+       ORDER BY timestamp ${orderDir} NULLS LAST, _id ${orderDir}
+       LIMIT ${params.limit} OFFSET ${params.offset}`
+    );
+    const logs = dataReader.getRowsJS().map(rowToLogEntry);
+    return { logs, total };
+  }
+  // -------------------------------------------------------------------------
+  // Statistics
+  // -------------------------------------------------------------------------
+  async getStats(params) {
+    const conn = this.getConnection();
+    const whereClause = params?.source ? `WHERE source = '${escapeSql(params.source)}'` : "";
+    const totalReader = await conn.runAndReadAll(
+      `SELECT COUNT(*) FROM logs ${whereClause}`
+    );
+    const total = Number(totalReader.getRowsJS()[0][0]);
+    if (total === 0) {
+      return {
+        total: 0,
+        byLevel: {},
+        errorRate: 0,
+        timeRange: { min: null, max: null }
+      };
+    }
+    const levelWhereClause = whereClause ? `${whereClause} AND level IS NOT NULL` : "WHERE level IS NOT NULL";
+    const levelReader = await conn.runAndReadAll(
+      `SELECT level, COUNT(*) as cnt FROM logs ${levelWhereClause} GROUP BY level ORDER BY cnt DESC`
+    );
+    const byLevel = {};
+    for (const row of levelReader.getRowsJS()) {
+      byLevel[row[0]] = Number(row[1]);
+    }
+    const errorCount = (byLevel["ERROR"] ?? 0) + (byLevel["FATAL"] ?? 0);
+    const errorRate = errorCount / total;
+    const timeReader = await conn.runAndReadAll(
+      `SELECT MIN(timestamp), MAX(timestamp) FROM logs ${whereClause}`
+    );
+    const timeRow = timeReader.getRowsJS()[0];
+    return {
+      total,
+      byLevel,
+      errorRate,
+      timeRange: {
+        min: timeRow[0] !== null ? jsToDate(timeRow[0]) : null,
+        max: timeRow[1] !== null ? jsToDate(timeRow[1]) : null
+      }
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Facets
+  // -------------------------------------------------------------------------
+  async getFacetDistribution(field, jsonPath, filters) {
+    const conn = this.getConnection();
+    const columnExpr = jsonPath !== null ? `CAST(json_extract(_raw, '${escapeSql("$." + jsonPath)}') AS VARCHAR)` : `"${field}"`;
+    const conditions = buildFilterConditions(filters);
+    conditions.push(`${columnExpr} IS NOT NULL`);
+    const whereClause = `WHERE ${conditions.join(" AND ")}`;
+    const reader = await conn.runAndReadAll(
+      `SELECT ${columnExpr} as val, COUNT(*) as cnt FROM logs ${whereClause} GROUP BY val ORDER BY cnt DESC, val ASC`
+    );
+    const values = reader.getRowsJS().map((row) => {
+      let value = String(row[0]);
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1);
+      }
+      return { value, count: Number(row[1]) };
+    });
+    return { field, values };
+  }
+  // -------------------------------------------------------------------------
+  // Custom SQL Execution
+  // -------------------------------------------------------------------------
+  async executeQuery(sql) {
+    const conn = this.getConnection();
+    const firstKeyword = sql.trimStart().split(/\s+/)[0].toUpperCase();
+    if (!ALLOWED_SQL_KEYWORDS.includes(firstKeyword)) {
+      throw new Error(
+        `Forbidden SQL: only SELECT, WITH, and EXPLAIN statements are allowed. Got: ${firstKeyword}`
+      );
+    }
+    const reader = await conn.runAndReadAll(sql);
+    const columns = reader.columnNames();
+    const rows = reader.getRowsJS().map(
+      (row) => row.map((val) => typeof val === "bigint" ? Number(val) : val)
+    );
+    return { columns, rows };
+  }
+  // -------------------------------------------------------------------------
+  // Export
+  // -------------------------------------------------------------------------
+  async exportLogs(params, format) {
+    const conn = this.getConnection();
+    const whereClause = buildWhereClause(params);
+    const orderDir = params.order === "asc" ? "ASC" : "DESC";
+    const reader = await conn.runAndReadAll(
+      `SELECT ${LOG_COLUMNS} FROM logs ${whereClause}
+       ORDER BY timestamp ${orderDir} NULLS LAST, _id ${orderDir}
+       LIMIT ${params.limit} OFFSET ${params.offset}`
+    );
+    const columns = reader.columnNames();
+    const rows = reader.getRowsJS();
+    const encoder = new TextEncoder();
+    if (format === "csv") {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue(encoder.encode(columns.join(",") + "\n"));
+          for (const row of rows) {
+            controller.enqueue(
+              encoder.encode(row.map(csvEscape).join(",") + "\n")
+            );
+          }
+          controller.close();
+        }
+      });
+    }
+    const jsonRows = rows.map((row) => {
+      const obj = {};
+      for (let i = 0; i < columns.length; i++) {
+        let val = row[i];
+        if (typeof val === "bigint") val = Number(val);
+        if (columns[i] === "_raw" && typeof val === "string") {
+          try {
+            val = JSON.parse(val);
+          } catch {
+          }
+        }
+        obj[columns[i]] = val;
+      }
+      return obj;
+    });
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder.encode(JSON.stringify(jsonRows)));
+        controller.close();
+      }
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Schema
+  // -------------------------------------------------------------------------
+  async getSchema() {
+    const conn = this.getConnection();
+    const reader = await conn.runAndReadAll(
+      "SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_name = 'logs' ORDER BY ordinal_position"
+    );
+    return reader.getRowsJS().map((row) => ({
+      name: row[0],
+      type: row[1],
+      nullable: row[2] === "YES"
+    }));
+  }
+}
+function dateToTimestamp(date) {
+  return new DuckDBTimestampValue(BigInt(date.getTime()) * 1000n);
+}
+function jsToDate(value) {
+  if (value instanceof Date) return value;
+  if (typeof value === "string" || typeof value === "number") return new Date(value);
+  return new Date(String(value));
+}
+function escapeSql(value) {
+  return value.replace(/'/g, "''");
+}
+function csvEscape(value) {
+  if (value === null || value === void 0) return "";
+  const str = String(value);
+  if (str.includes(",") || str.includes('"') || str.includes("\n")) {
+    return '"' + str.replace(/"/g, '""') + '"';
+  }
+  return str;
+}
+function appendNullableVarchar(appender, value) {
+  if (value !== null) {
+    appender.appendVarchar(value);
+  } else {
+    appender.appendNull();
+  }
+}
+function appendNullableTimestamp(appender, value) {
+  if (value !== null) {
+    appender.appendTimestamp(dateToTimestamp(value));
+  } else {
+    appender.appendNull();
+  }
+}
+function appendNullableDouble(appender, value) {
+  if (value !== null) {
+    appender.appendDouble(value);
+  } else {
+    appender.appendNull();
+  }
+}
+function buildFilterConditions(params) {
+  const conditions = [];
+  if (params.level) {
+    conditions.push(`level = '${escapeSql(params.level)}'`);
+  }
+  if (params.service) {
+    conditions.push(`service = '${escapeSql(params.service)}'`);
+  }
+  if (params.source) {
+    conditions.push(`source = '${escapeSql(params.source)}'`);
+  }
+  if (params.search) {
+    conditions.push(`message ILIKE '%${escapeSql(params.search)}%'`);
+  }
+  if (params.startTime) {
+    conditions.push(`timestamp >= '${params.startTime.toISOString()}'`);
+  }
+  if (params.endTime) {
+    conditions.push(`timestamp <= '${params.endTime.toISOString()}'`);
+  }
+  if (params.jsonFilters) {
+    for (const [jsonPath, value] of Object.entries(params.jsonFilters)) {
+      const expr = `CAST(json_extract(_raw, '${escapeSql("$." + jsonPath)}') AS VARCHAR)`;
+      conditions.push(`${expr} = '${escapeSql(value)}'`);
+    }
+  }
+  return conditions;
+}
+function buildWhereClause(params) {
+  const conditions = buildFilterConditions(params);
+  return conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+}
+function rowToLogEntry(row) {
+  return {
+    _id: BigInt(row[0]),
+    _ingested: jsToDate(row[1]),
+    _raw: typeof row[2] === "string" ? JSON.parse(row[2]) : row[2],
+    timestamp: row[3] !== null ? jsToDate(row[3]) : null,
+    level: row[4],
+    message: row[5],
+    service: row[6],
+    trace_id: row[7],
+    host: row[8],
+    duration_ms: row[9],
+    source: row[10]
+  };
+}
+const FIELD_MAPPINGS = {
+  timestamp: ["timestamp", "ts", "time", "@timestamp", "datetime"],
+  level: ["level", "severity", "loglevel", "lvl", "priority"],
+  message: ["message", "msg", "body", "text"],
+  service: ["service", "svc", "app", "component", "logger"],
+  trace_id: ["trace_id", "traceId", "request_id", "correlation_id"]
+};
+const REVERSE_FIELD_MAP = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const [canonical, aliases] of Object.entries(FIELD_MAPPINGS)) {
+    for (const alias of aliases) {
+      map.set(alias, canonical);
+    }
+  }
+  return map;
+})();
+function resolveField(fieldName) {
+  return REVERSE_FIELD_MAP.get(fieldName) ?? null;
+}
+class Ingester {
+  db;
+  options;
+  emitter = new EventEmitter();
+  nextId = 1n;
+  buffer = [];
+  flushTimer = null;
+  rl = null;
+  stopped = false;
+  flushing = null;
+  constructor(db, options) {
+    this.db = db;
+    this.options = options;
+  }
+  // -------------------------------------------------------------------------
+  // Public API: IngesterService interface
+  // -------------------------------------------------------------------------
+  /**
+   * Start the periodic flush timer without binding to a readable stream.
+   * Use this when ingesting logs via `ingestLines()` (e.g. HTTP endpoint).
+   */
+  startTimer() {
+    this.stopped = false;
+    this.resetFlushTimer();
+  }
+  /**
+   * Feed JSON lines directly (without a stream).
+   * Each string is processed through the same normalization pipeline as stdin.
+   */
+  ingestLines(lines) {
+    for (const line of lines) {
+      this.handleLine(line);
+    }
+    if (this.flushTimer === null && !this.stopped) {
+      this.resetFlushTimer();
+    }
+  }
+  start(input) {
+    this.startTimer();
+    this.rl = createInterface({
+      input,
+      crlfDelay: Infinity
+    });
+    this.rl.on("line", (line) => {
+      this.handleLine(line);
+    });
+    this.rl.on("close", () => {
+      this.flushBuffer();
+    });
+  }
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+    if (this.flushing) {
+      await this.flushing;
+    }
+    await this.flushBuffer();
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+  }
+  // -------------------------------------------------------------------------
+  // Line processing
+  // -------------------------------------------------------------------------
+  handleLine(line) {
+    const trimmed = line.trim();
+    if (trimmed === "") return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return;
+    }
+    const normalized = this.normalize(parsed, trimmed);
+    this.buffer.push(normalized);
+    if (this.buffer.length >= this.options.batchSize) {
+      this.flushBuffer();
+    } else if (this.flushTimer === null && !this.stopped) {
+      this.resetFlushTimer();
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Normalization
+  // -------------------------------------------------------------------------
+  normalize(obj, raw) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const canonical = resolveField(key);
+      if (canonical !== null && !(canonical in resolved)) {
+        resolved[canonical] = value;
+      }
+    }
+    let timestamp = null;
+    if (resolved.timestamp !== void 0 && resolved.timestamp !== null) {
+      const d = new Date(resolved.timestamp);
+      if (!isNaN(d.getTime())) {
+        timestamp = d;
+      }
+    }
+    let duration_ms = null;
+    if (obj.duration_ms !== void 0 && obj.duration_ms !== null) {
+      const n = Number(obj.duration_ms);
+      if (!isNaN(n)) {
+        duration_ms = n;
+      }
+    }
+    const source = typeof obj.source === "string" && obj.source !== "" ? obj.source : this.options.defaultSource;
+    const host = typeof obj.host === "string" && obj.host !== "" ? obj.host : null;
+    const id = this.nextId++;
+    return {
+      _id: id,
+      _ingested: /* @__PURE__ */ new Date(),
+      _raw: raw,
+      timestamp,
+      level: typeof resolved.level === "string" ? resolved.level : null,
+      message: typeof resolved.message === "string" ? resolved.message : null,
+      service: typeof resolved.service === "string" ? resolved.service : null,
+      trace_id: typeof resolved.trace_id === "string" ? resolved.trace_id : null,
+      host,
+      duration_ms,
+      source
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Buffer flush
+  // -------------------------------------------------------------------------
+  flushBuffer() {
+    if (this.buffer.length === 0) return;
+    const batch = this.buffer.slice();
+    this.buffer = [];
+    this.resetFlushTimer();
+    const prev = this.flushing ?? Promise.resolve();
+    this.flushing = prev.then(() => this.doFlush(batch));
+  }
+  async doFlush(batch) {
+    try {
+      await this.db.insertBatch(batch);
+      await this.db.evictOldRows(this.options.maxRows);
+      this.emitter.emit("batch", batch);
+    } catch (err) {
+      console.error("[ingester] doFlush error:", err);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Flush timer management
+  // -------------------------------------------------------------------------
+  resetFlushTimer() {
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+    }
+    if (!this.stopped) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+        this.flushBuffer();
+      }, this.options.flushIntervalMs);
+    }
+  }
+}
+function matchesFilter(log, filter) {
+  if (filter.level !== void 0 && log.level !== filter.level) {
+    return false;
+  }
+  if (filter.service !== void 0 && log.service !== filter.service) {
+    return false;
+  }
+  if (filter.source !== void 0 && log.source !== filter.source) {
+    return false;
+  }
+  if (filter.search !== void 0 && filter.search !== "") {
+    const needle = filter.search.toLowerCase();
+    if (!log.message?.toLowerCase().includes(needle)) {
+      return false;
+    }
+  }
+  return true;
+}
+function serializeLog(log) {
+  let rawParsed;
+  try {
+    rawParsed = JSON.parse(log._raw);
+  } catch {
+    rawParsed = {};
+  }
+  return {
+    _id: String(log._id),
+    _ingested: log._ingested.toISOString(),
+    _raw: rawParsed,
+    timestamp: log.timestamp?.toISOString() ?? null,
+    level: log.level,
+    message: log.message,
+    service: log.service,
+    trace_id: log.trace_id,
+    host: log.host,
+    duration_ms: log.duration_ms,
+    source: log.source
+  };
+}
+function serializeStats(stats) {
+  return {
+    total: stats.total,
+    byLevel: stats.byLevel,
+    errorRate: stats.errorRate,
+    timeRange: {
+      min: stats.timeRange.min?.toISOString() ?? null,
+      max: stats.timeRange.max?.toISOString() ?? null
+    }
+  };
+}
+class WSHandler {
+  clients = /* @__PURE__ */ new Map();
+  db = null;
+  /** Number of currently connected clients */
+  get clientCount() {
+    return this.clients.size;
+  }
+  /**
+   * Set the LogDatabase reference for stats retrieval during broadcast.
+   */
+  setDatabase(db) {
+    this.db = db;
+  }
+  /**
+   * Subscribe to an Ingester's "batch" event.
+   * When a batch is ingested, broadcasts matching logs to clients.
+   */
+  subscribe(ingester) {
+    ingester.on("batch", async (logs) => {
+      let stats = null;
+      if (this.db) {
+        try {
+          stats = await this.db.getStats();
+        } catch {
+        }
+      }
+      if (stats) {
+        this.broadcast([...logs], stats);
+      }
+    });
+  }
+  /**
+   * Handle a new WebSocket connection.
+   * Registers the client with an empty (match-all) filter.
+   */
+  handleConnection(ws) {
+    this.clients.set(ws, {});
+  }
+  /**
+   * Handle a message from a WebSocket client.
+   * Expects JSON messages of type WSClientMessage.
+   * Invalid messages are silently ignored.
+   */
+  handleMessage(ws, message) {
+    if (!this.clients.has(ws)) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(message);
+    } catch {
+      return;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return;
+    }
+    const msg = parsed;
+    if (msg.type !== "filter") {
+      return;
+    }
+    if (typeof msg.filter !== "object" || msg.filter === null || Array.isArray(msg.filter)) {
+      return;
+    }
+    const filterObj = msg.filter;
+    const filter = {};
+    if (typeof filterObj.level === "string") {
+      filter.level = filterObj.level;
+    }
+    if (typeof filterObj.service === "string") {
+      filter.service = filterObj.service;
+    }
+    if (typeof filterObj.source === "string") {
+      filter.source = filterObj.source;
+    }
+    if (typeof filterObj.search === "string") {
+      filter.search = filterObj.search;
+    }
+    this.clients.set(ws, filter);
+  }
+  /**
+   * Handle WebSocket connection close.
+   * Removes the client from the registry.
+   */
+  handleClose(ws) {
+    this.clients.delete(ws);
+  }
+  /**
+   * Get the current filter for a client.
+   * Returns undefined if the client is not registered.
+   */
+  getClientFilter(ws) {
+    return this.clients.get(ws);
+  }
+  /**
+   * Broadcast new logs and stats to all connected clients.
+   * Logs are filtered per-client based on their active filter.
+   * Stats are always sent to all clients.
+   * If no logs match a client's filter, only stats are sent.
+   */
+  broadcast(logs, stats) {
+    const serializedStats = JSON.stringify({
+      type: "stats",
+      data: serializeStats(stats)
+    });
+    for (const [ws, filter] of this.clients) {
+      if (ws.readyState !== 1) continue;
+      const matched = logs.filter((log) => matchesFilter(log, filter));
+      if (matched.length > 0) {
+        const logsMessage = JSON.stringify({
+          type: "logs",
+          data: matched.map(serializeLog)
+        });
+        ws.send(logsMessage);
+      }
+      ws.send(serializedStats);
+    }
+  }
+}
+function parseCLIArgs(args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      port: { type: "string", short: "p" },
+      "max-rows": { type: "string", short: "m" },
+      "batch-size": { type: "string" },
+      db: { type: "string" },
+      "no-ui": { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    },
+    strict: true
+  });
+  const result = {
+    port: values.port !== void 0 ? parseInt(values.port, 10) : 8080,
+    maxRows: values["max-rows"] !== void 0 ? parseInt(values["max-rows"], 10) : 1e5,
+    batchSize: values["batch-size"] !== void 0 ? parseInt(values["batch-size"], 10) : 5e3,
+    db: values.db ?? ":memory:",
+    noUi: values["no-ui"] ?? false
+  };
+  if (values.help) {
+    result.help = true;
+  }
+  return result;
+}
+const USAGE = `
+Usage: <command> | lduck [options]
+Options:
+  -p, --port <port>       Server port (default: 8080)
+  -m, --max-rows <n>      Maximum rows to keep (default: 100000)
+      --batch-size <n>    Batch INSERT size (default: 5000)
+      --db <path>         DuckDB persistence path (default: :memory:)
+      --no-ui             Disable Web UI, API server only
+  -h, --help              Show this help message
+Examples:
+  kubectl logs -f deploy/api | lduck --port 8080
+  cat app.log | lduck --db ./logs.duckdb
+  docker logs -f myapp | lduck --no-ui -p 9090
+`.trimStart();
+async function main() {
+  const opts = parseCLIArgs(process.argv.slice(2));
+  if (opts.help) {
+    process.stdout.write(USAGE);
+    process.exit(0);
+  }
+  const db = new LogDatabase();
+  await db.initialize(opts.db);
+  const ingester = new Ingester(db, {
+    batchSize: opts.batchSize,
+    flushIntervalMs: 500,
+    maxRows: opts.maxRows,
+    defaultSource: "default"
+  });
+  const wsHandler = new WSHandler();
+  wsHandler.setDatabase(db);
+  wsHandler.subscribe(ingester);
+  const apiApp = createApiApp(db, ingester);
+  const wsInit = { app: null };
+  const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket(wsInit);
+  const fullApp = createApp("/static/client.js", (app) => {
+    app.route("/", apiApp);
+    app.get(
+      "/api/ws/tail",
+      upgradeWebSocket(() => ({
+        onOpen(_evt, ws) {
+          wsHandler.handleConnection(ws);
+        },
+        onMessage(evt, ws) {
+          wsHandler.handleMessage(ws, evt.data.toString());
+        },
+        onClose(_evt, ws) {
+          wsHandler.handleClose(ws);
+        }
+      }))
+    );
+    if (!opts.noUi) {
+      app.use("/static/*", serveStatic({ root: import.meta.dirname }));
+    }
+  });
+  wsInit.app = fullApp;
+  const server = serve(
+    { fetch: fullApp.fetch, port: opts.port, hostname: "127.0.0.1" },
+    (info) => {
+      console.log(`lduck server listening on http://localhost:${info.port}`);
+    }
+  );
+  injectWebSocket(server);
+  ingester.start(process.stdin);
+}
+if (!process.env.VITEST) {
+  main().catch((err) => {
+    console.error("Failed to start lduck:", err);
+    process.exit(1);
+  });
+}
+export {
+  parseCLIArgs
+};