Skip to content
CAI
Software that uses CAICheck a score

leancodepl/patrol

49.9

Weak · 17 November 2026

44.5k

lines of production code

Dart

with Swift

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add DevTools service extension for native UI tree inspection

A new DevTools service extension has been added to allow users to fetch the native UI tree of the application. This feature exposes a \getNativeUITree\ method that interacts with the platform automator to retrieve view hierarchies for both Android and iOS, returning the data in a JSON-serializable format suitable for inspection within the DevTools interface.

_packages/patrol/lib/src/devtools\_service\extensions · high confidence

Add authentication state management to the example app

The example app now includes an AuthCubit that manages user authentication state using Firebase Auth and Google Sign-In. This component handles sign-in flows, tracks authentication status (loading, authenticated, unauthenticated), and exposes an option to display error states, providing a concrete implementation of state management for the example application.

packages/patrol/example/lib/cubit · high confidence

Add command-line entry point for code generation

A new executable entry point (bin/main.dart) has been added to the patrol\_gen package, allowing users to generate Dart, Android, and Darwin (iOS/macOS) code from a schema file via command-line arguments.

_packages/patrol\gen/bin · high confidence

Add example script for ADB initialization and APK installation

An example Dart script has been added to the ADB package's binary directory, demonstrating how to initialize the ADB client and install an APK from a specified path.

packages/adb/bin · high confidence

Add macOS Fastlane configuration for code signing

Added Appfile and Fastfile to the macOS E2E app directory to enable automated code signing on CI. The configuration defines the app identifier (pl.leancode.patrol.Example) and sets up a 'certificates' lane that uses App Store Connect API keys and Match for development provisioning profiles, specifically targeting the Runner and RunnerUITests targets in Release builds.

_dev/e2e\app/macos/fastlane · high confidence

Add macOS platform automator foundation with NSAlert support

This change introduces the initial macOS implementation of the Patrol automator server, enabling UI automation on macOS alongside the existing iOS support. The new \MacOSAutomator\ class provides native implementations for core actions such as opening apps, opening URLs, and tapping UI elements (including menu items), while other actions like pressing the home button or entering text are currently stubbed to throw 'method not implemented' errors. The diff also includes the \Automator\ protocol and \IOSSelector\ predicate logic required for element matching on both platforms.

packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator · high confidence

Add macOS platform support to the e2e\_app

The e2e\_app now includes a native macOS runner, enabling end-to-end testing on macOS. This adds the necessary macOS project files, including an AppDelegate, main window configuration, and Info.plist with URL scheme support for Patrol. It also introduces a native method channel that exposes an 'showAlert' capability, allowing tests to trigger and interact with native NSAlert dialogs on macOS.

_dev/e2e\_app/macos/Runner, dev/e2e\app/macos/Runner.xcodeproj · high confidence

Add public API barrel file for programmatic access to patrol develop session

A new \patrol\_cli.dart\ barrel file has been added to the \lib\ directory to expose a public API for driving a patrol develop session programmatically. This file re-exports specific types such as \ConfigEntry\, \Device\, \FlutterCommand\, and \BuildMode\, allowing consumers like the patrol MCP server to import these implementation details without directly accessing internal \lib/src/\ paths.

_packages/patrol\cli/lib · high confidence

Add web coverage support and refactor coverage collection

The coverage tool now supports collecting coverage for web tests by capturing Chrome's JavaScript coverage data and mapping it back to Dart sources via source maps, in addition to the existing VM-based collection for mobile platforms. The coverage logic has been refactored into dedicated components: a new \WebCoverageTool\ handles the web-specific flow, while \CoverageTool\ manages VM-based collection. A new \bind\_unused\_port.dart\ utility automatically finds and binds to an unused local port for port forwarding, replacing hardcoded port usage. The \coverage\_common.dart\ module provides shared utilities for resolving package configurations, including support for Pub workspaces via the \--coverage-workspace\ flag, and for formatting/saving LCOV reports. The \DeviceToHostPortTransformer\ handles device-to-host port forwarding for Android, while iOS/macOS uses the device port directly. A new \CoverageMode\ enum distinguishes between \none\, \vm\, and \web\ modes. The \VMConnectionDetails\ class parses VM service URIs from logs, and the \web\_coverage\_tool.dart\ parses Chrome coverage JSON files, resolves Dart sources using the \package:coverage\ library, and merges hit maps.

_packages/patrol\cli/lib/src/coverage · high confidence

Added Objective-C test service client and build-time test manifest support

The Patrol iOS implementation now exposes an Objective-C compatible client (\ObjCPatrolAppServiceClient\) that allows native code to list and run Dart tests via a configurable port (defaulting to 8082 or the \PATROL\_APP\_PORT\ environment variable). Additionally, a new \PatrolTestManifest\ class enables reading a build-time generated test manifest file, flattening the test structure to match the runtime discovery format, which supports faster test enumeration by avoiding runtime introspection when the manifest is available.

packages/patrol/darwin/patrol/Sources/PatrolImpl · high confidence

Added Xcode scheme for macOS e2e app

The macOS end-to-end application now includes a dedicated Xcode scheme (Runner.xcscheme) that configures the build, test, and launch actions for the Runner project. This enables developers to run and debug the macOS e2e app directly within Xcode, supporting both standard execution and UI testing via the RunnerUITests target.

_dev/e2e\app/macos/Runner.xcodeproj/xcshareddata · high confidence

Added Xcode schemes for the e2e\_app Runner and its UI tests

The e2e\_app iOS project now includes explicit Xcode scheme files (Runner.xcscheme and RunnerTests.xcscheme) in the shared data directory. This ensures that the Runner app and its associated UI test bundle (RunnerUITests.xctest) are correctly configured for building, running, and debugging within Xcode, including the necessary pre-actions to prepare the Flutter framework.

_dev/e2e\app/ios/Runner.xcodeproj/xcshareddata · high confidence

Added example app screens for patrol\_finders

The example application for the patrol\_finders package now includes dedicated screens to demonstrate various UI interaction patterns. A new ScrollingScreen allows testing of scrollable content with specific keys, a LoadingScreen demonstrates handling asynchronous state changes, and an OverlayScreen provides a layout with overlapping widgets for testing visibility and stacking contexts.

_packages/patrol\finders/example/lib · high confidence

Added localized strings and privacy manifest for iOS permissions and settings

The Patrol iOS implementation now includes a PrivacyInfo.xcprivacy manifest declaring no collected data types, ensuring compliance with Apple's privacy requirements. Additionally, localized string resources (Localizable.strings) have been added for German, English, French, Japanese, Korean, and Polish, covering UI text for permission dialogs (e.g., Allow, Limit Access), settings navigation (e.g., Dark Appearance, Display & Brightness), location precision toggles, and app management actions (Add, Remove, Delete).

packages/patrol/darwin/patrol/Sources/PatrolImpl/Resources · high confidence

Added macOS platform support for the e2e\_app with Fastlane and Match configuration

The e2e\app now includes a dedicated macOS platform setup. A new Matchfile has been added to configure code signing via a git-based storage mode using an SSH URL for the certificates repository, targeting the 'pl.leancode.patrol.\' app identifier. Additionally, the .gitignore file has been moved to this location and updated to exclude generated Flutter plugin registrant files.

_dev/e2e\app/macos · high confidence

Added macOS platform support to the e2e\_app

The e2e\_app now includes macOS support, evidenced by the addition of a GeneratedPluginRegistrant.swift file that registers Flutter plugins (including patrol, app\_links, file\_picker, and others) for the macOS target. Configuration files (Flutter-Debug.xcconfig and Flutter-Release.xcconfig) have been moved from the example directory to the e2e\_app's macOS Flutter directory to support this new platform.

_dev/e2e\app/macos/Flutter · high confidence

Added macOS project scaffolding to the example app

The example application now includes the necessary macOS project files, enabling it to be built and run on macOS. This change adds the Flutter configuration files for debug and release builds, as well as the Xcode workspace structure required to manage the project and its CocoaPods dependencies.

packages/patrol/example/macos/Flutter, packages/patrol/example/macos/Runner.xcworkspace · high confidence

Added macOS support to the Patrol example app

The example application now includes a complete macOS target, enabling users to build, run, and test the app on macOS. This addition includes the necessary project configuration files (such as AppInfo, Debug, Release, and Warnings xcconfigs), app icon assets, the main menu interface, and entitlements for sandboxing, JIT, and network access. The Swift source files have been migrated into the package structure, with a minor code adjustment in MainFlutterWindow.swift to use the modern FlutterViewController initializer.

packages/patrol/example/macos/Runner · high confidence

Added macOS test backend implementation

Introduced the \MacOSTestBackend\ class in \packages/patrol\_cli/lib/src/macos/macos\_test\_backend.dart\, enabling the CLI to build and execute UI tests on macOS. This implementation handles the build process via \flutter build macos\ and \xcodebuild build-for-testing\, and executes tests using \xcodebuild test-without-building\, passing specific environment variables (\TEST\_RUNNER\_PATROL\_TEST\_PORT\, \TEST\_RUNNER\_PATROL\_APP\_PORT\) to configure the test runner's communication ports.

_packages/patrol\cli/lib/src/macos · high confidence

Added macOS workspace configuration for the e2e\_app

The e2e\_app now includes the necessary Xcode workspace files to support the macOS platform. This change introduces the \contents.xcworkspacedata\ file, which references the project and its Pods, and moves the existing workspace check files from the example directory to the new e2e\_app location, enabling the app to be built and tested on macOS.

_dev/e2e\_app/macos/Runner.xcodeproj/project.xcworkspace, dev/e2e\app/macos/Runner.xcworkspace · high confidence

Added notification and permission handling logic to the example app

The example app now includes dedicated handlers for managing local and push notifications. A new \NotificationHandler\ class initializes Firebase Cloud Messaging and local notification plugins, requests necessary permissions, and displays notifications with specific styling for Android and iOS/macOS. A supporting \PermissionHandler\ class manages the runtime request for notification permissions. These changes enable the example app to demonstrate end-to-end notification flows, including triggering local alerts and sending push notifications via a backend endpoint.

packages/patrol/example/lib/handlers · high confidence

Android native configuration for the e2e example app

The Android native layer for the e2e example app has been established, including the AndroidManifest, MainActivity, and resource files. The manifest declares permissions required for testing features such as location (including mock location), camera, audio, contacts, notifications, and battery optimization, and configures an intent filter for the 'patrol' deep link scheme. The app now uses a Kotlin-based MainActivity extending FlutterActivity and includes metadata for Flutter embedding v2 and Google Maps API keys.

_dev/e2e\app/android · high confidence

Android test backend refactored with build-time codegen and per-test video recording

The Android test backend now supports build-time test discovery and static JUnit code generation, which creates a native test class for each Dart test file to enable per-test selection and cleaner report names. Additionally, the backend now includes per-test video recording capabilities, managing screenrecord sessions via ADB and pulling the resulting video files to the local output directory for inclusion in test summaries.

_packages/patrol\cli/lib/src/android · high confidence

Enable macOS end-to-end UI testing with Patrol and network entitlements

The macOS runner UI tests now support end-to-end execution using the Patrol framework. This change introduces a new test target configuration that includes the necessary network client and server entitlements, allowing the test app to communicate over the network during automated UI runs. The test implementation is set up to integrate with Patrol's macOS runner, ensuring that UI interactions can be verified in a release-like environment.

_dev/e2e\app/macos/RunnerUITests · high confidence

Example app now supports Firebase integration and push notifications

The example application has been updated to include Firebase support, allowing users to test features like Google Sign-In and push notifications. This change introduces a new \firebase\_options.dart\ file for platform-specific Firebase configuration, updates \main.dart\ to initialize Firebase and request location permissions when enabled via the \FIREBASE\_ENABLED\ environment flag, and adds new UI pages (\profile\_page.dart\ and \notification\_success\_page.dart\) to demonstrate authenticated user flows and push notification handling with location tracking.

packages/patrol/example/lib · high confidence

Incorporates HTTP parser and Telegraph networking library for Darwin builds

The Darwin package now includes the C-based http\_parser (version 2.9.4) and the Telegraph Swift networking library. This adds native HTTP request/response parsing and WebSocket client capabilities to the patrol agent, enabling it to handle complex HTTP interactions and real-time WebSocket connections directly on iOS, macOS, and other Apple platforms without external dependencies.

packages/patrol/darwin/patrol/Sources/HTTPParserC, packages/patrol/darwin/patrol/Sources/PatrolImpl/Telegraph · high confidence

Initial Fastlane configuration for the iOS e2e example app

Added Appfile and Fastfile to the dev/e2e\_app/ios/fastlane directory to automate code signing for the patrol example app. The configuration targets the 'pl.leancode.patrol.Example' identifier and defines a 'certificates' lane that sets up CI, configures App Store Connect API keys via environment variables, and uses Match for development certificate management.

_dev/e2e\app/ios/fastlane · high confidence

Initial example app scaffolding for patrol\_finders

The example application for the patrol\_finders package has been initialized with standard Flutter project configuration files. This includes a .gitignore tailored for Flutter/Dart artifacts, a .metadata file tracking the Flutter stable channel version, an analysis\_options.yaml file integrating the leancode\_lint package, and a README explaining the app's purpose as a test-writing demonstration.

_packages/patrol\finders/example · high confidence

Initial release of patrol\_cli package structure and documentation

This change introduces the foundational structure for the patrol\_cli package, including the addition of a .gitignore file to exclude build artifacts and pubspec.lock, a comprehensive CHANGELOG.md documenting the history from version 4.8.0 back to 3.9.0, and a README.md with installation and usage instructions. It also adds a LICENSE file (Apache 2.0), analysis\_options.yaml for linting, and a check\_versions shell script to ensure version consistency across pubspec, embedded constants, and the changelog.

_packages/patrol\cli · high confidence

Initial release of the ADB library

The \packages/adb/lib\ directory now contains the main entry point for the ADB package, exposing core ADB functionality and exception types to consumers.

packages/adb/lib · high confidence

Initial release of the package:adb library

This change introduces the core \package:adb\ library, providing a Dart interface for common Android Debug Bridge operations. Users can now install and uninstall APKs, pull files, remove device paths, and manage port forwarding (including a cancel function for forwarded ports). The library automatically ensures the ADB daemon is running and waits for necessary device services (activity and package) before executing commands. It also includes specific exception handling for scenarios like missing ADB executables, daemon issues, and installation failures.

packages/adb/lib/src · high confidence

Initial repository scaffolding and native automation schema

The repository is initialized with the core structure for the Patrol framework, including a \schema.dart\ file that defines the contract for native automation methods (such as selectors, taps, and native view retrieval) and a \gen\_from\_schema\ script to generate the corresponding Dart, Swift, and Kotlin code. The setup also introduces Melos for monorepo management, standardizes Git attributes and ignore rules for generated files, and provides initial documentation in \CONTRIBUTING.md\ and \README.md\.

(repo-wide) · high confidence

Introduce Patrol Service Extension API for DevTools

The DevTools extension now exposes a new \PatrolServiceExtensionApi\ class that communicates with the Flutter engine via service extensions (e.g., \ext.flutter.patrol.getNativeUITree\). This API provides a typed, error-safe interface (\ApiResult\) for retrieving native UI tree data, supporting both iOS (\IOSNativeView\) and Android (\AndroidNativeView\) platforms. The change includes the necessary data contracts (\contracts.dart\, \native\_views.dart\) and their JSON serialization logic to facilitate this interaction, enabling the DevTools UI to inspect and display native view hierarchies.

_packages/patrol\_devtools\extension/lib/api · high confidence

Introduce Patrol custom finders and tester API

This change introduces the \patrol\_finders\ library, providing a high-level testing API built on top of \flutter\_test\. It adds the \PatrolTester\ class (exposed as \$\) and the \PatrolFinder\ class, enabling concise selector syntax (e.g., \$(\#id).tap()\) and custom actions like \enterText\ and \scrollTo\. The update also includes the \patrolWidgetTest\ wrapper for running tests with Patrol-specific configuration, logging integration via \patrol\_log\, and new exception types (\PatrolStepException\, \PatrolTimeoutException\) to improve error reporting during test execution.

_packages/patrol\finders/lib · high confidence

Introduce build-time test discovery and hot restart support

Patrol now supports build-time test discovery, allowing the test tree to be registered and serialized into a manifest during compilation without executing test bodies, which enables faster test discovery and compatibility with host \flutter test\ runs. Additionally, a new hot restart mode is available (enabled via the \PATROL\_HOT\_RESTART\ environment variable), which allows developers to interact with the running app using a finger during tests and supports the \patrol test --hot-restart\ command. This change also introduces \patrolSetUp\ and \patrolTearDown\ callbacks that respect these modes, ensuring proper synchronization with the native side only when required.

packages/patrol/lib/src · high confidence

Introduce dedicated WebTestBackend for web test execution

A new \WebTestBackend\ class has been added to handle the lifecycle of web-based testing, including building the Flutter web app, starting the web server (either for testing or development), waiting for it to become ready, executing Playwright tests, and gracefully shutting down the server process. This backend supports configurable server timeouts and allows passing additional Flutter command arguments, providing a structured way to manage web test environments within the CLI.

_packages/patrol\cli/lib/src/web · high confidence

Introduce macOS native UI automation support

Added a new macOS platform automator that enables interaction with native macOS UI elements such as alerts, dialogs, and menu bar items, which are invisible to Flutter. This change introduces the \MacOSAutomator\ interface and its configuration (\MacOSAutomatorConfig\), allowing tests to tap native views, wait for visibility, handle system alerts, and interact with application menus via an HTTP-based communication with a native automation server.

packages/patrol/lib/src/platform/macos · high confidence

Introduce multi-tab browser support and web automator API

The web platform implementation now supports interacting with multiple browser tabs. The \WebAutomator\ interface and its native implementation expose methods to manage page lifecycles: \openNewPage\, \closePage\, \switchToPage\, \switchToInitialPage\, \getPages\, \getCurrentPage\, and \getCurrentPageUrl\. A new \waitForPopup\ method allows tests to wait for and interact with newly opened pages. Additionally, the \WebSelector\ class is introduced to define element selection criteria (e.g., by role, label, text, or CSS/XPath), and file upload capabilities are added via \uploadFile\ and the \UploadFileData\ model.

packages/patrol/lib/src/platform/web · high confidence

Introduce native UI inspector in DevTools

The Patrol DevTools extension now includes a native UI inspector, allowing users to view and interact with the native view hierarchy of connected Android and iOS applications. This new feature adds a dedicated panel within the DevTools interface that fetches and displays native root widgets and nodes, enabling developers to inspect the underlying native structure alongside Flutter widgets.

_packages/patrol\_devtools\extension/lib · high confidence

Introduce patrol\_mcp binary for AI-driven test automation

The \packages/patrol\_mcp/bin/patrol\_mcp.dart\ entry point is added, exposing a Model Context Protocol (MCP) server that allows AI agents to manage Patrol test sessions. The server provides tools to run tests (with configurable timeouts and device selection), capture screenshots, inspect the native UI tree, and check session status. It resolves the Flutter project root via the \PROJECT\_ROOT\ environment variable (canonicalized to an absolute path) and runs the \patrol develop\ command within that context, supporting additional flags via \PATROL\_FLAGS\.

_packages/patrol\mcp/bin · high confidence

Introduce patrol\_mcp server with device management, session control, and screenshot capabilities

The \packages/patrol\_mcp/lib\ directory now contains the core implementation of the Patrol MCP server, enabling external tools to interact with Flutter apps via the Model Context Protocol. This includes \device\_lister.dart\ and \device\_selection.dart\ to discover and rank attached Android/iOS devices, \flutter\_command\_resolver.dart\ to auto-detect FVM pins or respect environment variables for the Flutter SDK, and \patrol\_session.dart\ to manage the \patrol develop\ lifecycle with concurrency-safe teardown and log streaming. Additionally, \screenshot\_service.dart\ captures device screenshots (using temp files for iOS to avoid stdout issues and validating PNG headers), while \native\_tree\_service.dart\ fetches and trims the native UI tree for automation.

_packages/patrol\mcp/lib · high confidence

Introduces Playwright-based web test runner with extensive environment configuration

The web runner location now includes a full Playwright test infrastructure, featuring a main configuration file that exposes numerous environment variables (such as PATROL\_WEB\_RETRIES, PATROL\_WEB\_TIMEOUT, PATROL\_WEB\_CHANNEL, and PATROL\_WEB\_GEOLOCATION) to control browser behavior, reporting, and test execution. It also adds separate configuration files for unit and integration tests, along with standard tooling setup (TypeScript, ESLint, Prettier) and Node version specification.

_packages/patrol/web\runner · high confidence

Introduces build-time test discovery and static native test code generation

The CLI now supports an experimental, opt-in feature that discovers Dart tests at build time by running a host \flutter test\ in discovery mode and serializing the test tree to a manifest. This manifest is consumed by platform-specific code generators to produce static native test classes (one per Dart file) for both iOS (XCTest) and Android (JUnit), ensuring that generated native test names are byte-identical to runtime discovery. This change enables individually selectable native tests and allows test reports to reflect a real hierarchy (class = file, method = test), while also preventing runtime-discovery launchers from executing during the static build phase.

_packages/patrol\cli/lib/src/crossplatform · high confidence

Introduction of opt-in, event-based analytics with CI and environment overrides

The CLI now collects usage analytics via Google Analytics, but only when explicitly enabled by the user. This new analytics module respects the \PATROL\_ANALYTICS\_ENABLED\ environment variable to control behavior, automatically disables tracking when running in a CI environment, and ensures that internal Flutter commands invoked by the CLI do not trigger nested analytics or version checks. Users can opt out of data collection, and the system gracefully handles network failures without crashing.

_packages/patrol\cli/lib/src/analytics · high confidence

Launch of Patrol documentation site

The Patrol documentation site is now live, providing a searchable, deep-linkable reference for users. The new site features a dynamic table of contents that can be extended via frontmatter, accurate anchor scrolling that accounts for the sticky navigation bar, and a dedicated search API. It also includes social sharing images (Open Graph), a full-text export endpoint for LLMs, and a persistent webinar banner to promote upcoming events.

_docs\app/app · high confidence

New Cursor AI coding rules for Android Kotlin and GitHub Workflows

Added two new rule files to guide AI-assisted coding: \.cursor/rules/android-kotlin.mdc\ enforces centralizing automation constants in \AutomatorConstants.kt\ with KDoc and specific naming conventions, and \.cursor/rules/github-workflows.mdc\ mandates updating \.github/WORKFLOWS.md\ whenever workflow files in \.github/workflows/\ are modified, while also specifying exclusion patterns for physical device tests.

.cursor · high confidence

New Dart code generator for client and server implementations

The \patrol\_gen\ tool now includes a Dart generator that produces Dart code from the schema. This adds support for generating strongly-typed HTTP client classes (using the \http\ package) and Shelf-based server stubs, alongside generated contract models that utilize \equatable\ for value equality and \json\_annotation\ for serialization. Users can now automatically generate Dart bindings for both consuming and serving Patrol services.

_packages/patrol\gen/lib/src/generators/dart · high confidence

New Darwin code generators for Swift clients and servers

Added a new set of Dart generators in the darwin package that produce Swift code for iOS/macOS targets. The DarwinGenerator orchestrates the creation of shared contract structs/enums, a Telegraph-based server implementation (including protocol definitions, route setup, and JSON handling), and an URLSession-based client implementation (including request execution and JSON decoding). This enables users to generate native Swift networking code from their service schemas.

_packages/patrol\gen/lib/src/generators/darwin · high confidence

New e2e\_app example for testing Patrol capabilities

The dev/e2e\_app directory now contains a complete Flutter application designed to exercise Patrol's end-to-end testing features. This example includes screens for deep links, dynamic content (at() finder), camera and gallery interactions, file picking, location services, login flows, and permission handling. It also introduces macOS support with native alert integration, configures Marathon for device orchestration, sets up an MCP server for tooling, and provides environment variable definition files to test build-time configuration.

_dev/e2e\app · high confidence

New home page for the Patrol example app

The example application now features a new home page that serves as the entry point for testing various capabilities. This page provides buttons to sign in with Google, navigate to a quiz flow, and trigger push notifications, allowing users to exercise authentication, navigation, and notification handling within the example environment.

packages/patrol/example/lib/pages · high confidence

New quiz flow screens added to the example app

The example app now includes a complete quiz experience with new screens: a welcome page, a form page for nickname and color selection, a question page with interactive tasks, and success/error pages. This adds a new interactive demo path for users to explore the example app's UI components and navigation patterns.

packages/patrol/example/lib/pages/quiz · high confidence

Patrol 4.10.0 introduces macOS automation, BrowserStack Dart coverage, and agent skills

This release adds macOS platform automation via \$.platform.macos\ (supporting \tap\, \waitUntilVisible\, \isAlertVisible\, \tapAlertButton\, and \tapMenu\) and bundles Patrol agent skills for AI coding agents (installable via \dart run skills@ get\). It also introduces BrowserStack-friendly Dart coverage collection, which merges Dart line coverage with JaCoCo reports and fixes coverage loss when sessions are killed mid-dump. Additionally, the package now includes a \.gitignore\ file to exclude standard Dart build artifacts and private files.

packages/patrol · high confidence

Unified platform detection and cross-platform selector support

The platform layer now provides a unified way to detect the current execution environment and select UI elements across Android, iOS, macOS, and Web. A new \patrolTargetPlatform\ getter ensures tests are registered for the correct device during build-time discovery, resolving previous mismatches between host and target platforms. Additionally, the \Selector\ API now supports cross-platform element finding, allowing users to define selectors that automatically map to the appropriate Android, iOS, or Web implementation, while \PlatformSelector\ and \MobileSelector\ offer granular control for platform-specific needs.

packages/patrol/lib/src/platform · high confidence

iOS automation server now supports extensible routes via a plugin system

The iOS automation server has been refactored to allow optional extensions to register their own HTTP POST routes. Instead of the server searching the runtime for capabilities, extensions now explicitly register themselves using a \PatrolRouteRegistrar\. This change enables features like \patrol\_axe\ to add custom endpoints without modifying the core server code, and ensures these extension routes are always available rather than being hidden behind the \PATROL\_ENABLED\ build flag.

packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer · high confidence

iOS e2e app project now includes dedicated unit test target with Patrol integration

The Xcode project for the iOS end-to-end app now explicitly defines a \RunnerTests\ target alongside the existing \RunnerUITests\. This new unit test target is configured to link against the \patrol\ framework and includes a specific xcconfig file (\RunnerTests.xcconfig\), enabling unit-level testing capabilities for the e2e app infrastructure. The project structure also reflects the addition of Swift Package Manager support via the \FlutterGeneratedPluginSwiftPackage\ framework reference.

_dev/e2e\app/ios/Runner.xcodeproj · high confidence

iOS test backend now supports video recording and static test code generation

The iOS test backend now includes built-in video recording for simulator tests (captured via \xcrun simctl\ and reported in the CLI summary) and a new static test code generation path that creates native Objective-C XCTest classes from a build-time manifest, enabling Xcode test navigator integration and sharding.

_packages/patrol\cli/lib/src/ios · high confidence

macOS example app now supports UI testing with CocoaPods integration

The macOS example app project has been updated to include a dedicated RunnerUITests target, enabling end-to-end UI testing on macOS. This change integrates CocoaPods by adding the Pods group and framework references, updates the Xcode project version to 54, and configures the build scheme to automatically run these UI tests alongside the main application build.

packages/patrol/example/macos/Runner.xcodeproj · high confidence

patrol\_log package initial release and structure

The \patrol\_log\ package is introduced as a standalone library for logging within the Patrol Flutter testing framework. This change establishes the package's core structure, including the main barrel export (\patrol\_log.dart\), a separate export for the log reader (\patrol\_log\_reader.dart\) to isolate I/O dependencies, and the Apache 2.0 license. The changelog documents the initial versions (0.0.1 through 0.10.1), highlighting key features such as test name handling, duration formatting, and fixes for log entry parsing and crash prevention.

_packages/patrol\log · high confidence

Removals

Removal of legacy Android app scaffolding and build artifacts

The AutomatorServer app module has been stripped of its default Android application structure, including the AndroidManifest, UI themes, launcher icons, ProGuard rules, and the Gradle wrapper scripts. Additionally, the instrumentation test suite and its supporting classes (ServerInstrumentation, UIAutomatorInstrumentation) have been removed, indicating the project is no longer packaged or tested as a standalone Android application.

AutomatorServer/app · high confidence

Removal of legacy Maestro library and CLI entry point

The \maestro/lib\ directory and the \maestro/bin/maestro.dart\ CLI entry point have been deleted. This removes the local implementation of the command-line interface, the ADB helper for installing and forwarding ports for the instrumentation server, the Flutter driver runner, the Automator HTTP client, and the version constant. These components are no longer part of this package location, indicating the package has been split or moved to a \packages/\ directory.

maestro/lib · high confidence

Removal of the Flutter example application

The Flutter example application and all its platform-specific runner code (Android, iOS, Linux, macOS, Web, and Windows) have been removed from the repository. This includes the main Dart entry point, integration tests, and native platform configurations, effectively deleting the demo app that previously showcased the library's functionality.

example, example/android · high confidence

Behavioural changes

1 commit (0 fixes) modifying .agents

A change to existing behaviour in .agents — 1 commit, 4 files: “docs(skills): fix pr-status retries and patrol's unreleased scan”. Also in this area: 2 commits (0 fixes) modifying .agents.

.agents/skills/prepare-release · medium confidence · unverified

4 commits (2 fixes) modifying packages/patrol/android

A change to existing behaviour in packages/patrol/android — 4 commits (2 fixs), 2 files: “fix(patrol): keep AndroidJUnit4 for build-time discovery and note integration\_test in release mode”; “Merge \patrol\_next\ into \patrol\ (\#671)”; “Manage gradle files”; and 1 more (refs \#671).

packages/patrol/android · medium confidence · unverified

6 commits (0 fixes) modifying packages/patrol/android/gradle

A change to existing behaviour in packages/patrol/android/gradle — 6 commits, 1 file: “Add android contracts generation”; “Remove gradlewrapper”; “Manage gradle files”; and 3 more.

packages/patrol/android/gradle · medium confidence · unverified

Added iOS code-signing configuration and build artifacts ignore rules

The iOS development environment for the e2e app now includes a Matchfile that configures code-signing certificate management via a Git repository ([e-mail redacted]:leancodepl/certificates.git) using wildcard app identifiers (pl.leancode.patrol.\*). Additionally, a .gitignore file was added to exclude Xcode build artifacts, derived data, Pods, and Flutter ephemeral files from version control, ensuring a cleaner repository state.

_dev/e2e\app/ios · high confidence

Android automation engine restructured with cloud-testing workarounds and native UI tree support

The Android automation layer has been reorganized into a new set of core components, introducing a dedicated \Automator\ class that manages UI interactions, timeouts, and native screenshot capture (including scoped-storage handling for API 29+). A new \PatrolServerExtension\ interface with \ServiceLoader\ discovery enables optional packages (like \patrol\_axe\) to mount custom HTTP routes on the automation server without modifying core code. To support cloud testing environments like BrowserStack and LambdaTest, new \BrowserstackPatrolJUnitRunner\ and \LambdaTestPatrolJUnitRunner\ classes implement a loopback-address workaround when the default localhost connection fails. The runner also now supports build-time test discovery via \PatrolGeneratedTests\, allowing generated test classes to stand in for the host runner. Additionally, \UITreeUtils\ provides a new method to extract the native Android view hierarchy via \AccessibilityNodeInfo\, and \Localization.kt\ adds support for retrieving UI strings in English, German, French, Polish, Japanese, and Korean based on the device's system language.

packages/patrol/android/src/main/kotlin/pl/leancode/patrol · high confidence

Android automator refactored into modular interface and native implementation

The Android automation logic has been restructured to separate the public API from the native HTTP client implementation. A new \AndroidAutomator\ abstract interface defines the contract for actions like opening apps, pressing buttons, and interacting with notifications, while \AndroidAutomatorNative\ provides the actual HTTP-based communication with the device. An empty stub implementation is now provided for unsupported platforms to prevent runtime errors. Additionally, the \AndroidAutomatorConfig\ now exposes a \dontSuppressAccessibilityServices\ setting (defaulting to true) to allow third-party accessibility services to remain active during tests, addressing compatibility issues with tools like screen readers.

packages/patrol/lib/src/platform/android · high confidence

Android code generation now produces Ktor clients, HTTP4k servers, and shared contracts

The \patrol\_gen\ tool for Android now generates a complete set of Kotlin artifacts from the schema: a shared \Contracts.kt\ file containing data classes and enums, Ktor-based client implementations for each service, and HTTP4k-based server interfaces with routing logic. This replaces previous Android generation approaches, introducing a standardized client-server communication layer using Gson for serialization and Ktor's CIO engine for the client side.

_packages/patrol\gen/lib/src/generators/android · high confidence

Android server implementation migrated to HTTP4k with Ktor client

The Android automation server has been rewritten to use the HTTP4k framework for handling incoming requests, replacing the previous HTTP server implementation. This change introduces a new \AutomatorServer\ class that routes commands via HTTP4k and updates the \PatrolAppServiceClient\ to use Ktor with Gson serialization for outbound communication, ensuring consistent contract handling across the platform. Also in this area: 2 commits (1 fix) modifying (repo-wide), packages/patrol/android; New Android automator server interfaces for device control and interaction.

packages/patrol/android/src/main/kotlin/pl/leancode/patrol/contracts · low confidence · unverified

The \.claude/skills\ path is now a symbolic link pointing to \../.agents/skills\, establishing the location where the agent retrieves its skill definitions.

.claude · high confidence

Deep-linkable setup steps with correct scroll offsets

Setup steps and sections in the documentation are now deep-linkable via URL fragments. When a user navigates to a specific step or section (e.g., \#ios-setup), the page automatically scrolls to that target, ensuring it appears below the sticky header and promo banner rather than being hidden behind them. This is achieved by replacing native browser scrolling with custom logic that respects CSS-defined margins, and by controlling the accordion state to open the relevant section before scrolling. A copy-link button is also added to each step for easy sharing.

_docs\app/components · high confidence

Deprecation of NativeAutomator and NativeAutomator2 in favor of PlatformAutomator

The \NativeAutomator\ and \NativeAutomator2\ classes in the native automation layer are now deprecated and will be removed in a future release. Users should migrate to \PlatformAutomator\ for interacting with the OS. The \NativeAutomatorConfig\ is also deprecated, retained only for backward compatibility with \patrolTest\, and explicitly throws errors if legacy \host\ or \port\ parameters are provided. The \NativeView\ class now provides a unified representation of native UI elements across Android and iOS, mapping platform-specific properties (like Android's \className\ and iOS's \elementType\) to common fields.

packages/patrol/lib/src/native · high confidence

DevTools extension restructured and updated for v0.4.1

The patrol\_devtools\_extension package has been reorganized into a dedicated package location, including a new local development script to build and copy the extension to the main Patrol package. The extension now requires Dart 3.8.0 and Flutter 3.32.0, with dependencies updated to include leancode\_lint 17.0.0, custom\_lint 0.7.0, and vm\_service 15.0.0. API contracts have been regenerated to support new Android accessibility flags and native screenshot requests, and the details view panel is now scrollable when content overflows.

_packages/patrol\_devtools\extension · high confidence

Enable macOS UI testing with network entitlements and plugin integration

The macOS example app's UI test target now includes the necessary network client and server entitlements, allowing tests to communicate with the application. Additionally, the test implementation has been updated to import the Patrol plugin and utilize the new \PATROL\_INTEGRATION\_TEST\_MACOS\_RUNNER\ macro, ensuring the tests are properly initialized and integrated with the framework.

packages/patrol/example/macos/RunnerUITests · high confidence

Enforced version compatibility checks between patrol\_cli and patrol

The CLI now validates that the installed \patrol\_cli\ version is compatible with the \patrol\ package version in your project before running tests or builds. If a mismatch is detected, the process fails with a clear error message and provides specific resolution steps, such as downgrading \patrol\_cli\ to a compatible version or upgrading both packages. This check also includes a compatibility table generator to keep documentation in sync with the supported version ranges.

_packages/patrol\_cli/lib/src/compatibility\checker · high confidence

Example app Android project migrated to Gradle 8.12 and Flutter V2 embedding

The Android configuration for the patrol\_finders example app has been updated to use Gradle 8.12 and migrated to the Flutter V2 embedding. This includes adding the INTERNET permission, updating the MainActivity to extend FlutterActivity, and applying standard V2 theme and launch background resources. These changes ensure the example app builds correctly with modern Gradle and Flutter tooling.

_packages/patrol\finders/example/android · high confidence

Example app minimum iOS version increased to 14.0

The example application's minimum supported iOS version has been raised from 9.0 to 14.0, as reflected in the AppFrameworkInfo.plist configuration. This change ensures the app requires a more modern iOS environment to run.

_dev/e2e\app/ios/Flutter · high confidence

Example app regenerated as 'patrol\_challenge' with updated tooling configuration

The example application has been regenerated and renamed to 'patrol\_challenge', serving as a quiz app for Fluttercon that utilizes flavors and Google Sign-In. The project now includes a macOS target and is configured with the 'leancode\_lint' package and 'custom\_lint' plugin for static analysis. Additionally, a .gitignore file has been added to exclude build artifacts and Patrol-specific test bundles, while the .metadata file tracks the Flutter stable channel version for migration purposes.

packages/patrol/example · high confidence

Gradle wrapper upgraded to version 8.14.3

The Gradle wrapper for the e2e\_app Android project has been updated from version 6.7 to 8.14.3. This change ensures the build environment uses a modern Gradle distribution, which is necessary to support newer Android Gradle Plugin versions and Kotlin metadata parsing.

_dev/e2e\app/android/gradle, packages/patrol/example/android/gradle · high confidence

Introduce Patrol CLI entry point with hot restart support

The Patrol CLI now exposes a main entry point that initializes the command runner, enabling the new \patrol test --hot-restart\ flag for faster test iteration. This change also includes a refactored command runner structure to support these capabilities.

_packages/patrol\cli/bin · medium confidence

Introduce base utilities and update version to 4.8.0

The Patrol CLI now includes a new set of base utilities in the \lib/src/base\ directory to improve logging, process handling, and user interaction. A new \Logger\ class wraps \mason\_logger\ to provide non-animated progress tasks and consistent warning output. Process output is now decoded using \Utf8Decoder\ with \allowMalformed: true\, ensuring that malformed UTF-8 sequences in stdout/stderr do not crash the CLI. An \InteractivePrompts\ utility has been added to support menu-based selections in terminal environments. Additionally, the CLI version constant has been updated to 4.8.0.

_packages/patrol\cli/lib/src/base · high confidence

Introduce interactive device selection and Dart-side group support

When running tests with multiple devices attached, the CLI now prompts the user to select a specific device in interactive terminals (skipping device discovery for Chrome). Additionally, the test runner now supports Dart-side \group()\ definitions, allowing tests to be organized into hierarchical groups that are discovered and executed by the native runner.

_packages/patrol\cli/lib/src · high confidence

Introduce new code generation engine for Dart, Android, and iOS/macOS

The \patrol\_gen\ package now uses a completely rewritten generation engine. This new system parses Dart source files to automatically build a schema of enums, messages, and services, supporting complex types like lists and maps. It generates platform-specific code for Dart, Android, and Darwin (iOS/macOS) targets, allowing users to define their API contracts in Dart and have the corresponding client/server stubs generated automatically.

_packages/patrol\gen/lib/src · high confidence

Introduces structured logging with ANSI formatting and duration extensions

The patrol\_log package now includes dedicated source files for enhanced log presentation and structure: \ansi\_codes.dart\ provides a centralized class for ANSI color codes (bold, reset, and various colors) to style console output; \duration\_extension.dart\ adds a \toFormattedString()\ extension on \Duration\ for human-readable time reporting (e.g., '1h 2m 3s'); \emojis.dart\ defines static emoji constants (like ⏳, 🧪, ✅, ❌) used in log entries; \patrol\_log\_reader.dart\ and \patrol\_log\_writer.dart\ implement the core stream-based reading and writing of structured \Entry\ objects (including Test, Step, Log, Error, Warning, and Config entries) via JSON serialization; and \patrol\_single\_test\_entry.dart\ groups related entries into a single test context, tracking opening/closing test entries, status, execution time, and name with path. This refactors the internal logging mechanism to support richer, styled, and structured test output.

_packages/patrol\log/lib/src · high confidence

Migrate docs site to Next.js with Fumadocs and deep-linkable setup steps

The documentation site has been rebuilt as a Next.js application using the Fumadocs framework, replacing the previous static site generator. This migration introduces deep-linkable setup steps via custom MDX components (SetupAccordion, Step) and a declarative page-tree system that supports custom navigation metadata (previous/next, hide flags) and extra table-of-contents entries. The new site includes embedded social media components for YouTube and X (Twitter) with theme-aware rendering, a GitHub repository info component that fetches star counts with a 12-hour cache revalidation, and a structured navigation layout with tabs for Overview, Documentation, CLI commands, Feature Guide, Articles, Pricing, and Contact. URL redirects are configured to maintain compatibility with legacy paths, and the build environment is standardized with Node 24, Tailwind CSS, and LeanCode ESLint/Prettier configurations.

_docs\app · high confidence

Native Inspector UI overhaul with platform-specific details and improved interaction

The Native Inspector extension has been redesigned to provide a more detailed and interactive inspection experience. The view hierarchy now supports 2D scrolling (horizontal and vertical) and includes a button to fetch the native view hierarchy when it is not initially present. Selecting a node displays platform-specific properties in the details pane: Android nodes show properties like checkable, scrollable, and bounds; iOS nodes expose element type, identifier, and value. The UI also features row highlighting on hover, rounded corners, and a snackbar notification when copying property values to the clipboard.

_packages/patrol\_devtools\_extension/lib/native\inspector · high confidence

Native integration test runner refactored to pure Objective-C with dynamic test generation

The native iOS and macOS integration test runners have been rewritten in Objective-C to support dynamic test generation, allowing each Dart test to be executed and reported as a native XCTest result. This change introduces a new \PatrolPlugin\ (Objective-C) to expose runtime ports to Dart, replaces runtime discovery with a \PatrolExtensionRegistry\ for explicit extension registration, and provides macro-based runner templates (\PATROL\_INTEGRATION\_TEST\_IOS\_RUNNER\ and \PATROL\_INTEGRATION\_TEST\_MACOS\_RUNNER\) that developers include in their UI test targets. The module structure is now pure Objective-C to ensure compatibility with Swift Package Manager and Flutter's generated registrants, with Swift implementation details linked separately.

packages/patrol/darwin/patrol/Sources/patrol · high confidence

New CI validation tools for changelog and agent skills

Added two new shell scripts to the tool directory to enforce repository standards. check\_changelog.sh ensures that any pull request modifying source code in a package also updates that package's CHANGELOG.md, exempting tests, examples, and documentation. check\_skills.sh validates the agent-skills setup by verifying that the .claude/skills symlink correctly points to .agents/skills and that all SKILL.md files contain valid frontmatter with matching kebab-case names and descriptions. Also in this area: 1 commit (0 fixes) modifying .agents, tool.

tool · medium confidence · unverified

New PatrolIntegrationTester with native automation and logging

A new PatrolIntegrationTester class has been introduced in the custom\_finders module, extending PatrolTester to provide direct access to native platform features via platformAutomator. It includes deprecated wrappers for NativeAutomator and NativeAutomator2 for backward compatibility, a shorthand 'platform' accessor, and a 'log' method that records actions to a local PatrolLogWriter. Additionally, it offers a takeNativeScreenshot method for capturing Android-only screenshots for device farms, with errors logged rather than thrown.

_packages/patrol/lib/src/custom\finders · high confidence

New UI component library for the patrol\_challenge example app

The example app's UI layer has been replaced with a new set of styled components and design tokens. This includes a custom scaffold with horizontal page transitions, themed elevated and text buttons, a styled text field with error handling, and utility widgets like a top bar and logo hero. The visual design is now driven by centralized color and typography styles (PTColors, PTTextStyles) and SVG asset management, providing a consistent look and feel for the patrol\_challenge demonstration.

packages/patrol/example/lib/ui · high confidence

New base utility extensions for command handling, file system, and platform detection

This change introduces a new set of extension methods in the \packages/patrol\_cli/lib/src/base/extensions\ directory to support core CLI functionality. It adds \CommandRunnerX\ to handle command usage output formatting, \CompleterExt\ for safer async completion, and \MapX\/\StringX\ for common data manipulation. Additionally, it provides \FileSystemX\ to recursively search for files in directory hierarchies and \PlatformX\ to abstract file system styles and home directory paths across Windows, macOS, and Linux, laying the groundwork for improved project structure handling and hot restart support.

_packages/patrol\cli/lib/src/base/extensions · high confidence

New iOS platform automator implementation

The iOS platform layer has been restructured with a new \IOSAutomator\ interface and its native HTTP-based implementation (\IOSAutomatorNative\), replacing the previous approach. This change introduces a dedicated \IOSAutomatorConfig\ for managing iOS-specific settings such as bundle ID, installed apps, and keyboard behavior, and provides a stub implementation for unsupported platforms. Users interacting with iOS devices will now use this new automator structure for actions like opening apps, tapping notifications, and entering text, which communicates with the native automation server over HTTP.

packages/patrol/lib/src/platform/ios · high confidence

New mobile platform automator and runtime port handling

The mobile platform layer now uses a new \MobileAutomator\ interface and its \NativeMobileAutomator\ implementation to communicate with the native automation server over HTTP, adding support for actions like \sendKeyboardEnter\, permission handling, and device settings. Configuration is centralized in \MobileAutomatorConfig\, which resolves the server host and port (defaulting to 8081) via environment variables or runtime injection. On iOS and macOS, \PatrolRuntimePorts\ now reads the injected HTTP ports from the native side via a method channel, falling back to defaults if unavailable, while providing a no-op stub for web. The \PatrolAppService\ server (running on port 8082) is now hosted on the loopback interface using \http\_multi\_server\ to capture all relevant network traffic.

packages/patrol/lib/src/platform/mobile · high confidence

New platform automation API contracts and clients

The platform communication layer has been updated with new generated Dart contracts and HTTP clients for Android, iOS, and mobile-wide automation. Users can now interact with a broader set of device controls, including sending keyboard enter events, managing mock locations (set and stop), toggling system settings (airplane mode, Wi-Fi, cellular, Bluetooth, dark mode), and handling permission dialogs. The Android client adds methods for pressing back, double-pressing recent apps, and taking camera photos, while the iOS client includes closing heads-up notifications, tapping the back-to-previous-app button, and checking for visible permission dialogs. These changes reflect a schema update that expands the available automation capabilities across both platforms.

packages/patrol/lib/src/platform/contracts · high confidence

Refactored CLI command runner and command base classes

The CLI's command execution layer has been restructured to improve modularity and maintainability. A new \FlutterCommand\ class was introduced to parse and represent Flutter CLI invocations, separating executable paths from their arguments. The \PatrolCommand\ abstract class now serves as a centralized registry for common CLI flags (such as \--target\, \--device\, \--verbose\, and platform-specific options), allowing individual commands to inherit these options via helper methods like \usesTargetOption()\ and \usesPortOptions()\. Additionally, the \PatrolCommandRunner\ was refactored to explicitly instantiate and wire up platform-specific test backends (Android, iOS, macOS, Web) and the test bundler, ensuring that dependencies like the \TestBundler\ and \CompatibilityChecker\ are correctly scoped and passed to the relevant commands.

_packages/patrol\cli/lib/src/runner · high confidence

Refactored log entry structure and improved test name parsing

The log entry system in \packages/patrol\_log/lib/src/entries\ has been refactored to use a sealed \Entry\ class hierarchy with \Equatable\ support, introducing new entry types including \ConfigEntry\ for passing test configuration and \WarningEntry\ for warnings. For users, this brings a specific behavioral improvement to \TestEntry\: the logic for detecting file prefixes in test names now strictly requires the \\_test\ suffix, which prevents the accidental truncation of the first word of a test description when the name does not actually contain a file path prefix. Additionally, error messages are now printed in red and warning messages in yellow for better visual distinction in logs.

_packages/patrol\log/lib/src/entries · high confidence

Refactored native inspector node hierarchy for Android and iOS

The native inspector's internal node structure has been reorganized to use platform-specific node classes (AndroidNode, IOSNode) and a unified NativeViewNode, replacing the previous implementation. This change improves how UI elements are represented in the DevTools extension by separating Android and iOS view handling logic, ensuring more accurate node naming and hierarchy traversal for both platforms.

_packages/patrol\_devtools\_extension/lib/native\inspector/nodes · high confidence

Regenerated iOS example app with dev/prod flavors and updated test configuration

The iOS example app in the Patrol package has been regenerated to support multiple build configurations (dev and prod) via dedicated Xcode schemes, enabling distinct settings for development and production testing. The project now includes a dedicated TestPlan for UI tests, and the test runner has been updated to use the \patrol\ framework directly via \@import patrol\ in the \RunnerUITests\ target. Additionally, the app bundle name has been set to \patrol\_challenge\, and the project structure has been adjusted to reflect the new package location.

packages/patrol/example/ios · high confidence

Restructured CLI commands into dedicated platform-specific build and develop services

The CLI command implementations in \packages/patrol\_cli/lib/src/commands\ have been refactored to improve modularity and support for cross-platform development. The \build\ command is now split into dedicated subcommands (\build android\, \build ios\, \build macos\), each handling platform-specific test bundling, flavor configuration, and artifact generation. The \develop\ command has been decoupled from the CLI runner into a reusable \DevelopService\ and \DevelopSessionFactory\, enabling consistent hot-restart workflows across platforms and programmatic integration via the MCP server. Additionally, new utility files like \dart\_define\_utils.dart\ and \develop\_options.dart\ centralize argument parsing and Dart define merging logic used across these commands.

_packages/patrol\cli/lib/src/commands · high confidence

Restructured public API and added native server URI helper

The main entry point \patrol.dart\ has been reorganized to explicitly export platform-specific automators (Android, iOS, macOS, Web) and contracts, while hiding internal types like \PatrolTester\. A new \patrol\_extension.dart\ file provides a \patrolNativeServerUri\ getter that resolves the native automation server address using environment variables (\PATROL\_HOST\, \PATROL\_TEST\_SERVER\_PORT\), enabling extension packages to communicate with the core server.

packages/patrol/lib · high confidence

iOS Runner configuration for e2e\_app

The iOS Runner for the e2e\_app has been configured to support end-to-end testing scenarios. The app now reads the Google Maps API key from the MAPS\_API\_KEY environment variable, allowing for flexible key injection during tests. Additionally, the Info.plist has been updated to include a deep link URL scheme (patrol) for navigation testing, and permission usage descriptions for camera, contacts, location, microphone, and photo library have been added to support the permission screen tests.

_dev/e2e\app/ios/Runner · high confidence

iOS example app moved to dev/e2e\_app and configured for Patrol UI testing

The iOS example app has been relocated from the example directory to dev/e2e\_app. This move includes setting up the Xcode workspace to reference the project and its Pods, and adding a new UI test target (RunnerUITests) that integrates the Patrol framework to enable end-to-end testing of the app.

_dev/e2e\_app/ios/Runner.xcodeproj/project.xcworkspace, dev/e2e\_app/ios/Runner.xcworkspace, dev/e2e\app/ios/RunnerUITests · high confidence

iOS example app scaffolded with native test targets and updated build configuration

The iOS example project for \patrol\_finders\ has been restructured to include dedicated \RunnerTests\ (Swift) and \RunnerUITests\ (Objective-C) targets, which are now registered in the Xcode scheme for automatic execution. The project build file has been upgraded to object version 54, and the \AppDelegate\ now initializes the \UNUserNotificationCenter\ delegate. Additionally, the \Info.plist\ has been updated to include standard permission descriptions (camera, location, contacts, microphone) and modern iOS flags like \CADisableMinimumFrameDurationOnPhone\ and \UIApplicationSupportsIndirectInputEvents\.

_packages/patrol\finders/example/ios · high confidence

Fixes

1 commit (1 fix) fixing packages/patrol\_log/example

A fix in packages/patrol\_log/example — 1 commit (1 fix), 1 file: “fix(patrol\_log): restore full pana score”.

_packages/patrol\log/example · medium confidence · unverified

Test coverage

2 commits adding/updating tests in packages/patrol\_cli/test/web; Add platform-specific camera and gallery e2e tests; Added Android instrumentation tests for Flutter integration; Added Android native test runner for Dart tests; Added Patrol e2e tests for permissions and macOS app interactions; Added automated test for \patrol develop\ hot restart behavior; Added e2e tests for native permission handling and notification interactions; Added example test and updated example app test location; Added example tests for patrol\_finders; Added internal and example end-to-end tests for Patrol; Added internal and example end-to-end tests for Patrol; Added native camera e2e tests using Patrol native2 API; Added native integration tests for the e2e\_app; Added placeholder test to satisfy CI requirements; Added smoke test for MCP server startup and shutdown; Added test assets for e2e scenarios; Added test coverage for PatrolFinders; Added test coverage for core CLI utilities and test infrastructure; Added test coverage for patrol CLI commands and services; Added test coverage for web runner multi-tab and page management features; Added test infrastructure and mocks for patrol\_cli; Added test infrastructure for Patrol Web runner; Added tests for analytics sending behavior and error handling; Added tests for cross-platform app options, Flutter tool interactions, and test manifest parsing; Added tests for device listing, selection, FVM resolution, and screenshot capture; Added tests for iOS test backend and Xcode test code generation; Added tests for version compatibility logic; Added tests for web runner action handlers; Added unit tests for ADB device listing and forward parsing; Added unit tests for Android test backend logic and code generation; Added unit tests for Android test contract flattening and generated test detection; Added unit tests for Patrol internal components and configuration; Added unit tests for PatrolLogReader and TestEntry behavior; Added unit tests for PubspecReader and TestBundler; Added unit tests for iOS selector-to-NSPredicate conversion; Expanded web platform capabilities and new e2e test coverage; New Patrol e2e test suite for the e2e\_app; Removed empty test file in maestro/test.

Dependencies

Add e2e\_app and cli\_tests dependency manifests with updated SDK constraints

The e2e\_app and cli\_tests packages now include their pubspec.yaml and lockfile dependencies, with the e2e\_app targeting Dart SDK \>=3.10.0 and Flutter \>=3.38.0, and cli\_tests targeting Dart SDK \>=3.8.0. The e2e\_app also pins permission\_handler\_apple to 9.4.5 to work around a known issue.

(dependencies) · high confidence

Housekeeping

Added clang-format and gitignore configurations for the Darwin package

The darwin package now includes a .clang-format file to enforce Google-style formatting with a 120-column limit, and a .gitignore file to exclude common build artifacts, IDE settings, and Swift Package Manager directories from version control.

packages/patrol/darwin · high confidence

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

How this codebase got here

Score

  • CAI 46.8 → 49.9 (+3.1)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 74.4 → 71.4 (-3.0)
  • Architecture 90.1 → 88.8 (-1.3)
  • Maturity 56.1 → 65.8 (+9.7)
  • Readiness 40.3 → 46.0 (+5.7)
  • Security 42.1 → 42.1 (0.0)
  • Accessibility 61.2 → 73.2 (+12.0)
  • Performance 60.4 → 60.0 (-0.4)

Resolved (27)

  • Duplicated block (10 lines × 2) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • Duplicated block (11 lines × 2) (packages/patrol/android/src/main/kotlin/pl/leancode/patrol/AutomatorServer.kt)
  • Duplicated block (12 lines × 2) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • Duplicated block (12 lines × 2) (packages/patrol_cli/lib/src/pubspec_reader.dart)
  • Duplicated block (13 lines × 2) (packages/patrol/android/src/main/kotlin/pl/leancode/patrol/Automator.kt)
  • Duplicated block (14 lines × 2) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/Automator.swift)
  • Duplicated block (14 lines × 4) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • Duplicated block (17 lines × 2) (packages/patrol_cli/lib/src/commands/build_ios.dart)
  • Duplicated block (18 lines × 2) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • Duplicated block (19 lines × 2) (packages/patrol_cli/lib/src/runner/patrol_command.dart)
  • Duplicated block (21–22 lines × 2) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • Duplicated block (22–24 lines × 2) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • Duplicated block (26–29 lines × 2) (packages/patrol_cli/lib/src/runner/patrol_command.dart)
  • Duplicated block (29 lines × 3) (packages/patrol_cli/lib/src/commands/build_android.dart)
  • Duplicated block (8 lines × 2) (packages/patrol_gen/lib/src/generators/dart/dart_contracts_generator.dart)
  • High CVE: [GHSA redacted] (docs_app/package-lock.json)
  • Hotspot: packages/patrol/lib/src/bs_coverage.dart (packages/patrol/lib/src/bs_coverage.dart)
  • Hotspot: packages/patrol_cli/lib/src/commands/build_android.dart (packages/patrol_cli/lib/src/commands/build_android.dart)
  • Hotspot: packages/patrol_cli/lib/src/commands/test.dart (packages/patrol_cli/lib/src/commands/test.dart)
  • Members sharing a duplicated core (4 members, 50+ identical tokens) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • …and 7 more

New (62)

  • Documentation: no build, run or usage example (packages/adb/README.md)
  • Documentation: no build, run or usage example (packages/patrol_log/README.md)
  • Duplicated block (10 lines × 2) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • Duplicated block (11 lines × 2) (packages/patrol/android/src/main/kotlin/pl/leancode/patrol/AutomatorServer.kt)
  • Duplicated block (11 lines × 2) (packages/patrol_cli/lib/src/pubspec_reader.dart)
  • Duplicated block (12 lines × 2) (packages/patrol_cli/lib/src/pubspec_reader.dart)
  • Duplicated block (13 lines × 2) (packages/patrol/android/src/main/kotlin/pl/leancode/patrol/Automator.kt)
  • Duplicated block (19 lines × 2) (packages/patrol_cli/lib/src/runner/patrol_command.dart)
  • Duplicated block (23–24 lines × 2) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • Duplicated block (26–29 lines × 2) (packages/patrol_cli/lib/src/runner/patrol_command.dart)
  • Duplicated block (29 lines × 3) (packages/patrol_cli/lib/src/commands/build_android.dart)
  • Duplicated block (9 lines × 3) (packages/patrol_cli/lib/src/pubspec_reader.dart)
  • Edited copies of one member (3 members, 15+ corresponding lines) (packages/patrol/darwin/patrol/Sources/PatrolImpl/AutomatorServer/Automator/IOSAutomator.swift)
  • Edited copies of one member (3 members, 33+ corresponding lines) (packages/patrol_cli/lib/src/commands/build_android.dart)
  • Edited copy of a member (10 corresponding lines) (dev/e2e_app/macos/Runner/MainFlutterWindow.swift)
  • Edited copy of a member (11 corresponding lines) (packages/patrol_devtools_extension/lib/native_inspector/nodes/android_node.dart)
  • Edited copy of a member (14 corresponding lines) (packages/patrol_devtools_extension/lib/native_inspector/nodes/android_node.dart)
  • Edited copy of a member (14 corresponding lines) (packages/patrol_finders/lib/src/custom_finders/patrol_finder.dart)
  • Edited copy of a member (16 corresponding lines) (packages/patrol/android/src/main/kotlin/pl/leancode/patrol/Automator.kt)
  • Edited copy of a member (17 corresponding lines) (packages/patrol/android/src/main/kotlin/pl/leancode/patrol/BrowserstackPatrolJUnitRunner.java)
  • …and 42 more

Changes since last survey

  • 1 commits — 0 feature/other, 1 fixes

By area

  • (repo) — 1 commit

Notable commits

  • fix: Merge pull request #3334 from khb-works/fix/android-release-consumer-rules-v2

Architecture

  • Containers 0 added · 0 removed · contexts 3 added · 3 removed · edges 0 added · 0 removed

Added bounded contexts (3)

  • dev/e2e_app/android/app
  • packages/patrol/android
  • packages/patrol/example/android/app

Removed bounded contexts (3)

  • dev/e2e_app/android/app
  • packages/patrol/android
  • packages/patrol/example/android/app

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

Survey your own repository

leancodepl/patrol 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.

About this page

  • The score is its most recent published measurement, taken on 17 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit afd136cfd7f27458a5987b96f52711b3434a6f92 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.85+preprod-eba6548ac50f.