USP

Unlike traditional testing tools, flutter-skill enables AI agents to autonomously test across 10 platforms with zero test code, using natural language and direct MCP integration. Its "zero config" setup simplifies adoption significantly.

Use cases

• 01AI-driven end-to-end testing
• 02Cross-platform UI automation
• 03Debugging applications with AI agents
• 04Automated regression testing
• 05Exploratory testing by AI

Detected files (3)

• skills-submission/flutter-skill/SKILL.mdskill
  Show content (3675 bytes)

  ---
  name: flutter-skill
  description: Control and automate Flutter applications - inspect UI, perform gestures, validate state, take screenshots, and debug. Connects AI agents to running Flutter apps via Dart VM Service Protocol.
  ---
  
  # Flutter Skill
  
  Give your AI Agent eyes and hands inside your Flutter app. This skill enables comprehensive control of Flutter applications for testing, debugging, and automation.
  
  ## Installation
  
  ### Option 1: npx (Recommended)
  ```json
  {
    "flutter-skill": {
      "command": "npx",
      "args": ["flutter-skill"]
    }
  }
  ```
  
  ### Option 2: Global Install
  ```bash
  dart pub global activate flutter_skill
  ```
  
  Then configure:
  ```json
  {
    "flutter-skill": {
      "command": "flutter_skill",
      "args": ["server"]
    }
  }
  ```
  
  ## Available Tools
  
  ### Connection
  - `connect_app` - Connect to a running Flutter app via WebSocket URI
  - `launch_app` - Launch a Flutter app with auto-setup (adds dependencies, patches main.dart)
  
  ### UI Inspection
  - `inspect` - Get interactive elements (buttons, text fields, etc.)
  - `get_widget_tree` - Full widget tree structure with configurable depth
  - `get_widget_properties` - Widget details (size, position, visibility)
  - `get_text_content` - Extract all visible text from screen
  - `find_by_type` - Find all widgets of a specific type
  
  ### Interactions
  - `tap` - Tap element by key or text
  - `double_tap` - Double tap gesture
  - `long_press` - Long press gesture
  - `swipe` - Swipe up/down/left/right
  - `drag` - Drag from one element to another
  - `scroll_to` - Scroll element into view
  - `enter_text` - Input text into text field
  
  ### State Validation
  - `get_text_value` - Get text field value
  - `get_checkbox_state` - Get checkbox checked state
  - `get_slider_value` - Get slider current value
  - `wait_for_element` - Wait for element to appear (with timeout)
  - `wait_for_gone` - Wait for element to disappear
  
  ### Screenshots
  - `screenshot` - Capture full app screenshot (base64 PNG)
  - `screenshot_element` - Capture specific element screenshot
  
  ### Navigation
  - `get_current_route` - Get current route name
  - `go_back` - Navigate back
  - `get_navigation_stack` - Get navigation history
  
  ### Debug & Logs
  - `get_logs` - Application logs
  - `get_errors` - Error messages
  - `get_performance` - Performance metrics
  - `clear_logs` - Clear log buffer
  - `hot_reload` - Trigger hot reload
  
  ## Usage Examples
  
  ### Test a Counter App
  ```
  1. Launch the app: launch_app with project_path="/path/to/app"
  2. Inspect UI: inspect
  3. Tap increment: tap with key="increment_button"
  4. Verify: get_text_content to see updated counter
  ```
  
  ### Test a Login Flow
  ```
  1. Enter email: enter_text with key="email_field", text="user@example.com"
  2. Enter password: enter_text with key="password_field", text="password123"
  3. Tap login: tap with key="login_button"
  4. Wait for home: wait_for_element with key="home_screen", timeout=5000
  ```
  
  ### Debug an Issue
  ```
  1. Connect: connect_app with uri="ws://127.0.0.1:xxxxx/ws"
  2. Check errors: get_errors
  3. View logs: get_logs
  4. Take screenshot: screenshot
  ```
  
  ## Best Practices
  
  ### Use Widget Keys
  For reliable element identification, target apps should use `ValueKey`:
  ```dart
  ElevatedButton(
    key: const ValueKey('submit_button'),
    onPressed: _submit,
    child: const Text('Submit'),
  )
  ```
  
  ### Element Finding Priority
  1. **Key** (most reliable): `tap with key="submit_button"`
  2. **Text content**: `tap with text="Submit"`
  3. **Widget type**: `find_by_type with type="ElevatedButton"`
  
  ## Links
  
  - [GitHub Repository](https://github.com/ai-dashboad/flutter-skill)
  - [pub.dev Package](https://pub.dev/packages/flutter_skill)
  - [npm Package](https://www.npmjs.com/package/flutter-skill)
  

• skills/e2e-testing/SKILL.mdskill
  Show content (6391 bytes)

  ---
  name: e2e-testing
  description: AI-powered E2E testing for any app — Flutter, React Native, iOS, Android, Electron, Tauri, KMP, .NET MAUI. Test 8 platforms with natural language through MCP. No test code needed. Just describe what to test and the agent sees screenshots, taps elements, enters text, scrolls, and verifies UI state automatically.
  version: 0.9.36
  ---
  
  # AI E2E Testing — 8 Platforms, Zero Test Code
  
  > Give your AI agent eyes and hands inside any running app.
  
  flutter-skill is an MCP server that connects AI agents to running apps. The agent can see screenshots, tap elements, enter text, scroll, navigate, inspect UI trees, and verify state — all through natural language.
  
  ## Supported Platforms
  
  | Platform | Setup |
  |----------|-------|
  | Flutter (iOS/Android/Web) | `flutter pub add flutter_skill` |
  | React Native | `npm install flutter-skill-react-native` |
  | Electron | `npm install flutter-skill-electron` |
  | iOS (Swift/UIKit) | SPM: `FlutterSkillSDK` |
  | Android (Kotlin) | Gradle: `flutter-skill-android` |
  | Tauri (Rust) | `cargo add flutter-skill-tauri` |
  | KMP Desktop | Gradle dependency |
  | .NET MAUI | NuGet package |
  
  **Test scorecard: 562/567 (99.1%) across all 8 platforms.**
  
  ## Install
  
  ```bash
  # npm (recommended)
  npm install -g flutter-skill
  
  # Homebrew
  brew install ai-dashboad/flutter-skill/flutter-skill
  
  # Or download binary from GitHub Releases
  ```
  
  ## MCP Configuration
  
  Add to your AI agent's MCP config (Claude Desktop, Cursor, Windsurf, OpenClaw, etc.):
  
  ```json
  {
    "mcpServers": {
      "flutter-skill": {
        "command": "flutter-skill",
        "args": ["server"]
      }
    }
  }
  ```
  
  ### OpenClaw
  
  If using OpenClaw, add to your gateway config under `mcp.servers`:
  
  ```yaml
  mcp:
    servers:
      flutter-skill:
        command: flutter-skill
        args: ["server"]
  ```
  
  ## Quick Start
  
  ### 1. Initialize your app (one-time)
  
  ```bash
  cd /path/to/your/app
  flutter-skill init
  ```
  
  Auto-detects project type and patches your app with the testing bridge.
  
  ### 2. Launch and connect
  
  ```bash
  flutter-skill launch .
  ```
  
  ### 3. Test with natural language
  
  Tell the agent what to test:
  
  > "Test the login flow — enter admin@test.com and password123, tap Login, verify Dashboard appears"
  
  The agent will automatically:
  1. `screenshot()` → see the current screen
  2. `inspect_interactive()` → discover all tappable/typeable elements with semantic refs
  3. `tap(ref: "button:Login")` → tap using stable semantic reference
  4. `enter_text(ref: "input:Email", text: "admin@test.com")` → type into field
  5. `wait_for_element(key: "Dashboard")` → verify navigation
  6. `screenshot()` → confirm final state
  
  ## Available MCP Tools
  
  ### Core Actions
  | Tool | Description |
  |------|-------------|
  | `screenshot` | Capture current screen as image |
  | `tap` | Tap element by key, text, ref, or coordinates |
  | `enter_text` | Type text into a field |
  | `scroll` | Scroll up/down/left/right |
  | `swipe` | Swipe gesture between points |
  | `long_press` | Long press an element |
  | `drag` | Drag from point A to B |
  | `go_back` | Navigate back |
  | `press_key` | Send keyboard key events |
  
  ### Inspection (v0.8.0+)
  | Tool | Description |
  |------|-------------|
  | `inspect_interactive` | **NEW** — Get all interactive elements with semantic ref IDs |
  | `get_elements` | List all elements on screen |
  | `find_element` | Find element by key or text |
  | `wait_for_element` | Wait for element to appear (with timeout) |
  | `get_element_properties` | Get detailed properties of an element |
  
  ### Text Manipulation
  | Tool | Description |
  |------|-------------|
  | `set_text` | Replace text in a field |
  | `clear_text` | Clear a text field |
  | `get_text` | Read text content |
  
  ### App Control
  | Tool | Description |
  |------|-------------|
  | `get_logs` | Read app logs |
  | `clear_logs` | Clear log buffer |
  
  ## Semantic Refs (v0.8.0)
  
  `inspect_interactive` returns elements with stable semantic reference IDs:
  
  ```
  button:Login          → Login button
  input:Email           → Email text field
  toggle:Dark Mode      → Dark mode switch
  button:Submit[1]      → Second Submit button (disambiguated)
  ```
  
  Format: `{role}:{content}[{index}]`
  
  7 roles: `button`, `input`, `toggle`, `slider`, `select`, `link`, `item`
  
  Use refs for reliable element targeting that survives UI changes:
  ```
  tap(ref: "button:Login")
  enter_text(ref: "input:Email", text: "test@example.com")
  ```
  
  ## Testing Workflow
  
  ### Basic Flow
  ```
  screenshot() → inspect_interactive() → tap/enter_text → screenshot() → verify
  ```
  
  ### Comprehensive Testing
  > "Explore every screen of this app. Test all buttons, forms, navigation, and edge cases. Report any bugs you find."
  
  The agent will systematically:
  - Navigate every screen via tab bars, menus, links
  - Interact with every interactive element
  - Test form validation (empty, invalid, valid inputs)
  - Test edge cases (long text, special characters, emoji)
  - Verify navigation flows (forward, back, deep links)
  - Take screenshots at each step for verification
  
  ### Example Prompts
  
  **Quick smoke test:**
  > "Tap every tab and screenshot each page"
  
  **Form testing:**
  > "Fill the registration form with edge case data — emoji name, very long email, short password — and verify error messages"
  
  **Navigation:**
  > "Test the complete user journey: sign up → create post → like → comment → delete → sign out"
  
  **Accessibility:**
  > "Check every screen for missing labels, small tap targets, and contrast issues"
  
  ## Tips
  
  1. **Always start with `screenshot()`** — see before you act
  2. **Use `inspect_interactive()` to discover elements** — don't guess at selectors
  3. **Prefer `ref:` selectors** — more stable than text or coordinates
  4. **`wait_for_element()` after navigation** — apps need time to transition
  5. **Screenshot after every action** — verify the expected effect
  6. **Use `press_key` for keyboard shortcuts** — test keyboard navigation
  
  ## Links
  
  - [GitHub](https://github.com/ai-dashboad/flutter-skill)
  - [npm](https://www.npmjs.com/package/flutter-skill)
  - [Documentation](https://github.com/ai-dashboad/flutter-skill/blob/main/docs/USAGE_GUIDE.md)
  - [Demo Video](https://github.com/user-attachments/assets/d4617c73-043f-424c-9a9a-1a61d4c2d3c6)
  - [pub.dev](https://pub.dev/packages/flutter_skill)
  - [VSCode Extension](https://marketplace.visualstudio.com/items?itemName=AIDashboard.flutter-skill)
  

• server.jsonmcp_server
  Show content (585 bytes)

  {
    "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
    "name": "io.github.ai-dashboad/flutter-skill",
    "description": "AI-powered E2E testing for 10 platforms. 253 MCP tools. Zero test code needed.",
    "repository": {
      "url": "https://github.com/ai-dashboad/flutter-skill",
      "source": "github"
    },
    "version": "0.9.36",
    "packages": [
      {
        "registryType": "npm",
        "identifier": "flutter-skill",
        "version": "0.9.36",
        "transport": {
          "type": "stdio"
        },
        "environmentVariables": []
      }
    ]
  }
  

README

You: "Test the checkout flow with an empty cart, then add 3 items and complete purchase"

Your AI agent handles the rest — screenshots, taps, text entry, assertions, navigation.
No Page Objects. No XPath. No brittle selectors. Just plain English.

npm install -g flutter-skill

{
  "mcpServers": {
    "flutter-skill": {
      "command": "flutter-skill",
      "args": ["server"]
    }
  }
}

import 'package:flutter_skill/flutter_skill.dart';

void main() {
  if (kDebugMode) FlutterSkillBinding.ensureInitialized();
  runApp(MyApp());
}

{
  "mcpServers": {
    "flutter-skill": {
      "command": "flutter-skill",
      "args": ["server"]
    }
  }
}

# Start server
flutter-skill serve https://your-app.com

# Use CLI client commands
flutter-skill nav https://google.com
flutter-skill snap                    # Accessibility tree (99% fewer tokens)
flutter-skill screenshot /tmp/ss.jpg
flutter-skill tap "Login"
flutter-skill type "hello@example.com"
flutter-skill eval "document.title"
flutter-skill tools                   # List all available tools

# 🤖 AI autonomous exploration — finds bugs automatically
flutter-skill explore https://my-app.com --depth=3

# 🐒 Monkey/fuzz testing — random actions, crash detection
flutter-skill monkey https://my-app.com --actions=100 --seed=42

# 🚀 Parallel multi-platform testing
flutter-skill test --url https://my-app.com --platforms web,electron,android

# 🌐 Zero-config WebMCP server — any website becomes testable
flutter-skill serve https://my-app.com

// page_summary → ~200 tokens (vs ~4,000 for a screenshot)
{
  "title": "Shopping Cart",
  "nav": ["Home", "Products", "Cart", "Account"],
  "forms": [{"input:Coupon Code": "text"}],
  "buttons": ["Apply", "Checkout", "Continue Shopping"],
  "features": {"search": true, "pagination": true},
  "links": 47, "inputs": 3
}

// explore_actions → 5 actions per call (vs 5 separate tool calls)
{"actions": [
  {"type": "fill", "target": "input:Coupon Code", "value": "SAVE20"},
  {"type": "tap", "target": "button:Apply"},
  {"type": "tap", "target": "button:Checkout"},
  {"type": "fill", "target": "input:Email", "value": "test@example.com"},
  {"type": "tap", "target": "button:Continue"}
]}

dependencies:
  flutter_skill: ^0.9.36

import 'package:flutter_skill/flutter_skill.dart';

void main() {
  if (kDebugMode) FlutterSkillBinding.ensureInitialized();
  runApp(MyApp());
}

npm install flutter-skill-react-native

import FlutterSkill from 'flutter-skill-react-native';
FlutterSkill.start();

npm install flutter-skill-electron

const { FlutterSkillBridge } = require('flutter-skill-electron');
FlutterSkillBridge.start(mainWindow);

// Swift Package Manager: FlutterSkillSDK
import FlutterSkill
FlutterSkillBridge.shared.start()

Text("Hello").flutterSkillId("greeting")

implementation("com.flutterskill:flutter-skill:0.8.0")

FlutterSkillBridge.start(this)

[dependencies]
flutter-skill-tauri = "0.8.0"

git clone https://github.com/ai-dashboad/flutter-skill
cd flutter-skill
dart pub get
dart run bin/flutter_skill.dart server  # Start MCP server