everything-dev 0.1.2 → 0.1.4

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,
           });
@@ -756,7 +769,12 @@ export default createPlugin({
           const novaConfig = yield* getNovaConfig;
           const nova = createNovaClient(novaConfig);
 
-          yield* registerSecretsGroup(nova, fullAccount, parentAccount);
+          const gatewayNovaAccount = bosConfig.gateway?.nova?.account;
+          if (!gatewayNovaAccount) {
+            return yield* Effect.fail(new Error("gateway.nova.account is required for secrets registration"));
+          }
+
+          yield* registerSecretsGroup(nova, fullAccount, gatewayNovaAccount);
 
           return {
             status: "registered" as const,
@@ -1101,7 +1119,7 @@ export default createPlugin({
 
       try {
         const gatewayDomain = getGatewayDomain(bosConfig);
-        const gatewayAccount = bosConfig.account;
+        const gatewayAccount = bosConfig.gateway?.account || bosConfig.account;
 
         const wranglerContent = await Bun.file(wranglerPath).text();
 
@@ -1356,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;
@@ -1379,7 +1397,7 @@ export default createPlugin({
               },
             };
           }
-          
+
           return merged;
         };
 
@@ -1603,7 +1621,7 @@ export default createPlugin({
         const port = input.port || (input.target === "development" ? 4000 : 3000);
 
         const args = ["run"];
-        
+
         if (input.detach) {
           args.push("-d");
         }
@@ -1625,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}`);
@@ -1683,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]),
@@ -1716,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",
+        };
+      }
+    }),
   }),
 });
 

package/src/types.ts

@@ -30,9 +30,16 @@ export const RemoteConfigSchema = z.object({
 });
 export type RemoteConfig = z.infer<typeof RemoteConfigSchema>;
 
+export const NovaConfigSchema = z.object({
+  account: z.string(),
+});
+export type NovaConfig = z.infer<typeof NovaConfigSchema>;
+
 export const GatewayConfigSchema = z.object({
   development: z.string(),
   production: z.string(),
+  account: z.string().optional(),
+  nova: NovaConfigSchema.optional(),
 });
 export type GatewayConfig = z.infer<typeof GatewayConfigSchema>;
 
@@ -54,6 +61,7 @@ export type SyncConfig = z.infer<typeof SyncConfigSchema>;
 export const BosConfigSchema = z.object({
   account: z.string(),
   testnet: z.string().optional(),
+  nova: NovaConfigSchema.optional(),
   gateway: GatewayConfigSchema,
   template: z.string().optional(),
   cli: z.object({