everything-dev 0.1.3 → 0.1.4

package/src/lib/resource-monitor/diff.ts

@@ -0,0 +1,143 @@
+import { isProcessAliveSync } from "./snapshot";
+import type { PortInfo, Snapshot, SnapshotDiff } from "./types";
+
+export const diffSnapshots = (from: Snapshot, to: Snapshot): SnapshotDiff => {
+  const fromPids = new Set(from.processes.map((p) => p.pid));
+  const toPids = new Set(to.processes.map((p) => p.pid));
+
+  const stillBoundPorts: PortInfo[] = [];
+  const freedPorts: number[] = [];
+
+  for (const [portStr, fromPort] of Object.entries(from.ports)) {
+    const port = parseInt(portStr, 10);
+    const toPort = to.ports[port];
+
+    if (fromPort.state === "LISTEN") {
+      if (toPort?.state === "LISTEN") {
+        stillBoundPorts.push(toPort);
+      } else {
+        freedPorts.push(port);
+      }
+    }
+  }
+
+  const stillBoundPids = new Set(
+    stillBoundPorts.map((p) => p.pid).filter((pid): pid is number => pid !== null)
+  );
+
+  const orphanedProcesses = from.processes.filter(
+    (p) =>
+      fromPids.has(p.pid) &&
+      !toPids.has(p.pid) &&
+      isProcessAliveSync(p.pid) &&
+      stillBoundPids.has(p.pid)
+  );
+
+  const newProcesses = to.processes.filter((p) => !fromPids.has(p.pid));
+  const killedProcesses = from.processes.filter((p) => !toPids.has(p.pid));
+
+  const memoryDeltaBytes = to.memory.processRss - from.memory.processRss;
+
+  return {
+    from,
+    to,
+    orphanedProcesses,
+    stillBoundPorts,
+    freedPorts,
+    memoryDeltaBytes,
+    newProcesses,
+    killedProcesses,
+  };
+};
+
+export const hasLeaks = (diff: SnapshotDiff): boolean => {
+  return diff.orphanedProcesses.length > 0 || diff.stillBoundPorts.length > 0;
+};
+
+export const formatDiff = (diff: SnapshotDiff): string => {
+  const lines: string[] = [];
+  const elapsed = diff.to.timestamp - diff.from.timestamp;
+
+  lines.push(`Snapshot Diff (${elapsed}ms elapsed)`);
+  lines.push("─".repeat(50));
+
+  if (diff.stillBoundPorts.length > 0) {
+    lines.push("");
+    lines.push("⚠️  STILL BOUND PORTS:");
+    for (const port of diff.stillBoundPorts) {
+      lines.push(`   :${port.port} ← PID ${port.pid} (${port.command})`);
+    }
+  }
+
+  if (diff.orphanedProcesses.length > 0) {
+    lines.push("");
+    lines.push("⚠️  ORPHANED PROCESSES:");
+    for (const proc of diff.orphanedProcesses) {
+      const mb = (proc.rss / 1024 / 1024).toFixed(1);
+      lines.push(`   PID ${proc.pid}: ${proc.command} (${mb} MB)`);
+    }
+  }
+
+  if (diff.freedPorts.length > 0) {
+    lines.push("");
+    lines.push("✓  FREED PORTS:");
+    lines.push(`   ${diff.freedPorts.join(", ")}`);
+  }
+
+  if (diff.killedProcesses.length > 0) {
+    lines.push("");
+    lines.push("✓  KILLED PROCESSES:");
+    for (const proc of diff.killedProcesses) {
+      lines.push(`   PID ${proc.pid}: ${proc.command}`);
+    }
+  }
+
+  lines.push("");
+  const memDeltaMb = (diff.memoryDeltaBytes / 1024 / 1024).toFixed(1);
+  const sign = diff.memoryDeltaBytes >= 0 ? "+" : "";
+  lines.push(`Memory Delta: ${sign}${memDeltaMb} MB`);
+
+  if (!hasLeaks(diff)) {
+    lines.push("");
+    lines.push("✅ No resource leaks detected");
+  }
+
+  return lines.join("\n");
+};
+
+export const formatSnapshotSummary = (snapshot: Snapshot): string => {
+  const lines: string[] = [];
+
+  lines.push(`Snapshot at ${new Date(snapshot.timestamp).toISOString()}`);
+  lines.push(`Platform: ${snapshot.platform}`);
+  if (snapshot.configPath) {
+    lines.push(`Config: ${snapshot.configPath}`);
+  }
+  lines.push("");
+
+  lines.push("PORTS:");
+  for (const [port, info] of Object.entries(snapshot.ports)) {
+    if (info.state === "FREE") {
+      lines.push(`  :${port} ○ free`);
+    } else {
+      lines.push(`  :${port} ● PID ${info.pid} (${info.command})`);
+    }
+  }
+
+  if (snapshot.processes.length > 0) {
+    lines.push("");
+    lines.push("PROCESS TREE:");
+    for (const proc of snapshot.processes) {
+      const mb = (proc.rss / 1024 / 1024).toFixed(1);
+      const childCount = proc.children.length;
+      const childText = childCount > 0 ? ` [${childCount} children]` : "";
+      lines.push(`  ${proc.pid} ${proc.command} (${mb} MB)${childText}`);
+    }
+  }
+
+  lines.push("");
+  const totalMb = (snapshot.memory.processRss / 1024 / 1024).toFixed(1);
+  lines.push(`Total Process RSS: ${totalMb} MB`);
+
+  return lines.join("\n");
+};

package/src/lib/resource-monitor/errors.ts

@@ -0,0 +1,127 @@
+import { Data } from "effect";
+import type { PortInfo, ProcessInfo } from "./types";
+
+export class CommandFailed extends Data.TaggedError("CommandFailed")<{
+  readonly command: string;
+  readonly args: string[];
+  readonly exitCode: number;
+  readonly stderr: string;
+}> {
+  get message() {
+    return `Command '${this.command} ${this.args.join(" ")}' failed with exit code ${this.exitCode}: ${this.stderr}`;
+  }
+}
+
+export class CommandTimeout extends Data.TaggedError("CommandTimeout")<{
+  readonly command: string;
+  readonly timeoutMs: number;
+}> {
+  get message() {
+    return `Command '${this.command}' timed out after ${this.timeoutMs}ms`;
+  }
+}
+
+export class ParseError extends Data.TaggedError("ParseError")<{
+  readonly source: string;
+  readonly raw: string;
+  readonly reason: string;
+}> {
+  get message() {
+    return `Failed to parse ${this.source}: ${this.reason}`;
+  }
+}
+
+export class PortStillBound extends Data.TaggedError("PortStillBound")<{
+  readonly ports: Array<{ port: number; pid: number | null; command: string | null }>;
+}> {
+  get message() {
+    const portList = this.ports.map((p) => `:${p.port} (PID ${p.pid})`).join(", ");
+    return `Expected ports to be free, but still bound: ${portList}`;
+  }
+}
+
+export class OrphanedProcesses extends Data.TaggedError("OrphanedProcesses")<{
+  readonly processes: Array<{ pid: number; command: string; rss: number }>;
+}> {
+  get message() {
+    return `Found ${this.processes.length} orphaned processes still running`;
+  }
+}
+
+export class MemoryLimitExceeded extends Data.TaggedError("MemoryLimitExceeded")<{
+  readonly deltaMB: number;
+  readonly limitMB: number;
+  readonly baselineRss: number;
+  readonly afterRss: number;
+}> {
+  get message() {
+    return `Memory delta ${this.deltaMB.toFixed(1)} MB exceeds limit ${this.limitMB} MB`;
+  }
+}
+
+export class MemoryPercentExceeded extends Data.TaggedError("MemoryPercentExceeded")<{
+  readonly deltaPercent: number;
+  readonly limitPercent: number;
+  readonly baselineRss: number;
+  readonly afterRss: number;
+}> {
+  get message() {
+    return `Memory delta ${this.deltaPercent.toFixed(1)}% exceeds limit ${this.limitPercent}%`;
+  }
+}
+
+export class ProcessesStillAlive extends Data.TaggedError("ProcessesStillAlive")<{
+  readonly pids: number[];
+}> {
+  get message() {
+    return `Expected processes to be dead, but ${this.pids.length} still alive: ${this.pids.join(", ")}`;
+  }
+}
+
+export class ResourceLeaks extends Data.TaggedError("ResourceLeaks")<{
+  readonly orphanedProcesses: ProcessInfo[];
+  readonly stillBoundPorts: PortInfo[];
+}> {
+  get message() {
+    const parts: string[] = [];
+    if (this.orphanedProcesses.length > 0) {
+      parts.push(`${this.orphanedProcesses.length} orphaned processes`);
+    }
+    if (this.stillBoundPorts.length > 0) {
+      parts.push(`${this.stillBoundPorts.length} ports still bound`);
+    }
+    return `Resource leaks detected: ${parts.join(", ")}`;
+  }
+}
+
+export class ConfigNotFound extends Data.TaggedError("ConfigNotFound")<{
+  readonly path: string | undefined;
+}> {
+  get message() {
+    return this.path
+      ? `Config not found at ${this.path}`
+      : `No bos.config.json found in project`;
+  }
+}
+
+export class FileReadError extends Data.TaggedError("FileReadError")<{
+  readonly path: string;
+  readonly reason: string;
+}> {
+  get message() {
+    return `Failed to read ${this.path}: ${this.reason}`;
+  }
+}
+
+export type MonitorError =
+  | CommandFailed
+  | CommandTimeout
+  | ParseError
+  | PortStillBound
+  | OrphanedProcesses
+  | MemoryLimitExceeded
+  | MemoryPercentExceeded
+  | ProcessesStillAlive
+  | ResourceLeaks
+  | ConfigNotFound
+  | FileReadError;

package/src/lib/resource-monitor/index.ts

@@ -0,0 +1,305 @@
+import { writeFile } from "node:fs/promises";
+import { Effect, Logger, LogLevel } from "effect";
+import {
+  assertAllPortsFree,
+  assertAllPortsFreeWithPlatform,
+  assertCleanState,
+  assertCleanStateWithPlatform,
+  assertMemoryDelta,
+  assertNoLeaks,
+  assertNoOrphanProcesses,
+  assertProcessesDead,
+} from "./assertions";
+import { diffSnapshots, formatDiff, formatSnapshotSummary, hasLeaks } from "./diff";
+import {
+  MemoryLimitExceeded,
+  MemoryPercentExceeded,
+  OrphanedProcesses,
+  PortStillBound,
+  ProcessesStillAlive,
+  ResourceLeaks,
+} from "./errors";
+import { PlatformLive, PlatformService, withPlatform } from "./platform";
+import {
+  createSnapshot,
+  createSnapshotWithPlatform,
+  findBosProcesses,
+  isProcessAlive,
+  isProcessAliveSync,
+  waitForPortFree,
+  waitForPortFreeWithPlatform,
+  waitForProcessDeath,
+} from "./snapshot";
+import type {
+  MemoryInfo,
+  MonitorConfig,
+  PortInfo,
+  ProcessInfo,
+  Snapshot,
+  SnapshotDiff,
+} from "./types";
+
+export class ResourceMonitor {
+  private config: MonitorConfig;
+  private baseline: Snapshot | null = null;
+  private snapshots: Snapshot[] = [];
+
+  private constructor(config: MonitorConfig) {
+    this.config = config;
+  }
+
+  static create = (
+    config?: MonitorConfig
+  ): Effect.Effect<ResourceMonitor, never, PlatformService> =>
+    Effect.gen(function* () {
+      yield* Effect.logInfo("Creating ResourceMonitor instance");
+      return new ResourceMonitor(config || {});
+    });
+
+  static createWithPlatform = (
+    config?: MonitorConfig
+  ): Effect.Effect<ResourceMonitor> =>
+    withPlatform(ResourceMonitor.create(config));
+
+  snapshot(): Effect.Effect<Snapshot, never, PlatformService> {
+    const self = this;
+    return Effect.gen(function* () {
+      const snap = yield* createSnapshot(self.config);
+      self.snapshots.push(snap);
+      return snap;
+    });
+  }
+
+  snapshotWithPlatform(): Effect.Effect<Snapshot> {
+    return withPlatform(this.snapshot());
+  }
+
+  setBaseline(): Effect.Effect<Snapshot, never, PlatformService> {
+    const self = this;
+    return Effect.gen(function* () {
+      yield* Effect.logInfo("Setting baseline snapshot");
+      self.baseline = yield* self.snapshot();
+      return self.baseline;
+    });
+  }
+
+  setBaselineWithPlatform(): Effect.Effect<Snapshot> {
+    return withPlatform(this.setBaseline());
+  }
+
+  getBaseline(): Effect.Effect<Snapshot | null> {
+    return Effect.succeed(this.baseline);
+  }
+
+  clearBaseline(): Effect.Effect<void> {
+    return Effect.sync(() => {
+      this.baseline = null;
+    });
+  }
+
+  getSnapshots(): Effect.Effect<Snapshot[]> {
+    return Effect.succeed([...this.snapshots]);
+  }
+
+  clearSnapshots(): Effect.Effect<void> {
+    return Effect.sync(() => {
+      this.snapshots = [];
+    });
+  }
+
+  diff(from: Snapshot, to: Snapshot): Effect.Effect<SnapshotDiff> {
+    return Effect.sync(() => diffSnapshots(from, to));
+  }
+
+  diffFromBaseline(to: Snapshot): Effect.Effect<SnapshotDiff | null> {
+    return Effect.sync(() => {
+      if (!this.baseline) return null;
+      return diffSnapshots(this.baseline, to);
+    });
+  }
+
+  hasLeaks(diff: SnapshotDiff): Effect.Effect<boolean> {
+    return Effect.sync(() => hasLeaks(diff));
+  }
+
+  assertAllPortsFree(
+    ports?: number[]
+  ): Effect.Effect<void, PortStillBound, PlatformService> {
+    const portsToCheck =
+      ports ||
+      Object.keys(this.baseline?.ports || {}).map((p) => parseInt(p, 10));
+    return assertAllPortsFree(portsToCheck);
+  }
+
+  assertAllPortsFreeWithPlatform(
+    ports?: number[]
+  ): Effect.Effect<void, PortStillBound> {
+    const portsToCheck =
+      ports ||
+      Object.keys(this.baseline?.ports || {}).map((p) => parseInt(p, 10));
+    return assertAllPortsFreeWithPlatform(portsToCheck);
+  }
+
+  assertNoOrphanProcesses(
+    running: Snapshot,
+    after: Snapshot
+  ): Effect.Effect<void, OrphanedProcesses> {
+    return assertNoOrphanProcesses(running, after);
+  }
+
+  assertMemoryDelta(
+    baseline: Snapshot,
+    after: Snapshot,
+    options: { maxDeltaMB?: number; maxDeltaPercent?: number }
+  ): Effect.Effect<void, MemoryLimitExceeded | MemoryPercentExceeded> {
+    return assertMemoryDelta(baseline, after, options);
+  }
+
+  assertProcessesDead(pids: number[]): Effect.Effect<void, ProcessesStillAlive> {
+    return assertProcessesDead(pids);
+  }
+
+  assertNoLeaks(diff: SnapshotDiff): Effect.Effect<void, ResourceLeaks> {
+    return assertNoLeaks(diff);
+  }
+
+  assertCleanState(
+    running: Snapshot
+  ): Effect.Effect<void, PortStillBound | ProcessesStillAlive, PlatformService> {
+    return assertCleanState(running);
+  }
+
+  assertCleanStateWithPlatform(
+    running: Snapshot
+  ): Effect.Effect<void, PortStillBound | ProcessesStillAlive> {
+    return assertCleanStateWithPlatform(running);
+  }
+
+  waitForPortFree(
+    port: number,
+    timeoutMs?: number
+  ): Effect.Effect<boolean, never, PlatformService> {
+    return waitForPortFree(port, timeoutMs);
+  }
+
+  waitForPortFreeWithPlatform(
+    port: number,
+    timeoutMs?: number
+  ): Effect.Effect<boolean> {
+    return waitForPortFreeWithPlatform(port, timeoutMs);
+  }
+
+  waitForProcessDeath(pid: number, timeoutMs?: number): Effect.Effect<boolean> {
+    return waitForProcessDeath(pid, timeoutMs);
+  }
+
+  formatSnapshot(snapshot: Snapshot): Effect.Effect<string> {
+    return Effect.sync(() => formatSnapshotSummary(snapshot));
+  }
+
+  formatDiff(diff: SnapshotDiff): Effect.Effect<string> {
+    return Effect.sync(() => formatDiff(diff));
+  }
+
+  export(filepath: string): Effect.Effect<void> {
+    const self = this;
+    return Effect.gen(function* () {
+      yield* Effect.logInfo(`Exporting monitor data to ${filepath}`);
+
+      const data = {
+        config: self.config,
+        baseline: self.baseline,
+        snapshots: self.snapshots,
+        exportedAt: new Date().toISOString(),
+        platform: process.platform,
+      };
+
+      yield* Effect.tryPromise({
+        try: () => writeFile(filepath, JSON.stringify(data, null, 2)),
+        catch: (e) => new Error(`Failed to export: ${e}`),
+      });
+
+      yield* Effect.logInfo(`Exported ${self.snapshots.length} snapshots`);
+    }).pipe(Effect.catchAll(() => Effect.void));
+  }
+
+  toJSON(): Effect.Effect<{
+    config: MonitorConfig;
+    baseline: Snapshot | null;
+    snapshots: Snapshot[];
+  }> {
+    return Effect.succeed({
+      config: this.config,
+      baseline: this.baseline,
+      snapshots: this.snapshots,
+    });
+  }
+}
+
+export const runWithLogging = <A, E>(
+  effect: Effect.Effect<A, E, PlatformService>
+): Promise<A> =>
+  effect.pipe(
+    Effect.provide(PlatformLive),
+    Logger.withMinimumLogLevel(LogLevel.Debug),
+    Effect.runPromise
+  );
+
+export const runWithInfo = <A, E>(
+  effect: Effect.Effect<A, E, PlatformService>
+): Promise<A> =>
+  effect.pipe(
+    Effect.provide(PlatformLive),
+    Logger.withMinimumLogLevel(LogLevel.Info),
+    Effect.runPromise
+  );
+
+export const runSilent = <A, E>(
+  effect: Effect.Effect<A, E, PlatformService>
+): Promise<A> =>
+  effect.pipe(
+    Effect.provide(PlatformLive),
+    Logger.withMinimumLogLevel(LogLevel.Error),
+    Effect.runPromise
+  );
+
+export {
+  assertAllPortsFree,
+  assertAllPortsFreeWithPlatform,
+  assertCleanState,
+  assertCleanStateWithPlatform,
+  assertMemoryDelta,
+  assertNoLeaks,
+  assertNoOrphanProcesses,
+  assertProcessesDead,
+  createSnapshot,
+  createSnapshotWithPlatform,
+  diffSnapshots,
+  findBosProcesses,
+  formatDiff,
+  formatSnapshotSummary,
+  hasLeaks,
+  isProcessAlive,
+  isProcessAliveSync,
+  MemoryLimitExceeded,
+  MemoryPercentExceeded,
+  OrphanedProcesses,
+  PlatformLive,
+  PlatformService,
+  PortStillBound,
+  ProcessesStillAlive,
+  ResourceLeaks,
+  waitForPortFree,
+  waitForPortFreeWithPlatform,
+  waitForProcessDeath,
+  withPlatform,
+};
+
+export type {
+  MemoryInfo,
+  MonitorConfig,
+  PortInfo,
+  ProcessInfo,
+  Snapshot,
+  SnapshotDiff,
+};