explorbot 0.2.3 → 0.2.5

package/src/commands/config-command.ts

@@ -0,0 +1,146 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { type AIConfig, ConfigParser, EXPLORBOT_ENV_VARS, type ReporterConfig, configuredModels } from '../config.js';
+import { listSites } from '../global-config.js';
+import { Reporter } from '../reporter.js';
+import { getCliName } from '../utils/cli-name.js';
+import { tag } from '../utils/logger.js';
+import { BaseCommand } from './base-command.js';
+
+export class ConfigCommand extends BaseCommand {
+  name = 'config';
+  description = 'Show models, config file and paths used by this run';
+
+  async execute(): Promise<void> {
+    const parser = ConfigParser.getInstance();
+    tag('info').log(ConfigCommand.render(this.explorBot.getConfig(), { configPath: parser.getConfigPath(), root: parser.getProjectRoot() }));
+  }
+
+  static async summary(options: { config?: string; path?: string; url?: string; json?: boolean } = {}): Promise<string> {
+    const parser = ConfigParser.getInstance();
+    const [site] = listSites();
+    const load = (baseUrl?: string) => parser.loadConfig({ config: options.config, path: options.path, baseUrl });
+
+    const config = await load(options.url).catch((error) => {
+      if (!site) throw error;
+      return load(site.url);
+    });
+
+    return ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json });
+  }
+
+  static data(config: SummarizedConfig, options: ConfigSummaryOptions = {}): ConfigData {
+    let configPath = '';
+    if (options.configPath && existsSync(options.configPath)) configPath = options.configPath;
+
+    const dirs: Record<string, string> = {};
+    if (options.root) {
+      for (const [name, dir] of Object.entries({ output: 'output', ...config.dirs })) {
+        dirs[name] = path.join(options.root, dir);
+      }
+    }
+
+    const env: Record<string, string> = {};
+    for (const variable of EXPLORBOT_ENV_VARS) {
+      const value = process.env[variable.name];
+      if (value) env[variable.name] = value;
+    }
+
+    const models: Record<string, string> = {};
+    const providers: Record<string, string> = {};
+    for (const [role, model] of Object.entries(configuredModels(config.ai))) {
+      models[role] = model.name;
+      if (model.provider) providers[role] = model.provider;
+    }
+
+    return {
+      config: configPath,
+      url: config.playwright?.url || config.web?.url || config.api?.baseEndpoint || '',
+      browser: config.playwright?.browser || '',
+      headless: !config.playwright?.show,
+      dirs,
+      models,
+      providers,
+      integrations: {
+        langfuse: !!config.ai?.langfuse?.enabled,
+        testomatio: Reporter.resolveEnabled(config.reporter),
+      },
+      env,
+    };
+  }
+
+  static render(config: SummarizedConfig, options: ConfigSummaryOptions = {}): string {
+    const data = ConfigCommand.data(config, options);
+    if (options.json) return JSON.stringify(data, null, 2);
+
+    const lines: string[] = [];
+    const section = (title: string, entries: [string, string][]) => {
+      if (!entries.length) return;
+      const width = Math.max(...entries.map(([label]) => label.length));
+      lines.push(chalk.bold(title));
+      for (const [label, value] of entries) lines.push(`  ${chalk.dim(label.padEnd(width))}  ${value}`);
+      lines.push('');
+    };
+
+    const general: [string, string][] = [['config', data.config || 'EXPLORBOT_* environment variables']];
+    if (data.url) general.push(['url', data.url]);
+    if (data.browser) {
+      let window = 'visible';
+      if (data.headless) window = 'headless';
+      general.push(['browser', `${data.browser}, ${window}`]);
+    }
+    for (const [name, dir] of Object.entries(data.dirs)) general.push([name, dir]);
+    section('Config', general);
+
+    const providerWidth = Math.max(0, ...Object.values(data.providers).map((provider) => provider.length));
+    const models: [string, string][] = Object.entries(data.models).map(([role, model]) => {
+      if (!providerWidth) return [role, model];
+      return [role, `${chalk.dim((data.providers[role] || '').padEnd(providerWidth))}  ${model}`];
+    });
+    if (!models.length) models.push(['model', chalk.red(`not configured — run ${getCliName()} init`)]);
+    section('Models', models);
+
+    const integrations: [string, string][] = [];
+    if (data.integrations.langfuse) integrations.push(['langfuse', 'traces sent']);
+    if (data.integrations.testomatio) integrations.push(['testomatio', 'runs reported']);
+    section('Integrations', integrations);
+
+    const env: [string, string][] = Object.entries(data.env).map(([name, value]) => {
+      let shown = value;
+      if (shown.length > 60) shown = `${shown.slice(0, 57)}...`;
+      return [name, shown];
+    });
+    section('Environment', env);
+
+    lines.push(chalk.dim(`Every EXPLORBOT_* variable: ${getCliName()} --help`));
+    return lines.join('\n');
+  }
+}
+
+interface ConfigSummaryOptions {
+  configPath?: string | null;
+  root?: string;
+  json?: boolean;
+}
+
+export interface ConfigData {
+  config: string;
+  url: string;
+  browser: string;
+  headless: boolean;
+  dirs: Record<string, string>;
+  models: Record<string, string>;
+  providers: Record<string, string>;
+  integrations: { langfuse: boolean; testomatio: boolean };
+  env: Record<string, string>;
+}
+
+interface SummarizedConfig {
+  ai?: AIConfig;
+  playwright?: { url?: string; browser?: string; show?: boolean };
+  web?: { url?: string };
+  api?: { baseEndpoint?: string };
+  dirs?: Record<string, string>;
+  reporter?: ReporterConfig;
+}

package/src/commands/index.ts

@@ -3,6 +3,7 @@ import { AddRuleCommand } from './add-rule-command.js';
 import type { BaseCommand } from './base-command.js';
 import { CleanCommand } from './clean-command.js';
 import { CompactCommand } from './compact-command.js';
+import { ConfigCommand } from './config-command.js';
 import { ContextAriaCommand } from './context-aria-command.js';
 import { ContextCommand } from './context-command.js';
 import { ContextDataCommand } from './context-data-command.js';
@@ -70,6 +71,7 @@ const commandClasses: CommandClass[] = [
   RunsCommand,
   RerunCommand,
   StatusCommand,
+  ConfigCommand,
   DebugCommand,
   ExitCommand,
 ];

package/src/config.ts

@@ -1,12 +1,13 @@
 import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path, { basename, dirname, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { parseEnv } from 'node:util';
 import dedent from 'dedent';
 import matter from 'gray-matter';
 import { type SiteRecord, findGlobalConfig, globalEnvPath, isGlobalConfigPath, registerSite, resolveSiteTarget } from './global-config.js';
 import { getCliName } from './utils/cli-name.js';
-import { log } from './utils/logger.js';
+import { log, tag } from './utils/logger.js';
 
 export const PROVIDERS: Record<string, ProviderInfo> = {
   openai: { envKey: 'OPENAI_API_KEY', load: async () => (await import('@ai-sdk/openai')).createOpenAI() },
@@ -197,6 +198,7 @@ interface HtmlConfig {
 interface ActionConfig {
   delay?: number;
   retries?: number;
+  timeout?: number;
 }
 
 interface ReporterConfig {
@@ -455,7 +457,15 @@ export class ConfigParser {
   }
 
   public resolveTargetPath(target?: string): string {
-    if (!this.site) return target || '/';
+    if (!this.site) {
+      const configured = this.config?.playwright?.url || this.config?.web?.url;
+      const targetOrigin = target ? URL.parse(target)?.origin : null;
+      const baseOrigin = configured ? URL.parse(configured)?.origin : null;
+      if (targetOrigin && baseOrigin && targetOrigin !== baseOrigin) {
+        tag('warning').log(`Exploring ${targetOrigin} but base URL is ${baseOrigin}. Relative navigation resolves against the base URL — set web.url to ${targetOrigin} to avoid it.`);
+      }
+      return target || '/';
+    }
     if (!target) return this.siteStartPath;
 
     const resolved = resolveSiteTarget(target, this.site.url);
@@ -504,6 +514,7 @@ export class ConfigParser {
         model: { modelId: 'test-model', provider: 'test' },
         config: {},
         vision: false,
+        langfuse: { enabled: false },
       },
       dirs: {
         knowledge: join(testBaseDir, 'knowledge'),
@@ -610,17 +621,18 @@ export class ConfigParser {
 
   private async loadConfigModule(configPath: string): Promise<any> {
     const ext = configPath.split('.').pop();
+    const moduleUrl = pathToFileURL(resolve(configPath)).href;
 
     if (ext === 'ts') {
       try {
-        const module = await import(configPath);
+        const module = await import(moduleUrl);
         return module;
       } catch (error) {
         const require = (await import('node:module')).createRequire(import.meta.url);
         return require(configPath);
       }
     } else if (ext === 'js' || ext === 'mjs') {
-      const module = await import(configPath);
+      const module = await import(moduleUrl);
       return module;
     } else {
       const content = readFileSync(configPath, 'utf8');
@@ -639,6 +651,18 @@ export class ConfigParser {
       config.playwright.url = options.baseUrl;
     }
 
+    if (config.ai) {
+      const langfuse = config.ai.langfuse;
+      const publicKey = langfuse?.publicKey || process.env.LANGFUSE_PUBLIC_KEY;
+      const secretKey = langfuse?.secretKey || process.env.LANGFUSE_SECRET_KEY;
+      config.ai.langfuse = {
+        enabled: langfuse?.enabled ?? Boolean(publicKey && secretKey),
+        publicKey,
+        secretKey,
+        baseUrl: langfuse?.baseUrl || process.env.LANGFUSE_BASE_URL || process.env.LANGFUSE_HOST,
+      };
+    }
+
     return config;
   }
 
@@ -751,6 +775,32 @@ export function missingConfigMessage(configFile = 'explorbot.config.js'): string
   `;
 }
 
+export function modelName(model: unknown): string {
+  if (typeof model === 'string') return model;
+  return (model as any)?.modelId || (model as any)?.model || 'unknown';
+}
+
+export function modelProvider(model: unknown): string {
+  const provider = (model as any)?.provider;
+  if (typeof provider === 'string') return provider.split('.')[0];
+  if (typeof model === 'string') return model.split('/')[0];
+  return '';
+}
+
+export function configuredModels(ai?: AIConfig): Record<string, ConfiguredModel> {
+  if (!ai?.model) return {};
+
+  const describe = (model: unknown): ConfiguredModel => ({ name: modelName(model), provider: modelProvider(model) });
+
+  const models: Record<string, ConfiguredModel> = { model: describe(ai.model) };
+  if (ai.agenticModel) models.agenticModel = describe(ai.agenticModel);
+  if (ai.visionModel) models.visionModel = describe(ai.visionModel);
+  for (const [agent, agentConfig] of Object.entries(ai.agents || {})) {
+    if (agentConfig?.model) models[agent] = describe(agentConfig.model);
+  }
+  return models;
+}
+
 export async function resolveConfigModels(ai?: AIConfig): Promise<void> {
   if (!ai) return;
 
@@ -827,6 +877,11 @@ export async function createModel(provider: string, modelId: string): Promise<an
 
 type ModelRole = 'model' | 'visionModel' | 'agenticModel';
 
+interface ConfiguredModel {
+  name: string;
+  provider: string;
+}
+
 interface ProviderInfo {
   envKey: string;
   load: () => Promise<(modelId: string) => any>;
@@ -838,4 +893,4 @@ interface EnvVar {
   required?: boolean;
 }
 
-export type { ModelRole, EnvVar, ProviderInfo };
+export type { ModelRole, EnvVar, ProviderInfo, ConfiguredModel };

package/src/execution-controller.ts

@@ -27,6 +27,14 @@ export class ExecutionController extends EventEmitter {
     this.inputCallback = callback;
   }
 
+  hasInputCallback(): boolean {
+    return !!this.inputCallback;
+  }
+
+  clearInputCallback(): void {
+    this.inputCallback = null;
+  }
+
   startExecution(): void {
     this.interrupted = false;
     this.abortController = new AbortController();

package/src/explorbot.ts

@@ -20,7 +20,7 @@ import { createAgentTools } from './ai/tools.ts';
 import { ApiClient } from './api/api-client.ts';
 import { RequestStore } from './api/request-store.ts';
 import { loadSpec } from './api/spec-reader.ts';
-import type { ExplorbotConfig } from './config.js';
+import type { ExplorbotConfig, ReporterConfig } from './config.js';
 import { ConfigParser } from './config.ts';
 import { ExperienceTracker } from './experience-tracker.ts';
 import Explorer from './explorer.ts';
@@ -49,6 +49,7 @@ export interface ExplorBotOptions {
   session?: string | boolean;
   instance?: string;
   optionalAi?: boolean;
+  reporter?: ReporterConfig;
   attachedBrowser?: Browser;
   applicationSpec?: string;
 }
@@ -128,6 +129,7 @@ export class ExplorBot {
     if (this.provider) return;
     this.config = await this.configParser.loadConfig(this.options);
     if (this.options.session === true) this.options.session = path.join(this.configParser.getOutputDir(), 'session.json');
+    if (typeof this.options.session === 'string') this.options.session = path.resolve(this.options.path || '.', this.options.session);
     if (this.options.optionalAi) return this.bootstrapOptionalProvider();
     this.provider = new AIProvider(this.config.ai);
     await this.provider.validateConnection();
@@ -175,7 +177,7 @@ export class ExplorBot {
   }
 
   reporter(): Reporter {
-    return (this._reporter ||= new Reporter(this.config.reporter, this.stateManager()));
+    return (this._reporter ||= new Reporter(this.options.reporter || this.config.reporter, this.stateManager()));
   }
 
   requestStore(): RequestStore {
@@ -485,9 +487,11 @@ export class ExplorBot {
 
   setCurrentPlan(plan?: Plan): void {
     this.currentPlan = plan;
-    if (plan && !this.sessionPlans.includes(plan)) {
+    if (!plan) return;
+    if (!this.sessionPlans.includes(plan)) {
       this.sessionPlans.push(plan);
     }
+    plan.notifyChange();
   }
 
   getSessionTests(): Test[] {

package/src/explorer.ts

@@ -721,11 +721,11 @@ class Explorer {
     if (this.observedTestPages.has(page)) return;
 
     this.testPageErrorHandler ||= (err: Error) => {
-      this._activeTest?.addNote(`Console error: ${err.message}`, TestResult.FAILED);
+      this._activeTest?.addObservation(`Console error: ${err.message}`);
     };
     this.testConsoleHandler ||= (msg: any) => {
       if (msg.type() !== 'error') return;
-      this._activeTest?.addNote(`Console error: ${msg.text()}`, TestResult.FAILED);
+      this._activeTest?.addObservation(`Console error: ${msg.text()}`);
     };
     this.testDialogHandler ||= (dialog: any) => {
       const dialogType = dialog.type();

package/src/playwright-recorder.ts

@@ -287,8 +287,31 @@ function formatSelectOption(options: any): string {
   return `[${values.map((v) => quote(v)).join(', ')}]`;
 }
 
+function assertionLocator(target: any): string | null {
+  if (typeof target === 'string') return `page.locator(${JSON.stringify(target)})`;
+  if (!target || typeof target !== 'object') return null;
+
+  const role = target.role || target.aria;
+  const name = target.text ?? target.name ?? target.label;
+  if (role && name) return `page.getByRole(${JSON.stringify(String(role))}, { name: ${JSON.stringify(String(name))} })`;
+  if (role) return `page.getByRole(${JSON.stringify(String(role))})`;
+  if (name) return `page.getByText(${JSON.stringify(String(name))})`;
+  if (target.css) return `page.locator(${JSON.stringify(String(target.css))})`;
+  if (target.xpath) return `page.locator(${JSON.stringify(`xpath=${target.xpath}`)})`;
+  return null;
+}
+
 export function renderAssertion(assertion: { name: string; args: any[] }): string {
   const args = assertion.args;
+  const target = assertionLocator(args[0]);
+
+  if (target) {
+    if (assertion.name === 'seeElement') return `await expect(${target}).toBeVisible();`;
+    if (assertion.name === 'dontSeeElement') return `await expect(${target}).toBeHidden();`;
+    if (assertion.name === 'seeInField' && args[1] !== undefined) return `await expect(${target}).toHaveValue(${JSON.stringify(String(args[1]))});`;
+    if (assertion.name === 'dontSeeInField' && args[1] !== undefined) return `await expect(${target}).not.toHaveValue(${JSON.stringify(String(args[1]))});`;
+  }
+
   if (assertion.name === 'see' && typeof args[0] === 'string') {
     return `await expect(page).toContainText(${JSON.stringify(args[0])});`;
   }

package/src/remote.ts

@@ -0,0 +1,244 @@
+import type { Command } from 'commander';
+import stripAnsi from 'strip-ansi';
+import { type ActivityEntry, addActivityListener } from './activity.ts';
+import { executionController } from './execution-controller.ts';
+import { type LogDestination, type TaggedLogEntry, addDestination } from './utils/logger.ts';
+
+const QUEUE_CAP = 1000;
+const CONTENT_CAP = 8000;
+const RECONNECT_BASE_MS = 500;
+const RECONNECT_MAX_MS = 10_000;
+const ASK_TIMEOUT_MS = 15 * 60_000;
+const FLUSH_TIMEOUT_MS = 3000;
+
+/**
+ * Streams a run to a remote UI over one WebSocket, dialling out so a child
+ * process and a CI bot are the same case.
+ *
+ * It **is** a LogDestination — that is the whole integration on the logger's
+ * side, messages and `data` alike — and it answers asks by installing itself
+ * as the execution controller's input callback. Nothing else in explorbot
+ * knows it exists.
+ */
+export class Remote implements LogDestination {
+  private url: string | null = null;
+  private socket: WebSocket | null = null;
+  private queue: Frame[] = [];
+  private reconnectDelay = RECONNECT_BASE_MS;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private asks = new Map<string, (value: string | null) => void>();
+  private askCounter = 0;
+  private lastActivity: string | null = null;
+
+  registerOption(program: Command): void {
+    program.option('--ws <url>', 'Stream this run to a remote UI over WebSocket');
+    program.hook('preAction', (_thisCommand, actionCommand) => {
+      const url = actionCommand.optsWithGlobals().ws || process.env.EXPLORBOT_WS_URL;
+      if (!url) return;
+      this.attach(String(url), this.commandPath(actionCommand));
+    });
+  }
+
+  attach(url: string, command: string): void {
+    if (this.url) return;
+    this.url = url;
+    this.connect();
+
+    this.send('hello', { command, cwd: process.cwd(), pid: process.pid });
+    addDestination(this);
+    executionController.setInputCallback((prompt) => this.ask(prompt));
+    addActivityListener((activity) => this.reportActivity(activity));
+  }
+
+  isAttached(): boolean {
+    return !!this.url;
+  }
+
+  send(type: string, data: Record<string, unknown> = {}): void {
+    if (!this.url) return;
+    const frame: Frame = { type, ts: Date.now(), ...data };
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.push(frame);
+      return;
+    }
+    this.queue.push(frame);
+    if (this.queue.length > QUEUE_CAP) this.queue.splice(0, this.queue.length - QUEUE_CAP);
+  }
+
+  ask(prompt: string): Promise<string | null> {
+    if (!this.url) return Promise.resolve(null);
+    this.askCounter++;
+    const askId = `ask-${this.askCounter}`;
+    this.send('ask', { askId, prompt });
+
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.asks.delete(askId);
+        resolve(null);
+      }, ASK_TIMEOUT_MS);
+      this.asks.set(askId, (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      });
+    });
+  }
+
+  async close(exitCode: number): Promise<void> {
+    if (!this.url) return;
+    this.send('result', { ok: exitCode === 0, exitCode });
+    await this.flush();
+
+    this.url = null;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    // Whoever asks next has nobody to ask — leaving the callback installed would
+    // route them into a closed socket and park them until the ask times out.
+    executionController.clearInputCallback();
+    for (const resolve of this.asks.values()) resolve(null);
+    this.asks.clear();
+    this.queue = [];
+    this.socket?.close();
+    this.socket = null;
+  }
+
+  isEnabled(): boolean {
+    return this.isAttached();
+  }
+
+  /**
+   * The entry as the logger already built it, so the `LogType` reaches the UI
+   * as the frame's level and each kind is styled there instead of being scraped
+   * back out of flattened text.
+   */
+  write(entry: TaggedLogEntry): void {
+    if (entry.type === 'html') return;
+    if (entry.type === 'data') {
+      const [kind, payload] = entry.originalArgs || [];
+      this.send(String(kind), payload);
+      return;
+    }
+    let content = stripAnsi(entry.content ?? '');
+    if (content.length > CONTENT_CAP) content = `${content.slice(0, CONTENT_CAP)}… (${content.length} chars)`;
+    this.send('log', {
+      level: entry.type,
+      content,
+      namespace: entry.namespace,
+      error: this.errorOf(entry.originalArgs),
+    });
+  }
+
+  private connect(): void {
+    if (!this.url) return;
+
+    let opening: WebSocket;
+    try {
+      opening = new WebSocket(this.url);
+    } catch {
+      this.reconnect();
+      return;
+    }
+    this.socket = opening;
+
+    opening.addEventListener('open', () => {
+      this.reconnectDelay = RECONNECT_BASE_MS;
+      this.drain();
+    });
+
+    opening.addEventListener('message', (event: MessageEvent) => this.receive(String(event.data)));
+
+    opening.addEventListener('close', () => {
+      if (this.socket !== opening) return;
+      this.socket = null;
+      this.reconnect();
+    });
+
+    // A failed connection always closes too, which is where the retry is scheduled.
+    opening.addEventListener('error', () => {});
+  }
+
+  private reconnect(): void {
+    if (!this.url || this.reconnectTimer) return;
+    const delay = this.reconnectDelay;
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, RECONNECT_MAX_MS);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+    this.reconnectTimer.unref?.();
+  }
+
+  private async flush(): Promise<void> {
+    const deadline = Date.now() + FLUSH_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      if (this.socket?.readyState === WebSocket.OPEN) {
+        this.drain();
+        if (!this.queue.length && !this.socket.bufferedAmount) return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+  }
+
+  private drain(): void {
+    if (this.socket?.readyState !== WebSocket.OPEN) return;
+    const pending = this.queue;
+    this.queue = [];
+    for (const frame of pending) this.push(frame);
+  }
+
+  private push(frame: Frame): void {
+    try {
+      this.socket?.send(JSON.stringify(frame));
+    } catch {
+      this.queue.push(frame);
+    }
+  }
+
+  private receive(raw: string): void {
+    let frame: Frame;
+    try {
+      frame = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (frame.type === 'interrupt') {
+      executionController.interrupt();
+      return;
+    }
+    const resolve = this.asks.get(String(frame.askId));
+    if (!resolve) return;
+    this.asks.delete(String(frame.askId));
+    resolve((frame.value as string | null) ?? null);
+  }
+
+  /** A new listener is primed with the current activity, which at attach time is
+   *  nothing — so skip repeats, the priming null included. */
+  private reportActivity(activity: ActivityEntry | null): void {
+    const message = activity?.message ?? null;
+    if (message === this.lastActivity) return;
+    this.lastActivity = message;
+    this.send('activity', { message, kind: activity?.type });
+  }
+
+  private errorOf(args: any[] | undefined): string | undefined {
+    const failure = args?.[1] ?? args?.[0]?.error;
+    if (!failure) return undefined;
+    if (typeof failure === 'string') return failure;
+    if (typeof failure.message === 'string') return failure.message;
+    return undefined;
+  }
+
+  private commandPath(command: Command): string {
+    const parts: string[] = [];
+    let node: Command | null = command;
+    while (node) {
+      parts.unshift(node.name());
+      node = node.parent;
+    }
+    return parts.slice(1).join(' ') || parts.join(' ');
+  }
+}
+
+export const remote = new Remote();
+
+/** Whatever the run wants to say. Not a schema — the UI renders what it knows
+ *  and ignores the rest, so either side can start sending more at any time. */
+type Frame = { type: string; ts: number; [key: string]: unknown };

package/src/reporter.ts

@@ -283,13 +283,19 @@ export class Reporter {
 
       debugLog(testData);
 
-      await this.client.addTestRun(status, testData);
+      await this.reportTestData(status, testData);
       debugLog(`Test reported: ${test.scenario} - ${status}`);
     } catch (error) {
       debugLog('Failed to report test:', error);
     }
   }
 
+  async reportTestData(status: string | null, testData: Record<string, unknown>): Promise<void> {
+    await this.startRun();
+    if (!this.isRunStarted) return;
+    await this.client.addTestRun(status, testData);
+  }
+
   async finishRun(): Promise<void> {
     if (!this.isRunStarted) {
       return;