@loadmill/droid-cua 1.0.0 → 1.1.1

package/README.md

@@ -17,23 +17,23 @@
 
 ---
 
-**AI-powered Android testing using OpenAI's computer-use model**
+**AI-powered mobile testing using OpenAI's computer-use model**
 
-Create and run automated Android tests using natural language. The AI explores your app and generates executable test scripts.
+Create and run automated Android and iOS tests using natural language. The AI explores your app and generates executable test scripts.
 
-https://github.com/user-attachments/assets/36b2ea7e-820a-432d-9294-8aa61dceb4b0
+https://github.com/user-attachments/assets/e6450f45-3700-4cb6-aad5-33ba5f0437c3
 
 ---
 
 <h2 id="what-is-droid-cua">💡 What is droid-cua?</h2>
 
-`droid-cua` gives you three core components for Android testing:
+`droid-cua` gives you three core components for mobile testing:
 
 * **Interactive Shell** – Design and run tests with real-time feedback and visual status indicators
 * **Test Scripts** – Simple text files with natural language instructions and assertions
 * **AI Agent** – Autonomous exploration powered by OpenAI's computer-use model
 
-Together, these let you create and execute Android tests without writing traditional test code.
+Together, these let you create and execute Android and iOS tests without writing traditional test code.
 
 ---
 
@@ -66,10 +66,18 @@ Or create a `.env` file:
 echo "OPENAI_API_KEY=your-api-key" > .env
 ```
 
-**3. Ensure ADB is available**
+**3. Setup for your platform**
 
+For Android:
 ```sh
-adb version
+adb version  # Ensure ADB is available
+```
+
+For iOS (macOS only):
+```sh
+# Install Appium and XCUITest driver
+npm install -g appium
+appium driver install xcuitest
 ```
 
 **4. Run**
@@ -78,7 +86,20 @@ adb version
 droid-cua
 ```
 
-The emulator will auto-launch if not already running.
+An interactive menu will let you select your platform and device:
+
+```
+┌──────────────────────────────────────┐
+│ Select Platform                      │
+└──────────────────────────────────────┘
+
+❯ Android (1 running) - 2 emulator(s)
+  iOS - 5 simulator(s)
+
+↑/↓ Navigate  Enter Select  q Quit
+```
+
+The emulator/simulator will auto-launch if not already running.
 
 ---
 
@@ -176,31 +197,58 @@ assert: login button is enabled
 
 | Option | Description |
 |--------|-------------|
-| `--avd=NAME` | Specify emulator |
+| `--avd=NAME` | Specify emulator/simulator name |
+| `--platform=PLATFORM` | Force platform: `android` or `ios` |
 | `--instructions=FILE` | Run test headless |
 | `--record` | Save screenshots |
 | `--debug` | Enable debug logs |
 
+**Examples:**
+```sh
+# Interactive device selection
+droid-cua
+
+# Android emulator
+droid-cua --avd Pixel_8_API_35
+
+# iOS Simulator (auto-detected from name)
+droid-cua --avd "iPhone 16"
+
+# iOS Simulator (explicit platform)
+droid-cua --platform ios --avd "iPhone 16"
+
+# Headless CI mode
+droid-cua --avd "iPhone 16" --instructions tests/login.dcua
+```
+
 ---
 
 ## Requirements
 
+**All platforms:**
 - Node.js 18.17.0+
+- OpenAI API Key (Tier 3 for computer-use-preview model)
+
+**Android:**
 - Android Debug Bridge (ADB)
 - Android Emulator (AVD)
-- OpenAI API Key (Tier 3 for computer-use-preview model)
+
+**iOS (macOS only):**
+- Xcode with iOS Simulator
+- Appium (`npm install -g appium`)
+- XCUITest driver (`appium driver install xcuitest`)
 
 ---
 
 <h2 id="how-it-works">🔧 How It Works</h2>
 
-1. Connects to a running Android emulator
+1. Connects to Android emulator (via ADB) or iOS Simulator (via Appium)
 2. Captures full-screen device screenshots
 3. Scales down the screenshots for OpenAI model compatibility
 4. Sends screenshots and user instructions to OpenAI's computer-use-preview model
 5. Receives structured actions (click, scroll, type, keypress, wait, drag)
 6. Rescales model outputs back to real device coordinates
-7. Executes the actions on the device via ADB
+7. Executes the actions on the device
 8. Validates assertions and handles failures
 9. Repeats until task completion
 

package/build/index.js

@@ -8,8 +8,10 @@ import { buildBaseSystemPrompt } from "./src/core/prompts.js";
 import { startInkShell } from "./src/cli/ink-shell.js";
 import { ExecutionMode } from "./src/modes/execution-mode.js";
 import { logger } from "./src/utils/logger.js";
+import { selectDevice } from "./src/cli/device-selector.js";
 const args = minimist(process.argv.slice(2));
-const avdName = args["avd"];
+let avdName = args["avd"];
+let platform = args["platform"] || null; // 'ios' or 'android'
 const recordScreenshots = args["record"] || false;
 const instructionsFile = args.instructions || args.i || null;
 const debugMode = args["debug"] || false;
@@ -19,8 +21,14 @@ const screenshotDir = path.join("droid-cua-recording-" + Date.now());
 if (recordScreenshots)
     await mkdir(screenshotDir, { recursive: true });
 async function main() {
+    // If no device specified, show interactive selection menu
+    if (!avdName && !platform) {
+        const selection = await selectDevice();
+        platform = selection.platform;
+        avdName = selection.deviceName;
+    }
     // Connect to device
-    const deviceId = await connectToDevice(avdName);
+    const deviceId = await connectToDevice(avdName, platform);
     const deviceInfo = await getDeviceInfo(deviceId);
     console.log(`Using real resolution: ${deviceInfo.device_width}x${deviceInfo.device_height}`);
     console.log(`Model sees resolution: ${deviceInfo.scaled_width}x${deviceInfo.scaled_height}`);

package/build/src/cli/app.js

@@ -1,5 +1,5 @@
 import React, { useState, useEffect } from 'react';
-import { Box } from 'ink';
+import { Box, useInput } from 'ink';
 import { StatusBar } from './components/StatusBar.js';
 import { OutputPanel } from './components/OutputPanel.js';
 import { InputPanel } from './components/InputPanel.js';
@@ -22,6 +22,9 @@ export function App({ session, initialMode = 'command', onInput, onExit }) {
     const [isExecutionMode, setIsExecutionMode] = useState(false);
     const [inputValue, setInputValue] = useState('');
     const [inputResolver, setInputResolver] = useState(null); // For waiting on user input
+    const [commandHistory, setCommandHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [tempInput, setTempInput] = useState(''); // Store current typing when navigating history
     // Context object passed to modes and commands
     const context = {
         // Output methods
@@ -67,6 +70,34 @@ export function App({ session, initialMode = 'command', onInput, onExit }) {
             });
         },
     };
+    // Handle up/down arrow keys for command history
+    useInput((input, key) => {
+        if (inputDisabled)
+            return;
+        if (key.upArrow && commandHistory.length > 0) {
+            const newIndex = historyIndex === -1
+                ? commandHistory.length - 1
+                : Math.max(0, historyIndex - 1);
+            if (historyIndex === -1) {
+                setTempInput(inputValue); // Save current input
+            }
+            setHistoryIndex(newIndex);
+            setInputValue(commandHistory[newIndex]);
+        }
+        if (key.downArrow) {
+            if (historyIndex === -1)
+                return;
+            const newIndex = historyIndex + 1;
+            if (newIndex >= commandHistory.length) {
+                setHistoryIndex(-1);
+                setInputValue(tempInput); // Restore saved input
+            }
+            else {
+                setHistoryIndex(newIndex);
+                setInputValue(commandHistory[newIndex]);
+            }
+        }
+    });
     // Make context available globally for modes
     useEffect(() => {
         if (typeof global !== 'undefined') {
@@ -95,6 +126,12 @@ export function App({ session, initialMode = 'command', onInput, onExit }) {
             setInputValue('');
             return;
         }
+        // Add to command history (avoid duplicates of last command)
+        if (input && input !== commandHistory[commandHistory.length - 1]) {
+            setCommandHistory(prev => [...prev, input]);
+        }
+        setHistoryIndex(-1);
+        setTempInput('');
         // Add user input to output
         context.addOutput({ type: 'user', text: input });
         // Clear input value

package/build/src/cli/command-parser.js

@@ -45,6 +45,7 @@ export const COMMANDS = {
     view: 'View test contents with line numbers',
     edit: 'Edit a test in your default editor',
     stop: 'Stop current test creation or execution',
+    loadmill: 'Run Loadmill test flows using natural language',
 };
 /**
  * Get command suggestions for autocomplete

package/build/src/cli/device-selector.js

@@ -0,0 +1,195 @@
+/**
+ * Interactive device selection menu using Ink
+ */
+import React, { useState } from 'react';
+import { render, Box, Text, useInput, useApp } from 'ink';
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+/**
+ * Interactive selection component with arrow key navigation
+ */
+function SelectList({ title, items, onSelect }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const { exit } = useApp();
+    useInput((input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex((prev) => (prev > 0 ? prev - 1 : items.length - 1));
+        }
+        if (key.downArrow) {
+            setSelectedIndex((prev) => (prev < items.length - 1 ? prev + 1 : 0));
+        }
+        if (key.return) {
+            onSelect(items[selectedIndex]);
+        }
+        if (input === 'q' || key.escape) {
+            exit();
+            process.exit(0);
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, title)),
+        React.createElement(Box, { flexDirection: "column", paddingX: 1 }, items.map((item, index) => {
+            const isSelected = index === selectedIndex;
+            return (React.createElement(Box, { key: item.value + index },
+                React.createElement(Text, { color: isSelected ? 'green' : undefined }, isSelected ? '❯ ' : '  '),
+                React.createElement(Text, { bold: isSelected, color: isSelected ? 'green' : undefined }, item.label)));
+        })),
+        React.createElement(Box, { marginTop: 1, paddingX: 1 },
+            React.createElement(Text, { dimColor: true }, "\u2191/\u2193 Navigate  Enter Select  q Quit"))));
+}
+/**
+ * Render a selection and wait for result
+ */
+function renderSelection(title, items) {
+    return new Promise((resolve) => {
+        const { unmount } = render(React.createElement(SelectList, { title: title, items: items, onSelect: (item) => {
+                unmount();
+                resolve(item);
+            } }));
+    });
+}
+/**
+ * Get list of available Android AVDs
+ */
+async function getAndroidDevices() {
+    const devices = [];
+    // Get running emulators
+    try {
+        const { stdout: adbOutput } = await execAsync("adb devices");
+        const runningIds = adbOutput
+            .trim()
+            .split("\n")
+            .slice(1)
+            .map((line) => line.split("\t")[0])
+            .filter((id) => id.startsWith("emulator-"));
+        for (const id of runningIds) {
+            try {
+                const { stdout } = await execAsync(`adb -s ${id} emu avd name`);
+                const name = stdout.trim();
+                devices.push({
+                    label: `${name} (running)`,
+                    value: name,
+                    running: true,
+                });
+            }
+            catch { }
+        }
+    }
+    catch { }
+    // Get available AVDs
+    try {
+        const { stdout } = await execAsync("emulator -list-avds");
+        const avds = stdout.trim().split("\n").filter((name) => name.length > 0);
+        for (const avd of avds) {
+            if (!devices.some((d) => d.value === avd)) {
+                devices.push({
+                    label: avd,
+                    value: avd,
+                    running: false,
+                });
+            }
+        }
+    }
+    catch { }
+    return devices;
+}
+/**
+ * Get list of available iOS Simulators (iPhones only)
+ */
+async function getIOSDevices() {
+    const devices = [];
+    try {
+        const { stdout } = await execAsync("xcrun simctl list devices --json");
+        const data = JSON.parse(stdout);
+        const seen = new Set();
+        for (const [runtime, deviceList] of Object.entries(data.devices)) {
+            const versionMatch = runtime.match(/iOS[- ](\d+[-\.]\d+)/i);
+            const version = versionMatch ? versionMatch[1].replace("-", ".") : "";
+            for (const device of deviceList) {
+                if (device.isAvailable && !seen.has(device.name) && device.name.startsWith("iPhone")) {
+                    seen.add(device.name);
+                    const isBooted = device.state === "Booted";
+                    devices.push({
+                        label: isBooted
+                            ? `${device.name} (running)${version ? ` - iOS ${version}` : ""}`
+                            : `${device.name}${version ? ` - iOS ${version}` : ""}`,
+                        value: device.name,
+                        running: isBooted,
+                    });
+                }
+            }
+        }
+        // Sort: running first, then alphabetically
+        devices.sort((a, b) => {
+            if (a.running && !b.running)
+                return -1;
+            if (!a.running && b.running)
+                return 1;
+            return a.value.localeCompare(b.value);
+        });
+    }
+    catch { }
+    return devices;
+}
+/**
+ * Interactive device selection
+ * @returns {Promise<{platform: string, deviceName: string}>}
+ */
+export async function selectDevice() {
+    // Check what's available
+    const [androidDevices, iosDevices] = await Promise.all([
+        getAndroidDevices(),
+        getIOSDevices(),
+    ]);
+    const hasAndroid = androidDevices.length > 0;
+    const hasIOS = iosDevices.length > 0;
+    if (!hasAndroid && !hasIOS) {
+        console.error("\nNo devices found!");
+        console.error("  Android: Create an AVD with Android Studio");
+        console.error("  iOS: Xcode Simulator must be available");
+        process.exit(1);
+    }
+    // Build platform options
+    const platformOptions = [];
+    if (hasAndroid) {
+        const runningCount = androidDevices.filter((d) => d.running).length;
+        platformOptions.push({
+            label: `Android${runningCount > 0 ? ` (${runningCount} running)` : ""} - ${androidDevices.length} emulator(s)`,
+            value: "android",
+        });
+    }
+    if (hasIOS) {
+        const runningCount = iosDevices.filter((d) => d.running).length;
+        platformOptions.push({
+            label: `iOS${runningCount > 0 ? ` (${runningCount} running)` : ""} - ${iosDevices.length} simulator(s)`,
+            value: "ios",
+        });
+    }
+    // Select platform
+    let platform;
+    if (platformOptions.length === 1) {
+        platform = platformOptions[0].value;
+        console.log(`\nUsing ${platform} (only available platform)\n`);
+    }
+    else {
+        const selected = await renderSelection("Select Platform", platformOptions);
+        platform = selected.value;
+    }
+    // Select device
+    const deviceList = platform === "ios" ? iosDevices : androidDevices;
+    const deviceType = platform === "ios" ? "Simulator" : "Emulator";
+    let deviceName;
+    if (deviceList.length === 1) {
+        deviceName = deviceList[0].value;
+        console.log(`Using ${deviceName} (only available ${deviceType.toLowerCase()})\n`);
+    }
+    else {
+        const selected = await renderSelection(`Select ${deviceType}`, deviceList);
+        deviceName = selected.value;
+    }
+    // Clear some space after selection
+    console.log();
+    return { platform, deviceName };
+}

package/build/src/commands/help.js

@@ -10,9 +10,19 @@
  */
 export async function handleHelp(args, session, context) {
     const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
-    addOutput({ type: 'system', text: 'droid-cua - AI-powered Android testing CLI' });
+    addOutput({ type: 'system', text: 'droid-cua - AI-powered mobile device testing CLI' });
     addOutput({ type: 'info', text: '' });
-    addOutput({ type: 'info', text: 'Available commands:' });
+    addOutput({ type: 'info', text: 'Usage:' });
+    addOutput({ type: 'info', text: '  droid-cua --avd <device-name> [options]' });
+    addOutput({ type: 'info', text: '' });
+    addOutput({ type: 'info', text: 'Options:' });
+    addOutput({ type: 'info', text: '  --avd <name>           Device name (Android AVD or iOS Simulator)' });
+    addOutput({ type: 'info', text: '  --platform <platform>  Force platform: android or ios' });
+    addOutput({ type: 'info', text: '  --instructions <file>  Run test file in headless mode' });
+    addOutput({ type: 'info', text: '  --record               Record screenshots during execution' });
+    addOutput({ type: 'info', text: '  --debug                Enable debug logging' });
+    addOutput({ type: 'info', text: '' });
+    addOutput({ type: 'info', text: 'Interactive commands:' });
     addOutput({ type: 'info', text: '  /help                    Show this help message' });
     addOutput({ type: 'info', text: '  /exit                    Exit the CLI' });
     addOutput({ type: 'info', text: '' });
@@ -23,11 +33,33 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: '  /view <test-name>        View test contents with line numbers' });
     addOutput({ type: 'info', text: '  /edit <test-name>        Edit a test in your default editor' });
     addOutput({ type: 'info', text: '' });
+    addOutput({ type: 'info', text: 'Integrations:' });
+    addOutput({ type: 'info', text: '  /loadmill <command>      Run Loadmill test flows using natural language' });
+    addOutput({ type: 'info', text: '' });
+    addOutput({ type: 'info', text: 'Platform Support:' });
+    addOutput({ type: 'info', text: '  Android: Uses ADB to communicate with Android emulators' });
+    addOutput({ type: 'info', text: '  iOS:     Uses Appium + XCUITest for iOS Simulator automation' });
+    addOutput({ type: 'info', text: '' });
+    addOutput({ type: 'info', text: 'Platform Detection:' });
+    addOutput({ type: 'info', text: '  - Use --platform flag to force a specific platform' });
+    addOutput({ type: 'info', text: '  - Auto-detects iOS from device names containing "iPhone" or "iPad"' });
+    addOutput({ type: 'info', text: '  - Set DROID_CUA_PLATFORM env var to "ios" or "android"' });
+    addOutput({ type: 'info', text: '  - Defaults to Android if not detected' });
+    addOutput({ type: 'info', text: '' });
+    addOutput({ type: 'info', text: 'iOS Prerequisites:' });
+    addOutput({ type: 'info', text: '  1. Xcode with iOS Simulator installed' });
+    addOutput({ type: 'info', text: '  2. Appium: npm install -g appium' });
+    addOutput({ type: 'info', text: '  3. XCUITest driver: appium driver install xcuitest' });
+    addOutput({ type: 'info', text: '  Note: Appium server is auto-started when iOS platform is detected' });
+    addOutput({ type: 'info', text: '' });
     addOutput({ type: 'info', text: 'Examples:' });
-    addOutput({ type: 'info', text: '  /create login-test       (design a new test)' });
-    addOutput({ type: 'info', text: '  /list                    (see all tests)' });
-    addOutput({ type: 'info', text: '  /view login-test         (view test contents)' });
-    addOutput({ type: 'info', text: '  /run login-test          (execute test)' });
+    addOutput({ type: 'info', text: '  droid-cua --avd Pixel_8_API_35          (Android emulator)' });
+    addOutput({ type: 'info', text: '  droid-cua --avd "iPhone 16"             (iOS Simulator, auto-detected)' });
+    addOutput({ type: 'info', text: '  droid-cua --platform ios --avd MySim    (Force iOS platform)' });
+    addOutput({ type: 'info', text: '  /create login-test                      (design a new test)' });
+    addOutput({ type: 'info', text: '  /list                                   (see all tests)' });
+    addOutput({ type: 'info', text: '  /view login-test                        (view test contents)' });
+    addOutput({ type: 'info', text: '  /run login-test                         (execute test)' });
     addOutput({ type: 'info', text: '' });
     addOutput({ type: 'info', text: 'For more info, see README.md' });
     return true; // Continue loop

package/build/src/commands/index.js

@@ -9,6 +9,7 @@ import { handleList } from './list.js';
 import { handleView } from './view.js';
 import { handleEdit } from './edit.js';
 import { handleStop } from './stop.js';
+import { handleLoadmill } from './loadmill.js';
 /**
  * Map of command names to their handlers
  * Each handler receives (args, session, context)
@@ -22,6 +23,7 @@ const COMMAND_HANDLERS = {
     view: handleView,
     edit: handleEdit,
     stop: handleStop,
+    loadmill: handleLoadmill,
 };
 /**
  * Route a command to its handler

package/build/src/commands/loadmill.js

@@ -0,0 +1,87 @@
+/**
+ * Loadmill command handler
+ */
+import { executeLoadmillCommand, getApiToken } from "../integrations/loadmill/index.js";
+/**
+ * Handle /loadmill command
+ * @param {string} args - Command arguments (natural language command)
+ * @param {Object} session - Current session
+ * @param {Object} context - Additional context
+ * @returns {Promise<boolean>} - true to continue loop
+ */
+export async function handleLoadmill(args, session, context) {
+    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    const command = args.trim();
+    // Show help if no arguments
+    if (!command) {
+        addOutput({ type: 'system', text: 'Loadmill - Run test flows using natural language' });
+        addOutput({ type: 'info', text: '' });
+        addOutput({ type: 'info', text: 'Usage:' });
+        addOutput({ type: 'info', text: '  /loadmill <command>          Execute a Loadmill flow' });
+        addOutput({ type: 'info', text: '' });
+        addOutput({ type: 'info', text: 'Examples:' });
+        addOutput({ type: 'info', text: '  /loadmill search for login flow' });
+        addOutput({ type: 'info', text: '  /loadmill run checkout flow with user=test123' });
+        addOutput({ type: 'info', text: '  /loadmill run payment test with amount=100' });
+        addOutput({ type: 'info', text: '' });
+        addOutput({ type: 'info', text: 'In test scripts (.dcua files):' });
+        addOutput({ type: 'info', text: '  loadmill: run user authentication flow' });
+        addOutput({ type: 'info', text: '' });
+        addOutput({ type: 'info', text: 'Configuration:' });
+        addOutput({ type: 'info', text: '  Set LOADMILL_API_TOKEN in your .env file' });
+        // Check if token is configured
+        if (!getApiToken()) {
+            addOutput({ type: 'warning', text: '' });
+            addOutput({ type: 'warning', text: 'Warning: LOADMILL_API_TOKEN is not set.' });
+        }
+        return true;
+    }
+    // Check for API token
+    if (!getApiToken()) {
+        addOutput({ type: 'error', text: 'LOADMILL_API_TOKEN environment variable is not set.' });
+        addOutput({ type: 'info', text: 'Add it to your .env file:' });
+        addOutput({ type: 'info', text: '  LOADMILL_API_TOKEN=your-token-here' });
+        return true;
+    }
+    // Set agent working status
+    if (context.setAgentWorking) {
+        context.setAgentWorking(true, 'Running Loadmill flow...');
+    }
+    // Execute the command
+    const result = await executeLoadmillCommand(command, {
+        onProgress: ({ message }) => {
+            addOutput({ type: 'info', text: `[Loadmill] ${message}` });
+        }
+    });
+    // Clear agent working status
+    if (context.setAgentWorking) {
+        context.setAgentWorking(false);
+    }
+    // Display results
+    if (result.success) {
+        if (result.action === "search") {
+            addOutput({ type: 'success', text: `Found ${result.result.flows.length} flow(s):` });
+            result.result.flows.forEach((flow, i) => {
+                const name = flow.description || flow.name || "Unknown";
+                const suite = flow.testSuiteDescription ? ` (Suite: ${flow.testSuiteDescription})` : '';
+                addOutput({ type: 'info', text: `  ${i + 1}. ${name}${suite}` });
+                addOutput({ type: 'info', text: `     ID: ${flow.id}` });
+            });
+            if (result.result.selectedFlow) {
+                const selectedName = result.result.selectedFlow.description || result.result.selectedFlow.name || "Unknown";
+                addOutput({ type: 'info', text: '' });
+                addOutput({ type: 'info', text: `Best match: "${selectedName}" (confidence: ${(result.result.confidence * 100).toFixed(0)}%)` });
+            }
+        }
+        else {
+            addOutput({ type: 'success', text: `Flow "${result.flowName}" passed` });
+            if (result.runId) {
+                addOutput({ type: 'info', text: `Run ID: ${result.runId}` });
+            }
+        }
+    }
+    else {
+        addOutput({ type: 'error', text: `Loadmill failed: ${result.error}` });
+    }
+    return true; // Continue loop
+}

package/build/src/core/execution-engine.js

@@ -1,6 +1,6 @@
 import path from "path";
 import { writeFile } from "fs/promises";
-import { getScreenshotAsBase64 } from "../device/connection.js";
+import { getScreenshotAsBase64, getCurrentPlatform } from "../device/connection.js";
 import { handleModelAction } from "../device/actions.js";
 import { sendCUARequest } from "../device/openai.js";
 export class ExecutionEngine {
@@ -93,7 +93,7 @@ export class ExecutionEngine {
                             type: "computer_screenshot",
                             image_url: `data:image/png;base64,${screenshotBase64}`,
                         },
-                        current_url: "android://emulator", // Android emulator doesn't have URLs like a browser
+                        current_url: getCurrentPlatform() === "ios" ? "ios://simulator" : "android://emulator",
                         ...(pendingSafetyChecks.length > 0 ? { acknowledged_safety_checks: pendingSafetyChecks } : {})
                     }];
                 response = await sendCUARequest({