metwatch 0.1.0

package/src/core/launcher.ts

@@ -0,0 +1,280 @@
+// ---------------------------------------------------------------------------
+// Launcher
+//
+// Owns the lifecycle of every managed process: spawn, restart, stop, and
+// exponential back-off on crash. This is the ONLY place in MetWatch that
+// calls child_process.spawn().
+//
+// Back-off schedule (resets if process lives > STABLE_UPTIME_MS):
+//   attempt 1 → 1s
+//   attempt 2 → 2s
+//   attempt 3 → 4s
+//   attempt 4 → 8s
+//   attempt 5 → 16s
+//   attempt 6+ → 30s (cap)
+//
+// Events emitted on bus:
+//   managed:started           — process came up
+//   managed:stopped           — process was intentionally stopped
+//   managed:crashed           — process exited unexpectedly
+//   managed:restarted         — process was restarted (crash or manual)
+//   log:line                  — stdout / stderr line from the child
+//   log:stream:started        — child stdin/stdout attached
+//   log:stream:stopped        — child exited, streams closed
+// ---------------------------------------------------------------------------
+
+import { spawn } from 'child_process';
+import type { ChildProcess } from 'child_process';
+import { bus } from './event-bus.ts';
+import type { ManagedProcess, ManagedProcessDef } from '../types/managed-process.types.ts';
+
+const BACKOFF_STEPS_MS = [1000, 2000, 4000, 8000, 16000, 30000];
+const STABLE_UPTIME_MS = 10_000; // reset back-off counter after this many ms uptime
+const MAX_BACKOFF_MS   = 30_000;
+
+// ── Internal per-process state ─────────────────────────────────────────────
+
+interface ProcessEntry {
+  state:       ManagedProcess;
+  child:       ChildProcess | null;
+  backoffTimer: ReturnType<typeof setTimeout> | null;
+  /** Whether stop() was explicitly called (suppresses auto-restart) */
+  intentional: boolean;
+  /** Timestamp the current run started (for stability check) */
+  runStart: number | null;
+}
+
+// ── Launcher handle returned to callers ───────────────────────────────────
+
+export interface LauncherHandle {
+  /** Start all defined processes. Called once by bootstrap. */
+  startAll: () => void;
+  /** Restart a process by id. */
+  restart: (id: string) => void;
+  /** Gracefully stop a process by id (no auto-restart). */
+  stop: (id: string) => void;
+  /** Stop all managed processes. Called on TUI quit. */
+  stopAll: () => void;
+  /** Get a snapshot of all managed process states. */
+  getAll: () => ManagedProcess[];
+  /** Get a single managed process state by id. */
+  get: (id: string) => ManagedProcess | undefined;
+}
+
+// ── Factory ────────────────────────────────────────────────────────────────
+
+export function createLauncher(defs: ManagedProcessDef[]): LauncherHandle {
+  const entries = new Map<string, ProcessEntry>();
+
+  // Build initial entries from defs
+  for (const def of defs) {
+    entries.set(def.name, {
+      state: {
+        ...def,
+        pid: null,
+        status: 'stopped',
+        restarts: 0,
+        startedAt: null,
+        exitCode: null,
+      },
+      child: null,
+      backoffTimer: null,
+      intentional: false,
+      runStart: null,
+    });
+  }
+
+  // Subscribe to bus requests so the TUI can trigger restart/stop
+  const unsubRestart = bus.on('managed:restart:requested', ({ id }) => restart(id));
+  const unsubStop    = bus.on('managed:stop:requested',    ({ id }) => stop(id));
+
+  // ── Spawn ──────────────────────────────────────────────────────────────
+
+  function spawnProcess(entry: ProcessEntry): void {
+    const { state } = entry;
+
+    const child = spawn(state.command, state.args, {
+      cwd: state.cwd ?? process.cwd(),
+      env: { ...process.env, ...(state.env ?? {}) },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    entry.child    = child;
+    entry.runStart = Date.now();
+    entry.intentional = false;
+
+    state.pid       = child.pid ?? null;
+    state.status    = 'running';
+    state.startedAt = entry.runStart;
+    state.exitCode  = null;
+
+    bus.emit('managed:started', { id: state.name, pid: state.pid ?? 0 });
+    bus.emit('log:stream:started', { id: state.name, pid: state.pid ?? 0 });
+
+    // ── Stream stdout ──────────────────────────────────────────────────
+
+    child.stdout?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk: string) => {
+      for (const line of chunk.split('\n')) {
+        if (line.trim()) {
+          bus.emit('log:line', {
+            id: state.name,
+            stream: 'stdout',
+            line,
+            timestamp: Date.now(),
+          });
+        }
+      }
+    });
+
+    // ── Stream stderr ──────────────────────────────────────────────────
+
+    child.stderr?.setEncoding('utf8');
+    child.stderr?.on('data', (chunk: string) => {
+      for (const line of chunk.split('\n')) {
+        if (line.trim()) {
+          bus.emit('log:line', {
+            id: state.name,
+            stream: 'stderr',
+            line,
+            timestamp: Date.now(),
+          });
+        }
+      }
+    });
+
+    // ── Exit handler ───────────────────────────────────────────────────
+
+    child.on('exit', (code, signal) => {
+      const exitCode = code ?? (signal ? 1 : 0);
+      state.exitCode = exitCode;
+      entry.child    = null;
+      entry.runStart = null;
+
+      bus.emit('log:stream:stopped', { id: state.name, exitCode });
+
+      if (entry.intentional) {
+        state.status = 'stopped';
+        state.pid    = null;
+        bus.emit('managed:stopped', { id: state.name });
+        return;
+      }
+
+      // Unexpected exit — treat as crash
+      state.status = 'crashed';
+      state.pid    = null;
+      state.restarts++;
+      bus.emit('managed:crashed', {
+        id:       state.name,
+        exitCode,
+        restarts: state.restarts,
+      });
+
+      if (state.autoRestart) {
+        scheduleRestart(entry);
+      }
+    });
+  }
+
+  // ── Back-off restart scheduler ─────────────────────────────────────────
+
+  function scheduleRestart(entry: ProcessEntry): void {
+    const { state } = entry;
+
+    // Check if previous run was stable → reset back-off
+    const uptime = entry.runStart ? Date.now() - entry.runStart : 0;
+    if (uptime >= STABLE_UPTIME_MS) {
+      state.restarts = 1; // keep count but reset delay
+    }
+
+    const stepIndex = Math.min(state.restarts - 1, BACKOFF_STEPS_MS.length - 1);
+    const delayMs   = Math.min(BACKOFF_STEPS_MS[stepIndex] ?? MAX_BACKOFF_MS, MAX_BACKOFF_MS);
+
+    state.status = 'restarting';
+
+    entry.backoffTimer = setTimeout(() => {
+      entry.backoffTimer = null;
+      spawnProcess(entry);
+      bus.emit('managed:restarted', {
+        id:       state.name,
+        pid:      state.pid ?? 0,
+        restarts: state.restarts,
+      });
+    }, delayMs);
+  }
+
+  // ── Public API ─────────────────────────────────────────────────────────
+
+  function startAll(): void {
+    for (const entry of entries.values()) {
+      spawnProcess(entry);
+    }
+  }
+
+  function restart(id: string): void {
+    const entry = entries.get(id);
+    if (!entry) return;
+
+    // Cancel any pending back-off timer
+    if (entry.backoffTimer) {
+      clearTimeout(entry.backoffTimer);
+      entry.backoffTimer = null;
+    }
+
+    // Kill current child if running
+    if (entry.child) {
+      entry.intentional = true; // prevent crash handler from re-triggering
+      entry.child.kill('SIGTERM');
+    }
+
+    // Brief settle then re-spawn
+    setTimeout(() => {
+      entry.state.restarts++;
+      spawnProcess(entry);
+      bus.emit('managed:restarted', {
+        id,
+        pid:      entry.state.pid ?? 0,
+        restarts: entry.state.restarts,
+      });
+    }, 300);
+  }
+
+  function stop(id: string): void {
+    const entry = entries.get(id);
+    if (!entry) return;
+
+    // Cancel any pending back-off restart
+    if (entry.backoffTimer) {
+      clearTimeout(entry.backoffTimer);
+      entry.backoffTimer = null;
+    }
+
+    if (entry.child) {
+      entry.intentional = true;
+      entry.child.kill('SIGTERM');
+    } else {
+      // Already dead — just mark stopped
+      entry.state.status = 'stopped';
+      bus.emit('managed:stopped', { id });
+    }
+  }
+
+  function stopAll(): void {
+    unsubRestart();
+    unsubStop();
+    for (const [id] of entries) {
+      stop(id);
+    }
+  }
+
+  function getAll(): ManagedProcess[] {
+    return [...entries.values()].map(e => ({ ...e.state }));
+  }
+
+  function get(id: string): ManagedProcess | undefined {
+    const entry = entries.get(id);
+    return entry ? { ...entry.state } : undefined;
+  }
+
+  return { startAll, restart, stop, stopAll, getAll, get };
+}

package/src/core/log-manager.ts

@@ -0,0 +1,116 @@
+// ---------------------------------------------------------------------------
+// Log Manager
+//
+// Maintains a per-process circular buffer of log lines captured from
+// managed process stdout/stderr. Widgets read from this buffer on mount
+// (so they show history immediately) and then subscribe to 'log:line'
+// events for live updates.
+//
+// Design:
+//   - One circular buffer (fixed-size array + head pointer) per process ID
+//   - Lines are never sorted — insertion order is display order
+//   - Scrollback limit comes from ResolvedConfig.logScrollback
+//   - No UI awareness: log-manager only stores; widgets only render
+// ---------------------------------------------------------------------------
+
+import { bus } from './event-bus.ts';
+
+interface LogLine {
+  id:        string;
+  stream:    'stdout' | 'stderr';
+  line:      string;
+  timestamp: number;
+}
+
+// ── Circular buffer ────────────────────────────────────────────────────────
+
+class CircularBuffer<T> {
+  private readonly buf: (T | undefined)[];
+  private head = 0;
+  private size = 0;
+
+  constructor(private readonly capacity: number) {
+    this.buf = new Array<T | undefined>(capacity).fill(undefined);
+  }
+
+  push(item: T): void {
+    this.buf[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.size < this.capacity) this.size++;
+  }
+
+  toArray(): T[] {
+    if (this.size === 0) return [];
+    if (this.size < this.capacity) {
+      return this.buf.slice(0, this.size) as T[];
+    }
+    // Buffer is full — head points to oldest entry
+    return [
+      ...this.buf.slice(this.head),
+      ...this.buf.slice(0, this.head),
+    ] as T[];
+  }
+
+  clear(): void {
+    this.buf.fill(undefined);
+    this.head = 0;
+    this.size = 0;
+  }
+
+  get length(): number {
+    return this.size;
+  }
+}
+
+// ── Log Manager ────────────────────────────────────────────────────────────
+
+export interface LogManagerHandle {
+  /** Get all buffered lines for a process id. */
+  getLines: (id: string) => LogLine[];
+  /** Get all lines across all processes, sorted by timestamp. */
+  getAllLines: () => LogLine[];
+  /** Clear the buffer for a specific process. */
+  clearLines: (id: string) => void;
+  /** Stop listening to bus events. Call on TUI destroy. */
+  destroy: () => void;
+}
+
+export function createLogManager(scrollback: number): LogManagerHandle {
+  const buffers = new Map<string, CircularBuffer<LogLine>>();
+
+  function getOrCreate(id: string): CircularBuffer<LogLine> {
+    let buf = buffers.get(id);
+    if (!buf) {
+      buf = new CircularBuffer<LogLine>(scrollback);
+      buffers.set(id, buf);
+    }
+    return buf;
+  }
+
+  const unsub = bus.on('log:line', (payload) => {
+    getOrCreate(payload.id).push(payload);
+  });
+
+  function getLines(id: string): LogLine[] {
+    return buffers.get(id)?.toArray() ?? [];
+  }
+
+  function getAllLines(): LogLine[] {
+    const all: LogLine[] = [];
+    for (const buf of buffers.values()) {
+      all.push(...buf.toArray());
+    }
+    return all.sort((a, b) => a.timestamp - b.timestamp);
+  }
+
+  function clearLines(id: string): void {
+    buffers.get(id)?.clear();
+  }
+
+  function destroy(): void {
+    unsub();
+    buffers.clear();
+  }
+
+  return { getLines, getAllLines, clearLines, destroy };
+}

package/src/core/metrics-manager.ts

@@ -0,0 +1,115 @@
+// ---------------------------------------------------------------------------
+// Metrics Manager
+//
+// Orchestrates the CPU, memory, disk, and network polling loop.
+// Responsibilities:
+//   1. Call system services at the configured interval
+//   2. Write results into state manager
+//   3. Emit typed events on the bus
+//   4. Handle errors without crashing (emit app:error instead)
+//
+// The manager knows nothing about the UI. It is a pure data pipeline.
+// ---------------------------------------------------------------------------
+
+import { bus } from './event-bus.ts';
+import {
+  updateCpuMetrics,
+  updateMemoryMetrics,
+  updateDiskMetrics,
+  updateNetworkMetrics,
+} from './state-manager.ts';
+import { fetchCpuMetrics, fetchMemoryMetrics } from '../services/system.service.ts';
+import { fetchDiskMetrics }                     from '../services/disk.service.ts';
+import { fetchNetworkMetrics }                  from '../services/network.service.ts';
+
+interface MetricsManagerOptions {
+  intervalMs: number;
+}
+
+interface MetricsManagerHandle {
+  start: () => void;
+  stop:  () => void;
+}
+
+export function createMetricsManager(options: MetricsManagerOptions): MetricsManagerHandle {
+  const { intervalMs } = options;
+  let timer:   ReturnType<typeof setInterval> | null = null;
+  let running = false;
+
+  async function tick(): Promise<void> {
+    // Run all fetches in parallel — they are independent OS calls
+    const [cpuResult, memResult, diskResult, netResult] = await Promise.allSettled([
+      fetchCpuMetrics(),
+      fetchMemoryMetrics(),
+      fetchDiskMetrics(),
+      fetchNetworkMetrics(),
+    ]);
+
+    if (cpuResult.status === 'fulfilled') {
+      updateCpuMetrics(cpuResult.value);
+      bus.emit('metrics:cpu:updated', cpuResult.value);
+    } else {
+      bus.emit('app:error', {
+        source: 'metrics-manager:cpu',
+        error: cpuResult.reason instanceof Error
+          ? cpuResult.reason
+          : new Error(String(cpuResult.reason)),
+      });
+    }
+
+    if (memResult.status === 'fulfilled') {
+      updateMemoryMetrics(memResult.value);
+      bus.emit('metrics:memory:updated', memResult.value);
+    } else {
+      bus.emit('app:error', {
+        source: 'metrics-manager:memory',
+        error: memResult.reason instanceof Error
+          ? memResult.reason
+          : new Error(String(memResult.reason)),
+      });
+    }
+
+    if (diskResult.status === 'fulfilled') {
+      updateDiskMetrics(diskResult.value);
+      bus.emit('metrics:disk:updated', diskResult.value);
+    } else {
+      bus.emit('app:error', {
+        source: 'metrics-manager:disk',
+        error: diskResult.reason instanceof Error
+          ? diskResult.reason
+          : new Error(String(diskResult.reason)),
+      });
+    }
+
+    if (netResult.status === 'fulfilled') {
+      updateNetworkMetrics(netResult.value);
+      bus.emit('metrics:network:updated', netResult.value);
+    } else {
+      bus.emit('app:error', {
+        source: 'metrics-manager:network',
+        error: netResult.reason instanceof Error
+          ? netResult.reason
+          : new Error(String(netResult.reason)),
+      });
+    }
+  }
+
+  function start(): void {
+    if (running) return;
+    running = true;
+    // Immediate first tick so the UI isn't blank on startup
+    void tick();
+    timer = setInterval(() => void tick(), intervalMs);
+  }
+
+  function stop(): void {
+    if (!running) return;
+    running = false;
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  return { start, stop };
+}

package/src/core/process-manager.ts

@@ -0,0 +1,79 @@
+// ---------------------------------------------------------------------------
+// Process Manager
+//
+// Orchestrates the process list polling loop and handles process lifecycle
+// actions (kill). Follows the same pattern as metrics-manager:
+//   poll → normalize → write state → emit events
+//
+// Kill flow:
+//   Widget emits 'process:kill:requested' → manager catches it → sends SIGTERM
+//   → emits 'process:kill:result' back → widget shows feedback
+// ---------------------------------------------------------------------------
+
+import { bus } from './event-bus.ts';
+import { updateProcesses } from './state-manager.ts';
+import { fetchProcessList } from '../services/process.service.ts';
+import type { ResolvedConfig } from '../types/config.types.ts';
+
+interface ProcessManagerHandle {
+  start: () => void;
+  stop: () => void;
+}
+
+export function createProcessManager(config: ResolvedConfig): ProcessManagerHandle {
+  let timer: ReturnType<typeof setInterval> | null = null;
+  let running = false;
+
+  // Listen for kill requests from the UI
+  const unsubKill = bus.on('process:kill:requested', ({ pid }) => {
+    void handleKill(pid);
+  });
+
+  async function tick(): Promise<void> {
+    try {
+      const list = await fetchProcessList(config.maxProcesses);
+      updateProcesses(list);
+      bus.emit('processes:updated', list);
+    } catch (err) {
+      bus.emit('app:error', {
+        source: 'process-manager:poll',
+        error: err instanceof Error ? err : new Error(String(err)),
+      });
+    }
+  }
+
+  async function handleKill(pid: number): Promise<void> {
+    try {
+      process.kill(pid, 'SIGTERM');
+      // Brief delay then trigger a fresh poll so the table updates
+      await new Promise<void>(resolve => setTimeout(resolve, 300));
+      await tick();
+      bus.emit('process:kill:result', { pid, success: true });
+    } catch (err) {
+      bus.emit('process:kill:result', {
+        pid,
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
+  function start(): void {
+    if (running) return;
+    running = true;
+    void tick();
+    timer = setInterval(() => void tick(), config.refreshInterval);
+  }
+
+  function stop(): void {
+    if (!running) return;
+    running = false;
+    unsubKill();
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  return { start, stop };
+}