mobile-debug-mcp 0.12.4 → 0.12.5

package/dist/ios/manage.js

@@ -291,15 +291,26 @@ export class iOSManage {
     }
     async startApp(bundleId, deviceId = "booted") {
         validateBundleId(bundleId);
+        // Prepare instrumentation object upfront so it can be returned to callers
+        const instrumentation = { ts: new Date().toISOString(), action: 'startApp', cmd: 'xcrun', args: ['simctl', 'launch', deviceId, bundleId], cwd: process.cwd(), env: { PATH: process.env.PATH, XCRUN_PATH: process.env.XCRUN_PATH } };
         try {
+            // Instrumentation: persist and emit to stderr for server logs
+            try {
+                await fs.appendFile('/tmp/mcp_startapp_instrument.log', JSON.stringify(instrumentation) + '\n');
+            }
+            catch (e) { }
+            try {
+                console.error('MCP-STARTAPP-EXEC', JSON.stringify(instrumentation));
+            }
+            catch (e) { }
             const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId);
             const device = await getIOSDeviceMetadata(deviceId);
-            return { device, appStarted: !!result.output, launchTimeMs: 1000 };
+            return { device, appStarted: !!result.output, launchTimeMs: 1000, instrumentation };
         }
         catch (e) {
             const diag = execCommandWithDiagnostics(['simctl', 'launch', deviceId, bundleId], deviceId);
             const device = await getIOSDeviceMetadata(deviceId);
-            return { device, appStarted: false, launchTimeMs: 0, error: e instanceof Error ? e.message : String(e), diagnostics: diag };
+            return { device, appStarted: false, launchTimeMs: 0, error: e instanceof Error ? e.message : String(e), diagnostics: diag, instrumentation };
         }
     }
     async terminateApp(bundleId, deviceId = "booted") {

package/dist/ios/utils.js

@@ -96,7 +96,40 @@ export function validateBundleId(bundleId) {
 }
 export function execCommand(args, deviceId = "booted") {
     return new Promise((resolve, reject) => {
+        // Instrumentation: append a JSON line with timestamp, command, args, cwd and selected env vars
+        try {
+            const mcpEnv = {};
+            for (const k of Object.keys(process.env || {})) {
+                if (k.startsWith('MCP_'))
+                    mcpEnv[k] = process.env[k];
+            }
+            const instrument = {
+                timestamp: new Date().toISOString(),
+                command: getXcrunCmd(),
+                args,
+                cwd: process.cwd(),
+                env: {
+                    PATH: process.env.PATH,
+                    XCRUN_PATH: process.env.XCRUN_PATH,
+                    ...mcpEnv
+                }
+            };
+            try {
+                require('fs').appendFileSync('/tmp/mcp_exec_instrument.log', JSON.stringify(instrument) + '\n');
+            }
+            catch (e) { }
+        }
+        catch (e) {
+            // swallow instrumentation errors to avoid changing behavior
+        }
         // Use spawn for better stream control and consistency with Android implementation
+        // Instrument: emit a JSON line to stderr so the MCP server stderr/stdout capture can record the exact command and env
+        try {
+            const instLine = JSON.stringify({ ts: new Date().toISOString(), cmd: getXcrunCmd(), args, cwd: process.cwd(), PATH: process.env.PATH });
+            // Use stderr so it appears in server logs reliably
+            console.error('MCP-INSTRUMENT-EXEC', instLine);
+        }
+        catch (e) { }
         const child = spawn(getXcrunCmd(), args);
         let stdout = '';
         let stderr = '';
@@ -110,6 +143,17 @@ export function execCommand(args, deviceId = "booted") {
                 stderr += data.toString();
             });
         }
+        // Additional instrumentation: write pid and env snapshot when child starts
+        try {
+            const pidInfo = { ts: new Date().toISOString(), childPid: (child.pid || null), invoked: getXcrunCmd(), args };
+            try {
+                require('fs').appendFileSync('/tmp/mcp_exec_instrument.log', JSON.stringify(pidInfo) + '\n');
+            }
+            catch (e) { }
+        }
+        catch (e) {
+            // ignore
+        }
         const DEFAULT_XCRUN_LOG_TIMEOUT = parseInt(process.env.MCP_XCRUN_LOG_TIMEOUT || '', 10) || 30000; // env (ms) or default 30s
         const DEFAULT_XCRUN_CMD_TIMEOUT = parseInt(process.env.MCP_XCRUN_TIMEOUT || '', 10) || 60000; // env (ms) or default 60s
         const timeoutMs = args.includes('log') ? DEFAULT_XCRUN_LOG_TIMEOUT : DEFAULT_XCRUN_CMD_TIMEOUT; // choose appropriate timeout
@@ -133,6 +177,11 @@ export function execCommand(args, deviceId = "booted") {
     });
 }
 export function execCommandWithDiagnostics(args, deviceId = "booted") {
+    try {
+        const syncInst = { ts: new Date().toISOString(), cmd: getXcrunCmd(), args, cwd: process.cwd() };
+        require('fs').appendFileSync('/tmp/mcp_exec_instrument_sync.log', JSON.stringify(syncInst) + '\n');
+    }
+    catch (e) { }
     // Run synchronously to capture stdout/stderr and exitCode reliably for diagnostics
     const DEFAULT_XCRUN_LOG_TIMEOUT = parseInt(process.env.MCP_XCRUN_LOG_TIMEOUT || '', 10) || 30000;
     const DEFAULT_XCRUN_CMD_TIMEOUT = parseInt(process.env.MCP_XCRUN_TIMEOUT || '', 10) || 60000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-debug-mcp",
-  "version": "0.12.4",
+  "version": "0.12.5",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {

package/src/ios/manage.ts

@@ -298,14 +298,20 @@ export class iOSManage {
 
   async startApp(bundleId: string, deviceId: string = "booted"): Promise<StartAppResponse> {
     validateBundleId(bundleId)
+    // Prepare instrumentation object upfront so it can be returned to callers
+    const instrumentation = { ts: new Date().toISOString(), action: 'startApp', cmd: 'xcrun', args: ['simctl','launch', deviceId, bundleId], cwd: process.cwd(), env: { PATH: process.env.PATH, XCRUN_PATH: process.env.XCRUN_PATH } }
     try {
+      // Instrumentation: persist and emit to stderr for server logs
+      try { await fs.appendFile('/tmp/mcp_startapp_instrument.log', JSON.stringify(instrumentation) + '\n') } catch (e) {}
+      try { console.error('MCP-STARTAPP-EXEC', JSON.stringify(instrumentation)) } catch (e) {}
+
       const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId)
       const device = await getIOSDeviceMetadata(deviceId)
-      return { device, appStarted: !!result.output, launchTimeMs: 1000 }
+      return { device, appStarted: !!result.output, launchTimeMs: 1000, instrumentation }
     } catch (e:any) {
       const diag = execCommandWithDiagnostics(['simctl', 'launch', deviceId, bundleId], deviceId)
       const device = await getIOSDeviceMetadata(deviceId)
-      return { device, appStarted: false, launchTimeMs: 0, error: e instanceof Error ? e.message : String(e), diagnostics: diag } as any
+      return { device, appStarted: false, launchTimeMs: 0, error: e instanceof Error ? e.message : String(e), diagnostics: diag, instrumentation } as any
     }
   }
 

package/src/ios/utils.ts

@@ -88,7 +88,41 @@ export function validateBundleId(bundleId: string) {
 
 export function execCommand(args: string[], deviceId: string = "booted"): Promise<IOSResult> {
   return new Promise((resolve, reject) => {
+    // Instrumentation: append a JSON line with timestamp, command, args, cwd and selected env vars
+    try {
+      const mcpEnv: Record<string,string|undefined> = {}
+      for (const k of Object.keys(process.env || {})) {
+        if (k.startsWith('MCP_')) mcpEnv[k] = process.env[k]
+      }
+
+      const instrument = {
+        timestamp: new Date().toISOString(),
+        command: getXcrunCmd(),
+        args,
+        cwd: process.cwd(),
+        env: {
+          PATH: process.env.PATH,
+          XCRUN_PATH: process.env.XCRUN_PATH,
+          ...mcpEnv
+        }
+      }
+
+      try {
+        require('fs').appendFileSync('/tmp/mcp_exec_instrument.log', JSON.stringify(instrument) + '\n')
+      } catch (e) {}
+
+    } catch (e) {
+      // swallow instrumentation errors to avoid changing behavior
+    }
+
     // Use spawn for better stream control and consistency with Android implementation
+    // Instrument: emit a JSON line to stderr so the MCP server stderr/stdout capture can record the exact command and env
+    try {
+      const instLine = JSON.stringify({ ts: new Date().toISOString(), cmd: getXcrunCmd(), args, cwd: process.cwd(), PATH: process.env.PATH })
+      // Use stderr so it appears in server logs reliably
+      console.error('MCP-INSTRUMENT-EXEC', instLine)
+    } catch (e) {}
+
     const child = spawn(getXcrunCmd(), args)
     
     let stdout = ''
@@ -106,6 +140,14 @@ export function execCommand(args: string[], deviceId: string = "booted"): Promis
       })
     }
 
+    // Additional instrumentation: write pid and env snapshot when child starts
+    try {
+      const pidInfo = { ts: new Date().toISOString(), childPid: (child.pid || null), invoked: getXcrunCmd(), args }
+      try { require('fs').appendFileSync('/tmp/mcp_exec_instrument.log', JSON.stringify(pidInfo) + '\n') } catch (e) {}
+    } catch (e) {
+      // ignore
+    }
+
     const DEFAULT_XCRUN_LOG_TIMEOUT = parseInt(process.env.MCP_XCRUN_LOG_TIMEOUT || '', 10) || 30000 // env (ms) or default 30s
   const DEFAULT_XCRUN_CMD_TIMEOUT = parseInt(process.env.MCP_XCRUN_TIMEOUT || '', 10) || 60000 // env (ms) or default 60s
   const timeoutMs = args.includes('log') ? DEFAULT_XCRUN_LOG_TIMEOUT : DEFAULT_XCRUN_CMD_TIMEOUT // choose appropriate timeout
@@ -131,6 +173,11 @@ export function execCommand(args: string[], deviceId: string = "booted"): Promis
 }
 
 export function execCommandWithDiagnostics(args: string[], deviceId: string = "booted") {
+  try {
+    const syncInst = { ts: new Date().toISOString(), cmd: getXcrunCmd(), args, cwd: process.cwd() }
+    require('fs').appendFileSync('/tmp/mcp_exec_instrument_sync.log', JSON.stringify(syncInst) + '\n')
+  } catch (e) {}
+
   // Run synchronously to capture stdout/stderr and exitCode reliably for diagnostics
   const DEFAULT_XCRUN_LOG_TIMEOUT = parseInt(process.env.MCP_XCRUN_LOG_TIMEOUT || '', 10) || 30000
   const DEFAULT_XCRUN_CMD_TIMEOUT = parseInt(process.env.MCP_XCRUN_TIMEOUT || '', 10) || 60000

package/src/types.ts

@@ -12,6 +12,7 @@ export interface StartAppResponse {
   launchTimeMs: number;
   error?: string;
   diagnostics?: any;
+  instrumentation?: any;
 }
 
 export interface TerminateAppResponse {