appium-mcp 1.71.0 → 1.71.2

package/src/devicemanager/adb-manager.ts

@@ -92,6 +92,24 @@ export class ADBManager {
     }
   }
 
+  /**
+   * Get ADB instance for specific device operations
+   * This method ensures we reuse the singleton instance
+   * @param udid Optional device UDID for device-specific operations
+   * @returns Promise<ADB> The ADB instance
+   */
+  public async getADBForDevice(udid?: string): Promise<ADB> {
+    if (!this.isADBInitialized()) {
+      await this.initialize({ udid });
+    }
+
+    if (!this.adbInstance) {
+      throw new Error('ADB instance not available');
+    }
+
+    return this.adbInstance;
+  }
+
   /**
    * Create ADB instance with proper error handling
    * @param options ADB configuration options
@@ -118,24 +136,6 @@ export class ADBManager {
       throw new Error(`ADB initialization failed: ${error}`);
     }
   }
-
-  /**
-   * Get ADB instance for specific device operations
-   * This method ensures we reuse the singleton instance
-   * @param udid Optional device UDID for device-specific operations
-   * @returns Promise<ADB> The ADB instance
-   */
-  public async getADBForDevice(udid?: string): Promise<ADB> {
-    if (!this.isADBInitialized()) {
-      await this.initialize({ udid });
-    }
-
-    if (!this.adbInstance) {
-      throw new Error('ADB instance not available');
-    }
-
-    return this.adbInstance;
-  }
 }
 
 /**

package/src/index.ts

@@ -42,4 +42,4 @@ async function startServer(): Promise<void> {
 }
 
 // Start the server
-startServer();
+void startServer();

package/src/scripts/simple-index-documentation.ts

@@ -90,4 +90,4 @@ async function main(): Promise<void> {
   }
 }
 
-main();
+void main();

package/src/scripts/simple-query-documentation.ts

@@ -58,4 +58,4 @@ async function main(): Promise<void> {
   }
 }
 
-main();
+void main();

package/src/session-store.ts

@@ -109,10 +109,7 @@ export function setSession(
   // `getAppiumSessionCapabilities()` may return metadata fields without the
   // `appium:` prefix, so accept both namespaced and non-namespaced variants.
   const metadata: SessionMetadata = {
-    platform:
-      (capabilities.platformName as string | undefined) ??
-      (capabilities['appium:platformName'] as string | undefined) ??
-      null,
+    platform: (capabilities.platformName as string | undefined) ?? null,
     automationName:
       (capabilities['appium:automationName'] as string | undefined) ??
       (capabilities.automationName as string | undefined) ??
@@ -215,6 +212,13 @@ export function setCurrentContext(
   return true;
 }
 
+export function getSessionInfo(sessionId: string | null): SessionInfo | null {
+  if (!sessionId) {
+    return null;
+  }
+  return sessions.get(sessionId) ?? null;
+}
+
 export function getCurrentContext(sessionId?: string): string | null {
   const id = sessionId ?? activeSessionId;
   if (!id) {

package/src/tools/documentation/reasoning-rag.ts

@@ -60,7 +60,159 @@ export class ReasoningRAG {
   private isInitialized: boolean = false;
 
   constructor() {
-    this.initializeTransformers();
+    void this.initializeTransformers();
+  }
+
+  /**
+   * Enhanced RAG query with reasoning capabilities
+   */
+  async queryWithReasoning(
+    query: string,
+    options: {
+      topK?: number;
+      reasoningTasks?: ReasoningTask[];
+      customConfigs?: ReasoningConfig[];
+    } = {}
+  ): Promise<EnhancedRAGResponse> {
+    const {
+      topK = 50,
+      reasoningTasks = ['summarization', 'question-answering'],
+      customConfigs,
+    } = options;
+
+    try {
+      log.info(`Starting reasoning-enhanced RAG query: "${query}"`);
+
+      // Step 1: Retrieve relevant chunks using existing RAG
+      log.info(`Retrieving top ${topK} relevant chunks...`);
+      const retrievedChunks = await queryVectorStore(query, topK);
+
+      if (!retrievedChunks || retrievedChunks.length === 0) {
+        return {
+          query,
+          retrievedChunks: [],
+          reasoningResults: [],
+          summary: 'No relevant information found in the documentation.',
+          answer: 'No relevant information found to answer your query.',
+          sources: [],
+        };
+      }
+
+      log.info(`Retrieved ${retrievedChunks.length} chunks for reasoning`);
+
+      // Step 2: Configure reasoning models
+      const configs: ReasoningConfig[] = customConfigs || [
+        // Summarization using T5
+        {
+          task: 'summarization',
+          modelName: 'Xenova/t5-small',
+          maxLength: 150,
+          minLength: 30,
+        },
+        // Question answering using DistilBERT
+        {
+          task: 'question-answering',
+          modelName: 'Xenova/distilbert-base-cased-distilled-squad',
+        },
+      ];
+
+      // Filter configs based on requested tasks
+      const filteredConfigs = configs.filter((config) =>
+        reasoningTasks.includes(config.task)
+      );
+
+      // Step 3: Perform reasoning on retrieved chunks
+      log.info(
+        `Performing reasoning with ${filteredConfigs.length} different models...`
+      );
+      const reasoningResults = await this.processChunksWithReasoning(
+        retrievedChunks,
+        filteredConfigs,
+        query
+      );
+
+      // Step 4: Generate comprehensive summary
+      log.info('Generating comprehensive summary...');
+      const summary = await this.generateComprehensiveSummary(
+        reasoningResults,
+        query
+      );
+
+      // Step 5: Extract best answer from reasoning results
+      const qaResults = reasoningResults.filter(
+        (result) =>
+          result.metadata.task === 'question-answering' &&
+          !result.metadata.error
+      );
+
+      const bestAnswer =
+        qaResults.length > 0
+          ? qaResults.sort(
+              (a, b) => (b.confidence || 0) - (a.confidence || 0)
+            )[0].reasoningOutput
+          : summary;
+
+      // Step 6: Extract sources
+      const sources = retrievedChunks
+        .map(
+          (doc: any) =>
+            doc.metadata?.relativePath ||
+            doc.metadata?.filename ||
+            doc.metadata?.source
+        )
+        .filter(
+          (source: any, index: number, arr: any[]) =>
+            source && arr.indexOf(source) === index
+        );
+
+      log.info(
+        `Reasoning-enhanced RAG completed. Generated ${reasoningResults.length} reasoning results from ${sources.length} sources`
+      );
+
+      return {
+        query,
+        retrievedChunks,
+        reasoningResults,
+        summary,
+        answer: bestAnswer,
+        sources,
+      };
+    } catch (error) {
+      log.error('Error in reasoning-enhanced RAG:', error);
+      throw new Error(
+        `Reasoning-enhanced RAG failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Get available reasoning models and their capabilities
+   */
+  getAvailableModels(): Record<ReasoningTask, string[]> {
+    return {
+      summarization: [
+        'Xenova/t5-small',
+        'Xenova/t5-base',
+        'Xenova/bart-large-cnn',
+      ],
+      'question-answering': [
+        'Xenova/distilbert-base-cased-distilled-squad',
+        'Xenova/roberta-base-squad2',
+      ],
+      analysis: ['Xenova/gpt2', 'Xenova/distilgpt2'],
+      classification: [
+        'Xenova/distilbert-base-uncased-finetuned-sst-2-english',
+        'Xenova/bert-base-uncased',
+      ],
+    };
+  }
+
+  /**
+   * Clean up resources
+   */
+  async cleanup(): Promise<void> {
+    this.models.clear();
+    log.info('Reasoning RAG resources cleaned up');
   }
 
   /**
@@ -277,158 +429,6 @@ export class ReasoningRAG {
 
     return comprehensiveSummary;
   }
-
-  /**
-   * Enhanced RAG query with reasoning capabilities
-   */
-  async queryWithReasoning(
-    query: string,
-    options: {
-      topK?: number;
-      reasoningTasks?: ReasoningTask[];
-      customConfigs?: ReasoningConfig[];
-    } = {}
-  ): Promise<EnhancedRAGResponse> {
-    const {
-      topK = 50,
-      reasoningTasks = ['summarization', 'question-answering'],
-      customConfigs,
-    } = options;
-
-    try {
-      log.info(`Starting reasoning-enhanced RAG query: "${query}"`);
-
-      // Step 1: Retrieve relevant chunks using existing RAG
-      log.info(`Retrieving top ${topK} relevant chunks...`);
-      const retrievedChunks = await queryVectorStore(query, topK);
-
-      if (!retrievedChunks || retrievedChunks.length === 0) {
-        return {
-          query,
-          retrievedChunks: [],
-          reasoningResults: [],
-          summary: 'No relevant information found in the documentation.',
-          answer: 'No relevant information found to answer your query.',
-          sources: [],
-        };
-      }
-
-      log.info(`Retrieved ${retrievedChunks.length} chunks for reasoning`);
-
-      // Step 2: Configure reasoning models
-      const configs: ReasoningConfig[] = customConfigs || [
-        // Summarization using T5
-        {
-          task: 'summarization',
-          modelName: 'Xenova/t5-small',
-          maxLength: 150,
-          minLength: 30,
-        },
-        // Question answering using DistilBERT
-        {
-          task: 'question-answering',
-          modelName: 'Xenova/distilbert-base-cased-distilled-squad',
-        },
-      ];
-
-      // Filter configs based on requested tasks
-      const filteredConfigs = configs.filter((config) =>
-        reasoningTasks.includes(config.task)
-      );
-
-      // Step 3: Perform reasoning on retrieved chunks
-      log.info(
-        `Performing reasoning with ${filteredConfigs.length} different models...`
-      );
-      const reasoningResults = await this.processChunksWithReasoning(
-        retrievedChunks,
-        filteredConfigs,
-        query
-      );
-
-      // Step 4: Generate comprehensive summary
-      log.info('Generating comprehensive summary...');
-      const summary = await this.generateComprehensiveSummary(
-        reasoningResults,
-        query
-      );
-
-      // Step 5: Extract best answer from reasoning results
-      const qaResults = reasoningResults.filter(
-        (result) =>
-          result.metadata.task === 'question-answering' &&
-          !result.metadata.error
-      );
-
-      const bestAnswer =
-        qaResults.length > 0
-          ? qaResults.sort(
-              (a, b) => (b.confidence || 0) - (a.confidence || 0)
-            )[0].reasoningOutput
-          : summary;
-
-      // Step 6: Extract sources
-      const sources = retrievedChunks
-        .map(
-          (doc: any) =>
-            doc.metadata?.relativePath ||
-            doc.metadata?.filename ||
-            doc.metadata?.source
-        )
-        .filter(
-          (source: any, index: number, arr: any[]) =>
-            source && arr.indexOf(source) === index
-        );
-
-      log.info(
-        `Reasoning-enhanced RAG completed. Generated ${reasoningResults.length} reasoning results from ${sources.length} sources`
-      );
-
-      return {
-        query,
-        retrievedChunks,
-        reasoningResults,
-        summary,
-        answer: bestAnswer,
-        sources,
-      };
-    } catch (error) {
-      log.error('Error in reasoning-enhanced RAG:', error);
-      throw new Error(
-        `Reasoning-enhanced RAG failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * Get available reasoning models and their capabilities
-   */
-  getAvailableModels(): Record<ReasoningTask, string[]> {
-    return {
-      summarization: [
-        'Xenova/t5-small',
-        'Xenova/t5-base',
-        'Xenova/bart-large-cnn',
-      ],
-      'question-answering': [
-        'Xenova/distilbert-base-cased-distilled-squad',
-        'Xenova/roberta-base-squad2',
-      ],
-      analysis: ['Xenova/gpt2', 'Xenova/distilgpt2'],
-      classification: [
-        'Xenova/distilbert-base-uncased-finetuned-sst-2-english',
-        'Xenova/bert-base-uncased',
-      ],
-    };
-  }
-
-  /**
-   * Clean up resources
-   */
-  async cleanup(): Promise<void> {
-    this.models.clear();
-    log.info('Reasoning RAG resources cleaned up');
-  }
 }
 
 // Export a singleton instance

package/src/tools/documentation/sentence-transformers-embeddings.ts

@@ -21,56 +21,6 @@ export class SentenceTransformersEmbeddings {
     this.modelName = options.modelName || 'Xenova/all-MiniLM-L6-v2';
   }
 
-  /**
-   * Initialize the transformers library dynamically
-   */
-  private async initializeTransformers(): Promise<void> {
-    if (this.transformers) {
-      return;
-    }
-
-    try {
-      // Use eval to avoid CommonJS/ESM conflict during compilation
-      const importTransformers = new Function(
-        'return import("@xenova/transformers")'
-      );
-      this.transformers = await importTransformers();
-    } catch (error) {
-      log.error('Error importing @xenova/transformers:', error);
-      throw new Error(
-        `Failed to import @xenova/transformers: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * Initialize the model lazily
-   */
-  private async initializeModel(): Promise<void> {
-    if (this.isInitialized && this.model) {
-      return;
-    }
-
-    await this.initializeTransformers();
-
-    log.info(`Initializing sentence-transformers model: ${this.modelName}`);
-    try {
-      this.model = await this.transformers.pipeline(
-        'feature-extraction',
-        this.modelName
-      );
-      this.isInitialized = true;
-      log.info(
-        `Successfully initialized sentence-transformers model: ${this.modelName}`
-      );
-    } catch (error) {
-      log.error('Error initializing sentence-transformers model:', error);
-      throw new Error(
-        `Failed to initialize sentence-transformers model: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
   /**
    * Generate embeddings for a single text (LangChain interface)
    */
@@ -141,4 +91,54 @@ export class SentenceTransformersEmbeddings {
       );
     }
   }
+
+  /**
+   * Initialize the transformers library dynamically
+   */
+  private async initializeTransformers(): Promise<void> {
+    if (this.transformers) {
+      return;
+    }
+
+    try {
+      // Use eval to avoid CommonJS/ESM conflict during compilation
+      const importTransformers = new Function(
+        'return import("@xenova/transformers")'
+      );
+      this.transformers = await importTransformers();
+    } catch (error) {
+      log.error('Error importing @xenova/transformers:', error);
+      throw new Error(
+        `Failed to import @xenova/transformers: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Initialize the model lazily
+   */
+  private async initializeModel(): Promise<void> {
+    if (this.isInitialized && this.model) {
+      return;
+    }
+
+    await this.initializeTransformers();
+
+    log.info(`Initializing sentence-transformers model: ${this.modelName}`);
+    try {
+      this.model = await this.transformers.pipeline(
+        'feature-extraction',
+        this.modelName
+      );
+      this.isInitialized = true;
+      log.info(
+        `Successfully initialized sentence-transformers model: ${this.modelName}`
+      );
+    } catch (error) {
+      log.error('Error initializing sentence-transformers model:', error);
+      throw new Error(
+        `Failed to initialize sentence-transformers model: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
 }

package/src/tools/interactions/keyboard.ts

@@ -30,32 +30,6 @@ const schema = z.object({
 
 type KeyboardArgs = z.infer<typeof schema>;
 
-async function handleHide(
-  sessionId: string | undefined,
-  keys: string[] | undefined
-): Promise<ContentResult> {
-  const resolved = resolveDriver(sessionId);
-  if (!resolved.ok) {
-    return resolved.result;
-  }
-  const { driver } = resolved;
-
-  const params = keys && keys.length > 0 ? { keys } : {};
-  await execute(driver, 'mobile: hideKeyboard', params);
-  return textResult('Keyboard dismissed successfully.');
-}
-
-async function handleIsShown(sessionId?: string): Promise<ContentResult> {
-  const resolved = resolveDriver(sessionId);
-  if (!resolved.ok) {
-    return resolved.result;
-  }
-  const { driver } = resolved;
-
-  const keyboardShown = await execute(driver, 'mobile: isKeyboardShown', {});
-  return textResult(JSON.stringify({ keyboardShown }, null, 2));
-}
-
 export default function keyboard(server: FastMCP): void {
   server.addTool({
     name: 'appium_mobile_keyboard',
@@ -90,3 +64,29 @@ export default function keyboard(server: FastMCP): void {
     },
   });
 }
+
+async function handleHide(
+  sessionId: string | undefined,
+  keys: string[] | undefined
+): Promise<ContentResult> {
+  const resolved = resolveDriver(sessionId);
+  if (!resolved.ok) {
+    return resolved.result;
+  }
+  const { driver } = resolved;
+
+  const params = keys && keys.length > 0 ? { keys } : {};
+  await execute(driver, 'mobile: hideKeyboard', params);
+  return textResult('Keyboard dismissed successfully.');
+}
+
+async function handleIsShown(sessionId?: string): Promise<ContentResult> {
+  const resolved = resolveDriver(sessionId);
+  if (!resolved.ok) {
+    return resolved.result;
+  }
+  const { driver } = resolved;
+
+  const keyboardShown = await execute(driver, 'mobile: isKeyboardShown', {});
+  return textResult(JSON.stringify({ keyboardShown }, null, 2));
+}

package/src/tools/session/attach-session.ts

@@ -38,29 +38,6 @@ const METADATA_FIELDS = [
   ['deviceName', 'appium:deviceName', 'appium:deviceName'],
 ] as const;
 
-/**
- * Read capabilities from a WebdriverIO client method when available.
- *
- * @param client - Attached WebdriverIO client for the target Appium session.
- * @param methodName - Capability reader to invoke on the client.
- * @returns Parsed capabilities, or `undefined` when the method is missing or fails.
- */
-async function readClientCapabilities(
-  client: Client,
-  methodName: 'getAppiumSessionCapabilities' | 'getSession'
-): Promise<SessionCapabilities | undefined> {
-  const method = client[methodName];
-  if (typeof method !== 'function') {
-    return undefined;
-  }
-
-  try {
-    return readCapabilities(await method.call(client));
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * Attach MCP Appium to an existing remote Appium session without taking
  * ownership of the underlying session lifecycle.
@@ -154,3 +131,26 @@ export async function attachSessionAction(args: {
     );
   }
 }
+
+/**
+ * Read capabilities from a WebdriverIO client method when available.
+ *
+ * @param client - Attached WebdriverIO client for the target Appium session.
+ * @param methodName - Capability reader to invoke on the client.
+ * @returns Parsed capabilities, or `undefined` when the method is missing or fails.
+ */
+async function readClientCapabilities(
+  client: Client,
+  methodName: 'getAppiumSessionCapabilities' | 'getSession'
+): Promise<SessionCapabilities | undefined> {
+  const method = client[methodName];
+  if (typeof method !== 'function') {
+    return undefined;
+  }
+
+  try {
+    return readCapabilities(await method.call(client));
+  } catch {
+    return undefined;
+  }
+}