explorbot 0.4.8 → 0.4.10

package/boat/api-tester/src/cli.ts

@@ -40,7 +40,7 @@ export function createApiCommands(name = 'api'): Command {
       if (runOptions.endpoint && URL.canParse(runOptions.endpoint)) runOptions.baseEndpoint ||= runOptions.endpoint;
       try {
         const config = await parser.loadConfig(runOptions);
-        console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json }));
+        console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), siteConfigPath: parser.getSiteConfigPath(), root: parser.getProjectRoot(), json: options.json }));
       } catch (error) {
         console.error(error instanceof Error ? error.message : 'Unknown error');
         process.exit(1);

package/boat/api-tester/src/config.ts

@@ -18,7 +18,8 @@ import {
   resolveOutputRoot,
   setOutputDir,
 } from '../../../src/config.ts';
-import { type SiteRecord, findGlobalConfig, globalEnvPath, isGlobalConfigPath, registerSite, resolveSiteTarget } from '../../../src/global-config.ts';
+import { type SiteRecord, findGlobalConfig, globalEnvPath, isGlobalConfigPath, loadSiteConfig, registerSite, resolveSiteTarget } from '../../../src/global-config.ts';
+import { deepMerge } from '../../../src/utils/merge.ts';
 
 export type { AIConfig };
 
@@ -58,6 +59,7 @@ export class ApibotConfigParser {
   private config: ApibotConfig | null = null;
   private configPath: string | null = null;
   private site: SiteRecord | null = null;
+  private siteConfigPath: string | null = null;
 
   private constructor() {}
 
@@ -111,20 +113,22 @@ export class ApibotConfigParser {
         };
       }
 
-      this.config = this.mergeWithDefaults(loadedConfig);
-      this.applyEnvSpec(this.config.api);
-      this.applyEnvHeaders(this.config.api);
-      if (options?.baseEndpoint) this.config.api.baseEndpoint = options.baseEndpoint.replace(/\/$/, '');
-      await resolveConfigModels(this.config.ai);
-      resolveLangfuse(this.config.ai);
-      this.configPath = resolvedPath;
+      let config = this.mergeWithDefaults(loadedConfig);
+      this.applyEnvSpec(config.api);
+      this.applyEnvHeaders(config.api);
+      if (options?.baseEndpoint) config.api.baseEndpoint = options.baseEndpoint.replace(/\/$/, '');
+      await resolveConfigModels(config.ai);
+      resolveLangfuse(config.ai);
       this.site = null;
+      this.siteConfigPath = null;
 
       if (isGlobalConfigPath(resolvedPath)) {
-        this.enterGlobalMode(this.config, options?.endpoint);
+        config = await this.enterGlobalMode(config, options?.endpoint);
       }
 
-      this.validateConfig(this.config);
+      this.validateConfig(config);
+      this.config = config;
+      this.configPath = resolvedPath;
       setOutputDir(this.getOutputDir());
 
       return this.config;
@@ -144,6 +148,10 @@ export class ApibotConfigParser {
     return this.configPath;
   }
 
+  getSiteConfigPath(): string | null {
+    return this.siteConfigPath;
+  }
+
   getOutputDir(): string {
     const config = this.getConfig();
     return path.join(this.getProjectRoot(), config.dirs?.output || 'output');
@@ -207,17 +215,29 @@ export class ApibotConfigParser {
     api.headers = { ...api.headers, ...parseHeaders(process.env.EXPLORBOT_API_HEADERS) };
   }
 
-  private enterGlobalMode(config: ApibotConfig, endpoint?: string): void {
+  private async enterGlobalMode(config: ApibotConfig, endpoint?: string): Promise<ApibotConfig> {
     const site = resolveSiteTarget(endpoint);
     this.site = registerSite(site.baseUrl);
 
+    const { path, config: siteConfig } = await loadSiteConfig(this.site.dir, site.baseUrl);
+    this.siteConfigPath = path;
+
+    const overrides: Partial<ApibotConfig> = {};
+    if (siteConfig.ai) overrides.ai = siteConfig.ai;
+    if (siteConfig.api) overrides.api = siteConfig.api;
+
+    const merged = deepMerge(config, overrides);
+    await resolveConfigModels(merged.ai);
+    resolveLangfuse(merged.ai);
+
     let baseEndpoint = site.baseUrl;
     const envUrl = process.env.EXPLORBOT_URL;
     if (envUrl && URL.parse(envUrl)?.origin === site.baseUrl) baseEndpoint = envUrl.replace(/\/$/, '');
 
-    config.dirs = { output: 'output', knowledge: 'knowledge' };
-    config.api = { ...config.api, baseEndpoint };
+    merged.dirs = { output: 'output', knowledge: 'knowledge' };
+    merged.api = { ...merged.api, baseEndpoint };
     materializeKnowledge(this.site.dir);
+    return merged;
   }
 
   private async loadEnvConfig(): Promise<ApibotConfig> {
@@ -310,19 +330,7 @@ export class ApibotConfigParser {
   }
 
   private mergeWithDefaults(config: Partial<ApibotConfig>): ApibotConfig {
-    return this.deepMerge({ dirs: { output: 'output' }, api: {} }, config);
-  }
-
-  private deepMerge(target: any, source: any): any {
-    const result = { ...target };
-    for (const key in source) {
-      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key]) && source[key].constructor === Object) {
-        result[key] = this.deepMerge(result[key] || {}, source[key]);
-      } else {
-        result[key] = source[key];
-      }
-    }
-    return result;
+    return deepMerge({ dirs: { output: 'output' }, api: {} }, config);
   }
 }
 

package/dist/boat/api-tester/src/cli.js

@@ -38,7 +38,7 @@ export function createApiCommands(name = 'api') {
             runOptions.baseEndpoint ||= runOptions.endpoint;
         try {
             const config = await parser.loadConfig(runOptions);
-            console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json }));
+            console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), siteConfigPath: parser.getSiteConfigPath(), root: parser.getProjectRoot(), json: options.json }));
         }
         catch (error) {
             console.error(error instanceof Error ? error.message : 'Unknown error');

package/dist/boat/api-tester/src/config.js

@@ -11,7 +11,8 @@ import path, { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { parseEnv } from 'node:util';
 import { ConfigMissingError, EXPLORBOT_CONFIG_PATHS, createModel, envConfigRequested, materializeKnowledge, missingConfigMessage, resolveConfigModels, resolveLangfuse, resolveModel, resolveOutputRoot, setOutputDir, } from "../../../src/config.js";
-import { findGlobalConfig, globalEnvPath, isGlobalConfigPath, registerSite, resolveSiteTarget } from "../../../src/global-config.js";
+import { findGlobalConfig, globalEnvPath, isGlobalConfigPath, loadSiteConfig, registerSite, resolveSiteTarget } from "../../../src/global-config.js";
+import { deepMerge } from "../../../src/utils/merge.js";
 function isAbsoluteEndpoint(value) {
     return !!value && (value.startsWith('http://') || value.startsWith('https://'));
 }
@@ -30,6 +31,7 @@ export class ApibotConfigParser {
     config = null;
     configPath = null;
     site = null;
+    siteConfigPath = null;
     constructor() { }
     static getInstance() {
         if (!ApibotConfigParser.instance) {
@@ -76,19 +78,21 @@ export class ApibotConfigParser {
                     dirs: loadedConfig.dirs,
                 };
             }
-            this.config = this.mergeWithDefaults(loadedConfig);
-            this.applyEnvSpec(this.config.api);
-            this.applyEnvHeaders(this.config.api);
+            let config = this.mergeWithDefaults(loadedConfig);
+            this.applyEnvSpec(config.api);
+            this.applyEnvHeaders(config.api);
             if (options?.baseEndpoint)
-                this.config.api.baseEndpoint = options.baseEndpoint.replace(/\/$/, '');
-            await resolveConfigModels(this.config.ai);
-            resolveLangfuse(this.config.ai);
-            this.configPath = resolvedPath;
+                config.api.baseEndpoint = options.baseEndpoint.replace(/\/$/, '');
+            await resolveConfigModels(config.ai);
+            resolveLangfuse(config.ai);
             this.site = null;
+            this.siteConfigPath = null;
             if (isGlobalConfigPath(resolvedPath)) {
-                this.enterGlobalMode(this.config, options?.endpoint);
+                config = await this.enterGlobalMode(config, options?.endpoint);
             }
-            this.validateConfig(this.config);
+            this.validateConfig(config);
+            this.config = config;
+            this.configPath = resolvedPath;
             setOutputDir(this.getOutputDir());
             return this.config;
         }
@@ -106,6 +110,9 @@ export class ApibotConfigParser {
     getConfigPath() {
         return this.configPath;
     }
+    getSiteConfigPath() {
+        return this.siteConfigPath;
+    }
     getOutputDir() {
         const config = this.getConfig();
         return path.join(this.getProjectRoot(), config.dirs?.output || 'output');
@@ -168,16 +175,27 @@ export class ApibotConfigParser {
             return;
         api.headers = { ...api.headers, ...parseHeaders(process.env.EXPLORBOT_API_HEADERS) };
     }
-    enterGlobalMode(config, endpoint) {
+    async enterGlobalMode(config, endpoint) {
         const site = resolveSiteTarget(endpoint);
         this.site = registerSite(site.baseUrl);
+        const { path, config: siteConfig } = await loadSiteConfig(this.site.dir, site.baseUrl);
+        this.siteConfigPath = path;
+        const overrides = {};
+        if (siteConfig.ai)
+            overrides.ai = siteConfig.ai;
+        if (siteConfig.api)
+            overrides.api = siteConfig.api;
+        const merged = deepMerge(config, overrides);
+        await resolveConfigModels(merged.ai);
+        resolveLangfuse(merged.ai);
         let baseEndpoint = site.baseUrl;
         const envUrl = process.env.EXPLORBOT_URL;
         if (envUrl && URL.parse(envUrl)?.origin === site.baseUrl)
             baseEndpoint = envUrl.replace(/\/$/, '');
-        config.dirs = { output: 'output', knowledge: 'knowledge' };
-        config.api = { ...config.api, baseEndpoint };
+        merged.dirs = { output: 'output', knowledge: 'knowledge' };
+        merged.api = { ...merged.api, baseEndpoint };
         materializeKnowledge(this.site.dir);
+        return merged;
     }
     async loadEnvConfig() {
         const provider = process.env.EXPLORBOT_AI_PROVIDER;
@@ -261,18 +279,6 @@ export class ApibotConfigParser {
         }
     }
     mergeWithDefaults(config) {
-        return this.deepMerge({ dirs: { output: 'output' }, api: {} }, config);
-    }
-    deepMerge(target, source) {
-        const result = { ...target };
-        for (const key in source) {
-            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key]) && source[key].constructor === Object) {
-                result[key] = this.deepMerge(result[key] || {}, source[key]);
-            }
-            else {
-                result[key] = source[key];
-            }
-        }
-        return result;
+        return deepMerge({ dirs: { output: 'output' }, api: {} }, config);
     }
 }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",

package/dist/src/action.js

@@ -12,7 +12,9 @@ import { captureHtmlForSnapshot, htmlCombinedSnapshot, minifyHtml } from './util
 import { createDebug, setStepSpanParent, tag } from './utils/logger.js';
 import { Overlay, OverlayPage } from './utils/overlay.js';
 import { sleep, waitForPageReadiness } from "./utils/page-readiness.js";
+import { isInternalStep } from "./utils/step-analyzer.js";
 import { safeFilename } from "./utils/strings.js";
+import { isSameHostFamily } from './utils/url-matcher.js';
 import { codeceptJSSandbox, hasPlaywrightCommands, playwrightSandbox, sanitizeCodeBlock } from "./utils/web-sandbox.js";
 const debugLog = createDebug('explorbot:action');
 const CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS = 3;
@@ -303,7 +305,7 @@ class Action {
         const url = URL.parse(request.url());
         if (!url)
             return;
-        if (url.origin !== this.baseOrigin)
+        if (!isSameHostFamily(url.href, this.baseOrigin))
             return;
         const call = { method: request.method(), path: url.pathname, status };
         if (this.networkRequests.some((r) => r.method === call.method && r.path === call.path && r.status === call.status))
@@ -523,7 +525,7 @@ export const attachStepLogger = (target, assertionsTarget) => {
     const listener = (step, error) => {
         if (!step?.toCode)
             return;
-        if (step.name?.startsWith('grab'))
+        if (isInternalStep(step))
             return;
         const existing = recorded.get(step);
         if (existing) {

package/dist/src/ai/fisherman/tools.js

@@ -196,13 +196,19 @@ export function createAskApiTool(fisherman, task) {
     return {
         askApi: tool({
             description: dedent `
-        Ask what data already exists, changing nothing.
-        Ask a question about existing records: which ones are there, what they are called, whether a particular one exists.
-        Use it before precondition() to see whether suitable data is already available, and whenever a step needs the exact name or id of a record that is already there.
+        Read the app's data over the API, changing nothing.
+        Answers questions about records: which ones are there, what they are called, whether a particular one exists.
+
+        Use it to:
+        - check whether suitable data already exists, before precondition() creates any
+        - get the exact name or id of a record a step must act on
+        - find out whether an action was stored, when the app reported success but the page does not show the result
+        - find out whether data exists at all, when a list or dropdown is empty
+
         It never creates, edits or deletes anything — precondition() does that.
       `,
             inputSchema: z.object({
-                question: z.string().describe('What to find out about data that already exists'),
+                question: z.string().describe('What to find out about the data'),
             }),
             execute: async ({ question }) => {
                 tag('info').log(`Ask API: ${question}`);

package/dist/src/ai/navigator.d.ts

@@ -26,7 +26,6 @@ declare class Navigator implements Agent {
     constructor(deps: AgentDeps);
     get verifyAttempts(): number;
     get verifyTimeout(): number;
-    getBaseOrigin(): string | null;
     getComparableCurrentUrl(stateManager: any, expectedUrl: string): string;
     comparableUrl(state: {
         url?: string;

package/dist/src/ai/navigator.js

@@ -12,7 +12,7 @@ import { createDebug, pluralize, tag } from '../utils/logger.js';
 import { loop, pause } from '../utils/loop.js';
 import { RulesLoader } from "../utils/rules-loader.js";
 import { normalizeInlineText } from "../utils/strings.js";
-import { extractStatePath, matchesNavigationUrl } from '../utils/url-matcher.js';
+import { extractStatePath, isSameHostFamily, matchesNavigationUrl } from '../utils/url-matcher.js';
 import { Researcher } from "./researcher.js";
 import { actionRule, locatorRule, unexpectedPopupRule } from './rules.js';
 import { isInteractive } from './task-agent.js';
@@ -82,15 +82,6 @@ class Navigator {
     get verifyTimeout() {
         return this.config.ai?.agents?.navigator?.verifyTimeout ?? 1500;
     }
-    getBaseOrigin() {
-        const baseUrl = this.config.playwright.url;
-        try {
-            return new URL(baseUrl).origin;
-        }
-        catch {
-            return null;
-        }
-    }
     getComparableCurrentUrl(stateManager, expectedUrl) {
         const currentState = stateManager.getCurrentState();
         if (!currentState)
@@ -109,19 +100,14 @@ class Navigator {
         const currentFullUrl = currentState.fullUrl || currentState.url || '';
         if (!currentFullUrl)
             return false;
-        try {
-            const currentOrigin = new URL(currentFullUrl).origin;
-            if (/^https?:\/\//i.test(expectedUrl)) {
-                return currentOrigin === new URL(expectedUrl).origin;
-            }
-            const baseOrigin = this.getBaseOrigin();
-            if (!baseOrigin)
-                return true;
-            return currentOrigin === baseOrigin;
-        }
-        catch {
+        if (!/^https?:\/\//i.test(currentFullUrl))
             return !/^https?:\/\//i.test(expectedUrl);
-        }
+        if (/^https?:\/\//i.test(expectedUrl))
+            return isSameHostFamily(currentFullUrl, expectedUrl);
+        const baseUrl = this.config.playwright.url;
+        if (!baseUrl)
+            return true;
+        return isSameHostFamily(currentFullUrl, baseUrl);
     }
     isOnExpectedPage(expectedUrl, stateManager) {
         if (!this.isSameExpectedOrigin(expectedUrl, stateManager)) {
@@ -289,8 +275,9 @@ class Navigator {
                         tag('warning').log(`Page state did not change at ${check.freshState.url}`);
                     }
                     else {
-                        lastFailure = `Reached ${check.freshState.url}, expected ${expectedUrl}`;
-                        tag('warning').log(`URL verification failed: expected ${expectedUrl}, got ${check.freshState.url}`);
+                        const reachedUrl = check.freshState.fullUrl || check.freshState.url;
+                        lastFailure = `Reached ${reachedUrl}, expected ${expectedUrl}`;
+                        tag('warning').log(`URL verification failed: expected ${expectedUrl}, got ${reachedUrl}`);
                     }
                     batchFailures.push({
                         code: codeBlock,

package/dist/src/ai/pilot.js

@@ -95,7 +95,9 @@ export class Pilot {
             }
         }
         const schema = z.object({
-            decision: z.enum(['pass', 'fail', 'continue', 'skipped']).describe('pass = test succeeded, fail = test failed, continue = tester should keep going, skipped = scenario is irrelevant OR systematic execution failures prevented testing'),
+            decision: z
+                .enum(['pass', 'fail', 'continue', 'skipped'])
+                .describe('pass = scenario goal accomplished, fail = the app misbehaved, continue = tester should keep going, skipped = the scenario cannot be judged against this app (its premise does not hold, it is irrelevant, or systematic execution failures prevented testing)'),
             reason: z.string().describe('Concise user-facing reason, maximum 1 short sentence and 120 characters. Do NOT repeat the decision status; explain only the evidence. For continue: explain why rejected and suggest alternatives.'),
             guidance: z.string().nullable().describe('Required for "continue": specific actionable instruction for the tester — what exactly to verify, retry differently, or complete next. Be concrete.'),
             requestVerification: z
@@ -358,9 +360,13 @@ export class Pilot {
         DOM assertion can't be made.
         Do not pass when Tester achieved only a related navigation/filter/tab/status outcome instead of the
         requested action, workflow, or entity detail goal.
-      - "fail": goal not achieved and no further step toward it is available on the current page.
-      - "skipped": scenario is irrelevant to the app, OR systematic infrastructure failures (LLM errors,
-        crashes) prevented testing. NOT for "test failed to interact" — that's "fail" or "continue".
+      - "fail": the app misbehaved — the scenario's action ran against the right target and the app
+        produced a wrong, broken, or missing outcome. Not reaching the goal is not by itself a fail.
+      - "skipped": the scenario cannot be judged against this app — the page shows its premise does not
+        hold (the assumed constraint, field, or behaviour is designed differently), the target entity or
+        feature is not the one here, the scenario is irrelevant, OR systematic infrastructure failures
+        (LLM errors, crashes) prevented testing. NOT for "test failed to interact" — that's "fail" or
+        "continue".
       - "continue": goal incomplete but the control for the NEXT step is present on the current page, or a
         concrete missing check would change your verdict. Guidance must name that step.
         If a verify() asserted a state that was ALREADY TRUE before the test, it proves nothing — reject.
@@ -922,14 +928,14 @@ export class Pilot {
         const lines = [];
         for (const [assertion, passed] of Object.entries(currentState.verifications ?? {})) {
             if (passed)
-                lines.push(`state verification (passed): ${assertion}`);
+                lines.push(`verify: ${assertion}`);
         }
         for (const exec of testerConversation.getToolExecutions()) {
             if (!EVIDENCE_TOOLS.includes(exec.toolName) || !exec.wasSuccessful)
                 continue;
             const description = exec.input?.assertion || exec.input?.request || truncateJson(exec.input);
-            const result = exec.output?.message || exec.output?.analysis || exec.output?.result;
-            lines.push(`CHECK ${exec.toolName} (executed successfully): ${description}${result ? ` -> ${result}` : ''}`);
+            const analysis = exec.output?.analysis;
+            lines.push(`${exec.toolName}: ${description}${analysis ? ` -> ${analysis}` : ''}`);
         }
         return [...new Set(lines)].join('\n');
     }
@@ -1053,9 +1059,14 @@ export class Pilot {
 
       YOUR Pilot-only tools, both over the API:
 
-      askApi(question) — ask what data already exists. It changes nothing. Use it to check whether
-      suitable data is already there before creating any, and to get the exact name or id of an existing
-      record a step must act on.
+      askApi(question) — read the app's data over the API. It changes nothing. Use when:
+
+      - Before precondition() — check whether suitable data already exists.
+      - A step needs the exact name or id of an existing record.
+      - The app reported success but the page does not show the result — ask whether it was stored.
+      - A list or dropdown is empty — ask whether the data exists at all.
+
+      The page is not the only witness. A record missing from the page may still exist.
 
       precondition(description) — create FRESH disposable test data. Never request users. Use when:
 

package/dist/src/ai/rerunner.js

@@ -18,6 +18,7 @@ import { formatHeadings } from "../utils/context-formatter.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { loop } from "../utils/loop.js";
 import { RulesLoader } from "../utils/rules-loader.js";
+import { isInternalStep } from "../utils/step-analyzer.js";
 import { toolExecutionLabel } from "./conversation.js";
 import { actionRule, locatorRule, sectionContextRule } from "./rules.js";
 import { TaskAgent } from "./task-agent.js";
@@ -70,6 +71,8 @@ export class Rerunner extends TaskAgent {
         const onStepStarted = (step) => {
             if (!step.toCode)
                 return;
+            if (isInternalStep(step))
+                return;
             const code = highlight(step.toCode(), { language: 'javascript' });
             console.log(chalk.dim(`    ${code}`));
         };
@@ -77,12 +80,16 @@ export class Rerunner extends TaskAgent {
             const task = this.getCurrentTask(testMap);
             if (!task || !step.toCode)
                 return;
+            if (isInternalStep(step))
+                return;
             task.addStep(step.toCode(), step.duration, 'passed');
         };
         const onStepFailed = (step, error) => {
             const task = this.getCurrentTask(testMap);
             if (!task || !step.toCode)
                 return;
+            if (isInternalStep(step))
+                return;
             task.addStep(step.toCode(), step.duration, 'failed', error?.message);
             console.log(chalk.red(`    ${figureSet.cross} ${step.toCode()} — ${error?.message || 'failed'}`));
         };

package/dist/src/ai/tools.js

@@ -1202,7 +1202,8 @@ async function extractWebElements(error) {
 function formatElementList(matched) {
     if (!matched)
         return 'Could not fetch element details. Repeat the action to get better info.';
-    return matched
+    const keys = matched.map((el) => `${el.text}::${el.visible}::${el.html}`);
+    const list = matched
         .map((el, i) => {
         const lines = [`Element ${i + 1}:`, `Text: "${el.text}"`];
         if (el.visible !== undefined)
@@ -1210,10 +1211,16 @@ function formatElementList(matched) {
         const wrapped = matched.map((_, j) => j).filter((j) => j !== i && matched[j].xpath.startsWith(`${el.xpath}/`));
         if (wrapped.length)
             lines.push(`Wraps: element ${wrapped.map((j) => j + 1).join(', ')}`);
+        const same = keys.map((_, j) => j).filter((j) => j !== i && keys[j] === keys[i]);
+        if (same.length)
+            lines.push(`Identical to element ${same.map((j) => j + 1).join(', ')}`);
         lines.push(`XPath: ${el.xpath}`, `HTML: ${el.html}`);
         return lines.join('\n');
     })
         .join('\n\n');
+    if (new Set(keys).size === matched.length)
+        return list;
+    return `${list}\n\nIdentical matches are not told apart by their number — picking one is a guess. Click the one you mean by appearance with visualClick().`;
 }
 export async function formatMatchedElements(error) {
     return formatElementList(await extractWebElements(error));

package/dist/src/api/xhr-capture.js

@@ -1,3 +1,4 @@
+import { isSameHostFamily } from '../utils/url-matcher.js';
 import { RequestResult, generateRequestId } from "./request-result.js";
 const WRITE_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
 const JSON_CONTENT_TYPES = /application\/json|application\/.*\+json/i;
@@ -33,7 +34,7 @@ export class XhrCapture {
             return;
         const method = request.method();
         const url = request.url();
-        if (!url.startsWith(this.baseOrigin))
+        if (!isSameHostFamily(url, this.baseOrigin))
             return;
         const status = response.status();
         if (status >= 400) {

package/dist/src/commands/config-command.d.ts

@@ -15,11 +15,13 @@ export declare class ConfigCommand extends BaseCommand {
 }
 interface ConfigSummaryOptions {
     configPath?: string | null;
+    siteConfigPath?: string | null;
     root?: string;
     json?: boolean;
 }
 export interface ConfigData {
     config: string;
+    siteConfig: string;
     url: string;
     browser: string;
     headless: boolean;

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

@@ -13,7 +13,7 @@ export class ConfigCommand extends BaseCommand {
     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() }));
+        tag('info').log(ConfigCommand.render(this.explorBot.getConfig(), { configPath: parser.getConfigPath(), siteConfigPath: parser.getSiteConfigPath(), root: parser.getProjectRoot() }));
     }
     static async summary(options = {}) {
         const parser = ConfigParser.getInstance();
@@ -24,12 +24,15 @@ export class ConfigCommand extends BaseCommand {
                 throw error;
             return load(site.url);
         });
-        return ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json });
+        return ConfigCommand.render(config, { configPath: parser.getConfigPath(), siteConfigPath: parser.getSiteConfigPath(), root: parser.getProjectRoot(), json: options.json });
     }
     static data(config, options = {}) {
         let configPath = '';
         if (options.configPath && existsSync(options.configPath))
             configPath = options.configPath;
+        let siteConfigPath = '';
+        if (options.siteConfigPath && existsSync(options.siteConfigPath))
+            siteConfigPath = options.siteConfigPath;
         const dirs = {};
         if (options.root) {
             for (const [name, dir] of Object.entries({ output: 'output', ...config.dirs })) {
@@ -55,6 +58,7 @@ export class ConfigCommand extends BaseCommand {
         }
         return {
             config: configPath,
+            siteConfig: siteConfigPath,
             url: config.playwright?.url || config.web?.url || config.api?.baseEndpoint || '',
             browser: config.playwright?.browser || '',
             headless: !config.playwright?.show,
@@ -75,6 +79,8 @@ export class ConfigCommand extends BaseCommand {
         const lines = [];
         const section = (title, entries) => lines.push(...renderSection(title, entries));
         const general = [['config', data.config || 'EXPLORBOT_* environment variables']];
+        if (data.siteConfig)
+            general.push(['site config', data.siteConfig]);
         if (data.url)
             general.push(['url', data.url]);
         if (data.browser) {

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

@@ -6,10 +6,7 @@ import { findGlobalConfig, globalConfigPath, globalDir, globalEnvPath } from "..
 import { getCliName } from "../utils/cli-name.js";
 import { log, tag } from '../utils/logger.js';
 import { relativeToCwd } from "../utils/next-steps.js";
-function defaultConfigTemplate(provider, esm) {
-    let moduleExport = 'module.exports = config;';
-    if (esm)
-        moduleExport = 'export default config;';
+function defaultConfigTemplate(provider) {
     return `// 'provider/model-id' uses a bundled provider.
 // It is also possible to import provider as a module from Vercel AI SDK.
 // https://github.com/testomatio/explorbot/blob/main/docs/basics/providers.md
@@ -34,7 +31,7 @@ ${modelLines(provider)}
   },
 };
 
-${moduleExport}
+export default config;
 `;
 }
 export function envTemplate(provider) {
@@ -128,8 +125,7 @@ export function runInitCommand(options) {
             log('Use --force to overwrite existing file');
             process.exit(1);
         }
-        const esm = extname(outPath) !== '.js' || isModuleProject(dirname(outPath));
-        writeFileSync(outPath, defaultConfigTemplate(provider, esm), 'utf8');
+        writeFileSync(outPath, defaultConfigTemplate(provider), 'utf8');
         log(`Created config file: ${relativeToCwd(outPath)}`);
         const envPath = resolve(process.cwd(), '.env');
         if (!existsSync(envPath)) {
@@ -234,6 +230,8 @@ export function modelLines(provider, only) {
 function globalConfigTemplate(provider) {
     const { envKey } = PROVIDERS[provider];
     return `// Global Explorbot configuration — used by every directory without its own explorbot.config.js.
+// Settings shared by every site. Each site extends them in
+// ~/.explorbot/sites/<host>/explorbot.config.js, written on its first run.
 // Models are written as 'provider/model-id' so they resolve without a local node_modules.
 // The key is read from ${envKey} in ~/.explorbot/.env
 // Model ids are snapshotted from the recommendations of this Explorbot version.
@@ -251,27 +249,9 @@ ${modelLines(provider)}
   },
 };
 
-module.exports = config;
+export default config;
 `;
 }
-function isModuleProject(configDir) {
-    let currentDir = resolve(configDir);
-    while (true) {
-        const packagePath = join(currentDir, 'package.json');
-        if (existsSync(packagePath)) {
-            try {
-                return JSON.parse(readFileSync(packagePath, 'utf8')).type === 'module';
-            }
-            catch {
-                return false;
-            }
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir)
-            return false;
-        currentDir = parentDir;
-    }
-}
 function writeEnvKey(key, value) {
     const envPath = globalEnvPath();
     let content = '# AI provider API keys';