hypercore-cli 1.1.0

package/dist/telemetry-6R4EIE6O.js

@@ -0,0 +1,30 @@
+import {
+  getEventsFilePath,
+  getEventsSummary,
+  readEvents,
+  setTelemetryEnabled,
+  trackCmdExec,
+  trackError,
+  trackEvent,
+  trackLineRun,
+  trackModelSwitch,
+  trackSessionEnd,
+  trackSessionStart,
+  trackTeamAction,
+  trackWebStart
+} from "./chunk-2CMSCWQW.js";
+export {
+  getEventsFilePath,
+  getEventsSummary,
+  readEvents,
+  setTelemetryEnabled,
+  trackCmdExec,
+  trackError,
+  trackEvent,
+  trackLineRun,
+  trackModelSwitch,
+  trackSessionEnd,
+  trackSessionStart,
+  trackTeamAction,
+  trackWebStart
+};

package/dist/test-runner-ZQH5Y6OJ.js

@@ -0,0 +1,619 @@
+import {
+  HYPERCORE_DIR
+} from "./chunk-V5UHPPSY.js";
+
+// src/admin/test-runner.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+var DEFAULT_TIMEOUT_MS = 3 * 60 * 1e3;
+var MAX_OUTPUT_CHARS = 2e4;
+var MAX_OUTPUT_LOG_CHARS = 5e5;
+var MAX_HISTORY_RUNS = 30;
+var HISTORY_PREVIEW_RUNS = 10;
+var DEFAULT_AUTO_INTERVAL_MINUTES = 30;
+var MIN_AUTO_INTERVAL_MINUTES = 5;
+var MAX_AUTO_INTERVAL_MINUTES = 24 * 60;
+var DEFAULT_BASE_URL = "http://127.0.0.1:3210";
+var activeRun = null;
+var latestRun = null;
+var runHistoryLoaded = false;
+var runHistory = [];
+var autoConfigLoaded = false;
+var autoConfig = null;
+var autoSchedulerTimer = null;
+var autoNextRunAt = null;
+var autoLastAttemptAt = null;
+var autoLastRunId = null;
+var autoLastError = null;
+var autoContext = {
+  projectRoot: process.cwd(),
+  baseUrl: DEFAULT_BASE_URL
+};
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function trimTail(text) {
+  if (text.length <= MAX_OUTPUT_CHARS) return text;
+  return text.slice(text.length - MAX_OUTPUT_CHARS);
+}
+function trimLog(text) {
+  if (text.length <= MAX_OUTPUT_LOG_CHARS) return text;
+  return text.slice(text.length - MAX_OUTPUT_LOG_CHARS);
+}
+function historyFilePath() {
+  return join(HYPERCORE_DIR, "admin", "test-runs.json");
+}
+function logsDirPath() {
+  return join(HYPERCORE_DIR, "admin", "test-run-logs");
+}
+function runLogFilePath(runId) {
+  return join(logsDirPath(), `${runId}.log`);
+}
+function autoConfigFilePath() {
+  return join(HYPERCORE_DIR, "admin", "test-auto.json");
+}
+function sanitizeFileToken(value) {
+  const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "_");
+  return normalized.replace(/^_+|_+$/g, "") || "unknown";
+}
+function getTestRunDownloadFileName(info, ext = "log") {
+  const suiteId = sanitizeFileToken(info.suiteId);
+  const version = sanitizeFileToken(info.suiteVersion);
+  const runId = sanitizeFileToken(info.runId);
+  return `hypermirror-${suiteId}-v${version}-${runId}.${ext}`;
+}
+function formatTestRunDownloadText(detail) {
+  const info = detail.info;
+  const headerLines = [
+    "# HyperMirror Test Run Log",
+    `runId: ${info.runId}`,
+    `suiteId: ${info.suiteId}`,
+    `suiteName: ${info.suiteName}`,
+    `suiteVersion: ${info.suiteVersion}`,
+    `status: ${info.status}`,
+    `startedAt: ${info.startedAt}`,
+    `endedAt: ${info.endedAt || "-"}`,
+    `durationMs: ${info.durationMs ?? "-"}`,
+    `exitCode: ${info.exitCode ?? "-"}`,
+    `signal: ${info.signal ?? "-"}`,
+    `isRunning: ${detail.isRunning ? "true" : "false"}`,
+    "---"
+  ];
+  const output = detail.output || "";
+  return `${headerLines.join("\n")}
+${output}`;
+}
+function normalizeExec(exec) {
+  if (!Array.isArray(exec)) return [];
+  return exec.filter((v) => typeof v === "string" && v.trim().length > 0);
+}
+function sanitizeSuite(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const id = typeof obj.id === "string" ? obj.id.trim() : "";
+  const name = typeof obj.name === "string" ? obj.name.trim() : "";
+  const version = typeof obj.version === "string" ? obj.version.trim() : "";
+  const description = typeof obj.description === "string" ? obj.description : void 0;
+  const exec = normalizeExec(obj.exec);
+  const timeoutMs = typeof obj.timeoutMs === "number" && Number.isFinite(obj.timeoutMs) && obj.timeoutMs > 0 ? Math.floor(obj.timeoutMs) : void 0;
+  if (!id || !name || !version || exec.length === 0) return null;
+  return { id, name, version, description, exec, timeoutMs };
+}
+function defaultManifest() {
+  return {
+    schemaVersion: 1,
+    activeSuiteId: "api-regression",
+    suites: [
+      {
+        id: "api-regression",
+        name: "API Regression",
+        version: "1.0.0",
+        description: "\u8986\u76D6\u6838\u5FC3 Web/API/WS \u4E3B\u94FE\u8DEF",
+        exec: ["node", "tests/e2e/run-api-regression.mjs"],
+        timeoutMs: DEFAULT_TIMEOUT_MS
+      }
+    ]
+  };
+}
+function normalizeManifest(raw) {
+  const base = defaultManifest();
+  if (!raw || typeof raw !== "object") return base;
+  const obj = raw;
+  const suites = Array.isArray(obj.suites) ? obj.suites.map(sanitizeSuite).filter((s) => !!s) : [];
+  const schemaVersion = typeof obj.schemaVersion === "number" && Number.isFinite(obj.schemaVersion) ? Math.floor(obj.schemaVersion) : 1;
+  const activeSuiteId = typeof obj.activeSuiteId === "string" && obj.activeSuiteId.trim() ? obj.activeSuiteId.trim() : suites[0]?.id || base.activeSuiteId;
+  return {
+    schemaVersion,
+    activeSuiteId,
+    suites: suites.length > 0 ? suites : base.suites
+  };
+}
+function resolveRunnerContext(projectRootOrOpts) {
+  const envBaseUrl = process.env.HYPER_E2E_BASE_URL || DEFAULT_BASE_URL;
+  if (typeof projectRootOrOpts === "string") {
+    return {
+      projectRoot: projectRootOrOpts || process.cwd(),
+      baseUrl: envBaseUrl
+    };
+  }
+  const opts = projectRootOrOpts || {};
+  return {
+    projectRoot: opts.projectRoot || process.cwd(),
+    baseUrl: opts.baseUrl?.trim() || envBaseUrl
+  };
+}
+function pickDefaultSuiteId(manifest) {
+  if (manifest.activeSuiteId && manifest.suites.some((s) => s.id === manifest.activeSuiteId)) {
+    return manifest.activeSuiteId;
+  }
+  return manifest.suites[0]?.id || "";
+}
+function clampAutoIntervalMinutes(value) {
+  return Math.min(MAX_AUTO_INTERVAL_MINUTES, Math.max(MIN_AUTO_INTERVAL_MINUTES, Math.floor(value)));
+}
+function parseIntervalMinutes(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return clampAutoIntervalMinutes(value);
+  }
+  if (typeof value === "string" && value.trim()) {
+    const num = Number(value);
+    if (Number.isFinite(num)) {
+      return clampAutoIntervalMinutes(num);
+    }
+  }
+  return null;
+}
+function normalizeAutoRegressionConfig(raw, manifest) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  const suiteSet = new Set(manifest.suites.map((s) => s.id));
+  const defaultSuiteId = pickDefaultSuiteId(manifest);
+  const intervalMinutes = parseIntervalMinutes(obj.intervalMinutes) ?? DEFAULT_AUTO_INTERVAL_MINUTES;
+  const suiteCandidate = typeof obj.suiteId === "string" ? obj.suiteId.trim() : "";
+  const suiteId = suiteSet.has(suiteCandidate) ? suiteCandidate : defaultSuiteId;
+  return {
+    enabled: typeof obj.enabled === "boolean" ? obj.enabled : false,
+    suiteId,
+    intervalMinutes,
+    updatedAt: typeof obj.updatedAt === "string" && obj.updatedAt ? obj.updatedAt : nowISO()
+  };
+}
+function autoRuntimeSnapshot(config) {
+  return {
+    nextRunAt: autoNextRunAt,
+    lastAttemptAt: autoLastAttemptAt,
+    lastRunId: autoLastRunId,
+    lastError: autoLastError,
+    schedulerState: config.enabled && !!autoSchedulerTimer ? "active" : "idle"
+  };
+}
+function autoSnapshot(config) {
+  return {
+    config,
+    runtime: autoRuntimeSnapshot(config)
+  };
+}
+function clearAutoSchedulerTimer() {
+  if (autoSchedulerTimer) {
+    clearTimeout(autoSchedulerTimer);
+    autoSchedulerTimer = null;
+  }
+  autoNextRunAt = null;
+}
+function applyAutoContext(context) {
+  autoContext = context;
+}
+function sanitizeRunInfo(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const runId = typeof obj.runId === "string" ? obj.runId : "";
+  const suiteId = typeof obj.suiteId === "string" ? obj.suiteId : "";
+  const suiteName = typeof obj.suiteName === "string" ? obj.suiteName : "";
+  const suiteVersion = typeof obj.suiteVersion === "string" ? obj.suiteVersion : "";
+  const startedAt = typeof obj.startedAt === "string" ? obj.startedAt : "";
+  const endedAt = typeof obj.endedAt === "string" ? obj.endedAt : void 0;
+  const durationMs = typeof obj.durationMs === "number" && Number.isFinite(obj.durationMs) ? Math.floor(obj.durationMs) : void 0;
+  const status = typeof obj.status === "string" ? obj.status : "";
+  const outputTail = typeof obj.outputTail === "string" ? trimTail(obj.outputTail) : "";
+  const exitCode = typeof obj.exitCode === "number" || obj.exitCode === null ? obj.exitCode : void 0;
+  const signal = typeof obj.signal === "string" || obj.signal === null ? obj.signal : void 0;
+  if (!runId || !suiteId || !suiteName || !suiteVersion || !startedAt || !status) {
+    return null;
+  }
+  if (!["running", "passed", "failed", "timeout"].includes(status)) {
+    return null;
+  }
+  return {
+    runId,
+    suiteId,
+    suiteName,
+    suiteVersion,
+    startedAt,
+    endedAt,
+    durationMs,
+    status,
+    exitCode,
+    signal,
+    outputTail
+  };
+}
+async function loadRunHistory() {
+  if (runHistoryLoaded) return;
+  runHistoryLoaded = true;
+  const file = historyFilePath();
+  if (!existsSync(file)) {
+    runHistory = [];
+    return;
+  }
+  try {
+    const content = await readFile(file, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed)) {
+      runHistory = [];
+      return;
+    }
+    runHistory = parsed.map(sanitizeRunInfo).filter((v) => !!v).slice(0, MAX_HISTORY_RUNS);
+  } catch {
+    runHistory = [];
+  }
+}
+async function persistRunHistory() {
+  const file = historyFilePath();
+  await mkdir(join(HYPERCORE_DIR, "admin"), { recursive: true });
+  await writeFile(file, JSON.stringify(runHistory.slice(0, MAX_HISTORY_RUNS), null, 2), "utf-8");
+}
+async function writeRunLog(runId, output) {
+  await mkdir(logsDirPath(), { recursive: true });
+  await writeFile(runLogFilePath(runId), trimLog(output), "utf-8");
+}
+async function readRunLog(runId) {
+  try {
+    const file = runLogFilePath(runId);
+    if (!existsSync(file)) return null;
+    return await readFile(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function cleanupRunLogs() {
+  const dir = logsDirPath();
+  if (!existsSync(dir)) return;
+  const keep = new Set(runHistory.map((r) => `${r.runId}.log`));
+  try {
+    const files = await readdir(dir);
+    await Promise.all(
+      files.filter((file) => file.endsWith(".log") && !keep.has(file)).map((file) => unlink(join(dir, file)).catch(() => {
+      }))
+    );
+  } catch {
+  }
+}
+async function appendHistory(info) {
+  await loadRunHistory();
+  runHistory = [info, ...runHistory.filter((r) => r.runId !== info.runId)].slice(0, MAX_HISTORY_RUNS);
+  await persistRunHistory();
+  await cleanupRunLogs();
+}
+async function loadAutoRegressionConfig(manifest) {
+  if (autoConfigLoaded && autoConfig) {
+    autoConfig = normalizeAutoRegressionConfig(autoConfig, manifest);
+    return autoConfig;
+  }
+  autoConfigLoaded = true;
+  const file = autoConfigFilePath();
+  if (!existsSync(file)) {
+    autoConfig = normalizeAutoRegressionConfig({}, manifest);
+    return autoConfig;
+  }
+  try {
+    const content = await readFile(file, "utf-8");
+    const parsed = JSON.parse(content);
+    autoConfig = normalizeAutoRegressionConfig(parsed, manifest);
+    return autoConfig;
+  } catch {
+    autoConfig = normalizeAutoRegressionConfig({}, manifest);
+    return autoConfig;
+  }
+}
+async function persistAutoRegressionConfig(config) {
+  const file = autoConfigFilePath();
+  await mkdir(join(HYPERCORE_DIR, "admin"), { recursive: true });
+  await writeFile(file, JSON.stringify(config, null, 2), "utf-8");
+}
+function scheduleNextAutoRegressionRun(config) {
+  clearAutoSchedulerTimer();
+  if (!config.enabled) return;
+  const delayMs = config.intervalMinutes * 60 * 1e3;
+  autoNextRunAt = new Date(Date.now() + delayMs).toISOString();
+  autoSchedulerTimer = setTimeout(() => {
+    void executeAutoRegressionRun();
+  }, delayMs);
+  if (typeof autoSchedulerTimer.unref === "function") {
+    autoSchedulerTimer.unref();
+  }
+}
+async function executeAutoRegressionRun() {
+  autoSchedulerTimer = null;
+  autoNextRunAt = null;
+  const config = autoConfig;
+  if (!config || !config.enabled) return;
+  autoLastAttemptAt = nowISO();
+  try {
+    const snapshot = await startTestSuiteRun({
+      projectRoot: autoContext.projectRoot,
+      baseUrl: autoContext.baseUrl,
+      suiteId: config.suiteId,
+      trigger: "auto"
+    });
+    autoLastRunId = snapshot.running?.runId || snapshot.latest?.runId || autoLastRunId;
+    autoLastError = null;
+  } catch (err) {
+    if (err && typeof err === "object" && "statusCode" in err && err.statusCode === 409) {
+      autoLastError = "\u8DF3\u8FC7\u81EA\u52A8\u56DE\u5F52\uFF1A\u5DF2\u6709\u6D4B\u8BD5\u8FD0\u884C\u4E2D";
+    } else {
+      autoLastError = err instanceof Error ? err.message : String(err);
+    }
+  } finally {
+    if (autoConfig?.enabled) {
+      scheduleNextAutoRegressionRun(autoConfig);
+    }
+  }
+}
+function ensureAutoScheduler(config) {
+  if (!config.enabled) {
+    clearAutoSchedulerTimer();
+    return;
+  }
+  if (!autoSchedulerTimer) {
+    scheduleNextAutoRegressionRun(config);
+  }
+}
+async function ensureAutoConfig(context, manifest) {
+  applyAutoContext(context);
+  const config = await loadAutoRegressionConfig(manifest);
+  autoConfig = config;
+  return config;
+}
+async function getAutoRegressionSnapshot(opts = process.cwd()) {
+  const context = resolveRunnerContext(opts);
+  const manifest = await loadTestSuiteManifest(context.projectRoot);
+  const config = await ensureAutoConfig(context, manifest);
+  ensureAutoScheduler(config);
+  return autoSnapshot(config);
+}
+async function updateAutoRegressionConfig(update, opts = process.cwd()) {
+  const context = resolveRunnerContext(opts);
+  const manifest = await loadTestSuiteManifest(context.projectRoot);
+  const current = await ensureAutoConfig(context, manifest);
+  const suiteSet = new Set(manifest.suites.map((s) => s.id));
+  let enabled = current.enabled;
+  if (Object.prototype.hasOwnProperty.call(update, "enabled")) {
+    if (typeof update.enabled !== "boolean") {
+      throw new TestRunnerError("enabled \u5FC5\u987B\u662F boolean", 400);
+    }
+    enabled = update.enabled;
+  }
+  let suiteId = current.suiteId;
+  if (Object.prototype.hasOwnProperty.call(update, "suiteId")) {
+    if (typeof update.suiteId !== "string" || !update.suiteId.trim()) {
+      throw new TestRunnerError("suiteId \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32", 400);
+    }
+    const candidate = update.suiteId.trim();
+    if (!suiteSet.has(candidate)) {
+      throw new TestRunnerError(`\u672A\u77E5\u6D4B\u8BD5\u5957\u4EF6: ${candidate}`, 400);
+    }
+    suiteId = candidate;
+  }
+  let intervalMinutes = current.intervalMinutes;
+  if (Object.prototype.hasOwnProperty.call(update, "intervalMinutes")) {
+    if (typeof update.intervalMinutes !== "number" || !Number.isFinite(update.intervalMinutes)) {
+      throw new TestRunnerError("intervalMinutes \u5FC5\u987B\u662F\u6570\u5B57", 400);
+    }
+    const value = Math.floor(update.intervalMinutes);
+    if (value < MIN_AUTO_INTERVAL_MINUTES || value > MAX_AUTO_INTERVAL_MINUTES) {
+      throw new TestRunnerError(`intervalMinutes \u5FC5\u987B\u5728 ${MIN_AUTO_INTERVAL_MINUTES}-${MAX_AUTO_INTERVAL_MINUTES} \u4E4B\u95F4`, 400);
+    }
+    intervalMinutes = value;
+  }
+  const nextConfig = {
+    enabled,
+    suiteId,
+    intervalMinutes,
+    updatedAt: nowISO()
+  };
+  autoConfig = nextConfig;
+  await persistAutoRegressionConfig(nextConfig);
+  if (nextConfig.enabled) {
+    autoLastError = null;
+    scheduleNextAutoRegressionRun(nextConfig);
+  } else {
+    clearAutoSchedulerTimer();
+  }
+  return autoSnapshot(nextConfig);
+}
+async function loadTestSuiteManifest(projectRoot = process.cwd()) {
+  const manifestPath = join(projectRoot, "tests", "e2e", "manifest.json");
+  if (!existsSync(manifestPath)) {
+    return defaultManifest();
+  }
+  try {
+    const content = await readFile(manifestPath, "utf-8");
+    return normalizeManifest(JSON.parse(content));
+  } catch {
+    return defaultManifest();
+  }
+}
+function materializeRunningInfo(run) {
+  return {
+    ...run.info,
+    durationMs: Date.now() - run.startedMs,
+    outputTail: trimTail(run.output)
+  };
+}
+async function getTestRunnerSnapshot(opts = process.cwd()) {
+  const context = resolveRunnerContext(opts);
+  await loadRunHistory();
+  const manifest = await loadTestSuiteManifest(context.projectRoot);
+  const automationConfig = await ensureAutoConfig(context, manifest);
+  ensureAutoScheduler(automationConfig);
+  return {
+    manifest,
+    running: activeRun ? materializeRunningInfo(activeRun) : null,
+    latest: latestRun,
+    history: runHistory.slice(0, HISTORY_PREVIEW_RUNS),
+    automation: autoSnapshot(automationConfig)
+  };
+}
+async function getTestRunDetail(runId) {
+  await loadRunHistory();
+  if (activeRun && activeRun.info.runId === runId) {
+    return {
+      info: materializeRunningInfo(activeRun),
+      output: trimLog(activeRun.output),
+      isRunning: true
+    };
+  }
+  const info = runHistory.find((r) => r.runId === runId);
+  if (!info) {
+    throw new TestRunnerError(`\u672A\u627E\u5230\u6D4B\u8BD5\u8FD0\u884C\u8BB0\u5F55: ${runId}`, 404);
+  }
+  const output = await readRunLog(runId);
+  return {
+    info,
+    output: output || info.outputTail || "",
+    isRunning: false
+  };
+}
+var TestRunnerError = class extends Error {
+  statusCode;
+  constructor(message, statusCode = 400) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+};
+async function startTestSuiteRun(opts = {}) {
+  if (activeRun) {
+    throw new TestRunnerError("\u5DF2\u6709\u6D4B\u8BD5\u4EFB\u52A1\u5728\u8FD0\u884C\u4E2D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5", 409);
+  }
+  await loadRunHistory();
+  const context = resolveRunnerContext(opts);
+  const projectRoot = context.projectRoot;
+  const manifest = await loadTestSuiteManifest(projectRoot);
+  const automationConfig = await ensureAutoConfig(context, manifest);
+  const targetSuiteId = opts.suiteId || manifest.activeSuiteId || manifest.suites[0]?.id;
+  const suite = manifest.suites.find((s) => s.id === targetSuiteId) || manifest.suites[0];
+  if (!suite) {
+    throw new TestRunnerError("\u672A\u627E\u5230\u53EF\u6267\u884C\u6D4B\u8BD5\u5957\u4EF6", 404);
+  }
+  if (suite.exec.length === 0) {
+    throw new TestRunnerError(`\u6D4B\u8BD5\u5957\u4EF6 ${suite.id} \u672A\u914D\u7F6E exec`, 400);
+  }
+  const runId = `test_${Date.now().toString(36)}`;
+  const startedAt = nowISO();
+  const command = suite.exec[0];
+  const args = suite.exec.slice(1);
+  const env = {
+    ...process.env,
+    HYPER_E2E_BASE_URL: context.baseUrl || process.env.HYPER_E2E_BASE_URL || DEFAULT_BASE_URL,
+    HYPER_E2E_SUITE_ID: suite.id,
+    HYPER_E2E_SUITE_VERSION: suite.version
+  };
+  const child = spawn(command, args, {
+    cwd: projectRoot,
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const timeoutMs = suite.timeoutMs || DEFAULT_TIMEOUT_MS;
+  const info = {
+    runId,
+    suiteId: suite.id,
+    suiteName: suite.name,
+    suiteVersion: suite.version,
+    startedAt,
+    status: "running",
+    outputTail: ""
+  };
+  activeRun = {
+    child,
+    startedMs: Date.now(),
+    timer: setTimeout(() => {
+      if (!activeRun || activeRun.info.runId !== runId) return;
+      activeRun.timedOut = true;
+      activeRun.info.status = "timeout";
+      child.kill("SIGTERM");
+    }, timeoutMs),
+    info,
+    output: "",
+    timedOut: false
+  };
+  const appendOutput = (chunk) => {
+    if (!activeRun || activeRun.info.runId !== runId) return;
+    activeRun.output = trimLog(`${activeRun.output}${chunk.toString("utf-8")}`);
+  };
+  child.stdout.on("data", appendOutput);
+  child.stderr.on("data", appendOutput);
+  child.on("error", (err) => {
+    if (!activeRun || activeRun.info.runId !== runId) return;
+    clearTimeout(activeRun.timer);
+    const endedAt = nowISO();
+    latestRun = {
+      ...activeRun.info,
+      endedAt,
+      durationMs: Date.now() - activeRun.startedMs,
+      status: "failed",
+      exitCode: null,
+      signal: null,
+      outputTail: trimTail(`${activeRun.output}
+[runner error] ${err.message}`)
+    };
+    writeRunLog(latestRun.runId, `${activeRun.output}
+[runner error] ${err.message}`).catch(() => {
+    });
+    appendHistory(latestRun).catch(() => {
+    });
+    activeRun = null;
+  });
+  child.on("exit", (code, signal) => {
+    if (!activeRun || activeRun.info.runId !== runId) return;
+    clearTimeout(activeRun.timer);
+    const endedAt = nowISO();
+    const status = activeRun.timedOut ? "timeout" : code === 0 ? "passed" : "failed";
+    latestRun = {
+      ...activeRun.info,
+      endedAt,
+      durationMs: Date.now() - activeRun.startedMs,
+      status,
+      exitCode: code,
+      signal,
+      outputTail: trimTail(activeRun.output)
+    };
+    writeRunLog(latestRun.runId, activeRun.output).catch(() => {
+    });
+    appendHistory(latestRun).catch(() => {
+    });
+    activeRun = null;
+  });
+  const running = activeRun ? materializeRunningInfo(activeRun) : null;
+  if (opts.trigger !== "auto" && automationConfig.enabled) {
+    scheduleNextAutoRegressionRun(automationConfig);
+  }
+  return {
+    manifest,
+    running,
+    latest: latestRun,
+    history: runHistory.slice(0, HISTORY_PREVIEW_RUNS),
+    automation: autoSnapshot(automationConfig)
+  };
+}
+export {
+  TestRunnerError,
+  formatTestRunDownloadText,
+  getAutoRegressionSnapshot,
+  getTestRunDetail,
+  getTestRunDownloadFileName,
+  getTestRunnerSnapshot,
+  loadTestSuiteManifest,
+  startTestSuiteRun,
+  updateAutoRegressionConfig
+};

package/dist/theme-3SYJ3UQA.js

@@ -0,0 +1,14 @@
+import {
+  THEME_LABELS,
+  getAvailableThemes,
+  getTheme,
+  getThemeName,
+  setTheme
+} from "./chunk-RNG3K465.js";
+export {
+  THEME_LABELS,
+  getAvailableThemes,
+  getTheme,
+  getThemeName,
+  setTheme
+};