everything-dev 0.2.0 → 0.3.0

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

@@ -1,5 +1,4 @@
-import { isProcessAliveSync } from "./snapshot";
-import type { PortInfo, Snapshot, SnapshotDiff } from "./types";
+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));
@@ -21,13 +20,7 @@ export const diffSnapshots = (from: Snapshot, to: Snapshot): SnapshotDiff => {
     }
   }
 
-  const orphanedProcesses = from.processes.filter((p) => {
-    const wasInBaseline = fromPids.has(p.pid);
-    const notInAfter = !toPids.has(p.pid);
-    const stillAlive = isProcessAliveSync(p.pid);
-    
-    return wasInBaseline && notInAfter && stillAlive;
-  });
+  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));
@@ -46,6 +39,31 @@ export const diffSnapshots = (from: Snapshot, to: Snapshot): SnapshotDiff => {
   };
 };
 
+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;
 };

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

@@ -172,46 +172,59 @@ const getMemoryInfo = (): Effect.Effect<MemoryInfo, never> =>
   Effect.gen(function* () {
     yield* Effect.logDebug("[darwin] Getting memory info");
 
+    const sysctlMem = yield* execShellSafe(
+      "sysctl -n hw.memsize 2>/dev/null || echo 0"
+    );
+    const total = parseInt(sysctlMem, 10) || 16 * 1024 * 1024 * 1024;
+
+    const pageSizeOutput = yield* execShellSafe(
+      "sysctl -n hw.pagesize 2>/dev/null || echo 16384"
+    );
+    const pageSize = parseInt(pageSizeOutput.trim(), 10) || 16384;
+
     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;
+    let freePages = 0;
+    let activePages = 0;
+    let inactivePages = 0;
+    let wiredPages = 0;
+    let speculativePages = 0;
 
     for (const line of vmStat.split("\n")) {
-      const match = line.match(/^(.+):\s+(\d+)/);
+      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;
+      if (key.includes("Pages free")) freePages = pages;
+      else if (key.includes("Pages active")) activePages = pages;
+      else if (key.includes("Pages inactive")) inactivePages = pages;
+      else if (key.includes("Pages wired")) wiredPages = pages;
+      else if (key.includes("Pages speculative")) speculativePages = pages;
     }
 
-    const sysctlMem = yield* execShellSafe(
-      "sysctl -n hw.memsize 2>/dev/null || echo 0"
-    );
-    const total = parseInt(sysctlMem, 10) || 16 * 1024 * 1024 * 1024;
+    const free = freePages * pageSize;
+    const active = activePages * pageSize;
+    const inactive = inactivePages * pageSize;
+    const wired = wiredPages * pageSize;
+    const speculative = speculativePages * pageSize;
 
     const used = active + inactive + wired + speculative;
 
+    const effectiveFree = free > 0 ? free : Math.max(0, total - used);
+
     const totalMB = (total / 1024 / 1024).toFixed(0);
     const usedMB = (used / 1024 / 1024).toFixed(0);
+    const freeMB = (effectiveFree / 1024 / 1024).toFixed(0);
     yield* Effect.logDebug(
-      `[darwin] Memory: ${usedMB}MB used / ${totalMB}MB total`
+      `[darwin] Memory: ${usedMB}MB used / ${freeMB}MB free / ${totalMB}MB total`
     );
 
     return {
       total,
       used,
-      free: Math.max(0, total - used),
+      free: effectiveFree,
       processRss: 0,
     };
   });

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

@@ -1,204 +1,217 @@
 import { Effect } from "effect";
-import { getConfigPath, getPortsFromConfig, loadConfig } from "../../config";
+import { loadConfig } from "../../config";
 import { PlatformService, withPlatform } from "./platform";
 import type { MonitorConfig, ProcessInfo, Snapshot } from "./types";
 
 export const getPortsToMonitor = (
-  config?: MonitorConfig
+	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])));
-  });
+	Effect.gen(function* () {
+		if (config?.ports && config.ports.length > 0) {
+			yield* Effect.logDebug(
+				`Using configured ports: ${config.ports.join(", ")}`,
+			);
+			return config.ports;
+		}
+
+		// Load config and get ports from runtime config
+		const result = yield* Effect.tryPromise({
+			try: () => loadConfig({ path: config?.configPath }),
+			catch: () => new Error("Config not found"),
+		}).pipe(Effect.catchAll(() => Effect.succeed(null)));
+
+		if (result?.runtime) {
+			const ports = [
+				result.runtime.hostUrl,
+				result.runtime.ui.url,
+				result.runtime.api.url,
+			]
+				.map((url) => {
+					try {
+						return parseInt(new URL(url).port || "0");
+					} catch {
+						return 0;
+					}
+				})
+				.filter((p) => p > 0);
+			return ports;
+		}
+
+		return [3000, 3002, 3014];
+	});
 
 export const getConfigPathSafe = (
-  config?: MonitorConfig
+	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)));
+	Effect.tryPromise({
+		try: async () => {
+			const result = await loadConfig({ path: config?.configPath });
+			return result?.source.path ?? null;
+		},
+		catch: () => new Error("Config not found"),
+	}).pipe(Effect.catchAll(() => Effect.succeed(null)));
 
 export const createSnapshot = (
-  config?: MonitorConfig
+	config?: MonitorConfig,
 ): Effect.Effect<Snapshot, never, PlatformService> =>
-  Effect.gen(function* () {
-    yield* Effect.logInfo("Creating system snapshot");
+	Effect.gen(function* () {
+		yield* Effect.logInfo("Creating system snapshot");
 
-    const platform = yield* PlatformService;
-    const ports = yield* getPortsToMonitor(config);
-    const configPath = yield* getConfigPathSafe(config);
+		const platform = yield* PlatformService;
+		const ports = yield* getPortsToMonitor(config);
+		const configPath = yield* getConfigPathSafe(config);
 
-    yield* Effect.logDebug(`Monitoring ports: ${ports.join(", ")}`);
+		yield* Effect.logDebug(`Monitoring ports: ${ports.join(", ")}`);
 
-    const portInfo = yield* platform.getPortInfo(ports);
-    const boundPorts = Object.values(portInfo).filter(
-      (p) => p.state !== "FREE"
-    );
+		const portInfo = yield* platform.getPortInfo(ports);
+		const boundPorts = Object.values(portInfo).filter(
+			(p) => p.state !== "FREE",
+		);
 
-    yield* Effect.logInfo(`Found ${boundPorts.length} bound ports`);
+		yield* Effect.logInfo(`Found ${boundPorts.length} bound ports`);
 
-    const rootPids = boundPorts
-      .map((p) => p.pid)
-      .filter((pid): pid is number => pid !== null);
+		const rootPids = boundPorts
+			.map((p) => p.pid)
+			.filter((pid): pid is number => pid !== null);
 
-    const processes =
-      rootPids.length > 0 ? yield* platform.getProcessTree(rootPids) : [];
+		const processes =
+			rootPids.length > 0 ? yield* platform.getProcessTree(rootPids) : [];
 
-    yield* Effect.logInfo(`Tracked ${processes.length} processes in tree`);
+		yield* Effect.logInfo(`Tracked ${processes.length} processes in tree`);
 
-    const memory = yield* platform.getMemoryInfo();
+		const memory = yield* platform.getMemoryInfo();
 
-    const totalRss = processes.reduce((sum, p) => sum + p.rss, 0);
-    memory.processRss = totalRss;
+		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`
-    );
+		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,
-    };
+		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()}`
-    );
+		yield* Effect.logInfo(
+			`Snapshot created at ${new Date(snapshot.timestamp).toISOString()}`,
+		);
 
-    return snapshot;
-  });
+		return snapshot;
+	});
 
 export const createSnapshotWithPlatform = (
-  config?: MonitorConfig
+	config?: MonitorConfig,
 ): Effect.Effect<Snapshot> => withPlatform(createSnapshot(config));
 
 export const findProcessesByPattern = (
-  patterns: string[]
+	patterns: string[],
 ): Effect.Effect<ProcessInfo[], never, PlatformService> =>
-  Effect.gen(function* () {
-    yield* Effect.logDebug(
-      `Finding processes matching: ${patterns.join(", ")}`
-    );
+	Effect.gen(function* () {
+		yield* Effect.logDebug(
+			`Finding processes matching: ${patterns.join(", ")}`,
+		);
 
-    const platform = yield* PlatformService;
-    const allProcesses = yield* platform.getAllProcesses();
+		const platform = yield* PlatformService;
+		const allProcesses = yield* platform.getAllProcesses();
 
-    const matched = allProcesses.filter((proc) =>
-      patterns.some((pattern) =>
-        proc.command.toLowerCase().includes(pattern.toLowerCase())
-      )
-    );
+		const matched = allProcesses.filter((proc) =>
+			patterns.some((pattern) =>
+				proc.command.toLowerCase().includes(pattern.toLowerCase()),
+			),
+		);
 
-    yield* Effect.logInfo(
-      `Found ${matched.length} processes matching patterns`
-    );
+		yield* Effect.logInfo(
+			`Found ${matched.length} processes matching patterns`,
+		);
 
-    return matched;
-  });
+		return matched;
+	});
 
 export const findBosProcesses = (): Effect.Effect<
-  ProcessInfo[],
-  never,
-  PlatformService
+	ProcessInfo[],
+	never,
+	PlatformService
 > => {
-  const patterns = ["bun", "rspack", "rsbuild", "esbuild", "webpack", "node"];
-  return findProcessesByPattern(patterns);
+	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;
-  }
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
 };
 
 export const isProcessAlive = (pid: number): Effect.Effect<boolean> =>
-  Effect.sync(() => isProcessAliveSync(pid));
+	Effect.sync(() => isProcessAliveSync(pid));
 
 export const waitForProcessDeath = (
-  pid: number,
-  timeoutMs = 5000
+	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;
-  });
+	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
+	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;
-  });
+	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
+	port: number,
+	timeoutMs = 5000,
 ): Effect.Effect<boolean> => withPlatform(waitForPortFree(port, timeoutMs));