@nbakka/mcp-appium 3.0.22 → 3.0.24

package/lib/server.js

@@ -215,32 +215,259 @@ const createMcpServer = () => {
 //   }
 // );
 
- tool(
-   "mobile_learn_testcases_generation_context",
-   "Reads previously saved app context notes and returns them so they can be used to validate or update test cases. This should be executed before generating manual test cases.",
-   {},
-   async () => {
-     try {
-       // Read app context notes from file
-       const notesFilePath = path.join(__dirname, "app_context.txt");
-       const fileContent = await fs.readFile(notesFilePath, "utf-8");
-
-       const notes = fileContent
-         .split("\n")
-         .map(line => line.trim())
-         .filter(line => line.length > 0);
-
-       if (notes.length === 0) {
-         return "No app context notes found.";
-       }
-
-       return `App context loaded for testcase generation: ${JSON.stringify({ notes })}`;
-     } catch (error) {
-       return `Error reading app context notes: ${error.message}`;
-     }
-   }
- );
+// Tool 1: Fetch incomplete test case
+tool(
+  "mobile_fetch_incomplete_testcase",
+  "Fetches the first test case from a Google Sheet that has blank test steps but has a value in 'UT v/s Automation' column. Returns the test scenario and row number for later update.",
+  {
+    sheetName: zod_1.z.string().describe("The name of the Google Sheet tab to fetch test case data from").default("TestCases"),
+  },
+  async ({ sheetName }) => {
+    try {
+      // Load Google Sheets credentials
+      const keyFile = path.join(os.homedir(), 'Desktop', 'secret.json');
+
+      const auth = new google.auth.GoogleAuth({
+        keyFile,
+        scopes: ['https://www.googleapis.com/auth/spreadsheets.readonly'],
+      });
+
+      const authClient = await auth.getClient();
+      const sheets = google.sheets({ version: 'v4', auth: authClient });
+      const spreadsheetId = '1jAilVUeQW99JUYj1KL4jovoxeWGUnsIcY_nMJR5H6dc';
+
+      const range = `${sheetName}!A1:Z1000`;
+      const res = await sheets.spreadsheets.values.get({ spreadsheetId, range });
+      const rows = res.data.values;
+
+      if (!rows || rows.length === 0) {
+        return `Sheet "${sheetName}" is empty or does not exist.`;
+      }
+
+      // Map headers (trimmed, case-sensitive)
+      const header = rows[0].map(h => h.toString().trim());
+
+      // Find required column indices
+      const testCasesIdx = header.indexOf('Testcases');
+      const testStepsIdx = header.indexOf('Test Steps');
+      const utVsAutomationIdx = header.indexOf('UT v/s Automation');
+
+      if (testCasesIdx === -1 || testStepsIdx === -1 || utVsAutomationIdx === -1) {
+        return `Required columns "Testcases", "Test Steps", and/or "UT v/s Automation" not found in sheet "${sheetName}". Available columns: ${header.join(', ')}`;
+      }
+
+      // Find first row with empty test steps and non-empty UT v/s Automation
+      for (let i = 1; i < rows.length; i++) {
+        const row = rows[i];
+        const testSteps = row[testStepsIdx] ? row[testStepsIdx].toString().trim() : '';
+        const utVsAutomation = row[utVsAutomationIdx] ? row[utVsAutomationIdx].toString().trim() : '';
+        const testScenario = row[testCasesIdx] ? row[testCasesIdx].toString().trim() : '';
+
+        // Check if test steps are empty, UT v/s Automation is not empty, and test scenario exists
+        if (!testSteps && utVsAutomation && testScenario) {
+          // Convert column index to letter (A, B, C, etc.)
+          const columnLetter = String.fromCharCode(65 + testStepsIdx);
+          const rowNumber = i + 1; // +1 because spreadsheet rows are 1-indexed
+
+          return JSON.stringify({
+            testScenario: testScenario,
+            sheetName: sheetName,
+            rowNumber: rowNumber,
+            columnLetter: columnLetter,
+            cellReference: `${columnLetter}${rowNumber}`
+          });
+        }
+      }
+
+      return `No test cases found with blank test steps and non-empty "UT v/s Automation" in sheet "${sheetName}".`;
+
+    } catch (error) {
+      return `Error fetching incomplete test case: ${error.message}`;
+    }
+  }
+);
+
+// Tool 2: Update Test Steps
+tool(
+  "mobile_update_test_steps",
+  "Updates the Test Steps cell in Google Sheet for a specific test case. Use the sheetName, rowNumber, and columnLetter obtained from mobile_fetch_incomplete_testcase tool.",
+  {
+    sheetName: zod_1.z.string().describe("The name of the Google Sheet tab"),
+    rowNumber: zod_1.z.number().describe("The row number to update (from fetch tool)"),
+    columnLetter: zod_1.z.string().describe("The column letter for Test Steps (from fetch tool)"),
+    testSteps: zod_1.z.string().describe("The test steps content to write into the cell"),
+  },
+  async ({ sheetName, rowNumber, columnLetter, testSteps }) => {
+    try {
+      // Load Google Sheets credentials with write permissions
+      const keyFile = path.join(os.homedir(), 'Desktop', 'secret.json');
 
+      const auth = new google.auth.GoogleAuth({
+        keyFile,
+        scopes: ['https://www.googleapis.com/auth/spreadsheets'], // Full read/write access
+      });
+
+      const authClient = await auth.getClient();
+      const sheets = google.sheets({ version: 'v4', auth: authClient });
+      const spreadsheetId = '1jAilVUeQW99JUYj1KL4jovoxeWGUnsIcY_nMJR5H6dc';
+
+      // Construct the cell reference (e.g., "TestCases!C5")
+      const cellReference = `${sheetName}!${columnLetter}${rowNumber}`;
+
+      // Update the cell
+      const updateRes = await sheets.spreadsheets.values.update({
+        spreadsheetId,
+        range: cellReference,
+        valueInputOption: 'RAW',
+        resource: {
+          values: [[testSteps]]
+        }
+      });
+
+      if (updateRes.status === 200) {
+        return `Successfully updated Test Steps at ${cellReference} with content: "${testSteps.substring(0, 100)}${testSteps.length > 100 ? '...' : ''}"`;
+      } else {
+        return `Failed to update Test Steps. Status: ${updateRes.status}`;
+      }
+
+    } catch (error) {
+      return `Error updating test steps: ${error.message}`;
+    }
+  }
+);
+
+tool(
+  "mobile_learn_teststeps_generation_guidelines",
+  "Reads previously saved test steps generation guidelines and returns them so they can be used to validate or update test steps. This should be executed before generating manual test steps.",
+  {},
+  async () => {
+    try {
+      // Read test steps generation guidelines from Desktop
+      const guidelinesFilePath = path.join(os.homedir(), 'Desktop', 'teststeps_generation_guidelines.txt');
+      const fileContent = await fs.readFile(guidelinesFilePath, "utf-8");
+
+      const guidelines = fileContent
+        .split("\n")
+        .map(line => line.trim())
+        .filter(line => line.length > 0);
+
+      if (guidelines.length === 0) {
+        return "No test steps generation guidelines found.";
+      }
+
+      return `Test steps generation guidelines loaded: ${JSON.stringify({ guidelines })}`;
+    } catch (error) {
+      return `Error reading test steps generation guidelines: ${error.message}`;
+    }
+  }
+);
+
+// Tool 3: Update Test Scenario (Always appends with green color)
+tool(
+  "mobile_update_test_scenario",
+  "Updates the Test Scenario (Testcases column) in Google Sheet for outdated scenarios. Always keeps the existing scenario and adds the updated scenario in green color on a new line.",
+  {
+    sheetName: zod_1.z.string().describe("The name of the Google Sheet tab"),
+    rowNumber: zod_1.z.number().describe("The row number to update"),
+    columnLetter: zod_1.z.string().describe("The column letter for Testcases column"),
+    updatedScenario: zod_1.z.string().describe("The updated test scenario content"),
+  },
+  async ({ sheetName, rowNumber, columnLetter, updatedScenario }) => {
+    try {
+      // Load Google Sheets credentials with write permissions
+      const keyFile = path.join(os.homedir(), 'Desktop', 'secret.json');
+
+      const auth = new google.auth.GoogleAuth({
+        keyFile,
+        scopes: ['https://www.googleapis.com/auth/spreadsheets'],
+      });
+
+      const authClient = await auth.getClient();
+      const sheets = google.sheets({ version: 'v4', auth: authClient });
+      const spreadsheetId = '1jAilVUeQW99JUYj1KL4jovoxeWGUnsIcY_nMJR5H6dc';
+
+      const cellReference = `${sheetName}!${columnLetter}${rowNumber}`;
+
+      // First, read the existing scenario
+      const getRes = await sheets.spreadsheets.values.get({
+        spreadsheetId,
+        range: cellReference
+      });
+
+      const existingScenario = getRes.data.values && getRes.data.values[0] && getRes.data.values[0][0]
+        ? getRes.data.values[0][0]
+        : '';
+
+      if (!existingScenario) {
+        return `No existing scenario found at ${cellReference}. Cannot append to empty cell.`;
+      }
+
+      // Combine: existing scenario + newline + updated scenario
+      const combinedContent = `${existingScenario}\n${updatedScenario}`;
+
+      // Get sheet ID dynamically
+      const sheetsMetadata = await sheets.spreadsheets.get({ spreadsheetId });
+      const sheetId = sheetsMetadata.data.sheets.find(s => s.properties.title === sheetName)?.properties.sheetId || 0;
+
+      // Calculate text positions
+      const existingLength = existingScenario.length;
+      const newTextStartIndex = existingLength + 1; // +1 for newline
+
+      // Apply green color formatting to the new text
+      const batchUpdateRes = await sheets.spreadsheets.batchUpdate({
+        spreadsheetId,
+        resource: {
+          requests: [
+            {
+              repeatCell: {
+                range: {
+                  sheetId: sheetId,
+                  startRowIndex: rowNumber - 1,
+                  endRowIndex: rowNumber,
+                  startColumnIndex: columnLetter.charCodeAt(0) - 65,
+                  endColumnIndex: columnLetter.charCodeAt(0) - 64
+                },
+                cell: {
+                  userEnteredValue: {
+                    stringValue: combinedContent
+                  },
+                  textFormatRuns: [
+                    // Keep existing text in default color
+                    {
+                      startIndex: 0,
+                      format: {}
+                    },
+                    // New text in green
+                    {
+                      startIndex: newTextStartIndex,
+                      format: {
+                        foregroundColor: {
+                          red: 0.0,
+                          green: 0.5,
+                          blue: 0.0
+                        }
+                      }
+                    }
+                  ]
+                },
+                fields: 'userEnteredValue,textFormatRuns'
+              }
+            }
+          ]
+        }
+      });
+
+      if (batchUpdateRes.status === 200) {
+        return `Successfully appended updated scenario at ${cellReference}. New scenario added in green color: "${updatedScenario.substring(0, 100)}${updatedScenario.length > 100 ? '...' : ''}"`;
+      } else {
+        return `Failed to append scenario. Status: ${batchUpdateRes.status}`;
+      }
+
+    } catch (error) {
+      return `Error updating test scenario: ${error.message}`;
+    }
+  }
+);
 
  tool("mobile_list_elements_on_screennn", "List elements on screen and their coordinates, with display text or accessibility label. Returns the complete XML structure to maintain hierarchy for XPath creation. Do not cache this result.", {}, async ({}) => {
      requireRobot();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbakka/mcp-appium",
-  "version": "3.0.22",
+  "version": "3.0.24",
   "description": "Appium MCP",
   "engines": {
     "node": ">=18"