mobile-debug-mcp 0.12.8 → 0.13.0

package/dist/ios/manage.js

@@ -291,117 +291,16 @@ 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) { }
-        }
-        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 result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId);
             const device = await getIOSDeviceMetadata(deviceId);
-            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) {
-            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 };
+            return { device, appStarted: !!result.output, launchTimeMs: 1000 };
         }
         catch (e) {
-            diagnostics.screenshotError = String(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 diagnostics;
     }
     async terminateApp(bundleId, deviceId = "booted") {
         validateBundleId(bundleId);

package/dist/ios/utils.js

@@ -96,40 +96,7 @@ 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 = '';
@@ -143,17 +110,6 @@ 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
@@ -177,11 +133,6 @@ 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/dist/server.js

@@ -389,37 +389,52 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         if (name === "start_app") {
             const { platform, appId, deviceId } = args;
-            // Defensive validation: ensure required args are present and log malformed requests
+            // Defensive validation: ensure caller provided platform and appId.
             if (!platform || !appId) {
+                const msg = 'Both platform and appId parameters are required (platform: ios|android, appId: bundle id or package name).';
+                const payload = { ts: new Date().toISOString(), tool: 'start_app', args };
+                let logged = false;
+                // Prefer the diagnostics module when available
                 try {
-                    require('fs').appendFileSync('/tmp/mcp_bad_requests.log', JSON.stringify({ ts: new Date().toISOString(), tool: 'start_app', args }) + '\n');
+                    const diag = require('./utils/diagnostics.js');
+                    if (diag && diag.appendDiagnosticFile) {
+                        diag.appendDiagnosticFile('bad_requests.log', payload);
+                        logged = true;
+                    }
                 }
-                catch (e) { }
-                const deviceFallback = { platform: platform || 'ios', id: deviceId || 'unknown', osVersion: '', model: '', simulator: true };
-                const response = { device: deviceFallback, appStarted: false, launchTimeMs: 0, error: 'Missing required argument: platform and/or appId', diagnostics: { receivedArgs: args } };
-                return wrapResponse(response);
-            }
-            try {
-                const res = await (platform === 'android' ? new AndroidManage().startApp(appId, deviceId) : new iOSManage().startApp(appId, deviceId));
-                // Preserve diagnostics and instrumentation from platform managers so agents receive full context
-                const response = {
-                    device: res.device,
-                    appStarted: res.appStarted,
-                    launchTimeMs: res.launchTimeMs,
-                    error: res.error,
-                    diagnostics: res.diagnostics,
-                    instrumentation: res.instrumentation
-                };
-                return wrapResponse(response);
-            }
-            catch (err) {
-                try {
-                    require('fs').appendFileSync('/tmp/mcp_bad_requests.log', JSON.stringify({ ts: new Date().toISOString(), tool: 'start_app', args, error: err && err.message ? err.message : String(err) }) + '\n');
+                catch (err) {
+                    console.error('Diagnostics append failed:', String(err));
+                }
+                // Fallback to /tmp file (synchronous) and report failures rather than swallowing
+                if (!logged) {
+                    try {
+                        const fs = require('fs');
+                        fs.appendFileSync('/tmp/mcp_bad_requests.log', JSON.stringify(payload) + '\n');
+                        logged = true;
+                    }
+                    catch (err) {
+                        console.error('Failed to write bad request to /tmp/mcp_bad_requests.log:', String(err));
+                    }
                 }
-                catch (e) { }
-                const deviceFallback = { platform: platform || 'ios', id: deviceId || 'unknown', osVersion: '', model: '', simulator: true };
-                return wrapResponse({ device: deviceFallback, appStarted: false, launchTimeMs: 0, error: err instanceof Error ? err.message : String(err), diagnostics: { receivedArgs: args } });
+                // Final fallback: emit payload to stderr so it's visible in server logs
+                if (!logged) {
+                    try {
+                        console.error('Bad request (start_app) payload:', JSON.stringify(payload));
+                    }
+                    catch (err) {
+                        // Last resort: still log the failure
+                        console.error('Failed to emit bad request payload to stderr:', String(err));
+                    }
+                }
+                return wrapResponse({ error: msg });
             }
+            const res = await (platform === 'android' ? new AndroidManage().startApp(appId, deviceId) : new iOSManage().startApp(appId, deviceId));
+            const response = {
+                device: res.device,
+                appStarted: res.appStarted,
+                launchTimeMs: res.launchTimeMs
+            };
+            return wrapResponse(response);
         }
         if (name === "terminate_app") {
             const { platform, appId, deviceId } = args;

package/docs/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
+## [0.13.0]
+- Fixed a crash in the `start_app` tool by adding validation to ensure `appId` and `platform` are provided.
+
 ## [0.12.4]
 - Made projectType and platform mandatory
 

package/package.json

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

package/src/ios/manage.ts

@@ -298,102 +298,15 @@ 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) {}
-    } 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 result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId)
       const device = await getIOSDeviceMetadata(deviceId)
-      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) } }
-      }
+      return { device, appStarted: !!result.output, launchTimeMs: 1000 }
+    } 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
     }
-
-    // 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,41 +88,7 @@ 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 = ''
@@ -140,14 +106,6 @@ 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
@@ -173,11 +131,6 @@ 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/server.ts

@@ -412,31 +412,54 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   try {
     if (name === "start_app") {
       const { platform, appId, deviceId } = args as any
-      // Defensive validation: ensure required args are present and log malformed requests
+      // Defensive validation: ensure caller provided platform and appId.
       if (!platform || !appId) {
-        try { require('fs').appendFileSync('/tmp/mcp_bad_requests.log', JSON.stringify({ ts: new Date().toISOString(), tool: 'start_app', args }) + '\n') } catch (e) {}
-        const deviceFallback: any = { platform: platform || 'ios', id: deviceId || 'unknown', osVersion: '', model: '', simulator: true }
-        const response: StartAppResponse = { device: deviceFallback, appStarted: false, launchTimeMs: 0, error: 'Missing required argument: platform and/or appId', diagnostics: { receivedArgs: args } }
-        return wrapResponse(response)
-      }
+        const msg = 'Both platform and appId parameters are required (platform: ios|android, appId: bundle id or package name).'
+        const payload = { ts: new Date().toISOString(), tool: 'start_app', args }
+        let logged = false
+
+        // Prefer the diagnostics module when available
+        try {
+          const diag = require('./utils/diagnostics.js')
+          if (diag && diag.appendDiagnosticFile) {
+            diag.appendDiagnosticFile('bad_requests.log', payload)
+            logged = true
+          }
+        } catch (err) {
+          console.error('Diagnostics append failed:', String(err))
+        }
 
-      try {
-        const res = await (platform === 'android' ? new AndroidManage().startApp(appId, deviceId) : new iOSManage().startApp(appId, deviceId))
-        // Preserve diagnostics and instrumentation from platform managers so agents receive full context
-        const response: StartAppResponse = {
-          device: res.device,
-          appStarted: res.appStarted,
-          launchTimeMs: res.launchTimeMs,
-          error: (res as any).error,
-          diagnostics: (res as any).diagnostics,
-          instrumentation: (res as any).instrumentation
+        // Fallback to /tmp file (synchronous) and report failures rather than swallowing
+        if (!logged) {
+          try {
+            const fs = require('fs')
+            fs.appendFileSync('/tmp/mcp_bad_requests.log', JSON.stringify(payload) + '\n')
+            logged = true
+          } catch (err) {
+            console.error('Failed to write bad request to /tmp/mcp_bad_requests.log:', String(err))
+          }
         }
-        return wrapResponse(response)
-      } catch (err:any) {
-        try { require('fs').appendFileSync('/tmp/mcp_bad_requests.log', JSON.stringify({ ts: new Date().toISOString(), tool: 'start_app', args, error: err && err.message ? err.message : String(err) }) + '\n') } catch (e) {}
-        const deviceFallback: any = { platform: platform || 'ios', id: deviceId || 'unknown', osVersion: '', model: '', simulator: true }
-        return wrapResponse({ device: deviceFallback, appStarted: false, launchTimeMs: 0, error: err instanceof Error ? err.message : String(err), diagnostics: { receivedArgs: args } })
+
+        // Final fallback: emit payload to stderr so it's visible in server logs
+        if (!logged) {
+          try {
+            console.error('Bad request (start_app) payload:', JSON.stringify(payload))
+          } catch (err) {
+            // Last resort: still log the failure
+            console.error('Failed to emit bad request payload to stderr:', String(err))
+          }
+        }
+
+        return wrapResponse({ error: msg })
       }
+
+      const res = await (platform === 'android' ? new AndroidManage().startApp(appId, deviceId) : new iOSManage().startApp(appId, deviceId))
+      const response: StartAppResponse = {
+        device: res.device,
+        appStarted: res.appStarted,
+        launchTimeMs: res.launchTimeMs
+      }
+      return wrapResponse(response)
     }
 
     if (name === "terminate_app") {

package/src/types.ts

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