everything-dev 0.1.3 → 0.1.4

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

@@ -0,0 +1,267 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Effect } from "effect";
+import {
+  createSnapshotWithPlatform,
+  runSilent,
+} from "../resource-monitor";
+import { ServerNotReady, ServerStartFailed } from "./errors";
+import type { ServerHandle, ServerOrchestrator } from "./types";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_DIR = resolve(__dirname, "../../..");
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+interface SpawnOptions {
+  port?: number;
+  account?: string;
+  domain?: string;
+  interactive?: boolean;
+}
+
+const createServerHandle = (
+  proc: ReturnType<typeof spawn>,
+  name: string,
+  port: number
+): ServerHandle => {
+  proc.stdout?.on("data", () => {});
+  proc.stderr?.on("data", () => {});
+
+  let exitHandled = false;
+  let exitCode: number | null = null;
+  const exitPromise = new Promise<number | null>((resolve) => {
+    (proc as unknown as NodeJS.EventEmitter).on("exit", (code: number | null) => {
+      exitHandled = true;
+      exitCode = code;
+      resolve(code);
+    });
+  });
+
+  return {
+    pid: proc.pid!,
+    port,
+    name,
+    kill: async () => {
+      proc.kill("SIGTERM");
+      const killPromise = new Promise<void>((res) => {
+        const timeout = setTimeout(() => {
+          proc.kill("SIGKILL");
+          res();
+        }, 5000);
+        if (exitHandled) {
+          clearTimeout(timeout);
+          res();
+        } else {
+          exitPromise.then(() => {
+            clearTimeout(timeout);
+            res();
+          });
+        }
+      });
+      await killPromise;
+    },
+    waitForExit: (timeoutMs = 10000): Promise<number | null> =>
+      new Promise((res) => {
+        const timeout = setTimeout(() => res(null), timeoutMs);
+        if (exitHandled) {
+          clearTimeout(timeout);
+          res(exitCode);
+        } else {
+          exitPromise.then((code) => {
+            clearTimeout(timeout);
+            res(code);
+          });
+        }
+      }),
+  };
+};
+
+const spawnBosStart = (options: SpawnOptions = {}): ServerHandle => {
+  const args = [
+    "run",
+    "src/cli.ts",
+    "start",
+    "--account", options.account || "every.near",
+    "--domain", options.domain || "everything.dev",
+  ];
+
+  if (!options.interactive) {
+    args.push("--no-interactive");
+  }
+
+  if (options.port) {
+    args.push("--port", String(options.port));
+  }
+
+  const proc = spawn("bun", args, {
+    cwd: CLI_DIR,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false,
+    env: { ...process.env, NODE_ENV: "production" },
+  });
+
+  return createServerHandle(proc, "bos-start", options.port || 3000);
+};
+
+const spawnBosDev = (options: SpawnOptions = {}): ServerHandle => {
+  const args = ["run", "src/cli.ts", "dev"];
+
+  if (!options.interactive) {
+    args.push("--no-interactive");
+  }
+
+  if (options.port) {
+    args.push("--port", String(options.port));
+  }
+
+  const proc = spawn("bun", args, {
+    cwd: CLI_DIR,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false,
+    env: { ...process.env, NODE_ENV: "development" },
+  });
+
+  return createServerHandle(proc, "bos-dev", options.port || 3000);
+};
+
+const waitForPortBound = async (
+  port: number,
+  timeoutMs = 60000
+): Promise<boolean> => {
+  const start = Date.now();
+
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const snapshot = await runSilent(
+        createSnapshotWithPlatform({ ports: [port] })
+      );
+      if (snapshot.ports[port]?.state === "LISTEN") {
+        return true;
+      }
+    } catch {
+      // ignore errors during polling
+    }
+    await sleep(500);
+  }
+
+  return false;
+};
+
+const waitForPortFree = async (
+  port: number,
+  timeoutMs = 15000
+): Promise<boolean> => {
+  const start = Date.now();
+
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const snapshot = await runSilent(
+        createSnapshotWithPlatform({ ports: [port] })
+      );
+      if (snapshot.ports[port]?.state === "FREE") {
+        return true;
+      }
+    } catch {
+      // ignore errors during polling
+    }
+    await sleep(200);
+  }
+
+  return false;
+};
+
+export const startServers = (
+  mode: "start" | "dev" = "start",
+  options: SpawnOptions = {}
+): Effect.Effect<ServerOrchestrator, ServerStartFailed | ServerNotReady> =>
+  Effect.gen(function* () {
+    const port = options.port || 3000;
+
+    yield* Effect.logInfo(`Starting BOS in ${mode} mode on port ${port}`);
+
+    const handle = mode === "dev"
+      ? spawnBosDev(options)
+      : spawnBosStart(options);
+
+    const ready = yield* Effect.tryPromise({
+      try: () => waitForPortBound(port, 90000),
+      catch: (e) => new ServerStartFailed({
+        server: handle.name,
+        port,
+        reason: String(e),
+      }),
+    });
+
+    if (!ready) {
+      yield* Effect.promise(() => handle.kill());
+      return yield* Effect.fail(
+        new ServerNotReady({
+          servers: [handle.name],
+          timeoutMs: 90000,
+        })
+      );
+    }
+
+    yield* Effect.logInfo(`Server ready on port ${port}`);
+
+    const orchestrator: ServerOrchestrator = {
+      handles: [handle],
+      ports: [port],
+      shutdown: async () => {
+        console.log("Shutting down servers");
+        await handle.kill();
+        await waitForPortFree(port, 15000);
+        console.log("Servers stopped");
+      },
+      waitForReady: async () => {
+        return waitForPortBound(port, 30000);
+      },
+    };
+
+    return orchestrator;
+  });
+
+export const shutdownServers = (
+  orchestrator: ServerOrchestrator
+): Effect.Effect<void> =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo(`Shutting down ${orchestrator.handles.length} server(s)`);
+
+    for (const handle of orchestrator.handles) {
+      yield* Effect.logDebug(`Killing ${handle.name} (PID ${handle.pid})`);
+      yield* Effect.promise(() => handle.kill());
+    }
+
+    for (const port of orchestrator.ports) {
+      yield* Effect.logDebug(`Waiting for port ${port} to be free`);
+      const freed = yield* Effect.promise(() => waitForPortFree(port, 15000));
+      if (!freed) {
+        yield* Effect.logWarning(`Port ${port} still bound after shutdown`);
+      }
+    }
+
+    yield* Effect.logInfo("All servers stopped");
+  });
+
+export const checkPortsAvailable = (
+  ports: number[]
+): Effect.Effect<boolean> =>
+  Effect.gen(function* () {
+    const snapshot = yield* Effect.promise(() =>
+      runSilent(createSnapshotWithPlatform({ ports }))
+    );
+
+    for (const port of ports) {
+      if (snapshot.ports[port]?.state !== "FREE") {
+        yield* Effect.logWarning(`Port ${port} is already in use`);
+        return false;
+      }
+    }
+
+    return true;
+  });
+
+export { waitForPortBound, waitForPortFree };

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

@@ -0,0 +1,115 @@
+import type { Snapshot } from "../resource-monitor";
+
+export interface SessionConfig {
+  ports: number[];
+  snapshotIntervalMs: number;
+  headless: boolean;
+  baseUrl: string;
+  timeout: number;
+  outputPath?: string;
+  devMode?: "local" | "remote";
+}
+
+export interface BrowserMetrics {
+  jsHeapUsedSize: number;
+  jsHeapTotalSize: number;
+  documents: number;
+  frames: number;
+  jsEventListeners: number;
+  nodes: number;
+  layoutCount: number;
+  recalcStyleCount: number;
+  scriptDuration: number;
+  taskDuration: number;
+}
+
+export type SessionEventType =
+  | "baseline"
+  | "interval"
+  | "pageload"
+  | "navigation"
+  | "click"
+  | "popup_open"
+  | "popup_close"
+  | "auth_start"
+  | "auth_complete"
+  | "auth_failed"
+  | "error"
+  | "custom";
+
+export interface SessionEvent {
+  id: string;
+  timestamp: number;
+  type: SessionEventType;
+  label: string;
+  snapshot: Snapshot;
+  browserMetrics?: BrowserMetrics;
+  url?: string;
+  error?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface SessionSummary {
+  totalMemoryDeltaMb: number;
+  peakMemoryMb: number;
+  averageMemoryMb: number;
+  processesSpawned: number;
+  processesKilled: number;
+  orphanedProcesses: number;
+  portsUsed: number[];
+  portsLeaked: number;
+  hasLeaks: boolean;
+  eventCount: number;
+  duration: number;
+  browserMetricsSummary?: {
+    peakJsHeapMb: number;
+    averageJsHeapMb: number;
+    totalLayoutCount: number;
+    totalScriptDuration: number;
+  };
+}
+
+export interface SessionReport {
+  sessionId: string;
+  config: SessionConfig;
+  startTime: number;
+  endTime: number;
+  events: SessionEvent[];
+  summary: SessionSummary;
+  platform: NodeJS.Platform;
+  nodeVersion: string;
+}
+
+export interface ServerHandle {
+  pid: number;
+  port: number;
+  name: string;
+  kill: () => Promise<void>;
+  waitForExit: (timeoutMs?: number) => Promise<number | null>;
+}
+
+export interface ServerOrchestrator {
+  handles: ServerHandle[];
+  ports: number[];
+  shutdown: () => Promise<void>;
+  waitForReady: () => Promise<boolean>;
+}
+
+export type SessionFlow = (context: FlowContext) => Promise<void>;
+
+export interface FlowContext {
+  page: unknown;
+  context: unknown;
+  recordEvent: (type: SessionEventType, label: string, metadata?: Record<string, unknown>) => Promise<void>;
+  headless: boolean;
+  baseUrl: string;
+}
+
+export const DEFAULT_SESSION_CONFIG: SessionConfig = {
+  ports: [3000, 3002, 3014],
+  snapshotIntervalMs: 2000,
+  headless: true,
+  baseUrl: "http://localhost:3000",
+  timeout: 120000,
+  devMode: "remote",
+};

package/src/plugin.ts

@@ -1,9 +1,9 @@
 import { createPlugin } from "every-plugin";
 import { Effect } from "every-plugin/effect";
 import { z } from "every-plugin/zod";
-import { Graph, calculateRequiredDeposit } from "near-social-js";
+import { calculateRequiredDeposit, Graph } from "near-social-js";
 
-import { createProcessRegistry } from "./lib/process-registry";
+import { runMonitorCli } from "./components/monitor-view";
 import {
   type AppConfig,
   type BosConfig as BosConfigType,
@@ -18,7 +18,7 @@ import {
   loadConfig,
   type RemoteConfig,
   resolvePackageModes,
-  type SourceMode, 
+  type SourceMode,
   setConfig
 } from "./config";
 import { bosContract } from "./contract";
@@ -37,6 +37,19 @@ import {
   verifyNovaCredentials
 } from "./lib/nova";
 import { type AppOrchestrator, startApp } from "./lib/orchestrator";
+import { createProcessRegistry } from "./lib/process-registry";
+import {
+  createSnapshotWithPlatform,
+  formatSnapshotSummary,
+  runWithInfo
+} from "./lib/resource-monitor";
+import {
+  formatReportSummary,
+  navigateTo,
+  runLoginFlow,
+  runNavigationFlow,
+  SessionRecorder,
+} from "./lib/session-recorder";
 import { syncFiles } from "./lib/sync";
 import { run } from "./utils/run";
 import { colors, icons } from "./utils/theme";
@@ -76,8 +89,8 @@ function getSocialContract(network: "mainnet" | "testnet"): string {
 }
 
 function getSocialExplorerUrl(network: "mainnet" | "testnet", path: string): string {
-  const baseUrl = network === "testnet" 
-    ? "https://test.near.social" 
+  const baseUrl = network === "testnet"
+    ? "https://test.near.social"
     : "https://near.social";
   return `${baseUrl}/${path}`;
 }
@@ -359,7 +372,7 @@ export default createPlugin({
 
     serve: builder.serve.handler(async ({ input }) => {
       const port = input.port;
-      
+
       return {
         status: "serving" as const,
         url: `http://localhost:${port}`,
@@ -481,7 +494,7 @@ export default createPlugin({
           };
           const argsBase64 = Buffer.from(JSON.stringify(socialArgs)).toString("base64");
 
-          const graph = new Graph({ 
+          const graph = new Graph({
             network,
             contractId: socialContract,
           });
@@ -1361,11 +1374,11 @@ export default createPlugin({
 
         const mergeAppConfig = (localApp: Record<string, unknown>, remoteApp: Record<string, unknown>): Record<string, unknown> => {
           const merged: Record<string, unknown> = {};
-          
+
           for (const key of Object.keys(remoteApp)) {
             const local = localApp[key] as Record<string, unknown> | undefined;
             const remote = remoteApp[key] as Record<string, unknown>;
-            
+
             if (!local) {
               merged[key] = remote;
               continue;
@@ -1384,7 +1397,7 @@ export default createPlugin({
               },
             };
           }
-          
+
           return merged;
         };
 
@@ -1608,7 +1621,7 @@ export default createPlugin({
         const port = input.port || (input.target === "development" ? 4000 : 3000);
 
         const args = ["run"];
-        
+
         if (input.detach) {
           args.push("-d");
         }
@@ -1630,8 +1643,8 @@ export default createPlugin({
           args.push("-e", `BOS_ACCOUNT=${bosConfig.account}`);
           const gateway = bosConfig.gateway as { production?: string } | string | undefined;
           if (gateway) {
-            const domain = typeof gateway === "string" 
-              ? gateway 
+            const domain = typeof gateway === "string"
+              ? gateway
               : gateway.production?.replace(/^https?:\/\//, "") || "";
             if (domain) {
               args.push("-e", `GATEWAY_DOMAIN=${domain}`);
@@ -1688,14 +1701,14 @@ export default createPlugin({
           stopped.push(input.containerId!);
         } else if (input.all) {
           const imageName = bosConfig?.account?.replace(/\./g, "-") || "bos-app";
-          
+
           const psResult = yield* Effect.tryPromise({
             try: () => execa("docker", ["ps", "-q", "--filter", `ancestor=${imageName}`]),
             catch: () => new Error("Failed to list containers"),
           });
 
           const containerIds = psResult.stdout.trim().split("\n").filter(Boolean);
-          
+
           for (const id of containerIds) {
             yield* Effect.tryPromise({
               try: () => execa("docker", ["stop", id]),
@@ -1721,6 +1734,132 @@ export default createPlugin({
         };
       }
     }),
+
+    monitor: builder.monitor.handler(async ({ input }) => {
+      try {
+        if (input.json) {
+          const snapshot = await runWithInfo(
+            createSnapshotWithPlatform(input.ports ? { ports: input.ports } : undefined)
+          );
+          return {
+            status: "snapshot" as const,
+            snapshot: snapshot as any,
+          };
+        }
+
+        if (input.watch) {
+          runMonitorCli({ ports: input.ports, json: false });
+          return {
+            status: "watching" as const,
+          };
+        }
+
+        const snapshot = await runWithInfo(
+          createSnapshotWithPlatform(input.ports ? { ports: input.ports } : undefined)
+        );
+        console.log(formatSnapshotSummary(snapshot));
+
+        return {
+          status: "snapshot" as const,
+          snapshot: snapshot as any,
+        };
+      } catch (error) {
+        return {
+          status: "error" as const,
+          error: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    }),
+
+    session: builder.session.handler(async ({ input }) => {
+      const sessionEffect = Effect.gen(function* () {
+        const recorder = yield* SessionRecorder.create({
+          ports: [3000],
+          snapshotIntervalMs: input.snapshotInterval,
+          headless: input.headless,
+          baseUrl: "http://localhost:3000",
+          timeout: input.timeout,
+        });
+
+        try {
+          yield* recorder.startServers("start");
+
+          yield* recorder.startRecording();
+
+          const browser = yield* recorder.launchBrowser();
+
+          if (input.flow === "login") {
+            yield* runLoginFlow(browser, {
+              recordEvent: (type, label, metadata) =>
+                recorder.recordEvent(type, label, metadata).pipe(
+                  Effect.asVoid,
+                  Effect.catchAll(() => Effect.void)
+                ),
+            }, {
+              baseUrl: "http://localhost:3000",
+              headless: input.headless,
+              stubWallet: input.headless,
+              timeout: 30000,
+            });
+          } else if (input.flow === "navigation" && input.routes) {
+            yield* runNavigationFlow(
+              browser,
+              {
+                recordEvent: (type, label, metadata) =>
+                  recorder.recordEvent(type, label, metadata).pipe(
+                    Effect.asVoid,
+                    Effect.catchAll(() => Effect.void)
+                  ),
+              },
+              input.routes,
+              "http://localhost:3000"
+            );
+          } else {
+            yield* navigateTo(browser.page, "http://localhost:3000");
+            yield* Effect.sleep("5 seconds");
+          }
+
+          yield* recorder.cleanup();
+
+          const report = yield* recorder.stopRecording();
+
+          yield* recorder.exportReport(input.output, input.format);
+
+          console.log(formatReportSummary(report));
+
+          return {
+            status: report.summary.hasLeaks ? "leaks_detected" as const : "completed" as const,
+            sessionId: recorder.getSessionId(),
+            reportPath: input.output,
+            summary: {
+              totalMemoryDeltaMb: report.summary.totalMemoryDeltaMb,
+              peakMemoryMb: report.summary.peakMemoryMb,
+              averageMemoryMb: report.summary.averageMemoryMb,
+              processesSpawned: report.summary.processesSpawned,
+              processesKilled: report.summary.processesKilled,
+              orphanedProcesses: report.summary.orphanedProcesses,
+              portsUsed: report.summary.portsUsed,
+              portsLeaked: report.summary.portsLeaked,
+              hasLeaks: report.summary.hasLeaks,
+              eventCount: report.summary.eventCount,
+              duration: report.summary.duration,
+            },
+          };
+        } catch (error) {
+          yield* recorder.cleanup();
+          throw error;
+        }
+      });
+
+      try {
+        return await Effect.runPromise(sessionEffect);
+      } catch (error) {
+        return {
+          status: "error" as const,
+          error: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    }),
   }),
 });