everything-dev 0.1.2 → 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/nova.ts

@@ -20,7 +20,7 @@ export interface UploadResult {
 
 export const getNovaConfig = Effect.gen(function* () {
   const accountId = process.env.NOVA_ACCOUNT_ID;
-  const sessionToken = process.env.NOVA_SESSION_TOKEN;
+  const sessionToken = process.env.NOVA_API_KEY;
 
   if (!accountId || !sessionToken) {
     return yield* Effect.fail(
@@ -46,7 +46,7 @@ export function getSecretsGroupId(nearAccount: string): string {
 export const registerSecretsGroup = (
   nova: NovaSdk,
   nearAccount: string,
-  gatewayAccount: string
+  novaAccount: string
 ) =>
   Effect.gen(function* () {
     const groupId = getSecretsGroupId(nearAccount);
@@ -57,8 +57,8 @@ export const registerSecretsGroup = (
     });
 
     yield* Effect.tryPromise({
-      try: () => nova.addGroupMember(groupId, gatewayAccount),
-      catch: (e) => new Error(`Failed to add gateway to NOVA group: ${e}`),
+      try: () => nova.addGroupMember(groupId, novaAccount),
+      catch: (e) => new Error(`Failed to add gateway Nova account to group: ${e}`),
     });
 
     return groupId;
@@ -150,7 +150,7 @@ export function filterSecretsToRequired(
 }
 
 export function hasNovaCredentials(): boolean {
-  return !!(process.env.NOVA_ACCOUNT_ID && process.env.NOVA_SESSION_TOKEN);
+  return !!(process.env.NOVA_ACCOUNT_ID && process.env.NOVA_API_KEY);
 }
 
 function getBosEnvPath(): string {
@@ -182,8 +182,8 @@ export const saveNovaCredentials = (accountId: string, sessionToken: string) =>
       if (trimmed.startsWith("NOVA_ACCOUNT_ID=")) {
         newLines.push(`NOVA_ACCOUNT_ID=${accountId}`);
         foundAccountId = true;
-      } else if (trimmed.startsWith("NOVA_SESSION_TOKEN=")) {
-        newLines.push(`NOVA_SESSION_TOKEN=${sessionToken}`);
+      } else if (trimmed.startsWith("NOVA_API_KEY=")) {
+        newLines.push(`NOVA_API_KEY=${sessionToken}`);
         foundSessionToken = true;
       } else {
         newLines.push(line);
@@ -198,7 +198,7 @@ export const saveNovaCredentials = (accountId: string, sessionToken: string) =>
     }
 
     if (!foundSessionToken) {
-      newLines.push(`NOVA_SESSION_TOKEN=${sessionToken}`);
+      newLines.push(`NOVA_API_KEY=${sessionToken}`);
     }
 
     yield* Effect.tryPromise({
@@ -207,7 +207,7 @@ export const saveNovaCredentials = (accountId: string, sessionToken: string) =>
     });
 
     process.env.NOVA_ACCOUNT_ID = accountId;
-    process.env.NOVA_SESSION_TOKEN = sessionToken;
+    process.env.NOVA_API_KEY = sessionToken;
   });
 
 export const removeNovaCredentials = Effect.gen(function* () {
@@ -226,7 +226,7 @@ export const removeNovaCredentials = Effect.gen(function* () {
   const lines = content.split("\n");
   const newLines = lines.filter((line) => {
     const trimmed = line.trim();
-    return !trimmed.startsWith("NOVA_ACCOUNT_ID=") && !trimmed.startsWith("NOVA_SESSION_TOKEN=");
+    return !trimmed.startsWith("NOVA_ACCOUNT_ID=") && !trimmed.startsWith("NOVA_API_KEY=");
   });
 
   yield* Effect.tryPromise({
@@ -235,7 +235,7 @@ export const removeNovaCredentials = Effect.gen(function* () {
   });
 
   delete process.env.NOVA_ACCOUNT_ID;
-  delete process.env.NOVA_SESSION_TOKEN;
+  delete process.env.NOVA_API_KEY;
 });
 
 export const verifyNovaCredentials = (accountId: string, sessionToken: string) =>

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/process.ts

@@ -117,6 +117,46 @@ const detectStatus = (
   return null;
 };
 
+const killProcessTree = (pid: number) =>
+  Effect.gen(function* () {
+    const killSignal = (signal: NodeJS.Signals) =>
+      Effect.try({
+        try: () => {
+          process.kill(-pid, signal);
+        },
+        catch: () => null,
+      }).pipe(Effect.ignore);
+
+    const killDirect = (signal: NodeJS.Signals) =>
+      Effect.try({
+        try: () => {
+          process.kill(pid, signal);
+        },
+        catch: () => null,
+      }).pipe(Effect.ignore);
+
+    const isRunning = () =>
+      Effect.try({
+        try: () => {
+          process.kill(pid, 0);
+          return true;
+        },
+        catch: () => false,
+      });
+
+    yield* killSignal("SIGTERM");
+    yield* killDirect("SIGTERM");
+
+    yield* Effect.sleep("200 millis");
+
+    const stillRunning = yield* isRunning();
+    if (stillRunning) {
+      yield* killSignal("SIGKILL");
+      yield* killDirect("SIGKILL");
+      yield* Effect.sleep("100 millis");
+    }
+  });
+
 export const spawnDevProcess = (
   config: DevProcess,
   callbacks: ProcessCallbacks
@@ -181,11 +221,16 @@ export const spawnDevProcess = (
       name: config.name,
       pid: proc.pid,
       kill: async () => {
-        proc.kill("SIGTERM");
-        await new Promise((r) => setTimeout(r, 100));
-        try {
-          proc.kill("SIGKILL");
-        } catch { }
+        const pid = proc.pid;
+        if (pid) {
+          await Effect.runPromise(killProcessTree(pid));
+        } else {
+          proc.kill("SIGTERM");
+          await new Promise((r) => setTimeout(r, 100));
+          try {
+            proc.kill("SIGKILL");
+          } catch { }
+        }
       },
       waitForReady: Deferred.await(readyDeferred),
       waitForExit: Effect.gen(function* () {

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