lduck 0.0.1 → 0.0.2

package/dist/index.js

@@ -1029,6 +1029,134 @@ class WSHandler {
     }
   }
 }
+function parseRelayArgs(args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      url: { type: "string", short: "u" },
+      service: { type: "string", short: "s" },
+      "batch-size": { type: "string" },
+      interval: { type: "string" },
+      help: { type: "boolean", short: "h" }
+    },
+    strict: true
+  });
+  return {
+    url: values.url ?? "http://localhost:8080",
+    service: values.service,
+    batchSize: values["batch-size"] !== void 0 ? parseInt(values["batch-size"], 10) : 100,
+    intervalMs: values.interval !== void 0 ? parseInt(values.interval, 10) : 500,
+    help: values.help ?? false
+  };
+}
+const RELAY_USAGE = `
+Usage: <command> | lduck relay [options]
+
+Relay stdin JSON logs to a running lduck server via HTTP POST.
+
+Options:
+  -u, --url <url>         Target lduck server URL (default: http://localhost:8080)
+  -s, --service <name>    Service name to inject into each log entry
+      --batch-size <n>    Lines per HTTP batch (default: 100)
+      --interval <ms>     Flush interval in milliseconds (default: 500)
+  -h, --help              Show this help message
+
+Examples:
+  kubectl logs -f deploy/api | lduck relay --service api
+  cat app.log | lduck relay --url http://lduck:9090 --service backend
+  docker logs -f myapp | lduck relay -s myapp -u http://localhost:8080
+`.trimStart();
+async function runRelay(args) {
+  const opts = parseRelayArgs(args);
+  if (opts.help) {
+    process.stdout.write(RELAY_USAGE);
+    process.exit(0);
+  }
+  const ingestUrl = opts.url.replace(/\/$/, "") + "/api/ingest";
+  let buffer = [];
+  let flushTimer = null;
+  let totalSent = 0;
+  let totalErrors = 0;
+  let stdinClosed = false;
+  async function flush() {
+    if (buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    try {
+      const res = await fetch(ingestUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(batch)
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        console.error(`[relay] HTTP ${res.status}: ${text}`);
+        totalErrors += batch.length;
+      } else {
+        const result = await res.json();
+        totalSent += result.accepted;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[relay] Send failed: ${message}`);
+      totalErrors += batch.length;
+    }
+  }
+  function resetFlushTimer() {
+    if (flushTimer !== null) {
+      clearTimeout(flushTimer);
+    }
+    flushTimer = setTimeout(async () => {
+      flushTimer = null;
+      await flush();
+      if (!stdinClosed) {
+        resetFlushTimer();
+      }
+    }, opts.intervalMs);
+  }
+  const rl = createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity
+  });
+  console.error(`[relay] Relaying to ${ingestUrl}${opts.service ? ` (service: ${opts.service})` : ""}`);
+  resetFlushTimer();
+  rl.on("line", (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;
+    }
+    if (opts.service !== void 0 && !("service" in parsed)) {
+      parsed.service = opts.service;
+    }
+    buffer.push(parsed);
+    if (buffer.length >= opts.batchSize) {
+      flush();
+    }
+  });
+  await new Promise((resolve) => {
+    rl.on("close", async () => {
+      stdinClosed = true;
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      await flush();
+      if (totalSent > 0 || totalErrors > 0) {
+        console.error(
+          `[relay] Done. Sent: ${totalSent}, Errors: ${totalErrors}`
+        );
+      }
+      resolve();
+    });
+  });
+}
 function parseCLIArgs(args) {
   const { values } = parseArgs({
     args,
@@ -1056,8 +1184,13 @@ function parseCLIArgs(args) {
 }
 const USAGE = `
 Usage: <command> | lduck [options]
+       <command> | lduck relay [options]
 
-Options:
+Commands:
+  (default)    Start the lduck server (Web UI + API)
+  relay        Relay stdin logs to a running lduck server via HTTP
+
+Server 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)
@@ -1069,6 +1202,8 @@ 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
+  kubectl logs -f deploy/api | lduck relay --service api
+  docker logs -f myapp | lduck relay -s myapp -u http://localhost:8080
 `.trimStart();
 async function main() {
   const opts = parseCLIArgs(process.argv.slice(2));
@@ -1121,10 +1256,18 @@ async function main() {
   ingester.start(process.stdin);
 }
 if (!process.env.VITEST) {
-  main().catch((err) => {
-    console.error("Failed to start lduck:", err);
-    process.exit(1);
-  });
+  const args = process.argv.slice(2);
+  if (args[0] === "relay") {
+    runRelay(args.slice(1)).catch((err) => {
+      console.error("Failed to run lduck relay:", err);
+      process.exit(1);
+    });
+  } else {
+    main().catch((err) => {
+      console.error("Failed to start lduck:", err);
+      process.exit(1);
+    });
+  }
 }
 export {
   parseCLIArgs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lduck",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Pipe-friendly JSON log viewer powered by DuckDB",
   "type": "module",
   "bin": {