explorbot 0.2.3 → 0.2.5

package/dist/src/commands/config-command.js

@@ -0,0 +1,117 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { ConfigParser, EXPLORBOT_ENV_VARS, 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() {
+        const parser = ConfigParser.getInstance();
+        tag('info').log(ConfigCommand.render(this.explorBot.getConfig(), { configPath: parser.getConfigPath(), root: parser.getProjectRoot() }));
+    }
+    static async summary(options = {}) {
+        const parser = ConfigParser.getInstance();
+        const [site] = listSites();
+        const load = (baseUrl) => 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, options = {}) {
+        let configPath = '';
+        if (options.configPath && existsSync(options.configPath))
+            configPath = options.configPath;
+        const dirs = {};
+        if (options.root) {
+            for (const [name, dir] of Object.entries({ output: 'output', ...config.dirs })) {
+                dirs[name] = path.join(options.root, dir);
+            }
+        }
+        const env = {};
+        for (const variable of EXPLORBOT_ENV_VARS) {
+            const value = process.env[variable.name];
+            if (value)
+                env[variable.name] = value;
+        }
+        const models = {};
+        const providers = {};
+        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, options = {}) {
+        const data = ConfigCommand.data(config, options);
+        if (options.json)
+            return JSON.stringify(data, null, 2);
+        const lines = [];
+        const section = (title, entries) => {
+            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 = [['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 = 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 = [];
+        if (data.integrations.langfuse)
+            integrations.push(['langfuse', 'traces sent']);
+        if (data.integrations.testomatio)
+            integrations.push(['testomatio', 'runs reported']);
+        section('Integrations', integrations);
+        const env = 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');
+    }
+}

package/dist/src/commands/index.js

@@ -1,6 +1,7 @@
 import { AddRuleCommand } from './add-rule-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';
@@ -64,6 +65,7 @@ const commandClasses = [
     RunsCommand,
     RerunCommand,
     StatusCommand,
+    ConfigCommand,
     DebugCommand,
     ExitCommand,
 ];

package/dist/src/config.d.ts

@@ -172,6 +172,7 @@ interface HtmlConfig {
 interface ActionConfig {
     delay?: number;
     retries?: number;
+    timeout?: number;
 }
 interface ReporterConfig {
     enabled?: boolean;
@@ -271,12 +272,19 @@ export declare class ConfigMissingError extends Error {
 }
 export declare function envConfigRequested(): boolean;
 export declare function missingConfigMessage(configFile?: string): string;
+export declare function modelName(model: unknown): string;
+export declare function modelProvider(model: unknown): string;
+export declare function configuredModels(ai?: AIConfig): Record<string, ConfiguredModel>;
 export declare function resolveConfigModels(ai?: AIConfig): Promise<void>;
 export declare function resolveOutputRoot(baseUrl?: string): string;
 export declare function resolveStateRoot(baseUrl: string, ephemeral?: boolean): string;
 export declare function materializeKnowledge(outputRoot: string): void;
 export declare function createModel(provider: string, modelId: string): Promise<any>;
 type ModelRole = 'model' | 'visionModel' | 'agenticModel';
+interface ConfiguredModel {
+    name: string;
+    provider: string;
+}
 interface ProviderInfo {
     envKey: string;
     load: () => Promise<(modelId: string) => any>;
@@ -286,4 +294,4 @@ interface EnvVar {
     description: string;
     required?: boolean;
 }
-export type { ModelRole, EnvVar, ProviderInfo };
+export type { ModelRole, EnvVar, ProviderInfo, ConfiguredModel };

package/dist/src/config.js

@@ -9,12 +9,13 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 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 { 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 = {
     openai: { envKey: 'OPENAI_API_KEY', load: async () => (await import('@ai-sdk/openai')).createOpenAI() },
     anthropic: { envKey: 'ANTHROPIC_API_KEY', load: async () => (await import('@ai-sdk/anthropic')).createAnthropic() },
@@ -178,8 +179,15 @@ export class ConfigParser {
         return this.site;
     }
     resolveTargetPath(target) {
-        if (!this.site)
+        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);
@@ -223,6 +231,7 @@ export class ConfigParser {
                 model: { modelId: 'test-model', provider: 'test' },
                 config: {},
                 vision: false,
+                langfuse: { enabled: false },
             },
             dirs: {
                 knowledge: join(testBaseDir, 'knowledge'),
@@ -321,9 +330,10 @@ export class ConfigParser {
     }
     async loadConfigModule(configPath) {
         const ext = configPath.split('.').pop();
+        const moduleUrl = pathToFileURL(resolve(configPath)).href;
         if (ext === 'ts') {
             try {
-                const module = await import(__rewriteRelativeImportExtension(configPath));
+                const module = await import(__rewriteRelativeImportExtension(moduleUrl));
                 return module;
             }
             catch (error) {
@@ -332,7 +342,7 @@ export class ConfigParser {
             }
         }
         else if (ext === 'js' || ext === 'mjs') {
-            const module = await import(__rewriteRelativeImportExtension(configPath));
+            const module = await import(__rewriteRelativeImportExtension(moduleUrl));
             return module;
         }
         else {
@@ -349,6 +359,17 @@ export class ConfigParser {
             config.playwright = config.playwright || { browser: 'chromium', url: '' };
             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;
     }
     validateConfig(config) {
@@ -445,6 +466,34 @@ export function missingConfigMessage(configFile = 'explorbot.config.js') {
     Providers: ${Object.keys(PROVIDERS).join(', ')}
   `;
 }
+export function modelName(model) {
+    if (typeof model === 'string')
+        return model;
+    return model?.modelId || model?.model || 'unknown';
+}
+export function modelProvider(model) {
+    const provider = model?.provider;
+    if (typeof provider === 'string')
+        return provider.split('.')[0];
+    if (typeof model === 'string')
+        return model.split('/')[0];
+    return '';
+}
+export function configuredModels(ai) {
+    if (!ai?.model)
+        return {};
+    const describe = (model) => ({ name: modelName(model), provider: modelProvider(model) });
+    const models = { 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) {
     if (!ai)
         return;

package/dist/src/execution-controller.d.ts

@@ -10,6 +10,8 @@ export declare class ExecutionController extends EventEmitter {
     constructor();
     static getInstance(): ExecutionController;
     setInputCallback(callback: InputCallback): void;
+    hasInputCallback(): boolean;
+    clearInputCallback(): void;
     startExecution(): void;
     getAbortSignal(): AbortSignal | undefined;
     interrupt(): void;

package/dist/src/execution-controller.js

@@ -20,6 +20,12 @@ export class ExecutionController extends EventEmitter {
     setInputCallback(callback) {
         this.inputCallback = callback;
     }
+    hasInputCallback() {
+        return !!this.inputCallback;
+    }
+    clearInputCallback() {
+        this.inputCallback = null;
+    }
     startExecution() {
         this.interrupted = false;
         this.abortController = new AbortController();

package/dist/src/explorbot.d.ts

@@ -15,7 +15,7 @@ import { Researcher } from './ai/researcher.js';
 import { SessionAnalyst } from './ai/session-analyst.js';
 import { Tester } from './ai/tester.js';
 import { RequestStore } from './api/request-store.js';
-import type { ExplorbotConfig } from './config.js';
+import type { ExplorbotConfig, ReporterConfig } from './config.js';
 import { ConfigParser } from './config.js';
 import { ExperienceTracker } from './experience-tracker.js';
 import Explorer from './explorer.js';
@@ -37,6 +37,7 @@ export interface ExplorBotOptions {
     session?: string | boolean;
     instance?: string;
     optionalAi?: boolean;
+    reporter?: ReporterConfig;
     attachedBrowser?: Browser;
     applicationSpec?: string;
 }

package/dist/src/explorbot.js

@@ -101,6 +101,8 @@ export class ExplorBot {
         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);
@@ -138,7 +140,7 @@ export class ExplorBot {
         return (this._stateManager ||= new StateManager(this.experienceTracker(), this.knowledgeTracker()));
     }
     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() {
         return (this._requestStore ||= new RequestStore(this.configParser.getOutputDir()));
@@ -416,9 +418,12 @@ export class ExplorBot {
     }
     setCurrentPlan(plan) {
         this.currentPlan = plan;
-        if (plan && !this.sessionPlans.includes(plan)) {
+        if (!plan)
+            return;
+        if (!this.sessionPlans.includes(plan)) {
             this.sessionPlans.push(plan);
         }
+        plan.notifyChange();
     }
     getSessionTests() {
         return this.sessionPlans.flatMap((p) => p.tests.filter((t) => t.startTime != null));

package/dist/src/explorer.js

@@ -10,7 +10,6 @@ import { ActionResult } from "./action-result.js";
 import Action from './action.js';
 import { XhrCapture } from "./api/xhr-capture.js";
 import { ConfigParser } from './config.js';
-import { TestResult } from "./test-plan.js";
 import { BrowserRecoveryError, browserErrorMessage, isFatalBrowserError, isNavigationTransitionError } from "./utils/browser-errors.js";
 import { createDebug, log, tag } from './utils/logger.js';
 import { sleep, waitForPageReadiness } from "./utils/page-readiness.js";
@@ -624,12 +623,12 @@ class Explorer {
         if (this.observedTestPages.has(page))
             return;
         this.testPageErrorHandler ||= (err) => {
-            this._activeTest?.addNote(`Console error: ${err.message}`, TestResult.FAILED);
+            this._activeTest?.addObservation(`Console error: ${err.message}`);
         };
         this.testConsoleHandler ||= (msg) => {
             if (msg.type() !== 'error')
                 return;
-            this._activeTest?.addNote(`Console error: ${msg.text()}`, TestResult.FAILED);
+            this._activeTest?.addObservation(`Console error: ${msg.text()}`);
         };
         this.testDialogHandler ||= (dialog) => {
             const dialogType = dialog.type();

package/dist/src/playwright-recorder.js

@@ -292,8 +292,38 @@ function formatSelectOption(options) {
         return quote(values[0]);
     return `[${values.map((v) => quote(v)).join(', ')}]`;
 }
+function assertionLocator(target) {
+    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) {
     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/dist/src/remote.d.ts

@@ -0,0 +1,55 @@
+import type { Command } from 'commander';
+import { type ActivityEntry } from './activity.js';
+import { type LogDestination, type TaggedLogEntry } from './utils/logger.js';
+/**
+ * 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 declare class Remote implements LogDestination {
+    url: string | null;
+    socket: WebSocket | null;
+    queue: Frame[];
+    reconnectDelay: number;
+    reconnectTimer: ReturnType<typeof setTimeout> | null;
+    asks: Map<string, (value: string | null) => void>;
+    askCounter: number;
+    lastActivity: string | null;
+    registerOption(program: Command): void;
+    attach(url: string, command: string): void;
+    isAttached(): boolean;
+    send(type: string, data?: Record<string, unknown>): void;
+    ask(prompt: string): Promise<string | null>;
+    close(exitCode: number): Promise<void>;
+    isEnabled(): boolean;
+    /**
+     * 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;
+    connect(): void;
+    reconnect(): void;
+    flush(): Promise<void>;
+    drain(): void;
+    push(frame: Frame): void;
+    receive(raw: string): void;
+    /** A new listener is primed with the current activity, which at attach time is
+     *  nothing — so skip repeats, the priming null included. */
+    reportActivity(activity: ActivityEntry | null): void;
+    errorOf(args: any[] | undefined): string | undefined;
+    commandPath(command: Command): string;
+}
+export declare const remote: 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;
+};
+export {};