mobile-debug-mcp 0.12.4 → 0.12.6

package/dist/ios/manage.js

@@ -291,16 +291,117 @@ 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 {
-            const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId);
+            // 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) { }
+        }
+        catch { }
+        // Attempt to launch
+        let launchResult = null;
+        try {
+            launchResult = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId);
+        }
+        catch (launchErr) {
+            // Collect diagnostics when simctl launch fails
+            const launchDiag = execCommandWithDiagnostics(['simctl', 'launch', deviceId, bundleId], deviceId);
             const device = await getIOSDeviceMetadata(deviceId);
-            return { device, appStarted: !!result.output, launchTimeMs: 1000 };
+            const post = await this.collectPostLaunchDiagnostics(bundleId, deviceId);
+            return { device, appStarted: false, launchTimeMs: 0, error: launchErr instanceof Error ? launchErr.message : String(launchErr), diagnostics: { launchDiag, post }, instrumentation };
+        }
+        // Basic success — but verify RunningBoard/installcoordination didn't mark it as placeholder
+        const device = await getIOSDeviceMetadata(deviceId);
+        // short wait to let system settle
+        await new Promise(r => setTimeout(r, 1000));
+        let appinfo = '';
+        try {
+            const ai = await execCommand(['simctl', 'appinfo', deviceId, bundleId], deviceId);
+            appinfo = ai.output || '';
+        }
+        catch { }
+        // capture recent runningboard/installcoordination logs
+        const logDiag = execCommandWithDiagnostics(['simctl', 'spawn', deviceId, 'log', 'show', '--style', 'syslog', '--predicate', `(process == "${bundleId}" ) OR eventMessage CONTAINS "installcoordinationd" OR eventMessage CONTAINS "runningboard"`, '--last', '1m'], deviceId);
+        const placeholderDetected = (appinfo && /isPlaceholder[:=]?\s*Y/i.test(appinfo)) || (logDiag && ((logDiag.runResult && ((logDiag.runResult.stdout || '').includes('isPlaceholder')) || (logDiag.runResult.stderr || '').includes('isPlaceholder'))));
+        if (placeholderDetected) {
+            const post = await this.collectPostLaunchDiagnostics(bundleId, deviceId, appinfo);
+            return { device, appStarted: false, launchTimeMs: 0, diagnostics: { appinfo, logDiag, post }, instrumentation };
+        }
+        return { device, appStarted: !!(launchResult && launchResult.output), launchTimeMs: 1000, instrumentation };
+    }
+    appExecutableName(bundleId) {
+        // Best-effort executable name: prefer last component of bundleId
+        try {
+            const candidate = bundleId.split('.').pop();
+            return candidate || bundleId;
+        }
+        catch {
+            return bundleId;
+        }
+    }
+    // Collect bundle- and system-level diagnostics after a failed or placeholder launch
+    async collectPostLaunchDiagnostics(bundleId, deviceId = "booted", appinfo) {
+        const diagnostics = { ts: new Date().toISOString(), bundleId, deviceId };
+        // gather simctl appinfo (if not provided)
+        try {
+            diagnostics.appinfo = appinfo || ((await execCommand(['simctl', 'appinfo', deviceId, bundleId], deviceId)).output || '');
         }
         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 };
+            diagnostics.appinfoError = String(e);
+        }
+        // attempt to discover bundle path from appinfo
+        let bundlePath = null;
+        if (diagnostics.appinfo) {
+            const m = diagnostics.appinfo.match(/Path\s*=\s*"?([\S]+)"?/) || diagnostics.appinfo.match(/Container: (\/\S+)/);
+            if (m)
+                bundlePath = m[1];
+        }
+        // lipo / file / otool / codesign / xattr
+        if (bundlePath) {
+            diagnostics.bundlePath = bundlePath;
+            const execs = [
+                { name: 'file', cmd: ['file', bundlePath + '/' + this.appExecutableName(bundleId)] },
+                { name: 'lipo', cmd: ['lipo', '-info', bundlePath + '/' + this.appExecutableName(bundleId)] },
+                { name: 'otool-L', cmd: ['otool', '-L', bundlePath + '/' + this.appExecutableName(bundleId)] },
+                { name: 'otool-load', cmd: ['otool', '-l', bundlePath + '/' + this.appExecutableName(bundleId)] },
+                { name: 'plutil', cmd: ['plutil', '-p', bundlePath + '/Info.plist'] },
+                { name: 'codesign', cmd: ['codesign', '-dvvv', bundlePath] },
+                { name: 'xattr', cmd: ['xattr', '-l', bundlePath] },
+                { name: 'ls', cmd: ['ls', '-la', bundlePath] },
+            ];
+            diagnostics.bundle = {};
+            for (const e of execs) {
+                try {
+                    const r = execCommandWithDiagnostics(e.cmd, deviceId);
+                    diagnostics.bundle[e.name] = r && r.runResult ? { stdout: r.runResult.stdout, stderr: r.runResult.stderr, code: r.runResult.exitCode } : { error: 'no-result' };
+                }
+                catch (err) {
+                    diagnostics.bundle[e.name] = { error: String(err) };
+                }
+            }
+        }
+        // collect recent system logs and a screenshot
+        try {
+            diagnostics.recentLogs = execCommandWithDiagnostics(['simctl', 'spawn', deviceId, 'log', 'show', '--style', 'syslog', '--predicate', `eventMessage CONTAINS "installcoordinationd" OR eventMessage CONTAINS "runningboard"`, '--last', '5m'], deviceId);
+        }
+        catch (e) {
+            diagnostics.recentLogsError = String(e);
+        }
+        try {
+            const shot = await execCommandWithDiagnostics(['simctl', 'io', deviceId, 'screenshot', '--type', 'png', '/tmp/mcp_post_launch_screenshot.png'], deviceId);
+            diagnostics.screenshot = { created: true, path: '/tmp/mcp_post_launch_screenshot.png', result: shot && shot.runResult };
+        }
+        catch (e) {
+            diagnostics.screenshotError = String(e);
         }
+        return diagnostics;
     }
     async terminateApp(bundleId, deviceId = "booted") {
         validateBundleId(bundleId);

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.6",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {

package/src/ios/manage.ts

@@ -298,15 +298,102 @@ 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 {
-      const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId)
-      const device = await getIOSDeviceMetadata(deviceId)
-      return { device, appStarted: !!result.output, launchTimeMs: 1000 }
-    } catch (e:any) {
-      const diag = execCommandWithDiagnostics(['simctl', 'launch', deviceId, bundleId], deviceId)
+      // 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) {}
+    } catch {}
+
+    // Attempt to launch
+    let launchResult: any = null
+    try {
+      launchResult = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId)
+    } catch (launchErr:any) {
+      // Collect diagnostics when simctl launch fails
+      const launchDiag = 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
+      const post = await this.collectPostLaunchDiagnostics(bundleId, deviceId)
+      return { device, appStarted: false, launchTimeMs: 0, error: launchErr instanceof Error ? launchErr.message : String(launchErr), diagnostics: { launchDiag, post }, instrumentation } as any
+    }
+
+    // Basic success — but verify RunningBoard/installcoordination didn't mark it as placeholder
+    const device = await getIOSDeviceMetadata(deviceId)
+    // short wait to let system settle
+    await new Promise(r => setTimeout(r, 1000))
+
+    let appinfo = ''
+    try {
+      const ai = await execCommand(['simctl', 'appinfo', deviceId, bundleId], deviceId)
+      appinfo = ai.output || ''
+    } catch {}
+
+    // capture recent runningboard/installcoordination logs
+    const logDiag = execCommandWithDiagnostics(['simctl','spawn',deviceId,'log','show','--style','syslog','--predicate',`(process == "${bundleId}" ) OR eventMessage CONTAINS "installcoordinationd" OR eventMessage CONTAINS "runningboard"`, '--last', '1m'], deviceId)
+
+    const placeholderDetected = (appinfo && /isPlaceholder[:=]?\s*Y/i.test(appinfo)) || (logDiag && ((logDiag.runResult && ((logDiag.runResult.stdout || '').includes('isPlaceholder')) || (logDiag.runResult.stderr || '').includes('isPlaceholder'))))
+
+    if (placeholderDetected) {
+      const post = await this.collectPostLaunchDiagnostics(bundleId, deviceId, appinfo)
+      return { device, appStarted: false, launchTimeMs: 0, diagnostics: { appinfo, logDiag, post }, instrumentation } as any
+    }
+
+    return { device, appStarted: !!(launchResult && launchResult.output), launchTimeMs: 1000, instrumentation }
+  }
+
+  appExecutableName(bundleId: string) {
+    // Best-effort executable name: prefer last component of bundleId
+    try { const candidate = bundleId.split('.').pop(); return candidate || bundleId }
+    catch { return bundleId }
+  }
+
+  // Collect bundle- and system-level diagnostics after a failed or placeholder launch
+  async collectPostLaunchDiagnostics(bundleId: string, deviceId: string = "booted", appinfo?: string) {
+    const diagnostics: any = { ts: new Date().toISOString(), bundleId, deviceId }
+
+    // gather simctl appinfo (if not provided)
+    try { diagnostics.appinfo = appinfo || ((await execCommand(['simctl','appinfo', deviceId, bundleId], deviceId)).output || '') } catch (e) { diagnostics.appinfoError = String(e) }
+
+    // attempt to discover bundle path from appinfo
+    let bundlePath: string | null = null
+    if (diagnostics.appinfo) {
+      const m = diagnostics.appinfo.match(/Path\s*=\s*"?([\S]+)"?/) || diagnostics.appinfo.match(/Container: (\/\S+)/)
+      if (m) bundlePath = m[1]
     }
+
+    // lipo / file / otool / codesign / xattr
+    if (bundlePath) {
+      diagnostics.bundlePath = bundlePath
+      const execs = [
+        { name: 'file', cmd: ['file', bundlePath + '/' + this.appExecutableName(bundleId)] },
+        { name: 'lipo', cmd: ['lipo', '-info', bundlePath + '/' + this.appExecutableName(bundleId)] },
+        { name: 'otool-L', cmd: ['otool', '-L', bundlePath + '/' + this.appExecutableName(bundleId)] },
+        { name: 'otool-load', cmd: ['otool', '-l', bundlePath + '/' + this.appExecutableName(bundleId)] },
+        { name: 'plutil', cmd: ['plutil', '-p', bundlePath + '/Info.plist'] },
+        { name: 'codesign', cmd: ['codesign', '-dvvv', bundlePath] },
+        { name: 'xattr', cmd: ['xattr', '-l', bundlePath] },
+        { name: 'ls', cmd: ['ls', '-la', bundlePath] },
+      ]
+
+      diagnostics.bundle = {}
+      for (const e of execs) {
+        try {
+          const r = execCommandWithDiagnostics(e.cmd, deviceId)
+          diagnostics.bundle[e.name] = r && r.runResult ? { stdout: r.runResult.stdout, stderr: r.runResult.stderr, code: r.runResult.exitCode } : { error: 'no-result' }
+        } catch (err) { diagnostics.bundle[e.name] = { error: String(err) } }
+      }
+    }
+
+    // collect recent system logs and a screenshot
+    try { diagnostics.recentLogs = execCommandWithDiagnostics(['simctl','spawn',deviceId,'log','show','--style','syslog','--predicate',`eventMessage CONTAINS "installcoordinationd" OR eventMessage CONTAINS "runningboard"`, '--last', '5m'], deviceId) } catch (e) { diagnostics.recentLogsError = String(e) }
+    try {
+      const shot = await execCommandWithDiagnostics(['simctl','io', deviceId, 'screenshot', '--type', 'png', '/tmp/mcp_post_launch_screenshot.png'], deviceId)
+      diagnostics.screenshot = { created: true, path: '/tmp/mcp_post_launch_screenshot.png', result: shot && shot.runResult }
+    } catch (e) { diagnostics.screenshotError = String(e) }
+
+    return diagnostics
   }
 
   async terminateApp(bundleId: string, deviceId: string = "booted"): Promise<TerminateAppResponse> {

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 {