@logtrace/shared 0.1.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@logtrace/shared",
+  "version": "0.1.0",
+  "description": "Utilidades compartidas del ecosistema LogTrace (constantes, máscara de datos sensibles, helpers).",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./constants": "./src/constants.js",
+    "./utils": "./src/utils.js",
+    "./masker": "./src/masker.js"
+  },
+  "files": ["src"],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/logtrace/tracker-cli.git",
+    "directory": "packages/shared"
+  },
+  "homepage": "https://logtrace.cloud",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.js"
+  }
+}

package/src/constants.js

@@ -0,0 +1,32 @@
+/**
+ * @logtrace/shared — constants.js
+ *
+ * Single source of truth for paths, versions, and config shared
+ * between daemon and CLI.
+ *
+ * ENV overrides let dev run without root or /opt access.
+ *   Dev:  LOGTRACE_DIR=./tmp/logtrace  SOCKET_PATH=./tmp/logtrace/daemon.sock
+ *   Prod: defaults below (/opt/logtrace, /run/logtrace/daemon.sock)
+ */
+
+export const LOGTRACE_DIR = process.env.LOGTRACE_DIR || '/opt/logtrace'
+export const SOCKET_PATH  = process.env.SOCKET_PATH  || '/run/logtrace/daemon.sock'
+
+export const VERSION    = '0.1.0'
+export const LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'critical']
+
+/** True when running in development mode — relaxes license checks, verbose logs */
+export const IS_DEV = process.env.LOGTRACE_ENV === 'development'
+
+/** Directories created by daemon on startup */
+export const DAEMON_DIRS = [
+  `${LOGTRACE_DIR}/data`,
+  `${LOGTRACE_DIR}/backups`,
+  `${LOGTRACE_DIR}/logs`,
+]
+
+/** SQLite database path */
+export const DB_PATH = `${LOGTRACE_DIR}/data/logtrace.db`
+
+/** License cache path */
+export const LICENSE_CACHE_PATH = `${LOGTRACE_DIR}/.license-cache.json`

package/src/index.js

@@ -0,0 +1,3 @@
+export * from './constants.js'
+export * from './utils.js'
+export * from './masker.js'

package/src/masker.js

@@ -0,0 +1,114 @@
+/**
+ * @logtrace/shared — masker.js
+ *
+ * maskLog(obj) strips sensitive data from a log object BEFORE it is stored
+ * in SQLite or forwarded to the central server.
+ *
+ * Patterns applied (in order):
+ *   EMAIL     — user@example.com          → [EMAIL]
+ *   CARD      — 16-digit Luhn numbers      → [CARD]
+ *   JWT       — eyJh...eyJh...sig          → [JWT]
+ *   AWS_KEY   — AKIA[A-Z0-9]{16}           → [AWS_KEY]
+ *   PASSWORD  — JSON field "password":"…"  → "password":"[REDACTED]"
+ *   SECRET    — JSON field "secret":"…"    → "secret":"[REDACTED]"
+ *   TOKEN     — JSON field "token":"…"     → "token":"[REDACTED]"
+ *
+ * Only string values inside the object are modified.
+ * Non-string values (numbers, booleans, null) are left as-is.
+ * Nested objects are processed recursively.
+ *
+ * Custom patterns can be added at runtime via addPattern().
+ */
+
+/** @type {Array<{regex: RegExp, replace: string}>} */
+const PATTERNS = [
+  // Email addresses
+  {
+    regex: /[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/g,
+    replace: '[EMAIL]',
+  },
+  // Credit/debit card numbers (Luhn-structured 16-digit, with optional separators)
+  {
+    regex: /\b(?:\d[ \-]?){13,15}\d\b/g,
+    replace: '[CARD]',
+  },
+  // JSON Web Tokens (3-part base64url)
+  {
+    regex: /eyJ[A-Za-z0-9_\-]+\.eyJ[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+/g,
+    replace: '[JWT]',
+  },
+  // AWS access key IDs
+  {
+    regex: /AKIA[0-9A-Z]{16}/g,
+    replace: '[AWS_KEY]',
+  },
+  // JSON field: "password":"<value>"  (double or single quotes, any depth)
+  {
+    regex: /"password"\s*:\s*"[^"]*"/gi,
+    replace: '"password":"[REDACTED]"',
+  },
+  // JSON field: "secret":"<value>"
+  {
+    regex: /"secret"\s*:\s*"[^"]*"/gi,
+    replace: '"secret":"[REDACTED]"',
+  },
+  // JSON field: "token":"<value>"  (catches api_token, access_token, etc.)
+  {
+    regex: /"[a-z_]*token[a-z_]*"\s*:\s*"[^"]*"/gi,
+    replace: (match) => match.replace(/"[^"]*"$/, '"[REDACTED]"'),
+  },
+]
+
+/**
+ * Add a custom masking pattern at runtime.
+ * @param {RegExp} regex
+ * @param {string|Function} replace
+ */
+export function addPattern(regex, replace) {
+  PATTERNS.push({ regex, replace })
+}
+
+/**
+ * Apply all masking patterns to a single string value.
+ * @param {string} str
+ * @returns {string}
+ */
+function maskString(str) {
+  let result = str
+  for (const { regex, replace } of PATTERNS) {
+    // Reset lastIndex for global regexes to avoid stale state
+    if (regex.global) regex.lastIndex = 0
+    result = result.replace(regex, replace)
+  }
+  return result
+}
+
+/**
+ * Recursively mask all string values in an object or array.
+ * Returns a new object — the original is never mutated.
+ *
+ * @param {any} obj
+ * @returns {any}
+ */
+export function maskLog(obj) {
+  if (obj === null || obj === undefined) return obj
+
+  if (typeof obj === 'string') {
+    return maskString(obj)
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(maskLog)
+  }
+
+  if (typeof obj === 'object') {
+    const result = {}
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = maskLog(value)
+    }
+    return result
+  }
+
+  // number, boolean, bigint, symbol — return as-is
+  return obj
+}

package/src/utils.js

@@ -0,0 +1,55 @@
+/**
+ * @logtrace/shared — utils.js
+ *
+ * Utility functions shared between daemon and CLI.
+ */
+
+import { createHash } from 'node:crypto'
+
+/**
+ * fingerprint(log) — deterministic hash for deduplication.
+ *
+ * Two log entries with the same level + service + message produce the same
+ * fingerprint, regardless of timestamp or meta. This lets the alert system
+ * deduplicate bursts without a DB query per log.
+ *
+ * @param {object} log - { level, service, message }
+ * @returns {string} 16-char hex fingerprint
+ */
+export function fingerprint(log) {
+  const key = [
+    (log.level   || '').toLowerCase(),
+    (log.service || '').toLowerCase(),
+    (log.message || '').slice(0, 200),  // cap at 200 chars — ignore trailing noise
+  ].join('|')
+  return createHash('sha256').update(key).digest('hex').slice(0, 16)
+}
+
+/**
+ * formatDate(ts) — ISO timestamp → human-readable local string.
+ *
+ * @param {number|string|Date} ts
+ * @returns {string} e.g. "2026-06-09 14:32:01"
+ */
+export function formatDate(ts) {
+  const d = ts instanceof Date ? ts : new Date(ts)
+  if (isNaN(d.getTime())) return 'invalid date'
+  const pad = (n) => String(n).padStart(2, '0')
+  return (
+    `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+    `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`
+  )
+}
+
+/**
+ * truncate(str, n) — truncate a string to n chars, appending "…" if cut.
+ *
+ * @param {string} str
+ * @param {number} n - maximum length (including the ellipsis character)
+ * @returns {string}
+ */
+export function truncate(str, n) {
+  if (typeof str !== 'string') return String(str)
+  if (str.length <= n) return str
+  return str.slice(0, n - 1) + '…'
+}