mega-tail 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# mega-tail
+
+Tail dynamic logs in a directory tree.
+
+`mega-tail` follows appended lines across all matching log files under a root directory, and automatically starts following newly created log files as they appear.
+
+## Features
+
+- Recursive discovery under a root directory
+- Live follow of existing files
+- Auto-discovery of new files
+- Per-line prefix with source file path and detection timestamp
+- Handles truncation/rotation safely
+
+## Usage
+
+Run via `npx` (no prior install needed):
+
+```bash
+npx mega-tail /var/log/myapp
+```
+
+Run local Python script:
+
+```bash
+./mega-tail <directory>
+```
+
+Run local Node script:
+
+```bash
+node bin/mega-tail.js <directory>
+```
+
+Examples:
+
+```bash
+./mega-tail /var/log/myapp
+node bin/mega-tail.js /var/log/myapp
+npx mega-tail /var/log/myapp
+```
+
+Sample output:
+
+```text
+[subdir1/somelog.log] [2026-02-05 16:09:07.333] 2026-02-02: 12:23:23.123 [DEBUG] my log message....
+[subdir2/somelog2.log] [2026-02-05 16:09:07.337] 2026-02-02: 12:23:23.223 [DEBUG] my otherlog message....
+```
+
+## Options
+
+```bash
+npx mega-tail --help
+```
+
+Key options:
+
+- `--glob <pattern>`: Add include glob (repeatable)
+- `--poll-interval <seconds>`: Read loop interval
+- `--scan-interval <seconds>`: New-file scan interval
+- `-n, --initial-lines <N>`: Show last N lines on startup
+- `--color auto|always|never`: Color mode
+
+## Publishing to npm
+
+```bash
+npm login
+npm whoami
+npm version patch
+npm publish --access public
+```

package/bin/mega-tail.js

@@ -0,0 +1,508 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { performance } = require("node:perf_hooks");
+
+const DEFAULT_GLOBS = ["*.log", "*.log.*"];
+const DEFAULT_POLL_INTERVAL = 0.2;
+const DEFAULT_SCAN_INTERVAL = 1.0;
+
+const C_RESET = "\u001b[0m";
+const C_TIMESTAMP = "\u001b[38;5;81m";
+const C_FILE = "\u001b[38;5;245m";
+const C_CONTENT = "\u001b[38;5;252m";
+const C_INFO = "\u001b[38;5;244m";
+
+function usage() {
+  return [
+    "mega-tail - Tail dynamic log files in a directory tree.",
+    "",
+    "Usage:",
+    "  mega-tail <directory> [options]",
+    "",
+    "Options:",
+    "  --glob <pattern>           Add include glob (repeatable).",
+    `  --poll-interval <seconds>  Read loop interval (default: ${DEFAULT_POLL_INTERVAL}).`,
+    `  --scan-interval <seconds>  New-file scan interval (default: ${DEFAULT_SCAN_INTERVAL}).`,
+    "  -n, --initial-lines <N>    Show last N lines on startup (default: 0).",
+    "  --color auto|always|never  Color mode (default: auto).",
+    "  -h, --help                 Show help.",
+  ].join("\n");
+}
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exitCode = 1;
+}
+
+function parseArgs(argv) {
+  const args = {
+    directory: null,
+    globs: [],
+    pollInterval: DEFAULT_POLL_INTERVAL,
+    scanInterval: DEFAULT_SCAN_INTERVAL,
+    initialLines: 0,
+    color: "auto",
+    help: false,
+  };
+
+  for (let i = 2; i < argv.length; i += 1) {
+    const token = argv[i];
+
+    if (token === "-h" || token === "--help") {
+      args.help = true;
+      continue;
+    }
+
+    if (token === "--glob") {
+      const value = argv[i + 1];
+      if (!value) {
+        throw new Error("Error: --glob requires a value");
+      }
+      args.globs.push(value);
+      i += 1;
+      continue;
+    }
+
+    if (token === "--poll-interval") {
+      const value = Number(argv[i + 1]);
+      if (!Number.isFinite(value)) {
+        throw new Error("Error: --poll-interval requires a numeric value");
+      }
+      args.pollInterval = value;
+      i += 1;
+      continue;
+    }
+
+    if (token === "--scan-interval") {
+      const value = Number(argv[i + 1]);
+      if (!Number.isFinite(value)) {
+        throw new Error("Error: --scan-interval requires a numeric value");
+      }
+      args.scanInterval = value;
+      i += 1;
+      continue;
+    }
+
+    if (token === "-n" || token === "--initial-lines") {
+      const raw = argv[i + 1];
+      const value = Number(raw);
+      if (!Number.isInteger(value)) {
+        throw new Error("Error: --initial-lines requires an integer value");
+      }
+      args.initialLines = value;
+      i += 1;
+      continue;
+    }
+
+    if (token === "--color") {
+      const value = argv[i + 1];
+      if (!value) {
+        throw new Error("Error: --color requires a value");
+      }
+      args.color = value;
+      i += 1;
+      continue;
+    }
+
+    if (token.startsWith("-")) {
+      throw new Error(`Error: unknown option: ${token}`);
+    }
+
+    if (args.directory !== null) {
+      throw new Error("Error: only one directory argument is allowed");
+    }
+    args.directory = token;
+  }
+
+  if (!args.help && args.directory === null) {
+    throw new Error("Error: directory is required");
+  }
+
+  return args;
+}
+
+function colorEnabled(mode) {
+  if (mode === "always") {
+    return true;
+  }
+  if (mode === "never") {
+    return false;
+  }
+  return Boolean(process.stdout.isTTY) && process.env.TERM !== "dumb";
+}
+
+function paint(text, color, enabled) {
+  if (!enabled) {
+    return text;
+  }
+  return `${color}${text}${C_RESET}`;
+}
+
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+
+function pad3(value) {
+  return String(value).padStart(3, "0");
+}
+
+function detectionTimestamp() {
+  const now = new Date();
+  const yyyy = now.getFullYear();
+  const mm = pad2(now.getMonth() + 1);
+  const dd = pad2(now.getDate());
+  const hh = pad2(now.getHours());
+  const min = pad2(now.getMinutes());
+  const ss = pad2(now.getSeconds());
+  const ms = pad3(now.getMilliseconds());
+  return `${yyyy}-${mm}-${dd} ${hh}:${min}:${ss}.${ms}`;
+}
+
+function escapeRegexChar(ch) {
+  return /[\\^$.*+?()[\]{}|]/.test(ch) ? `\\${ch}` : ch;
+}
+
+function globToRegex(glob) {
+  let out = "^";
+  for (let i = 0; i < glob.length; i += 1) {
+    const ch = glob[i];
+    if (ch === "*") {
+      out += ".*";
+      continue;
+    }
+    if (ch === "?") {
+      out += ".";
+      continue;
+    }
+    if (ch === "[") {
+      let j = i + 1;
+      if (j < glob.length && glob[j] === "!") {
+        j += 1;
+      }
+      if (j < glob.length && glob[j] === "]") {
+        j += 1;
+      }
+      while (j < glob.length && glob[j] !== "]") {
+        j += 1;
+      }
+      if (j >= glob.length) {
+        out += "\\[";
+      } else {
+        let classContent = glob.slice(i + 1, j);
+        if (classContent.startsWith("!")) {
+          classContent = `^${classContent.slice(1)}`;
+        }
+        classContent = classContent.replace(/\\/g, "\\\\");
+        out += `[${classContent}]`;
+        i = j;
+      }
+      continue;
+    }
+    out += escapeRegexChar(ch);
+  }
+  out += "$";
+  return new RegExp(out);
+}
+
+function discoverLogFiles(root, globRegexes) {
+  const matches = new Set();
+  const stack = [root];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      const lower = entry.name.toLowerCase();
+      if (globRegexes.some((regex) => regex.test(lower))) {
+        matches.add(full);
+      }
+    }
+  }
+
+  return matches;
+}
+
+function readLastLines(filePath, count) {
+  if (count <= 0) {
+    return [];
+  }
+
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return [];
+  }
+
+  const lines = content.split(/\r\n|\n|\r/);
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines.slice(-count);
+}
+
+function relativeDisplay(root, filePath) {
+  const rel = path.relative(root, filePath);
+  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+    return filePath;
+  }
+  return rel.split(path.sep).join("/");
+}
+
+function formatOutput(relPath, line, useColor) {
+  const fileBlock = paint(`[${relPath}]`, C_FILE, useColor);
+  const tsBlock = paint(`[${detectionTimestamp()}]`, C_TIMESTAMP, useColor);
+  const content = paint(line, C_CONTENT, useColor);
+  return `${fileBlock} ${tsBlock} ${content}`;
+}
+
+function drainNewLines(filePath, state) {
+  let stats;
+  try {
+    stats = fs.statSync(filePath);
+  } catch {
+    return [];
+  }
+
+  const inode = stats.ino ?? null;
+  const size = stats.size;
+
+  if (state.inode === null) {
+    state.inode = inode;
+  }
+
+  const rotated = state.inode !== inode;
+  const truncated = size < state.position;
+  if (rotated || truncated) {
+    state.inode = inode;
+    state.position = 0;
+    state.partial = "";
+  }
+
+  if (size <= state.position) {
+    return [];
+  }
+
+  const toRead = size - state.position;
+  let payload = Buffer.alloc(0);
+  let fd = null;
+  try {
+    fd = fs.openSync(filePath, "r");
+    payload = Buffer.allocUnsafe(toRead);
+    const bytesRead = fs.readSync(fd, payload, 0, toRead, state.position);
+    state.position += bytesRead;
+    payload = payload.subarray(0, bytesRead);
+  } catch {
+    return [];
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+        // ignore close failures
+      }
+    }
+  }
+
+  if (payload.length === 0) {
+    return [];
+  }
+
+  const chunk = state.partial + payload.toString("utf8");
+  const parts = chunk.split(/(\r\n|\n|\r)/);
+  const lines = [];
+
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    lines.push(parts[i]);
+  }
+
+  state.partial = parts.length % 2 === 1 ? parts[parts.length - 1] : "";
+  return lines;
+}
+
+function expandHome(inputPath) {
+  if (inputPath === "~") {
+    return os.homedir();
+  }
+  if (inputPath.startsWith(`~${path.sep}`)) {
+    return path.join(os.homedir(), inputPath.slice(2));
+  }
+  return inputPath;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv);
+  } catch (error) {
+    fail(String(error.message || error));
+    process.stderr.write("\n");
+    process.stderr.write(`${usage()}\n`);
+    return 1;
+  }
+
+  if (args.help) {
+    process.stdout.write(`${usage()}\n`);
+    return 0;
+  }
+
+  const root = path.resolve(expandHome(args.directory));
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    fail(`Error: not a directory: ${root}`);
+    return 1;
+  }
+
+  if (args.pollInterval <= 0 || args.scanInterval <= 0) {
+    fail("Error: poll and scan intervals must be positive");
+    return 1;
+  }
+
+  if (args.initialLines < 0) {
+    fail("Error: --initial-lines must be >= 0");
+    return 1;
+  }
+
+  if (!["auto", "always", "never"].includes(args.color)) {
+    fail("Error: --color must be one of: auto, always, never");
+    return 1;
+  }
+
+  const useColor = colorEnabled(args.color);
+  const globs = args.globs.length > 0 ? args.globs : DEFAULT_GLOBS;
+  const globRegexes = globs.map((glob) => globToRegex(glob.toLowerCase()));
+  const tracked = new Map();
+
+  const existingFiles = Array.from(discoverLogFiles(root, globRegexes)).sort();
+  for (const filePath of existingFiles) {
+    let stats;
+    try {
+      stats = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+
+    tracked.set(filePath, {
+      position: stats.size,
+      inode: stats.ino ?? null,
+      partial: "",
+    });
+
+    if (args.initialLines > 0) {
+      const rel = relativeDisplay(root, filePath);
+      for (const line of readLastLines(filePath, args.initialLines)) {
+        process.stdout.write(`${formatOutput(rel, line, useColor)}\n`);
+      }
+    }
+  }
+
+  const info =
+    `Monitoring ${tracked.size} files under ${root} ` +
+    `(globs: ${globs.join(", ")} | poll=${args.pollInterval}s | scan=${args.scanInterval}s). ` +
+    "Press Ctrl+C to stop.";
+  process.stdout.write(`${paint(info, C_INFO, useColor)}\n`);
+
+  let stopped = false;
+  const stop = () => {
+    stopped = true;
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+
+  let lastScan = performance.now() / 1000;
+
+  try {
+    while (!stopped) {
+      const now = performance.now() / 1000;
+      if (now - lastScan >= args.scanInterval) {
+        const currentFiles = discoverLogFiles(root, globRegexes);
+        const trackedFiles = new Set(tracked.keys());
+
+        const newFiles = Array.from(currentFiles)
+          .filter((filePath) => !trackedFiles.has(filePath))
+          .sort();
+
+        for (const newPath of newFiles) {
+          let stats;
+          try {
+            stats = fs.statSync(newPath);
+          } catch {
+            continue;
+          }
+
+          tracked.set(newPath, {
+            position: 0,
+            inode: stats.ino ?? null,
+            partial: "",
+          });
+
+          const rel = relativeDisplay(root, newPath);
+          process.stdout.write(`${paint(`[watch] ${rel}`, C_INFO, useColor)}\n`);
+        }
+
+        for (const filePath of trackedFiles) {
+          if (!currentFiles.has(filePath)) {
+            tracked.delete(filePath);
+          }
+        }
+
+        lastScan = now;
+      }
+
+      const trackedPaths = Array.from(tracked.keys()).sort();
+      for (const filePath of trackedPaths) {
+        const state = tracked.get(filePath);
+        if (!state) {
+          continue;
+        }
+
+        const lines = drainNewLines(filePath, state);
+        if (lines.length === 0) {
+          continue;
+        }
+
+        const rel = relativeDisplay(root, filePath);
+        for (const line of lines) {
+          process.stdout.write(`${formatOutput(rel, line, useColor)}\n`);
+        }
+      }
+
+      if (stopped) {
+        break;
+      }
+      await sleep(args.pollInterval * 1000);
+    }
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  }
+
+  process.stdout.write(`${paint("Stopping mega-tail.", C_INFO, useColor)}\n`);
+  return 0;
+}
+
+main().then((code) => {
+  process.exitCode = code;
+});

package/mega-tail

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""
+mega-tail - Follow dynamic log files under a directory tree.
+
+Behavior:
+- Follows appended lines from all matching log files under the target directory.
+- Detects and starts following newly created log files as they appear.
+- Handles truncation/rotation by checking inode and file size changes.
+- Prefixes each line with relative file path and detection timestamp.
+"""
+
+from __future__ import annotations
+
+import argparse
+import fnmatch
+import os
+import signal
+import sys
+import time
+from collections import deque
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+DEFAULT_GLOBS = ("*.log", "*.log.*")
+DEFAULT_POLL_INTERVAL = 0.2
+DEFAULT_SCAN_INTERVAL = 1.0
+
+# ANSI colors
+C_RESET = "\033[0m"
+C_TIMESTAMP = "\033[38;5;81m"   # highlighted cyan
+C_FILE = "\033[38;5;245m"       # dim gray
+C_CONTENT = "\033[38;5;252m"    # brighter gray
+C_INFO = "\033[38;5;244m"
+
+
+@dataclass
+class FileState:
+    position: int
+    inode: int | None
+    partial: str = ""
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="mega-tail",
+        description="Tail dynamic log files in a directory tree.",
+    )
+    parser.add_argument("directory", help="Root directory to monitor recursively")
+    parser.add_argument(
+        "--glob",
+        dest="globs",
+        action="append",
+        help="Filename glob to include (repeatable). Default: *.log and *.log.*",
+    )
+    parser.add_argument(
+        "--poll-interval",
+        type=float,
+        default=DEFAULT_POLL_INTERVAL,
+        help=f"Seconds between reads of tracked files (default: {DEFAULT_POLL_INTERVAL})",
+    )
+    parser.add_argument(
+        "--scan-interval",
+        type=float,
+        default=DEFAULT_SCAN_INTERVAL,
+        help=f"Seconds between directory scans for new/deleted files (default: {DEFAULT_SCAN_INTERVAL})",
+    )
+    parser.add_argument(
+        "-n",
+        "--initial-lines",
+        type=int,
+        default=0,
+        help="Show last N lines from each existing file at startup (default: 0)",
+    )
+    parser.add_argument(
+        "--color",
+        choices=("auto", "always", "never"),
+        default="auto",
+        help="Color mode (default: auto)",
+    )
+    return parser.parse_args()
+
+
+def color_enabled(mode: str) -> bool:
+    if mode == "always":
+        return True
+    if mode == "never":
+        return False
+    return sys.stdout.isatty() and os.environ.get("TERM", "") != "dumb"
+
+
+def paint(text: str, color: str, enabled: bool) -> str:
+    if not enabled:
+        return text
+    return f"{color}{text}{C_RESET}"
+
+
+def detection_timestamp() -> str:
+    now = datetime.now().astimezone()
+    return now.strftime("%Y-%m-%d %H:%M:%S.") + f"{now.microsecond // 1000:03d}"
+
+
+def discover_log_files(root: Path, globs: list[str]) -> set[Path]:
+    lowered_globs = [g.lower() for g in globs]
+    matches: set[Path] = set()
+    for dirpath, _, filenames in os.walk(root):
+        base = Path(dirpath)
+        for filename in filenames:
+            name = filename.lower()
+            if any(fnmatch.fnmatch(name, pattern) for pattern in lowered_globs):
+                matches.add(base / filename)
+    return matches
+
+
+def read_last_lines(path: Path, count: int) -> list[str]:
+    if count <= 0:
+        return []
+    lines = deque(maxlen=count)
+    try:
+        with path.open("r", encoding="utf-8", errors="replace") as handle:
+            for line in handle:
+                lines.append(line.rstrip("\r\n"))
+    except OSError:
+        return []
+    return list(lines)
+
+
+def relative_display(root: Path, path: Path) -> str:
+    try:
+        return path.relative_to(root).as_posix()
+    except ValueError:
+        return str(path)
+
+
+def format_output(relpath: str, line: str, use_color: bool) -> str:
+    file_block = paint(f"[{relpath}]", C_FILE, use_color)
+    ts_block = paint(f"[{detection_timestamp()}]", C_TIMESTAMP, use_color)
+    content = paint(line, C_CONTENT, use_color)
+    return f"{file_block} {ts_block} {content}"
+
+
+def drain_new_lines(path: Path, state: FileState) -> list[str]:
+    try:
+        stat = path.stat()
+    except OSError:
+        return []
+
+    inode = stat.st_ino
+    size = stat.st_size
+
+    if state.inode is None:
+        state.inode = inode
+
+    rotated = state.inode != inode
+    truncated = size < state.position
+    if rotated or truncated:
+        state.inode = inode
+        state.position = 0
+        state.partial = ""
+
+    if size <= state.position:
+        return []
+
+    try:
+        with path.open("rb") as handle:
+            handle.seek(state.position)
+            payload = handle.read()
+            state.position = handle.tell()
+    except OSError:
+        return []
+
+    if not payload:
+        return []
+
+    # Preserve a trailing partial line and emit only complete lines.
+    chunk = state.partial + payload.decode("utf-8", errors="replace")
+    parts = chunk.splitlines(keepends=True)
+    lines: list[str] = []
+    state.partial = ""
+
+    for part in parts:
+        if part.endswith("\n") or part.endswith("\r"):
+            lines.append(part.rstrip("\r\n"))
+        else:
+            state.partial = part
+
+    return lines
+
+
+def install_signal_handlers() -> None:
+    def _stop(_signum, _frame):
+        raise KeyboardInterrupt
+
+    signal.signal(signal.SIGINT, _stop)
+    signal.signal(signal.SIGTERM, _stop)
+
+
+def main() -> int:
+    args = parse_args()
+
+    root = Path(args.directory).expanduser().resolve()
+    if not root.is_dir():
+        print(f"Error: not a directory: {root}", file=sys.stderr)
+        return 1
+
+    if args.poll_interval <= 0 or args.scan_interval <= 0:
+        print("Error: poll and scan intervals must be positive", file=sys.stderr)
+        return 1
+
+    if args.initial_lines < 0:
+        print("Error: --initial-lines must be >= 0", file=sys.stderr)
+        return 1
+
+    use_color = color_enabled(args.color)
+    globs = args.globs if args.globs else list(DEFAULT_GLOBS)
+    tracked: dict[Path, FileState] = {}
+
+    existing_files = discover_log_files(root, globs)
+    for path in sorted(existing_files):
+        try:
+            stat = path.stat()
+        except OSError:
+            continue
+        tracked[path] = FileState(position=stat.st_size, inode=stat.st_ino)
+        if args.initial_lines > 0:
+            rel = relative_display(root, path)
+            for line in read_last_lines(path, args.initial_lines):
+                print(format_output(rel, line, use_color), flush=True)
+
+    info = (
+        f"Monitoring {len(tracked)} files under {root} "
+        f"(globs: {', '.join(globs)} | poll={args.poll_interval}s | scan={args.scan_interval}s). "
+        "Press Ctrl+C to stop."
+    )
+    print(paint(info, C_INFO, use_color), flush=True)
+
+    install_signal_handlers()
+    last_scan = time.monotonic()
+
+    try:
+        while True:
+            now = time.monotonic()
+            if now - last_scan >= args.scan_interval:
+                current_files = discover_log_files(root, globs)
+                tracked_files = set(tracked.keys())
+
+                for new_path in sorted(current_files - tracked_files):
+                    try:
+                        stat = new_path.stat()
+                    except OSError:
+                        continue
+                    # Start new files at byte 0 so early writes are not missed.
+                    tracked[new_path] = FileState(position=0, inode=stat.st_ino)
+                    rel = relative_display(root, new_path)
+                    watch_msg = f"[watch] {rel}"
+                    print(paint(watch_msg, C_INFO, use_color), flush=True)
+
+                for removed_path in tracked_files - current_files:
+                    tracked.pop(removed_path, None)
+
+                last_scan = now
+
+            for path in sorted(tracked.keys()):
+                lines = drain_new_lines(path, tracked[path])
+                if not lines:
+                    continue
+                rel = relative_display(root, path)
+                for line in lines:
+                    print(format_output(rel, line, use_color), flush=True)
+
+            time.sleep(args.poll_interval)
+    except KeyboardInterrupt:
+        print(paint("Stopping mega-tail.", C_INFO, use_color), flush=True)
+        return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "mega-tail",
+  "version": "0.1.0",
+  "description": "Tail dynamic log files in a directory tree.",
+  "license": "MIT",
+  "bin": {
+    "mega-tail": "bin/mega-tail.js"
+  },
+  "files": [
+    "bin/mega-tail.js",
+    "README.md",
+    "mega-tail"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "tail",
+    "logs",
+    "cli",
+    "monitoring"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orlenko/mega-tail.git"
+  }
+}