everything-dev 0.3.2 → 1.3.2

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

@@ -1,234 +0,0 @@
-import { Effect } from "effect";
-import {
-  MemoryLimitExceeded,
-  MemoryPercentExceeded,
-  OrphanedProcesses,
-  PortStillBound,
-  ProcessesStillAlive,
-  ResourceLeaks,
-} from "./errors";
-import { PlatformService, withPlatform } from "./platform";
-import { isProcessAlive } from "./snapshot";
-import type { Snapshot, SnapshotDiff } from "./types";
-
-export const assertAllPortsFree = (
-  ports: number[]
-): Effect.Effect<void, PortStillBound, PlatformService> =>
-  Effect.gen(function* () {
-    yield* Effect.logInfo(`Asserting ${ports.length} ports are free`);
-
-    const platform = yield* PlatformService;
-    const portInfo = yield* platform.getPortInfo(ports);
-
-    const bound: Array<{
-      port: number;
-      pid: number | null;
-      command: string | null;
-    }> = [];
-
-    for (const [portStr, info] of Object.entries(portInfo)) {
-      if (info.state !== "FREE") {
-        bound.push({
-          port: parseInt(portStr, 10),
-          pid: info.pid,
-          command: info.command,
-        });
-      }
-    }
-
-    if (bound.length > 0) {
-      yield* Effect.logError(`${bound.length} ports still bound:`);
-      for (const p of bound) {
-        yield* Effect.logError(`  :${p.port} ← PID ${p.pid} (${p.command})`);
-      }
-      return yield* Effect.fail(new PortStillBound({ ports: bound }));
-    }
-
-    yield* Effect.logInfo(`All ${ports.length} ports are free ✓`);
-  });
-
-export const assertAllPortsFreeWithPlatform = (
-  ports: number[]
-): Effect.Effect<void, PortStillBound> =>
-  withPlatform(assertAllPortsFree(ports));
-
-export const assertNoOrphanProcesses = (
-  runningSnapshot: Snapshot,
-  afterSnapshot: Snapshot
-): Effect.Effect<void, OrphanedProcesses> =>
-  Effect.gen(function* () {
-    yield* Effect.logInfo("Checking for orphaned processes");
-
-    const runningPids = new Set(runningSnapshot.processes.map((p) => p.pid));
-
-    const orphans: Array<{ pid: number; command: string; rss: number }> = [];
-
-    for (const proc of runningSnapshot.processes) {
-      if (!runningPids.has(proc.pid)) continue;
-
-      const stillInAfter = afterSnapshot.processes.some(
-        (p) => p.pid === proc.pid
-      );
-      if (stillInAfter) continue;
-
-      const alive = yield* isProcessAlive(proc.pid);
-      if (alive) {
-        orphans.push({
-          pid: proc.pid,
-          command: proc.command,
-          rss: proc.rss,
-        });
-      }
-    }
-
-    if (orphans.length > 0) {
-      yield* Effect.logError(`${orphans.length} orphaned processes found:`);
-      for (const p of orphans) {
-        yield* Effect.logError(
-          `  PID ${p.pid}: ${p.command} (${(p.rss / 1024 / 1024).toFixed(1)}MB)`
-        );
-      }
-      return yield* Effect.fail(new OrphanedProcesses({ processes: orphans }));
-    }
-
-    yield* Effect.logInfo("No orphaned processes ✓");
-  });
-
-export const assertMemoryDelta = (
-  baseline: Snapshot,
-  after: Snapshot,
-  options: { maxDeltaMB?: number; maxDeltaPercent?: number }
-): Effect.Effect<void, MemoryLimitExceeded | MemoryPercentExceeded> =>
-  Effect.gen(function* () {
-    yield* Effect.logInfo("Checking memory delta");
-
-    const deltaMB =
-      (after.memory.processRss - baseline.memory.processRss) / 1024 / 1024;
-
-    yield* Effect.logDebug(
-      `Memory delta: ${deltaMB >= 0 ? "+" : ""}${deltaMB.toFixed(1)}MB`
-    );
-
-    if (options.maxDeltaMB !== undefined && deltaMB > options.maxDeltaMB) {
-      yield* Effect.logError(
-        `Memory delta ${deltaMB.toFixed(1)}MB exceeds max ${options.maxDeltaMB}MB`
-      );
-      return yield* Effect.fail(
-        new MemoryLimitExceeded({
-          deltaMB,
-          limitMB: options.maxDeltaMB,
-          baselineRss: baseline.memory.processRss,
-          afterRss: after.memory.processRss,
-        })
-      );
-    }
-
-    if (options.maxDeltaPercent !== undefined && baseline.memory.processRss > 0) {
-      const deltaPercent =
-        ((after.memory.processRss - baseline.memory.processRss) /
-          baseline.memory.processRss) *
-        100;
-
-      yield* Effect.logDebug(
-        `Memory delta: ${deltaPercent >= 0 ? "+" : ""}${deltaPercent.toFixed(1)}%`
-      );
-
-      if (deltaPercent > options.maxDeltaPercent) {
-        yield* Effect.logError(
-          `Memory delta ${deltaPercent.toFixed(1)}% exceeds max ${options.maxDeltaPercent}%`
-        );
-        return yield* Effect.fail(
-          new MemoryPercentExceeded({
-            deltaPercent,
-            limitPercent: options.maxDeltaPercent,
-            baselineRss: baseline.memory.processRss,
-            afterRss: after.memory.processRss,
-          })
-        );
-      }
-    }
-
-    yield* Effect.logInfo("Memory delta within limits ✓");
-  });
-
-export const assertProcessesDead = (
-  pids: number[]
-): Effect.Effect<void, ProcessesStillAlive> =>
-  Effect.gen(function* () {
-    yield* Effect.logInfo(`Asserting ${pids.length} processes are dead`);
-
-    const stillAlive: number[] = [];
-
-    for (const pid of pids) {
-      const alive = yield* isProcessAlive(pid);
-      if (alive) {
-        stillAlive.push(pid);
-      }
-    }
-
-    if (stillAlive.length > 0) {
-      yield* Effect.logError(
-        `${stillAlive.length} processes still alive: ${stillAlive.join(", ")}`
-      );
-      return yield* Effect.fail(new ProcessesStillAlive({ pids: stillAlive }));
-    }
-
-    yield* Effect.logInfo(`All ${pids.length} processes are dead ✓`);
-  });
-
-export const assertNoLeaks = (
-  diff: SnapshotDiff
-): Effect.Effect<void, ResourceLeaks> =>
-  Effect.gen(function* () {
-    yield* Effect.logInfo("Checking for resource leaks");
-
-    if (
-      diff.orphanedProcesses.length > 0 ||
-      diff.stillBoundPorts.length > 0
-    ) {
-      yield* Effect.logError("Resource leaks detected:");
-
-      for (const proc of diff.orphanedProcesses) {
-        yield* Effect.logError(
-          `  Orphaned PID ${proc.pid}: ${proc.command} (${(proc.rss / 1024 / 1024).toFixed(1)}MB)`
-        );
-      }
-
-      for (const port of diff.stillBoundPorts) {
-        yield* Effect.logError(
-          `  Port :${port.port} still bound to PID ${port.pid} (${port.command})`
-        );
-      }
-
-      return yield* Effect.fail(
-        new ResourceLeaks({
-          orphanedProcesses: diff.orphanedProcesses,
-          stillBoundPorts: diff.stillBoundPorts,
-        })
-      );
-    }
-
-    yield* Effect.logInfo("No resource leaks detected ✓");
-  });
-
-export const assertCleanState = (
-  baseline: Snapshot
-): Effect.Effect<void, PortStillBound | ProcessesStillAlive, PlatformService> =>
-  Effect.gen(function* () {
-    yield* Effect.logInfo("Asserting clean state");
-
-    const ports = Object.keys(baseline.ports).map((p) => parseInt(p, 10));
-    yield* assertAllPortsFree(ports);
-
-    const pids = baseline.processes.map((p) => p.pid);
-    if (pids.length > 0) {
-      yield* assertProcessesDead(pids);
-    }
-
-    yield* Effect.logInfo("Clean state verified ✓");
-  });
-
-export const assertCleanStateWithPlatform = (
-  baseline: Snapshot
-): Effect.Effect<void, PortStillBound | ProcessesStillAlive> =>
-  withPlatform(assertCleanState(baseline));

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

@@ -1,283 +0,0 @@
-import { Effect, Schedule } from "effect";
-import { execa } from "execa";
-import { CommandFailed, CommandTimeout } from "./errors";
-
-export interface ExecOptions {
-  cwd?: string;
-  timeout?: number;
-  retries?: number;
-  silent?: boolean;
-}
-
-const DEFAULT_TIMEOUT = 10000;
-const DEFAULT_RETRIES = 1;
-
-export const execCommand = (
-  cmd: string,
-  args: string[],
-  options?: ExecOptions
-): Effect.Effect<string, CommandFailed | CommandTimeout> =>
-  Effect.gen(function* () {
-    const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-    const silent = options?.silent ?? false;
-
-    if (!silent) {
-      yield* Effect.logDebug(`Executing: ${cmd} ${args.join(" ")}`);
-    }
-
-    const result = yield* Effect.tryPromise({
-      try: async () => {
-        const proc = await execa(cmd, args, {
-          cwd: options?.cwd,
-          timeout,
-          reject: false,
-          shell: true,
-        });
-        return {
-          stdout: proc.stdout?.trim() ?? "",
-          stderr: proc.stderr?.trim() ?? "",
-          exitCode: proc.exitCode,
-          timedOut: proc.timedOut,
-        };
-      },
-      catch: (error) => {
-        const err = error as { timedOut?: boolean; message?: string };
-        if (err.timedOut) {
-          return new CommandTimeout({ command: cmd, timeoutMs: timeout });
-        }
-        return new CommandFailed({
-          command: cmd,
-          args,
-          exitCode: -1,
-          stderr: String(error),
-        });
-      },
-    });
-
-    if (result.timedOut) {
-      return yield* Effect.fail(
-        new CommandTimeout({ command: cmd, timeoutMs: timeout })
-      );
-    }
-
-    if (result.exitCode !== 0) {
-      if (!silent) {
-        yield* Effect.logWarning(
-          `Command failed: ${cmd} (exit ${result.exitCode})`
-        );
-      }
-      return yield* Effect.fail(
-        new CommandFailed({
-          command: cmd,
-          args,
-          exitCode: result.exitCode ?? 1,
-          stderr: result.stderr,
-        })
-      );
-    }
-
-    if (!silent) {
-      yield* Effect.logDebug(`Command succeeded: ${cmd}`);
-    }
-
-    return result.stdout;
-  }).pipe(
-    Effect.retry(
-      Schedule.recurs(options?.retries ?? DEFAULT_RETRIES).pipe(
-        Schedule.addDelay(() => "100 millis")
-      )
-    ),
-    Effect.catchAll((error) => Effect.fail(error))
-  );
-
-export const execCommandSafe = (
-  cmd: string,
-  args: string[],
-  options?: ExecOptions
-): Effect.Effect<string, never> =>
-  execCommand(cmd, args, options).pipe(
-    Effect.catchAll((error) =>
-      Effect.gen(function* () {
-        yield* Effect.logWarning(`Command failed (graceful): ${error.message}`);
-        return "";
-      })
-    )
-  );
-
-export const execShell = (
-  script: string,
-  options?: ExecOptions
-): Effect.Effect<string, CommandFailed | CommandTimeout> =>
-  Effect.gen(function* () {
-    const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-    const silent = options?.silent ?? false;
-
-    if (!silent) {
-      yield* Effect.logDebug(`Executing shell: ${script.slice(0, 50)}...`);
-    }
-
-    const result = yield* Effect.tryPromise({
-      try: async () => {
-        const proc = await execa(script, {
-          cwd: options?.cwd,
-          timeout,
-          reject: false,
-          shell: true,
-        });
-        return {
-          stdout: proc.stdout?.trim() ?? "",
-          stderr: proc.stderr?.trim() ?? "",
-          exitCode: proc.exitCode,
-          timedOut: proc.timedOut,
-        };
-      },
-      catch: (error) => {
-        const err = error as { timedOut?: boolean; message?: string };
-        if (err.timedOut) {
-          return new CommandTimeout({ command: script, timeoutMs: timeout });
-        }
-        return new CommandFailed({
-          command: script,
-          args: [],
-          exitCode: -1,
-          stderr: String(error),
-        });
-      },
-    });
-
-    if (result.timedOut) {
-      return yield* Effect.fail(
-        new CommandTimeout({ command: script, timeoutMs: timeout })
-      );
-    }
-
-    if (result.exitCode !== 0) {
-      if (!silent) {
-        yield* Effect.logWarning(
-          `Shell command failed (exit ${result.exitCode})`
-        );
-      }
-      return yield* Effect.fail(
-        new CommandFailed({
-          command: script,
-          args: [],
-          exitCode: result.exitCode ?? 1,
-          stderr: result.stderr,
-        })
-      );
-    }
-
-    return result.stdout;
-  }).pipe(
-    Effect.retry(
-      Schedule.recurs(options?.retries ?? DEFAULT_RETRIES).pipe(
-        Schedule.addDelay(() => "100 millis")
-      )
-    ),
-    Effect.catchAll((error) => Effect.fail(error))
-  );
-
-export const execShellSafe = (
-  script: string,
-  options?: ExecOptions
-): Effect.Effect<string, never> =>
-  execShell(script, options).pipe(
-    Effect.catchAll((error) =>
-      Effect.gen(function* () {
-        yield* Effect.logWarning(
-          `Shell command failed (graceful): ${error.message}`
-        );
-        return "";
-      })
-    )
-  );
-
-export const powershell = (
-  script: string,
-  options?: ExecOptions
-): Effect.Effect<string, CommandFailed | CommandTimeout> =>
-  Effect.gen(function* () {
-    const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-    const silent = options?.silent ?? false;
-
-    if (!silent) {
-      yield* Effect.logDebug(`Executing PowerShell: ${script.slice(0, 50)}...`);
-    }
-
-    const result = yield* Effect.tryPromise({
-      try: async () => {
-        const proc = await execa("powershell", ["-NoProfile", "-Command", script], {
-          cwd: options?.cwd,
-          timeout,
-          reject: false,
-        });
-        return {
-          stdout: proc.stdout?.trim() ?? "",
-          stderr: proc.stderr?.trim() ?? "",
-          exitCode: proc.exitCode,
-          timedOut: proc.timedOut,
-        };
-      },
-      catch: (error) => {
-        const err = error as { timedOut?: boolean; message?: string };
-        if (err.timedOut) {
-          return new CommandTimeout({
-            command: "powershell",
-            timeoutMs: timeout,
-          });
-        }
-        return new CommandFailed({
-          command: "powershell",
-          args: [script],
-          exitCode: -1,
-          stderr: String(error),
-        });
-      },
-    });
-
-    if (result.timedOut) {
-      return yield* Effect.fail(
-        new CommandTimeout({ command: "powershell", timeoutMs: timeout })
-      );
-    }
-
-    if (result.exitCode !== 0) {
-      if (!silent) {
-        yield* Effect.logWarning(
-          `PowerShell command failed (exit ${result.exitCode})`
-        );
-      }
-      return yield* Effect.fail(
-        new CommandFailed({
-          command: "powershell",
-          args: [script],
-          exitCode: result.exitCode ?? 1,
-          stderr: result.stderr,
-        })
-      );
-    }
-
-    return result.stdout;
-  }).pipe(
-    Effect.retry(
-      Schedule.recurs(options?.retries ?? DEFAULT_RETRIES).pipe(
-        Schedule.addDelay(() => "100 millis")
-      )
-    ),
-    Effect.catchAll((error) => Effect.fail(error))
-  );
-
-export const powershellSafe = (
-  script: string,
-  options?: ExecOptions
-): Effect.Effect<string, never> =>
-  powershell(script, options).pipe(
-    Effect.catchAll((error) =>
-      Effect.gen(function* () {
-        yield* Effect.logWarning(
-          `PowerShell command failed (graceful): ${error.message}`
-        );
-        return "";
-      })
-    )
-  );

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

@@ -1,157 +0,0 @@
-import type { PortInfo, ProcessInfo, 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 orphanedProcesses = findOrphanedProcesses(from, to, fromPids, toPids);
-
-  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,
-  };
-};
-
-const findOrphanedProcesses = (
-  from: Snapshot,
-  to: Snapshot,
-  fromPids: Set<number>,
-  toPids: Set<number>
-): ProcessInfo[] => {
-  const orphaned: ProcessInfo[] = [];
-
-  for (const toProc of to.processes) {
-    const parentPid = toProc.ppid;
-    
-    if (parentPid <= 1) continue;
-
-    const parentWasTracked = fromPids.has(parentPid);
-    const parentIsGone = !toPids.has(parentPid);
-    const childStillAlive = toPids.has(toProc.pid);
-
-    if (parentWasTracked && parentIsGone && childStillAlive) {
-      orphaned.push(toProc);
-    }
-  }
-
-  return orphaned;
-};
-
-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");
-};