cdp-skill 1.0.7 → 1.0.14

package/src/runner/step-executors.js

@@ -49,12 +49,40 @@ import { executeWait, executeWaitForNavigation, executeScroll } from './execute-
 import { executeClick, executeHover, executeDrag } from './execute-interaction.js';
 import { executeFillActive, executeSelectOption } from './execute-input.js';
 import { executeSnapshot, executeSnapshotSearch, executeQuery, executeQueryAll, executeInspect, executeGetDom, executeGetBox, executeRefAt, executeElementsAt, executeElementsNear } from './execute-query.js';
-import { executeValidate, executeSubmit, executeExtract } from './execute-form.js';
+// executeRefAt, executeElementsNear kept for internal dispatch from unified elementsAt
+import { executeSubmit, executeExtract } from './execute-form.js';
 import { executePdf, executeEval, executeCookies, executeListTabs, executeCloseTab, executeConsole, formatCommandConsole } from './execute-browser.js';
-import { executePageFunction, executePoll, executePipeline, executeWriteSiteManifest, loadSiteManifest, runLightAutoFit } from './execute-dynamic.js';
+// executeEval kept for internal dispatch from unified pageFunction
+import { executePageFunction, executePoll, executeWriteSiteProfile, executeReadSiteProfile, loadSiteProfile } from './execute-dynamic.js';
 
 const keyValidator = createKeyValidator();
 
+/**
+ * Detect if a string looks like a function expression (vs a bare expression).
+ * Functions start with (, function keyword, async keyword, or match arrow function patterns.
+ * Must use word boundaries to avoid matching identifiers like "asyncStorage" or "functionName".
+ */
+function isFunctionExpression(str) {
+  const trimmed = str.trim();
+  // Parenthesized expression / IIFE / arrow with parens: (...)
+  if (trimmed.startsWith('(')) {
+    return true;
+  }
+  // function keyword followed by space, paren, or * (generator)
+  if (/^function[\s*(]/.test(trimmed)) {
+    return true;
+  }
+  // async keyword followed by space or paren (async function, async () =>)
+  if (/^async[\s(]/.test(trimmed)) {
+    return true;
+  }
+  // Arrow function: identifier => ...
+  if (/^\w+\s*=>/.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+
 /**
  * Execute a single test step
  * @param {Object} deps - Dependencies
@@ -64,7 +92,7 @@ const keyValidator = createKeyValidator();
  */
 export async function executeStep(deps, step, options = {}) {
   const { pageController, elementLocator, inputEmulator } = deps;
-  const stepTimeout = options.stepTimeout || 30000;
+  let stepTimeout = options.stepTimeout || 30000;
   const isOptional = step.optional === true;
 
   const stepResult = {
@@ -101,37 +129,51 @@ export async function executeStep(deps, step, options = {}) {
       const gotoOptions = typeof step.goto === 'object' ? step.goto : {};
       await pageController.navigate(url, gotoOptions);
 
-      // Site manifest: load existing or run light auto-fit
+      // Wait for network to settle after navigation (best-effort, never throws)
+      await pageController.waitForNetworkSettle();
+
+      // Site profile: load existing or signal that none exists
       try {
         const currentUrl = await pageController.evaluateInFrame('window.location.href', { returnByValue: true });
         const resolvedUrl = currentUrl.result?.value || url;
         const domain = new URL(resolvedUrl).hostname.replace(/^www\./, '');
 
-        const existingManifest = await loadSiteManifest(domain);
-        if (existingManifest) {
-          stepResult.siteManifest = existingManifest;
+        const existingProfile = await loadSiteProfile(domain);
+        if (existingProfile) {
+          stepResult.siteProfile = existingProfile;
         } else {
-          const fitResult = await runLightAutoFit(pageController, resolvedUrl);
-          if (fitResult) {
-            stepResult.fitted = fitResult;
-          }
+          stepResult.profileAvailable = false;
+          stepResult.profileDomain = domain;
+          stepResult.hint = `Unknown site: ${domain}. No site profile exists. Create one with writeSiteProfile after exploring the site (snapshot, pageFunction, snapshotSearch). This speeds up all future visits.`;
         }
       } catch {
-        // Manifest/fit errors are non-fatal
+        // Profile errors are non-fatal
       }
     } else if (step.reload !== undefined) {
       stepResult.action = 'reload';
       const reloadOptions = step.reload === true ? {} : step.reload;
       await pageController.reload(reloadOptions);
+      await pageController.waitForNetworkSettle();
+    } else if (step.sleep !== undefined) {
+      stepResult.action = 'sleep';
+      await sleep(step.sleep);
     } else if (step.wait !== undefined) {
       stepResult.action = 'wait';
-      if (typeof step.wait === 'number') {
-        await sleep(step.wait);
-      } else {
-        await executeWait(elementLocator, step.wait);
-      }
+      await executeWait(elementLocator, step.wait);
     } else if (step.click !== undefined) {
       stepResult.action = 'click';
+
+      // Capture tabs before click for new-tab detection
+      let tabsBefore = null;
+      try {
+        if (deps.browser) {
+          const pages = await deps.browser.getPages();
+          tabsBefore = new Set(pages.map(p => p.targetId));
+        }
+      } catch {
+        // Detection failure is non-fatal
+      }
+
       const clickResult = await executeClick(elementLocator, inputEmulator, deps.ariaSnapshot, step.click);
       if (clickResult) {
         if (clickResult.method) {
@@ -155,29 +197,75 @@ export async function executeStep(deps, step, options = {}) {
           stepResult.warning = 'CDP click was intercepted, used JavaScript click fallback';
         }
       }
+
+      // Detect new tabs opened by the click
+      try {
+        if (tabsBefore && deps.browser) {
+          await sleep(200);
+          const pagesAfter = await deps.browser.getPages();
+          const newTabs = pagesAfter
+            .filter(p => !tabsBefore.has(p.targetId))
+            .map(p => ({ targetId: p.targetId, url: p.url, title: p.title }));
+          if (newTabs.length > 0) {
+            // Register new tabs in the tab registry so agents can switch to them
+            if (deps.registerNewTab) {
+              for (const tab of newTabs) {
+                tab.alias = deps.registerNewTab(tab.targetId);
+              }
+            }
+            stepResult.output = stepResult.output || {};
+            stepResult.output.newTabs = newTabs;
+          }
+        }
+      } catch {
+        // Detection failure is non-fatal
+      }
     } else if (step.fill !== undefined) {
       stepResult.action = 'fill';
-      const fillExecutor = createFillExecutor(
-        elementLocator.session,
-        elementLocator,
-        inputEmulator,
-        deps.ariaSnapshot
-      );
-      const urlBeforeFill = await getCurrentUrl(elementLocator.session);
-      await fillExecutor.execute(step.fill);
-      const urlAfterFill = await getCurrentUrl(elementLocator.session);
-      if (urlAfterFill !== urlBeforeFill) {
-        stepResult.output = { navigated: true, newUrl: urlAfterFill };
+      const params = step.fill;
+
+      if (typeof params === 'string') {
+        // Shape 1: focused mode — type into active element
+        stepResult.output = await executeFillActive(pageController, inputEmulator, params);
+        stepResult.output.mode = 'focused';
+      } else if (params && typeof params === 'object') {
+        const hasTargeting = params.selector || params.ref || params.label;
+        const hasFields = params.fields && typeof params.fields === 'object';
+
+        if (hasTargeting) {
+          // Shape 2: single field with targeting
+          const fillExecutor = createFillExecutor(
+            elementLocator.session,
+            elementLocator,
+            inputEmulator,
+            deps.ariaSnapshot,
+            { getFrameContext: pageController.getFrameContext }
+          );
+          const urlBeforeFill = await getCurrentUrl(elementLocator.session);
+          await fillExecutor.execute(params);
+          const urlAfterFill = await getCurrentUrl(elementLocator.session);
+          stepResult.output = { mode: 'single' };
+          if (urlAfterFill !== urlBeforeFill) {
+            stepResult.output.navigated = true;
+            stepResult.output.newUrl = urlAfterFill;
+          }
+        } else if (params.value !== undefined && !hasFields) {
+          // Shape 3: focused with options
+          stepResult.output = await executeFillActive(pageController, inputEmulator, params);
+          stepResult.output.mode = 'focused';
+        } else {
+          // Shape 4 ({fields: ...}) or Shape 5 (plain mapping)
+          const fillExecutor = createFillExecutor(
+            elementLocator.session,
+            elementLocator,
+            inputEmulator,
+            deps.ariaSnapshot,
+            { getFrameContext: pageController.getFrameContext }
+          );
+          stepResult.output = await fillExecutor.executeBatch(params);
+          stepResult.output.mode = 'batch';
+        }
       }
-    } else if (step.fillForm !== undefined) {
-      stepResult.action = 'fillForm';
-      const fillExecutor = createFillExecutor(
-        elementLocator.session,
-        elementLocator,
-        inputEmulator,
-        deps.ariaSnapshot
-      );
-      stepResult.output = await fillExecutor.executeBatch(step.fillForm);
     } else if (step.press !== undefined) {
       stepResult.action = 'press';
       const keyValidation = keyValidator.validate(step.press);
@@ -204,11 +292,10 @@ export async function executeStep(deps, step, options = {}) {
     } else if (step.pdf !== undefined) {
       stepResult.action = 'pdf';
       stepResult.output = await executePdf(deps.pdfCapture, elementLocator, step.pdf);
-    } else if (step.eval !== undefined) {
-      stepResult.action = 'eval';
-      stepResult.output = await executeEval(pageController, step.eval);
     } else if (step.snapshot !== undefined) {
       stepResult.action = 'snapshot';
+      // Brief network settle before capturing — catches async content loading
+      await pageController.waitForNetworkSettle({ timeout: 1500, idleTime: 200 });
       stepResult.output = await executeSnapshot(deps.ariaSnapshot, step.snapshot, { tabAlias: options.tabAlias, inlineLimit: options.inlineLimit });
     } else if (step.snapshotSearch !== undefined) {
       stepResult.action = 'snapshotSearch';
@@ -230,11 +317,13 @@ export async function executeStep(deps, step, options = {}) {
       const backOptions = step.back === true ? {} : step.back;
       const entry = await pageController.goBack(backOptions);
       stepResult.output = entry ? { url: entry.url, title: entry.title } : { noHistory: true };
+      if (entry) await pageController.waitForNetworkSettle();
     } else if (step.forward !== undefined) {
       stepResult.action = 'forward';
       const forwardOptions = step.forward === true ? {} : step.forward;
       const entry = await pageController.goForward(forwardOptions);
       stepResult.output = entry ? { url: entry.url, title: entry.title } : { noHistory: true };
+      if (entry) await pageController.waitForNetworkSettle();
     } else if (step.waitForNavigation !== undefined) {
       stepResult.action = 'waitForNavigation';
       await executeWaitForNavigation(pageController, step.waitForNavigation);
@@ -244,35 +333,47 @@ export async function executeStep(deps, step, options = {}) {
     } else if (step.closeTab !== undefined) {
       stepResult.action = 'closeTab';
       stepResult.output = await executeCloseTab(deps.browser, step.closeTab);
-    } else if (step.openTab !== undefined) {
-      stepResult.action = 'openTab';
-      if (step._openTabHandled) {
-        if (step._openTabUrl) {
-          await pageController.navigate(step._openTabUrl);
+    } else if (step.newTab !== undefined) {
+      stepResult.action = 'newTab';
+      if (step._newTabHandled) {
+        if (step._newTabUrl) {
+          const navOptions = {};
+          if (step._newTabTimeout) {
+            navOptions.timeout = step._newTabTimeout;
+          }
+          await pageController.navigate(step._newTabUrl, navOptions);
+          await pageController.waitForNetworkSettle();
+
+          // Site profile check (same as goto)
+          try {
+            const currentUrl = await pageController.evaluateInFrame('window.location.href', { returnByValue: true });
+            const resolvedUrl = currentUrl.result?.value || step._newTabUrl;
+            const domain = new URL(resolvedUrl).hostname.replace(/^www\./, '');
+
+            const existingProfile = await loadSiteProfile(domain);
+            if (existingProfile) {
+              stepResult.siteProfile = existingProfile;
+            } else {
+              stepResult.profileAvailable = false;
+              stepResult.profileDomain = domain;
+              stepResult.hint = `Unknown site: ${domain}. No site profile exists. Create one with writeSiteProfile after exploring the site (snapshot, pageFunction, snapshotSearch). This speeds up all future visits.`;
+            }
+          } catch {
+            // Profile errors are non-fatal
+          }
         }
-        stepResult.output = { tab: step._openTabAlias };
+        stepResult.output = { tab: step._newTabAlias };
       } else {
         throw new Error('openTab must be the first step when no targetId is provided');
       }
-    } else if (step.type !== undefined) {
-      stepResult.action = 'type';
+    } else if (step.selectText !== undefined) {
+      stepResult.action = 'selectText';
       const keyboardExecutor = createKeyboardExecutor(
         elementLocator.session,
         elementLocator,
         inputEmulator
       );
-      stepResult.output = await keyboardExecutor.executeType(step.type);
-    } else if (step.select !== undefined) {
-      stepResult.action = 'select';
-      const keyboardExecutor = createKeyboardExecutor(
-        elementLocator.session,
-        elementLocator,
-        inputEmulator
-      );
-      stepResult.output = await keyboardExecutor.executeSelect(step.select);
-    } else if (step.validate !== undefined) {
-      stepResult.action = 'validate';
-      stepResult.output = await executeValidate(elementLocator, step.validate);
+      stepResult.output = await keyboardExecutor.executeSelect(step.selectText);
     } else if (step.submit !== undefined) {
       stepResult.action = 'submit';
       stepResult.output = await executeSubmit(elementLocator, step.submit);
@@ -282,26 +383,44 @@ export async function executeStep(deps, step, options = {}) {
     } else if (step.queryAll !== undefined) {
       stepResult.action = 'queryAll';
       stepResult.output = await executeQueryAll(elementLocator, step.queryAll);
-    } else if (step.switchToFrame !== undefined) {
-      stepResult.action = 'switchToFrame';
-      stepResult.output = await pageController.switchToFrame(step.switchToFrame);
-    } else if (step.switchToMainFrame !== undefined) {
-      stepResult.action = 'switchToMainFrame';
-      stepResult.output = await pageController.switchToMainFrame();
-    } else if (step.listFrames !== undefined) {
-      stepResult.action = 'listFrames';
-      stepResult.output = await pageController.getFrameTree();
+    } else if (step.frame !== undefined) {
+      stepResult.action = 'frame';
+      const frameParams = step.frame;
+      if (frameParams === 'top') {
+        stepResult.output = await pageController.switchToMainFrame();
+      } else if (typeof frameParams === 'object' && frameParams.list) {
+        stepResult.output = await pageController.getFrameTree();
+      } else {
+        // string selector, number index, or {name: "foo"} — all go to switchToFrame
+        stepResult.output = await pageController.switchToFrame(frameParams);
+      }
     } else if (step.drag !== undefined) {
       stepResult.action = 'drag';
       stepResult.output = await executeDrag(elementLocator, inputEmulator, pageController, deps.ariaSnapshot, step.drag);
-    } else if (step.formState !== undefined) {
-      stepResult.action = 'formState';
-      const formValidator = createFormValidator(elementLocator.session, elementLocator);
-      const formSelector = typeof step.formState === 'string' ? step.formState : step.formState.selector;
-      stepResult.output = await formValidator.getFormState(formSelector);
-    } else if (step.extract !== undefined) {
-      stepResult.action = 'extract';
-      stepResult.output = await executeExtract(deps, step.extract);
+    } else if (step.get !== undefined) {
+      stepResult.action = 'get';
+      const getParams = step.get;
+      const mode = typeof getParams === 'object' ? getParams.mode : null;
+
+      if (mode === 'html') {
+        // HTML extraction mode → use getDom
+        stepResult.output = await executeGetDom(pageController, getParams);
+        stepResult.output.mode = 'html';
+      } else if (mode === 'box') {
+        // Bounding box mode → use getBox (requires ref format)
+        stepResult.output = await executeGetBox(deps.ariaSnapshot, getParams.ref || getParams.selector);
+        stepResult.output.mode = 'box';
+      } else if (mode === 'value') {
+        // Form value extraction → use formState
+        const formValidator = createFormValidator(elementLocator.session, elementLocator);
+        const selector = typeof getParams === 'string' ? getParams : getParams.selector;
+        stepResult.output = await formValidator.getFormState(selector);
+        stepResult.output.mode = 'value';
+      } else {
+        // Default: text/attributes extraction → use extract
+        stepResult.output = await executeExtract(deps, getParams);
+        stepResult.output.mode = mode || 'text';
+      }
     } else if (step.selectOption !== undefined) {
       stepResult.action = 'selectOption';
       stepResult.output = await executeSelectOption(elementLocator, step.selectOption);
@@ -311,30 +430,63 @@ export async function executeStep(deps, step, options = {}) {
     } else if (step.getBox !== undefined) {
       stepResult.action = 'getBox';
       stepResult.output = await executeGetBox(deps.ariaSnapshot, step.getBox);
-    } else if (step.fillActive !== undefined) {
-      stepResult.action = 'fillActive';
-      stepResult.output = await executeFillActive(pageController, inputEmulator, step.fillActive);
-    } else if (step.refAt !== undefined) {
-      stepResult.action = 'refAt';
-      stepResult.output = await executeRefAt(pageController.session, step.refAt);
     } else if (step.elementsAt !== undefined) {
       stepResult.action = 'elementsAt';
-      stepResult.output = await executeElementsAt(pageController.session, step.elementsAt);
-    } else if (step.elementsNear !== undefined) {
-      stepResult.action = 'elementsNear';
-      stepResult.output = await executeElementsNear(pageController.session, step.elementsNear);
+      const eaParams = step.elementsAt;
+      if (Array.isArray(eaParams)) {
+        // Batch mode (array of coordinates)
+        stepResult.output = await executeElementsAt(pageController.session, eaParams);
+      } else if (eaParams && typeof eaParams === 'object' && eaParams.radius !== undefined) {
+        // Nearby mode (has radius)
+        stepResult.output = await executeElementsNear(pageController.session, eaParams);
+      } else {
+        // Single point mode (was refAt)
+        stepResult.output = await executeRefAt(pageController.session, eaParams);
+      }
     } else if (step.pageFunction !== undefined) {
       stepResult.action = 'pageFunction';
-      stepResult.output = await executePageFunction(pageController, step.pageFunction);
+      const pfParams = step.pageFunction;
+      // Check if this is a bare expression (not a function)
+      const pfStr = typeof pfParams === 'string' ? pfParams : (pfParams?.fn || pfParams?.expression);
+      const isBareExpression = pfStr && !isFunctionExpression(pfStr);
+      if (isBareExpression) {
+        // Use eval-style wrapping for bare expressions
+        const evalParams = typeof pfParams === 'string'
+          ? pfStr
+          : { expression: pfStr, await: pfParams?.await, serialize: pfParams?.serialize, timeout: pfParams?.timeout };
+        stepResult.output = await executeEval(pageController, evalParams);
+      } else {
+        // If expression key provided, remap to fn
+        if (typeof pfParams === 'object' && pfParams.expression && !pfParams.fn) {
+          stepResult.output = await executePageFunction(pageController, { ...pfParams, fn: pfParams.expression });
+        } else {
+          stepResult.output = await executePageFunction(pageController, pfParams);
+        }
+      }
     } else if (step.poll !== undefined) {
       stepResult.action = 'poll';
       stepResult.output = await executePoll(pageController, step.poll);
-    } else if (step.pipeline !== undefined) {
-      stepResult.action = 'pipeline';
-      stepResult.output = await executePipeline(pageController, step.pipeline);
-    } else if (step.writeSiteManifest !== undefined) {
-      stepResult.action = 'writeSiteManifest';
-      stepResult.output = await executeWriteSiteManifest(step.writeSiteManifest);
+    } else if (step.writeSiteProfile !== undefined) {
+      stepResult.action = 'writeSiteProfile';
+      stepResult.output = await executeWriteSiteProfile(step.writeSiteProfile);
+    } else if (step.readSiteProfile !== undefined) {
+      stepResult.action = 'readSiteProfile';
+      stepResult.output = await executeReadSiteProfile(step.readSiteProfile);
+    } else if (step.switchTab !== undefined) {
+      stepResult.action = 'switchTab';
+      if (step._switchTabHandled) {
+        stepResult.output = { tab: step._switchTabAlias, connected: true };
+      } else {
+        throw new Error('switchTab must be the first step when no tab is specified');
+      }
+    } else if (step.getUrl !== undefined) {
+      stepResult.action = 'getUrl';
+      const urlResult = await pageController.evaluateInFrame('window.location.href', { returnByValue: true });
+      stepResult.output = { url: urlResult.result?.value };
+    } else if (step.getTitle !== undefined) {
+      stepResult.action = 'getTitle';
+      const titleResult = await pageController.evaluateInFrame('document.title', { returnByValue: true });
+      stepResult.output = { title: titleResult.result?.value };
     }
 
     // Process hooks on action steps (settledWhen, observe)
@@ -347,7 +499,11 @@ export async function executeStep(deps, step, options = {}) {
           timeout: stepTimeout || 30000
         });
         if (!settledResult.resolved) {
-          stepResult.warning = (stepResult.warning || '') + ' settledWhen timed out without resolving';
+          const lastValStr = settledResult.lastValue !== undefined
+            ? ` (last value: ${JSON.stringify(settledResult.lastValue).substring(0, 200)})`
+            : '';
+          stepResult.warning = (stepResult.warning || '') +
+            `settledWhen timed out after ${settledResult.elapsed || 'unknown'}ms${lastValStr}`;
         }
       }
 
@@ -360,6 +516,11 @@ export async function executeStep(deps, step, options = {}) {
   const definedAction = STEP_TYPES.find(type => step[type] !== undefined);
   const stepParams = definedAction ? step[definedAction] : null;
 
+  // Step-level timeout overrides the default step timeout
+  if (stepParams && typeof stepParams === 'object' && typeof stepParams.timeout === 'number' && stepParams.timeout > 0) {
+    stepTimeout = stepParams.timeout;
+  }
+
   let timeoutId;
   try {
     const stepPromise = executeStepInternal();