cdp-skill 1.0.16 → 1.0.17

package/{src → scripts}/page/page-controller.js

@@ -140,8 +140,7 @@ export function createPageController(cdpClient, options = {}) {
     }
   }
 
-  function onRequestStarted({ requestId, frameId }) {
-    if (frameId && frameId !== mainFrameId) return;
+  function onRequestStarted({ requestId }) {
     pendingRequests.add(requestId);
     networkRequestCount++;
     lastNetworkActivity = Date.now();
@@ -424,7 +423,9 @@ export function createPageController(cdpClient, options = {}) {
     addListener('Runtime.executionContextCreated', ({ context }) => {
       if (context.auxData && context.auxData.frameId) {
         frameExecutionContexts.set(context.auxData.frameId, context.id);
-        if (context.auxData.frameId === mainFrameId) {
+        // Update current context when the active frame gets a new context
+        // (handles both main frame and iframes after switchToFrame)
+        if (context.auxData.frameId === currentFrameId) {
           currentExecutionContextId = context.id;
         }
       }
@@ -437,6 +438,14 @@ export function createPageController(cdpClient, options = {}) {
           break;
         }
       }
+      if (executionContextId === currentExecutionContextId) {
+        currentExecutionContextId = null;
+      }
+    });
+
+    addListener('Runtime.executionContextsCleared', () => {
+      frameExecutionContexts.clear();
+      currentExecutionContextId = null;
     });
 
     addListener('Page.lifecycleEvent', onLifecycleEvent);
@@ -552,9 +561,8 @@ export function createPageController(cdpClient, options = {}) {
 
       await waitPromise;
 
-      if (abortReason) {
-        throw navigationAbortedError(abortReason, url);
-      }
+      // Note: if abort happened during waitPromise, abortWaiters already rejected it.
+      // We don't re-check abortReason here to avoid rejecting a successfully completed navigation.
 
       return {
         frameId: response.frameId,
@@ -646,10 +654,7 @@ export function createPageController(cdpClient, options = {}) {
    */
   async function getUrl() {
     try {
-      const result = await cdpClient.send('Runtime.evaluate', {
-        expression: 'window.location.href',
-        returnByValue: true
-      });
+      const result = await evaluateInFrame('window.location.href');
       return result.result.value;
     } catch (error) {
       throw connectionError(error.message, 'Runtime.evaluate (getUrl)');
@@ -662,10 +667,7 @@ export function createPageController(cdpClient, options = {}) {
    */
   async function getTitle() {
     try {
-      const result = await cdpClient.send('Runtime.evaluate', {
-        expression: 'document.title',
-        returnByValue: true
-      });
+      const result = await evaluateInFrame('document.title');
       return result.result.value;
     } catch (error) {
       throw connectionError(error.message, 'Runtime.evaluate (getTitle)');
@@ -689,6 +691,7 @@ export function createPageController(cdpClient, options = {}) {
     pendingRequests.clear();
     crashWaiters.clear();
     abortWaiters.clear();
+    networkIdleWaiters.clear();
   }
 
   /**
@@ -754,11 +757,11 @@ export function createPageController(cdpClient, options = {}) {
   async function setGeolocation(options) {
     const { latitude, longitude, accuracy = 1 } = options;
 
-    if (latitude < -90 || latitude > 90) {
-      throw new Error('Latitude must be between -90 and 90');
+    if (typeof latitude !== 'number' || Number.isNaN(latitude) || latitude < -90 || latitude > 90) {
+      throw new Error('Latitude must be a number between -90 and 90');
     }
-    if (longitude < -180 || longitude > 180) {
-      throw new Error('Longitude must be between -180 and 180');
+    if (typeof longitude !== 'number' || Number.isNaN(longitude) || longitude < -180 || longitude > 180) {
+      throw new Error('Longitude must be a number between -180 and 180');
     }
 
     await cdpClient.send('Emulation.setGeolocationOverride', {
@@ -811,7 +814,7 @@ export function createPageController(cdpClient, options = {}) {
 
     // Discover cross-origin iframes via DOM query
     try {
-      const domResult = await cdpClient.send('Runtime.evaluate', {
+      const evalParams = {
         expression: `
           (function() {
             const iframes = document.querySelectorAll('iframe');
@@ -826,7 +829,9 @@ export function createPageController(cdpClient, options = {}) {
           })()
         `,
         returnByValue: true
-      });
+      };
+      if (currentExecutionContextId) evalParams.contextId = currentExecutionContextId;
+      const domResult = await cdpClient.send('Runtime.evaluate', evalParams);
 
       const domIframes = domResult.result?.value;
       if (Array.isArray(domIframes)) {
@@ -894,7 +899,7 @@ export function createPageController(cdpClient, options = {}) {
       targetFrame = allFrames.find(f => f.frame.name === params);
 
       if (!targetFrame) {
-        const result = await cdpClient.send('Runtime.evaluate', {
+        const findParams = {
           expression: `
             (function() {
               const iframe = document.querySelector(${JSON.stringify(params)});
@@ -903,10 +908,12 @@ export function createPageController(cdpClient, options = {}) {
             })()
           `,
           returnByValue: true
-        });
+        };
+        if (currentExecutionContextId) findParams.contextId = currentExecutionContextId;
+        const result = await cdpClient.send('Runtime.evaluate', findParams);
 
-        if (result.result.value === 'found') {
-          const srcResult = await cdpClient.send('Runtime.evaluate', {
+        if (result.result?.value === 'found') {
+          const srcParams = {
             expression: `
               (function() {
                 const iframe = document.querySelector(${JSON.stringify(params)});
@@ -918,15 +925,18 @@ export function createPageController(cdpClient, options = {}) {
               })()
             `,
             returnByValue: true
-          });
+          };
+          if (currentExecutionContextId) srcParams.contextId = currentExecutionContextId;
+          const srcResult = await cdpClient.send('Runtime.evaluate', srcParams);
 
-          if (srcResult.result.value) {
+          if (srcResult.result?.value) {
             const { src, name } = srcResult.result.value;
             targetFrame = allFrames.find(f =>
-              (src && f.frame.url === src) ||
-              (src && f.frame.url.endsWith(src)) ||
-              (name && f.frame.name === name) ||
-              f.frame.parentId
+              f.frame.parentId && (
+                (src && f.frame.url === src) ||
+                (src && f.frame.url.endsWith(src)) ||
+                (name && f.frame.name === name)
+              )
             );
 
             if (!targetFrame) {
@@ -1108,10 +1118,7 @@ export function createPageController(cdpClient, options = {}) {
    */
   async function getViewport() {
     try {
-      const result = await cdpClient.send('Runtime.evaluate', {
-        expression: '({ width: window.innerWidth, height: window.innerHeight })',
-        returnByValue: true
-      });
+      const result = await evaluateInFrame('({ width: window.innerWidth, height: window.innerHeight })');
       return result.result.value;
     } catch (error) {
       throw connectionError(error.message, 'Runtime.evaluate (getViewport)');

package/{src → scripts}/runner/context-helpers.js

@@ -69,6 +69,13 @@ export function buildActionContext(action, params, context) {
     case 'press': {
       return `Pressed ${params || 'key'}`;
     }
+    case 'upload': {
+      if (typeof params === 'string') return `Uploaded ${params}`;
+      if (Array.isArray(params)) return `Uploaded ${params.length} file(s)`;
+      if (params?.selector) return `Uploaded to ${params.selector}`;
+      if (params?.ref) return `Uploaded to [ref=${params.ref}]`;
+      return 'Uploaded file(s)';
+    }
     default:
       return '';
   }

package/{src → scripts}/runner/execute-browser.js

@@ -120,14 +120,14 @@ export async function executeEval(pageController, params) {
   }
 
   // Process serialized result if serialization was used
-  if (serialize && result.result.value && typeof result.result.value === 'object') {
+  if (serialize && result.result?.value && typeof result.result.value === 'object') {
     const evalSerializer = createEvalSerializer();
     return evalSerializer.processResult(result.result.value);
   }
 
   return {
-    value: result.result.value,
-    type: result.result.type
+    value: result.result?.value,
+    type: result.result?.type
   };
 }
 
@@ -402,121 +402,6 @@ export function formatCommandConsole(consoleCapture, messageCountBefore) {
   };
 }
 
-/**
- * Run an array of test steps
- * @param {Object} deps - Dependencies
- * @param {Array<Object>} steps - Array of step definitions
- * @param {Object} [options] - Execution options
- * @param {boolean} [options.stopOnError=true] - Stop on first error
- * @param {number} [options.stepTimeout=30000] - Timeout per step
- * @returns {Promise<{status: string, steps: Array, errors: Array}>}
- */
-export async function runSteps(deps, steps, options = {}) {
-  const validation = validateSteps(steps);
-  if (!validation.valid) {
-    throw stepValidationError(validation.errors);
-  }
-
-  const stopOnError = options.stopOnError !== false;
-  const result = {
-    status: 'ok',
-    steps: [],
-    errors: []
-  };
-
-  // Capture console message count before command starts
-  const consoleCountBefore = deps.consoleCapture ? deps.consoleCapture.getMessages().length : 0;
-
-  // Feature 8.1: Capture BEFORE state at command start (for diff baseline)
-  let beforeUrl, beforeViewport, beforeSnapshot;
-  const contextCapture = deps.pageController ? createContextCapture(deps.pageController.session) : null;
-
-  if (deps.ariaSnapshot && contextCapture) {
-    try {
-      beforeUrl = await getCurrentUrl(deps.pageController.session);
-      // Capture viewport-only snapshot for command-level diff
-      // Use preserveRefs to avoid clobbering refs from snapshotSearch
-      // Use internal to avoid incrementing snapshot ID (this is for diff, not agent-facing)
-      beforeViewport = await deps.ariaSnapshot.generate({ mode: 'ai', viewportOnly: true, preserveRefs: true, internal: true });
-    } catch {
-      // Ignore initial snapshot errors - will just skip diff comparison
-    }
-  }
-
-  for (const step of steps) {
-    const stepResult = await executeStep(deps, step, options);
-    result.steps.push(stepResult);
-
-    if (stepResult.status === 'error') {
-      result.status = 'error';
-      result.errors.push({
-        step: result.steps.length,
-        action: stepResult.action,
-        error: stepResult.error
-      });
-
-      if (stopOnError) {
-        break;
-      }
-    }
-    // 'skipped' (optional) steps don't fail the run
-  }
-
-  // Wait for async console messages after steps complete
-  if (deps.consoleCapture) {
-    await sleep(250);
-    const consoleSummary = formatCommandConsole(deps.consoleCapture, consoleCountBefore);
-    if (consoleSummary) {
-      result.console = consoleSummary;
-    }
-  }
-
-  // Feature 8.1: Capture AFTER state and compute command-level diff
-  if (deps.ariaSnapshot && contextCapture && beforeViewport) {
-    try {
-      const afterUrl = await getCurrentUrl(deps.pageController.session);
-      const afterContext = await contextCapture.captureContext();
-
-      // Capture both viewport and full page snapshots
-      // Use preserveRefs to avoid clobbering refs from snapshotSearch
-      // Use internal to avoid incrementing snapshot ID (this is for diff, not agent-facing)
-      const afterViewport = await deps.ariaSnapshot.generate({ mode: 'ai', viewportOnly: true, preserveRefs: true, internal: true });
-      const afterFull = await deps.ariaSnapshot.generate({ mode: 'ai', viewportOnly: false, preserveRefs: true, internal: true });
-
-      const navigated = contextCapture.isNavigation(beforeUrl, afterUrl);
-
-      // Save full page snapshot to file (use tabAlias for filename)
-      const fullSnapshotPath = await resolveTempPath(`${options.tabAlias || 'command'}.after.yaml`, '.yaml');
-      await fs.writeFile(fullSnapshotPath, afterFull.yaml || '', 'utf8');
-
-      // Add command-level results
-      result.navigated = navigated;
-      result.fullSnapshot = fullSnapshotPath;
-      result.context = afterContext;
-
-      // Always include viewport snapshot inline
-      result.viewportSnapshot = afterViewport.yaml;
-      result.truncated = afterViewport.truncated || false;
-
-      // For same-page interactions, compute viewport diff
-      if (!navigated && beforeViewport?.yaml) {
-        const differ = createSnapshotDiffer();
-        const viewportDiff = differ.computeDiff(beforeViewport.yaml, afterViewport.yaml);
-
-        // Report changes if any significant changes found
-        if (differ.hasSignificantChanges(viewportDiff)) {
-          const actionContext = buildCommandContext(steps);
-          result.changes = differ.formatDiff(viewportDiff, { actionContext });
-        }
-      }
-    } catch (e) {
-      result.viewportSnapshotError = e.message;
-    }
-  }
-
-  return result;
-}
-
 /**
  * Execute a validate step - query validation state of an element
  */

package/{src → scripts}/runner/execute-dynamic.js

@@ -65,8 +65,20 @@ export async function executePageFunction(pageController, params) {
   const arg = useRefs ? 'window.__ariaRefs' : '';
   const serializerFn = getSerializationWrapper();
 
+  // Detect async functions to await their return value
+  const isAsync = /^async[\s(]/.test(fn.trim()) ||
+    (fn.trim().startsWith('(') && /^async[\s(]/.test(fn.trim().slice(1).trim()));
+
   // Wrap the agent function so its return value is serialized
-  const wrapped = `(function() {
+  // Use async wrapper when the function is async so we can await its result
+  const wrapped = isAsync
+    ? `(async function() {
+  const __fn = ${fn};
+  const __serialize = ${serializerFn};
+  const __result = await __fn(${arg});
+  return __serialize(__result);
+})()`
+    : `(function() {
   const __fn = ${fn};
   const __serialize = ${serializerFn};
   const __result = __fn(${arg});
@@ -75,7 +87,7 @@ export async function executePageFunction(pageController, params) {
 
   const evalPromise = pageController.evaluateInFrame(wrapped, {
     returnByValue: true,
-    awaitPromise: false
+    awaitPromise: isAsync
   });
 
   let result;
@@ -84,8 +96,14 @@ export async function executePageFunction(pageController, params) {
     const tp = new Promise((_, reject) => {
       tid = setTimeout(() => reject(new Error(`pageFunction timed out after ${timeout}ms`)), timeout);
     });
-    result = await Promise.race([evalPromise, tp]);
-    clearTimeout(tid);
+    try {
+      result = await Promise.race([evalPromise, tp]);
+    } catch (err) {
+      evalPromise.catch(() => {});
+      throw err;
+    } finally {
+      clearTimeout(tid);
+    }
   } else {
     result = await evalPromise;
   }
@@ -96,7 +114,7 @@ export async function executePageFunction(pageController, params) {
     throw new Error(`pageFunction error: ${errorText}\nSource: ${fn.substring(0, 200)}`);
   }
 
-  return processSerializedResult(result.result.value);
+  return processSerializedResult(result.result?.value);
 }
 
 // ---------------------------------------------------------------------------
@@ -122,7 +140,18 @@ export async function executePoll(pageController, params) {
   }
 
   const serializerFn = getSerializationWrapper();
-  const expression = `(function() {
+
+  // Detect async predicates to properly await their return value
+  const isAsync = /^async[\s(]/.test(fn.trim()) ||
+    (fn.trim().startsWith('(') && /^async[\s(]/.test(fn.trim().slice(1).trim()));
+
+  const expression = isAsync
+    ? `(async function() {
+  const __fn = ${fn};
+  const __serialize = ${serializerFn};
+  return __serialize(await __fn());
+})()`
+    : `(function() {
   const __fn = ${fn};
   const __serialize = ${serializerFn};
   return __serialize(__fn());
@@ -134,7 +163,7 @@ export async function executePoll(pageController, params) {
   while (true) {
     const result = await pageController.evaluateInFrame(expression, {
       returnByValue: true,
-      awaitPromise: false
+      awaitPromise: isAsync
     });
 
     if (result.exceptionDetails) {
@@ -143,11 +172,11 @@ export async function executePoll(pageController, params) {
       throw new Error(`poll error: ${errorText}\nSource: ${fn.substring(0, 200)}`);
     }
 
-    const processed = processSerializedResult(result.result.value);
+    const processed = processSerializedResult(result.result?.value);
     lastValue = processed;
 
     // Check truthiness from the raw value (before serialization wrapping)
-    const rawVal = result.result.value;
+    const rawVal = result.result?.value;
     const isTruthy = rawVal !== null && rawVal !== undefined &&
       rawVal !== false && rawVal !== 0 && rawVal !== '' &&
       !(typeof rawVal === 'object' && rawVal !== null && rawVal.type === 'null') &&
@@ -336,8 +365,14 @@ export async function executePipeline(pageController, params) {
     const tp = new Promise((_, reject) => {
       tid = setTimeout(() => reject(new Error(`pipeline timed out after ${timeout}ms`)), timeout);
     });
-    result = await Promise.race([evalPromise, tp]);
-    clearTimeout(tid);
+    try {
+      result = await Promise.race([evalPromise, tp]);
+    } catch (err) {
+      evalPromise.catch(() => {});
+      throw err;
+    } finally {
+      clearTimeout(tid);
+    }
   } else {
     result = await evalPromise;
   }

package/{src → scripts}/runner/execute-form.js

@@ -105,8 +105,10 @@ export async function executeExtract(deps, params) {
             }
           }
 
-          // Get data rows
-          const dataRows = tableEl.querySelectorAll('tbody tr, tr');
+          // Get data rows - prefer tbody rows, fall back to all rows
+          const dataRows = tableEl.querySelector('tbody')
+            ? tableEl.querySelectorAll('tbody tr')
+            : tableEl.querySelectorAll('tr');
           let count = 0;
           for (const row of dataRows) {
             // Skip header row
@@ -222,7 +224,7 @@ export async function executeAssert(pageController, elementLocator, params) {
 
   // URL assertion
   if (params.url) {
-    const currentUrl = await pageController.getUrl();
+    const currentUrl = (await pageController.getUrl()) || '';
     const urlAssertion = { type: 'url', actual: currentUrl };
 
     if (params.url.contains) {
@@ -264,7 +266,7 @@ export async function executeAssert(pageController, elementLocator, params) {
           })()
         `);
 
-      const actualText = textResult.result.value;
+      const actualText = textResult.result?.value ?? null;
       textAssertion.found = actualText !== null;
 
       if (actualText === null) {