# MCP Appium - Mobile Development and Automation Server (npm · @sniffski/squire)

MCP server for Appium mobile automation on iOS and Android devices with test creation tools.

- Trust score: 71/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `@sniffski/squire`: 71/100 (this document), [markdown](https://verifymcp.io/servers/ihubanov-squire/sniffski-squire.md), [page](https://verifymcp.io/servers/ihubanov-squire/sniffski-squire)

## Channel facts

- Registry: `npm`
- Package: `@sniffski/squire`
- Version: `1.31.6`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 85/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known high-severity CVE affects sharp 0.32.6, reached via @xenova/transformers > sharp. A fixed version is available.
  - No install/post-install scripts declared.
  - Dependency health was assessed across the 400 of 678 dependencies we could resolve, so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 71/100
  - Repository check failed: no source repository is declared.
  - Cryptographically verified build provenance (signed, bound to ihubanov/squire).
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 1 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 82/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 7755 tokens (~121/item across 64 items; 63 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 98% of tool parameters carry a description.
- **Tool Safety**: 81/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 1 of 4 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "appium_drag_and_drop" implies "drop" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 65 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the MCP Appium - Mobile Development and Automation Server server?

MCP Appium - Mobile Development and Automation Server runs locally as an npm package, launched with npx -y @sniffski/squire. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add ihubanov-squire -- npx -y @sniffski/squire
```

### Cursor

```json
{
  "mcpServers": {
    "ihubanov-squire": {
      "command": "npx",
      "args": [
        "-y",
        "@sniffski/squire"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ihubanov-squire": {
      "command": "npx",
      "args": [
        "-y",
        "@sniffski/squire"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add ihubanov-squire -- npx -y @sniffski/squire
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ihubanov-squire": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@sniffski/squire"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ihubanov-squire --command npx --arg -y --arg @sniffski/squire
```

### Hermes

```yaml
mcp_servers:
  ihubanov-squire:
    command: "npx"
    args: ["-y", "@sniffski/squire"]
```

### Netclaw

```json
{
  "McpServers": {
    "ihubanov-squire": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@sniffski/squire"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add ihubanov-squire -t stdio -c npx -a -y @sniffski/squire
```

### Other

```json
{
  "mcpServers": {
    "ihubanov-squire": {
      "command": "npx",
      "args": [
        "-y",
        "@sniffski/squire"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 71, +21)

- [security regression] CVE-2026-114112 affects this package: high
- [security regression] CVE-2026-118764 affects this package: high
- [security regression] CVE-2026-114113 affects this package: high
- [security regression] CVE-2026-114111 affects this package: high
- [security regression] CVE-2026-118773 affects this package: high
- [security regression] Known CVEs: unverified → fail
- [security improvement] Malware scan: unverified → pass
- [functional improvement] Dependency health: unverified → partial

### 2026-11-03 (score 50)

First indexed and scored.

## MCP tools (63)

### `select_platform` (~375 tokens)

Select the platform for LOCAL servers ONLY.
      DO NOT use this tool if the user mentions a REMOTE Appium server URL (e.g., http://localhost:4723, http://192.168.1.100:4723, or any other server address).
      WORKFLOW FOR LOCAL SERVERS:
      1. First, ASK THE USER which platform they want to use (Android, iOS, or Web)
      2. You MUST explicitly prompt the user to choose between Android, iOS, or Web
      3. DO NOT assume or default to any platform
      4. For Android/iOS: After platform selection, available devices will be listed
      5. If multiple devices are available, use select_device to let the user choose
      6. After device selection, proceed to create_session
      7. For Web: No device selection needed, proceed directly to create_session
      WORKFLOW FOR REMOTE SERVERS:
      If user provides a remote server URL, SKIP this tool entirely. Instead, infer the platform and device type from the user's request (e.g., 'ios xcuitest driver with iphone 17 simulator' means platform='ios') and call create_session directly with the remoteServerUrl parameter.

Input parameters:

- `iosDeviceType` (string): For iOS only: Specify whether to use 'simulator' (iOS Simulator on macOS) or 'real' (physical iOS device). REQUIRED when platform is 'ios'.
- `platform` (string, required): REQUIRED: The platform chosen by the user - 'android' for Android devices/emulators, 'ios' for iOS devices/simulators, or 'web' for browser automation with Playwright. This must be based on the user'…

### `select_device` (~272 tokens)

Select a specific device from available LOCAL devices. For LOCAL Appium servers ONLY.
      DO NOT use this tool for REMOTE Appium servers - remoteServerUrl indicates a remote server.
      WORKFLOW FOR LOCAL SERVERS:
      - Use this tool ONLY when select_platform returns multiple devices
      - For Android: Use before calling create_session if multiple devices are found
      - For iOS: Use before calling boot_simulator or create_session if multiple simulators/devices are found
      - Ask the user which device they want to use from the list provided
      WORKFLOW FOR REMOTE SERVERS:
      - SKIP this tool entirely
      - Device selection should be handled via capabilities in create_session (e.g., appium:deviceName, appium:udid)
      - The remote Appium server is already configured for specific device(s)

Input parameters:

- `deviceUdid` (string): The UDID of the device selected by the user. If not provided, this tool will list available devices for the user to choose from.
- `iosDeviceType` (string): For iOS only: Specify whether to use 'simulator' or 'real' device. REQUIRED when platform is 'ios'.
- `platform` (string, required): The platform to list devices for (must match previously selected platform)

### `create_session` (~849 tokens)

Create a new session with Android, iOS, Web (Playwright), or any device/driver Appium supports.
      WORKFLOW FOR LOCAL SERVERS (no remoteServerUrl):
      - Use select_platform tool FIRST to ask the user which platform they want
      - Then optionally use select_device tool if multiple devices are available
      - Finally call create_session with the selected platform and device
      - DO NOT assume or default to any platform
      WORKFLOW FOR WEB (Playwright):
      - Use select_platform with platform='web' first
      - Then call create_session with platform='web'
      - Optionally specify browser (chromium, firefox, webkit) and headless mode
      - When AI_COLLEAGUE_CDP_ENDPOINT / APPIUM_MCP_CDP_ENDPOINT is set, this attaches to the user's already-running Chromium window (the one they can see); focus/protected-tab guards apply there. Otherwise Playwright launches a fresh browser fully detached from any Chrome/Chromium the user already has open (own process/profile/window class, own CDP debug port chosen to be free — APPIUM_MCP_CDP_PORT sets the preferred port, 0/none disables); no focus guards apply to a detached browser. Either way it's a real browser — full JavaScript, cookies, redirects, captchas all behave like for a human user.
      WORKFLOW FOR REMOTE SERVERS (remoteServerUrl provided):
      - SKIP select_platform tool entirely
      - Infer the platform from the user's request (e.g., 'ios', 'android', or 'general')
      - If platform is 'general', treat the provided capabilities as a pass-through W3C/Appium capability set (useful for non-Android/iOS drivers like Windows, macOS, or custom drivers)
      - Infer device type from context when possible (e.g., 'simulator', 'real device')
      - Call create_session directly with platform, remoteServerUrl, and any other capabilities from the user's request
      - Example: User says 'start session with http://localhost:4723 for ios with iphone 17' → infer platform='ios' and call create_session with r…

Input parameters:

- `browser` (string): For web platform only: Browser engine to use. Default is 'chromium'. Options: 'chromium', 'firefox', 'webkit' (Safari engine).
- `capabilities` (object): Optional custom W3C format capabilities for the session. These are applied on top of defaults for ios/android or used as-is for platform="general". For web sessions, use browser, headless, and url pa…
- `headless` (boolean): For web platform only: Whether to run the browser in headless mode. Default is true. Pass false when a person should watch, as for playwright_present.
- `platform` (string, required): REQUIRED: Platform to use.           - For local servers, this must match the platform the user explicitly selected via the select_platform tool ('ios', 'android', or 'web').           - Use 'web' fo…
- `remoteServerUrl` (string): Remote Appium server URL (e.g., http://localhost:4723 or http://192.168.1.100:4723). If not provided, uses local Appium server. Not used for web/Playwright sessions.
- `url` (string): For web platform only: Initial URL to navigate to after launching the browser.
- `viewport` (object): For web platform only: Browser viewport size. Default is 1280x720.

### `list_sessions` (~27 tokens)

List all active Appium sessions managed by this MCP server, including active flag and current context.

### `select_session` (~36 tokens)

Set an existing Appium session as the active session for subsequent tool calls.

Input parameters:

- `sessionId` (string, required): The session ID to activate.

### `delete_session` (~48 tokens)

Delete a mobile session and clean up resources. If sessionId is omitted, deletes the active session.

Input parameters:

- `sessionId` (string): Optional session ID to delete. If omitted, deletes active session.

### `appium_mobile_open_notifications` (~33 tokens)

Open the Android notifications panel using the mobile: openNotifications extension. Does nothing if the panel is already open.

### `appium_mobile_lock` (~124 tokens)

Lock the device. Optionally lock for a given number of seconds (both Android and iOS support automatic unlock after the timeout). If no timeout is provided, the device stays locked until appium_mobile_unlock is called. Supported on Android (UiAutomator2) and iOS (XCUITest).

Input parameters:

- `seconds` (integer): How long to lock the screen in seconds before it is automatically unlocked. Supported on both Android (UiAutomator2) and iOS (XCUITest). If omitted, the device stays locked until appium_mobile_unlock…

### `appium_mobile_unlock` (~41 tokens)

Unlock the device if it is locked. No-op if already unlocked. Supported on Android (UiAutomator2) and iOS (XCUITest).

### `appium_set_geolocation` (~119 tokens)

Set the geolocation (GPS coordinates) of the device. Works on both iOS (simulators and real devices) and Android (emulators and real devices with mock location enabled).

Input parameters:

- `altitude` (number): Altitude value in meters. Android only. Defaults to 0.
- `latitude` (number, required): Latitude value (-90 to 90). Measurement of distance north or south of the Equator.
- `longitude` (number, required): Longitude value (-180 to 180). Measurement of distance east or west of the prime meridian.

### `appium_get_geolocation` (~32 tokens)

Get the current geolocation (GPS coordinates) of the device. Returns latitude, longitude, and altitude.

### `appium_reset_geolocation` (~86 tokens)

Reset the geolocation to the default/system value. On iOS, resets the simulated location. On Android real devices, resets the mocked geolocation provider (note: GPS cache behavior varies by device — the mocked location may persist until the cache refreshes). On Android emulators, reset is not supported — use appium_set_geolocation to manually set the desired coordinates instead.

### `boot_simulator` (~70 tokens)

Boot an iOS simulator and wait for it to be ready.
      This speeds up subsequent session creation by ensuring the simulator is already running.

Input parameters:

- `udid` (string, required): The UDID of the iOS simulator to boot.           Use select_platform and select_device tools first to get the UDID.

### `setup_wda` (~119 tokens)

Download and setup prebuilt WebDriverAgent (WDA) for iOS/tvOS simulators only (not for real devices).
      This significantly speeds up the first Appium session by avoiding the need to build WDA from source.
      Downloads the latest version from GitHub and caches it locally.

Input parameters:

- `platform` (string): The simulator platform to download WDA for.           Default is "ios".           Use "tvos" for Apple TV simulators.           Note: This tool only works with simulators, not real devices.

### `install_wda` (~140 tokens)

Install and launch the WebDriverAgent (WDA) app on a booted iOS simulator using the app path from setup_wda.
      This tool requires WDA to be already set up using setup_wda and at least one simulator to be booted.

Input parameters:

- `appPath` (string): The path to the WDA app bundle (.app file) that be generated by setup_wda tool.           If not provided, will try to find the latest cached WDA app.
- `simulatorUdid` (string): The UDID of the simulator to install WDA on. If not provided, will use the first booted simulator found.

### `appium_scroll` (~27 tokens)

Scrolls the current screen up or down

Input parameters:

- `direction` (string): Scroll direction

### `appium_scroll_to_element` (~58 tokens)

Scrolls the current screen till a certain element is visible

Input parameters:

- `direction` (string): Direction to scroll when searching for the element
- `selector` (string, required): The selector to find the element
- `strategy` (string, required)

### `appium_swipe` (~261 tokens)

Swipe on the current screen in a specified direction or between custom coordinates.
      Supports four directions: left, right, up, down.
      Can also perform custom coordinate-based swipes for precise control.
      This is useful for navigating carousels, switching tabs, dismissing elements, or navigating between screens.

Input parameters:

- `direction` (string): Direction to swipe. If provided, coordinates will be calculated automatically based on screen size or, when elementUUID is set, relative to that element. Either direction OR custom coordinates must b…
- `duration` (integer): Duration of the swipe gesture in milliseconds. Default is 600ms. Higher values create slower swipes.
- `elementUUID` (string): Optional element to base the swipe on. When provided with direction, the swipe is calculated relative to this element instead of the whole screen.
- `endX` (integer): Ending X coordinate for custom swipe. Required if direction is not provided.
- `endY` (integer): Ending Y coordinate for custom swipe. Required if direction is not provided.
- `startX` (integer): Starting X coordinate for custom swipe. Required if direction is not provided.
- `startY` (integer): Starting Y coordinate for custom swipe. Required if direction is not provided.

### `appium_find_element` (~96 tokens)

Find a specific element by strategy and selector which will return a uuid that can be used for interactions. [PRIORITY 2: Use this to search for a target element by xpath, id, accessibility id, css selector, text, data-testid, etc.] Works with both Appium mobile sessions and Playwright web sessions.

Input parameters:

- `selector` (string, required): The selector to find the element
- `strategy` (string, required)

### `appium_click` (~91 tokens)

Click an element. In a Playwright web session this clicks like a human cursor — full mouse-down/up, JS click handlers fire, navigation/form submission happens normally. Use it on links, buttons, search-result entries, login submit buttons, etc. Element is identified by UUID from appium_find_element.

Input parameters:

- `elementUUID` (string, required): The uuid of the element returned by appium_find_element to click

### `appium_double_tap` (~39 tokens)

Perform double tap on an element

Input parameters:

- `elementUUID` (string, required): The uuid of the element returned by appium_find_element to click

### `appium_long_press` (~66 tokens)

Perform a long press (press and hold) gesture on an element

Input parameters:

- `duration` (integer): Duration of the long press in milliseconds. Default is 2000ms.
- `elementUUID` (string, required): The uuid of the element returned by appium_find_element to click

### `appium_drag_and_drop` (~352 tokens)

Perform a drag and drop gesture from a source location to a target location.
      The gesture includes:
      1. Long press (default 600ms, configurable) on the source to initiate drag mode
      2. While holding, drag to the target location
      3. Release at the target to complete the drop

      Supports four modes:
      1. Element to Element: Drag from one element to another element
      2. Element to Coordinates: Drag from an element to specific coordinates
      3. Coordinates to Element: Drag from coordinates to an element
      4. Coordinates to Coordinates: Drag from coordinates to coordinates

      This is useful for reordering lists, moving items, drag-to-delete, and other drag interactions.

Input parameters:

- `duration` (integer): Duration of the drag movement in milliseconds. Default is 1200ms.
- `longPressDuration` (integer): Duration of the long press before dragging in milliseconds. Default is 600ms.
- `sourceElementUUID` (string): UUID of the source element to drag from. Either sourceElementUUID or sourceX/sourceY must be provided.
- `sourceX` (integer): Starting X coordinate. Required if sourceElementUUID is not provided.
- `sourceY` (integer): Starting Y coordinate. Required if sourceElementUUID is not provided.
- `targetElementUUID` (string): UUID of the target element to drop on. Either targetElementUUID or targetX/targetY must be provided.
- `targetX` (integer): Ending X coordinate. Required if targetElementUUID is not provided.
- `targetY` (integer): Ending Y coordinate. Required if targetElementUUID is not provided.

### `appium_pinch` (~211 tokens)

Perform a pinch gesture to zoom in or zoom out. Use scale < 1 to zoom out (pinch close) and scale > 1 to zoom in (pinch open). Works on both iOS and Android. Optionally target a specific element, otherwise the gesture applies to the whole screen.

Input parameters:

- `elementUUID` (string): Optional UUID of the element to pinch on. If not provided, the pinch gesture is applied to the whole screen.
- `scale` (number, required): Pinch scale. Use a value between 0 and 1 to zoom out (pinch close), and a value greater than 1 to zoom in (pinch open). Example: 0.5 = zoom out 50%, 2.0 = zoom in 2x.
- `velocity` (number): The velocity of the pinch in scale factor per second. Used natively by iOS for zoom in, and controls gesture speed for zoom out on both platforms. Default is 2.2.

### `appium_mobile_press_key` (~141 tokens)

Press navigation keys (BACK, HOME, APP_SWITCH) on Android or physical buttons (HOME, volume, etc.) on iOS/tvOS.

Input parameters:

- `isLongPress` (boolean): Android only. Whether to perform a long press. Defaults to false.
- `key` (string): Logical key/button to press. On Android: BACK, HOME, APP_SWITCH. On iOS/tvOS: HOME, VOLUME_UP, VOLUME_DOWN, UP, DOWN, LEFT, RIGHT, MENU, PLAY_PAUSE, SELECT.
- `keyCode` (integer): Android keycode to press. If provided, takes precedence over key for Android.

### `appium_set_value` (~48 tokens)

Enter text into an element

Input parameters:

- `elementUUID` (string, required): The uuid of the element returned by appium_find_element to click
- `text` (string, required): The text to enter

### `appium_get_text` (~37 tokens)

Get text from an element

Input parameters:

- `elementUUID` (string, required): The uuid of the element returned by appium_find_element to click

### `appium_get_active_element` (~48 tokens)

Get the currently active/focused element and return its UUID for follow-up interactions. [PRIORITY 1: Use this first when you need to find what element currently has focus]

### `appium_get_page_source` (~57 tokens)

Get the page source of the current screen (XML for native apps, HTML for web/Playwright sessions). The full source is saved to a file and a capped preview is returned inline; read the file for the complete source.

### `appium_get_orientation` (~27 tokens)

Get the current device/screen orientation. Returns LANDSCAPE or PORTRAIT.

### `appium_set_orientation` (~51 tokens)

Set the device/screen orientation to LANDSCAPE or PORTRAIT. Works for both Android and iOS sessions.

Input parameters:

- `orientation` (string, required): Target orientation: LANDSCAPE or PORTRAIT

### `appium_handle_alert` (~308 tokens)

Handle system alerts or dialogs that do not belong to the app.
Use this to dismiss or accept alerts programmatically instead of using autoDismissAlerts capability.
Supports permission dialogs with buttons like:
\- Android: "While using the app", "Only this time", "Don't allow"
\- iOS: "Always", "Allow Once", "Don't allow"
For iOS: Uses mobile: alert execute command.
For Android: Uses mobile: acceptAlert/dismissAlert or searches the current page source for an element whose text or content-desc matches the label, then uses generated locators to find and click it (no hardcoded resource IDs or XPaths).
If no alert is present, the error is caught and returned gracefully.
To discover button labels and screen structure first, use appium_get_page_source (XML hierarchy) or generate_locators (interactable elements with text/content-desc).

Input parameters:

- `action` (string, required): Action to perform on the alert: accept or dismiss
- `buttonLabel` (string): Optional label of the button to click. Common permission dialog buttons: Android: "While using the app", "Only this time", "Don't allow" iOS: "Always" or "Allow Always", "Once" or "Allow Once", "Don'…

### `appium_screenshot` (~59 tokens)

Take a screenshot of the current screen and return as PNG image

Input parameters:

- `maxWidth` (number): Optional maximum width in pixels to resize the screenshot. The aspect ratio is preserved. Useful for reducing token usage when sending screenshots to LLMs.

### `appium_element_screenshot` (~82 tokens)

Take a screenshot of the given element uuid and return as PNG image

Input parameters:

- `elementUUID` (string, required): The uuid of the element returned by appium_find_element to click
- `maxWidth` (number): Optional maximum width in pixels to resize the screenshot. The aspect ratio is preserved. Useful for reducing token usage when sending screenshots to LLMs.

### `appium_activate_app` (~25 tokens)

Activate app by id

Input parameters:

- `id` (string, required): The app id

### `appium_install_app` (~35 tokens)

Install an app on the device from a file path.

Input parameters:

- `path` (string, required): Path to the app file to install

### `appium_uninstall_app` (~39 tokens)

Uninstall an app from the device.

Input parameters:

- `id` (string, required): App identifier (package name for Android, bundle ID for iOS)

### `appium_terminate_app` (~39 tokens)

Terminate an app on the device.

Input parameters:

- `id` (string, required): App identifier (package name for Android, bundle ID for iOS)

### `appium_list_apps` (~43 tokens)

List all installed apps on the device. On Android, only package IDs are returned (no display names); on iOS, bundle IDs and display names are returned.

### `appium_is_app_installed` (~50 tokens)

Check whether an app is installed. Package name for Android, bundle ID for iOS.

Input parameters:

- `id` (string, required): App identifier (package name for Android, bundle ID for iOS)

### `appium_deep_link` (~106 tokens)

Open a deep link URL with the default or specified app. Supported on Android and iOS.

Input parameters:

- `appId` (string): App identifier: bundleId (iOS) or package (Android)
- `url` (string, required): Deep link URL to open (e.g. https://example.com, myapp://path)
- `waitForLaunch` (boolean): Android only. If false, ADB does not wait for the activity to return control. Defaults to true.

### `appium_get_contexts` (~53 tokens)

Get all available contexts in the current Appium session. Returns a list of context names including NATIVE_APP and any webview contexts (e.g., WEBVIEW_<id> or WEBVIEW_<package>).

### `appium_switch_context` (~108 tokens)

Switch to a specific context in the Appium session. Use this to switch between native app context (NATIVE_APP) and webview contexts (WEBVIEW_<id> or WEBVIEW_<package>). Use appium_get_contexts to see available contexts first.

Input parameters:

- `context` (string, required): The name of the context to switch to. Common values: "NATIVE_APP" for native context, or "WEBVIEW_<id>" / "WEBVIEW_<package>" for webview contexts.

### `generate_locators` (~46 tokens)

Generate locators for all interactable elements on the current page. [PRIORITY 3: Use this for debugging/inspection or when you need comprehensive element info with locator suggestions]

### `appium_generate_tests` (~30 tokens)

Generate tests for a given mobile app

Input parameters:

- `steps` (array, required): The steps of the test

### `playwright_navigate` (~172 tokens)

Navigate the AI's currently active tab to a URL in the real Chromium browser the user is sitting in front of. The page loads, JavaScript runs, cookies/redirects/captchas behave exactly as they would for a human. Use this to follow a link from a previous result, change the URL of a tab you already opened, or move through a multi-page flow. Prefer playwright_new_tab when starting a fresh task so you don't clobber an existing tab. Refused if the target tab is the qwen-web TUI or the user is currently focused on it.

Input parameters:

- `url` (string, required): The URL to navigate to
- `waitUntil` (string): When to consider navigation complete. Default is 'load'. Use 'networkidle' to wait until no network requests for 500ms.

### `playwright_go_back` (~27 tokens)

Go back to the previous page in browser history. Only works with Playwright web sessions.

### `playwright_go_forward` (~27 tokens)

Go forward to the next page in browser history. Only works with Playwright web sessions.

### `playwright_reload` (~21 tokens)

Reload the current page. Only works with Playwright web sessions.

### `playwright_evaluate` (~137 tokens)

Run a JavaScript expression in the AI's active tab and get the result back. Use this to scrape structured data from a page (`document.querySelectorAll(...).map(e => e.textContent)`), call a page's own JS API, fetch a JSON endpoint via `fetch(...)` from the page's origin (useful for SearXNG's /search?format=json), or check page state. The page is real and live — DOM, cookies, network are all what a human would see.

Input parameters:

- `script` (string, required): JavaScript code to evaluate in the browser page context. The result will be serialized and returned.

### `playwright_run_script` (~467 tokens)

Drive the AI's active tab through a sequence of steps in one call, like a human would. Survives page navigations (form submits no longer abort the rest of the script) and falls back to a humanised, hidden-element-revealing path only when the normal fast path fails — useful for modals/menus that a plain click cannot reach. Returns per-step results; on a failing step it stops and hands back a `continuationId` you can pass as `resume` to pick up where it left off after you adjust. Prefer this over chaining many single-action tools when a flow (login, multi-field form, open-menu-then-click) should run as one human-like unit. An upload step puts local files into a file input or the file picker a button opens.

Input parameters:

- `humanize` (string): auto (default): normal first, human fallback only on a wall. always: human path every step. never: normal only, fail instead of falling back.
- `pauseAfter` (number): Hand control back after this many successful steps, returning a continuation for the rest.
- `resume` (string): Continuation id from a prior run that stopped early — resumes its remaining steps.
- `stepTimeout` (number): Per-step normal-attempt timeout in ms (default 5000).
- `steps` (array): Ordered steps to run in one go. Each is attempted the normal fast way first; if it hits a wall (hidden/not-actionable/intercepted) and humanize allows, it escalates to a human path that reveals the e…
- `stopOnError` (boolean): Stop on the first failing step and return a continuation (default true).
- `tab` (string): Stable tab id (from playwright_list_tabs) to run this script against. Omit to use the AI-active tab. Targeting a tab id drives that tab DIRECTLY without changing the active-tab pointer or foregroundi…

### `playwright_present` (~416 tokens)

Show a person how to do something on a website: an animated spotlight, a pointing arrow and a caption walk them through it step by step on the real page. Use when the user says "show me how…", "where do I…", "walk me through…", "guide me". Default mode "guided" points and explains — the person clicks/types themselves, and the tour advances on their click, their input, or navigation; pressing Next does the step's action for them (never into password/payment/one-time-code fields), and Back undoes a step that navigated. Mode "demo" performs the steps itself, slowly, with a visible cursor. Guided calls return waiting:true with a tourId when the person is still busy; call again with `resume` to keep waiting, or `stop` to end it. Tours always run where the person can see them: a headless session is reopened in a visible browser first (same page, cookies and localStorage), and the call fails if no visible browser can open.

Input parameters:

- `accent` (string): CSS colour for the spotlight, arrow and buttons (default violet).
- `mode` (string): guided (default): point and explain, the person does each step. demo: Squire does the steps itself, slowly, with a visible cursor. Demo never types into password/payment fields — those steps wait for…
- `resume` (string): Tour id from a previous call that returned waiting:true — keep waiting for the person.
- `steps` (array): The tour, in order. Omit when using `resume` or `stop`.
- `stop` (string): Tour id to end now; removes the overlay.
- `tab` (string): Stable tab id (from playwright_list_tabs) to present on. Omit for the active tab. The tab is brought to the front.
- `waitSeconds` (number): Guided: how long this call waits for the person before returning waiting:true (default 120). The overlay stays up meanwhile.

### `playwright_select_option` (~99 tokens)

Select an option from a <select> dropdown element. Provide value, label, or index. Only works with Playwright web sessions.

Input parameters:

- `elementUUID` (string, required): The UUID of the <select> element returned by appium_find_element
- `index` (integer): Select option by its zero-based index
- `label` (string): Select option by its visible text label
- `value` (string): Select option by its value attribute

### `playwright_hover` (~65 tokens)

Hover the mouse over an element on the active tab, just like a human cursor would. Use this to reveal hover-only menus, tooltips, or dropdown previews before clicking through.

Input parameters:

- `elementUUID` (string, required): The uuid of the element returned by appium_find_element to click

### `playwright_new_tab` (~348 tokens)

Open a new tab in the real Chromium window the user is in, optionally navigated to a URL. This is your primary tool for "go look at a website" — it does literally what a person does when they Cmd+T and type a URL. The page loads with full JavaScript, cookies, redirects, and captchas just like for a human. New tabs open in the background by default so the user's view doesn't get yanked; the AI's "active tab" follows the new one. Use this for: web search (always via http://localhost:8484/search?q=…, never google.com directly), opening a specific site the user mentioned, opening a result link from a previous search.

Input parameters:

- `bringToFront` (boolean): Whether to bring the new tab to the foreground in the user's window. Default false — new tabs open in the background so the AI doesn't steal focus from the user. Set true only if the user explicitly…
- `evenIfOpen` (boolean): Attached to the user's Chrome only: open a new tab even when one of the user's tabs already has this site open. By default no tab is opened and you are pointed at the existing one, because users pref…
- `sameProfileAs`: Attached to the user's Chrome only: open the tab in the same Chrome profile, with the same logins, as this tab (index or tab id from playwright_list_tabs). When Chrome has several profiles open the d…
- `url` (string): Optional URL to navigate to in the new tab

### `playwright_switch_tab` (~143 tokens)

Change which existing open tab the AI is acting on. By default this does NOT change what the user sees — the user's foreground tab stays put — it only retargets subsequent playwright_* calls. Pass bringToFront=true to also surface the tab in the user's window (only do this if the user explicitly asked to be shown that tab).

Input parameters:

- `bringToFront` (boolean): Whether to also foreground the tab in the user's window. Default false — switches the AI's internal active tab without stealing focus from the user. Set true only if the user explicitly asked to be s…
- `index` (integer, required): Zero-based index of the tab to switch to

### `playwright_list_tabs` (~63 tokens)

List every tab currently open in the real browser window with index, URL, title, and which is the AI-active tab. Use mcp__tabs__tabs_state instead when you can — it also reports user-focus and content previews, and doesn't require a session bootstrap.

### `playwright_user_activity` (~147 tokens)

What the user did in their own browser (clicks, field changes, Enter, form submits, page loads, new tabs) since you last looked. Attached to the user's Chrome only. Use it to work together in one tab: ask the user to do a step (log in, pick something, approve a 2FA prompt), then call this with waitSeconds to see when and what they did. Every other tool result also starts with this report when there is something new. Password and card fields never show values.

Input parameters:

- `waitSeconds` (number): Wait up to this long for the user to do something (returns as soon as they do). Default 0: just report.

### `playwright_close_tab` (~92 tokens)

Close a tab in the user's browser window by index, or the AI-active tab if no index is given. Use this to clean up after you're done with a research tab and don't need it anymore. Refused on the qwen-web TUI tab and on a tab the user is currently looking at.

Input parameters:

- `index` (integer): Zero-based index of the tab to close. Defaults to the current active tab.

### `playwright_type` (~145 tokens)

Type text into a real input field, exactly the way a human types — character by character with optional inter-key delay. Use this for search boxes, sign-in forms, contenteditable elements, or anywhere `set_value` would skip JS-driven autocomplete/validation. Targets either a specific element (by UUID from appium_find_element) or whatever the active tab currently has focused.

Input parameters:

- `delay` (number): Delay between keystrokes in milliseconds. Default is 0 (instant).
- `elementUUID` (string): Optional UUID of the element to type into. If not provided, types into the currently focused element.
- `text` (string, required): The text to type character by character

### `playwright_press_key` (~105 tokens)

Press a keyboard key or key combination on the AI's active tab — same as a human pressing it. Use Enter to submit a form after typing in a search box, Tab to advance focus, ArrowDown to scroll suggestions, etc. Supports modifiers (Control, Shift, Alt, Meta).

Input parameters:

- `key` (string, required): Key to press. Examples: "Enter", "Tab", "Escape", "ArrowDown", "Control+a", "Meta+c", "Shift+Tab"

### `playwright_get_url` (~40 tokens)

Get the URL and title of the AI's currently active tab in the real browser. Useful after a navigation or a click that may have triggered a redirect.

### `appium_documentation_query` (~67 tokens)

Query Appium documentation using RAG (Retrieval-Augmented Generation).
      This tool searches through indexed Appium documentation to answer questions about Appium features, setup, configuration, drivers, and usage.

Input parameters:

- `query` (string, required): The question or query about Appium documentation

## Diagnostics

Captured diagnostic sections: Provenance, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/ihubanov-squire/sniffski-squire#diagnostics

## Score history

- 2026-11-05: 71
- 2026-11-04: 71
- 2026-11-03: 50

## Common questions

### What is the MCP Appium - Mobile Development and Automation Server server?

MCP Appium - Mobile Development and Automation Server is listed in the public MCP registry as io.github.ihubanov/squire. MCP server for Appium mobile automation on iOS and Android devices with test creation tools. This page covers its npm package (@sniffski/squire).

### Is the MCP Appium - Mobile Development and Automation Server server safe to use?

MCP Appium - Mobile Development and Automation Server scores 71 out of 100 on VerifyMCP. We recorded 5 known advisories against it as of 5 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the MCP Appium - Mobile Development and Automation Server server expose?

MCP Appium - Mobile Development and Automation Server exposes 63 tools: select_platform, select_device, create_session, list_sessions, select_session, and 58 more. Their descriptions and schemas cost roughly 7,585 tokens of context every time the server is loaded.

### Is the MCP Appium - Mobile Development and Automation Server server still maintained?

MCP Appium - Mobile Development and Automation Server is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the MCP Appium - Mobile Development and Automation Server server under?

MCP Appium - Mobile Development and Automation Server declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@sniffski/squire
- Socket report: https://socket.dev/npm/package/@sniffski/squire
- Changelog RSS feed: https://verifymcp.io/servers/ihubanov-squire/sniffski-squire.xml
- Changelog JSON feed: https://verifymcp.io/servers/ihubanov-squire/sniffski-squire.json
- HTML version of this page: https://verifymcp.io/servers/ihubanov-squire/sniffski-squire