@nbakka/mcp-appium 2.0.95 → 2.0.97

package/lib/server.js

@@ -828,16 +828,47 @@ tool(
 
       const parsedTestCases = parseTestCases(testCases);
 
+      // Initialize session with proper locking mechanism
       approvalSessions.set(sessionId, {
         status: 'pending',
         testCases: parsedTestCases,
         originalTestCases: JSON.parse(JSON.stringify(parsedTestCases)),
         server: null,
-        startTime: Date.now()
+        startTime: Date.now(),
+        locked: false
       });
 
       const app = express();
-      const port = 3001;
+
+      // Try multiple ports if 3001 is busy
+      let port = 3001;
+      let server = null;
+
+      const tryStartServer = (portToTry) => {
+        return new Promise((resolve, reject) => {
+          const testServer = app.listen(portToTry, () => {
+            resolve({ server: testServer, port: portToTry });
+          }).on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+              reject(err);
+            } else {
+              reject(err);
+            }
+          });
+        });
+      };
+
+      // Try ports 3001-3010
+      for (let i = 0; i < 10; i++) {
+        try {
+          const result = await tryStartServer(port + i);
+          server = result.server;
+          port = result.port;
+          break;
+        } catch (err) {
+          if (i === 9) throw new Error(`No available ports found (tried ${port}-${port + 9})`);
+        }
+      }
 
       app.use(express.json());
       app.use(express.static(path.join(__dirname, 'review-ui')));
@@ -871,13 +902,16 @@ tool(
 
       app.post(`/approve/${sessionId}`, (req, res) => {
         const session = approvalSessions.get(sessionId);
-        if (session) {
-          // overwrite authoritative copy with the submitted version
-          session.testCases = req.body;
-          session.finalTestCases = req.body;
-          session.status = 'approved';
-          approvalSessions.set(sessionId, session);
-        }
+        if (!session) return res.status(404).json({ error: 'Session not found' });
+
+        // Use atomic update with locking
+        session.locked = true;
+        session.testCases = req.body;
+        session.finalTestCases = req.body;
+        session.status = 'approved';
+        session.approvedAt = Date.now();
+        approvalSessions.set(sessionId, session);
+
         res.json({ status: 'approved', message: 'Test cases approved successfully!' });
       });
 
@@ -885,23 +919,24 @@ tool(
         const session = approvalSessions.get(sessionId);
         if (session) {
           session.status = 'cancelled';
+          session.cancelledAt = Date.now();
           approvalSessions.set(sessionId, session);
         }
         res.json({ status: 'cancelled', message: 'Review cancelled' });
       });
 
-      const serverInstance = app.listen(port, async () => {
-        try {
-          const { default: open } = await import('open');
-          await open(`http://localhost:${port}`);
-        } catch { /* silent */ }
-      });
-
+      // Update session with server reference
       const stored = approvalSessions.get(sessionId);
-      stored.server = serverInstance;
+      stored.server = server;
       approvalSessions.set(sessionId, stored);
 
-      // timeout safeguard
+      // Open browser
+      try {
+        const { default: open } = await import('open');
+        await open(`http://localhost:${port}`);
+      } catch { /* silent */ }
+
+      // Timeout safeguard - but don't override approved status
       setTimeout(() => {
         const s = approvalSessions.get(sessionId);
         if (s && s.status === 'pending') {
@@ -911,24 +946,23 @@ tool(
         }
       }, 300000);
 
-      return {
-        status: "review_started",
-        sessionId,
-        message: "Test case review interface opened.",
-        testCasesCount: testCases.length,
-        browserUrl: `http://localhost:${port}`,
-        instructions: "Use check_approval_status tool to poll."
-      };
+      return `✅ Test case review interface opened successfully!
+Session ID: ${sessionId}
+Test Cases Count: ${testCases.length}
+Browser URL: http://localhost:${port}
+Status: review_started
+
+Instructions: Use check_approval_status tool with session ID "${sessionId}" to poll for approval status.`;
+
     } catch (err) {
-      return { status: "error", message: `Error setting up review interface: ${err.message}` };
+      return `❌ Error setting up review interface: ${err.message}`;
     }
   }
 );
 
-
 tool(
   "check_approval_status",
-  "Check the approval status of test cases review session (short-circuits if already approved)",
+  "Check the approval status of test cases review session (waits 20 seconds before checking)",
   { sessionId: zod_1.z.string().describe("Session ID from review_testcases") },
   async ({ sessionId }) => {
     const session = approvalSessions.get(sessionId);
@@ -937,6 +971,7 @@ tool(
     const now = Date.now();
     const elapsed = Math.floor((now - session.startTime) / 1000);
 
+    // Check if already approved (short-circuit without waiting)
     if (session.status === 'approved') {
       const approvedTestCases = session.finalTestCases || session.testCases;
       session.server?.close();
@@ -944,31 +979,36 @@ tool(
       return `✅ Test cases approved. Elapsed: ${elapsed}s\n${JSON.stringify(approvedTestCases, null, 2)}`;
     }
 
-    await new Promise(r => setTimeout(r, 5000));
+    // Wait 20 seconds before checking status
+    await new Promise(r => setTimeout(r, 20000));
 
+    // Re-fetch session after wait
     const refreshed = approvalSessions.get(sessionId);
-    if (!refreshed) return `❌ Session expired`;
+    if (!refreshed) return `❌ Session expired during wait`;
+
+    const newElapsed = Math.floor((Date.now() - refreshed.startTime) / 1000);
 
     if (refreshed.status === 'approved') {
       const approvedTestCases = refreshed.finalTestCases || refreshed.testCases;
       refreshed.server?.close();
       approvalSessions.delete(sessionId);
-      return `✅ Test cases approved. Elapsed: ${elapsed + 5}s\n${JSON.stringify(approvedTestCases, null, 2)}`;
+      return `✅ Test cases approved. Elapsed: ${newElapsed}s\n${JSON.stringify(approvedTestCases, null, 2)}`;
     } else if (refreshed.status === 'cancelled') {
       refreshed.server?.close();
       approvalSessions.delete(sessionId);
-      return `❌ Review cancelled. Elapsed: ${elapsed + 5}s`;
-    } else if (refreshed.status === 'timeout' || elapsed > 300) {
+      return `❌ Review cancelled. Elapsed: ${newElapsed}s`;
+    } else if (refreshed.status === 'timeout' || newElapsed > 300) {
       refreshed.server?.close();
       approvalSessions.delete(sessionId);
-      return `⏰ Review session timed out. Elapsed: ${elapsed + 5}s`;
+      return `⏰ Review session timed out. Elapsed: ${newElapsed}s`;
     }
 
-    return `⏳ Still pending. Elapsed: ${elapsed + 5}s Remaining: ${Math.max(0, 300 - (elapsed + 5))}s`;
+    return `⏳ Still pending. Elapsed: ${newElapsed}s Remaining: ${Math.max(0, 300 - newElapsed)}s`;
   }
 );
 
 
+
     return server;
 };
 

package/package.json

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