@elizaos/app-core 2.0.0-beta.2 → 2.0.11-beta.5

package/scripts/playwright-ui-live-stack.ts

@@ -1,6 +1,6 @@
 import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { access, mkdtemp, readFile, rm } from "node:fs/promises";
+import { access, cp, mkdtemp, readFile, rm } from "node:fs/promises";
 import {
   createServer,
   type IncomingMessage,
@@ -10,15 +10,25 @@ import {
 import os from "node:os";
 import path from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
-import { buildOnboardingRuntimeConfig } from "@elizaos/ui/onboarding-config";
 import { WebSocket, WebSocketServer } from "ws";
-import { selectLiveProvider } from "../test/helpers/live-provider.ts";
+import { buildFirstRunRuntimeConfig } from "../src/first-run/first-run-config.ts";
+import {
+  getFirstRunProviderForLiveProvider,
+  selectLiveProvider,
+} from "../test/helpers/live-provider.ts";
 import { resolveMainAppDir } from "./lib/app-dir.mjs";
+import { shouldForceStubStack } from "./lib/ui-smoke-stub-decision.mjs";
 import { viteRendererBuildNeeded } from "./lib/vite-renderer-dist-stale.mjs";
 
-const REPO_ROOT = path.resolve(import.meta.dirname, "..", "..", "..", "..");
+const REPO_ROOT = path.resolve(import.meta.dirname, "..", "..", "..");
 const APP_DIR = resolveMainAppDir(REPO_ROOT, "app");
 const APP_DIST_DIR = path.join(APP_DIR, "dist");
+const COMPANION_PUBLIC_DIR = path.join(
+  REPO_ROOT,
+  "plugins",
+  "app-companion",
+  "public",
+);
 const UI_SMOKE_STUB_SCRIPT = path.join(
   import.meta.dirname,
   "playwright-ui-smoke-api-stub.mjs",
@@ -27,8 +37,11 @@ const READY_TIMEOUT_MS = 180_000;
 const API_PORT = Number(process.env.ELIZA_UI_SMOKE_API_PORT ?? "31337");
 const UI_PORT = Number(process.env.ELIZA_UI_SMOKE_PORT ?? "2138");
 const LIVE_PROVIDER = selectLiveProvider();
-const FORCE_STUB_STACK =
-  process.env.ELIZA_UI_SMOKE_FORCE_STUB === "1" || process.env.CI === "true";
+// Precedence (force-stub > live opt-in > CI default) lives in one tested helper.
+// The key behavior: ELIZA_UI_SMOKE_LIVE_STACK=1 overrides the CI-based stub force
+// so a genuinely-real lane is possible (GitHub Actions always sets CI=true, which
+// would otherwise re-force the stub even when a provider key was supplied).
+const FORCE_STUB_STACK = shouldForceStubStack(process.env);
 
 type StartedStack = {
   apiBase: string;
@@ -38,6 +51,37 @@ type StartedStack = {
   uiServer: Server;
 };
 
+function resolveBunCommand(): string {
+  const bunFromEnv = process.env.BUN?.trim();
+  if (bunFromEnv && existsSync(bunFromEnv)) {
+    return bunFromEnv;
+  }
+
+  const bunInstallRoot = process.env.BUN_INSTALL?.trim();
+  if (bunInstallRoot) {
+    const bunFromInstall = path.join(
+      bunInstallRoot,
+      "bin",
+      process.platform === "win32" ? "bun.exe" : "bun",
+    );
+    if (existsSync(bunFromInstall)) {
+      return bunFromInstall;
+    }
+  }
+
+  const homeBun = path.join(
+    os.homedir(),
+    ".bun",
+    "bin",
+    process.platform === "win32" ? "bun.exe" : "bun",
+  );
+  if (existsSync(homeBun)) {
+    return homeBun;
+  }
+
+  return process.platform === "win32" ? "bun.exe" : "bun";
+}
+
 function contentTypeFor(filePath: string): string {
   switch (path.extname(filePath).toLowerCase()) {
     case ".css":
@@ -66,16 +110,19 @@ function contentTypeFor(filePath: string): string {
   }
 }
 
-function resolveDistAssetPath(requestedPath: string): string | null {
+function resolveDistAssetPath(
+  requestedPath: string,
+  distDir: string,
+): string | null {
   const normalizedPath = requestedPath.replace(/^\/+/, "");
   const segments = normalizedPath.split("/").filter(Boolean);
   for (let index = 0; index < segments.length; index += 1) {
     const candidatePath = path.resolve(
-      APP_DIST_DIR,
+      distDir,
       segments.slice(index).join("/"),
     );
     if (
-      candidatePath.startsWith(APP_DIST_DIR) &&
+      candidatePath.startsWith(distDir) &&
       existsSync(candidatePath) &&
       path.extname(candidatePath).length > 0
     ) {
@@ -85,6 +132,27 @@ function resolveDistAssetPath(requestedPath: string): string | null {
   return null;
 }
 
+function resolveCompanionPublicAssetPath(requestedPath: string): string | null {
+  const normalizedPath = requestedPath.replace(/^\/+/, "");
+  if (
+    !normalizedPath.startsWith("animations/") &&
+    !normalizedPath.startsWith("vrm-decoders/") &&
+    !normalizedPath.startsWith("vrms/")
+  ) {
+    return null;
+  }
+
+  const candidatePath = path.resolve(COMPANION_PUBLIC_DIR, normalizedPath);
+  if (
+    candidatePath.startsWith(COMPANION_PUBLIC_DIR) &&
+    existsSync(candidatePath) &&
+    path.extname(candidatePath).length > 0
+  ) {
+    return candidatePath;
+  }
+  return null;
+}
+
 async function readRequestBody(request: IncomingMessage): Promise<Buffer> {
   const chunks: Buffer[] = [];
   for await (const chunk of request) {
@@ -97,6 +165,7 @@ async function proxyUiRequest(args: {
   apiBase: string;
   request: IncomingMessage;
   response: ServerResponse<IncomingMessage>;
+  uiDistDir: string;
 }): Promise<void> {
   const requestUrl = new URL(args.request.url ?? "/", "http://127.0.0.1");
 
@@ -136,9 +205,18 @@ async function proxyUiRequest(args: {
     requestUrl.pathname === "/"
       ? "index.html"
       : requestUrl.pathname.replace(/^\/+/, "");
-  let filePath = resolveDistAssetPath(requestedPath);
+  let filePath =
+    resolveDistAssetPath(requestedPath, args.uiDistDir) ??
+    resolveCompanionPublicAssetPath(requestedPath);
   const isAssetRequest = path.extname(requestedPath).length > 0;
-  const indexHtmlPath = path.join(APP_DIST_DIR, "index.html");
+  const indexHtmlPath = path.join(args.uiDistDir, "index.html");
+  if (!filePath && isAssetRequest) {
+    args.response.writeHead(404, {
+      "Content-Type": "application/json",
+    });
+    args.response.end(JSON.stringify({ error: "Static asset not found" }));
+    return;
+  }
   if (!filePath && !isAssetRequest) {
     filePath = indexHtmlPath;
   }
@@ -146,7 +224,7 @@ async function proxyUiRequest(args: {
   const primaryPath = filePath ?? indexHtmlPath;
   let body: Buffer | null = null;
   let resolvedPath = primaryPath;
-  const maxReadAttempts = 40;
+  const maxReadAttempts = 300;
   for (let attempt = 0; attempt < maxReadAttempts; attempt++) {
     try {
       body = await readFile(primaryPath);
@@ -245,6 +323,7 @@ function relayWebSocket(args: {
 async function startUiProxyServer(args: {
   apiBase: string;
   port: number;
+  uiDistDir: string;
 }): Promise<Server> {
   const server = createServer(async (request, response) => {
     try {
@@ -252,6 +331,7 @@ async function startUiProxyServer(args: {
         apiBase: args.apiBase,
         request,
         response,
+        uiDistDir: args.uiDistDir,
       });
     } catch (error) {
       if (response.headersSent || response.writableEnded) {
@@ -396,16 +476,39 @@ async function ensureUiDistReady(): Promise<void> {
     needsBuild = true;
   }
 
+  // Escape hatch symmetric to ELIZA_DESKTOP_RENDERER_BUILD=always: when the dist
+  // is known-current and only the stub API or specs changed, skip the ~12 min
+  // rebuild. The mtime heuristic false-positives whenever an unrelated bulk op
+  // (git checkout, repo-wide formatter) bumps source mtimes without touching the
+  // renderer. Only honored when a built index.html already exists.
+  if (needsBuild && process.env.ELIZA_UI_SMOKE_SKIP_BUILD === "1") {
+    try {
+      await access(distIndex);
+      needsBuild = false;
+    } catch {
+      throw new Error(
+        `ELIZA_UI_SMOKE_SKIP_BUILD=1 but no built renderer at ${distIndex}. Build once (bun run --cwd packages/app build:web) before skipping.`,
+      );
+    }
+  }
+
   if (!needsBuild) {
     return;
   }
 
+  await rm(path.join(APP_DIR, ".vite"), { force: true, recursive: true });
+
   const logs: string[] = [];
-  const child = spawn("bun", ["run", "build:web"], {
+  const child = spawn(resolveBunCommand(), ["run", "build:web"], {
     cwd: APP_DIR,
     env: {
       ...process.env,
       FORCE_COLOR: "0",
+      VITE_ELIZA_RENDER_TELEMETRY: "1",
+      // ui-smoke serves the dist locally and never ships it, so skip the
+      // memory-heavy esbuild minify pass that otherwise OOMs (EPIPE) on a
+      // ~6.5MB bundle in CI/sandbox builds.
+      ELIZA_DESKTOP_VITE_FAST_DIST: "1",
     },
     stdio: ["ignore", "pipe", "pipe"],
   });
@@ -413,38 +516,58 @@ async function ensureUiDistReady(): Promise<void> {
   child.stdout.on("data", (chunk) => logs.push(String(chunk)));
   child.stderr.on("data", (chunk) => logs.push(String(chunk)));
 
-  const exited = await waitForChildExit(child, 300_000);
-  if (!exited || child.exitCode !== 0) {
+  // Cold renderer build transforms ~3000 modules and measures ~12 min on a
+  // clean dist; cap at 18 min so a legitimately slow first build is not killed
+  // mid-flight (the previous 5/10 min caps produced spurious "service stopped").
+  const RENDERER_BUILD_TIMEOUT_MS = 1_080_000;
+  const exited = await waitForChildExit(child, RENDERER_BUILD_TIMEOUT_MS);
+  if (!exited) {
+    child.kill("SIGKILL");
     throw new Error(
-      `app renderer build failed.\n${logs.join("").slice(-8_000)}`,
+      `app renderer build timed out after ${RENDERER_BUILD_TIMEOUT_MS}ms.\n${logs.join("").slice(-8_000)}`,
     );
   }
+  if (child.exitCode !== 0) {
+    throw new Error(
+      `app renderer build failed (exit ${child.exitCode}).\n${logs.join("").slice(-8_000)}`,
+    );
+  }
+}
+
+async function snapshotUiDist(stateDir: string): Promise<string> {
+  const snapshotDir = path.join(stateDir, "ui-dist");
+  await cp(APP_DIST_DIR, snapshotDir, {
+    recursive: true,
+    force: true,
+  });
+  await access(path.join(snapshotDir, "index.html"));
+  return snapshotDir;
 }
 
-async function submitOnboarding(apiBase: string): Promise<void> {
+async function submitFirstRun(apiBase: string): Promise<void> {
   if (!LIVE_PROVIDER) {
     throw new Error(
       "UI smoke needs a real provider. Set OPENAI_API_KEY, GROQ_API_KEY, ANTHROPIC_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, OPENROUTER_API_KEY, or ELIZAOS_CLOUD_API_KEY.",
     );
   }
 
-  const runtimeConfig = buildOnboardingRuntimeConfig({
-    onboardingServerTarget: "local",
-    onboardingCloudApiKey: "",
-    onboardingProvider: LIVE_PROVIDER.name,
-    onboardingApiKey: LIVE_PROVIDER.apiKey,
-    onboardingVoiceProvider: "",
-    onboardingVoiceApiKey: "",
-    onboardingPrimaryModel: LIVE_PROVIDER.largeModel,
-    onboardingOpenRouterModel: LIVE_PROVIDER.largeModel,
-    onboardingRemoteConnected: false,
-    onboardingRemoteApiBase: "",
-    onboardingRemoteToken: "",
-    onboardingSmallModel: LIVE_PROVIDER.smallModel,
-    onboardingLargeModel: LIVE_PROVIDER.largeModel,
+  const runtimeConfig = buildFirstRunRuntimeConfig({
+    firstRunRuntimeTarget: "local",
+    firstRunCloudApiKey: "",
+    firstRunProvider: getFirstRunProviderForLiveProvider(LIVE_PROVIDER),
+    firstRunApiKey: LIVE_PROVIDER.apiKey,
+    firstRunVoiceProvider: "",
+    firstRunVoiceApiKey: "",
+    firstRunPrimaryModel: LIVE_PROVIDER.largeModel,
+    firstRunOpenRouterModel: LIVE_PROVIDER.largeModel,
+    firstRunRemoteConnected: false,
+    firstRunRemoteApiBase: "",
+    firstRunRemoteToken: "",
+    firstRunSmallModel: LIVE_PROVIDER.smallModel,
+    firstRunLargeModel: LIVE_PROVIDER.largeModel,
   });
 
-  const response = await fetch(`${apiBase}/api/onboarding`, {
+  const response = await fetch(`${apiBase}/api/first-run`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -452,7 +575,7 @@ async function submitOnboarding(apiBase: string): Promise<void> {
     body: JSON.stringify({
       name: "Playwright Smoke",
       bio: ["A real runtime used by the UI smoke suite."],
-      systemPrompt: "You are a concise assistant for Playwright smoke tests.",
+      systemPrompt: "Concise assistant for Playwright smoke tests.",
       language: "en",
       presetId: "default",
       avatarIndex: 0,
@@ -476,7 +599,7 @@ async function submitOnboarding(apiBase: string): Promise<void> {
   }
 
   await waitForJsonPredicate<{ complete: boolean }>(
-    `${apiBase}/api/onboarding/status`,
+    `${apiBase}/api/first-run/status`,
     (status) => status.complete === true,
     READY_TIMEOUT_MS,
   );
@@ -486,6 +609,7 @@ async function startStubStack(): Promise<StartedStack> {
   const stateDir = await mkdtemp(
     path.join(os.tmpdir(), "eliza-ui-smoke-stub-"),
   );
+  const uiDistDir = await snapshotUiDist(stateDir);
   const apiBase = `http://127.0.0.1:${API_PORT}`;
   const apiChild = spawn("node", [UI_SMOKE_STUB_SCRIPT], {
     cwd: REPO_ROOT,
@@ -493,6 +617,7 @@ async function startStubStack(): Promise<StartedStack> {
       ...process.env,
       FORCE_COLOR: "0",
       ELIZA_UI_SMOKE_API_PORT: String(API_PORT),
+      ELIZA_UI_SMOKE_STUB_IGNORE_SIGTERM: "1",
     },
     stdio: ["ignore", "pipe", "pipe"],
   });
@@ -504,16 +629,22 @@ async function startStubStack(): Promise<StartedStack> {
     process.stdout.write(`[ui-smoke][stub-err] ${chunk}`);
   });
 
-  await waitForJson<{ complete: boolean }>(`${apiBase}/api/onboarding/status`);
+  await waitForJson<{ complete: boolean }>(`${apiBase}/api/first-run/status`);
   await waitForJsonPredicate<{ state?: string }>(
     `${apiBase}/api/status`,
     (status) => status.state === "running",
     READY_TIMEOUT_MS,
   );
+  await waitForJsonPredicate<{ session?: { kind?: string } }>(
+    `${apiBase}/api/auth/me`,
+    (me) => me.session?.kind === "local",
+    READY_TIMEOUT_MS,
+  );
 
   const uiServer = await startUiProxyServer({
     apiBase,
     port: UI_PORT,
+    uiDistDir,
   });
   process.env.ELIZA_API_PORT = String(API_PORT);
 
@@ -536,12 +667,13 @@ async function startRealStack(): Promise<StartedStack> {
   const stateDir = await mkdtemp(
     path.join(os.tmpdir(), "eliza-ui-smoke-live-"),
   );
+  const uiDistDir = await snapshotUiDist(stateDir);
   const apiBase = `http://127.0.0.1:${API_PORT}`;
   const apiChild = spawn(
     "node",
     [
-      path.join(REPO_ROOT, "eliza/packages/app-core/scripts/run-node-tsx.mjs"),
-      path.join(REPO_ROOT, "eliza/packages/app-core/src/runtime/eliza.ts"),
+      path.join(REPO_ROOT, "packages/app-core/scripts/run-node-tsx.mjs"),
+      path.join(REPO_ROOT, "packages/app-core/src/runtime/eliza.ts"),
     ],
     {
       cwd: REPO_ROOT,
@@ -565,28 +697,41 @@ async function startRealStack(): Promise<StartedStack> {
     process.stdout.write(`[ui-smoke][api-err] ${chunk}`);
   });
 
-  await waitForJson<{ complete: boolean }>(`${apiBase}/api/onboarding/status`);
-  const onboardingStatus = await fetchJson<{ complete: boolean }>(
-    `${apiBase}/api/onboarding/status`,
-  );
-  if (!onboardingStatus.complete) {
-    await submitOnboarding(apiBase);
-  }
+  await waitForJson<{ complete: boolean }>(`${apiBase}/api/first-run/status`);
+  // Cloud-live mode (ELIZA_UI_SMOKE_CLOUD_LIVE=1) leaves first-run UNcompleted so
+  // the spec can drive the real cloud onboarding (login -> provision) through the
+  // UI against real Eliza Cloud. The default lane auto-completes a local first-run
+  // so chat/view specs land on a ready agent.
+  const skipAutoFirstRun = process.env.ELIZA_UI_SMOKE_CLOUD_LIVE === "1";
+  if (!skipAutoFirstRun) {
+    const onboardingStatus = await fetchJson<{ complete: boolean }>(
+      `${apiBase}/api/first-run/status`,
+    );
+    if (!onboardingStatus.complete) {
+      await submitFirstRun(apiBase);
+    }
 
-  await waitForJsonPredicate<{ complete: boolean }>(
-    `${apiBase}/api/onboarding/status`,
-    (status) => status.complete === true,
-    READY_TIMEOUT_MS,
-  );
+    await waitForJsonPredicate<{ complete: boolean }>(
+      `${apiBase}/api/first-run/status`,
+      (status) => status.complete === true,
+      READY_TIMEOUT_MS,
+    );
+  }
   await waitForJsonPredicate<{ state?: string }>(
     `${apiBase}/api/status`,
     (status) => status.state === "running",
     READY_TIMEOUT_MS,
   );
+  await waitForJsonPredicate<{ session?: { kind?: string } }>(
+    `${apiBase}/api/auth/me`,
+    (me) => me.session?.kind === "local",
+    READY_TIMEOUT_MS,
+  );
 
   const uiServer = await startUiProxyServer({
     apiBase,
     port: UI_PORT,
+    uiDistDir,
   });
   process.env.ELIZA_API_PORT = String(API_PORT);