everything-dev 0.1.2 → 0.1.4

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

@@ -0,0 +1,283 @@
+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

@@ -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;