everything-dev 0.1.2 → 0.1.4

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,
+};

package/src/lib/resource-monitor/platform/darwin.ts

@@ -0,0 +1,293 @@
+import { Effect, Layer } from "effect";
+import { execShellSafe } from "../command";
+import type {
+  MemoryInfo,
+  PlatformOperations,
+  PortInfo,
+  ProcessInfo,
+} from "../types";
+import { PlatformService } from "../types";
+
+const parseLsofLine = (
+  line: string,
+  ports: number[]
+): { port: number; pid: number; command: string } | null => {
+  const parts = line.split(/\s+/);
+  if (parts.length < 9) return null;
+
+  const command = parts[0];
+  const pid = parseInt(parts[1], 10);
+  const nameCol = parts[8] || parts[7];
+
+  const portMatch = nameCol.match(/:(\d+)$/);
+  if (!portMatch) return null;
+
+  const port = parseInt(portMatch[1], 10);
+  if (!ports.includes(port)) return null;
+
+  return { port, pid, command };
+};
+
+const getPortInfo = (
+  ports: number[]
+): Effect.Effect<Record<number, PortInfo>, never> =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo(`[darwin] Checking ${ports.length} ports`);
+
+    const result: Record<number, PortInfo> = {};
+    for (const port of ports) {
+      result[port] = { port, pid: null, command: null, state: "FREE" };
+    }
+
+    if (ports.length === 0) return result;
+
+    const output = yield* execShellSafe(
+      "lsof -i -P -n -sTCP:LISTEN 2>/dev/null || true"
+    );
+    if (!output) {
+      yield* Effect.logDebug("[darwin] No lsof output, all ports appear free");
+      return result;
+    }
+
+    const lines = output.split("\n").filter(Boolean);
+    yield* Effect.logDebug(`[darwin] Parsing ${lines.length} lsof lines`);
+
+    for (const line of lines.slice(1)) {
+      const parsed = parseLsofLine(line, ports);
+      if (parsed) {
+        result[parsed.port] = {
+          port: parsed.port,
+          pid: parsed.pid,
+          command: parsed.command,
+          state: "LISTEN",
+        };
+        yield* Effect.logDebug(
+          `[darwin] Port :${parsed.port} bound to PID ${parsed.pid} (${parsed.command})`
+        );
+      }
+    }
+
+    const boundCount = Object.values(result).filter(
+      (p) => p.state === "LISTEN"
+    ).length;
+    yield* Effect.logInfo(
+      `[darwin] Found ${boundCount}/${ports.length} ports in use`
+    );
+
+    return result;
+  });
+
+const getProcessTree = (
+  rootPids: number[]
+): Effect.Effect<ProcessInfo[], never> =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo(
+      `[darwin] Building process tree for ${rootPids.length} root PIDs`
+    );
+
+    const processes: ProcessInfo[] = [];
+    const visited = new Set<number>();
+
+    const getProcess = (
+      pid: number
+    ): Effect.Effect<ProcessInfo | null, never> =>
+      Effect.gen(function* () {
+        if (visited.has(pid)) return null;
+        visited.add(pid);
+
+        const output = yield* execShellSafe(
+          `ps -p ${pid} -o pid=,ppid=,rss=,comm=,args= 2>/dev/null || true`
+        );
+        if (!output) return null;
+
+        const parts = output.trim().split(/\s+/);
+        if (parts.length < 4) return null;
+
+        const [pidStr, ppidStr, rssStr, ...rest] = parts;
+        const command = rest[0] || "";
+        const args = rest.slice(1);
+
+        yield* Effect.logDebug(
+          `[darwin] Process ${pid}: ${command} (RSS: ${rssStr}KB)`
+        );
+
+        return {
+          pid: parseInt(pidStr, 10),
+          ppid: parseInt(ppidStr, 10),
+          command,
+          args,
+          rss: parseInt(rssStr, 10) * 1024,
+          children: [],
+        };
+      });
+
+    const getChildren = (pid: number): Effect.Effect<number[], never> =>
+      Effect.gen(function* () {
+        const output = yield* execShellSafe(
+          `pgrep -P ${pid} 2>/dev/null || true`
+        );
+        if (!output) return [];
+
+        const children = output
+          .split("\n")
+          .filter(Boolean)
+          .map((s) => parseInt(s, 10))
+          .filter((n) => !isNaN(n));
+
+        if (children.length > 0) {
+          yield* Effect.logDebug(
+            `[darwin] PID ${pid} has ${children.length} children: ${children.join(", ")}`
+          );
+        }
+
+        return children;
+      });
+
+    const traverse = (pid: number): Effect.Effect<void, never> =>
+      Effect.gen(function* () {
+        const proc = yield* getProcess(pid);
+        if (!proc) return;
+
+        const children = yield* getChildren(pid);
+        proc.children = children;
+        processes.push(proc);
+
+        for (const child of children) {
+          yield* traverse(child);
+        }
+      });
+
+    for (const pid of rootPids) {
+      yield* traverse(pid);
+    }
+
+    yield* Effect.logInfo(
+      `[darwin] Process tree contains ${processes.length} processes`
+    );
+
+    return processes;
+  });
+
+const getMemoryInfo = (): Effect.Effect<MemoryInfo, never> =>
+  Effect.gen(function* () {
+    yield* Effect.logDebug("[darwin] Getting memory info");
+
+    const vmStat = yield* execShellSafe("vm_stat 2>/dev/null || true");
+    const pageSize = 16384;
+
+    let free = 0;
+    let active = 0;
+    let inactive = 0;
+    let wired = 0;
+    let speculative = 0;
+
+    for (const line of vmStat.split("\n")) {
+      const match = line.match(/^(.+):\s+(\d+)/);
+      if (!match) continue;
+
+      const [, key, value] = match;
+      const pages = parseInt(value, 10);
+
+      if (key.includes("free")) free = pages * pageSize;
+      else if (key.includes("active")) active = pages * pageSize;
+      else if (key.includes("inactive")) inactive = pages * pageSize;
+      else if (key.includes("wired")) wired = pages * pageSize;
+      else if (key.includes("speculative")) speculative = pages * pageSize;
+    }
+
+    const sysctlMem = yield* execShellSafe(
+      "sysctl -n hw.memsize 2>/dev/null || echo 0"
+    );
+    const total = parseInt(sysctlMem, 10) || 16 * 1024 * 1024 * 1024;
+
+    const used = active + inactive + wired + speculative;
+
+    const totalMB = (total / 1024 / 1024).toFixed(0);
+    const usedMB = (used / 1024 / 1024).toFixed(0);
+    yield* Effect.logDebug(
+      `[darwin] Memory: ${usedMB}MB used / ${totalMB}MB total`
+    );
+
+    return {
+      total,
+      used,
+      free: total - used,
+      processRss: 0,
+    };
+  });
+
+const getAllProcesses = (): Effect.Effect<ProcessInfo[], never> =>
+  Effect.gen(function* () {
+    yield* Effect.logDebug("[darwin] Getting all processes");
+
+    const processes: ProcessInfo[] = [];
+
+    const output = yield* execShellSafe(
+      "ps -axo pid=,ppid=,rss=,comm= 2>/dev/null || true"
+    );
+    for (const line of output.split("\n").filter(Boolean)) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 4) continue;
+
+      const [pidStr, ppidStr, rssStr, ...rest] = parts;
+      processes.push({
+        pid: parseInt(pidStr, 10),
+        ppid: parseInt(ppidStr, 10),
+        command: rest.join(" "),
+        args: [],
+        rss: parseInt(rssStr, 10) * 1024,
+        children: [],
+      });
+    }
+
+    yield* Effect.logDebug(`[darwin] Found ${processes.length} total processes`);
+
+    return processes;
+  });
+
+const findChildProcesses = (pid: number): Effect.Effect<number[], never> =>
+  Effect.gen(function* () {
+    yield* Effect.logDebug(`[darwin] Finding all children of PID ${pid}`);
+
+    const children: number[] = [];
+    const visited = new Set<number>();
+
+    const recurse = (parentPid: number): Effect.Effect<void, never> =>
+      Effect.gen(function* () {
+        if (visited.has(parentPid)) return;
+        visited.add(parentPid);
+
+        const output = yield* execShellSafe(
+          `pgrep -P ${parentPid} 2>/dev/null || true`
+        );
+        if (!output) return;
+
+        for (const line of output.split("\n").filter(Boolean)) {
+          const childPid = parseInt(line, 10);
+          if (!isNaN(childPid)) {
+            children.push(childPid);
+            yield* recurse(childPid);
+          }
+        }
+      });
+
+    yield* recurse(pid);
+
+    if (children.length > 0) {
+      yield* Effect.logDebug(
+        `[darwin] PID ${pid} has ${children.length} descendants`
+      );
+    }
+
+    return children;
+  });
+
+const darwinOperations: PlatformOperations = {
+  getPortInfo,
+  getProcessTree,
+  getMemoryInfo,
+  getAllProcesses,
+  findChildProcesses,
+};
+
+export const DarwinLayer = Layer.succeed(PlatformService, darwinOperations);

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

@@ -0,0 +1,35 @@
+import { Effect, Layer } from "effect";
+import { PlatformService } from "../types";
+import { DarwinLayer } from "./darwin";
+import { LinuxLayer } from "./linux";
+import { WindowsLayer } from "./windows";
+
+export const makePlatformLayer = (): Layer.Layer<PlatformService> => {
+  const platform = process.platform;
+
+  switch (platform) {
+    case "darwin":
+      return DarwinLayer;
+    case "linux":
+      return LinuxLayer;
+    case "win32":
+      return WindowsLayer;
+    default:
+      console.warn(`Unsupported platform: ${platform}, falling back to linux`);
+      return LinuxLayer;
+  }
+};
+
+export const PlatformLive = makePlatformLayer();
+
+export const withPlatform = <A, E, R>(
+  effect: Effect.Effect<A, E, R | PlatformService>
+): Effect.Effect<A, E, Exclude<R, PlatformService>> =>
+  effect.pipe(Effect.provide(PlatformLive)) as Effect.Effect<
+    A,
+    E,
+    Exclude<R, PlatformService>
+  >;
+
+export { DarwinLayer, LinuxLayer, WindowsLayer };
+export { PlatformService };