everything-dev 0.1.3 → 0.1.4

package/src/contract.ts

@@ -314,6 +314,84 @@ const DockerStopResultSchema = z.object({
   error: z.string().optional(),
 });
 
+const MonitorOptionsSchema = z.object({
+  ports: z.array(z.number()).optional(),
+  json: z.boolean().default(false),
+  watch: z.boolean().default(false),
+});
+
+const PortInfoSchema = z.object({
+  port: z.number(),
+  pid: z.number().nullable(),
+  command: z.string().nullable(),
+  state: z.enum(["LISTEN", "ESTABLISHED", "TIME_WAIT", "FREE"]),
+  name: z.string().optional(),
+});
+
+const ProcessInfoSchema = z.object({
+  pid: z.number(),
+  ppid: z.number(),
+  command: z.string(),
+  args: z.array(z.string()),
+  rss: z.number(),
+  children: z.array(z.number()),
+  startTime: z.number().optional(),
+});
+
+const MemoryInfoSchema = z.object({
+  total: z.number(),
+  used: z.number(),
+  free: z.number(),
+  processRss: z.number(),
+});
+
+const SnapshotSchema = z.object({
+  timestamp: z.number(),
+  configPath: z.string().nullable(),
+  ports: z.record(z.string(), PortInfoSchema),
+  processes: z.array(ProcessInfoSchema),
+  memory: MemoryInfoSchema,
+  platform: z.string(),
+});
+
+const MonitorResultSchema = z.object({
+  status: z.enum(["snapshot", "watching", "error"]),
+  snapshot: SnapshotSchema.optional(),
+  error: z.string().optional(),
+});
+
+const SessionOptionsSchema = z.object({
+  headless: z.boolean().default(true),
+  timeout: z.number().default(120000),
+  output: z.string().default("./session-report.json"),
+  format: z.enum(["json", "html"]).default("json"),
+  flow: z.enum(["login", "navigation", "custom"]).default("login"),
+  routes: z.array(z.string()).optional(),
+  snapshotInterval: z.number().default(2000),
+});
+
+const SessionSummarySchema = z.object({
+  totalMemoryDeltaMb: z.number(),
+  peakMemoryMb: z.number(),
+  averageMemoryMb: z.number(),
+  processesSpawned: z.number(),
+  processesKilled: z.number(),
+  orphanedProcesses: z.number(),
+  portsUsed: z.array(z.number()),
+  portsLeaked: z.number(),
+  hasLeaks: z.boolean(),
+  eventCount: z.number(),
+  duration: z.number(),
+});
+
+const SessionResultSchema = z.object({
+  status: z.enum(["completed", "leaks_detected", "error", "timeout"]),
+  sessionId: z.string().optional(),
+  reportPath: z.string().optional(),
+  summary: SessionSummarySchema.optional(),
+  error: z.string().optional(),
+});
+
 const DepsUpdateOptionsSchema = z.object({
   category: z.enum(["ui", "api"]).default("ui"),
   packages: z.array(z.string()).optional(),
@@ -460,6 +538,16 @@ export const bosContract = oc.router({
     .route({ method: "POST", path: "/docker/stop" })
     .input(DockerStopOptionsSchema)
     .output(DockerStopResultSchema),
+
+  monitor: oc
+    .route({ method: "GET", path: "/monitor" })
+    .input(MonitorOptionsSchema)
+    .output(MonitorResultSchema),
+
+  session: oc
+    .route({ method: "POST", path: "/session" })
+    .input(SessionOptionsSchema)
+    .output(SessionResultSchema),
 });
 
 export type BosContract = typeof bosContract;
@@ -498,3 +586,9 @@ export type DepsUpdateOptions = z.infer<typeof DepsUpdateOptionsSchema>;
 export type DepsUpdateResult = z.infer<typeof DepsUpdateResultSchema>;
 export type FilesSyncOptions = z.infer<typeof FilesSyncOptionsSchema>;
 export type FilesSyncResult = z.infer<typeof FilesSyncResultSchema>;
+export type MonitorOptions = z.infer<typeof MonitorOptionsSchema>;
+export type MonitorResult = z.infer<typeof MonitorResultSchema>;
+export type MonitorSnapshot = z.infer<typeof SnapshotSchema>;
+export type SessionOptions = z.infer<typeof SessionOptionsSchema>;
+export type SessionResult = z.infer<typeof SessionResultSchema>;
+export type SessionSummary = z.infer<typeof SessionSummarySchema>;

package/src/lib/orchestrator.ts

@@ -12,6 +12,8 @@ import { renderStreamingView } from "../components/streaming-view";
 import type { AppConfig, BosConfig } from "../config";
 import { getProcessConfig, makeDevProcess, type ProcessCallbacks, type ProcessHandle } from "./process";
 
+let activeCleanup: (() => Promise<void>) | null = null;
+
 const LOG_NOISE_PATTERNS = [
   /\[ Federation Runtime \] Version .* from host of shared singleton module/,
   /Executing an Effect versioned \d+\.\d+\.\d+ with a Runtime of version/,
@@ -137,8 +139,11 @@ export const runDevServers = (orchestrator: AppOrchestrator) =>
       if (showLogs) {
         await exportLogs();
       }
+      activeCleanup = null;
     };
 
+    activeCleanup = cleanup;
+
     const useInteractive = orchestrator.interactive ?? isInteractiveSupported();
 
     view = useInteractive
@@ -220,12 +225,18 @@ export const startApp = (orchestrator: AppOrchestrator) => {
     }))
   );
 
+  const handleSignal = async () => {
+    if (activeCleanup) {
+      await activeCleanup();
+    }
+  };
+
   process.on("SIGINT", () => {
-    setTimeout(() => process.exit(0), 500);
+    handleSignal().finally(() => process.exit(0));
   });
 
   process.on("SIGTERM", () => {
-    setTimeout(() => process.exit(0), 500);
+    handleSignal().finally(() => process.exit(0));
   });
 
   BunRuntime.runMain(program);

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

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

@@ -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 "";
+      })
+    )
+  );