tinylogs 0.1.0 → 0.3.0

package/README.md

@@ -19,6 +19,24 @@ Non-interactive init (CI/containers):
 TINYLOGS_PASSWORD=hunter2 npx tinylogs init --yes --port 4700
 ```
 
+## Install & run as a service
+
+Install globally so `tinylogs` is on your PATH (recommended for a long-running server):
+
+```bash
+npm i -g tinylogs        # puts `tinylogs` on PATH
+tinylogs init            # create tinylogs.config.json + tinylogs.db in the current dir
+tinylogs start -d        # run in the background (writes tinylogs.pid + tinylogs.log)
+tinylogs status          # running? pid, url, uptime, version
+tinylogs stop            # stop it
+tinylogs restart         # stop + start -d
+tinylogs update          # update to the latest published version
+```
+
+`npx tinylogs …` still works for one-off use. `start -d`, `status`, and `stop` are supported on
+Linux/macOS; on Windows run the foreground `tinylogs start` under a service manager (NSSM / Task
+Scheduler). The PID and log files live next to your config file.
+
 ## Sending logs
 
 Anything that can make an HTTP request can send logs. `service` and `message` are
@@ -37,8 +55,10 @@ missing, 401 if the token is wrong).
 
 ### Node client
 
+Install the standalone, zero-dependency client package [`@tinylogs/client`](packages/client) (`npm install @tinylogs/client`):
+
 ```ts
-import { TinyLogsClient } from 'tinylogs/client';
+import { TinyLogsClient } from '@tinylogs/client';
 
 const logs = new TinyLogsClient({
   url: 'http://localhost:4700',

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { createInterface } from "node:readline/promises";
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 
 // src/config.ts
 import { createHash, randomBytes } from "node:crypto";
@@ -46,7 +46,7 @@ function resolveDbPath(configPath, cfg) {
 }
 
 // src/storage/db.ts
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
 var MIGRATIONS = [
   `CREATE TABLE logs (
      id      INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -72,34 +72,43 @@ var MIGRATIONS = [
      created_at    INTEGER NOT NULL
    );`
 ];
+function tx(db, fn) {
+  db.exec("BEGIN");
+  try {
+    const result = fn();
+    db.exec("COMMIT");
+    return result;
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
 function openDb(path) {
-  const db = new Database(path);
-  db.pragma("journal_mode = WAL");
-  db.pragma("foreign_keys = ON");
+  const db = new DatabaseSync(path);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
   db.exec("CREATE TABLE IF NOT EXISTS schema_migrations (version INTEGER PRIMARY KEY)");
   const current = db.prepare("SELECT COALESCE(MAX(version),0) v FROM schema_migrations").get().v;
-  const apply = db.transaction((from) => {
-    for (let i = from; i < MIGRATIONS.length; i++) {
+  tx(db, () => {
+    for (let i = current; i < MIGRATIONS.length; i++) {
       db.exec(MIGRATIONS[i]);
       db.prepare("INSERT INTO schema_migrations (version) VALUES (?)").run(i + 1);
     }
   });
-  apply(current);
   return db;
 }
 function insertLog(db, rec) {
-  const txn = db.transaction((r) => {
-    const info = db.prepare("INSERT INTO logs (ts, service, message, labels) VALUES (?,?,?,?)").run(r.ts, r.service, r.message, JSON.stringify(r.labels ?? {}));
+  return tx(db, () => {
+    const info = db.prepare("INSERT INTO logs (ts, service, message, labels) VALUES (?,?,?,?)").run(rec.ts, rec.service, rec.message, JSON.stringify(rec.labels ?? {}));
     const logId = Number(info.lastInsertRowid);
     const ins = db.prepare("INSERT INTO log_labels (log_id, key, value) VALUES (?,?,?)");
-    for (const [k, v] of Object.entries(r.labels ?? {})) ins.run(logId, k, String(v));
+    for (const [k, v] of Object.entries(rec.labels ?? {})) ins.run(logId, k, String(v));
     return logId;
   });
-  return txn(rec);
 }
 function dbSizeBytes(db) {
-  const pageCount = db.pragma("page_count", { simple: true });
-  const pageSize = db.pragma("page_size", { simple: true });
+  const pageCount = Number(db.prepare("PRAGMA page_count").get().page_count);
+  const pageSize = Number(db.prepare("PRAGMA page_size").get().page_size);
   return pageCount * pageSize;
 }
 
@@ -150,6 +159,21 @@ function verifySession(cookieVal, secret) {
   return username;
 }
 
+// src/style.ts
+function computeSupportsColor() {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return true;
+  return Boolean(process.stdout.isTTY);
+}
+var useColor = computeSupportsColor();
+var wrap = (open, close) => (s) => useColor ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+var bold = wrap(1, 22);
+var dim = wrap(2, 22);
+var red = wrap(31, 39);
+var green = wrap(32, 39);
+var yellow = wrap(33, 39);
+var cyan = wrap(36, 39);
+
 // src/wizard.ts
 function buildInitConfig(opts) {
   const s = generateSecrets();
@@ -166,13 +190,13 @@ function buildInitConfig(opts) {
   return { config, token: s.token };
 }
 async function runInit(configPath, opts, io) {
-  const port = opts.port ?? (Number(await io.prompt(`Port [${DEFAULTS.port}]: `)) || DEFAULTS.port);
-  const host = opts.host ?? (await io.prompt(`Host [${DEFAULTS.host}]: `) || DEFAULTS.host);
-  const username = opts.username ?? (await io.prompt("Admin username [admin]: ") || "admin");
+  const port = opts.port ?? (Number(await io.prompt(`Port ${dim(`[${DEFAULTS.port}]`)}: `)) || DEFAULTS.port);
+  const host = opts.host ?? (await io.prompt(`Host ${dim(`[${DEFAULTS.host}]`)}: `) || DEFAULTS.host);
+  const username = opts.username ?? (await io.prompt(`Admin username ${dim("[admin]")}: `) || "admin");
   const password = opts.password ?? await io.promptHidden("Admin password: ");
   if (!password || password.length === 0) throw new Error("password must not be empty");
-  const retentionDays = opts.retentionDays ?? (Number(await io.prompt(`Retention days [${DEFAULTS.retentionDays}]: `)) || DEFAULTS.retentionDays);
-  const maxSizeMB = opts.maxSizeMB ?? (Number(await io.prompt(`Max DB size MB [${DEFAULTS.maxSizeMB}]: `)) || DEFAULTS.maxSizeMB);
+  const retentionDays = opts.retentionDays ?? (Number(await io.prompt(`Retention days ${dim(`[${DEFAULTS.retentionDays}]`)}: `)) || DEFAULTS.retentionDays);
+  const maxSizeMB = opts.maxSizeMB ?? (Number(await io.prompt(`Max DB size MB ${dim(`[${DEFAULTS.maxSizeMB}]`)}: `)) || DEFAULTS.maxSizeMB);
   const dbPath = opts.dbPath ?? DEFAULTS.dbPath;
   const { config, token } = buildInitConfig({ port, host, retentionDays, maxSizeMB, dbPath });
   const db = openDb(resolveDbPath(configPath, config));
@@ -180,11 +204,13 @@ async function runInit(configPath, opts, io) {
   db.close();
   saveConfig(configPath, config);
   io.log("");
-  io.log(`  tinylogs configured \u2192 ${configPath}`);
-  io.log(`  Ingest token (shown once, store it now):`);
-  io.log(`    ${token}`);
+  io.log(`  ${green("\u2713")} tinylogs configured \u2192 ${dim(configPath)}`);
+  io.log("");
+  io.log(`  ${yellow("\u26A0")} Ingest token \u2014 shown once, store it now:`);
+  io.log("");
+  io.log(`      ${bold(cyan(token))}`);
   io.log("");
-  io.log(`  Start with: npx tinylogs start`);
+  io.log(`  ${dim("Start with:")} ${bold("tinylogs start -d")}`);
 }
 
 // src/server/index.ts
@@ -193,15 +219,15 @@ import { createServer } from "node:http";
 // src/storage/retention.ts
 function pruneByAge(db, retentionDays, now) {
   const cutoff = now - retentionDays * 864e5;
-  return db.prepare("DELETE FROM logs WHERE ts < ?").run(cutoff).changes;
+  return Number(db.prepare("DELETE FROM logs WHERE ts < ?").run(cutoff).changes);
 }
 function pruneBySize(db, maxSizeMB, batch = 1e3) {
   const maxBytes = maxSizeMB * 1024 * 1024;
   let deleted = 0;
   while (dbSizeBytes(db) > maxBytes) {
-    const changes = db.prepare(
+    const changes = Number(db.prepare(
       "DELETE FROM logs WHERE id IN (SELECT id FROM logs ORDER BY id ASC LIMIT ?)"
-    ).run(batch).changes;
+    ).run(batch).changes);
     if (changes === 0) break;
     deleted += changes;
   }
@@ -339,23 +365,21 @@ function queryLogs(db, params) {
                ORDER BY logs.id DESC LIMIT ?`;
   return db.prepare(sql).all(...args, limit).map(rowToRecord);
 }
+function rowToLabel(row) {
+  return { key: row.key, value: row.value, count: Number(row.count) };
+}
 function queryLabels(db, opts = {}) {
   const services = db.prepare(
     "SELECT service, COUNT(*) count FROM logs GROUP BY service ORDER BY count DESC"
-  ).all();
-  let labels;
-  if (opts.service) {
-    labels = db.prepare(
-      `SELECT ll.key, ll.value, COUNT(*) count FROM log_labels ll
-       JOIN logs ON logs.id = ll.log_id WHERE logs.service = ?
-       GROUP BY ll.key, ll.value ORDER BY ll.key, count DESC`
-    ).all(opts.service);
-  } else {
-    labels = db.prepare(
-      `SELECT key, value, COUNT(*) count FROM log_labels
-       GROUP BY key, value ORDER BY key, count DESC`
-    ).all();
-  }
+  ).all().map((row) => ({ service: row.service, count: Number(row.count) }));
+  const labels = opts.service ? db.prepare(
+    `SELECT ll.key, ll.value, COUNT(*) count FROM log_labels ll
+         JOIN logs ON logs.id = ll.log_id WHERE logs.service = ?
+         GROUP BY ll.key, ll.value ORDER BY ll.key, count DESC`
+  ).all(opts.service).map(rowToLabel) : db.prepare(
+    `SELECT key, value, COUNT(*) count FROM log_labels
+         GROUP BY key, value ORDER BY key, count DESC`
+  ).all().map(rowToLabel);
   return { services, labels };
 }
 
@@ -519,13 +543,13 @@ async function start(configPath = resolveConfigPath()) {
     6e4
   );
   retentionTimer.unref();
-  await new Promise((resolve2) => server.listen(cfg.port, cfg.host, resolve2));
+  await new Promise((resolve3) => server.listen(cfg.port, cfg.host, resolve3));
   const addr = server.address();
   const port = typeof addr === "object" && addr ? addr.port : cfg.port;
   console.log(`[tinylogs] listening on http://${cfg.host}:${port}`);
   return {
     port,
-    close: () => new Promise((resolve2) => {
+    close: () => new Promise((resolve3) => {
       clearInterval(retentionTimer);
       for (const c of wsClients) {
         try {
@@ -535,12 +559,188 @@ async function start(configPath = resolveConfigPath()) {
       }
       server.close(() => {
         db.close();
-        resolve2();
+        resolve3();
       });
+      server.closeIdleConnections?.();
     })
   };
 }
 
+// src/daemon.ts
+import { spawn } from "node:child_process";
+import {
+  openSync,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync2,
+  unlinkSync,
+  statSync
+} from "node:fs";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function pidPath(configPath) {
+  return join3(dirname3(resolve2(configPath)), "tinylogs.pid");
+}
+function logPath(configPath) {
+  return join3(dirname3(resolve2(configPath)), "tinylogs.log");
+}
+function readPid(configPath) {
+  const p = pidPath(configPath);
+  if (!existsSync2(p)) return null;
+  const n = Number(readFileSync2(p, "utf8").trim());
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function statusInfo(configPath) {
+  const cfg = loadConfig(configPath);
+  const pid = readPid(configPath);
+  if (pid && isAlive(pid)) {
+    let uptimeMs = null;
+    try {
+      uptimeMs = Date.now() - statSync(pidPath(configPath)).mtimeMs;
+    } catch {
+    }
+    return { running: true, stale: false, pid, port: cfg.port, host: cfg.host, uptimeMs };
+  }
+  if (pid) {
+    try {
+      unlinkSync(pidPath(configPath));
+    } catch {
+    }
+  }
+  return {
+    running: false,
+    stale: pid !== null,
+    pid: null,
+    port: cfg.port,
+    host: cfg.host,
+    uptimeMs: null
+  };
+}
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+async function spawnDaemon(configPath) {
+  const existing = readPid(configPath);
+  if (existing && isAlive(existing)) {
+    throw new Error(`already running (pid ${existing})`);
+  }
+  if (existing) {
+    try {
+      unlinkSync(pidPath(configPath));
+    } catch {
+    }
+  }
+  const cfg = loadConfig(configPath);
+  const logFile = logPath(configPath);
+  const fd = openSync(logFile, "a");
+  const cliEntry = fileURLToPath2(import.meta.url);
+  const child = spawn(
+    process.execPath,
+    [cliEntry, "start", "--config", resolve2(configPath)],
+    { detached: true, stdio: ["ignore", fd, fd] }
+  );
+  child.unref();
+  const pid = child.pid;
+  if (!pid) throw new Error("failed to spawn daemon process");
+  writeFileSync2(pidPath(configPath), String(pid) + "\n");
+  await delay(400);
+  if (!isAlive(pid)) {
+    let tail = "";
+    try {
+      tail = readFileSync2(logFile, "utf8").split("\n").slice(-8).join("\n");
+    } catch {
+    }
+    try {
+      unlinkSync(pidPath(configPath));
+    } catch {
+    }
+    throw new Error(`daemon exited immediately. Recent log:
+${tail}`);
+  }
+  return { pid, port: cfg.port, logFile };
+}
+async function stopDaemon(configPath) {
+  const pid = readPid(configPath);
+  if (!pid || !isAlive(pid)) {
+    if (pid) {
+      try {
+        unlinkSync(pidPath(configPath));
+      } catch {
+      }
+    }
+    return "not-running";
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  for (let i = 0; i < 50; i++) {
+    if (!isAlive(pid)) {
+      try {
+        unlinkSync(pidPath(configPath));
+      } catch {
+      }
+      return "stopped";
+    }
+    await delay(100);
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+  try {
+    unlinkSync(pidPath(configPath));
+  } catch {
+  }
+  return "killed";
+}
+
+// src/update.ts
+import { spawnSync } from "node:child_process";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname4, join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function pkgRoot() {
+  return dirname4(dirname4(fileURLToPath3(import.meta.url)));
+}
+function currentVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync3(join4(pkgRoot(), "package.json"), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function fetchLatest(timeoutMs = 2500) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch("https://registry.npmjs.org/tinylogs", { signal: ctrl.signal });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data["dist-tags"]?.latest ?? null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+function detectInstall() {
+  const root = pkgRoot();
+  if (existsSync3(join4(root, ".git")) && existsSync3(join4(root, "src"))) return "source";
+  return "global";
+}
+function runNpmUpdate() {
+  const r = spawnSync("npm", ["i", "-g", "tinylogs@latest"], { stdio: "inherit" });
+  return r.status ?? 1;
+}
+
 // src/cli.ts
 function parseFlags(argv) {
   const out = {};
@@ -569,6 +769,17 @@ function makeIo() {
     done: () => rl.close()
   };
 }
+function formatUptime(ms) {
+  if (ms == null) return "\u2014";
+  const s = Math.floor(ms / 1e3);
+  const d = Math.floor(s / 86400);
+  const h = Math.floor(s % 86400 / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  if (d) return `${d}d ${h}h`;
+  if (h) return `${h}h ${m}m`;
+  if (m) return `${m}m`;
+  return `${s}s`;
+}
 async function main() {
   const [cmd, ...rest] = process.argv.slice(2);
   const flags = parseFlags(rest);
@@ -584,7 +795,7 @@ async function main() {
       maxSizeMB: flags["max-size-mb"] ? Number(flags["max-size-mb"]) : void 0,
       dbPath: typeof flags["db-path"] === "string" ? flags["db-path"] : void 0
     };
-    if (existsSync2(configPath) && !flags.force) {
+    if (existsSync4(configPath) && !flags.force) {
       console.error(`Config already exists at ${configPath} (use --force to overwrite).`);
       process.exit(1);
     }
@@ -605,15 +816,127 @@ async function main() {
     return;
   }
   if (cmd === "start") {
-    if (!existsSync2(configPath)) {
-      console.error(`No config at ${configPath}. Run: npx tinylogs init`);
+    if (!existsSync4(configPath)) {
+      console.error(`No config at ${configPath}. Run: tinylogs init`);
       process.exit(1);
     }
-    await start(configPath);
+    const daemon = flags.daemon === true || rest.includes("-d");
+    if (daemon) {
+      try {
+        const { pid, port, logFile } = await spawnDaemon(configPath);
+        console.log(`${green("\u2713")} tinylogs started in background`);
+        console.log(`  ${dim("pid")}   ${pid}`);
+        console.log(`  ${dim("url")}   http://127.0.0.1:${port}`);
+        console.log(`  ${dim("logs")}  ${logFile}`);
+        console.log(`  ${dim("stop")}  tinylogs stop`);
+      } catch (e) {
+        console.error(`${red("\u2717")} ${e.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+    const srv = await start(configPath);
+    const shutdown = async () => {
+      try {
+        await srv.close();
+      } finally {
+        process.exit(0);
+      }
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    return;
+  }
+  if (cmd === "status") {
+    if (!existsSync4(configPath)) {
+      console.error(`No config at ${configPath}. Run: tinylogs init`);
+      process.exit(1);
+    }
+    const s = statusInfo(configPath);
+    if (s.running) {
+      console.log(`${green("\u25CF")} running`);
+      console.log(`  ${dim("pid")}     ${s.pid}`);
+      const shownHost = s.host === "0.0.0.0" || s.host === "::" ? "127.0.0.1" : s.host;
+      console.log(`  ${dim("url")}     http://${shownHost}:${s.port}`);
+      console.log(`  ${dim("uptime")}  ${formatUptime(s.uptimeMs)}`);
+    } else {
+      console.log(`${dim("\u25CB")} stopped${s.stale ? " " + yellow("(cleaned stale pidfile)") : ""}`);
+    }
+    console.log(`  ${dim("version")} ${currentVersion()}`);
+    const latest = await fetchLatest();
+    if (latest && latest !== currentVersion()) {
+      console.log(`  ${yellow("\u26A0")} update available: ${latest} \u2014 run: tinylogs update`);
+    }
+    return;
+  }
+  if (cmd === "stop") {
+    if (!existsSync4(configPath)) {
+      console.error(`No config at ${configPath}.`);
+      process.exit(1);
+    }
+    const r = await stopDaemon(configPath);
+    if (r === "not-running") console.log(`${dim("\u25CB")} not running`);
+    else if (r === "stopped") console.log(`${green("\u2713")} stopped`);
+    else console.log(`${yellow("\u26A0")} force-killed (did not stop gracefully within 5s)`);
+    return;
+  }
+  if (cmd === "restart") {
+    if (!existsSync4(configPath)) {
+      console.error(`No config at ${configPath}. Run: tinylogs init`);
+      process.exit(1);
+    }
+    await stopDaemon(configPath);
+    try {
+      const { pid, port, logFile } = await spawnDaemon(configPath);
+      console.log(`${green("\u2713")} tinylogs restarted`);
+      console.log(`  ${dim("pid")}   ${pid}`);
+      console.log(`  ${dim("url")}   http://127.0.0.1:${port}`);
+      console.log(`  ${dim("logs")}  ${logFile}`);
+    } catch (e) {
+      console.error(`${red("\u2717")} ${e.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+  if (cmd === "version" || cmd === "--version" || cmd === "-v") {
+    console.log(`tinylogs ${currentVersion()}`);
+    const latest = await fetchLatest();
+    if (latest && latest !== currentVersion()) {
+      console.log(`${yellow("\u26A0")} update available: ${latest} \u2014 run: tinylogs update`);
+    } else if (latest) {
+      console.log(dim("up to date"));
+    }
+    return;
+  }
+  if (cmd === "update") {
+    const cur = currentVersion();
+    const latest = await fetchLatest();
+    console.log(`  ${dim("current")} ${cur}`);
+    if (latest) console.log(`  ${dim("latest")}  ${latest}`);
+    if (latest && latest === cur) {
+      console.log(`${green("\u2713")} already up to date`);
+      return;
+    }
+    if (detectInstall() === "source") {
+      console.log(`${yellow("\u26A0")} running from a source checkout \u2014 update with:`);
+      console.log(`  git pull && npm install && npm run build`);
+      return;
+    }
+    console.log(dim("\u2192 npm i -g tinylogs@latest"));
+    const code = runNpmUpdate();
+    if (code !== 0) {
+      console.error(`${red("\u2717")} npm update failed`);
+      process.exit(code);
+    }
+    console.log(`${green("\u2713")} updated to ${latest ?? "latest"}`);
+    if (existsSync4(configPath)) {
+      const s = statusInfo(configPath);
+      if (s.running) console.log(`${yellow("\u26A0")} daemon is running \u2014 run: tinylogs restart`);
+    }
     return;
   }
   if (cmd === "rotate-token") {
-    if (!existsSync2(configPath)) {
+    if (!existsSync4(configPath)) {
       console.error(`No config at ${configPath}.`);
       process.exit(1);
     }
@@ -625,7 +948,19 @@ async function main() {
     console.log(`  ${s.token}`);
     return;
   }
-  console.log("tinylogs \u2014 usage:\n  tinylogs init [--yes --password ...]\n  tinylogs start\n  tinylogs rotate-token");
+  console.log(
+    [
+      "tinylogs \u2014 usage:",
+      "  tinylogs init [--yes --password ...]",
+      "  tinylogs start [-d|--daemon]   start (foreground, or background with -d)",
+      "  tinylogs status                is it running? pid, url, uptime, version",
+      "  tinylogs stop                  stop the background server",
+      "  tinylogs restart               stop + start -d",
+      "  tinylogs update                update to the latest published version",
+      "  tinylogs version               show version (and check for updates)",
+      "  tinylogs rotate-token          issue a new ingest token"
+    ].join("\n")
+  );
   if (cmd && cmd !== "help") process.exit(1);
 }
 main().catch((err) => {