everything-dev 0.1.3 → 0.1.4

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

@@ -0,0 +1,298 @@
+import { Effect, Layer } from "effect";
+import { execShellSafe, powershellSafe } from "../command";
+import type {
+  MemoryInfo,
+  PlatformOperations,
+  PortInfo,
+  ProcessInfo,
+} from "../types";
+import { PlatformService } from "../types";
+
+const getPortInfo = (
+  ports: number[]
+): Effect.Effect<Record<number, PortInfo>, never> =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo(`[windows] 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("netstat -ano -p TCP");
+    if (!output) {
+      yield* Effect.logDebug(
+        "[windows] No netstat output, all ports appear free"
+      );
+      return result;
+    }
+
+    const lines = output.split("\n").filter(Boolean);
+    yield* Effect.logDebug(`[windows] Parsing ${lines.length} netstat lines`);
+
+    for (const line of lines) {
+      if (!line.includes("LISTENING")) continue;
+
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 5) continue;
+
+      const localAddr = parts[1];
+      const portMatch = localAddr.match(/:(\d+)$/);
+      if (!portMatch) continue;
+
+      const port = parseInt(portMatch[1], 10);
+      if (!ports.includes(port)) continue;
+
+      const pid = parseInt(parts[4], 10);
+
+      let command: string | null = null;
+      if (pid) {
+        const cmdOutput = yield* execShellSafe(
+          `wmic process where ProcessId=${pid} get Name /format:list`
+        );
+        const nameMatch = cmdOutput.match(/Name=(.+)/);
+        command = nameMatch ? nameMatch[1].trim() : null;
+      }
+
+      result[port] = {
+        port,
+        pid,
+        command,
+        state: "LISTEN",
+      };
+
+      yield* Effect.logDebug(
+        `[windows] Port :${port} bound to PID ${pid} (${command})`
+      );
+    }
+
+    const boundCount = Object.values(result).filter(
+      (p) => p.state === "LISTEN"
+    ).length;
+    yield* Effect.logInfo(
+      `[windows] Found ${boundCount}/${ports.length} ports in use`
+    );
+
+    return result;
+  });
+
+const getProcessTree = (
+  rootPids: number[]
+): Effect.Effect<ProcessInfo[], never> =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo(
+      `[windows] 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(
+          `wmic process where ProcessId=${pid} get ProcessId,ParentProcessId,WorkingSetSize,Name,CommandLine /format:csv`
+        );
+        const lines = output
+          .split("\n")
+          .filter((l) => l.trim() && !l.startsWith("Node"));
+        if (lines.length === 0) return null;
+
+        const parts = lines[0].split(",");
+        if (parts.length < 5) return null;
+
+        const cmdLine = parts[1] || "";
+        const name = parts[2] || "";
+        const ppid = parseInt(parts[3], 10);
+        const procId = parseInt(parts[4], 10);
+        const rss = parseInt(parts[5], 10) || 0;
+
+        yield* Effect.logDebug(
+          `[windows] Process ${pid}: ${name} (RSS: ${(rss / 1024).toFixed(0)}KB)`
+        );
+
+        return {
+          pid: procId,
+          ppid,
+          command: name,
+          args: cmdLine.split(/\s+/).slice(1),
+          rss,
+          children: [],
+        };
+      });
+
+    const getChildren = (pid: number): Effect.Effect<number[], never> =>
+      Effect.gen(function* () {
+        const output = yield* execShellSafe(
+          `wmic process where ParentProcessId=${pid} get ProcessId /format:list`
+        );
+        const matches = output.match(/ProcessId=(\d+)/g);
+        if (!matches) return [];
+
+        const children = matches.map((m) =>
+          parseInt(m.replace("ProcessId=", ""), 10)
+        );
+
+        if (children.length > 0) {
+          yield* Effect.logDebug(
+            `[windows] 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(
+      `[windows] Process tree contains ${processes.length} processes`
+    );
+
+    return processes;
+  });
+
+const getMemoryInfo = (): Effect.Effect<MemoryInfo, never> =>
+  Effect.gen(function* () {
+    yield* Effect.logDebug("[windows] Getting memory info");
+
+    const script = `
+      $os = Get-CimInstance Win32_OperatingSystem
+      $total = $os.TotalVisibleMemorySize * 1024
+      $free = $os.FreePhysicalMemory * 1024
+      Write-Output "$total,$free"
+    `;
+    const output = yield* powershellSafe(script);
+
+    if (!output) {
+      yield* Effect.logWarning("[windows] Could not get memory info");
+      return { total: 0, used: 0, free: 0, processRss: 0 };
+    }
+
+    const [totalStr, freeStr] = output.split(",");
+    const total = parseInt(totalStr, 10) || 0;
+    const free = parseInt(freeStr, 10) || 0;
+
+    const totalMB = (total / 1024 / 1024).toFixed(0);
+    const usedMB = ((total - free) / 1024 / 1024).toFixed(0);
+    yield* Effect.logDebug(
+      `[windows] Memory: ${usedMB}MB used / ${totalMB}MB total`
+    );
+
+    return {
+      total,
+      used: total - free,
+      free,
+      processRss: 0,
+    };
+  });
+
+const getAllProcesses = (): Effect.Effect<ProcessInfo[], never> =>
+  Effect.gen(function* () {
+    yield* Effect.logDebug("[windows] Getting all processes");
+
+    const processes: ProcessInfo[] = [];
+
+    const output = yield* execShellSafe(
+      "wmic process get ProcessId,ParentProcessId,WorkingSetSize,Name /format:csv"
+    );
+    const lines = output
+      .split("\n")
+      .filter((l) => l.trim() && !l.startsWith("Node"));
+
+    for (const line of lines) {
+      const parts = line.split(",");
+      if (parts.length < 4) continue;
+
+      const name = parts[1] || "";
+      const ppid = parseInt(parts[2], 10);
+      const pid = parseInt(parts[3], 10);
+      const rss = parseInt(parts[4], 10) || 0;
+
+      if (isNaN(pid)) continue;
+
+      processes.push({
+        pid,
+        ppid: isNaN(ppid) ? 0 : ppid,
+        command: name,
+        args: [],
+        rss,
+        children: [],
+      });
+    }
+
+    yield* Effect.logDebug(
+      `[windows] Found ${processes.length} total processes`
+    );
+
+    return processes;
+  });
+
+const findChildProcesses = (pid: number): Effect.Effect<number[], never> =>
+  Effect.gen(function* () {
+    yield* Effect.logDebug(`[windows] 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(
+          `wmic process where ParentProcessId=${parentPid} get ProcessId /format:list`
+        );
+        const matches = output.match(/ProcessId=(\d+)/g);
+        if (!matches) return;
+
+        for (const match of matches) {
+          const childPid = parseInt(match.replace("ProcessId=", ""), 10);
+          if (!isNaN(childPid)) {
+            children.push(childPid);
+            yield* recurse(childPid);
+          }
+        }
+      });
+
+    yield* recurse(pid);
+
+    if (children.length > 0) {
+      yield* Effect.logDebug(
+        `[windows] PID ${pid} has ${children.length} descendants`
+      );
+    }
+
+    return children;
+  });
+
+const windowsOperations: PlatformOperations = {
+  getPortInfo,
+  getProcessTree,
+  getMemoryInfo,
+  getAllProcesses,
+  findChildProcesses,
+};
+
+export const WindowsLayer = Layer.succeed(PlatformService, windowsOperations);

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

@@ -0,0 +1,204 @@
+import { Effect } from "effect";
+import { getConfigPath, getPortsFromConfig, loadConfig } from "../../config";
+import { PlatformService, withPlatform } from "./platform";
+import type { MonitorConfig, ProcessInfo, Snapshot } from "./types";
+
+export const getPortsToMonitor = (
+  config?: MonitorConfig
+): Effect.Effect<number[]> =>
+  Effect.gen(function* () {
+    if (config?.ports && config.ports.length > 0) {
+      yield* Effect.logDebug(
+        `Using configured ports: ${config.ports.join(", ")}`
+      );
+      return config.ports;
+    }
+
+    return yield* Effect.try({
+      try: () => {
+        loadConfig(config?.configPath);
+        const portConfig = getPortsFromConfig();
+        const ports = [portConfig.host, portConfig.ui, portConfig.api].filter(
+          (p) => p > 0
+        );
+        return ports;
+      },
+      catch: () => new Error("Config not found"),
+    }).pipe(Effect.catchAll(() => Effect.succeed([3000, 3002, 3014])));
+  });
+
+export const getConfigPathSafe = (
+  config?: MonitorConfig
+): Effect.Effect<string | null> =>
+  Effect.try({
+    try: () => {
+      loadConfig(config?.configPath);
+      return getConfigPath();
+    },
+    catch: () => new Error("Config not found"),
+  }).pipe(Effect.catchAll(() => Effect.succeed(null)));
+
+export const createSnapshot = (
+  config?: MonitorConfig
+): Effect.Effect<Snapshot, never, PlatformService> =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo("Creating system snapshot");
+
+    const platform = yield* PlatformService;
+    const ports = yield* getPortsToMonitor(config);
+    const configPath = yield* getConfigPathSafe(config);
+
+    yield* Effect.logDebug(`Monitoring ports: ${ports.join(", ")}`);
+
+    const portInfo = yield* platform.getPortInfo(ports);
+    const boundPorts = Object.values(portInfo).filter(
+      (p) => p.state !== "FREE"
+    );
+
+    yield* Effect.logInfo(`Found ${boundPorts.length} bound ports`);
+
+    const rootPids = boundPorts
+      .map((p) => p.pid)
+      .filter((pid): pid is number => pid !== null);
+
+    const processes =
+      rootPids.length > 0 ? yield* platform.getProcessTree(rootPids) : [];
+
+    yield* Effect.logInfo(`Tracked ${processes.length} processes in tree`);
+
+    const memory = yield* platform.getMemoryInfo();
+
+    const totalRss = processes.reduce((sum, p) => sum + p.rss, 0);
+    memory.processRss = totalRss;
+
+    yield* Effect.logDebug(
+      `Total process RSS: ${(totalRss / 1024 / 1024).toFixed(1)}MB`
+    );
+
+    const snapshot: Snapshot = {
+      timestamp: Date.now(),
+      configPath,
+      ports: portInfo,
+      processes,
+      memory,
+      platform: process.platform,
+    };
+
+    yield* Effect.logInfo(
+      `Snapshot created at ${new Date(snapshot.timestamp).toISOString()}`
+    );
+
+    return snapshot;
+  });
+
+export const createSnapshotWithPlatform = (
+  config?: MonitorConfig
+): Effect.Effect<Snapshot> => withPlatform(createSnapshot(config));
+
+export const findProcessesByPattern = (
+  patterns: string[]
+): Effect.Effect<ProcessInfo[], never, PlatformService> =>
+  Effect.gen(function* () {
+    yield* Effect.logDebug(
+      `Finding processes matching: ${patterns.join(", ")}`
+    );
+
+    const platform = yield* PlatformService;
+    const allProcesses = yield* platform.getAllProcesses();
+
+    const matched = allProcesses.filter((proc) =>
+      patterns.some((pattern) =>
+        proc.command.toLowerCase().includes(pattern.toLowerCase())
+      )
+    );
+
+    yield* Effect.logInfo(
+      `Found ${matched.length} processes matching patterns`
+    );
+
+    return matched;
+  });
+
+export const findBosProcesses = (): Effect.Effect<
+  ProcessInfo[],
+  never,
+  PlatformService
+> => {
+  const patterns = ["bun", "rspack", "rsbuild", "esbuild", "webpack", "node"];
+  return findProcessesByPattern(patterns);
+};
+
+export const isProcessAliveSync = (pid: number): boolean => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const isProcessAlive = (pid: number): Effect.Effect<boolean> =>
+  Effect.sync(() => isProcessAliveSync(pid));
+
+export const waitForProcessDeath = (
+  pid: number,
+  timeoutMs = 5000
+): Effect.Effect<boolean> =>
+  Effect.gen(function* () {
+    yield* Effect.logDebug(
+      `Waiting for PID ${pid} to die (timeout: ${timeoutMs}ms)`
+    );
+    const start = Date.now();
+
+    while (Date.now() - start < timeoutMs) {
+      const alive = yield* isProcessAlive(pid);
+      if (!alive) {
+        yield* Effect.logDebug(`PID ${pid} is dead`);
+        return true;
+      }
+      yield* Effect.sleep("100 millis");
+    }
+
+    const finalAlive = yield* isProcessAlive(pid);
+    if (finalAlive) {
+      yield* Effect.logWarning(`PID ${pid} still alive after ${timeoutMs}ms`);
+    }
+    return !finalAlive;
+  });
+
+export const waitForPortFree = (
+  port: number,
+  timeoutMs = 5000
+): Effect.Effect<boolean, never, PlatformService> =>
+  Effect.gen(function* () {
+    yield* Effect.logDebug(
+      `Waiting for port :${port} to be free (timeout: ${timeoutMs}ms)`
+    );
+    const platform = yield* PlatformService;
+    const start = Date.now();
+
+    while (Date.now() - start < timeoutMs) {
+      const portInfo = yield* platform.getPortInfo([port]);
+      if (portInfo[port].state === "FREE") {
+        yield* Effect.logDebug(`Port :${port} is now free`);
+        return true;
+      }
+      yield* Effect.sleep("100 millis");
+    }
+
+    const finalPortInfo = yield* platform.getPortInfo([port]);
+    const isFree = finalPortInfo[port].state === "FREE";
+
+    if (!isFree) {
+      yield* Effect.logWarning(
+        `Port :${port} still bound after ${timeoutMs}ms`
+      );
+    }
+
+    return isFree;
+  });
+
+export const waitForPortFreeWithPlatform = (
+  port: number,
+  timeoutMs = 5000
+): Effect.Effect<boolean> => withPlatform(waitForPortFree(port, timeoutMs));

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

@@ -0,0 +1,74 @@
+import { Context, Effect } from "effect";
+
+export interface PortInfo {
+  port: number;
+  pid: number | null;
+  command: string | null;
+  state: "LISTEN" | "ESTABLISHED" | "TIME_WAIT" | "FREE";
+  name?: string;
+}
+
+export interface ProcessInfo {
+  pid: number;
+  ppid: number;
+  command: string;
+  args: string[];
+  rss: number;
+  children: number[];
+  startTime?: number;
+}
+
+export interface MemoryInfo {
+  total: number;
+  used: number;
+  free: number;
+  processRss: number;
+}
+
+export interface Snapshot {
+  timestamp: number;
+  configPath: string | null;
+  ports: Record<number, PortInfo>;
+  processes: ProcessInfo[];
+  memory: MemoryInfo;
+  platform: NodeJS.Platform;
+}
+
+export interface SnapshotDiff {
+  from: Snapshot;
+  to: Snapshot;
+  orphanedProcesses: ProcessInfo[];
+  stillBoundPorts: PortInfo[];
+  freedPorts: number[];
+  memoryDeltaBytes: number;
+  newProcesses: ProcessInfo[];
+  killedProcesses: ProcessInfo[];
+}
+
+export interface MonitorConfig {
+  ports?: number[];
+  processPatterns?: string[];
+  refreshInterval?: number;
+  configPath?: string;
+}
+
+export interface PlatformOperations {
+  readonly getPortInfo: (
+    ports: number[]
+  ) => Effect.Effect<Record<number, PortInfo>, never>;
+
+  readonly getProcessTree: (
+    rootPids: number[]
+  ) => Effect.Effect<ProcessInfo[], never>;
+
+  readonly getMemoryInfo: () => Effect.Effect<MemoryInfo, never>;
+
+  readonly getAllProcesses: () => Effect.Effect<ProcessInfo[], never>;
+
+  readonly findChildProcesses: (pid: number) => Effect.Effect<number[], never>;
+}
+
+export class PlatformService extends Context.Tag("PlatformService")<
+  PlatformService,
+  PlatformOperations
+>() {}

package/src/lib/session-recorder/errors.ts

@@ -0,0 +1,102 @@
+import { Data } from "effect";
+
+export class SessionTimeout extends Data.TaggedError("SessionTimeout")<{
+  readonly timeoutMs: number;
+  readonly elapsedMs: number;
+}> {
+  get message() {
+    return `Session timed out after ${this.elapsedMs}ms (limit: ${this.timeoutMs}ms)`;
+  }
+}
+
+export class BrowserLaunchFailed extends Data.TaggedError("BrowserLaunchFailed")<{
+  readonly reason: string;
+  readonly headless: boolean;
+}> {
+  get message() {
+    return `Failed to launch browser (headless: ${this.headless}): ${this.reason}`;
+  }
+}
+
+export class ServerStartFailed extends Data.TaggedError("ServerStartFailed")<{
+  readonly server: string;
+  readonly port: number;
+  readonly reason: string;
+}> {
+  get message() {
+    return `Failed to start ${this.server} on port ${this.port}: ${this.reason}`;
+  }
+}
+
+export class ServerNotReady extends Data.TaggedError("ServerNotReady")<{
+  readonly servers: string[];
+  readonly timeoutMs: number;
+}> {
+  get message() {
+    return `Servers not ready after ${this.timeoutMs}ms: ${this.servers.join(", ")}`;
+  }
+}
+
+export class FlowExecutionFailed extends Data.TaggedError("FlowExecutionFailed")<{
+  readonly flowName: string;
+  readonly step: string;
+  readonly reason: string;
+}> {
+  get message() {
+    return `Flow "${this.flowName}" failed at step "${this.step}": ${this.reason}`;
+  }
+}
+
+export class SnapshotFailed extends Data.TaggedError("SnapshotFailed")<{
+  readonly reason: string;
+}> {
+  get message() {
+    return `Failed to capture snapshot: ${this.reason}`;
+  }
+}
+
+export class ExportFailed extends Data.TaggedError("ExportFailed")<{
+  readonly path: string;
+  readonly reason: string;
+}> {
+  get message() {
+    return `Failed to export session to ${this.path}: ${this.reason}`;
+  }
+}
+
+export class BrowserMetricsFailed extends Data.TaggedError("BrowserMetricsFailed")<{
+  readonly reason: string;
+}> {
+  get message() {
+    return `Failed to collect browser metrics: ${this.reason}`;
+  }
+}
+
+export class PopupNotDetected extends Data.TaggedError("PopupNotDetected")<{
+  readonly timeoutMs: number;
+}> {
+  get message() {
+    return `Popup window not detected within ${this.timeoutMs}ms`;
+  }
+}
+
+export class AuthenticationFailed extends Data.TaggedError("AuthenticationFailed")<{
+  readonly step: string;
+  readonly reason: string;
+}> {
+  get message() {
+    return `Authentication failed at "${this.step}": ${this.reason}`;
+  }
+}
+
+export type SessionRecorderError =
+  | SessionTimeout
+  | BrowserLaunchFailed
+  | ServerStartFailed
+  | ServerNotReady
+  | FlowExecutionFailed
+  | SnapshotFailed
+  | ExportFailed
+  | BrowserMetricsFailed
+  | PopupNotDetected
+  | AuthenticationFailed;