@nbakka/mcp-appium 1.0.28 → 2.0.0

package/lib/webdriver-agent.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDriverAgent = void 0;
+const robot_1 = require("./robot");
+class WebDriverAgent {
+    host;
+    port;
+    constructor(host, port) {
+        this.host = host;
+        this.port = port;
+    }
+    async isRunning() {
+        const url = `http://${this.host}:${this.port}/status`;
+        try {
+            const response = await fetch(url);
+            return response.status === 200;
+        }
+        catch (error) {
+            console.error(`Failed to connect to WebDriverAgent: ${error}`);
+            return false;
+        }
+    }
+    async createSession() {
+        const url = `http://${this.host}:${this.port}/session`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ capabilities: { alwaysMatch: { platformName: "iOS" } } }),
+        });
+        const json = await response.json();
+        return json.value.sessionId;
+    }
+    async deleteSession(sessionId) {
+        const url = `http://${this.host}:${this.port}/session/${sessionId}`;
+        const response = await fetch(url, { method: "DELETE" });
+        return response.json();
+    }
+    async withinSession(fn) {
+        const sessionId = await this.createSession();
+        const url = `http://${this.host}:${this.port}/session/${sessionId}`;
+        const result = await fn(url);
+        await this.deleteSession(sessionId);
+        return result;
+    }
+    async getScreenSize() {
+        return this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/wda/screen`;
+            const response = await fetch(url);
+            const json = await response.json();
+            return {
+                width: json.value.screenSize.width,
+                height: json.value.screenSize.height,
+                scale: json.value.scale || 1,
+            };
+        });
+    }
+    async sendKeys(keys) {
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/wda/keys`;
+            await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ value: [keys] }),
+            });
+        });
+    }
+    async pressButton(button) {
+        const _map = {
+            "HOME": "home",
+            "VOLUME_UP": "volumeup",
+            "VOLUME_DOWN": "volumedown",
+        };
+        if (button === "ENTER") {
+            await this.sendKeys("\n");
+            return;
+        }
+        // Type assertion to check if button is a key of _map
+        if (!(button in _map)) {
+            throw new robot_1.ActionableError(`Button "${button}" is not supported`);
+        }
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/wda/pressButton`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    name: button,
+                }),
+            });
+            return response.json();
+        });
+    }
+    async tap(x, y) {
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/actions`;
+            await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    actions: [
+                        {
+                            type: "pointer",
+                            id: "finger1",
+                            parameters: { pointerType: "touch" },
+                            actions: [
+                                { type: "pointerMove", duration: 0, x, y },
+                                { type: "pointerDown", button: 0 },
+                                { type: "pause", duration: 100 },
+                                { type: "pointerUp", button: 0 }
+                            ]
+                        }
+                    ]
+                }),
+            });
+        });
+    }
+    isVisible(rect) {
+        return rect.x >= 0 && rect.y >= 0;
+    }
+    filterSourceElements(source) {
+        const output = [];
+        const acceptedTypes = ["TextField", "Button", "Switch", "Icon", "SearchField", "StaticText", "Image"];
+        if (acceptedTypes.includes(source.type)) {
+            if (source.isVisible === "1" && this.isVisible(source.rect)) {
+                if (source.label !== null || source.name !== null) {
+                    output.push({
+                        type: source.type,
+                        label: source.label,
+                        name: source.name,
+                        value: source.value,
+                        rect: {
+                            x: source.rect.x,
+                            y: source.rect.y,
+                            width: source.rect.width,
+                            height: source.rect.height,
+                        },
+                    });
+                }
+            }
+        }
+        if (source.children) {
+            for (const child of source.children) {
+                output.push(...this.filterSourceElements(child));
+            }
+        }
+        return output;
+    }
+    async getPageSource() {
+        const url = `http://${this.host}:${this.port}/source/?format=json`;
+        const response = await fetch(url);
+        const json = await response.json();
+        return json;
+    }
+    async getElementsOnScreen() {
+        const source = await this.getPageSource();
+        return this.filterSourceElements(source.value);
+    }
+    async openUrl(url) {
+        await this.withinSession(async (sessionUrl) => {
+            await fetch(`${sessionUrl}/url`, {
+                method: "POST",
+                body: JSON.stringify({ url }),
+            });
+        });
+    }
+    async swipe(direction) {
+        await this.withinSession(async (sessionUrl) => {
+            const x0 = 200;
+            let y0 = 600;
+            const x1 = 200;
+            let y1 = 200;
+            if (direction === "up") {
+                const tmp = y0;
+                y0 = y1;
+                y1 = tmp;
+            }
+            const url = `${sessionUrl}/actions`;
+            await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    actions: [
+                        {
+                            type: "pointer",
+                            id: "finger1",
+                            parameters: { pointerType: "touch" },
+                            actions: [
+                                { type: "pointerMove", duration: 0, x: x0, y: y0 },
+                                { type: "pointerDown", button: 0 },
+                                { type: "pointerMove", duration: 0, x: x1, y: y1 },
+                                { type: "pause", duration: 1000 },
+                                { type: "pointerUp", button: 0 }
+                            ]
+                        }
+                    ]
+                }),
+            });
+        });
+    }
+    async setOrientation(orientation) {
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/orientation`;
+            await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    orientation: orientation.toUpperCase()
+                })
+            });
+        });
+    }
+    async getOrientation() {
+        return this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/orientation`;
+            const response = await fetch(url);
+            const json = await response.json();
+            return json.value.toLowerCase();
+        });
+    }
+}
+exports.WebDriverAgent = WebDriverAgent;

package/package.json

@@ -1,24 +1,52 @@
 {
   "name": "@nbakka/mcp-appium",
-  "version": "1.0.28",
-  "description": "Selenium WebDriver MCP Server",
-  "type": "module",
-  "main": "src/lib/server.js",
-  "bin": {
-    "mcp-appium": "./src/lib/server.js"
+  "version": "2.0.0",
+  "description": "Appium MCP",
+  "engines": {
+    "node": ">=18"
   },
+  "license": "Apache-2.0",
   "scripts": {
-"start": "node src/lib/server.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc && chmod +x lib/index.js",
+    "lint": "eslint .",
+    "test": "nyc mocha --require ts-node/register test/*.ts",
+    "watch": "tsc --watch",
+    "clean": "rm -rf lib",
+    "prepare": "husky"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "files": [
+    "lib"
+  ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.7.0",
-     "axios": "^1.4.0",
-    "zod": "^3.22.2",
-    "yargs": "^17.7.2",
-"xml2js": "0.6.2"
-  }
-}
+    "@modelcontextprotocol/sdk": "^1.6.1",
+    "fast-xml-parser": "^5.0.9",
+    "zod-to-json-schema": "^3.24.4"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.19.0",
+    "@stylistic/eslint-plugin": "^3.0.1",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.13.10",
+    "@typescript-eslint/eslint-plugin": "^8.28.0",
+    "@typescript-eslint/parser": "^8.26.1",
+    "@typescript-eslint/utils": "^8.26.1",
+    "eslint": "^9.19.0",
+    "eslint-plugin": "^1.0.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-notice": "^1.0.0",
+    "husky": "^9.1.7",
+    "nyc": "^17.1.0",
+    "mocha": "^11.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  },
+  "main": "index.js",
+  "bin": {
+    "mcp-server-mobile": "lib/index.js"
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "author": "nbakka"
+}

package/bin/mcp-appium.js

@@ -1,57 +0,0 @@
-#!/usr/bin/env node
-
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-import { spawn } from 'child_process';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const serverPath = resolve(__dirname, '../src/lib/server.js');
-
-// Start the server
-const child = spawn('node', [serverPath], {
-    stdio: 'inherit'
-});
-
-child.on('error', (error) => {
-    console.error(`Error starting server: ${error.message}`);
-    process.exit(1);
-});
-
-// Handle process termination
-process.on('SIGTERM', () => {
-    child.kill('SIGTERM');
-});
-
-process.on('SIGINT', () => {
-    child.kill('SIGINT');
-});#!/usr/bin/env node
-
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-import { spawn } from 'child_process';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const serverPath = resolve(__dirname, '../src/lib/server.js');
-
-// Start the server
-const child = spawn('node', [serverPath], {
-    stdio: 'inherit'
-});
-
-child.on('error', (error) => {
-    console.error(`Error starting server: ${error.message}`);
-    process.exit(1);
-});
-
-// Handle process termination
-process.on('SIGTERM', () => {
-    child.kill('SIGTERM');
-});
-
-process.on('SIGINT', () => {
-    child.kill('SIGINT');
-});

package/src/lib/server.js

@@ -1,237 +0,0 @@
-#!/usr/bin/env node
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import axios from "axios";
-import { exec } from "child_process";
-import { parseStringPromise } from "xml2js";
-
-
-const APPIUM_URL = "http://127.0.0.1:4723";  // Corrected endpoint for Appium 2.x
-
-const server = new McpServer({ name: "MCP Appium JSONWire", version: "1.0.0" });
-const state = { sessionId: null };
-
-// Helper to extract element ID
-function extractElementId(element) {
-  return element.ELEMENT || element["element-6066-11e4-a52e-4f735466cecf"];
-}
-
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-// Start Session tool
-server.tool(
-  "start_session",
-  "Start Appium session with capabilities",
-  {
-    capabilities: z.object({
-      platformName: z.string(),
-      udid: z.string(),
-      automationName: z.string(),
-      app: z.string().optional(),
-    }),
-  },
-  async ({ capabilities }) => {
-    try {
-      // Construct capabilities strictly with prefixes
-      const alwaysMatch = {
-        platformName: capabilities.platformName,
-        "appium:udid": capabilities.udid,
-        "appium:automationName": capabilities.automationName,
-      };
-      if (capabilities.app) {
-        alwaysMatch["appium:app"] = capabilities.app;
-      }
-
-      const payload = {
-        capabilities: {
-          firstMatch: [{}],
-          alwaysMatch,
-        },
-      };
-
-      const response = await axios.post(`${APPIUM_URL}/session`, payload);
-      state.sessionId = response.data.value.sessionId;
-      state.deviceId = capabilities.udid;
-      await delay(10000);
-      return { content: [{ type: "text", text: `Session started: ${state.sessionId}` }] };
-    } catch (e) {
-      return { content: [{ type: "text", text: `Error starting session: ${e.message}` }] };
-    }
-  }
-);
-
-
-// Tap tool
-server.tool(
-  "tap",
-  "Tap element by locator",
-  {
-    by: z.enum(["id", "accessibility id", "xpath", "class name", "name"]),
-    value: z.string(),
-  },
-  async ({ by, value }) => {
-    if (!state.sessionId) return { content: [{ type: "text", text: "No active session" }] };
-    try {
-      const findResp = await axios.post(`${APPIUM_URL}/session/${state.sessionId}/element`, { using: by, value });
-      const elementId = extractElementId(findResp.data.value);
-      await axios.post(`${APPIUM_URL}/session/${state.sessionId}/element/${elementId}/click`);
-      return { content: [{ type: "text", text: "Element tapped" }] };
-    } catch (e) {
-      return { content: [{ type: "text", text: `Error tapping element: ${e.message}` }] };
-    }
-  }
-);
-
-// Swipe tool
-server.tool(
-  "swipe",
-  "Swipe from start to end coordinates",
-  {
-    startX: z.number(),
-    startY: z.number(),
-    endX: z.number(),
-    endY: z.number(),
-    duration: z.number().optional(),
-  },
-  async ({ startX, startY, endX, endY, duration = 800 }) => {
-    if (!state.sessionId) return { content: [{ type: "text", text: "No active session" }] };
-    try {
-      const actions = [
-        { action: "press", options: { x: startX, y: startY } },
-        { action: "wait", options: { ms: duration } },
-        { action: "moveTo", options: { x: endX, y: endY } },
-        { action: "release", options: {} },
-      ];
-      await axios.post(`${APPIUM_URL}/session/${state.sessionId}/touch/perform`, { actions });
-      return { content: [{ type: "text", text: `Swiped from (${startX},${startY}) to (${endX},${endY})` }] };
-    } catch (e) {
-      return { content: [{ type: "text", text: `Error swiping: ${e.message}` }] };
-    }
-  }
-);
-
-// Open Deep Link
-server.tool(
-  "open_deep_link_adb",
-  "Open deep link on device via ADB shell",
-  {
-    deepLink: z.string(),
-  },
-  async ({ deepLink }) => {
-    if (!state.deviceId) {
-      return { content: [{ type: "text", text: "No connected device found" }] };
-    }
-
-    const command = `adb -s ${state.deviceId} shell am start -a android.intent.action.VIEW -d "${deepLink}"`;
-
-    return new Promise((resolve) => {
-      exec(command, (error, stdout, stderr) => {
-        if (error) {
-          resolve({ content: [{ type: "text", text: `Error executing ADB command: ${error.message}` }] });
-          return;
-        }
-        if (stderr) {
-          resolve({ content: [{ type: "text", text: `ADB stderr: ${stderr}` }] });
-          return;
-        }
-        resolve({ content: [{ type: "text", text: `Deep link opened via ADB: ${deepLink}` }] });
-      });
-    });
-  }
-);
-
-// Get visible text elements including duplicates
-server.tool(
-  "get_visible_text_elements",
-  "Get all visible texts from screen XML source including duplicates",
-  {},
-  async () => {
-    if (!state.sessionId) return { content: [{ type: "text", text: "No active session" }] };
-    try {
-      const response = await axios.get(`${APPIUM_URL}/session/${state.sessionId}/source`);
-      const xml = response.data;
-	console.log(response.data);
-      const parsed = await parseStringPromise(xml, { explicitArray: false, mergeAttrs: true });
-
-      function collectTextsFromXml(node, texts = []) {
-        if (!node) return texts;
-
-        // If array, recurse each element
-        if (Array.isArray(node)) {
-          node.forEach(child => collectTextsFromXml(child, texts));
-          return texts;
-        }
-
-        // If node has 'text' attribute with non-empty value, collect it
-        if (node.text && node.text.trim() !== "") {
-          texts.push(node.text.trim());
-        }
-
-        // Recurse into all children nodes
-        for (const key in node) {
-          if (key !== "text" && typeof node[key] === "object") {
-            collectTextsFromXml(node[key], texts);
-          }
-        }
-        return texts;
-      }
-
-      const allTexts = collectTextsFromXml(parsed);
-      return { content: [{ type: "json", json: allTexts }] };
-    } catch (e) {
-      return { content: [{ type: "text", text: `Error fetching or parsing source XML: ${e.message}` }] };
-    }
-  }
-);
-
-// Click element by text with optional index (default 0)
-server.tool(
-  "click_by_text",
-  "Click element by visible text with optional index",
-  {
-    text: z.string(),
-    index: z.number().optional().default(0),
-  },
-  async ({ text, index }) => {
-    if (!state.sessionId) return { content: [{ type: "text", text: "No active session" }] };
-    try {
-      const xpath = `(//*[normalize-space(@text)='${text}'])[${index + 1}]`;
-      const findResp = await axios.post(`${APPIUM_URL}/session/${state.sessionId}/element`, { using: "xpath", value: xpath });
-      const elementId = extractElementId(findResp.data.value);
-      await axios.post(`${APPIUM_URL}/session/${state.sessionId}/element/${elementId}/click`);
-      return { content: [{ type: "text", text: `Clicked element with text: "${text}" at index ${index}` }] };
-    } catch (e) {
-      return { content: [{ type: "text", text: `Error clicking element: ${e.message}` }] };
-    }
-  }
-);
-
-
-
-
-
-// Close Session tool
-server.tool(
-  "close_session",
-  "Close the current Appium session",
-  {},
-  async () => {
-    if (!state.sessionId) return { content: [{ type: "text", text: "No active session" }] };
-    try {
-      await axios.delete(`${APPIUM_URL}/session/${state.sessionId}`);
-      const oldSession = state.sessionId;
-      state.sessionId = null;
-      return { content: [{ type: "text", text: `Session ${oldSession} closed` }] };
-    } catch (e) {
-      return { content: [{ type: "text", text: `Error closing session: ${e.message}` }] };
-    }
-  }
-);
-
-// Connect MCP server to stdio
-const transport = new StdioServerTransport();
-await server.connect(transport);