explorbot 0.1.31 → 0.1.32-beta.1

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,35 @@
+import { type Span } from '@opentelemetry/api';
+export type LogType = 'info' | 'success' | 'error' | 'warning' | 'debug' | 'substep' | 'operation' | 'step' | 'multiline' | 'details' | 'html' | 'input';
+export interface TaggedLogEntry {
+    type: LogType;
+    content: string;
+    timestamp?: Date;
+    originalArgs?: any[];
+    namespace?: string;
+    maxLines?: number;
+}
+type LogEntry = TaggedLogEntry;
+export declare const tag: (type: LogType) => {
+    log: (...args: any[]) => void;
+};
+export declare const log: (...args: any[]) => void;
+export declare const logSuccess: (...args: any[]) => void;
+export declare const logError: (...args: any[]) => void;
+export declare const logWarning: (...args: any[]) => void;
+export declare const logSubstep: (...args: any[]) => void;
+export declare const createDebug: (namespace: string) => (...args: any[]) => void;
+export declare const getMethodsOfObject: (obj: any) => string[];
+export declare const startLogCapture: () => void;
+export declare const stopLogCapture: () => string[];
+export declare const setVerboseMode: (enabled: boolean) => void;
+export declare const setPreserveConsoleLogs: (enabled: boolean) => void;
+export declare const isVerboseMode: () => boolean;
+export declare const setDebugMode: (enabled: boolean) => void;
+export declare const isDebugMode: () => boolean;
+export declare const registerLogPane: (addLog: (entry: LogEntry) => void) => void;
+export declare const unregisterLogPane: (addLog: (entry: LogEntry) => void) => void;
+export declare const addTruncateTag: (tagName: string) => void;
+export declare const setStepSpanParent: (span: Span | null) => void;
+export declare const setLogCallback: (addLog: (entry: LogEntry) => void) => void;
+export declare const pluralize: (count: number, singular: string, plural?: string) => string;
+export {};

package/dist/src/utils/loop.d.ts

@@ -0,0 +1,35 @@
+export declare class StopError extends Error {
+    constructor(message?: string);
+}
+export declare class InterruptError extends Error {
+    userInput: string | null;
+    constructor(userInput: string | null);
+}
+export interface LoopContext {
+    stop: () => void;
+    iteration: number;
+    pause: (prompt?: string) => Promise<string | null>;
+    userInput: string | null;
+    setUserInput: (input: string) => void;
+}
+export interface CatchContext {
+    error: Error;
+    stop: () => void;
+    iteration: number;
+}
+export interface LoopOptions {
+    maxAttempts?: number;
+    interruptible?: boolean;
+    interruptPrompt?: string;
+    onInterrupt?: (userInput: string | null, context: LoopContext) => Promise<void> | void;
+    catch?: (context: CatchContext) => Promise<void> | void;
+    observability?: {
+        name?: string;
+        agent?: string;
+        sessionId?: string;
+        tags?: string[];
+        metadata?: Record<string, unknown>;
+    };
+}
+export declare function pause(prompt?: string): Promise<string | null>;
+export declare function loop<T>(handler: (context: LoopContext) => Promise<T>, options?: LoopOptions): Promise<any>;

package/dist/src/utils/markdown-parser.d.ts

@@ -0,0 +1,17 @@
+export interface MarkdownSection {
+    name: string;
+    depth: number;
+    rawMarkdown: string;
+}
+export declare function parseSections(markdown: string, opts?: {
+    minDepth?: number;
+    maxDepth?: number;
+}): MarkdownSection[];
+export declare function extractLabeledCode(markdown: string, labelPattern: RegExp): string | null;
+export declare function tableToJson(markdown: string): Record<string, string>[];
+export declare function jsonToTable(rows: Record<string, string>[], columns?: string[]): string;
+export declare function findTableRaw(markdown: string): string | null;
+export declare function findTableLineRange(markdown: string): {
+    start: number;
+    end: number;
+} | null;

package/dist/src/utils/markdown-query.d.ts

@@ -0,0 +1,40 @@
+import { type Token } from 'marked';
+export type SelectorType = 'section' | 'section1' | 'section2' | 'section3' | 'section4' | 'section5' | 'section6' | 'table' | 'heading' | 'paragraph' | 'list' | 'item' | 'code' | 'blockquote' | 'hr' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+export interface TextMatcher {
+    mode: 'exact' | 'contains' | 'regex';
+    value: string;
+    negated: boolean;
+}
+export interface QuerySegment {
+    selector: SelectorType;
+    textMatch?: TextMatcher;
+    index: number | null;
+    slice: {
+        from?: number;
+        to?: number;
+    } | null;
+}
+export interface MatchedRange {
+    token: Token;
+    start: number;
+    length: number;
+    innerTokens?: MatchedRange[];
+}
+export declare function parseQuery(input: string): QuerySegment[];
+export declare class MarkdownQuery {
+    source: string;
+    matches: MatchedRange[];
+    constructor(source: string, matches?: MatchedRange[]);
+    query(selector: string): MarkdownQuery;
+    text(): string;
+    get(): string;
+    toJson(): Record<string, string>[];
+    replace(content: string): string;
+    count(): number;
+    first(): MarkdownQuery;
+    last(): MarkdownQuery;
+    before(): MarkdownQuery;
+    after(): MarkdownQuery;
+    each(): MarkdownQuery[];
+}
+export declare function mdq(source: string): MarkdownQuery;

package/dist/src/utils/markdown-terminal.d.ts

@@ -0,0 +1 @@
+export declare function parseMarkdownToTerminal(markdown: string): string;

package/dist/src/utils/next-steps.d.ts

@@ -0,0 +1,11 @@
+export interface NextStepCommand {
+    label: string;
+    command: string;
+}
+export interface NextStepSection {
+    label: string;
+    path?: string;
+    commands?: NextStepCommand[];
+}
+export declare function relativeToCwd(absPath: string): string;
+export declare function printNextSteps(sections: NextStepSection[]): void;

package/dist/src/utils/page-readiness.d.ts

@@ -0,0 +1,6 @@
+export declare function waitForPageReadiness(page: any, options?: PageReadinessOptions): Promise<void>;
+interface PageReadinessOptions {
+    timeout?: number;
+    spinnerSelectors?: string[];
+}
+export {};

package/dist/src/utils/research-parser.d.ts

@@ -0,0 +1 @@
+export { RESEARCH_COLUMN_ORDER, type ResearchElement, type ResearchSection, extractContainerFromBlockquote, extractValidContainers, formatResearchSummary, mapRowToElement, parseResearchSections, rebuildSectionMarkdown, } from '../ai/researcher/parser.js';

package/dist/src/utils/retry.d.ts

@@ -0,0 +1,8 @@
+export interface RetryOptions {
+    maxAttempts?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+    retryCondition?: (error: Error) => boolean;
+}
+export declare function withRetry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/src/utils/rules-loader.d.ts

@@ -0,0 +1,12 @@
+export declare class RulesLoader {
+    static loadRules(agentName: string, rulesConfig: RuleEntry[], currentUrl: string): string;
+    static loadStyles(agentName: string, styleNames: string[]): Record<string, string>;
+    static listStyleNames(agentName: string): string[];
+    static getActiveStyle(styles: Record<string, string>, iteration: number, override?: string): {
+        name: string;
+        approach: string;
+    };
+    static extractRules(agentName: string, targetDir: string): string[];
+}
+type RuleEntry = string | Record<string, string>;
+export type { RuleEntry };

package/dist/src/utils/secrets.d.ts

@@ -0,0 +1,4 @@
+export declare function registerSecret(value: string): void;
+export declare function redactSecrets(text: string): string;
+export declare function clearRegisteredSecrets(): void;
+export declare function isSecretName(name: string): boolean;

package/dist/src/utils/secrets.js

@@ -0,0 +1,28 @@
+const MIN_SECRET_LENGTH = 4;
+const secretValues = new Set();
+export function registerSecret(value) {
+    if (!value)
+        return;
+    if (value.length < MIN_SECRET_LENGTH)
+        return;
+    secretValues.add(value);
+}
+export function redactSecrets(text) {
+    if (!text)
+        return text;
+    let result = text;
+    for (const value of secretValues) {
+        if (!result.includes(value))
+            continue;
+        result = result.split(value).join('***REDACTED***');
+    }
+    return result;
+}
+export function clearRegisteredSecrets() {
+    secretValues.clear();
+}
+const SECRET_NAME_TOKENS = ['password', 'passwd', 'secret', 'token', 'apikey', 'api_key', 'credential', 'private_key', 'privatekey', 'access_key'];
+export function isSecretName(name) {
+    const lower = name.toLowerCase();
+    return SECRET_NAME_TOKENS.some((token) => lower.includes(token));
+}

package/dist/src/utils/step-analyzer.d.ts

@@ -0,0 +1,11 @@
+import type { SessionStep } from '../experience-tracker.js';
+import type { StepData } from '../test-plan.js';
+export declare const CODECEPT_TOOLS: readonly ["click", "hover", "pressKey", "form"];
+export type CodeceptToolName = (typeof CODECEPT_TOOLS)[number];
+export declare function isCodeceptToolName(toolName: string): toolName is CodeceptToolName;
+export declare function getCodeceptToolName(commandName: string): CodeceptToolName | null;
+export declare function getCodeceptToolNameFromCode(code: string): CodeceptToolName | null;
+export declare function stripComments(code: string): string;
+export declare function isNonReusableCode(code: string): boolean;
+export declare function toReusableSessionStep(step: StepData): SessionStep | null;
+export declare function mergeUniqueStepsByCode(primary: SessionStep[], secondary: SessionStep[]): SessionStep[];

package/dist/src/utils/strings.d.ts

@@ -0,0 +1,3 @@
+export declare function truncateJson(input: any): string;
+export declare function sanitizeFilename(name: string): string;
+export declare function safeFilename(name: string, ext?: string, maxBytes?: number): string;

package/dist/src/utils/test-files.d.ts

@@ -0,0 +1,3 @@
+export declare function loadTestSuites(testsDir: string): any[];
+export declare function printTestList(suites: any[]): void;
+export declare function dryRunTestFile(filePath: string): Promise<void>;

package/dist/src/utils/test-plan-markdown.d.ts

@@ -0,0 +1,9 @@
+import { Plan } from '../test-plan.js';
+export declare function planToCompactAiContext(plan: Plan): string;
+export declare function parsePlanFromMarkdown(filePath: string): Plan;
+export declare function parsePlansFromMarkdown(filePath: string): Plan[];
+export declare function savePlanToMarkdown(plan: Plan, filePath: string): void;
+export declare function savePlansToMarkdown(plans: Plan[], filePath: string): void;
+export declare function planToAiContext(plan: Plan, options?: {
+    skipSteps?: boolean;
+}): string;

package/dist/src/utils/throttle.d.ts

@@ -0,0 +1,2 @@
+export declare function throttle<T>(fn: () => Promise<T> | T, intervalSeconds?: number): Promise<T | undefined>;
+export declare function __clearThrottleCacheForTests(): void;

package/dist/src/utils/unique-names.d.ts

@@ -0,0 +1,2 @@
+export declare function uniqSessionName(): string;
+export declare function uniqExplorationName(): string;

package/dist/src/utils/url-matcher.d.ts

@@ -0,0 +1,6 @@
+export declare function isDynamicSegment(segment: string): boolean;
+export declare function hasDynamicUrlSegment(url: string): boolean;
+export declare function generalizeSegment(segment: string): string;
+export declare function generalizeUrl(url: string): string;
+export declare function matchesUrl(pattern: string, path: string): boolean;
+export declare function extractStatePath(url: string): string;

package/dist/src/utils/web-element.d.ts

@@ -0,0 +1,44 @@
+import { type RawElementData } from './html.js';
+import { type XPathMatch } from './xpath.js';
+export { extractElementData } from './html.js';
+export declare class WebElement {
+    tag: string;
+    role: string;
+    xpath: string;
+    clickXPath: string;
+    attrs: Record<string, string>;
+    text: string;
+    outerHTML: string;
+    x: number;
+    y: number;
+    constructor(data: {
+        tag: string;
+        role?: string;
+        xpath: string;
+        clickXPath: string;
+        attrs: Record<string, string>;
+        text: string;
+        outerHTML?: string;
+        x: number;
+        y: number;
+    });
+    get description(): string;
+    get keyAttrs(): string;
+    get coordinates(): string;
+    get eidx(): string | null;
+    get isNavigationLink(): boolean;
+    get filteredClasses(): string[];
+    get areaHints(): string[];
+    get contextLabel(): string;
+    get variantHints(): string[];
+    static fromRawData(d: RawElementData, role?: string): WebElement;
+    static fromXPathMatch(m: XPathMatch): WebElement;
+    static fromPlaywrightLocator(locator: any): Promise<WebElement | null>;
+    static fromEidx(page: any, eidx: string): Promise<WebElement | null>;
+    static fromEidxList(page: any, eidxList: string[]): Promise<WebElement[]>;
+    static findByXPath(html: string, xpath: string): Promise<{
+        totalFound: number;
+        elements: WebElement[];
+        error?: string;
+    }>;
+}

package/dist/src/utils/xpath.d.ts

@@ -0,0 +1,17 @@
+export interface XPathMatch {
+    tag: string;
+    outerHTML: string;
+    text: string;
+    absoluteXPath: string;
+    allAttrs: Record<string, string>;
+}
+export interface XPathResult {
+    totalFound: number;
+    matches: XPathMatch[];
+    error?: string;
+}
+export declare const isDynamicId: (id: string) => boolean;
+export declare const isGenericClass: (cls: string) => boolean;
+export declare function buildClickableXPath(el: XPathMatch): string;
+export declare function cssToAncestorXPath(css: string): string | null;
+export declare function evaluateXPath(html: string, xpath: string): Promise<XPathResult>;

package/package.json

@@ -1,39 +1,30 @@
 {
   "name": "explorbot",
-  "version": "0.1.31",
+  "version": "0.1.32-beta.1",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
   "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
   "exports": {
     ".": {
-      "bun": "./src/index.tsx",
+      "types": "./dist/src/index.d.ts",
+      "bun": "./src/index.ts",
       "import": "./dist/src/index.js"
     }
   },
   "bin": {
     "explorbot": "./dist/bin/explorbot-cli.js"
   },
-  "files": [
-    "dist/",
-    "src/**/*.ts",
-    "src/**/*.tsx",
-    "bin/**/*.ts",
-    "boat/api-tester/src/**/*.ts",
-    "boat/doc-collector/src/**/*.ts",
-    "boat/doc-collector/bin/**/*.ts",
-    "boat/doc-collector/package.json",
-    "rules/",
-    "assets/sample-files/"
-  ],
+  "files": ["dist/", "src/**/*.ts", "src/**/*.tsx", "bin/**/*.ts", "boat/api-tester/src/**/*.ts", "boat/doc-collector/src/**/*.ts", "boat/doc-collector/bin/**/*.ts", "boat/doc-collector/package.json", "rules/", "assets/sample-files/"],
   "scripts": {
-    "build": "bun run src/index.tsx build && bun run build:bin",
+    "build": "bun run build:bin",
     "build:bin": "bun build bin/explorbot-cli.ts --outdir bin --target node --external commander --format esm",
     "build:npm": "bash scripts/build-npm.sh",
     "prepublishOnly": "npm run build:npm",
-    "dev": "bun run src/index.tsx",
-    "start": "node dist/index.js",
-    "init": "bun run src/index.tsx init",
+    "dev": "bun run bin/explorbot-cli.ts start",
+    "start": "node dist/bin/explorbot-cli.js",
+    "init": "bun run bin/explorbot-cli.ts init",
     "test": "codeceptjs run",
     "test:headless": "codeceptjs run --headless",
     "test:ui": "bun test tests/ui",
@@ -52,13 +43,7 @@
     "check:fix": "biome check --write .",
     "langfuse:export": "bun run .claude/skills/explorbot-debug/langfuse-export.ts"
   },
-  "keywords": [
-    "cli",
-    "react",
-    "ink",
-    "codeceptjs",
-    "playwright"
-  ],
+  "keywords": ["cli", "react", "ink", "codeceptjs", "playwright"],
   "repository": {
     "type": "git",
     "url": "https://github.com/testomatio/explorbot"

package/src/action-result.ts

@@ -68,6 +68,7 @@ export class ActionResult implements ActionResultData {
   private _screenshot: Buffer | undefined = undefined;
   readonly htmlFile: string | undefined = undefined;
   private _html: string | undefined = undefined;
+  private snapshotCache = new Map<string, string>();
   readonly logFile: string | undefined = undefined;
   private _browserLogs: any[] | undefined = undefined;
   readonly ariaSnapshotFile: string | undefined = undefined;
@@ -151,6 +152,7 @@ export class ActionResult implements ActionResultData {
 
   set html(value: string) {
     this._html = value;
+    this.snapshotCache.clear();
   }
 
   get screenshot(): Buffer | undefined {
@@ -263,21 +265,26 @@ export class ActionResult implements ActionResultData {
 
   async simplifiedHtml(htmlConfig?: HtmlConfig): Promise<string> {
     const normalizedConfig = this.normalizeHtmlConfig(htmlConfig);
-    return await minifyHtml(htmlMinimalUISnapshot(this.html ?? '', normalizedConfig?.minimal));
+    const cacheKey = `simplified:${JSON.stringify(normalizedConfig?.minimal ?? null)}`;
+    return this.cachedSnapshot(cacheKey, () => minifyHtml(htmlMinimalUISnapshot(this.html ?? '', normalizedConfig?.minimal)));
   }
 
   async combinedHtml(htmlConfig?: HtmlConfig & { keepPositions?: boolean }): Promise<string> {
     const normalizedConfig = this.normalizeHtmlConfig(htmlConfig);
-    const combinedHtml = await minifyHtml(htmlCombinedSnapshot(this.html ?? '', normalizedConfig?.combined, { keepPositions: htmlConfig?.keepPositions }));
-    debugLog(`----${this.url}----`);
-    debugLog(`Combined HTML: \n${combinedHtml}`);
-    debugLog('----');
-    return combinedHtml;
+    const cacheKey = `combined:${!!htmlConfig?.keepPositions}:${JSON.stringify(normalizedConfig?.combined ?? null)}`;
+    return this.cachedSnapshot(cacheKey, async () => {
+      const combinedHtml = await minifyHtml(htmlCombinedSnapshot(this.html ?? '', normalizedConfig?.combined, { keepPositions: htmlConfig?.keepPositions }));
+      debugLog(`----${this.url}----`);
+      debugLog(`Combined HTML: \n${combinedHtml}`);
+      debugLog('----');
+      return combinedHtml;
+    });
   }
 
   async textHtml(htmlConfig?: HtmlConfig): Promise<string> {
     const normalizedConfig = this.normalizeHtmlConfig(htmlConfig);
-    return await minifyHtml(htmlTextSnapshot(this.html ?? '', normalizedConfig?.text));
+    const cacheKey = `text:${JSON.stringify(normalizedConfig?.text ?? null)}`;
+    return this.cachedSnapshot(cacheKey, () => minifyHtml(htmlTextSnapshot(this.html ?? '', normalizedConfig?.text)));
   }
 
   getInteractiveARIA(): string {
@@ -296,6 +303,14 @@ export class ActionResult implements ActionResultData {
     return parser.getConfig().html;
   }
 
+  private async cachedSnapshot(key: string, compute: () => Promise<string>): Promise<string> {
+    const cached = this.snapshotCache.get(key);
+    if (cached !== undefined) return cached;
+    const value = await compute();
+    this.snapshotCache.set(key, value);
+    return value;
+  }
+
   static fromState(state: WebPageState): ActionResult {
     let html: string | undefined = undefined;
     let screenshot: Buffer | undefined = undefined;

package/src/action.ts

@@ -303,11 +303,11 @@ class Action {
 
       if (isPlaywright) {
         const page = this.playwrightHelper.page;
-        const asyncFn = new Function('page', `return (async () => { ${sanitizedCode} })()`);
+        const asyncFn = createSandboxedFunction(['page'], `return (async () => { ${sanitizedCode} })()`);
         await asyncFn(page);
         await sleep(this.config.action?.delay || 500);
       } else {
-        const codeFunction = new Function('I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step', 'faker', sanitizedCode);
+        const codeFunction = createSandboxedFunction(['I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step', 'faker'], sanitizedCode);
         codeFunction(this.actor, tryTo, retryTo, within, hopeThat, step, faker);
         await recorder.add(() => sleep(this.config.action?.delay || 500));
         await recorder.promise();
@@ -366,7 +366,7 @@ class Action {
         if (!sanitizedCode) {
           throw new Error('No valid I.* commands found in code block');
         }
-        codeFunction = new Function('I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step', sanitizedCode);
+        codeFunction = createSandboxedFunction(['I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step'], sanitizedCode);
       }
       codeFunction(this.actor, tryTo, retryTo, within, hopeThat, step);
       await recorder.promise();
@@ -480,14 +480,21 @@ async function captureTitle(page: any, actor: any): Promise<string> {
   return '';
 }
 
-function sanitizeCodeBlock(code: string): string {
+const SHADOWED_GLOBALS = ['process', 'global', 'globalThis', 'fetch', 'Bun', 'require', 'module', 'exports'];
+
+export function sanitizeCodeBlock(code: string): string {
   return code
     .split('\n')
     .map((line) => line.trim())
-    .filter((line) => line.startsWith('I.') || line.startsWith('page.') || line.startsWith('await '))
+    .filter((line) => line.startsWith('I.') || line.startsWith('page.') || line.startsWith('await page.') || line.startsWith('await I.'))
     .join('\n');
 }
 
+export function createSandboxedFunction(argNames: string[], body: string): (...args: any[]) => any {
+  const fn = new Function(...argNames, ...SHADOWED_GLOBALS, `'use strict';\n${body}`);
+  return (...args: any[]) => fn(...args);
+}
+
 function hasPlaywrightCommands(code: string): boolean {
   return code.split('\n').some((line) => {
     const trimmed = line.trim();

package/src/ai/provider.ts

@@ -31,7 +31,7 @@ function extractCachedTokens(usage: any): number {
   return typeof fromRaw === 'number' ? fromRaw : 0;
 }
 
-function rejectAfterIdle(ms: number, signal: { cancelled: boolean }): Promise<never> {
+function rejectAfterIdle(ms: number, signal: { cancelled: boolean }, controller: AbortController): Promise<never> {
   return new Promise((_, reject) => {
     const tick = () => {
       if (signal.cancelled) return;
@@ -39,6 +39,7 @@ function rejectAfterIdle(ms: number, signal: { cancelled: boolean }): Promise<ne
         setTimeout(tick, ms);
         return;
       }
+      controller.abort();
       reject(new Error('AI request timeout'));
     };
     setTimeout(tick, ms);
@@ -367,13 +368,16 @@ export class Provider {
       const response = await withRetry(async () => {
         const timeout = config.timeout || 30000;
         const cancel = { cancelled: false };
+        const controller = new AbortController();
+        const combinedSignal = AbortSignal.any([controller.signal, executionController.getAbortSignal()].filter(Boolean) as AbortSignal[]);
         try {
           const result = (await Promise.race([
             generateText({
               messages,
               ...config,
+              abortSignal: combinedSignal,
             }),
-            rejectAfterIdle(timeout, cancel),
+            rejectAfterIdle(timeout, cancel, controller),
           ])) as any;
           const hasToolCall = (result.toolCalls?.length || 0) > 0;
           if (!result.text && !hasToolCall && result.finishReason === 'length') {
@@ -455,13 +459,16 @@ export class Provider {
       const response = await withRetry(async () => {
         const timeout = config.timeout || 30000;
         const cancel = { cancelled: false };
+        const controller = new AbortController();
+        const combinedSignal = AbortSignal.any([controller.signal, executionController.getAbortSignal()].filter(Boolean) as AbortSignal[]);
         try {
           return (await Promise.race([
             generateObject({
               messages,
               ...config,
+              abortSignal: combinedSignal,
             }),
-            rejectAfterIdle(timeout, cancel),
+            rejectAfterIdle(timeout, cancel, controller),
           ])) as any;
         } finally {
           cancel.cancelled = true;

package/src/experience-tracker.ts

@@ -8,6 +8,7 @@ import { KnowledgeTracker } from './knowledge-tracker.js';
 import type { WebPageState } from './state-manager.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.ts';
 import { extractStatePath } from './utils/url-matcher.js';
 
@@ -109,7 +110,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');
   }
 

package/src/explorer.ts

@@ -727,17 +727,22 @@ class Explorer {
 
     this.watchActiveTestPage();
 
-    codeceptjs.event.dispatcher.emit('test.before', codeceptjsTest);
-    codeceptjs.event.dispatcher.emit('test.start', codeceptjsTest);
-    codeceptjs.event.dispatcher.on('step.passed', (step: any) => stepHandler(step, 'passed'));
-    codeceptjs.event.dispatcher.on('step.failed', (step: any, error: any) => {
+    const onStepPassed = (step: any) => stepHandler(step, 'passed');
+    const onStepFailed = (step: any, error: any) => {
       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;
   }

package/src/index.ts

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

package/src/knowledge-tracker.ts

@@ -5,6 +5,7 @@ import { ActionResult } from './action-result.js';
 import { ConfigParser } from './config.js';
 import { getCliName } from './utils/cli-name.ts';
 import { createDebug } from './utils/logger.js';
+import { isSecretName, registerSecret } from './utils/secrets.js';
 
 const debugLog = createDebug('explorbot:knowledge-tracker');
 
@@ -138,9 +139,14 @@ export class KnowledgeTracker {
       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: any, k) => obj?.[k], config);
         if (value !== undefined && typeof value !== 'object') return String(value);