appium-mcp 1.1.4 → 1.1.6

package/src/tools/documentation/simple-pdf-indexer.ts

@@ -16,6 +16,7 @@ import { fileURLToPath } from 'url';
 
 // Initialize embeddings using sentence-transformers (no API key required)
 import { SentenceTransformersEmbeddings } from './sentence-transformers-embeddings.js';
+import log from '../../locators/logger.js';
 
 let embeddings: SentenceTransformersEmbeddings | null = null;
 
@@ -30,11 +31,11 @@ function getEmbeddings(): SentenceTransformersEmbeddings {
 
   try {
     // Use local sentence-transformers (no API key required)
-    console.log('Using local sentence-transformers embeddings');
+    log.info('Using local sentence-transformers embeddings');
     const modelName =
       process.env.SENTENCE_TRANSFORMERS_MODEL || 'Xenova/all-MiniLM-L6-v2';
     embeddings = new SentenceTransformersEmbeddings({ modelName });
-    console.log(`Using sentence-transformers model: ${modelName}`);
+    log.info(`Using sentence-transformers model: ${modelName}`);
   } catch (error) {
     throw new Error(
       `Failed to initialize embeddings: ${
@@ -85,12 +86,12 @@ async function saveDocuments(
         if (existingContent) {
           const existingSerialized = JSON.parse(existingContent);
           allSerialized = [...existingSerialized, ...serializedNew];
-          console.log(
+          log.info(
             `Appending ${serializedNew.length} documents to existing ${existingSerialized.length} documents`
           );
         }
       } catch (readError) {
-        console.warn(
+        log.warn(
           'Error reading existing documents, overwriting instead:',
           readError
         );
@@ -99,13 +100,13 @@ async function saveDocuments(
 
     // Write to file
     fs.writeFileSync(DOCUMENTS_PATH, JSON.stringify(allSerialized));
-    console.log(
+    log.info(
       `${
         append ? 'Appended to' : 'Saved'
       } documents in ${DOCUMENTS_PATH} (total: ${allSerialized.length})`
     );
   } catch (error) {
-    console.error('Error saving documents:', error);
+    log.error('Error saving documents:', error);
     throw error;
   }
 }
@@ -117,10 +118,10 @@ async function clearDocumentsFile(): Promise<void> {
   try {
     if (fs.existsSync(DOCUMENTS_PATH)) {
       fs.writeFileSync(DOCUMENTS_PATH, JSON.stringify([]));
-      console.log(`Cleared documents file at ${DOCUMENTS_PATH}`);
+      log.info(`Cleared documents file at ${DOCUMENTS_PATH}`);
     }
   } catch (error) {
-    console.error('Error clearing documents file:', error);
+    log.error('Error clearing documents file:', error);
     throw error;
   }
 }
@@ -132,7 +133,7 @@ async function clearDocumentsFile(): Promise<void> {
 async function loadDocuments(): Promise<Document[] | null> {
   try {
     if (!fs.existsSync(DOCUMENTS_PATH)) {
-      console.log('No saved documents found');
+      log.info('No saved documents found');
       return null;
     }
 
@@ -148,10 +149,10 @@ async function loadDocuments(): Promise<Document[] | null> {
         })
     );
 
-    console.log(`${documents.length} documents loaded from ${DOCUMENTS_PATH}`);
+    log.info(`${documents.length} documents loaded from ${DOCUMENTS_PATH}`);
     return documents;
   } catch (error) {
-    console.error('Error loading documents:', error);
+    log.error('Error loading documents:', error);
     return null;
   }
 }
@@ -166,7 +167,7 @@ async function extractTextFromMarkdown(markdownPath: string): Promise<string> {
     const text = fs.readFileSync(markdownPath, 'utf-8');
     return text;
   } catch (error) {
-    console.error('Error extracting text from Markdown:', error);
+    log.error('Error extracting text from Markdown:', error);
     throw new Error(
       `Failed to extract text from Markdown: ${
         error instanceof Error ? error.message : String(error)
@@ -188,13 +189,13 @@ export async function initializeVectorStore(
   chunkOverlap: number = 200
 ): Promise<MemoryVectorStore> {
   try {
-    console.log(`Initializing vector store for Markdown: ${markdownPath}`);
-    console.log(`Using chunk size: ${chunkSize}, overlap: ${chunkOverlap}`);
+    log.info(`Initializing vector store for Markdown: ${markdownPath}`);
+    log.info(`Using chunk size: ${chunkSize}, overlap: ${chunkOverlap}`);
 
     // Extract text from Markdown
-    console.log('Extracting text from Markdown...');
+    log.info('Extracting text from Markdown...');
     const markdownText = await extractTextFromMarkdown(markdownPath);
-    console.log(`Extracted ${markdownText.length} characters from Markdown`);
+    log.info(`Extracted ${markdownText.length} characters from Markdown`);
 
     // Create text splitter
     const textSplitter = new RecursiveCharacterTextSplitter({
@@ -203,12 +204,12 @@ export async function initializeVectorStore(
     });
 
     // Split text into documents
-    console.log('Splitting text into chunks...');
+    log.info('Splitting text into chunks...');
     const documents = await textSplitter.createDocuments([markdownText]);
-    console.log(`Created ${documents.length} document chunks`);
+    log.info(`Created ${documents.length} document chunks`);
 
     // Store documents in memory vector store
-    console.log('Storing documents in memory vector store...');
+    log.info('Storing documents in memory vector store...');
     const vectorStore = await MemoryVectorStore.fromDocuments(
       documents,
       getEmbeddings()
@@ -220,10 +221,10 @@ export async function initializeVectorStore(
     // Save documents to file for persistence
     await saveDocuments(documents, false); // Don't append for single file indexing
 
-    console.log('Successfully stored documents in memory vector store');
+    log.info('Successfully stored documents in memory vector store');
     return vectorStore;
   } catch (error) {
-    console.error('Error initializing vector store:', error);
+    log.error('Error initializing vector store:', error);
     throw error;
   }
 }
@@ -242,7 +243,7 @@ export async function getMarkdownFilesInDirectory(
 
     // Check if directory exists
     if (!fs.existsSync(dirPath)) {
-      console.error(`Directory does not exist: ${dirPath}`);
+      log.error(`Directory does not exist: ${dirPath}`);
       return [];
     }
 
@@ -268,10 +269,10 @@ export async function getMarkdownFilesInDirectory(
     }
 
     await scanDirectory(dirPath);
-    console.log(`Found ${markdownFiles.length} Markdown files in ${dirPath}`);
+    log.info(`Found ${markdownFiles.length} Markdown files in ${dirPath}`);
     return markdownFiles;
   } catch (error) {
-    console.error('Error getting Markdown files:', error);
+    log.error('Error getting Markdown files:', error);
     return [];
   }
 }
@@ -288,14 +289,14 @@ export async function indexMarkdown(
   chunkOverlap: number = 200
 ): Promise<void> {
   try {
-    console.log('Starting Markdown indexing process...');
+    log.info('Starting Markdown indexing process...');
 
     // Initialize vector store
     await initializeVectorStore(markdownPath, chunkSize, chunkOverlap);
 
-    console.log('Markdown indexing completed successfully');
+    log.info('Markdown indexing completed successfully');
   } catch (error) {
-    console.error('Markdown indexing failed:', error);
+    log.error('Markdown indexing failed:', error);
     throw error;
   }
 }
@@ -313,7 +314,7 @@ export async function indexAllMarkdownFiles(
   chunkOverlap: number = 200
 ): Promise<string[]> {
   try {
-    console.log(
+    log.info(
       `Starting indexing of all Markdown files in directory: ${dirPath}`
     );
 
@@ -321,7 +322,7 @@ export async function indexAllMarkdownFiles(
     const markdownFiles = await getMarkdownFilesInDirectory(dirPath);
 
     if (markdownFiles.length === 0) {
-      console.log('No Markdown files found in the directory');
+      log.info('No Markdown files found in the directory');
       return [];
     }
 
@@ -333,16 +334,14 @@ export async function indexAllMarkdownFiles(
     for (let i = 0; i < markdownFiles.length; i++) {
       const markdownFile = markdownFiles[i];
       try {
-        console.log(
+        log.info(
           `Indexing Markdown ${i + 1}/${markdownFiles.length}: ${markdownFile}`
         );
 
         // Extract text from Markdown
-        console.log('Extracting text from Markdown...');
+        log.info('Extracting text from Markdown...');
         const markdownText = await extractTextFromMarkdown(markdownFile);
-        console.log(
-          `Extracted ${markdownText.length} characters from Markdown`
-        );
+        log.info(`Extracted ${markdownText.length} characters from Markdown`);
 
         // Create text splitter
         const textSplitter = new RecursiveCharacterTextSplitter({
@@ -351,9 +350,9 @@ export async function indexAllMarkdownFiles(
         });
 
         // Split text into documents
-        console.log('Splitting text into chunks...');
+        log.info('Splitting text into chunks...');
         const documents = await textSplitter.createDocuments([markdownText]);
-        console.log(`Created ${documents.length} document chunks`);
+        log.info(`Created ${documents.length} document chunks`);
 
         // Add file metadata to each document
         const filename = path.basename(markdownFile);
@@ -368,7 +367,7 @@ export async function indexAllMarkdownFiles(
         });
 
         // Store documents in memory vector store
-        console.log('Storing documents in memory vector store...');
+        log.info('Storing documents in memory vector store...');
         if (i === 0) {
           // For the first Markdown file, create a new vector store
           memoryVectorStore = await MemoryVectorStore.fromDocuments(
@@ -384,19 +383,19 @@ export async function indexAllMarkdownFiles(
         await saveDocuments(documents, i > 0);
 
         indexedFiles.push(markdownFile);
-        console.log(`Successfully indexed Markdown: ${filename}`);
+        log.info(`Successfully indexed Markdown: ${filename}`);
       } catch (error) {
-        console.error(`Error indexing Markdown ${markdownFile}:`, error);
+        log.error(`Error indexing Markdown ${markdownFile}:`, error);
         // Continue with next file even if one fails
       }
     }
 
-    console.log(
+    log.info(
       `Successfully indexed ${indexedFiles.length} out of ${markdownFiles.length} Markdown files`
     );
     return indexedFiles;
   } catch (error) {
-    console.error('Error indexing all Markdown files:', error);
+    log.error('Error indexing all Markdown files:', error);
     throw error;
   }
 }
@@ -419,7 +418,7 @@ export async function queryVectorStore(
 
       // If documents exist, create a new vector store
       if (documents && documents.length > 0) {
-        console.log('Creating vector store from saved documents...');
+        log.info('Creating vector store from saved documents...');
         memoryVectorStore = await MemoryVectorStore.fromDocuments(
           documents,
           getEmbeddings()
@@ -436,7 +435,7 @@ export async function queryVectorStore(
 
     return results;
   } catch (error) {
-    console.error('Error querying vector store:', error);
+    log.error('Error querying vector store:', error);
     throw error;
   }
 }
@@ -477,32 +476,30 @@ if (import.meta.url === `file://${process.argv[1]}`) {
   }
 
   // Log embeddings provider that will be used
-  console.log('Using sentence-transformers embeddings (no API key required)');
+  log.info('Using sentence-transformers embeddings (no API key required)');
 
   // Run the indexing process
   if (indexSingleFile) {
     // Index a single Markdown file
-    console.log(`Indexing single Markdown file: ${markdownPath}`);
+    log.info(`Indexing single Markdown file: ${markdownPath}`);
     indexMarkdown(markdownPath, chunkSize, chunkOverlap)
       .then(() => {
         process.exit(0);
       })
       .catch(error => {
-        console.error('Indexing failed:', error);
+        log.error('Indexing failed:', error);
         process.exit(1);
       });
   } else {
     // Index all Markdown files in the directory
-    console.log(`Indexing all Markdown files in directory: ${markdownPath}`);
+    log.info(`Indexing all Markdown files in directory: ${markdownPath}`);
     indexAllMarkdownFiles(markdownPath, chunkSize, chunkOverlap)
       .then(indexedFiles => {
-        console.log(
-          `Successfully indexed ${indexedFiles.length} Markdown files`
-        );
+        log.info(`Successfully indexed ${indexedFiles.length} Markdown files`);
         process.exit(0);
       })
       .catch(error => {
-        console.error('Indexing failed:', error);
+        log.error('Indexing failed:', error);
         process.exit(1);
       });
   }

package/src/tools/index.ts

@@ -31,6 +31,7 @@ import clickElement from './interactions/click.js';
 import doubleTap from './interactions/double-tap.js';
 import setValue from './interactions/set-value.js';
 import getText from './interactions/get-text.js';
+import getPageSource from './interactions/get-page-source.js';
 import screenshot from './interactions/screenshot.js';
 import activateApp from './interactions/activate-app.js';
 import installApp from './interactions/install-app.js';
@@ -127,6 +128,7 @@ export default function registerTools(server: FastMCP): void {
   doubleTap(server);
   setValue(server);
   getText(server);
+  getPageSource(server);
   screenshot(server);
   generateTest(server);
   log.info('All tools registered');

package/src/tools/install-wda.ts

@@ -9,6 +9,7 @@ import { access, readdir, stat } from 'fs/promises';
 import { constants } from 'fs';
 import fs from 'fs'; // Keep for createWriteStream if used
 import os from 'os';
+import log from '../locators/logger.js';
 
 const execAsync = promisify(exec);
 
@@ -228,7 +229,7 @@ export default function installWDA(server: any): void {
           );
         }
 
-        console.log(
+        log.info(
           `Installing WDA from ${appPath} on simulator ${targetSimulator}...`
         );
 
@@ -250,14 +251,14 @@ export default function installWDA(server: any): void {
         // Install the app (only if not already installed)
         if (!isInstalled) {
           await installAppOnSimulator(appPath, targetSimulator);
-          console.log('WDA app installed successfully');
+          log.info('WDA app installed successfully');
         } else {
-          console.log('WDA app already installed, skipping installation');
+          log.info('WDA app already installed, skipping installation');
         }
 
         // Get bundle ID and launch the app
         const bundleId = await getAppBundleId(appPath);
-        console.log(`Launching WDA with bundle ID: ${bundleId}`);
+        log.info(`Launching WDA with bundle ID: ${bundleId}`);
         await launchAppOnSimulator(bundleId, targetSimulator);
 
         return {
@@ -269,7 +270,7 @@ export default function installWDA(server: any): void {
           ],
         };
       } catch (error: any) {
-        console.error('Error installing WDA:', error);
+        log.error('Error installing WDA:', error);
         throw new Error(`Failed to install WebDriverAgent: ${error.message}`);
       }
     },

package/src/tools/interactions/get-page-source.ts

@@ -0,0 +1,52 @@
+import { FastMCP } from 'fastmcp/dist/FastMCP.js';
+import { z } from 'zod';
+import { getDriver } from '../session-store.js';
+
+export default function getPageSource(server: FastMCP): void {
+  server.addTool({
+    name: 'appium_get_page_source',
+    description: 'Get the page source (XML) from the current screen',
+    parameters: z.object({}),
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false,
+    },
+    execute: async (args: any, context: any): Promise<any> => {
+      const driver = getDriver();
+      if (!driver) {
+        throw new Error('No driver found. Please create a session first.');
+      }
+
+      try {
+        const pageSource = await driver.getPageSource();
+
+        if (!pageSource) {
+          throw new Error('Page source is empty or null');
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text:
+                'Page source retrieved successfully: \n' +
+                '```xml ' +
+                pageSource +
+                '```',
+            },
+          ],
+        };
+      } catch (err: any) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Failed to get page source. Error: ${err.toString()}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  });
+}

package/src/tools/locators.ts

@@ -12,6 +12,7 @@
 import { z } from 'zod';
 import { getDriver } from './session-store.js';
 import { generateAllElementLocators } from '../locators/generate-all-locators.js';
+import log from '../locators/logger.js';
 
 export default function generateLocators(server: any): void {
   server.addTool({
@@ -34,8 +35,6 @@ export default function generateLocators(server: any): void {
           );
         }
 
-        console.log('Getting page source');
-
         try {
           // Get the page source from the driver
           const pageSource = await driver.getPageSource();
@@ -71,11 +70,11 @@ export default function generateLocators(server: any): void {
             ],
           };
         } catch (parseError: any) {
-          console.error('Error parsing XML:', parseError);
+          log.error('Error parsing XML:', parseError);
           throw new Error(`Failed to parse XML: ${parseError.message}`);
         }
       } catch (error: any) {
-        console.error('Error getting page source:', error);
+        log.error('Error getting page source:', error);
         throw new Error(`Failed to get page source: ${error.message}`);
       }
     },

package/src/tools/scroll.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { getDriver, getPlatformName } from './session-store.js';
+import log from '../locators/logger.js';
 
 export default function scroll(server: any): void {
   server.addTool({
@@ -25,7 +26,7 @@ export default function scroll(server: any): void {
 
       try {
         const { width, height } = await driver.getWindowSize();
-        console.log('Device screen size:', { width, height });
+        log.info('Device screen size:', { width, height });
         const startX = Math.floor(width / 2);
         // calculate start and end Y positions for scrolling depending on the direction
         // startY is at 80% of the height, endY is at 20% of the height for downward scroll
@@ -42,8 +43,8 @@ export default function scroll(server: any): void {
             ? Math.floor(height * 0.2)
             : Math.floor(height * 0.8);
 
-        console.log('Going to scroll from:', { startX, startY });
-        console.log('Going to scroll to:', { startX, endY });
+        log.info('Going to scroll from:', { startX, startY });
+        log.info('Going to scroll to:', { startX, endY });
 
         if (getPlatformName(driver) === 'Android') {
           await driver.performActions([
@@ -60,7 +61,7 @@ export default function scroll(server: any): void {
               ],
             },
           ]);
-          console.log('Scroll action completed successfully.');
+          log.info('Scroll action completed successfully.');
         } else if (getPlatformName(driver) === 'iOS') {
           await driver.execute('mobile: scroll', {
             direction: args.direction,

package/src/tools/session-store.ts

@@ -1,5 +1,6 @@
 import { AndroidUiautomator2Driver } from 'appium-uiautomator2-driver';
 import { XCUITestDriver } from 'appium-xcuitest-driver';
+import log from '../locators/logger.js';
 
 let driver: any = null;
 let sessionId: string | null = null;
@@ -33,13 +34,13 @@ export function hasActiveSession(): boolean {
 export async function safeDeleteSession(): Promise<boolean> {
   // Check if there's no session to delete
   if (!driver || !sessionId) {
-    console.log('No active session to delete.');
+    log.info('No active session to delete.');
     return false;
   }
 
   // Check if deletion is already in progress
   if (isDeletingSession) {
-    console.log('Session deletion already in progress, skipping...');
+    log.info('Session deletion already in progress, skipping...');
     return false;
   }
 
@@ -47,17 +48,17 @@ export async function safeDeleteSession(): Promise<boolean> {
   isDeletingSession = true;
 
   try {
-    console.log('Deleting current session');
+    log.info('Deleting current session');
     await driver.deleteSession();
 
     // Clear the session from store
     driver = null;
     sessionId = null;
 
-    console.log('Session deleted successfully.');
+    log.info('Session deleted successfully.');
     return true;
   } catch (error) {
-    console.error('Error deleting session:', error);
+    log.error('Error deleting session:', error);
     throw error;
   } finally {
     // Always release lock