mobile-dev-inc/Maestro

Maestro is a cross-platform UI automation framework that executes test flows on Android, iOS, and Web applications via a command-line interface. It manages device connections, interprets YAML-based test scripts, and captures detailed execution artifacts like screenshots and logs. The system also provides cloud integration for remote test execution and an MCP server to enable LLM-driven automation.

49 changes.

The project underwent a major architectural overhaul, replacing the legacy Conductor client and iOS support with a new Maestro CLI framework and robust Android driver. This period focused on establishing a unified command-line interface with interactive device management, structured error reporting, and foundational support for cloud test execution. Key improvements included migrating to GraalJS, implementing secure file access scopes, and adding comprehensive test coverage for the new orchestration and reporting systems.

37 changes.

This period focused on a comprehensive rewrite of the iOS driver to unify simulator and physical device management, introducing a new HTTP-based architecture and robust error handling. Concurrently, the CLI was enhanced to support parallel session execution with file-locked state management, while the orchestration engine gained advanced workspace planning and geographic simulation features.

38 changes.

This period focused on integrating AI-driven automation through a new Model Context Protocol (MCP) server and test analysis features, while significantly enhancing platform stability. Key improvements included robust handling of iOS permission dialogs and UI hangs, augmented Android WebView hierarchy detection, and the introduction of a real-time Maestro Viewer for debugging.

The CLI now supports rendering test recordings locally via the new \--local\ flag, replacing the previous remote server-based rendering. This change introduces a local rendering pipeline using the JCodec library for video encoding and the Skia graphics library for compositing the device screen with terminal output, providing a faster, offline-capable alternative to the deprecated remote rendering service.

maestro-cli/src/main/java/maestro/cli/graphics · high confidence

A new JReleaser template file (formula.rb.tpl) has been added to generate Homebrew formulae for the Maestro CLI. This enables users to install and update Maestro via Homebrew, with the generated formula automatically handling versioning, checksums, dependencies, and a basic version-check test.

maestro-cli/src/jreleaser · high confidence

The maestro-driver-ios module now includes the standard iOS application structure, adding the AppDelegate, SceneDelegate, ViewController, and associated storyboard files (Main and LaunchScreen). This change also introduces the necessary asset catalogs for app icons and accent colors, along with the Info.plist and Xcode workspace configuration files required to build and run the iOS driver application.

maestro-ios-xctest-runner/maestro-driver-ios, maestro-ios-xctest-runner/maestro-driver-ios.xcodeproj/project.xcworkspace · high confidence

Maestro now augments the Android UI tree with DOM nodes from WebViews using Chrome DevTools Protocol. This change introduces a new client that fetches WebView hierarchies, merges them with the native view hierarchy based on bounds and text/ID matching, and handles edge cases like deep DOM nesting, circular references, and stalled connections by using bounded timeouts and fallback to native-only hierarchies.

maestro-client/src/main/java/maestro/android/chromedevtools · high confidence

The Android driver test harness in maestro-android/src/androidTest has been expanded to support new automation capabilities and improve stability. It now includes a mock location service (using both Fused and LocationManager providers) to allow setting device location during tests, and a ToastAccessibilityListener to detect and expose toast notifications in the view hierarchy. Screenshot capture reliability is improved via a ScreenshotService with retry logic for null results and better error handling. Additionally, the accessibility dump now correctly handles hint text on older Android versions and includes important-for-accessibility and error attributes, while tap interactions use a custom click method to prevent out-of-bounds failures.

maestro-android/src/androidTest · high confidence

The Maestro orchestration layer now includes utilities to analyze application metadata and calculate precise interaction points. A new AppMetadataAnalyzer extracts platform-specific details (iOS, Android, and Web) from app files, enforcing requirements such as iOS simulator targets and Android arm64-v8a architecture support. Additionally, a new utility allows commands to specify click or interaction points relative to a UI element's bounds using either percentages (e.g., "50%, 90%") or absolute offsets, enabling more flexible and robust element targeting in test flows.

maestro-orchestra/src/main/java/maestro/orchestra/util · high confidence

The Maestro CLI now automatically checks for new versions and displays the corresponding changelog entries when an update is available. This behavior can be disabled by setting the MAESTRO\_DISABLE\_UPDATE\_CHECK environment variable to true, which is useful for package-managed installations like Nix. The update check runs asynchronously with a 3-second timeout to avoid blocking the CLI startup.

maestro-cli/src/main/java/maestro/cli/update · high confidence

Maestro now includes native Android components to handle Unicode text input and device locale configuration directly. A new MaestroInputMethodService and UnicodeInputReceiver allow the framework to commit arbitrary Unicode text to active input fields via a broadcast interface, while the LocaleSettingHandler and LocaleSettingReceiver enable setting the device locale (including language, country, and script) through system broadcasts. This provides first-party support for complex input scenarios and environment setup on Android devices.

maestro-android/src/main/java · high confidence

This change introduces the core \CloudInteractor\ class, which enables uploading test flows and app binaries to the Maestro Cloud service. It handles authentication, project selection, workspace zipping, and device configuration (including Android system image paths, device locale, and API levels). The implementation also adds a \PromotionStateManager\ to track CLI usage for promotional messaging and a \WebInteractor\ to support web app uploads by generating manifests. This represents the foundational code for the \maestro cloud\ command.

maestro-cli/src/main/java/maestro/cli/cloud · high confidence

The \maestro-ai\ module introduces new AI-driven features for visual testing, including defect detection, assertion verification, and text extraction from screenshots. This change adds support for both OpenAI (GPT-4o) and Anthropic (Claude) models, allowing users to evaluate UI screenshots against expected behaviors or extract specific text content. A demo application is included to help users test and evaluate these AI capabilities locally using their API keys.

maestro-ai · high confidence

Maestro now supports executing JavaScript via the experimental GraalJS engine, enabling users to make HTTP requests (get, post, put, delete, request) and generate data using DataFaker directly within scripts. The engine provides a shared, reusable context to prevent memory bloat during long flows, isolates environment variables using sub-scopes for nested runFlow commands, and exposes platform information and copied text to the script environment. JavaScript errors are now wrapped in a serializable JsEvaluationException to ensure safe downstream handling.

maestro-client/src/main/java/maestro/js · high confidence

The Maestro CLI now includes a built-in Model Context Protocol (MCP) server, accessible via the \maestro mcp\ command, which allows LLM agents to automate UI testing on Android emulators, iOS simulators, and Chromium browsers. This integration exposes tools for listing devices, inspecting screen hierarchies, taking screenshots, and running test flows (inline YAML, specific files, or directories). It also supports running tests on Maestro Cloud and includes a local Maestro Viewer for real-time debugging and device streaming.

maestro-cli/src/main/java/maestro/cli/mcp · high confidence

A new Maestro Viewer is now available, providing a real-time visual interface for observing Maestro test flows. The CLI now includes a built-in web server that serves a React-based dashboard, displaying command execution status (pending, started, completed, failed, etc.) and streaming device interactions such as taps, swipes, and text input. This viewer is integrated into the MCP tooling via a new \open\_maestro\_viewer\ tool, which launches the local server and provides the access URL to the user or agent.

maestro-cli/mcp-viewer, maestro-cli/src/main/java/maestro/cli/mcp/viewer · high confidence

The MCP server now includes a suite of new tools for interacting with Maestro Cloud and local devices. Users can now run flows on cloud devices via \run\_on\_cloud\ (with optional \device\_model\ and \device\_os\ parameters), check their status with \get\_cloud\_run\_status\, and fetch detailed run artifacts and metadata using \describe\_cloud\_run\. Device discovery is enhanced with \list\_cloud\_devices\ for cloud options and \list\_devices\ for local connected/available devices. Local automation capabilities have been updated: the \run\ tool consolidates previous \run\_flow\ and \run\_flow\_files\ functionality into a single entry point supporting inline YAML, specific files, or directories with tag filtering; \inspect\_screen\ replaces the old \inspect\_view\_hierarchy\ and now returns a compact JSON view hierarchy; and \take\_screenshot\ now downscales images to a maximum of 2000px to ensure compatibility with vision models. Additionally, a new \cheat\_sheet\ tool provides on-demand access to Maestro syntax documentation, and \open\_maestro\_viewer\ allows users to access the live Maestro Viewer interface.

maestro-cli/src/main/java/maestro/cli/mcp/tools · high confidence

Maestro now emits a structured, schema-validated manifest (manifest.json) for every flow run, replacing ad-hoc artifact tracking. The new ArtifactManifest model defines typed ArtifactKind values (such as SCREENSHOT, SCREEN\_RECORDING, DEVICE\_LOG, CRASH\_REPORT, and ANR\_REPORT) and ArtifactFormat enums, allowing the CLI and cloud workers to reliably discover and bundle outputs like per-step screenshots, full-run recordings, and device logs. The change includes the v1 JSON schema, Kotlin data classes, and tests ensuring the model and schema stay in sync.

maestro-orchestra-models · high confidence

A new KeyValueStore implementation has been added to the CLI's database layer to manage session state. This component uses file locking to ensure safe concurrent access, enabling multiple parallel Maestro sessions to run without data corruption. Users benefit from improved stability when executing tests in parallel, as session tracking is now handled with proper synchronization.

maestro-cli/src/main/java/maestro/cli/db · high confidence

The Maestro CLI now collects anonymous usage analytics via PostHog to help improve the product. This system tracks command runs, test execution results, and cloud workspace activity, enriched with environment details like OS, CLI version, and connected device SDKs. To protect user privacy, command-line arguments are sanitized before being sent: sensitive flags (such as API keys and environment variables) are redacted, and positional arguments that look like file paths are dropped entirely. Users can opt out of all analytics at any time by setting the MAESTRO\_CLI\_NO\_ANALYTICS environment variable, and the CLI will no longer print the 'analytics enabled' message if the feature is disabled. User identification is handled securely via PostHog's identify method, linking anonymous usage data to authenticated accounts only when a user logs in.

maestro-cli/src/main/java/maestro/cli/analytics · high confidence

The CLI now includes a suite of new utility classes in the \maestro.cli.util\ package to support core functionality. \EnvUtils\ handles environment detection, including OS architecture (macOS, Linux, Windows), Java version parsing, WSL detection, and CLI version retrieval. \CiUtils\ identifies the CI provider from environment variables. \ChangeLogUtils\ fetches and formats the changelog from GitHub for display. \ErrorReporter\ sends crash reports to the API while scrubbing sensitive environment variables. \FileDownloader\ and \Unpacker\ handle downloading files and unpacking binary dependencies from the classpath. \FileUtils\ provides helpers for detecting web flows and zip files. \IOSEnvUtils\ retrieves installed iOS simulator runtimes and Xcode version. \PrintUtils\ manages colored console output. \ScreenReporter\ sends screen depth analytics. \ScreenshotUtils\ writes AI-generated screenshots. \SocketUtils\ finds free TCP ports. \StudioDownload\ provides the download URL for the Maestro Studio desktop app. \TimeUtils\ formats duration for display. \WorkingDirectory\ manages the base working directory path.

maestro-cli/src/main/java/maestro/cli/util · high confidence

The CLI now supports generating test reports in HTML and JUnit XML formats alongside the existing debug output. The HTML reporter provides a visual summary of test suites, including flow status, duration, and start times, while the detailed HTML mode adds step-level details. The JUnit XML reporter includes configurable IDs and classnames, cloud run URLs and IDs, tags, and custom properties. Additionally, a new HTML reporter specifically for AI-generated test insights displays defect analysis with screenshots and reasoning for each flow. These reports are generated via a new factory pattern that allows selecting the output format (HTML, HTML-DETAILED, JUnit XML, or NOOP) through the CLI.

maestro-cli/src/main/java/maestro/cli/report · high confidence

A new \scripts/install.sh\ script has been added to allow users to install Maestro via a bash script. The script checks for required dependencies (Java, unzip, curl), detects the operating system, downloads the Maestro archive from GitHub releases, extracts it to a configurable directory (defaulting to \\~/.maestro\), and updates shell profiles (\.bash\_profile\, \.bashrc\, \.zshrc\) to add Maestro to the PATH. It also supports installing a specific version by setting the \MAESTRO\_VERSION\ environment variable.

scripts · high confidence

Added shell scripts to the \maestro-ios-xctest-runner\ directory to streamline the build, run, and test workflows for the iOS driver. \build-maestro-ios-runner.sh\ handles building the runner for both iOS Simulator (multi-arch) and physical devices, while \build-maestro-ios-runner-all.sh\ orchestrates builds for both platforms. \run-maestro-ios-runner.sh\ executes the runner against a specified simulator, and \test-maestro-ios-runner.sh\ validates the setup by launching the runner and polling the \/deviceInfo\ endpoint to confirm readiness. A \.gitignore\ file was also added to exclude build artifacts.

maestro-ios-xctest-runner · high confidence

The orchestra module now generates a structured debug artifact bundle for every flow run. This includes a manifest and commands log, plus per-step screenshots and view hierarchies (JSON) for failed or warned steps, and optional full-run screen recordings and device logs (crashes/ANRs) when enabled. Artifact paths are now 1-based, human-readable, and safely confined to the bundle directory, with passing steps no longer capturing unnecessary view hierarchies.

maestro-orchestra/src/main/kotlin · high confidence

Added a new set of utility classes in the device module to handle environment detection and command-line interactions for Android and iOS. AndroidEnvUtils now manages Android SDK paths, validates compatible cmdline-tools based on the Java version, and locates the emulator binary, while CommandLineUtils provides a robust wrapper for executing shell commands with timeout and error handling. Additional utilities include EnvUtils for OS and Java version detection, SimctlList for parsing iOS simulator data, and supporting data models like AvdDevice.

maestro-client/src/main/java/maestro/device/util · high confidence

The e2e directory now contains a complete test harness for validating Maestro itself, including shell scripts to download and install sample apps (APKs and iOS zips), a web fixture server for browser-based flows, and a central \run\_tests\ script that orchestrates execution across Android, iOS, and Web platforms. The suite uses a \workspaces.txt\ manifest to define which apps and flows run on which platforms, supports filtering by specific apps or flows via environment variables, and distinguishes between passing and failing test cases to ensure expected outcomes are correctly asserted.

e2e · high confidence

The iOS xctest runner now exposes a comprehensive set of HTTP handlers for controlling the device and inspecting the UI. These include handlers for launching and terminating apps, inputting and erasing text, pressing keys and buttons, and performing swipes (including a new v2 swipe implementation with improved timeout classification). Device state can be managed via handlers for setting orientation, appearance (dark/light mode), and permissions, while inspection capabilities cover screenshots, screen static detection, running app identification, keyboard visibility, and a robust view hierarchy snapshot that handles landscape orientation offsets, keyboard exclusion, and Safari WebView integration.

maestro-ios-xctest-runner/maestro-driver-iosUITests/Routes/Handlers · high confidence

The CLI now includes a new build system for iOS drivers targeting real devices. This introduces a configurable xcodebuild timeout (defaulting to 120 seconds, adjustable via the MAESTRO\_XCODEBUILD\_WAIT\_TIME environment variable) and adds a visual spinner to provide feedback during the driver build process. The system automatically validates and updates the iOS driver when the CLI version changes or if the driver files are missing.

maestro-cli/src/main/java/maestro/cli/driver · high confidence

The iOS xctest-runner now includes a comprehensive set of Codable request and response models in the \Routes/Models\ directory to support UI automation commands. These changes introduce data structures for interacting with the device hierarchy (\AXElement\, \ViewHierarchyRequest\ with keyboard exclusion), input handling (\InputTextRequest\, \EraseTextRequest\, \PressKeyRequest\, \PressButtonRequest\, \TouchRequest\, \SwipeRequest\), and device state management (\LaunchAppRequest\, \TerminateAppRequest\, \SetOrientationRequest\, \SetPermissionsRequest\, \SetAppearanceRequest\, \DeviceInfoResponse\). This provides the underlying data contracts for the driver's API endpoints.

maestro-ios-xctest-runner/maestro-driver-iosUITests/Routes/Models · high confidence

Added FlowStatus and TestExecutionSummary model classes to support detailed reporting of test execution results. FlowStatus defines the lifecycle states for flows (PENDING, PREPARING, INSTALLING, RUNNING, SUCCESS, ERROR, CANCELED, STOPPED, WARNING) and maps to upload statuses. TestExecutionSummary structures test results with suite and flow-level details including duration, start time, device name, cloud upload/run IDs and URLs, app binary ID, properties, tags, step results, and failure information.

maestro-cli/src/main/java/maestro/cli/model · high confidence

The CLI now includes a new \--analyze\ option for the test command, powered by the new \TestAnalysisManager\ in the insights module. This feature processes debug artifacts (screenshots, logs, commands) from test runs, filters out visually similar screenshots to reduce noise, and sends the data to the cloud for AI-powered analysis. A key behavioral change is that the introductory notification for this feature is automatically suppressed when running in a CI environment, ensuring a cleaner output for automated pipelines while still allowing users to opt-out of notifications locally via an environment variable.

maestro-cli/src/main/java/maestro/cli/insights · high confidence

The \maestro-utils\ module now provides a suite of core utilities: \FileAccessScope\ enforces path resolution within a bounded root to prevent directory traversal, while \HttpClient\ builds OkHttp clients with integrated Micrometer metrics and ensures call timeouts never fall below read timeouts. \MaestroTimer\ adds suspend-aware timeout and retry logic for coroutines, and \TempFileHandler\ manages the lifecycle of temporary files and directories. Additional helpers include \DepthTracker\ for tracking UI hierarchy depth, \Insights\ for reporting CLI status, and utilities for string chunking and socket port allocation.

maestro-utils/src/main/kotlin · high confidence

The web driver now uses a new JavaScript injection (maestro-web.js) to build the accessibility tree, enabling support for cross-domain iframes (via Chrome DevTools protocol injection for cross-origin frames) and Flutter web apps (using flt-semantics-identifier). It also fixes text extraction for select/textarea elements and prevents JSON serialization errors from circular DOM references.

maestro-client/src/main/resources · high confidence

This change introduces several new capabilities to the web module. It adds a CDP client for communicating with Chrome DevTools, enabling better target selection and JS evaluation. It also introduces a web screen recorder that captures video using Jcodec, allowing users to record web interactions. Additionally, it adds support for HTML date inputs by normalizing various date formats before input, and includes a headless Chrome factory with configurable screen sizes and password leak prevention.

maestro-web · high confidence

Maestro now supports running multiple parallel sessions on iOS simulators by introducing a new session management system. The \MaestroSessionManager\ and \SessionStore\ components track active sessions per device using a heartbeat mechanism stored in \\~/.maestro/sessions\. This allows multiple Maestro instances to run concurrently on different iOS simulators without interfering with each other, while ensuring sessions are properly cleaned up when inactive.

maestro-cli/src/main/java/maestro/cli/session · high confidence

The Maestro orchestration engine now supports a Travel command that simulates movement between geographic coordinates. When a travel command is executed, the system calculates the distance and duration based on a specified speed, then iteratively updates the device's location over a series of small steps with delays, creating a realistic transition effect rather than an instantaneous jump.

maestro-orchestra/src/main/java/maestro/orchestra/geo · high confidence

The \ConductorDriverService\ instrumentation test class and the \AndroidManifest.xml\ file have been removed from the \conductor-android\ module. This eliminates the local gRPC server implementation that previously exposed device information, view hierarchy, and tap actions via UiAutomator, along with the associated internet permissions and cleartext traffic configuration.

conductor-android · high confidence

The \conductor\_android.proto\ file has been removed, eliminating the \ConductorDriver\ service and its associated message definitions (such as \deviceInfo\, \viewHierarchy\, and \tap\) from the protocol buffer schema. This change removes the API contract for Android device interaction capabilities defined in this specific proto file.

conductor-proto · high confidence

The \conductor-cli\ module no longer includes the \App.kt\ entry point that provided a command-line interface for executing test scripts on Android or iOS devices, nor does it include the \simplelogger.properties\ file that configured SLF4J logging levels. Users can no longer run this specific CLI tool to execute YAML-based test commands against local devices.

conductor-cli · high confidence

The core implementation files for the Conductor client have been deleted, including the main Conductor class, the Driver interface, and supporting data models such as Bounds, Point, DeviceInfo, TreeNode, and UiElement. This removes the ability to interact with Android and iOS devices through this specific client package.

conductor-client/src/main/java/conductor · high confidence

The \Orchestra\ class, which previously handled the execution of commands such as tapping, back pressing, scrolling, and crawling, has been removed along with its supporting interfaces \CommandReader\ and \Crawler\. This change eliminates the specific command-processing logic and element-finding mechanisms (including regex-based text and ID selectors) that were previously implemented in this module.

conductor-orchestra/src/main/java/conductor/orchestra · high confidence

The YAML command reader and its associated fluent command mapping classes have been removed from the conductor-orchestra module. This deletion eliminates the previous mechanism for interpreting YAML-based test scripts, specifically the logic that mapped YAML fields like \tapOnText\, \tapOnId\, and \action\ to specific Conductor commands such as tap, crawler, back press, and scroll operations.

conductor-orchestra/src/main/java/conductor/orchestra/yaml · high confidence

The \ScrollCommand\, \BackPressCommand\, \TapOnElementCommand\, \CrawlerCommand\, \ConductorCommand\, and \ElementSelector\ classes have been removed from the \conductor-orchestra-models\ package. This deletion eliminates the previous data structures used to define UI interaction commands (such as scrolling, back presses, and tapping) and element selection criteria (text and ID regexes), indicating a shift away from this specific command model in the conductor orchestration system.

conductor-orchestra-models · high confidence

The iOS device integration module has been deleted, removing the ability to interact with iOS simulators and devices. This change eliminates the \IOSDevice\ interface and its \IdbIOSDevice\ implementation, along with supporting data models like \AccessibilityNode\ and \DeviceInfo\, the gRPC log stream handler, and the \idb.proto\ service definition. Users can no longer perform iOS-specific actions such as tapping, installing apps, launching applications, or accessing accessibility trees through this component.

conductor-ios · high confidence

The iOS xctest runner now uses a centralized HTTP server and factory pattern to manage its command endpoints. This change introduces a \Route\ enum and \RouteHandlerFactory\ that map specific API paths (such as swipe, touch, setOrientation, setAppearance, viewHierarchy, and terminateApp) to dedicated handler classes. This structure replaces previous ad-hoc routing, providing a consistent and extensible foundation for handling driver commands via the FlyingFox HTTP library.

maestro-ios-xctest-runner/maestro-driver-iosUITests/Routes · high confidence

A change to existing behaviour in conductor-client/src/main/resources — 3 commits, 2 files.

conductor-client/src/main/resources · medium confidence · unverified

This change introduces new resource files to support the UI and operational aspects of the CLI. It adds \ai\_report.css\ and \html-detailed.css\ to define the visual styling for AI-generated reports and the new detailed HTML report format, including dark mode support via a new \tailwind.config.js\. Additionally, a \logback-test.xml\ file is added to configure logging levels, specifically suppressing DEBUG messages from internal Micrometer utilities during test execution.

maestro-cli/src/main/resources · high confidence

The Android driver now uses a dedicated, bounded thread pool for ADB I/O operations to prevent webview interactions from hanging indefinitely, ensuring that socket timeouts are enforced and resources are released properly. Additionally, the driver can now detect and report native (SIGSEGV) crashes in addition to JVM crashes, providing more comprehensive crash diagnostics for Android applications.

maestro-client/src/main/java/maestro/android · high confidence

The Android driver implementation has been significantly restructured to improve stability and connection management. The previous approach, which relied on a dedicated \InstrumentationThread\ to launch the Conductor service via \am instrument\ and a separate \DadbForwarder\ to tunnel gRPC traffic, has been removed. The new implementation maintains an open shell session with the device, eliminating the need for port forwarding and the associated complexity of managing background threads for connection handling. This change simplifies the driver's lifecycle and reduces potential points of failure related to network port availability and instrumentation process management.

conductor-client/src/main/java/conductor/drivers · high confidence

The CLI command implementations in maestro-cli have been rewritten and expanded. New commands introduced include 'bugreport' for guided issue submission, 'check-syntax' for validating flow files, 'download-samples' for fetching example apps, 'list-cloud-devices' and 'list-devices' for discovering available hardware, and 'mcp' for starting the Model Context Protocol server. The 'chat' command is now a hidden placeholder that directs users to the new MCP integration. Existing commands like 'cloud', 'test', 'record', 'start-device', and 'hierarchy' have been refactored to support new options such as '--device-os', '--app-binary-id', and '--device-locale', while 'studio' and 'query' are now hidden deprecation notices pointing to the desktop app.

maestro-cli/src/main/java/maestro/cli/command · high confidence

The Maestro CLI now uses a centralized \App.kt\ entry point that registers all subcommands (including \test\, \cloud\, \record\, \studio\, \chat\, \mcp\, and others) and enforces consistent global behaviors. Users benefit from standardized \--help\ flags on all commands via the new \ShowHelpMixin\, reliable color/ANSI output control (defaulting to TTY detection but overridable with \--no-color\/\--no-ansi\ via \DisableAnsiMixin\), and a unified error reporting path that suppresses stack traces for known expected errors while ensuring consistent logging initialization. The CLI also initializes analytics and dependency installation (e.g., \applesimutils\) at startup, ensuring these are ready before command execution.

maestro-cli/src/main/java/maestro/cli · high confidence

The Android, iOS, and Web drivers in the maestro-client have been refactored to improve stability and error management. Android driver startup now uses a dedicated timeout exception instead of generic failures, and gRPC channel cleanup is guaranteed to prevent resource leaks. iOS driver operations now wrap transport failures with explicit error messages rather than rethrowing raw exceptions. The Web driver implementation has been hardened to swallow Selenium CDP ServiceConfigurationErrors and LinkageErrors during initialization, preventing crashes when DevTools are unsupported or mismatched, and input handling for native date fields has been improved.

maestro-client/src/main/java/maestro/drivers · high confidence

The project now enforces that flow file paths are resolved through the \FileAccessScope\ abstraction rather than using raw \java.io.File\ or \java.nio.file.Paths\ constructors. This is implemented by adding a new \detekt-guard.yml\ configuration and updating \detekt.yml\ to forbid direct file path instantiation in core modules (such as \YamlFluentCommand\, \Orchestra\, \HttpUtils\, and \GraalJsHttp\), ensuring that path traversal and security issues are caught at lint time.

(repo-wide) · high confidence

The screenshot assertion logic has been corrected so that the reported match percentage now accurately aligns with the configured threshold, resolving a historical bug where the pass/fail decision and the reported metric used different calculations. Additionally, the deprecated Rhino JavaScript engine has been removed; flows now run on GraalJS by default, and any configuration specifying \jsEngine: rhino\ will now fail with a clear error message.

maestro-orchestra/src/main/java/maestro/orchestra · high confidence

The iOS driver now surfaces a specific \IOSDeviceErrors.Unreachable\ error when the underlying XCTest runner connection fails, replacing raw transport exceptions with a clearer, product-facing message. This change ensures that connection issues are handled gracefully, preventing cryptic crashes and providing better diagnostics for users when the device becomes unreachable during operations like tapping or retrieving view hierarchies.

maestro-ios/src · high confidence

The iOS xctest-runner now includes dedicated helper modules to stabilize device interaction. ScreenSizeHelper provides orientation-aware coordinate transformation and screen dimensions, ensuring that touch inputs and UI queries respect landscape, portrait, and upside-down orientations correctly. TextInputHelper addresses character-skipping issues on iOS by splitting text input into a slow first character followed by faster remaining characters, and waits for the keyboard to appear before typing. SystemPermissionHelper automatically handles system permission alerts (such as notifications) by locating and tapping the appropriate buttons in the UI hierarchy. Additionally, AppError.swift centralizes error handling for XCUITest timeouts, classifying them as HTTP 408s to prevent unnecessary retries and improve error reporting clarity.

maestro-ios-xctest-runner/maestro-driver-iosUITests/Routes/Helpers · high confidence

The CLI now uses a new \ResultView\ interface with two implementations—\AnsiResultView\ for colored, formatted terminal output and \PlainTextResultView\ for simple text output—to display test execution status. This change standardizes how command states (running, completed, failed, skipped, warned) and insights are rendered, supporting features like multiline insight formatting, sub-command expansion, and deduplication of repeated output lines in plain text mode.

maestro-cli/src/main/java/maestro/cli/runner/resultview · high confidence

The maestro-client now provides a unified \DeviceConnectionException\ hierarchy (including \DeviceUnreachableException\ and \DeviceDiagnostics\) to surface structured diagnostics when device transports fail, replacing raw \IOException\ handling. This change also introduces foundational model classes such as \Bounds\, \Point\, \DeviceInfo\, and \TreeNode\, alongside a comprehensive \Driver\ interface that defines the core set of device operations (e.g., \launchApp\, \tap\, \swipe\, \setPermissions\) and capabilities available to the orchestration layer.

maestro-client/src/main/java/maestro · high confidence

The device module now uses a sealed \DeviceSpec\ hierarchy (Android, iOS, Web) to define device configurations, replacing the previous loose structure. This change enforces strict validation for model, OS, and locale fields, and introduces platform-specific locale enums (\AndroidLocale\, \IosLocale\, \WebLocale\) with type-safe serialization. The \DeviceService\ implementation has been updated to use these new types, ensuring that device specifications are validated at construction and that locale settings are correctly applied during device startup.

maestro-client/src/main/java/maestro/device · high confidence

The Maestro CLI now utilizes a new ApiClient implementation that significantly improves reliability during cloud uploads by implementing automatic retries for 5xx server errors and socket exceptions, along with extended timeouts to handle large binary transfers. This change also integrates PostHog analytics for tracking trial starts, screen depth insights, and error reports, while introducing new CLI commands and flags such as \--device-os\ for specifying Android system images, \--android-api-level\, and \--ios-version\ to configure device parameters for cloud runs.

maestro-cli/src/main/java/maestro/cli/api · high confidence

A new \maestro\_android.proto\ file defines the gRPC service contract for the Android driver, introducing RPCs for device info, view hierarchy, screenshots, tapping, text input, and location setting. This update adds support for passing launch arguments to Android applications via the \LaunchApp\ command and enables media file injection through the new \addMedia\ stream. It also includes capabilities to check for window updates during settling and to enable/disable mock location providers.

maestro-proto · high confidence

The CLI test runner has been refactored to provide real-time, command-level visibility into test execution. A new \CliConsoleListener\ now logs every command lifecycle event (RUNNING, COMPLETED, FAILED, SKIPPED, WARNED, PENDING) to the console, giving users immediate feedback on individual steps rather than just overall flow status. The runner now supports a continuous mode that watches flow files for changes and restarts execution automatically, triggered either by file modifications or by pressing ENTER. This is powered by new \FileWatcher\ and \CliWatcher\ components that handle OS-level file system events and input interrupts concurrently. The \TestSuiteInteractor\ and \TestRunner\ have been updated to use this new listener-based architecture, ensuring that debug outputs and AI artifacts are captured per-flow with proper directory isolation.

maestro-cli/src/main/java/maestro/cli/runner · high confidence

The Xcode project now includes explicit scheme definitions for the main \maestro-driver-ios\ target and its \maestro-driver-iosTests\ target. The main scheme configures the app to build for testing, running, profiling, archiving, and analyzing, while explicitly skipping \ViewHierarchyHandlerTests\ during test runs. The test scheme sets the \snapshotKeyHonorModalViews\ environment variable to \false\ and configures the test bundle to run without parallelization, ensuring consistent test execution behavior for developers and CI systems.

maestro-ios-xctest-runner/maestro-driver-ios.xcodeproj/xcshareddata · high confidence

The CLI now features a new interactive device selection and creation workflow. When no device is specified or available, users are presented with a numbered list of connected devices to choose from, or options to start a new Maestro-recommended device, list existing devices, or quit. The new \DeviceCreateUtil\ handles the creation of Android emulators and iOS simulators, including logic to resolve the closest matching OS runtime for iOS and to prompt for the installation of missing Android system images. The \PickDeviceInteractor\ manages the launch process, ensuring that newly launched devices are correctly identified and started, while \PickDeviceView\ provides the console UI for these interactions.

maestro-cli/src/main/java/maestro/cli/device · high confidence

The CLI now includes a new \Auth\ class that manages user authentication by launching a local server to handle OAuth callbacks. When a user triggers sign-in, the CLI opens their browser to an authorization URL and waits for a callback at a local port. Upon successful token exchange, a success HTML page is displayed; if the token exchange fails, a failure page is shown with an error message. This replaces previous authentication mechanisms with a unified flow that supports both API key usage and interactive browser-based login.

maestro-cli/src/main/java/maestro/cli/auth · high confidence

The Maestro client now includes a new \MockInteractor\ component that retrieves mock server events from the Maestro Cloud API, requiring a valid authentication token. To support this, a new \ApiKey\ utility has been introduced to centralize token resolution, checking for the \MAESTRO\_CLOUD\_API\_KEY\ environment variable or reading a cached token from \\~/.mobiledev/authtoken\. This change shifts the mock server integration to rely on this unified authentication mechanism rather than previous, potentially disparate, methods.

maestro-client/src/main/java/maestro/mockserver · high confidence

The maestro-client module now includes several new utility objects: FileUtils for zipping, unzipping, and deleting directories; HttpUtils to handle multipart form data uploads with file path resolution; LocaleUtils (now deprecated in favor of DeviceLocale) containing supported language and country lists for Android and iOS; ScreenshotUtils for capturing screenshots and waiting for the app to settle or the screen to become static; StringUtils with a safe regex conversion method; and TemporaryDirectory for managing scoped temporary files. Additionally, the BlockingStreamObserver class has been moved from conductor-ios to maestro-client, and its gRPC stream wait timeout has been changed from 120 seconds to 10 minutes.

maestro-client/src/main/java/maestro/utils · high confidence

The iOS xctest-runner now includes three new extension files to support internal operations: Logger.swift adds a measure helper to time and log code blocks, StringExtensions.swift provides a toUInt16 method for safe string-to-integer conversion, and XCUIElement+Extensions.swift introduces a setText method that simulates pasting text via the system pasteboard and menu. These utilities enhance the test runner's ability to handle performance measurement, data parsing, and complex text input scenarios, particularly for React Native support.

maestro-ios-xctest-runner/maestro-driver-iosUITests/Routes/Extensions · high confidence

The workspace module now includes a new execution planner and validator that support sequential flow execution via the \executionOrder\ configuration, handle negation globs in \config.yaml\, and improve path resolution for media files and dependencies. The planner filters flows based on tags and glob patterns, validates that referenced media files exist, and ensures flows are executed in the specified order when \flowsOrder\ is set. The validator checks for duplicate flow names, missing \launchApp\ commands, and ensures the workspace zip contains a single config file at the root. Path validation now correctly handles Windows separators and prevents path traversal issues during cloud uploads.

maestro-orchestra/src/main/java/maestro/orchestra/workspace · high confidence

The iOS xctest-runner's interaction layer has been rewritten to bypass the older accessibility-based approach in favor of direct XCTest private APIs. This change introduces new internal components: \RunnerDaemonProxy\ for sending strings and synthesizing events, \EventTarget\ and \EventRecord\ for handling touch and swipe actions, and \PointerEventPath\ for defining complex input paths. Additionally, \RunningApp\ now explicitly checks for the \.runningForeground\ state before returning an app, preventing false crash errors during app launch when the UI hierarchy is not yet ready. \AXClientSwizzler\ is also added to override default accessibility parameters. For users, this results in more robust UI automation that is less prone to timing-related failures and false positives during app startup.

maestro-ios-xctest-runner/maestro-driver-iosUITests/Routes/XCTest · high confidence

The CLI view layer has been restructured to improve how test results and errors are displayed. A new TestSuiteStatusView now provides detailed, color-coded feedback for flow execution, including specific statuses like 'Preparing Device', 'Installing App', and 'Stopped', along with cancellation reasons and links to Maestro Cloud results. Error reporting is centralized in ErrorViewUtils, which formats validation and flow errors for terminal display. Additionally, a new ProgressBar class handles visual progress updates with ANSI support, and ViewUtils provides helper functions for colored and boxed text output.

maestro-cli/src/main/java/maestro/cli/view · high confidence

The error reporting system has been refactored to provide structured, detailed feedback for flow validation and parsing issues. New specific exception types (such as FlowPathOutsideWorkspace, InvalidFlowFile, MediaFileNotFound, and SyntaxError) now carry context like file paths and line numbers, replacing generic runtime exceptions. A new ParserErrorRenderer formats these errors into a readable summary and a detailed block that includes a code snippet with line numbers and a caret pointing to the exact error location, ensuring consistent display in both terminal and web interfaces.

maestro-orchestra/src/main/java/maestro/orchestra/error · high confidence

The Maestro client now captures structured debug logs into dedicated, timestamped directories per run, automatically archiving completed runs as ZIP files and retaining only the six most recent archives. This change introduces per-flow log isolation, allowing multiple flows within a single process to write to separate log files without interfering with each other, and ensures that logs are captured even when the host application configures non-additive logging for Maestro loggers. Additionally, verbose HTTP client logs from Ktor are now suppressed by default to reduce noise in the output.

maestro-client/src/main/java/maestro/debuglog · high confidence

The validation layer now provides structured, user-friendly error reporting for app and workspace issues. App validation errors (such as missing sources, unrecognized files, unsupported platforms, or iOS version incompatibilities) are now thrown as specific, typed exceptions with clear messages. Workspace validation errors (including syntax errors, name conflicts, missing launchApp commands, and empty workspaces) are converted into structured exceptions containing both a human-readable message and a machine-parseable error type with optional details, enabling better error handling and debugging for users.

maestro-orchestra/src/main/java/maestro/orchestra/validation · high confidence

The private headers in the iOS UI test runner have been updated to reflect the current Apple XCTest framework, adding declarations for new structures and methods required for modern automation. This includes new gesture recognition additions (RecordingAdditions) for accessing automation names, updated keyboard input solving and layout classes, and expanded event generation capabilities (XCEventGenerator) covering iOS 9 through 10.3 specific interactions. The diff also introduces newer application monitoring and accessibility client protocols, ensuring the driver can correctly interface with the latest system-level UI testing APIs.

maestro-ios-xctest-runner/maestro-driver-iosUITests/PrivateHeaders · high confidence

The YAML parsing layer in maestro-orchestra has been rewritten to use a new set of strongly-typed data classes (e.g., YamlFluentCommand, YamlConfig, YamlElementSelector) and a custom parser (MaestroFlowParser). This change introduces structured syntax errors with line/column details and documentation links, attaches source provenance (file path, line numbers) to every parsed command, and standardizes the inclusion of optional labels and optional execution flags across all commands. Users will see more precise error messages when their flow files contain syntax issues, and commands can now carry custom labels for better readability in CLI output and logs.

maestro-orchestra/src/main/java/maestro/orchestra/yaml · high confidence

The Xcode project configuration for the iOS driver has been updated to include new source files and build phases. This includes the addition of route handlers and request/response models for input text, swiping (including a v2 implementation), app launching, touch events, keyboard interaction, device information, screen diffs, screenshots, and permission management. The project now embeds the MaestroDriverLib framework and incorporates helper classes for accessibility (AXClientProxy, XCAccessibilityElement) and quiescence control, alongside updated test targets and framework dependencies like FlyingFox and XCTest.

maestro-ios-xctest-runner/maestro-driver-ios.xcodeproj · high confidence

The iOS driver has been completely rewritten, introducing a new \IOSDevice\ interface and concrete implementations (\SimctlIOSDevice\ for simulators, \LocalIOSDevice\ for real devices via \devicectl\) to unify device management. This change adds support for setting device appearance (dark/light mode), orientation, and geolocation, as well as improved screen recording with MP4 duration normalization to ensure correct video playback. The XCTest runner communication is now handled by a dedicated \XCTestClient\ and \XCTestDriverClient\ with robust transport-failure handling, and the driver now supports passing launch arguments to apps, clearing the device keychain, and installing/uninstalling apps on both simulators and physical devices.

maestro-ios-driver · high confidence

The iOS UI test runner now includes categories that suppress XCTest UI-interruption preflight hangs and allow disabling application quiescence checks. By swizzling \XCUIApplication\'s \doesNotHandleUIInterruptions\ to always return true and adding a \fb\_shouldWaitForQuiescence\ property to \XCUIApplicationProcess\, the driver prevents tests from hanging on permission dialogs or when waiting for the app to become idle. Additionally, a new \FBSnapshotReqParams\ category allows configuring snapshot parameters, such as \snapshotKeyHonorModalViews\, to ensure elements behind modals remain visible during snapshots.

maestro-ios-xctest-runner/maestro-driver-iosUITests/Categories · high confidence

The XCUITest server communication layer now uses a dedicated error model to distinguish between specific failure modes such as network errors, app crashes, bad requests, and operation timeouts. This change introduces a sealed class hierarchy for server results and errors, allowing the system to handle transport-layer failures (like unreachable runners) more gracefully by failing fast rather than throwing raw exceptions, which improves stability when the keyboard is not present or UI queries time out.

maestro-utils/src/main/kotlin/network · high confidence

The iOS driver library now includes logic to automatically detect and interact with system permission dialogs (such as notifications). A new helper class scans the accessibility hierarchy for permission prompts and taps the appropriate button based on the desired permission state, preventing connection failures caused by unhandled permission requests during automation.

maestro-ios-xctest-runner/MaestroDriverLib · high confidence

Add Wikipedia e2e test flows for Android and iOS; Added CLI end-to-end tests for version and help output; Added MCP server test infrastructure and evaluation suites; Added iOS regression test for UI-interruption preflight hang; Added mock XCTest installer for iOS driver testing; Added test coverage for screenshot matching, command descriptions, and serialization; Added test coverage for screenshot scope isolation, childOf selector error messaging, and JS engine behavior; Added test for AndroidDeviceProvider; Added test infrastructure for driver simulation; Added test workspaces for workspace execution planning and error handling; Added tests for API client upload behavior and device specification handling; Added tests for Android ADB socket handling, device connection logic, and launch arguments; Added tests for Android WebView DevTools client robustness; Added tests for Android crash log parsing; Added tests for Android device creation and system image resolution logic; Added tests for Android media store functionality; Added tests for AppMetadataAnalyzer and ElementCoordinateUtil; Added tests for CLI command argument parsing and web flow detection logic; Added tests for CLI command argument sanitization; Added tests for CLI driver building, changelog formatting, and utility functions; Added tests for CLI report generation and debug output management; Added tests for MCP server tools and configuration; Added tests for SessionStore session management and isolation; Added tests for YAML command parsing, source info, and mode configuration; Added tests for debug log storage and scoped log capture; Added tests for device locale validation and iOS BCP-47 tag generation; Added tests for device service parsing and device spec validation; Added tests for element filtering, point serialization, and visibility calculation; Added tests for file, HTTP, and string utility functions; Added tests for nested runFlow command printing in plain text output; Added tests for structured parser error rendering and app/workspace validation; Added tests for the debug artifact collection and generation system; Added tests for the flow command schema derivation logic; Added tests for workspace orchestration components; Added unit tests for Android, iOS, and Web driver logic; Added unit tests for CloudInteractor; Added unit tests for XCTestDriverClient error handling and retry logic; Added unit tests for maestro-utils utility functions; Added unit tests for swipe error classification logic; Comprehensive Maestro E2E test suite for the demo app; Expanded test coverage for Maestro flow commands and configuration; Expanded test coverage for YamlCommandReader configuration and command parsing; Expanded web e2e test coverage for navigation, state, and interaction behaviors.

The project's Gradle wrapper has been updated from version 7.4.1 to 8.13. This upgrade includes the addition of network timeout and distribution validation settings to improve build reliability and security.

gradle · high confidence

This change introduces the foundational build manifests and dependency catalogs for the project. It adds a Gradle version catalog (\gradle/libs.versions.toml\) defining versions for key libraries including Kotlin 2.2.0, Ktor 2.3.13, Selenium 4.43.0, and gRPC 1.50.2. It also establishes the build structure for the \maestro-ai\ and \maestro-android\ modules, sets the CLI version to 2.10.0, and adds the complete Flutter project scaffolding (including \pubspec.yaml\ and \Podfile\) for the \e2e/demo\_app\.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 39 → 55 (+16.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 55 → 91 (+35.6)
• Architecture 90 → 96 (+6.3)
• Maturity 52 → 66 (+13.6)
• Readiness 18 → 40 (+21.9)
• Security 58 → 66 (+7.9)
• Accessibility 64 (new)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (maestro-orchestra/src/main/java/maestro/orchestra/Orchestra.kt)
• Duplicated block (10 lines × 3) (maestro-client/src/main/java/maestro/Filters.kt)
• Duplicated block (11 lines × 2) (maestro-client/src/main/java/maestro/Maestro.kt)
• Duplicated block (11 lines × 2) (maestro-client/src/main/java/maestro/device/DeviceService.kt)
• Duplicated block (11 lines × 3) (maestro-client/src/main/java/maestro/drivers/AndroidDriver.kt)
• Duplicated block (13 lines × 2) (maestro-client/src/main/java/maestro/device/DeviceService.kt)
• Duplicated block (13 lines × 3) (maestro-client/src/main/java/maestro/drivers/AndroidDriver.kt)
• Duplicated block (17 lines × 2) (maestro-cli/src/main/java/maestro/cli/api/ApiClient.kt)
• Duplicated block (17 lines × 3) (maestro-cli/src/main/java/maestro/cli/api/ApiClient.kt)
• Duplicated block (18 lines × 2) (maestro-cli/src/main/java/maestro/cli/api/ApiClient.kt)
• Duplicated block (18 lines × 2) (maestro-client/src/main/java/maestro/device/DeviceService.kt)
• Duplicated block (19 lines × 2) (maestro-cli/src/main/java/maestro/cli/command/TestCommand.kt)
• Duplicated block (19 lines × 3) (maestro-cli/src/main/java/maestro/cli/api/ApiClient.kt)
• Duplicated block (24 lines × 2) (maestro-orchestra/src/main/java/maestro/orchestra/Orchestra.kt)
• Duplicated block (50 lines × 2) (maestro-orchestra-models/src/main/java/maestro/orchestra/Commands.kt)
• High CVE: [GHSA redacted] (maestro-cli/mcp-viewer/package-lock.json)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 56 more

• (anonymous)::createXPathFromElement (cognitive 30) (maestro-client/src/main/resources/maestro-web.js)
• (anonymous)::traverse (cognitive 27) (maestro-client/src/main/resources/maestro-web.js)
• (anonymous)::traverse (cyclomatic 29) (maestro-client/src/main/resources/maestro-web.js)
• AnalyticsStateManagerKt.getOrgStatus (cognitive 17) (maestro-cli/src/main/java/maestro/cli/analytics/AnalyticsStateManager.kt)
• AndroidDriver.mapHierarchy (cognitive 32) (maestro-client/src/main/java/maestro/drivers/AndroidDriver.kt)
• AndroidDriver.mapHierarchy (cyclomatic 18) (maestro-client/src/main/java/maestro/drivers/AndroidDriver.kt)
• ApiClient.upload (cognitive 30) (maestro-cli/src/main/java/maestro/cli/api/ApiClient.kt)
• ApiClient.upload (cyclomatic 23) (maestro-cli/src/main/java/maestro/cli/api/ApiClient.kt)
• Boundary-crossing change coupling: AndroidDriver.kt ↔ IOSDevice.kt (maestro-client/src/main/java/maestro/drivers/AndroidDriver.kt)
• Boundary-crossing change coupling: DeviceCreateUtil.kt ↔ DeviceService.kt (maestro-cli/src/main/java/maestro/cli/device/DeviceCreateUtil.kt)
• Boundary-crossing change coupling: Driver.kt ↔ IOSDevice.kt (maestro-client/src/main/java/maestro/Driver.kt)
• Boundary-crossing change coupling: Driver.kt ↔ YamlFluentCommand.kt (maestro-client/src/main/java/maestro/Driver.kt)
• Boundary-crossing change coupling: ElementSelector.kt ↔ YamlElementSelector.kt (maestro-orchestra-models/src/main/java/maestro/orchestra/ElementSelector.kt)
• Boundary-crossing change coupling: Filters.kt ↔ ElementSelector.kt (maestro-client/src/main/java/maestro/Filters.kt)
• Boundary-crossing change coupling: Filters.kt ↔ Orchestra.kt (maestro-client/src/main/java/maestro/Filters.kt)
• Boundary-crossing change coupling: Filters.kt ↔ YamlElementSelector.kt (maestro-client/src/main/java/maestro/Filters.kt)
• Boundary-crossing change coupling: IOSDriver.kt ↔ SimctlIOSDevice.kt (maestro-client/src/main/java/maestro/drivers/IOSDriver.kt)
• Boundary-crossing change coupling: Maestro.kt ↔ IOSDevice.kt (maestro-client/src/main/java/maestro/Maestro.kt)
• Boundary-crossing change coupling: SimctlIOSDevice.kt ↔ LocalIOSDevice.kt (maestro-ios-driver/src/main/kotlin/device/SimctlIOSDevice.kt)
• Boundary-crossing change coupling: SimctlIOSDevice.kt ↔ XCTestIOSDevice.kt (maestro-ios-driver/src/main/kotlin/device/SimctlIOSDevice.kt)
• …and 231 more

• 32 commits — 22 feature/other, 10 fixes

• maestro-client/src — 9 commits
• maestro-orchestra/src — 6 commits
• maestro-cli/src — 4 commits
• (root) — 3 commits
• .claude/skills — 2 commits
• .github/workflows — 2 commits
• e2e/demo_app — 2 commits
• e2e/workspaces — 2 commits
• assets/maestro-mcp-demo.gif — 1 commit
• maestro-android/src — 1 commit

• fix: Fix file separators on Windows for Cloud uploads (#3564)
• fix: Fixes CDP target selection for modern Chrome (#3522)
• fix: fix(android): don't fail devtools WebView inspection on React/Vue/Angular circular DOMs (#3521)
• fix: fix(android): don't report an empty input's hint as its text (#3510)
• fix: fix(android): fetch WebView hierarchy as a serialized string to avoid CDP depth cap (#3504)
• fix: fix(android): wait out a late locale flip with a grace poll (#3516)
• fix: fix(ci): stop a demo_app cache miss relocating the Android AVD (#3615)
• fix: fix(cli): retry upload-status polls that get no HTTP response (MA-4180) (#3503)
• fix: fix(e2e): update wikipedia android flows for API 37 sample app (#3630)
• fix: fix(orchestra): close GraalJS engine after validating each flow (#3508)
• change: Add files via upload (#3568)
• change: Better web e2e (#3530)
• change: Fixed typo in the casing in the --help command. (#3566)
• change: Prepare for release v2.10.0 (#3548)
• change: Prepare for release v2.9.0 (#3535)
• change: Propose the version and split the release skill into two checkpoints (#3537)
• change: Reduce confusion over iOS physical device support (#3609)
• change: Text matches should match against 'error' property (#3524)
• change: Unify the release process into a single release skill
• change: Update README.md (#3571)
• …and 12 more

• Containers 0 added · 0 removed · contexts 10 added · 0 removed · edges 17 added · 0 removed

• maestro-ai
• maestro-android
• maestro-cli
• maestro-client
• maestro-ios
• maestro-ios-driver
• maestro-orchestra
• maestro-orchestra-models
• maestro-utils
• maestro-web

• maestro-cli → maestro-ai (coupling)
• maestro-cli → maestro-client (coupling)
• maestro-cli → maestro-orchestra (coupling)
• maestro-cli → maestro-orchestra-models (coupling)
• maestro-cli → maestro-utils (coupling)
• maestro-client → maestro-ios-driver (coupling)
• maestro-client → maestro-utils
• maestro-client → maestro-web
• maestro-ios → maestro-ios-driver (coupling)
• maestro-ios → maestro-utils
• maestro-ios-driver → maestro-ai
• maestro-ios-driver → maestro-utils
• maestro-orchestra → maestro-ai
• maestro-orchestra → maestro-client (coupling)
• maestro-orchestra → maestro-orchestra-models (coupling)
• maestro-orchestra → maestro-utils (coupling)
• maestro-orchestra-models → maestro-client (coupling)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

mobile-dev-inc/Maestro was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.