everything-dev 0.3.2 → 1.3.2

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

@@ -1,267 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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/lib/sync.ts

@@ -1 +0,0 @@
-export { syncFiles, type FileSyncOptions, type FileSyncResult } from "../ui/files";

package/src/ui/files.ts

@@ -1,134 +0,0 @@
-import { execa } from "execa";
-import { cp, mkdir, mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
-import { dirname, join } from "path";
-
-export interface FileSyncResult {
-  package: string;
-  files: string[];
-  depsAdded?: string[];
-  depsUpdated?: string[];
-}
-
-export interface FileSyncOptions {
-  configDir: string;
-  packages: string[];
-  bosConfig: {
-    app: Record<string, {
-      template?: string;
-      files?: string[];
-      sync?: { dependencies?: boolean; devDependencies?: boolean };
-    }>;
-  };
-  catalog?: Record<string, string>;
-  force?: boolean;
-}
-
-export async function syncFiles(options: FileSyncOptions): Promise<FileSyncResult[]> {
-  const { configDir, packages, bosConfig, catalog = {}, force } = options;
-  const results: FileSyncResult[] = [];
-
-  for (const pkg of packages) {
-    const pkgDir = `${configDir}/${pkg}`;
-    const pkgDirExists = await Bun.file(`${pkgDir}/package.json`).exists();
-    if (!pkgDirExists) continue;
-
-    const appConfig = bosConfig.app[pkg];
-
-    if (!appConfig?.template || !appConfig?.files) {
-      continue;
-    }
-
-    const tempDir = await mkdtemp(join(tmpdir(), `bos-files-${pkg}-`));
-
-    try {
-      await execa("npx", ["degit", appConfig.template, tempDir, "--force"], {
-        stdio: "pipe",
-      });
-
-      const filesSynced: string[] = [];
-      const depsAdded: string[] = [];
-      const depsUpdated: string[] = [];
-
-      for (const file of appConfig.files) {
-        const srcPath = join(tempDir, file);
-        const destPath = join(pkgDir, file);
-
-        try {
-          const destDir = dirname(destPath);
-          await mkdir(destDir, { recursive: true });
-          await cp(srcPath, destPath, { force: true, recursive: true });
-          filesSynced.push(file);
-        } catch {
-        }
-      }
-
-      const syncConfig = appConfig.sync ?? { dependencies: true, devDependencies: true };
-
-      if (syncConfig.dependencies !== false || syncConfig.devDependencies !== false) {
-        const templatePkgPath = join(tempDir, "package.json");
-        const localPkgPath = join(pkgDir, "package.json");
-
-        try {
-          const templatePkg = await Bun.file(templatePkgPath).json() as {
-            dependencies?: Record<string, string>;
-            devDependencies?: Record<string, string>;
-            scripts?: Record<string, string>;
-          };
-          const localPkg = await Bun.file(localPkgPath).json() as {
-            dependencies?: Record<string, string>;
-            devDependencies?: Record<string, string>;
-            scripts?: Record<string, string>;
-          };
-
-          if (syncConfig.dependencies !== false && templatePkg.dependencies) {
-            if (!localPkg.dependencies) localPkg.dependencies = {};
-            for (const [name, version] of Object.entries(templatePkg.dependencies)) {
-              if (!(name in localPkg.dependencies)) {
-                localPkg.dependencies[name] = name in catalog ? "catalog:" : version;
-                depsAdded.push(name);
-              } else if (localPkg.dependencies[name] !== "catalog:" && version !== localPkg.dependencies[name]) {
-                localPkg.dependencies[name] = name in catalog ? "catalog:" : version;
-                depsUpdated.push(name);
-              }
-            }
-          }
-
-          if (syncConfig.devDependencies !== false && templatePkg.devDependencies) {
-            if (!localPkg.devDependencies) localPkg.devDependencies = {};
-            for (const [name, version] of Object.entries(templatePkg.devDependencies)) {
-              if (!(name in localPkg.devDependencies)) {
-                localPkg.devDependencies[name] = name in catalog ? "catalog:" : version;
-                depsAdded.push(name);
-              } else if (localPkg.devDependencies[name] !== "catalog:" && version !== localPkg.devDependencies[name]) {
-                localPkg.devDependencies[name] = name in catalog ? "catalog:" : version;
-                depsUpdated.push(name);
-              }
-            }
-          }
-
-          if (templatePkg.scripts) {
-            if (!localPkg.scripts) localPkg.scripts = {};
-            for (const [name, script] of Object.entries(templatePkg.scripts)) {
-              localPkg.scripts[name] = script;
-            }
-          }
-
-          await Bun.write(localPkgPath, JSON.stringify(localPkg, null, 2));
-        } catch {
-        }
-      }
-
-      results.push({
-        package: pkg,
-        files: filesSynced,
-        depsAdded: depsAdded.length > 0 ? depsAdded : undefined,
-        depsUpdated: depsUpdated.length > 0 ? depsUpdated : undefined,
-      });
-    } finally {
-      await rm(tempDir, { recursive: true, force: true });
-    }
-  }
-
-  return results;
-}