@logtrace/tracker 0.1.0

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@logtrace/tracker",
+  "version": "0.1.0",
+  "description": "CLI oficial de LogTrace — gestiona el agente de observabilidad en tu VPS (status, logs, docker, alertas).",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "tracker": "src/index.js"
+  },
+  "files": ["src"],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "keywords": ["logtrace", "observability", "logs", "monitoring", "vps", "cli", "tracker"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/logtrace/tracker-cli.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://logtrace.cloud",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node --test test/**/*.test.js"
+  },
+  "dependencies": {
+    "@logtrace/shared": "^0.1.0",
+    "yargs": "^17.7.2",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.1",
+    "cli-table3": "^0.6.5",
+    "inquirer": "^10.1.8",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "pkg": "^5.8.1"
+  }
+}

package/src/client.js

@@ -0,0 +1,181 @@
+/**
+ * packages/cli/src/client.js
+ *
+ * Unix socket client — the CLI's connection to the daemon.
+ *
+ * Usage:
+ *   const client = createClient()
+ *   await client.connect()
+ *   const data = await client.send('status', {})
+ *   client.close()
+ *
+ * Auto-start behavior:
+ *   If the daemon is not running (ENOENT or ECONNREFUSED on the socket),
+ *   the client will attempt to spawn the daemon process, wait 2 seconds
+ *   for it to become ready, then retry the connection once.
+ *
+ *   This means `tracker status` always works — even if the user hasn't
+ *   explicitly started the daemon first.
+ */
+
+import net from 'node:net'
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { SOCKET_PATH } from '@logtrace/shared/constants'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname  = dirname(__filename)
+
+/** Path to the daemon entry point (relative to this file in the monorepo) */
+const DAEMON_ENTRY = resolve(__dirname, '../../daemon/src/core/index.js')
+
+// ── Client factory ────────────────────────────────────────────────────────────
+
+/**
+ * @returns {{ connect: Function, send: Function, close: Function }}
+ */
+export function createClient() {
+  /** @type {net.Socket|null} */
+  let socket = null
+
+  /**
+   * connect() — connect to the daemon Unix socket.
+   * If the daemon is not running, spawns it and retries.
+   */
+  async function connect() {
+    try {
+      socket = await connectToSocket()
+    } catch (err) {
+      if (err.code === 'ENOENT' || err.code === 'ECONNREFUSED') {
+        // Daemon not running — start it
+        await spawnDaemon()
+        // Wait for daemon to initialize
+        await sleep(2000)
+        // Retry once
+        socket = await connectToSocket()
+      } else {
+        throw err
+      }
+    }
+  }
+
+  /**
+   * send(cmd, args) — send a command and wait for the response.
+   *
+   * @param {string} cmd
+   * @param {object} [args={}]
+   * @returns {Promise<any>} the `data` field from the response
+   * @throws {Error} if ok=false or connection fails
+   */
+  async function send(cmd, args = {}) {
+    if (!socket || socket.destroyed) {
+      throw new Error('Not connected. Call connect() first.')
+    }
+
+    return new Promise((resolve, reject) => {
+      const message = JSON.stringify({ cmd, args }) + '\n'
+
+      let buffer = ''
+
+      // One-shot listener: resolve on first complete response
+      const onData = (chunk) => {
+        buffer += chunk
+        const idx = buffer.indexOf('\n')
+        if (idx === -1) return  // incomplete — keep buffering
+
+        const line = buffer.slice(0, idx).trim()
+        // Remove the one-shot listener before resolving
+        socket.removeListener('data', onData)
+
+        let response
+        try {
+          response = JSON.parse(line)
+        } catch (e) {
+          return reject(new Error(`Invalid JSON response: ${line}`))
+        }
+
+        if (!response.ok) {
+          return reject(new Error(response.error || 'Daemon error'))
+        }
+
+        resolve(response.data)
+      }
+
+      socket.on('data', onData)
+
+      socket.once('error', (err) => {
+        socket.removeListener('data', onData)
+        reject(err)
+      })
+
+      socket.write(message)
+    })
+  }
+
+  /**
+   * close() — gracefully close the socket connection.
+   */
+  function close() {
+    if (socket && !socket.destroyed) {
+      socket.end()
+    }
+    socket = null
+  }
+
+  return { connect, send, close }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+/**
+ * connectToSocket() — open a connection to the Unix socket.
+ * Rejects with a Node.js system error (ENOENT, ECONNREFUSED, etc.) on failure.
+ *
+ * @returns {Promise<net.Socket>}
+ */
+function connectToSocket() {
+  return new Promise((resolve, reject) => {
+    const sock = net.createConnection({ path: SOCKET_PATH }, () => {
+      sock.setEncoding('utf8')
+      resolve(sock)
+    })
+    sock.on('error', reject)
+  })
+}
+
+/**
+ * spawnDaemon() — start the daemon as a detached background process.
+ *
+ * The daemon inherits the current environment so LOGTRACE_ENV,
+ * LOGTRACE_DIR, and SOCKET_PATH are passed through automatically.
+ * stdout/stderr are ignored in CLI context — the daemon writes its
+ * own logs to file (configured in Paso 8+).
+ */
+function spawnDaemon() {
+  if (!existsSync(DAEMON_ENTRY)) {
+    throw new Error(
+      `Daemon entry not found: ${DAEMON_ENTRY}\n` +
+      'Make sure the monorepo is installed correctly.'
+    )
+  }
+
+  const child = spawn(process.execPath, [DAEMON_ENTRY], {
+    detached: true,
+    stdio: 'ignore',
+  })
+
+  child.unref()  // allow CLI to exit even if daemon is still starting
+
+  return Promise.resolve()
+}
+
+/**
+ * sleep(ms) — promise-based delay.
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/commands/alert.js

@@ -0,0 +1,34 @@
+/**
+ * packages/cli/src/commands/alert.js
+ *
+ * tracker alert test — fire a test alert through the daemon's alert system.
+ *
+ * Triggers bus.emit('alert', ...) inside the daemon and reports whether
+ * Telegram (or other configured channels) received the message.
+ */
+
+import chalk from 'chalk'
+import ora from 'ora'
+import { createClient } from '../client.js'
+import { printError } from '../ui/renderer.js'
+
+export async function alertTestCommand(_argv) {
+  const spinner = ora('Enviando alerta de prueba...').start()
+  const client  = createClient()
+
+  try {
+    await client.connect()
+    const result = await client.send('alert.test', {})
+
+    if (result.sent) {
+      spinner.succeed(chalk.green('Alerta de prueba enviada correctamente.'))
+    } else {
+      spinner.warn(chalk.yellow(`Alerta no enviada: ${result.reason || 'sin canales configurados'}`))
+    }
+  } catch (err) {
+    spinner.fail(chalk.red(`Error al enviar alerta de prueba: ${err.message}`))
+    process.exitCode = 1
+  } finally {
+    client.close()
+  }
+}

package/src/commands/config.js

@@ -0,0 +1,306 @@
+/**
+ * packages/cli/src/commands/config.js
+ *
+ * tracker config — read and write the LogTrace .env file directly from the CLI.
+ *
+ * This command operates on the .env file on disk without going through the
+ * daemon socket. That lets operators inspect and change config even when the
+ * daemon is stopped.
+ *
+ * Subcommands:
+ *   tracker config list             — show all key/value pairs (secrets masked)
+ *   tracker config get <key>        — print exact value (no masking)
+ *   tracker config set <key> <val>  — upsert a key
+ *   tracker config unset <key>      — remove a key
+ *
+ * Masking rule: any key whose name contains KEY, TOKEN, SECRET, or PASSWORD
+ * (case-insensitive) is shown as **** in `list`.
+ *
+ * Permissions: EACCES is caught and surfaced with a human-readable message.
+ */
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import chalk from 'chalk'
+import { LOGTRACE_DIR } from '@logtrace/shared/constants'
+import { printError, printWarning, printInfo, printTable } from '../ui/renderer.js'
+
+// ── Path ──────────────────────────────────────────────────────────────────────
+
+const ENV_PATH = path.join(LOGTRACE_DIR, '.env')
+
+// ── Sensitive key pattern (case-insensitive) ──────────────────────────────────
+
+const SENSITIVE_RE = /KEY|TOKEN|SECRET|PASSWORD/i
+
+function isSensitive(key) {
+  return SENSITIVE_RE.test(key)
+}
+
+// ── .env parser (preserves comments and blank lines) ─────────────────────────
+
+/**
+ * Parse an .env file into an ordered list of entries.
+ * Each entry is one of:
+ *   { type: 'pair',    key, value, raw }   — KEY=value line
+ *   { type: 'comment', raw }               — # comment or blank line
+ *
+ * We keep all three fields so we can reconstruct the file faithfully.
+ */
+function parseEnv(text) {
+  const entries = []
+
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim()
+
+    // Blank line or comment
+    if (trimmed === '' || trimmed.startsWith('#')) {
+      entries.push({ type: 'comment', raw: line })
+      continue
+    }
+
+    // KEY=value — only the first '=' is the separator
+    const eqIdx = line.indexOf('=')
+    if (eqIdx === -1) {
+      // Malformed line — keep as comment so we don't lose it
+      entries.push({ type: 'comment', raw: line })
+      continue
+    }
+
+    const key   = line.slice(0, eqIdx).trim()
+    const value = line.slice(eqIdx + 1)   // value may contain '=' — do NOT trim
+
+    entries.push({ type: 'pair', key, value, raw: line })
+  }
+
+  return entries
+}
+
+/**
+ * Serialize entries back to .env text.
+ */
+function serializeEnv(entries) {
+  return entries.map((e) => e.type === 'pair' ? `${e.key}=${e.value}` : e.raw).join('\n')
+}
+
+// ── File I/O helpers ──────────────────────────────────────────────────────────
+
+async function readEnv() {
+  try {
+    const text = await fs.readFile(ENV_PATH, 'utf8')
+    return parseEnv(text)
+  } catch (err) {
+    if (err.code === 'ENOENT') return null           // file does not exist
+    if (err.code === 'EACCES') throw new AccessError(ENV_PATH)
+    throw err
+  }
+}
+
+async function writeEnv(entries) {
+  try {
+    await fs.writeFile(ENV_PATH, serializeEnv(entries), 'utf8')
+  } catch (err) {
+    if (err.code === 'EACCES') throw new AccessError(ENV_PATH)
+    throw err
+  }
+}
+
+class AccessError extends Error {
+  constructor(filePath) {
+    super(`sin permisos para ${filePath}. Intenta con sudo.`)
+    this.name = 'AccessError'
+  }
+}
+
+// ── Commands ──────────────────────────────────────────────────────────────────
+
+/**
+ * tracker config list
+ *
+ * Prints a two-column table: KEY | VALOR
+ * Sensitive values are shown as ****
+ * Comments and blank lines are ignored in the output.
+ */
+export async function configListCommand(_argv) {
+  let entries
+
+  try {
+    entries = await readEnv()
+  } catch (err) {
+    printError(err.message)
+    process.exitCode = 1
+    return
+  }
+
+  if (entries === null) {
+    printInfo(`Archivo de config no encontrado: ${ENV_PATH}`)
+    printInfo('Usa "tracker config set <KEY> <VALUE>" para crear una clave.')
+    return
+  }
+
+  const pairs = entries.filter((e) => e.type === 'pair')
+
+  if (pairs.length === 0) {
+    printInfo('El archivo de config existe pero no contiene claves.')
+    return
+  }
+
+  const rows = pairs.map(({ key, value }) => {
+    const displayVal = isSensitive(key)
+      ? chalk.dim('****')
+      : chalk.white(value)
+    return [chalk.cyan(key), displayVal]
+  })
+
+  console.log()
+  console.log(chalk.bold(`  Config: ${ENV_PATH}`))
+  console.log()
+  printTable(['KEY', 'VALOR'], rows)
+}
+
+/**
+ * tracker config get <key>
+ *
+ * Prints the raw value for <key>, no masking.
+ * Exits with code 1 if the key does not exist.
+ */
+export async function configGetCommand(argv) {
+  const { key } = argv
+
+  let entries
+
+  try {
+    entries = await readEnv()
+  } catch (err) {
+    printError(err.message)
+    process.exitCode = 1
+    return
+  }
+
+  if (entries === null) {
+    printError(`Archivo no encontrado: ${ENV_PATH}`)
+    process.exitCode = 1
+    return
+  }
+
+  const found = entries.find((e) => e.type === 'pair' && e.key === key)
+
+  if (!found) {
+    printError(`Clave no encontrada: ${key}`)
+    process.exitCode = 1
+    return
+  }
+
+  // Raw output — no newline decoration so it can be captured via $()
+  process.stdout.write(found.value + '\n')
+}
+
+/**
+ * tracker config set <key> <value>
+ *
+ * Upserts the key in the .env file.
+ *   - Existing key → replaces that line in-place (preserves file order)
+ *   - New key → appended at the end
+ *   - Comments and blank lines are preserved exactly
+ *
+ * Special warnings:
+ *   - TELEGRAM_BOT_TOKEN → remind user to run `tracker alert test`
+ *   - *PASSWORD*         → remind user to restart the daemon
+ */
+export async function configSetCommand(argv) {
+  const { key, value } = argv
+
+  // Validate key — must be a valid env var name
+  if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) {
+    printError(`Nombre de clave inválido: "${key}". Usa solo letras, números y guiones bajos.`)
+    process.exitCode = 1
+    return
+  }
+
+  let entries
+
+  try {
+    entries = await readEnv()
+  } catch (err) {
+    printError(err.message)
+    process.exitCode = 1
+    return
+  }
+
+  // Start with an empty file if it doesn't exist yet
+  if (entries === null) {
+    entries = []
+  }
+
+  const existingIdx = entries.findIndex((e) => e.type === 'pair' && e.key === key)
+
+  if (existingIdx !== -1) {
+    // Replace in-place — keep surrounding comments intact
+    entries[existingIdx] = { type: 'pair', key, value, raw: `${key}=${value}` }
+    printInfo(`Clave actualizada: ${key}`)
+  } else {
+    // Append at the end
+    entries.push({ type: 'pair', key, value, raw: `${key}=${value}` })
+    printInfo(`Clave agregada: ${key}`)
+  }
+
+  try {
+    await writeEnv(entries)
+  } catch (err) {
+    printError(err.message)
+    process.exitCode = 1
+    return
+  }
+
+  // Special contextual warnings
+  if (key === 'TELEGRAM_BOT_TOKEN') {
+    printWarning('Tip: ejecuta tracker alert test para verificar la conexión con Telegram.')
+  } else if (/PASSWORD/i.test(key)) {
+    printWarning('Tip: reinicia el daemon para aplicar el nuevo valor.')
+  }
+}
+
+/**
+ * tracker config unset <key>
+ *
+ * Removes a key from the .env file.
+ * Blank lines and comments around the key are NOT removed.
+ * If the key is not present, prints an informational message (not an error).
+ */
+export async function configUnsetCommand(argv) {
+  const { key } = argv
+
+  let entries
+
+  try {
+    entries = await readEnv()
+  } catch (err) {
+    printError(err.message)
+    process.exitCode = 1
+    return
+  }
+
+  if (entries === null) {
+    printInfo(`Archivo no encontrado: ${ENV_PATH}. No hay nada que eliminar.`)
+    return
+  }
+
+  const existingIdx = entries.findIndex((e) => e.type === 'pair' && e.key === key)
+
+  if (existingIdx === -1) {
+    printInfo(`La clave "${key}" no existe en el archivo de config.`)
+    return
+  }
+
+  entries.splice(existingIdx, 1)
+
+  try {
+    await writeEnv(entries)
+  } catch (err) {
+    printError(err.message)
+    process.exitCode = 1
+    return
+  }
+
+  printInfo(`Clave eliminada: ${key}`)
+}

package/src/commands/docker.js

@@ -0,0 +1,139 @@
+/**
+ * packages/cli/src/commands/docker.js
+ *
+ * tracker docker list              — table of all containers
+ * tracker docker restart <name>    — restart a container
+ * tracker docker logs <name>       — tail container log lines
+ *
+ * State colors:
+ *   running → green  |  exited → red  |  paused → yellow  |  other → dim
+ */
+
+import chalk from 'chalk'
+import ora from 'ora'
+import { createClient } from '../client.js'
+import { printTable, printError, printInfo } from '../ui/renderer.js'
+
+// ── Image display ─────────────────────────────────────────────────────────────
+
+/**
+ * Format a Docker image string for display in the table.
+ *
+ * Rules:
+ *   - sha256:... → keep "sha256:" prefix + up to 20 hex chars + "..."
+ *     e.g. sha256:74225daec0e0a2a371072e... → "sha256:74225daec0e0a2a37107..."
+ *   - normal name (nginx:alpine, postgres:16) → show as-is up to 40 chars,
+ *     truncate with "..." if longer
+ */
+function formatImage(image) {
+  if (!image || image === '-') return '-'
+
+  if (image.startsWith('sha256:')) {
+    const hash = image.slice('sha256:'.length)
+    const truncatedHash = hash.slice(0, 20)
+    return `sha256:${truncatedHash}...`
+  }
+
+  if (image.length > 40) {
+    return image.slice(0, 37) + '...'
+  }
+
+  return image
+}
+
+// ── State coloring ────────────────────────────────────────────────────────────
+
+function colorState(state) {
+  switch (state) {
+    case 'running': return chalk.green(state)
+    case 'exited':  return chalk.red(state)
+    case 'paused':  return chalk.yellow(state)
+    default:        return chalk.dim(state || '?')
+  }
+}
+
+// ── Handlers ──────────────────────────────────────────────────────────────────
+
+export async function dockerListCommand(_argv) {
+  const client = createClient()
+  try {
+    await client.connect()
+    const containers = await client.send('docker.list', {})
+
+    if (!Array.isArray(containers) || containers.length === 0) {
+      printInfo('No hay containers en este sistema.')
+      return
+    }
+
+    const rows = containers.map((c) => [
+      chalk.bold(c.name || '-'),
+      chalk.dim(formatImage(c.image)),
+      colorState(c.state),
+      chalk.dim((c.ports || []).join(', ') || '-'),
+    ])
+
+    console.log()
+    printTable(['Nombre', 'Imagen', 'Estado', 'Puertos'], rows)
+  } catch (err) {
+    printError(`Error al listar containers: ${err.message}`)
+    process.exitCode = 1
+  } finally {
+    client.close()
+  }
+}
+
+export async function dockerRestartCommand(argv) {
+  const name = argv.name
+  if (!name) {
+    printError('Especificá el nombre del container.')
+    process.exitCode = 1
+    return
+  }
+
+  const spinner = ora(`Reiniciando ${chalk.bold(name)}...`).start()
+  const client  = createClient()
+
+  try {
+    await client.connect()
+    await client.send('docker.restart', { name })
+    spinner.succeed(chalk.green(`Container ${chalk.bold(name)} reiniciado`))
+  } catch (err) {
+    spinner.fail(chalk.red(`Error al reiniciar ${name}: ${err.message}`))
+    process.exitCode = 1
+  } finally {
+    client.close()
+  }
+}
+
+export async function dockerLogsCommand(argv) {
+  const name = argv.name
+  const tail = argv.tail ?? 50
+
+  if (!name) {
+    printError('Especificá el nombre del container.')
+    process.exitCode = 1
+    return
+  }
+
+  const client = createClient()
+  try {
+    await client.connect()
+    const result = await client.send('docker.logs', { name, tail: Number(tail) })
+
+    if (!result.lines || result.lines.length === 0) {
+      printInfo(`No hay logs para el container "${name}".`)
+      return
+    }
+
+    console.log()
+    for (const line of result.lines) {
+      console.log(chalk.gray(line))
+    }
+    console.log()
+  } catch (err) {
+    printError(`Error al obtener logs de ${name}: ${err.message}`)
+    process.exitCode = 1
+  } finally {
+    client.close()
+  }
+}