@specsage/cli 0.1.16 → 0.1.18

package/lib/browser.js

@@ -704,6 +704,7 @@ const DIALOG_BLOCKING_COMMANDS = ['navigate', 'click_element', 'select_option',
 
 async function handleCommand(msg) {
   const { request_id, command, params } = msg;
+  const startTime = Date.now();
 
   try {
     let result = {};
@@ -860,21 +861,70 @@ async function handleCommand(msg) {
         const centerX = x + w / 2;
         centerY = y + h / 2;
 
-        // Use Playwright's selectOption by locating the element at the position
-        const selectEl = page.locator('select').filter({
-          has: page.locator(`text="${value}"`)
-        }).or(page.locator('select')).first();
-
-        // Try to find the exact select element by position
-        const selectAtPoint = await page.evaluateHandle(
+        // Try to find a native <select> element by position
+        const selectHandle = await page.evaluateHandle(
           ({ x, y }) => document.elementFromPoint(x, y)?.closest('select'),
           { x: centerX, y: centerY }
         );
 
-        if (selectAtPoint) {
-          await selectAtPoint.selectOption({ label: value });
+        // evaluateHandle returns a JSHandle even for null — check the underlying value
+        const isNativeSelect = await selectHandle.evaluate(el => el !== null).catch(() => false);
+
+        if (isNativeSelect) {
+          await selectHandle.selectOption({ label: value });
         } else {
-          throw new Error(`No select element found at position for ${element_id}`);
+          // Custom combobox/select: click to open, then poll for the option.
+          // Options may load asynchronously (e.g. MUI selects that fetch data
+          // after a dependent field changes), so we retry instead of a fixed wait.
+
+          // Grab aria-controls before clicking so we can scope to the correct listbox
+          const listboxId = await page.evaluate(
+            ({ x, y }) => {
+              const el = document.elementFromPoint(x, y)?.closest('[role="combobox"]');
+              return el?.getAttribute('aria-controls') || null;
+            },
+            { x: centerX, y: centerY }
+          );
+
+          await page.mouse.click(centerX, centerY);
+
+          const SELECT_TIMEOUT = 10000;
+          const POLL_INTERVAL = 300;
+          const deadline = Date.now() + SELECT_TIMEOUT;
+          let clicked = false;
+
+          // Build a scoped listbox locator: prefer aria-controls ID, fall back to last visible listbox
+          const listboxLocator = listboxId
+            ? page.locator(`#${CSS.escape(listboxId)}`)
+            : page.locator('[role="listbox"]').last();
+
+          while (Date.now() < deadline) {
+            await new Promise(r => setTimeout(r, POLL_INTERVAL));
+
+            // Try scoped role=option first (MUI, Radix, Headless UI, etc.)
+            const optionLocator = listboxLocator.getByRole('option', { name: value, exact: true });
+            const optionCount = await optionLocator.count();
+            if (optionCount > 0) {
+              await optionLocator.first().click();
+              clicked = true;
+              break;
+            }
+
+            // Fallback: text match inside the scoped listbox or any ul within it
+            const textLocator = listboxLocator.locator(`text="${value}"`).or(
+              page.locator(`ul >> text="${value}"`)
+            ).first();
+            const textCount = await textLocator.count();
+            if (textCount > 0) {
+              await textLocator.click();
+              clicked = true;
+              break;
+            }
+          }
+
+          if (!clicked) {
+            throw new Error(`Option "${value}" not found in custom select after ${SELECT_TIMEOUT}ms`);
+          }
         }
 
         // Wait for page to settle after selection (form updates, validation)
@@ -1087,13 +1137,15 @@ async function handleCommand(msg) {
       }
     }
 
+    if (page) result.page_url = page.url();
+    result.duration_ms = Date.now() - startTime;
     send({ request_id, ok: true, result, error: null });
 
   } catch (err) {
     send({
       request_id,
       ok: false,
-      result: {},
+      result: { duration_ms: Date.now() - startTime },
       error: {
         code: "BROWSER_ERROR",
         message: err.message

package/lib/runner.rb

@@ -157,6 +157,7 @@ class Runner
     interactive_elements_by_id = build_elements_by_id(interactive_elements)
     previous_action = nil
     action_result = nil
+    browser_result = nil
 
     # Reset credentials and max_steps for each scenario (each has its own)
     scenario_credentials = {}
@@ -175,6 +176,7 @@ class Runner
         elements: interactive_elements,
         previous_action: previous_action,
         action_result: action_result,
+        browser_result: browser_result,
         pre_scenario_for_id: pre_scenario_for_id,
         execution_order: execution_order
       )
@@ -231,6 +233,7 @@ class Runner
 
       previous_action = action
       action_result = result[:result]
+      browser_result = { page_url: result[:page_url], duration_ms: result[:duration_ms] }
 
       # Check if step count has reached max_steps limit
       step_number = step_result[:step_number] || 0
@@ -505,16 +508,12 @@ class Runner
       url = substitute_credentials(url) if contains_credential_placeholder?(url)
 
       response = send_to_node('navigate', { url: url }, eval_capture_data: eval_capture_data)
-      screenshot_base64 = response.dig('result', 'screenshot_base64')
-      elements = response.dig('result', 'elements') || []
-      { result: "Navigated to #{display_url}", screenshot_base64: screenshot_base64, elements: elements }
+      extract_result(response, "Navigated to #{display_url}")
 
     when 'click'
       element_id = action['element_id']
       response = send_to_node('click_element', { element_id: element_id }, eval_capture_data: eval_capture_data)
-      screenshot_base64 = response.dig('result', 'screenshot_base64')
-      elements = response.dig('result', 'elements') || []
-      { result: "Clicked element #{element_id}", screenshot_base64: screenshot_base64, elements: elements }
+      extract_result(response, "Clicked element #{element_id}")
 
     when 'select'
       element_id = action['element_id']
@@ -523,9 +522,7 @@ class Runner
       value = substitute_credentials(value) if contains_credential_placeholder?(value)
 
       response = send_to_node('select_option', { element_id: element_id, value: value }, eval_capture_data: eval_capture_data)
-      screenshot_base64 = response.dig('result', 'screenshot_base64')
-      elements = response.dig('result', 'elements') || []
-      { result: "Selected '#{display_value}' in element #{element_id}", screenshot_base64: screenshot_base64, elements: elements }
+      extract_result(response, "Selected '#{display_value}' in element #{element_id}")
 
     when 'type'
       # Substitute credential placeholders at the last moment before browser execution
@@ -535,47 +532,46 @@ class Runner
       keys = substitute_credentials(keys) if contains_credential_placeholder?(keys)
 
       response = send_to_node('type', { keys: keys }, eval_capture_data: eval_capture_data)
-      screenshot_base64 = response.dig('result', 'screenshot_base64')
-      elements = response.dig('result', 'elements') || []
-      { result: "Typed: #{display_keys}", screenshot_base64: screenshot_base64, elements: elements }
+      extract_result(response, "Typed: #{display_keys}")
 
     when 'hotkey'
       keys = action['keys']
       response = send_to_node('hotkey', { keys: keys }, eval_capture_data: eval_capture_data)
-      screenshot_base64 = response.dig('result', 'screenshot_base64')
-      elements = response.dig('result', 'elements') || []
-      { result: "Hotkey: #{keys}", screenshot_base64: screenshot_base64, elements: elements }
+      extract_result(response, "Hotkey: #{keys}")
 
     when 'wait'
       response = send_to_node('wait', { ms: action['ms'] }, eval_capture_data: eval_capture_data)
-      screenshot_base64 = response.dig('result', 'screenshot_base64')
-      elements = response.dig('result', 'elements') || []
-      { result: "Waited #{action['ms']}ms", screenshot_base64: screenshot_base64, elements: elements }
+      extract_result(response, "Waited #{action['ms']}ms")
 
     when 'scroll'
       response = send_to_node('scroll', { direction: action['direction'] }, eval_capture_data: eval_capture_data)
-      screenshot_base64 = response.dig('result', 'screenshot_base64')
-      elements = response.dig('result', 'elements') || []
-      { result: "Scrolled #{action['direction']}", screenshot_base64: screenshot_base64, elements: elements }
+      extract_result(response, "Scrolled #{action['direction']}")
 
     when 'accept_dialog'
       value = action['value'] # Optional, for prompt dialogs
       response = send_to_node('accept_dialog', { value: value }, eval_capture_data: eval_capture_data)
-      screenshot_base64 = response.dig('result', 'screenshot_base64')
-      elements = response.dig('result', 'elements') || []
-      { result: "Accepted dialog#{value ? " with value '#{value}'" : ''}", screenshot_base64: screenshot_base64, elements: elements }
+      extract_result(response, "Accepted dialog#{value ? " with value '#{value}'" : ''}")
 
     when 'dismiss_dialog'
       response = send_to_node('dismiss_dialog', {}, eval_capture_data: eval_capture_data)
-      screenshot_base64 = response.dig('result', 'screenshot_base64')
-      elements = response.dig('result', 'elements') || []
-      { result: "Dismissed dialog", screenshot_base64: screenshot_base64, elements: elements }
+      extract_result(response, "Dismissed dialog")
 
     else
       { result: "Unknown action: #{action['action']}", screenshot_base64: nil, elements: nil }
     end
   end
 
+  def extract_result(response, description)
+    r = response['result'] || {}
+    {
+      result: description,
+      screenshot_base64: r['screenshot_base64'],
+      elements: r['elements'] || [],
+      page_url: r['page_url'],
+      duration_ms: r['duration_ms']
+    }
+  end
+
   def build_elements_by_id(elements)
     return {} unless elements
 

package/lib/step_client.rb

@@ -48,7 +48,7 @@ class StepClient
   # Submit a step to the server
   # Returns: { action: Hash, step_number: Integer, continue: Boolean }
   def submit_step(scenario_id:, screenshot_base64:, elements:, previous_action: nil, action_result: nil,
-                  pre_scenario_for_id: nil, execution_order: 0)
+                  browser_result: nil, pre_scenario_for_id: nil, execution_order: 0)
     body = {
       scenario_id: scenario_id,
       screenshot_base64: screenshot_base64,
@@ -58,6 +58,7 @@ class StepClient
 
     body[:previous_action] = previous_action if previous_action
     body[:action_result] = action_result if action_result
+    body[:browser_result] = browser_result if browser_result
     body[:pre_scenario_for_id] = pre_scenario_for_id if pre_scenario_for_id
 
     response = post("/api/runs/#{@server_run_id}/step", body)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specsage/cli",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "SpecSage CLI - AI-powered end-to-end testing automation (Node wrapper for Ruby CLI)",
   "type": "module",
   "bin": {