everything-dev 0.1.2 → 0.1.4

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;

package/src/lib/session-recorder/flows/login.ts

@@ -0,0 +1,210 @@
+import { Effect } from "effect";
+import { AuthenticationFailed, PopupNotDetected } from "../errors";
+import {
+  type BrowserHandle,
+  clickElement,
+  getBrowserMetrics,
+  navigateTo,
+  sleep,
+  waitForPopup,
+  waitForSelector,
+} from "../playwright";
+import type { SessionEventType } from "../types";
+
+interface FlowRecorder {
+  recordEvent: (
+    type: SessionEventType,
+    label: string,
+    metadata?: Record<string, unknown>
+  ) => Effect.Effect<void>;
+}
+
+interface LoginFlowOptions {
+  baseUrl: string;
+  headless: boolean;
+  stubWallet: boolean;
+  timeout: number;
+}
+
+const DEFAULT_LOGIN_OPTIONS: LoginFlowOptions = {
+  baseUrl: "http://localhost:3000",
+  headless: true,
+  stubWallet: true,
+  timeout: 30000,
+};
+
+export const runLoginFlow = (
+  browser: BrowserHandle,
+  recorder: FlowRecorder,
+  options: Partial<LoginFlowOptions> = {}
+): Effect.Effect<void, AuthenticationFailed | PopupNotDetected> =>
+  Effect.gen(function* () {
+    const opts = { ...DEFAULT_LOGIN_OPTIONS, ...options };
+    const { page, context } = browser;
+
+    yield* Effect.logInfo("Starting login flow");
+    yield* Effect.asVoid(recorder.recordEvent("custom", "login_flow_start"));
+
+    yield* navigateTo(page, `${opts.baseUrl}/login`);
+    yield* Effect.asVoid(recorder.recordEvent("pageload", "/login", { url: `${opts.baseUrl}/login` }));
+
+    yield* sleep(1000);
+
+    const connectButtonSelector = 'button:has-text("connect near wallet")';
+
+    yield* Effect.tryPromise({
+      try: () => page.waitForSelector(connectButtonSelector, { timeout: opts.timeout }),
+      catch: () => new AuthenticationFailed({
+        step: "find_connect_button",
+        reason: "Connect wallet button not found",
+      }),
+    });
+
+    yield* Effect.asVoid(recorder.recordEvent("auth_start", "wallet_connect_initiated"));
+
+    if (opts.headless && opts.stubWallet) {
+      yield* Effect.logInfo("Stubbing wallet connection in headless mode");
+      yield* Effect.asVoid(recorder.recordEvent("custom", "wallet_stubbed", { reason: "headless_mode" }));
+
+      yield* clickElement(page, connectButtonSelector);
+
+      yield* sleep(2000);
+
+      const hasSignInButton = yield* Effect.tryPromise({
+        try: async () => {
+          try {
+            await page.waitForSelector('button:has-text("sign in as")', { timeout: 5000 });
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        catch: () => false,
+      });
+
+      if (hasSignInButton) {
+        yield* Effect.asVoid(recorder.recordEvent("custom", "sign_in_button_appeared"));
+      } else {
+        yield* Effect.asVoid(recorder.recordEvent("custom", "wallet_popup_would_open", {
+          note: "In headed mode, NEAR wallet popup would appear here",
+        }));
+      }
+
+      yield* Effect.asVoid(recorder.recordEvent("auth_complete", "login_flow_completed_stubbed"));
+
+    } else {
+      yield* Effect.logInfo("Running full wallet flow (headed mode)");
+
+      yield* clickElement(page, connectButtonSelector);
+      yield* Effect.asVoid(recorder.recordEvent("click", "connect_wallet_button"));
+
+      const popupPromise = waitForPopup(context, opts.timeout);
+
+      const popup = yield* Effect.catchAll(popupPromise, () =>
+        Effect.fail(new PopupNotDetected({ timeoutMs: opts.timeout }))
+      );
+
+      yield* Effect.asVoid(recorder.recordEvent("popup_open", "near_wallet_popup", {
+        url: popup.url(),
+      }));
+
+      yield* Effect.logInfo("NEAR wallet popup opened - waiting for user interaction");
+      yield* Effect.asVoid(recorder.recordEvent("custom", "awaiting_user_approval"));
+
+      yield* sleep(5000);
+
+      const popupClosed = yield* Effect.tryPromise({
+        try: async () => {
+          try {
+            await popup.waitForSelector("body", { timeout: 1000 });
+            return false;
+          } catch {
+            return true;
+          }
+        },
+        catch: () => true,
+      });
+
+      if (popupClosed) {
+        yield* Effect.asVoid(recorder.recordEvent("popup_close", "near_wallet_popup"));
+      }
+
+      const signInButtonSelector = 'button:has-text("sign in as")';
+      const hasSignIn = yield* Effect.tryPromise({
+        try: async () => {
+          try {
+            await page.waitForSelector(signInButtonSelector, { timeout: 10000 });
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        catch: () => false,
+      });
+
+      if (hasSignIn) {
+        yield* Effect.asVoid(recorder.recordEvent("custom", "wallet_connected"));
+        yield* clickElement(page, signInButtonSelector);
+        yield* Effect.asVoid(recorder.recordEvent("click", "sign_in_button"));
+      }
+
+      yield* Effect.asVoid(recorder.recordEvent("auth_complete", "login_flow_completed"));
+    }
+
+    yield* Effect.logInfo("Login flow completed");
+  });
+
+export const runNavigationFlow = (
+  browser: BrowserHandle,
+  recorder: FlowRecorder,
+  routes: string[],
+  baseUrl: string
+): Effect.Effect<void> =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo(`Running navigation flow through ${routes.length} routes`);
+
+    for (const route of routes) {
+      const url = `${baseUrl}${route}`;
+      yield* navigateTo(browser.page, url);
+      yield* Effect.asVoid(recorder.recordEvent("navigation", route, { url }));
+
+      yield* sleep(1000);
+
+      yield* Effect.asVoid(recorder.recordEvent("interval", `visited_${route}`));
+    }
+
+    yield* Effect.logInfo("Navigation flow completed");
+  });
+
+export const runClickFlow = (
+  browser: BrowserHandle,
+  recorder: FlowRecorder,
+  selectors: Array<{ selector: string; label: string }>
+): Effect.Effect<void> =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo(`Running click flow with ${selectors.length} interactions`);
+
+    for (const { selector, label } of selectors) {
+      const exists = yield* Effect.tryPromise({
+        try: async () => {
+          try {
+            await browser.page.waitForSelector(selector, { timeout: 5000 });
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        catch: () => false,
+      });
+
+      if (exists) {
+        yield* clickElement(browser.page, selector);
+        yield* Effect.asVoid(recorder.recordEvent("click", label, { selector }));
+        yield* sleep(500);
+      } else {
+        yield* Effect.logWarning(`Selector not found: ${selector}`);
+      }
+    }
+
+    yield* Effect.logInfo("Click flow completed");
+  });