Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
27.8 KB
Raw Blame
/**
 * Den-stack harness for eval environments.
 *
 * Brings up everything the cloud eval specs need, idempotently:
 *   1. MySQL (docker compose, reuses the dev:den compose project + volume)
 *   2. Schema push when the persistent database is behind the current checkout
 *   3. den-api behind a local proxy on :8790: bare /* plus den-web
 *      /api/den/* topology (only when not already healthy)
 *   4. Demo-org seed (only when the demo owner cannot sign in)
 *   5. Desktop bootstrap pointed at the local Den + dev Electron with CDP
 *      (only when no CDP endpoint is reachable)
 *   6. A demo-owner session token, exported as OMNIRUSH_EVAL_DEN_API_URL /
 *      OMNIRUSH_EVAL_DEN_TOKEN so env-gated specs run without manual setup.
 *
 * `denStackDown()` stops what the harness started.
 */
import { execFile, spawn } from "node:child_process";
import { openSync } from "node:fs";
import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
import { dirname, join, resolve } from "node:path";
import { fileURLToPath } from "node:url";

const HOSTS_SRC_DIR = dirname(fileURLToPath(import.meta.url));
const REPO_ROOT = resolve(HOSTS_SRC_DIR, "..", "..", "..", "..");
const STATE_DIR = resolve(HOSTS_SRC_DIR, "..", "..", "..", "results", ".den-stack");
const EVAL_ELECTRON_USERDATA = process.env.OMNIRUSH_EVAL_ELECTRON_USERDATA?.trim()
  || join(STATE_DIR, "electron-user-data");

const DEN_API_PORT = Number(process.env.OMNIRUSH_EVAL_DEN_PORT ?? 8790);
const DEN_API_INTERNAL_PORT = DEN_API_PORT + 1;
const DEN_API_URL = `http://127.0.0.1:${DEN_API_PORT}`;
const DEN_API_INTERNAL_URL = `http://127.0.0.1:${DEN_API_INTERNAL_PORT}`;
const DEN_BASE_URL = `http://localhost:${DEN_API_PORT}`;
const DEMO_EMAIL = process.env.DEN_DEMO_OWNER_EMAIL ?? "[email protected]";
const DEMO_PASSWORD = process.env.DEN_DEMO_OWNER_PASSWORD ?? "OmniRushDemo123!";
const MYSQL_CONTAINER = "omnirush-web-local-mysql";
const MYSQL_STATE_DIR = join(STATE_DIR, "mysql");
const MYSQL_SOCKET = join(MYSQL_STATE_DIR, "mysql.sock");
const COMPOSE_ARGS = ["compose", "-p", "omnirush-den-local", "-f", "packaging/docker/docker-compose.web-local.yml"];
const DEFAULT_MOCK_IDP_ISSUER = "http://127.0.0.1:19190";
const MOCK_IDP_ISSUER = (process.env.OMNIRUSH_EVAL_MOCK_IDP_ISSUER?.trim() || DEFAULT_MOCK_IDP_ISSUER).replace(/\/+$/, "");
const DEN_WEB_ORIGIN = (process.env.OMNIRUSH_EVAL_DEN_WEB_URL ?? "http://localhost:3005").replace(/\/+$/, "");
const DEN_WEB_PORT = new URL(DEN_WEB_ORIGIN).port || "3005";

function envCsv(name: string): string[] {
  return (process.env[name] ?? "")
    .split(",")
    .map((entry) => entry.trim().replace(/\/+$/, ""))
    .filter(Boolean);
}

const DEN_TRUSTED_ORIGINS = [
  DEN_BASE_URL,
  DEN_WEB_ORIGIN,
  `http://localhost:${DEN_WEB_PORT}`,
  `http://127.0.0.1:${DEN_WEB_PORT}`,
  "http://localhost:5173",
  "http://127.0.0.1:5173",
  MOCK_IDP_ISSUER,
  ...envCsv("OMNIRUSH_EVAL_DEN_EXTRA_TRUSTED_ORIGINS"),
].filter((origin, index, origins) => origins.indexOf(origin) === index).join(",");

// Override with OMNIRUSH_EVAL_DATABASE_URL to isolate a run from the shared
// dev database (e.g. a dedicated schema on the same MySQL container).
const DEN_DATABASE_URL = process.env.OMNIRUSH_EVAL_DATABASE_URL ?? "mysql://root:[email protected]:3306/omnirush_den";
const DEN_DATABASE_NAME = new URL(DEN_DATABASE_URL).pathname.replace(/^\//, "") || "omnirush_den";
if (!/^[A-Za-z0-9_]+$/.test(DEN_DATABASE_NAME)) {
  throw new Error(`Unsupported Den database name: ${DEN_DATABASE_NAME}`);
}

type DenOrgMode = "single_org" | "multi_org";

interface DenEvalEnvironmentOptions {
  orgMode?: DenOrgMode;
}

export function denEvalEnvironment(options: DenEvalEnvironmentOptions = {}): NodeJS.ProcessEnv {
  const env: NodeJS.ProcessEnv = {
    OMNIRUSH_DEV_MODE: "1",
    DEN_SINGLE_ORG_ALLOW_PUBLIC_SIGNUP: "true",
    PORT: String(DEN_API_INTERNAL_PORT),
    DATABASE_URL: DEN_DATABASE_URL,
    DEN_DB_ENCRYPTION_KEY: "local-dev-db-encryption-key-please-change-1234567890",
    BETTER_AUTH_SECRET: "local-dev-secret-not-for-production-use!!",
    BETTER_AUTH_URL: DEN_WEB_ORIGIN,
    DEN_API_PUBLIC_URL: DEN_API_URL,
    DEN_BETTER_AUTH_TRUSTED_ORIGINS: DEN_TRUSTED_ORIGINS,
    CORS_ORIGINS: DEN_TRUSTED_ORIGINS,
    PROVISIONER_MODE: "stub",
    STRIPE_SECRET_KEY: process.env.STRIPE_SECRET_KEY ?? "sk_test_omnirush_eval",
    STRIPE_INFERENCE_PRICE_ID: process.env.STRIPE_INFERENCE_PRICE_ID ?? "price_omnirush_models_eval",
    STRIPE_WEBHOOK_SECRET: process.env.STRIPE_WEBHOOK_SECRET ?? "whsec_omnirush_eval",
    INFERENCE_PROXY_BASE_URL: process.env.INFERENCE_PROXY_BASE_URL ?? "http://127.0.0.1:8791",
  };
  if (options.orgMode) env.DEN_ORG_MODE = options.orgMode;
  return env;
}

const DEN_ENV = denEvalEnvironment();

const sleep = (ms: number) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms));

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

function errorCode(error: unknown): string | null {
  return isRecord(error) && typeof error.code === "string" ? error.code : null;
}

function isDenOrgMode(value: unknown): value is DenOrgMode {
  return value === "single_org" || value === "multi_org";
}

function devUserDataHome(): string {
  return EVAL_ELECTRON_USERDATA;
}

function devBootstrapPath(): string {
  return join(devUserDataHome(), "omnirush-dev-data", "home", ".config", "omnirush", "desktop-bootstrap.json");
}

async function httpOk(url: string, timeoutMs = 2_500): Promise<boolean> {
  try {
    const controller = new AbortController();
    const timer = setTimeout(() => controller.abort(), timeoutMs);
    const response = await fetch(url, { signal: controller.signal });
    clearTimeout(timer);
    return response.ok;
  } catch {
    return false;
  }
}

async function runtimeOrgMode(timeoutMs = 2_500): Promise<DenOrgMode | null> {
  try {
    const controller = new AbortController();
    const timer = setTimeout(() => controller.abort(), timeoutMs);
    const response = await fetch(`${DEN_WEB_ORIGIN}/api/runtime-config`, { signal: controller.signal });
    clearTimeout(timer);
    if (!response.ok) return null;
    const payload: unknown = await response.json();
    return isRecord(payload) && isDenOrgMode(payload.orgMode) ? payload.orgMode : null;
  } catch {
    return null;
  }
}

function pidIsAlive(pid: number): boolean {
  try {
    process.kill(pid, 0);
    return true;
  } catch (error) {
    return errorCode(error) !== "ESRCH";
  }
}

async function waitForPidGone(pid: number, timeoutMs: number): Promise<boolean> {
  const startedAt = Date.now();
  while (Date.now() - startedAt < timeoutMs) {
    if (!pidIsAlive(pid)) return true;
    await sleep(250);
  }
  return !pidIsAlive(pid);
}

async function stopRecordedProcess(name: string, label: string, log: (message: string) => void): Promise<void> {
  const pidText = await readPidState(name);
  if (!pidText) return;
  const pid = Number(pidText);
  if (!Number.isInteger(pid) || pid <= 0) return;
  let signaled = false;
  try {
    process.kill(-pid, "SIGINT");
    signaled = true;
  } catch {
    // Group may not exist, or this may be Windows.
  }
  try {
    process.kill(pid, "SIGINT");
    signaled = true;
  } catch {
    // Already gone.
  }
  if (signaled) log(`Stopped ${label} for orgMode restart (pid ${pid})`);
  if (await waitForPidGone(pid, 5_000)) return;
  try {
    process.kill(-pid, "SIGKILL");
  } catch {
    // Group may already be gone.
  }
  try {
    process.kill(pid, "SIGKILL");
  } catch {
    // Already gone.
  }
  await waitForPidGone(pid, 1_000);
}

async function hasCdpPageTarget(baseUrl: string): Promise<boolean> {
  try {
    const controller = new AbortController();
    const timer = setTimeout(() => controller.abort(), 2_500);
    const response = await fetch(`${baseUrl}/json/list`, { signal: controller.signal });
    clearTimeout(timer);
    if (!response.ok) return false;
    const targets: unknown = await response.json();
    return Array.isArray(targets)
      && targets.some((target) => isRecord(target) && target.type === "page" && typeof target.webSocketDebuggerUrl === "string");
  } catch {
    return false;
  }
}

async function signInDemoOwner(): Promise<string | null> {
  try {
    const response = await fetch(`${DEN_API_URL}/api/auth/sign-in/email`, {
      method: "POST",
      headers: { "content-type": "application/json", origin: DEN_BASE_URL },
      body: JSON.stringify({ email: DEMO_EMAIL, password: DEMO_PASSWORD }),
    });
    if (!response.ok) return null;
    const payload: unknown = await response.json();
    return isRecord(payload) && typeof payload.token === "string" && payload.token ? payload.token : null;
  } catch {
    return null;
  }
}

interface RunOptions {
  cwd?: string;
  env?: NodeJS.ProcessEnv;
  maxBuffer?: number;
}

interface RunResult {
  stdout: string;
  stderr: string;
}

async function run(command: string, args: string[], options: RunOptions = {}): Promise<RunResult> {
  return new Promise((resolveRun, reject) => {
    execFile(command, args, { cwd: REPO_ROOT, maxBuffer: 16 * 1024 * 1024, encoding: "utf8", ...options }, (error, stdout, stderr) => {
      if (error) {
        reject(error);
        return;
      }
      resolveRun({
        stdout,
        stderr,
      });
    });
  });
}

interface SpawnDetachedOptions {
  logName: string;
  env: NodeJS.ProcessEnv;
  cwd?: string;
}

function spawnDetached(command: string, args: string[], { logName, env, cwd }: SpawnDetachedOptions): number {
  // Redirect stdio to a log file — inheriting it would keep the parent's
  // pipes open forever and hang any shell pipeline wrapping the runner.
  const logFd = openSync(join(STATE_DIR, `${logName}.log`), "a");
  const child = spawn(command, args, {
    cwd: cwd ?? REPO_ROOT,
    env: { ...process.env, ...env },
    detached: true,
    stdio: ["ignore", logFd, logFd],
  });
  child.unref();
  if (!child.pid) throw new Error(`Could not spawn ${command}.`);
  return child.pid;
}

async function writePidState(name: string, value: unknown): Promise<void> {
  await mkdir(STATE_DIR, { recursive: true });
  await writeFile(join(STATE_DIR, name), String(value));
}

async function readPidState(name: string): Promise<string | null> {
  try {
    return (await readFile(join(STATE_DIR, name), "utf8")).trim();
  } catch {
    return null;
  }
}

async function resolveExecutable(names: string[]): Promise<string | null> {
  for (const name of names) {
    try {
      const { stdout } = await run("which", [name]);
      const executable = stdout.trim();
      if (executable) return executable;
    } catch {
      // Try the next compatible binary name.
    }
  }
  return null;
}

function mysqlConnectionArgs(includeDatabase = true): string[] {
  const url = new URL(DEN_DATABASE_URL);
  const args = [
    "--protocol=tcp",
    "-h",
    url.hostname,
    "-P",
    url.port || "3306",
    `-u${decodeURIComponent(url.username || "root")}`,
  ];
  const password = decodeURIComponent(url.password);
  if (password) args.push(`-p${password}`);
  if (includeDatabase) args.push(DEN_DATABASE_NAME);
  return args;
}

async function nativeMysqlQuery(sql: string, includeDatabase = true): Promise<string> {
  const client = await resolveExecutable(["mariadb", "mysql"]);
  if (!client) throw new Error("Neither mariadb nor mysql client is available.");
  const { stdout } = await run(client, [
    ...mysqlConnectionArgs(includeDatabase),
    "-N",
    "-e",
    sql,
  ]);
  return stdout.trim();
}

async function nativeMysqlHealthy(): Promise<boolean> {
  try {
    await nativeMysqlQuery("SELECT 1");
    return true;
  } catch {
    return false;
  }
}

export function nativeMysqlServerArgs(
  runAsRoot = process.getuid?.() === 0,
): string[] {
  const args = [
    `--datadir=${MYSQL_STATE_DIR}`,
    `--socket=${MYSQL_SOCKET}`,
    "--port=3306",
    "--bind-address=127.0.0.1",
    "--skip-networking=0",
    `--pid-file=${join(MYSQL_STATE_DIR, "mysql.pid")}`,
    `--log-error=${join(MYSQL_STATE_DIR, "mysql.error.log")}`,
  ];
  if (runAsRoot) args.push("--user=root");
  return args;
}

export function nativeMysqlSocketArgs(
  authenticated: boolean,
): string[] {
  const url = new URL(DEN_DATABASE_URL);
  const args = [
    "--protocol=socket",
    `--socket=${MYSQL_SOCKET}`,
    `-u${decodeURIComponent(url.username || "root")}`,
  ];
  const password = decodeURIComponent(url.password);
  if (authenticated && password) args.push(`-p${password}`);
  return args;
}

async function ensureNativeMysql(log: (message: string) => void): Promise<void> {
  if (await nativeMysqlHealthy()) {
    await writePidState("mysql.backend", "native");
    log("Native MySQL already healthy");
    return;
  }

  const server = await resolveExecutable(["mariadbd", "mysqld"]);
  const installer = await resolveExecutable(["mariadb-install-db", "mysql_install_db"]);
  const socketClient = await resolveExecutable(["mariadb", "mysql"]);
  if (!server || !installer || !socketClient) {
    throw new Error(
      "Docker is unavailable and the native MySQL server/client toolchain is incomplete.",
    );
  }

  await mkdir(MYSQL_STATE_DIR, { recursive: true });
  try {
    await access(join(MYSQL_STATE_DIR, "mysql"));
  } catch {
    log("Initializing native MariaDB data directory...");
    await run(installer, [
      `--datadir=${MYSQL_STATE_DIR}`,
      "--auth-root-authentication-method=normal",
      "--skip-test-db",
    ]);
  }

  log("Starting native MariaDB...");
  const pid = spawnDetached(
    server,
    nativeMysqlServerArgs(),
    { logName: "mysql", env: {} },
  );
  await writePidState("mysql.pid", pid);
  await writePidState("mysql.backend", "native");

  let socketArgs: string[] | null = null;
  for (let attempt = 0; attempt < 60; attempt += 1) {
    for (const authenticated of [false, true]) {
      const candidateArgs = nativeMysqlSocketArgs(authenticated);
      try {
        await run(socketClient, [
          ...candidateArgs,
          "-N",
          "-e",
          "SELECT 1",
        ]);
        socketArgs = candidateArgs;
        break;
      } catch {
        // A fresh data directory accepts passwordless root while a resumed
        // directory requires the password configured below.
      }
    }
    if (socketArgs) break;
    await sleep(500);
  }
  if (!socketArgs) {
    throw new Error("Native MariaDB did not become ready within 30s.");
  }

  await run(socketClient, [
    ...socketArgs,
    "-e",
    [
      "ALTER USER 'root'@'localhost' IDENTIFIED BY 'password'",
      "CREATE USER IF NOT EXISTS 'root'@'127.0.0.1' IDENTIFIED BY 'password'",
      "GRANT ALL PRIVILEGES ON *.* TO 'root'@'127.0.0.1' WITH GRANT OPTION",
      `CREATE DATABASE IF NOT EXISTS \`${DEN_DATABASE_NAME}\``,
      "FLUSH PRIVILEGES",
    ].join("; "),
  ]);

  for (let attempt = 0; attempt < 30; attempt += 1) {
    if (await nativeMysqlHealthy()) {
      log("Native MariaDB healthy");
      return;
    }
    await sleep(500);
  }
  throw new Error("Native MariaDB did not accept Den database connections within 15s.");
}

async function ensureMysql(log: (message: string) => void): Promise<void> {
  if (process.env.OMNIRUSH_EVAL_DATABASE_URL) {
    if (!(await nativeMysqlHealthy())) {
      throw new Error("OMNIRUSH_EVAL_DATABASE_URL is configured but not reachable.");
    }
    await writePidState("mysql.backend", "external");
    log("External MySQL already healthy");
    return;
  }

  const docker = await resolveExecutable(["docker"]);
  if (!docker) {
    await ensureNativeMysql(log);
    return;
  }

  try {
    const { stdout } = await run(docker, ["inspect", "-f", "{{.State.Health.Status}}", MYSQL_CONTAINER]);
    if (stdout.trim() === "healthy") {
      await writePidState("mysql.backend", "docker");
      log("MySQL already healthy");
      return;
    }
  } catch {
    // Not running — start it below.
  }
  log("Starting MySQL (docker compose)...");
  await run(docker, [...COMPOSE_ARGS, "up", "-d", "--wait", "mysql"]);
  await writePidState("mysql.backend", "docker");
  await writePidState("mysql.started", "1");
  log("MySQL healthy");
}

async function mysqlQuery(sql: string): Promise<string> {
  const backend = await readPidState("mysql.backend");
  if (backend === "native" || backend === "external") {
    return nativeMysqlQuery(sql);
  }
  const docker = await resolveExecutable(["docker"]);
  if (!docker) throw new Error("The selected Docker MySQL backend is unavailable.");
  const { stdout } = await run(docker, [
    "exec", MYSQL_CONTAINER,
    "mysql", "-uroot", "-ppassword", DEN_DATABASE_NAME, "-N", "-e", sql,
  ]);
  return stdout.trim();
}

async function ensureSchema(log: (message: string) => void): Promise<void> {
  try {
    const schema = await mysqlQuery("SHOW TABLES LIKE 'organization'; SHOW TABLES LIKE 'desktop_connect_grant'; SHOW TABLES LIKE 'scim_group'; SHOW COLUMNS FROM scim_provider LIKE 'group_mapping_mode';");
    if (
      schema.includes("organization")
      && schema.includes("desktop_connect_grant")
      && schema.includes("scim_group")
      && schema.includes("group_mapping_mode")
    ) {
      log("Schema present");
      return;
    }
  } catch {
    // Database may not exist yet — push will create what it needs.
  }
  log("Synchronizing schema with the current checkout...");
  const denDbDir = join(REPO_ROOT, "ee", "packages", "den-db");
  await run("pnpm", ["--filter", "@omnirush-ee/den-db", "build"]);
  await run("node", ["--import", "tsx", "./node_modules/drizzle-kit/bin.cjs", "push", "--config", "drizzle.config.ts"], {
    cwd: denDbDir,
    env: { ...process.env, DATABASE_URL: DEN_ENV.DATABASE_URL, DEN_DB_ENCRYPTION_KEY: DEN_ENV.DEN_DB_ENCRYPTION_KEY },
  });
  log("Schema pushed");
}

async function ensureDenApi(log: (message: string) => void, orgMode?: DenOrgMode): Promise<void> {
  const publicHealthOk = await httpOk(`${DEN_API_URL}/health`);
  const denWebPathHealthOk = await httpOk(`${DEN_API_URL}/api/den/health`);
  if (publicHealthOk && denWebPathHealthOk) {
    log("den stack already healthy (with /api/den path)");
    return;
  }
  if (publicHealthOk) {
    throw new Error(
      `A den-api is already healthy on :${DEN_API_PORT}, but it does not serve /api/den. ` +
      "The desktop app cannot use a bare den-api there; rerun with OMNIRUSH_EVAL_DEN_PORT=<free port>.",
    );
  }

  log(`Starting den-api on internal :${DEN_API_INTERNAL_PORT} (proxied on :${DEN_API_PORT})...`);
  const pid = spawnDetached("pnpm", ["exec", "tsx", "src/main.ts"], {
    logName: "den-api",
    cwd: join(REPO_ROOT, "ee", "apps", "den-api"),
    env: denEvalEnvironment({ orgMode }),
  });
  await writePidState("den-api.pid", pid);
  for (let attempt = 0; attempt < 30; attempt += 1) {
    if (await httpOk(`${DEN_API_INTERNAL_URL}/health`)) {
      log("den-api healthy");
      break;
    }
    await sleep(2_000);
  }
  if (!(await httpOk(`${DEN_API_INTERNAL_URL}/health`))) {
    throw new Error(`den-api did not become healthy on internal :${DEN_API_INTERNAL_PORT} within 60s.`);
  }

  if (await httpOk(`${DEN_API_URL}/api/den/health`)) {
    log("den proxy healthy");
    return;
  }

  log(`Starting den proxy on :${DEN_API_PORT} -> :${DEN_API_INTERNAL_PORT}...`);
  const proxyPid = spawnDetached(process.execPath, [join(HOSTS_SRC_DIR, "den-proxy.ts")], {
    logName: "den-proxy",
    env: {
      DEN_PROXY_LISTEN_PORT: String(DEN_API_PORT),
      DEN_PROXY_UPSTREAM_PORT: String(DEN_API_INTERNAL_PORT),
      OMNIRUSH_EVAL_DEN_PROXY_CONTROL: "1",
    },
  });
  await writePidState("den-proxy.pid", proxyPid);
  for (let attempt = 0; attempt < 30; attempt += 1) {
    if (await httpOk(`${DEN_API_URL}/api/den/health`)) {
      log("den proxy healthy");
      return;
    }
    await sleep(1_000);
  }
  throw new Error("den proxy did not expose /api/den/health within 30s.");
}

export async function clearDenWebBuildCache(
  denWebRoot = join(REPO_ROOT, "ee", "apps", "den-web"),
): Promise<void> {
  await rm(join(denWebRoot, ".next"), { recursive: true, force: true });
}

export async function ensureDenOrgMode(orgMode: DenOrgMode | undefined, log: (message: string) => void): Promise<void> {
  if (!orgMode) return;
  const actual = await runtimeOrgMode();
  if (actual === orgMode) {
    log(`Den orgMode already ${orgMode}`);
    return;
  }
  if (!actual && !(await httpOk(`${DEN_API_URL}/health`)) && !(await httpOk(`${DEN_WEB_ORIGIN}/api/den/health`))) {
    return;
  }
  const detail = actual ? `reports ${actual}` : "could not be verified from runtime-config";
  log(`Den orgMode ${detail}; restarting den-api and den-web for ${orgMode}.`);
  await stopRecordedProcess("den-api.pid", "den-api", log);
  await stopRecordedProcess("den-web.pid", "den-web", log);
  await freePorts([DEN_API_PORT, DEN_API_INTERNAL_PORT, Number(DEN_WEB_PORT)].filter((port) => Number.isInteger(port) && port > 0), log, "Den orgMode restart");
  await clearDenWebBuildCache();
}

async function ensureDenWeb(log: (message: string) => void, orgMode?: DenOrgMode): Promise<void> {
  if (await httpOk(`${DEN_WEB_ORIGIN}/api/den/health`)) {
    log(`den-web already healthy at ${DEN_WEB_ORIGIN}`);
    return;
  }

  const webUrl = new URL(DEN_WEB_ORIGIN);
  const denWebPort = webUrl.port || "3005";
  // Reusable Daytona images may retain a generated Next.js route manifest
  // from an older checkout. Dependencies remain cached, but generated app
  // output must match the exact candidate being proved.
  await clearDenWebBuildCache();
  log(`Starting den-web on :${denWebPort}...`);
  const pid = spawnDetached("pnpm", ["dev:den:web"], {
    logName: "den-web",
    env: {
      DEN_API_BASE: DEN_API_URL,
      DEN_AUTH_ORIGIN: DEN_WEB_ORIGIN,
      DEN_AUTH_FALLBACK_BASE: DEN_API_URL,
      DEN_WEB_PORT: denWebPort,
      ...(orgMode ? { DEN_ORG_MODE: orgMode } : {}),
    },
  });
  await writePidState("den-web.pid", pid);
  // A clean Daytona checkout can spend more than 90 seconds compiling the
  // first den-web route even after the process has started successfully.
  for (let attempt = 0; attempt < 90; attempt += 1) {
    if (await httpOk(`${DEN_WEB_ORIGIN}/api/den/health`)) {
      log("den-web healthy");
      return;
    }
    await sleep(2_000);
  }
  throw new Error(`den-web did not become healthy at ${DEN_WEB_ORIGIN} within 180s.`);
}

export function denSeedNodeArgs(): string[] {
  return [
    "--conditions=development",
    "--import",
    "tsx",
    "scripts/seed-demo-org.ts",
  ];
}

async function ensureSeed(log: (message: string) => void): Promise<void> {
  if (await signInDemoOwner()) {
    log(`Demo org present (${DEMO_EMAIL})`);
    return;
  }
  log("Seeding demo org (Acme Robotics)...");
  await run(process.execPath, denSeedNodeArgs(), {
    cwd: join(REPO_ROOT, "ee", "apps", "den-api"),
    env: { ...process.env, ...DEN_ENV },
  });
  if (!(await signInDemoOwner())) {
    throw new Error("Seed completed but the demo owner still cannot sign in.");
  }
  log("Demo org seeded");
}

async function freePorts(ports: number[], log: (message: string) => void, reason: string): Promise<void> {
  for (const port of ports) {
    try {
      const { stdout } = await run("lsof", ["-nP", "-ti", `tcp:${port}`]);
      const pids = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
      for (const pid of pids) {
        try {
          process.kill(Number(pid), "SIGKILL");
          log(`Cleared process ${pid} holding :${port} (${reason})`);
        } catch {
          // Already gone.
        }
      }
    } catch {
      // Port free — nothing to do.
    }
  }
  await sleep(1_500);
}

async function freeStaleAppPorts(log: (message: string) => void): Promise<void> {
  // If no app page target is serving but the dev ports are held, a previous
  // run left a half-dead app behind (e.g. Electron without its renderer).
  // Clear them so the fresh spawn does not lose the bind race.
  await freePorts([9823, 5173], log, "stale app cleanup");
}

async function ensureApp(log: (message: string) => void, cdpCandidates: string[]): Promise<void> {
  for (const candidate of cdpCandidates) {
    if (await hasCdpPageTarget(candidate)) {
      log(`App CDP already reachable at ${candidate} — make sure it targets the local Den (reload after bootstrap changes).`);
      return;
    }
  }

  await freeStaleAppPorts(log);

  const bootstrapPath = devBootstrapPath();
  await mkdir(dirname(bootstrapPath), { recursive: true });
  await writeFile(
    bootstrapPath,
    `${JSON.stringify({ baseUrl: DEN_BASE_URL, requireSignin: false }, null, 2)}\n`,
  );
  await writePidState("bootstrap.path", bootstrapPath);
  log(`Wrote desktop bootstrap -> ${DEN_BASE_URL}`);

  log("Starting dev Electron (pnpm dev)...");
  const pid = spawnDetached("pnpm", ["dev"], {
    logName: "app",
    env: { OMNIRUSH_ELECTRON_USERDATA: EVAL_ELECTRON_USERDATA },
  });
  await writePidState("app.pid", pid);
  for (let attempt = 0; attempt < 45; attempt += 1) {
    for (const candidate of cdpCandidates) {
      if (await hasCdpPageTarget(candidate)) {
        log(`App CDP up at ${candidate}`);
        // Give the renderer a moment to finish booting providers.
        await sleep(8_000);
        return;
      }
    }
    await sleep(4_000);
  }
  throw new Error("Dev Electron CDP page target did not come up within 3 minutes.");
}

export interface EnsureDenStackOptions {
  log(message: string): void;
  cdpCandidates: string[];
  skipApp?: boolean;
  orgMode?: DenOrgMode;
}

export async function ensureDenStack({ log, cdpCandidates, skipApp = false, orgMode }: EnsureDenStackOptions): Promise<void> {
  await mkdir(STATE_DIR, { recursive: true });
  await ensureMysql(log);
  await ensureSchema(log);
  await ensureDenOrgMode(orgMode, log);
  await ensureDenApi(log, orgMode);
  await ensureDenWeb(log, orgMode);
  await ensureSeed(log);
  if (skipApp) {
    log("Skipping dev Electron startup — selected eval flow is app-less");
  } else {
    await ensureApp(log, cdpCandidates);
  }

  const token = await signInDemoOwner();
  if (!token) throw new Error("Could not obtain a demo-owner session token.");

  process.env.OMNIRUSH_EVAL_DEN_API_URL = DEN_API_URL;
  process.env.OMNIRUSH_EVAL_DEN_WEB_URL = DEN_WEB_ORIGIN;
  process.env.OMNIRUSH_EVAL_DEN_TOKEN = token;
  log(`Den stack ready — flows get OMNIRUSH_EVAL_DEN_API_URL=${DEN_API_URL}, OMNIRUSH_EVAL_DEN_WEB_URL=${DEN_WEB_ORIGIN}, and a fresh ${DEMO_EMAIL} token.`);
}

export interface DenStackDownOptions {
  log(message: string): void;
}

export async function denStackDown({ log }: DenStackDownOptions): Promise<void> {
  const proxyPid = await readPidState("den-proxy.pid");
  if (proxyPid) {
    try { process.kill(Number(proxyPid)); log(`Stopped den-proxy (pid ${proxyPid})`); } catch { /* already gone */ }
  }
  const apiPid = await readPidState("den-api.pid");
  if (apiPid) {
    try { process.kill(Number(apiPid)); log(`Stopped den-api (pid ${apiPid})`); } catch { /* already gone */ }
  }
  const webPid = await readPidState("den-web.pid");
  if (webPid) {
    try { process.kill(-Number(webPid)); } catch { /* group gone */ }
    try { process.kill(Number(webPid)); log(`Stopped den-web (pid ${webPid})`); } catch { /* already gone */ }
  }
  const appPid = await readPidState("app.pid");
  if (appPid) {
    try { process.kill(-Number(appPid)); } catch { /* group gone */ }
    try { process.kill(Number(appPid)); log(`Stopped dev app (pid ${appPid})`); } catch { /* already gone */ }
  }
  const bootstrapPath = await readPidState("bootstrap.path");
  if (bootstrapPath) {
    await rm(bootstrapPath, { force: true });
    log("Removed dev desktop bootstrap override");
  }
  const mysqlBackend = await readPidState("mysql.backend");
  const mysqlPid = await readPidState("mysql.pid");
  if (mysqlBackend === "native" && mysqlPid) {
    try {
      process.kill(Number(mysqlPid));
      log(`Stopped native MariaDB (pid ${mysqlPid})`);
    } catch {
      // Already gone.
    }
  } else if (mysqlBackend === "docker") {
    const docker = await resolveExecutable(["docker"]);
    if (docker) {
      try {
        await run(docker, [...COMPOSE_ARGS, "down"]);
        log("MySQL compose project stopped (volume kept)");
      } catch {
        log("Docker compose down skipped (docker unavailable?)");
      }
    }
  }
  await rm(STATE_DIR, { recursive: true, force: true });
}