explorbot 0.1.31 → 0.1.32-beta.1

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

@@ -0,0 +1,25 @@
+import { EventEmitter } from 'node:events';
+export type InputCallback = (prompt: string) => Promise<string | null>;
+export declare class ExecutionController extends EventEmitter {
+    static instance: ExecutionController;
+    interrupted: boolean;
+    inputCallback: InputCallback | null;
+    interruptResolvers: Array<() => void>;
+    abortController: AbortController | null;
+    awaitingInput: boolean;
+    constructor();
+    static getInstance(): ExecutionController;
+    setInputCallback(callback: InputCallback): void;
+    startExecution(): void;
+    getAbortSignal(): AbortSignal | undefined;
+    interrupt(): void;
+    isAwaitingInput(): boolean;
+    isInterrupted(): boolean;
+    waitForInterrupt(): Promise<void>;
+    checkInterrupt(): Promise<string | null>;
+    handleInterrupt(prompt?: string): Promise<string | null>;
+    requestInput(prompt: string): Promise<string | null>;
+    readlineInput(prompt: string): Promise<string | null>;
+    reset(): void;
+}
+export declare const executionController: ExecutionController;

package/dist/src/experience-tracker.d.ts

@@ -0,0 +1,107 @@
+import type { ActionResult } from './action-result.js';
+import { KnowledgeTracker } from './knowledge-tracker.js';
+export declare const RECENT_WINDOW_DAYS = 30;
+/**
+ * Stores and reads per-page experience files (`./experience/<stateHash>.md`).
+ *
+ * Two writers, two contracts:
+ *
+ *   writeFlow(state, body, relatedUrls?)  — caller hands in a fully-formatted
+ *                                            `## FLOW: <imperative title>` block (multi-step,
+ *                                            `*` bullets + optional ```js``` + `>` discovery,
+ *                                            ends with `---`). Tracker dedups + prepends.
+ *   writeAction(state, ActionInput)        — `## ACTION: <imperative title>`, single-step,
+ *                                            optional `Solution:` line + one ```js``` code block.
+ *                                            Title normalized via normalizeTitle().
+ *
+ * - Always h2. Never h3 for FLOW/ACTION.
+ * - On read (getSuccessfulExperience), headings are rendered as
+ *   `## HOW to <title> (multi-step|single-step)` so prompts get natural phrasing.
+ */
+export declare class ExperienceTracker {
+    experienceDir: string;
+    disabled: boolean;
+    knowledgeTracker: KnowledgeTracker;
+    constructor(options?: {
+        disabled?: boolean;
+    });
+    getExperienceDirectories(): string[];
+    ensureDirectory(dir: string): void;
+    readExperienceFile(stateHash: string): {
+        content: string;
+        data: any;
+    };
+    writeExperienceFile(stateHash: string, content: string, frontmatter?: any): void;
+    hasRecentExperience(stateHash: string, prefix?: string): boolean;
+    getExperienceFilePath(stateHash: string): string;
+    ensureExperienceFile(state: ActionResult): string;
+    updateSummary(state: ActionResult, summary: string): void;
+    isWritingDisabled(state: ActionResult): boolean;
+    writeAction(state: ActionResult, action: ActionInput): void;
+    writeFlow(state: ActionResult, body: string, relatedUrls?: string[]): void;
+    getAllExperience(): ExperienceFile[];
+    getRelevantExperience(state: ActionResult, options?: {
+        includeDescendantExperience?: boolean;
+    }): ExperienceFile[];
+    /**
+     * Clean up experience tracker (for testing)
+     */
+    cleanup(): void;
+    getSuccessfulExperience(state: ActionResult, options?: {
+        includeDescendants?: boolean;
+        stripCode?: boolean;
+    }): string[];
+    getExperienceTableOfContents(state: ActionResult, options?: {
+        includeDescendantExperience?: boolean;
+    }): ExperienceTocEntry[];
+    getExperienceSection(fileTag: string, sectionIndex: number, state: ActionResult, options?: {
+        includeDescendantExperience?: boolean;
+    }): {
+        title: string;
+        url: string;
+        content: string;
+    } | null;
+    findExperienceFileByHash(fileHash: string): string | null;
+    listAllExperienceToc(filter?: string, options?: {
+        recency?: 'recent' | 'old';
+    }): ExperienceTocEntry[];
+    getExperienceSectionByTag(fileTag: string, sectionIndex: number, filter?: string): {
+        title: string;
+        url: string;
+        content: string;
+        fileHash: string;
+    } | null;
+}
+export declare function renderExperienceToc(toc: ExperienceTocEntry[]): string;
+export interface ExperienceFile {
+    filePath: string;
+    data: {
+        url?: string;
+        title?: string;
+        [key: string]: any;
+    };
+    content: string;
+    mtime: Date;
+}
+export interface ActionInput {
+    title: string;
+    code: string;
+    explanation?: string;
+}
+export interface SessionStep {
+    message: string;
+    status: 'passed' | 'failed' | 'neutral';
+    tool?: string;
+    code?: string;
+    discovery?: string;
+}
+export interface ExperienceTocEntry {
+    fileTag: string;
+    fileHash: string;
+    url: string;
+    sections: {
+        index: number;
+        level: 2 | 3;
+        title: string;
+    }[];
+}

package/dist/src/experience-tracker.js

@@ -6,6 +6,7 @@ import { ConfigParser } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
 import { createDebug, tag } from './utils/logger.js';
 import { mdq } from './utils/markdown-query.js';
+import { redactSecrets } from './utils/secrets.js';
 import { isNonReusableCode } from "./utils/step-analyzer.js";
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:experience');
@@ -93,7 +94,7 @@ export class ExperienceTracker {
             return;
         }
         const filePath = this.getExperienceFilePath(stateHash);
-        const fileContent = matter.stringify(content, frontmatter || {});
+        const fileContent = matter.stringify(redactSecrets(content), frontmatter || {});
         writeFileSync(filePath, fileContent, 'utf8');
     }
     hasRecentExperience(stateHash, prefix = '') {

package/dist/src/explorbot.d.ts

@@ -0,0 +1,107 @@
+import { Captain } from './ai/captain.js';
+import { Driller } from './ai/driller.js';
+import { ExperienceCompactor } from './ai/experience-compactor.js';
+import { Fisherman } from './ai/fisherman.js';
+import { Historian } from './ai/historian.js';
+import { Navigator } from './ai/navigator.js';
+import { Pilot } from './ai/pilot.js';
+import { Planner } from './ai/planner.js';
+import { AIProvider } from './ai/provider.js';
+import { Quartermaster } from './ai/quartermaster.js';
+import { Rerunner } from './ai/rerunner.js';
+import { Researcher } from './ai/researcher.js';
+import { SessionAnalyst } from './ai/session-analyst.js';
+import { Tester } from './ai/tester.js';
+import type { ExplorbotConfig } from './config.js';
+import { ConfigParser } from './config.js';
+import { ExperienceTracker } from './experience-tracker.js';
+import Explorer from './explorer.js';
+import { KnowledgeTracker } from './knowledge-tracker.js';
+import { WebPageState } from './state-manager.js';
+import type { Suite } from './suite.js';
+import { Plan, type Test } from './test-plan.js';
+export interface ExplorBotOptions {
+    from?: string;
+    baseUrl?: string;
+    verbose?: boolean;
+    config?: string;
+    path?: string;
+    show?: boolean;
+    headless?: boolean;
+    incognito?: boolean;
+    session?: string;
+}
+export type UserResolveFunction = (error?: Error, showWelcome?: boolean) => Promise<string | null>;
+export declare class ExplorBot {
+    configParser: ConfigParser;
+    explorer: Explorer;
+    provider: AIProvider;
+    config: ExplorbotConfig;
+    options: ExplorBotOptions;
+    userResolveFn: UserResolveFunction | null;
+    needsInput: boolean;
+    currentPlan?: Plan;
+    planFeature?: string;
+    lastPlanError: Error | null;
+    lastSavedPlanPath: string | null;
+    agents: Record<string, any>;
+    sessionPlans: Plan[];
+    lastReportedTestCount: number;
+    constructor(options?: ExplorBotOptions);
+    get isExploring(): boolean;
+    setUserResolve(fn: UserResolveFunction): void;
+    start(): Promise<void>;
+    startProviderOnly(): Promise<void>;
+    stop(): Promise<void>;
+    visitInitialState(): Promise<void>;
+    visit(url: string): Promise<void>;
+    openFreshTab(): Promise<void>;
+    getCurrentState(): WebPageState | null;
+    getExplorer(): Explorer;
+    getKnowledgeTracker(): KnowledgeTracker;
+    getExperienceTracker(): ExperienceTracker;
+    getConfig(): ExplorbotConfig;
+    getOptions(): ExplorBotOptions;
+    isReady(): boolean;
+    getConfigParser(): ConfigParser;
+    getProvider(): AIProvider;
+    createAgent<T>(factory: (deps: {
+        explorer: Explorer;
+        ai: AIProvider;
+        config: ExplorbotConfig;
+    }) => T): T;
+    agentResearcher(): Researcher;
+    agentNavigator(): Navigator;
+    agentPlanner(): Planner;
+    agentPilot(): Pilot;
+    agentTester(): Tester;
+    agentCaptain(): Captain;
+    agentExperienceCompactor(): ExperienceCompactor;
+    agentQuartermaster(): Quartermaster | null;
+    agentHistorian(): Historian;
+    agentRerunner(): Rerunner;
+    agentDriller(): Driller;
+    agentSessionAnalyst(): SessionAnalyst;
+    agentFisherman(): Fisherman | null;
+    getCurrentPlan(): Plan | undefined;
+    getSuite(): Suite | null;
+    getPlanFeature(): string | undefined;
+    clearPlan(): void;
+    plan(feature?: string, opts?: {
+        fresh?: boolean;
+        style?: string;
+        extend?: Plan;
+        completedPlans?: Plan[];
+        noSave?: boolean;
+    }): Promise<Plan>;
+    getPlansDir(): string;
+    savePlan(filename?: string): string | null;
+    savePlans(plans: Plan[], filename?: string): string | null;
+    generatePlanFilename(feature?: string): string;
+    resolvePlanPath(filename: string): string;
+    loadPlan(filename: string): Plan;
+    loadPlans(filename: string): Plan[];
+    setCurrentPlan(plan?: Plan): void;
+    getSessionTests(): Test[];
+    printSessionAnalysis(): Promise<void>;
+}

package/dist/src/explorer.d.ts

@@ -0,0 +1,140 @@
+import type { BrowserContextOptions } from 'playwright';
+import { ActionResult } from './action-result.js';
+import Action from './action.js';
+import { AIProvider } from './ai/provider.js';
+import { RequestStore } from './api/request-store.js';
+import { XhrCapture } from './api/xhr-capture.js';
+import type { ExplorbotConfig } from './config.js';
+import type { UserResolveFunction } from './explorbot.js';
+import { KnowledgeTracker } from './knowledge-tracker.js';
+import { PlaywrightRecorder } from './playwright-recorder.js';
+import { Reporter } from './reporter.js';
+import { StateManager } from './state-manager.js';
+import { Test } from './test-plan.js';
+import { WebElement } from './utils/web-element.js';
+declare global {
+    namespace NodeJS {
+        interface Global {
+            output_dir: string;
+        }
+    }
+}
+declare namespace CodeceptJS {
+    interface I {
+        [key: string]: any;
+    }
+}
+interface TabInfo {
+    url: string;
+    title: string;
+}
+interface BrowserExecutionErrorResult {
+    action: 'continue' | 'stop';
+    message: string;
+    recovered?: boolean;
+}
+declare class Explorer {
+    aiProvider: AIProvider;
+    playwrightHelper: any;
+    isStarted: boolean;
+    isSharedBrowser: boolean;
+    actor: CodeceptJS.I;
+    stateManager: StateManager;
+    knowledgeTracker: KnowledgeTracker;
+    config: ExplorbotConfig;
+    userResolveFn: UserResolveFunction | null;
+    options?: {
+        show?: boolean;
+        headless?: boolean;
+        incognito?: boolean;
+        session?: string;
+    };
+    reporter: Reporter;
+    otherTabs: TabInfo[];
+    _activeTest: Test | null;
+    xhrCapture: XhrCapture | null;
+    requestStore: RequestStore | null;
+    playwrightRecorder: PlaywrightRecorder;
+    observedTestPages: Set<any>;
+    testPageErrorHandler: ((error: Error) => void) | null;
+    testConsoleHandler: ((message: any) => void) | null;
+    testDialogHandler: ((dialog: any) => void) | null;
+    constructor(config: ExplorbotConfig, aiProvider: AIProvider, options?: {
+        show?: boolean;
+        headless?: boolean;
+        incognito?: boolean;
+        session?: string;
+    });
+    initializeContainer(): void;
+    convertToCodeceptConfig(config: ExplorbotConfig): any;
+    getConfig(): ExplorbotConfig;
+    getConfigPath(): string | null;
+    getAIProvider(): AIProvider;
+    getStateManager(): StateManager;
+    getCurrentUrl(): string;
+    getKnowledgeTracker(): KnowledgeTracker;
+    getReporter(): Reporter;
+    getRequestStore(): RequestStore | null;
+    extractCookies(): Promise<Record<string, string>>;
+    setupXhrCapture(reuseRequestStore?: boolean): void;
+    start(): Promise<any>;
+    connectOrLaunchBrowser(): Promise<void>;
+    createBrowserContextOptions(): BrowserContextOptions;
+    createAction(): Action;
+    runWithBrowserRecovery<T>(label: string, operation: () => Promise<T>): Promise<T>;
+    capturePageState(opts?: {
+        includeScreenshot?: boolean;
+    }): Promise<ActionResult>;
+    capturePageWithScreenshot(): Promise<ActionResult>;
+    executeAction(code: string): Promise<Action>;
+    attemptAction(code: string, originalMessage?: string, experience?: boolean): Promise<boolean>;
+    getPlaywrightRecorder(): PlaywrightRecorder;
+    visit(url: string): Promise<Action>;
+    visitOnce(url: string): Promise<Action>;
+    annotateElements(): Promise<WebElement[]>;
+    visuallyAnnotateElements(opts?: {
+        containers?: Array<{
+            css: string;
+            label: string;
+        }>;
+    }): Promise<number>;
+    getEidxInContainer(containerCss: string | null): Promise<string[]>;
+    getEidxByLocator(locator: string, container?: string | null): Promise<string | null>;
+    reload(): Promise<void>;
+    resolveBrowserUrl(url?: string): string | null;
+    isFatalBrowserError(error: unknown): boolean;
+    recoverFromBrowserError(): Promise<boolean>;
+    restartBrowser(): Promise<boolean>;
+    switchToMainFrame(): Promise<void>;
+    waitForPageReadiness(): Promise<boolean>;
+    isInsideIframe(): Promise<boolean>;
+    getCurrentIframeInfo(): string | null;
+    hasOtherTabs(): boolean;
+    getOtherTabsInfo(): TabInfo[];
+    clearOtherTabsInfo(): void;
+    setUserResolve(userResolveFn: UserResolveFunction): void;
+    listenToStateChanged(): void;
+    stop(): Promise<void>;
+    get activeTest(): Test | null;
+    startTest(test: Test): Promise<boolean>;
+    ensurePageAvailable(): Promise<boolean>;
+    ensureActiveTestPageAvailable(): Promise<boolean>;
+    handleExecutionError(error: unknown): Promise<BrowserExecutionErrorResult>;
+    watchActiveTestPage(page?: any): void;
+    stopTest(test: Test, meta?: Record<string, string>): Promise<void>;
+    unwatchActiveTestPages(): void;
+    hasPlaywrightLocator(locatorFn: (page: any) => any, opts?: {
+        multiple?: boolean;
+        contents?: boolean;
+        success?: (locator: any) => Promise<void> | void;
+    }): Promise<boolean>;
+    playwrightLocatorCount(locatorFn: (page: any) => any): Promise<number>;
+    bindFrameNavigated(page: any): void;
+    openFreshTab(): Promise<void>;
+    closeOtherTabs(): Promise<void>;
+}
+export declare function annotatePageElements(page: any): Promise<{
+    ariaSnapshot: string;
+    elements: WebElement[];
+}>;
+export default Explorer;

package/dist/src/explorer.js

@@ -629,17 +629,21 @@ class Explorer {
             test.setActiveNoteScreenshot(lastScreenshot);
         };
         this.watchActiveTestPage();
-        codeceptjs.event.dispatcher.emit('test.before', codeceptjsTest);
-        codeceptjs.event.dispatcher.emit('test.start', codeceptjsTest);
-        codeceptjs.event.dispatcher.on('step.passed', (step) => stepHandler(step, 'passed'));
-        codeceptjs.event.dispatcher.on('step.failed', (step, error) => {
+        const onStepPassed = (step) => stepHandler(step, 'passed');
+        const onStepFailed = (step, error) => {
             stepHandler(step, 'failed', error?.message || String(error), error?.stack);
-        });
-        codeceptjs.event.dispatcher.on('test.after', () => {
-            codeceptjs.event.dispatcher.off('step.passed', stepHandler);
-            codeceptjs.event.dispatcher.off('step.failed', stepHandler);
+        };
+        const onTestAfter = () => {
+            codeceptjs.event.dispatcher.off('step.passed', onStepPassed);
+            codeceptjs.event.dispatcher.off('step.failed', onStepFailed);
+            codeceptjs.event.dispatcher.off('test.after', onTestAfter);
             this.unwatchActiveTestPages();
-        });
+        };
+        codeceptjs.event.dispatcher.emit('test.before', codeceptjsTest);
+        codeceptjs.event.dispatcher.emit('test.start', codeceptjsTest);
+        codeceptjs.event.dispatcher.on('step.passed', onStepPassed);
+        codeceptjs.event.dispatcher.on('step.failed', onStepFailed);
+        codeceptjs.event.dispatcher.on('test.after', onTestAfter);
         return true;
     }
     async ensurePageAvailable() {

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export { ExplorBot } from './explorbot.js';
+export type { ExplorBotOptions, UserResolveFunction } from './explorbot.js';
+export { Plan, Test, TestResult, TestStatus } from './test-plan.js';
+export type { Note, StepData, TestResultType, TestStatusType } from './test-plan.js';
+export type { Link, StateTransition, WebPageState } from './state-manager.js';
+export type { AIConfig, ExplorbotConfig, PlaywrightConfig } from './config.js';

package/dist/src/index.js

@@ -1,55 +1,2 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import { addKnowledgeCommand } from './commands/add-knowledge.js';
-import { cleanCommand } from './commands/clean.js';
-import { exploreCommand } from './commands/explore.js';
-import { initCommand } from './commands/init.js';
-const program = new Command();
-program
-    .name('explorbot')
-    .description('AI-powered web exploration tool')
-    .option('-f, --from <url>', 'Start exploration from a specific URL')
-    .option('-v, --verbose', 'Enable verbose logging')
-    .option('--debug', 'Enable debug logging (same as --verbose)')
-    .option('-c, --config <path>', 'Path to configuration file')
-    .option('-p, --path <path>', 'Working directory path')
-    .helpOption('-h, --help', 'Show this help message');
-program
-    .command('clean')
-    .description('Clean up artifacts or experience folders')
-    .option('-t, --type <type>', 'Type of cleanup (artifacts|experience|all)', 'artifacts')
-    .option('-p, --path <path>', 'Custom path to clean')
-    .action(async (options, command) => {
-    const globalOptions = command.parent.opts();
-    const allOptions = { ...globalOptions, ...options };
-    await cleanCommand(allOptions);
-});
-program
-    .command('init')
-    .description('Initialize a new project with configuration')
-    .option('-c, --config-path <path>', 'Path for the config file', './explorbot.config.js')
-    .option('-f, --force', 'Overwrite existing config file', false)
-    .option('-p, --path <path>', 'Working directory for initialization')
-    .action(async (options, command) => {
-    const globalOptions = command.parent.opts();
-    const allOptions = { ...globalOptions, ...options };
-    await initCommand(allOptions);
-});
-program
-    .command('add-knowledge')
-    .alias('learn')
-    .description('Add knowledge for specific URLs')
-    .option('-p, --path <path>', 'Knowledge directory path')
-    .action(async (options) => {
-    await addKnowledgeCommand(options);
-});
-program.parse();
-const options = program.opts();
-const command = program.args[0];
-if (command === 'clean' || command === 'init' || command === 'add-knowledge' || command === 'learn') {
-    // These commands are handled by their respective actions
-}
-else {
-    // Default to explore command
-    exploreCommand(options);
-}
+export { ExplorBot } from "./explorbot.js";
+export { Plan, Test, TestResult, TestStatus } from "./test-plan.js";

package/dist/src/knowledge-tracker.d.ts

@@ -0,0 +1,33 @@
+import { ActionResult } from './action-result.js';
+interface Knowledge {
+    filePath: string;
+    url: string;
+    content: string;
+    [key: string]: any;
+}
+export declare class KnowledgeTracker {
+    knowledgeDir: string;
+    knowledgeFiles: Knowledge[];
+    isLoaded: boolean;
+    constructor();
+    loadKnowledgeFiles(): void;
+    getRelevantKnowledge(state: ActionResult): Knowledge[];
+    addKnowledge(urlPattern: string, description: string): {
+        filename: string;
+        filePath: string;
+        isNewFile: boolean;
+    };
+    interpolateVars(content: string): string;
+    generateFilename(url: string): string;
+    getExistingUrls(): string[];
+    getKnowledgeForUrl(urlPattern: string): string[];
+    listAllKnowledge(): Array<{
+        url: string;
+        firstLine: string;
+        filePath: string;
+    }>;
+    getMatchingKnowledge(url: string): Knowledge[];
+    normalizeUrl(url: string): string;
+    getStateParameters(state: ActionResult, keys: string[]): Record<string, any>;
+}
+export {};

package/dist/src/knowledge-tracker.js

@@ -5,6 +5,7 @@ import { ActionResult } from './action-result.js';
 import { ConfigParser } from './config.js';
 import { getCliName } from "./utils/cli-name.js";
 import { createDebug } from './utils/logger.js';
+import { isSecretName, registerSecret } from './utils/secrets.js';
 const debugLog = createDebug('explorbot:knowledge-tracker');
 export class KnowledgeTracker {
     knowledgeDir;
@@ -109,9 +110,15 @@ export class KnowledgeTracker {
                 return match;
             const namespace = expr.slice(0, dotIndex);
             const key = expr.slice(dotIndex + 1);
-            if (namespace === 'env')
-                return process.env[key] ?? '';
+            if (namespace === 'env') {
+                const value = process.env[key] ?? '';
+                if (isSecretName(key))
+                    registerSecret(value);
+                return value;
+            }
             if (namespace === 'config') {
+                if (isSecretName(key))
+                    return '';
                 const config = ConfigParser.getInstance().getConfig();
                 const value = key.split('.').reduce((obj, k) => obj?.[k], config);
                 if (value !== undefined && typeof value !== 'object')

package/dist/src/observability.d.ts

@@ -0,0 +1,13 @@
+import { type Span } from '@opentelemetry/api';
+type TelemetryMetadata = Record<string, unknown>;
+export declare const Observability: {
+    run<T>(name: string, metadata: TelemetryMetadata, fn: () => Promise<T>): Promise<T>;
+    getTelemetry(): {
+        isEnabled: boolean;
+        functionId: string;
+        metadata: Record<string, unknown>;
+    };
+    isTracing(): boolean;
+    getSpan(): Span;
+};
+export {};

package/dist/src/observability.js

@@ -1,4 +1,5 @@
 import { trace } from '@opentelemetry/api';
+import { redactSecrets } from './utils/secrets.js';
 let current = null;
 export const Observability = {
     async run(name, metadata, fn) {
@@ -70,7 +71,7 @@ function buildRootSpanAttributes(name, metadata) {
         attributes['langfuse.trace.tags'] = metadata.tags;
     }
     if (metadata.input !== undefined) {
-        attributes['langfuse.trace.input'] = JSON.stringify(metadata.input);
+        attributes['langfuse.trace.input'] = redactSecrets(JSON.stringify(metadata.input));
     }
     return attributes;
 }

package/dist/src/playwright-recorder.d.ts

@@ -0,0 +1,31 @@
+export interface TraceCall {
+    class: string;
+    method: string;
+    params: Record<string, any>;
+}
+export interface VerificationStep {
+    name: string;
+    args: any[];
+}
+export declare class PlaywrightRecorder {
+    context: any;
+    tracing: any;
+    active: boolean;
+    nextGroupId: number;
+    verifications: VerificationStep[];
+    recordVerification(steps: VerificationStep[]): void;
+    drainVerifications(): VerificationStep[];
+    start(browserContext: any): Promise<void>;
+    beginAction(title: string): Promise<string | null>;
+    endAction(): Promise<void>;
+    exportChunk(): Promise<Map<string, TraceCall[]>>;
+    stop(): Promise<void>;
+    isActive(): boolean;
+}
+declare function parseTrace(ndjson: string): Map<string, TraceCall[]>;
+export declare function renderCall(call: TraceCall): string;
+export declare function renderAssertion(assertion: {
+    name: string;
+    args: any[];
+}): string;
+export { parseTrace };

package/dist/src/reporter.d.ts

@@ -0,0 +1,34 @@
+import { Client } from '@testomatio/reporter';
+import type { Step } from '@testomatio/reporter/types/types.js';
+import type { ReporterConfig } from './config.js';
+import type { StateManager } from './state-manager.js';
+import { Test } from './test-plan.js';
+export type ReporterMeta = Record<string, string | undefined>;
+export interface ReporterStep {
+    title: string;
+    status: 'passed' | 'failed';
+    code: string[];
+    discovery?: string;
+}
+export declare class Reporter {
+    client: Client;
+    isRunStarted: boolean;
+    reporterEnabled: boolean;
+    stateManager?: StateManager;
+    constructor(config?: ReporterConfig, stateManager?: StateManager);
+    buildTitle(): string;
+    static resolveEnabled(config?: ReporterConfig): boolean;
+    configureHtmlPipe(): void;
+    configureMarkdownPipe(): void;
+    configureRunGroup(runGroup: string | null | undefined): void;
+    startRun(): Promise<void>;
+    reportTestStart(test: Test): Promise<void>;
+    combineStepsAndNotes(test: Test, lastScreenshotFile?: string): Step[];
+    buildVerificationStep(test: Test, lastScreenshotFile?: string): Step | undefined;
+    reportTest(test: Test, meta?: ReporterMeta): Promise<void>;
+    finishRun(): Promise<void>;
+    isEnabled(): boolean;
+    setRunDescription(text: string): Promise<void>;
+    extractLastNoteMessage(test: Test): string;
+    reportSteps(test: Test, steps: ReporterStep[]): Promise<void>;
+}