explorbot 0.4.6 → 0.4.7

package/src/ai/tools.ts

@@ -374,6 +374,7 @@ export function createCodeceptJSTools({ explorer, stateManager }: ToolDeps, task
         - Working with iframes (switch context with I.switchTo)
         - Performing multiple form actions in a single batch
         - Complex interactions requiring sequential commands
+        - Reaching items further down a list (I.scrollTo)
 
         Example - filling a form with context (PREFERRED):
         I.fillField('Username', 'John', '.login-form')
@@ -441,10 +442,10 @@ export function createCodeceptJSTools({ explorer, stateManager }: ToolDeps, task
 
           if (!hasObservablePageChange(toolResult)) {
             activeNote.commit(TestResult.FAILED);
-            return failedToolResult('form', 'Form command executed, but no observable page or form-state change was captured.', {
+            return failedToolResult('form', 'Command executed, but nothing on the page changed: no navigation, no ARIA change, no HTML change and no request.', {
               ...toolResult,
               code: codeBlock,
-              suggestion: 'Treat the field/form action as not completed. Re-locate the editable control, check whether another UI layer is active, then retry and verify the field value before submitting.',
+              suggestion: 'The command ran without reaching anything. Re-locate the target, check whether another UI layer is active, then retry. If the goal was to load more of a list, no change means the collection has ended.',
             });
           }
           await commitNote(activeNote, TestResult.PASSED, toolResult, action);
@@ -1238,7 +1239,10 @@ export function successToolResult(action: string, data?: Record<string, any>, so
 }
 
 export function isMajorPageChange(pageDiff: PageDiff): boolean {
-  return pageDiff.urlChanged !== true && (pageDiff.ariaChangeCount ?? 0) >= LARGE_ARIA_CHANGE_THRESHOLD;
+  if (pageDiff.urlChanged === true) return false;
+  if ((pageDiff.ariaChangeCount ?? 0) < LARGE_ARIA_CHANGE_THRESHOLD) return false;
+  if (pageDiff.ariaRemoved === 0 && (pageDiff.ariaAdded ?? 0) > 0) return false;
+  return true;
 }
 
 export function hasFailedRequest(pageDiff: PageDiff): boolean {

package/src/commands/options/ws-option.ts

@@ -6,6 +6,20 @@ export class WsOption extends BaseOption {
   flags = '--ws <url>';
   description = 'Stream this run to a remote UI over WebSocket';
 
+  /**
+   * An open socket holds the event loop, and `WebSocket` has no `unref` on
+   * either runtime — so a command that ends by returning rather than through
+   * `showStatsAndExit` would never exit once it is attached. The option that
+   * opened the connection is what closes it.
+   */
+  override register(command: Command): void {
+    super.register(command);
+    command.hook('postAction', async () => {
+      if (!remote.isAttached()) return;
+      await remote.close(0);
+    });
+  }
+
   protected apply(options: Record<string, any>, command: Command): void {
     const url = options.ws || process.env.EXPLORBOT_WS_URL;
     if (!url) return;

package/src/config.ts

@@ -677,17 +677,7 @@ export class ConfigParser {
       config.playwright.url = options.baseUrl;
     }
 
-    if (config.ai) {
-      const langfuse = config.ai.langfuse;
-      const publicKey = langfuse?.publicKey || process.env.LANGFUSE_PUBLIC_KEY;
-      const secretKey = langfuse?.secretKey || process.env.LANGFUSE_SECRET_KEY;
-      config.ai.langfuse = {
-        enabled: langfuse?.enabled ?? Boolean(publicKey && secretKey),
-        publicKey,
-        secretKey,
-        baseUrl: langfuse?.baseUrl || process.env.LANGFUSE_BASE_URL || process.env.LANGFUSE_HOST,
-      };
-    }
+    resolveLangfuse(config.ai);
 
     return config;
   }
@@ -857,6 +847,20 @@ export async function resolveConfigModels(ai?: AIConfig): Promise<void> {
   }
 }
 
+export function resolveLangfuse(ai?: AIConfig): void {
+  if (!ai) return;
+
+  const langfuse = ai.langfuse;
+  const publicKey = langfuse?.publicKey || process.env.LANGFUSE_PUBLIC_KEY;
+  const secretKey = langfuse?.secretKey || process.env.LANGFUSE_SECRET_KEY;
+  ai.langfuse = {
+    enabled: langfuse?.enabled ?? Boolean(publicKey && secretKey),
+    publicKey,
+    secretKey,
+    baseUrl: langfuse?.baseUrl || process.env.LANGFUSE_BASE_URL || process.env.LANGFUSE_HOST,
+  };
+}
+
 export function resolveOutputRoot(baseUrl?: string): string {
   if (cachedOutputRoot) return cachedOutputRoot;
 

package/src/remote.ts

@@ -28,6 +28,7 @@ export class Remote implements LogDestination {
   private asks = new Map<string, (value: string | null) => void>();
   private askCounter = 0;
   private lastActivity: string | null = null;
+  private closing: Promise<void> | null = null;
 
   attach(url: string, command: string): void {
     if (this.url) return;
@@ -73,21 +74,10 @@ export class Remote implements LogDestination {
     });
   }
 
-  async close(exitCode: number): Promise<void> {
-    if (!this.url) return;
-    this.send('result', { ok: exitCode === 0, exitCode });
-    await this.flush();
-
-    this.url = null;
-    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
-    // Whoever asks next has nobody to ask — leaving the callback installed would
-    // route them into a closed socket and park them until the ask times out.
-    executionController.clearInputCallback();
-    for (const resolve of this.asks.values()) resolve(null);
-    this.asks.clear();
-    this.queue = [];
-    this.socket?.close();
-    this.socket = null;
+  close(exitCode: number): Promise<void> {
+    if (!this.url) return Promise.resolve();
+    if (!this.closing) this.closing = this.shutdown(exitCode);
+    return this.closing;
   }
 
   isEnabled(): boolean {
@@ -116,6 +106,23 @@ export class Remote implements LogDestination {
     });
   }
 
+  private async shutdown(exitCode: number): Promise<void> {
+    this.send('result', { ok: exitCode === 0, exitCode });
+    await this.flush();
+
+    this.url = null;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    // Whoever asks next has nobody to ask — leaving the callback installed would
+    // route them into a closed socket and park them until the ask times out.
+    executionController.clearInputCallback();
+    for (const resolve of this.asks.values()) resolve(null);
+    this.asks.clear();
+    this.queue = [];
+    this.socket?.close();
+    this.socket = null;
+    this.closing = null;
+  }
+
   private connect(): void {
     if (!this.url) return;
 

package/src/utils/aria.ts

@@ -521,7 +521,12 @@ export const diffAriaSnapshots = (previous: string | null, current: string | nul
   const renames = detectRenames(prev, curr, prevTotals, currTotals);
   const added = [...byCount.added, ...renames.added];
   const removed = [...byCount.removed, ...renames.removed];
-  return { text: formatDiff(added, removed, toggled, typed), count: added.length + removed.length + toggled.length + typed.length };
+  return {
+    text: formatDiff(added, removed, toggled, typed),
+    count: added.length + removed.length + toggled.length + typed.length,
+    added: added.length,
+    removed: removed.length,
+  };
 };
 
 export const detectFocusArea = (snapshot: string | null): FocusAreaResult => {
@@ -587,6 +592,8 @@ export const LARGE_ARIA_CHANGE_THRESHOLD = 50;
 export interface AriaDiff {
   text: string | null;
   count: number;
+  added: number;
+  removed: number;
 }
 
 type AriaNode = {

package/src/utils/markdown-query.ts

@@ -162,6 +162,12 @@ function matchText(text: string, matcher: TextMatcher): boolean {
   return matcher.negated ? !result : result;
 }
 
+function entryKey(line: string): string | null {
+  const separator = line.indexOf(':');
+  if (separator < 1) return null;
+  return line.slice(0, separator).trim().toLowerCase();
+}
+
 function getTokenText(token: Token): string {
   const t = token as any;
   switch (token.type) {
@@ -407,6 +413,39 @@ export class MarkdownQuery {
     return results;
   }
 
+  keyValue(): Record<string, string> {
+    const entries: Record<string, string> = {};
+
+    for (const range of this.matches) {
+      for (const line of getTokenText(range.token).split('\n')) {
+        const key = entryKey(line);
+        if (!key) continue;
+        const value = line.slice(line.indexOf(':') + 1).trim();
+        if (value) entries[key] = value;
+      }
+    }
+
+    return entries;
+  }
+
+  setKeyValue(key: string, value: string | null): string {
+    return this.replaceEach((match) => {
+      const token = match.matches[0].token;
+      const lines = getTokenText(token)
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+
+      const index = lines.findIndex((line) => entryKey(line) === key.toLowerCase());
+      if (index < 0 && value) lines.push(`${key}: ${value}`);
+      if (index >= 0 && value) lines[index] = `${key}: ${value}`;
+      if (index >= 0 && !value) lines.splice(index, 1);
+
+      if (token.type !== 'blockquote') return lines.join('\n');
+      return lines.map((line) => `> ${line}`).join('\n');
+    });
+  }
+
   replace(content: string): string {
     return this.replaceEach(() => content);
   }

package/src/utils/pagination.ts

@@ -0,0 +1,36 @@
+export function inspectList(css: string): ListMeasure | null {
+  const element = document.querySelector(css);
+  if (!element) return null;
+  const rect = element.getBoundingClientRect();
+  return {
+    hasPagingControls: !!element.querySelector('a[rel="next"], a[rel="prev"]'),
+    isFeed: element.matches('[role="feed"]') || !!element.querySelector('[role="feed"]'),
+    scrolls: element.scrollHeight > element.clientHeight + 1 || rect.bottom > window.innerHeight,
+    items: element.querySelectorAll(':scope > *').length,
+    scrollTop: element.scrollTop,
+    pageScrollY: window.scrollY,
+  };
+}
+
+export function restoreScroll({ css, scrollTop, pageScrollY }: ScrollPosition): void {
+  const element = document.querySelector(css);
+  if (element) element.scrollTop = scrollTop;
+  window.scrollTo(0, pageScrollY);
+}
+
+export type PaginationStrategy = 'controls' | 'infinite';
+
+export interface ListMeasure {
+  hasPagingControls: boolean;
+  isFeed: boolean;
+  scrolls: boolean;
+  items: number;
+  scrollTop: number;
+  pageScrollY: number;
+}
+
+export interface ScrollPosition {
+  css: string;
+  scrollTop: number;
+  pageScrollY: number;
+}