mobile-debug-mcp 0.24.6 → 0.24.7

package/test/unit/manage/scoped_env.test.ts

@@ -0,0 +1,137 @@
+import assert from 'assert'
+import { ToolsManage } from '../../../src/manage/index.js'
+import { AndroidManage } from '../../../src/manage/android.js'
+import { iOSManage } from '../../../src/manage/ios.js'
+
+async function run() {
+  const originalAndroidBuild = AndroidManage.prototype.build
+  const originalIOSBuild = iOSManage.prototype.build
+  const originalGradleWorkers = process.env.MCP_GRADLE_WORKERS
+  const originalGradleCache = process.env.MCP_GRADLE_CACHE
+  const originalForceCleanAndroid = process.env.MCP_FORCE_CLEAN_ANDROID
+  const originalDerivedData = process.env.MCP_DERIVED_DATA
+  const originalXcodeJobs = process.env.MCP_XCODE_JOBS
+  const originalForceCleanIOS = process.env.MCP_FORCE_CLEAN
+  const originalDestination = process.env.MCP_XCODE_DESTINATION_UDID
+
+  try {
+    process.env.MCP_GRADLE_WORKERS = 'ambient-workers'
+    process.env.MCP_GRADLE_CACHE = 'ambient-cache'
+    process.env.MCP_FORCE_CLEAN_ANDROID = 'ambient-force-android'
+    process.env.MCP_DERIVED_DATA = '/tmp/ambient-derived'
+    process.env.MCP_XCODE_JOBS = 'ambient-xcode-jobs'
+    process.env.MCP_FORCE_CLEAN = 'ambient-force-ios'
+    process.env.MCP_XCODE_DESTINATION_UDID = 'ambient-destination'
+
+    let androidCalls = 0
+    AndroidManage.prototype.build = async function (_projectPath: string, options?: { variant?: string, env?: Record<string, string | undefined> }) {
+      androidCalls += 1
+      if (androidCalls === 1) {
+        assert.strictEqual(options?.variant, 'assembleDebug')
+        assert.deepStrictEqual(options?.env, {
+          MCP_GRADLE_TASK: 'assembleDebug',
+          MCP_GRADLE_WORKERS: '3',
+          MCP_GRADLE_CACHE: '0',
+          MCP_FORCE_CLEAN_ANDROID: '1'
+        })
+      } else {
+        assert.strictEqual(options?.variant, 'assembleDebug')
+        assert.deepStrictEqual(options?.env, {
+          MCP_GRADLE_TASK: 'assembleDebug'
+        })
+      }
+      return { artifactPath: '/tmp/fake.apk' }
+    }
+
+    let iosCalls = 0
+    iOSManage.prototype.build = async function (_projectPath: string, options?: { variant?: string, workspace?: string, project?: string, scheme?: string, destinationUDID?: string, derivedDataPath?: string, buildJobs?: number, forceClean?: boolean, xcodeCmd?: string, env?: Record<string, string | undefined> }) {
+      iosCalls += 1
+      if (iosCalls === 1) {
+        assert.deepStrictEqual(options?.env, {
+          MCP_DERIVED_DATA: '/tmp/derived',
+          MCP_XCODE_JOBS: '4',
+          MCP_FORCE_CLEAN: '1',
+          MCP_XCODE_DESTINATION_UDID: 'booted'
+        })
+      } else if (iosCalls === 2) {
+        assert.deepStrictEqual(options?.env, {})
+      } else {
+        assert.deepStrictEqual(options?.env, {
+          MCP_FORCE_CLEAN: '0',
+        })
+      }
+      assert.strictEqual(options?.derivedDataPath, iosCalls === 1 ? '/tmp/derived' : undefined)
+      assert.strictEqual(options?.buildJobs, iosCalls === 1 ? 4 : undefined)
+      assert.strictEqual(options?.forceClean, iosCalls === 1 ? true : iosCalls === 3 ? false : undefined)
+      assert.strictEqual(options?.destinationUDID, iosCalls === 1 ? 'booted' : undefined)
+      return { artifactPath: '/tmp/Fake.app' }
+    }
+
+    await ToolsManage.build_android({
+      projectPath: '/tmp/project',
+      maxWorkers: 3,
+      gradleCache: false,
+      forceClean: true
+    })
+
+    await ToolsManage.build_ios({
+      projectPath: '/tmp/project',
+      derivedDataPath: '/tmp/derived',
+      buildJobs: 4,
+      forceClean: true,
+      destinationUDID: 'booted'
+    })
+
+    await ToolsManage.build_android({
+      projectPath: '/tmp/project'
+    })
+
+    await ToolsManage.build_ios({
+      projectPath: '/tmp/project'
+    })
+
+    await ToolsManage.build_ios({
+      projectPath: '/tmp/project',
+      forceClean: false
+    })
+
+    assert.strictEqual(process.env.MCP_GRADLE_WORKERS, 'ambient-workers')
+    assert.strictEqual(process.env.MCP_GRADLE_CACHE, 'ambient-cache')
+    assert.strictEqual(process.env.MCP_FORCE_CLEAN_ANDROID, 'ambient-force-android')
+    assert.strictEqual(process.env.MCP_DERIVED_DATA, '/tmp/ambient-derived')
+    assert.strictEqual(process.env.MCP_XCODE_JOBS, 'ambient-xcode-jobs')
+    assert.strictEqual(process.env.MCP_FORCE_CLEAN, 'ambient-force-ios')
+    assert.strictEqual(process.env.MCP_XCODE_DESTINATION_UDID, 'ambient-destination')
+
+    console.log('manage scoped env tests passed')
+  } finally {
+    AndroidManage.prototype.build = originalAndroidBuild
+    iOSManage.prototype.build = originalIOSBuild
+
+    if (originalGradleWorkers === undefined) delete process.env.MCP_GRADLE_WORKERS
+    else process.env.MCP_GRADLE_WORKERS = originalGradleWorkers
+
+    if (originalGradleCache === undefined) delete process.env.MCP_GRADLE_CACHE
+    else process.env.MCP_GRADLE_CACHE = originalGradleCache
+
+    if (originalForceCleanAndroid === undefined) delete process.env.MCP_FORCE_CLEAN_ANDROID
+    else process.env.MCP_FORCE_CLEAN_ANDROID = originalForceCleanAndroid
+
+    if (originalDerivedData === undefined) delete process.env.MCP_DERIVED_DATA
+    else process.env.MCP_DERIVED_DATA = originalDerivedData
+
+    if (originalXcodeJobs === undefined) delete process.env.MCP_XCODE_JOBS
+    else process.env.MCP_XCODE_JOBS = originalXcodeJobs
+
+    if (originalForceCleanIOS === undefined) delete process.env.MCP_FORCE_CLEAN
+    else process.env.MCP_FORCE_CLEAN = originalForceCleanIOS
+
+    if (originalDestination === undefined) delete process.env.MCP_XCODE_DESTINATION_UDID
+    else process.env.MCP_XCODE_DESTINATION_UDID = originalDestination
+  }
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/test/unit/server/capture_screenshot.test.ts

@@ -0,0 +1,17 @@
+import assert from 'assert'
+import { handleToolCall } from '../../../src/server-core.js'
+
+async function run() {
+  const result = await handleToolCall('capture_screenshot', {})
+  const payload = JSON.parse(result.content[0].text)
+
+  assert.strictEqual(payload.error.tool, 'capture_screenshot')
+  assert.match(payload.error.message, /Missing or invalid string argument: platform/)
+
+  console.log('capture_screenshot argument tests passed')
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/test/unit/server/common.test.ts

@@ -0,0 +1,18 @@
+import assert from 'assert'
+import { requireBooleanArg } from '../../../src/server/common.js'
+
+function run() {
+  assert.strictEqual(requireBooleanArg({ exact: true }, 'exact'), true)
+  assert.strictEqual(requireBooleanArg({ exact: false }, 'exact'), false)
+  assert.throws(() => requireBooleanArg({}, 'exact'), /Missing or invalid boolean argument: exact/)
+  assert.throws(() => requireBooleanArg({ exact: 'true' as unknown as boolean }, 'exact'), /Missing or invalid boolean argument: exact/)
+
+  console.log('server common tests passed')
+}
+
+try {
+  run()
+} catch (error) {
+  console.error(error)
+  process.exit(1)
+}

package/test/unit/server/contract.test.ts

@@ -1,11 +1,14 @@
 import assert from 'assert'
+import { readFileSync } from 'fs'
 import { handleToolCall, serverInfo, toolDefinitions } from '../../../src/server-core.js'
 
 async function run() {
+  const packageJson = JSON.parse(readFileSync(new URL('../../../package.json', import.meta.url), 'utf8'))
   const names = toolDefinitions.map((tool) => tool.name)
   const uniqueNames = new Set(names)
 
   assert.strictEqual(serverInfo.name, 'mobile-debug-mcp')
+  assert.strictEqual(serverInfo.version, packageJson.version, 'serverInfo version should match package.json')
   assert.strictEqual(names.length, uniqueNames.size, 'tool names should be unique')
   assert(names.includes('wait_for_ui'))
   assert(names.includes('expect_screen'))

package/test/unit/server/get_logs.test.ts

@@ -0,0 +1,17 @@
+import assert from 'assert'
+import { handleToolCall } from '../../../src/server-core.js'
+
+async function run() {
+  const result = await handleToolCall('get_logs', {})
+  const payload = JSON.parse(result.content[0].text)
+
+  assert.strictEqual(payload.error.tool, 'get_logs')
+  assert.match(payload.error.message, /Missing or invalid string argument: platform/)
+
+  console.log('get_logs argument tests passed')
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/test/unit/server/get_network_activity.test.ts

@@ -0,0 +1,17 @@
+import assert from 'assert'
+import { handleToolCall } from '../../../src/server-core.js'
+
+async function run() {
+  const result = await handleToolCall('get_network_activity', {})
+  const payload = JSON.parse(result.content[0].text)
+
+  assert.strictEqual(payload.error.tool, 'get_network_activity')
+  assert.match(payload.error.message, /Missing or invalid string argument: platform/)
+
+  console.log('get_network_activity argument tests passed')
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/test/unit/server/get_ui_tree.test.ts

@@ -0,0 +1,17 @@
+import assert from 'assert'
+import { handleToolCall } from '../../../src/server-core.js'
+
+async function run() {
+  const result = await handleToolCall('get_ui_tree', {})
+  const payload = JSON.parse(result.content[0].text)
+
+  assert.strictEqual(payload.error.tool, 'get_ui_tree')
+  assert.match(payload.error.message, /Missing or invalid string argument: platform/)
+
+  console.log('get_ui_tree argument tests passed')
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/test/unit/server/response_shapes.test.ts

@@ -32,6 +32,15 @@ async function run() {
     assert.strictEqual(installPayload.output, 'Success')
     assert.strictEqual(installPayload.device.id, 'emulator-5554')
 
+    const missingBuildResponse = await handleToolCall('build_app', { projectPath: '/tmp/project' })
+    const missingBuildPayload = JSON.parse((missingBuildResponse as any).content[0].text)
+    assert.deepStrictEqual(missingBuildPayload, {
+      error: {
+        tool: 'build_app',
+        message: 'Missing or invalid string argument: platform'
+      }
+    })
+
     ;(ToolsInteract as any).waitForUIHandler = async () => ({
       status: 'success',
       matched: 1,
@@ -156,6 +165,15 @@ async function run() {
     assert.match(objectTapPayload.error.message, /"code": "E_CUSTOM"/)
     assert.match(objectTapPayload.error.message, /"field": "value"/)
 
+    const missingArgResponse = await handleToolCall('tap', { platform: 'android', x: 1 })
+    const missingArgPayload = JSON.parse((missingArgResponse as any).content[0].text)
+    assert.deepStrictEqual(missingArgPayload, {
+      error: {
+        tool: 'tap',
+        message: 'Missing or invalid number argument: y'
+      }
+    })
+
     ;(ToolsObserve as any).captureScreenshotHandler = async () => ({
       device: { platform: 'ios', id: 'booted', osVersion: '18.0', model: 'Simulator', simulator: true },
       screenshot: Buffer.from('png-data').toString('base64'),

package/test/unit/server/start_log_stream.test.ts

@@ -0,0 +1,37 @@
+import assert from 'assert'
+import { handleToolCall } from '../../../src/server-core.js'
+import { ToolsObserve } from '../../../src/observe/index.js'
+
+async function run() {
+  const originalStartLogStreamHandler = (ToolsObserve as any).startLogStreamHandler
+
+  try {
+    let captured: any = null
+    ;(ToolsObserve as any).startLogStreamHandler = async (args: any) => {
+      captured = args
+      return { sessionId: 'session-1', started: true }
+    }
+
+    const result = await handleToolCall('start_log_stream', { packageName: 'com.example.app' })
+    const payload = JSON.parse(result.content[0].text)
+
+    assert.deepStrictEqual(captured, {
+      platform: 'android',
+      packageName: 'com.example.app',
+      level: 'error',
+      sessionId: undefined,
+      deviceId: undefined
+    })
+    assert.strictEqual(payload.sessionId, 'session-1')
+    assert.strictEqual(payload.started, true)
+
+    console.log('start_log_stream default tests passed')
+  } finally {
+    ;(ToolsObserve as any).startLogStreamHandler = originalStartLogStreamHandler
+  }
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/.eslintignore

@@ -1,5 +0,0 @@
-node_modules/
-dist/
-.env
-.vscode/
-coverage/

package/.eslintrc.cjs

@@ -1,18 +0,0 @@
-module.exports = {
-  root: true,
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 2020,
-    sourceType: 'module',
-    project: './tsconfig.json'
-  },
-  plugins: ['@typescript-eslint', 'unused-imports'],
-  rules: {
-    // Use plugin to error on unused imports and provide autofix where possible
-    'unused-imports/no-unused-imports': 'error',
-    'unused-imports/no-unused-vars': ['error', { vars: 'all', args: 'after-used', ignoreRestSiblings: true }],
-    // Disable the default TS rule to avoid duplicate warnings
-    '@typescript-eslint/no-unused-vars': 'off'
-  },
-  ignorePatterns: ['dist/', 'node_modules/', '.git/']
-}

package/eslint.config.cjs

@@ -1,36 +0,0 @@
-module.exports = [
-  // Files/directories to ignore
-  {
-    ignores: [
-      'dist/',
-      'node_modules/',
-      '.git/',
-      '.vscode/',
-      'coverage/',
-      '.env'
-    ]
-  },
-  // Apply rules to JS/TS source and tests
-  {
-    files: ['src/**/*.ts', 'test/**/*.ts', 'src/**/*.js', 'test/**/*.js'],
-    languageOptions: {
-      parser: require.resolve('@typescript-eslint/parser'),
-      parserOptions: {
-        ecmaVersion: 2020,
-        sourceType: 'module',
-        project: './tsconfig.json'
-      }
-    },
-    plugins: {
-      '@typescript-eslint': require('@typescript-eslint/eslint-plugin'),
-      'unused-imports': require('eslint-plugin-unused-imports')
-    },
-    rules: {
-      // Use plugin to error on unused imports and provide autofix where possible
-      'unused-imports/no-unused-imports': 'error',
-      'unused-imports/no-unused-vars': ['error', { vars: 'all', args: 'after-used', ignoreRestSiblings: true }],
-      // Disable the default TS rule to avoid duplicate warnings
-      '@typescript-eslint/no-unused-vars': 'off'
-    }
-  }
-]