mobile-debug-mcp 0.30.1 → 0.31.0

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

@@ -70,6 +70,10 @@ async function run() {
   const adjustControl = toolDefinitions.find((tool) => tool.name === 'adjust_control')
   assert(adjustControl, 'adjust_control should be registered')
   assert.deepStrictEqual((adjustControl as any).inputSchema.required, ['targetValue'])
+  assert.deepStrictEqual((adjustControl as any).inputSchema.oneOf, [
+    { required: ['selector'] },
+    { required: ['element_id'] }
+  ])
   assert.strictEqual((adjustControl as any).inputSchema.properties.targetValue.type, 'number')
   assert.match((adjustControl as any).description, /numeric control value/i)
   assert.match((adjustControl as any).description, /expect_state/i)

package/test/unit/system/get_system_status.test.ts

@@ -9,6 +9,9 @@ async function run() {
   assert(typeof (payload as any).status === 'string')
   assert(Array.isArray(payload.issues))
   assert((payload as any).summary && typeof (payload as any).summary.overall === 'string')
+  assert((payload as any).host && typeof (payload as any).host.os === 'string')
+  assert((payload as any).android && typeof (payload as any).android.status === 'string')
+  assert((payload as any).ios && typeof (payload as any).ios.status === 'string')
 
   const adb = ensureAdbAvailable()
   assert(adb && typeof adb.ok === 'boolean')

package/test/unit/system/system_status.test.ts

@@ -74,6 +74,7 @@ async function run() {
     XCRUN_VERSION_OUTPUT: process.env.XCRUN_VERSION_OUTPUT,
     XCRUN_VERSION_STATUS: process.env.XCRUN_VERSION_STATUS,
     SIMCTL_LIST_OUTPUT: process.env.SIMCTL_LIST_OUTPUT,
+    MOBILE_DEBUG_MCP_HOST_OS: process.env.MOBILE_DEBUG_MCP_HOST_OS,
   }
 
   try {
@@ -82,6 +83,7 @@ async function run() {
     process.env.XCRUN_PATH = xcrunPath
 
     setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'darwin',
       ADB_VERSION_STATUS: '0',
       ADB_VERSION_OUTPUT: '8.1.0\n',
       ADB_DEVICES_OUTPUT: 'List of devices attached\nemulator-5554\tdevice product:sdk\n',
@@ -94,12 +96,16 @@ async function run() {
     const healthy = await systemStatus.getSystemStatus()
     assert.strictEqual(healthy.success, true)
     assert.strictEqual((healthy as any).status, 'ready')
+    assert.strictEqual((healthy as any).host.supported, true)
     assert.strictEqual(healthy.adbAvailable, true)
     assert.strictEqual(typeof healthy.adbVersion, 'string')
+    assert.strictEqual((healthy as any).android.status, 'ready')
+    assert.strictEqual((healthy as any).ios.status, 'ready')
     assert.strictEqual((healthy as any).summary.android.ready, true)
     assert.strictEqual(typeof (healthy as any).summary.ios.summary, 'string')
 
     setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'darwin',
       ADB_VERSION_STATUS: '1',
       ADB_VERSION_OUTPUT: 'not found',
       ADB_DEVICES_OUTPUT: 'List of devices attached\n',
@@ -112,6 +118,7 @@ async function run() {
     assert(missingAdb.issues.some((issue: string) => issue.includes('ADB')))
 
     setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'darwin',
       ADB_VERSION_STATUS: '0',
       ADB_VERSION_OUTPUT: '8.1.0\n',
       ADB_DEVICES_OUTPUT: 'List of devices attached\nserial1\tunauthorized\nserial2\toffline\n',
@@ -125,6 +132,7 @@ async function run() {
     assert(unauthorized.issues.some((issue: string) => issue.includes('offline')))
 
     setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'darwin',
       ADB_VERSION_STATUS: '0',
       ADB_VERSION_OUTPUT: '8.1.0\n',
       ADB_DEVICES_OUTPUT: 'List of devices attached\nemulator-5554\tdevice product:sdk\n',
@@ -136,6 +144,38 @@ async function run() {
     assert.strictEqual(missingXcrun.adbAvailable, true)
     assert.strictEqual(Array.isArray(missingXcrun.issues), true)
     assert.strictEqual((missingXcrun as any).summary.ios.ready, false)
+    assert.strictEqual((missingXcrun as any).ios.status, 'unavailable')
+
+    setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'win32',
+      ADB_VERSION_STATUS: '0',
+      ADB_VERSION_OUTPUT: '8.1.0\n',
+      ADB_DEVICES_OUTPUT: 'List of devices attached\nemulator-5554\tdevice product:sdk\n',
+      XCRUN_VERSION_STATUS: '1',
+      XCRUN_VERSION_OUTPUT: 'not found',
+    })
+    const windowsHost = await systemStatus.getSystemStatus()
+    assert.strictEqual((windowsHost as any).host.os, 'windows')
+    assert.strictEqual((windowsHost as any).host.supported, true)
+    assert.strictEqual((windowsHost as any).ios.status, 'unsupported')
+    assert.deepStrictEqual((windowsHost as any).ios.tools, {})
+    assert.deepStrictEqual((windowsHost as any).ios.providers, {})
+    assert.deepStrictEqual((windowsHost as any).ios.capabilities, {})
+    assert.deepStrictEqual((windowsHost as any).ios.devices, [])
+    assert.strictEqual((windowsHost as any).ios.failures[0].code, 'PLATFORM_UNAVAILABLE')
+    assert.strictEqual((windowsHost as any).summary.ios.ready, false)
+
+    setScenario({ MOBILE_DEBUG_MCP_HOST_OS: 'freebsd' })
+    const unsupported = await systemStatus.getSystemStatus()
+    assert.strictEqual((unsupported as any).host.os, 'freebsd')
+    assert.strictEqual((unsupported as any).host.supported, false)
+    assert.strictEqual((unsupported as any).android.status, 'unsupported')
+    assert.strictEqual((unsupported as any).ios.status, 'unsupported')
+    assert.strictEqual((unsupported as any).android.failures[0].code, 'HOST_OS_UNSUPPORTED')
+    assert.strictEqual((unsupported as any).ios.failures[0].code, 'HOST_OS_UNSUPPORTED')
+    assert.strictEqual(unsupported.adbAvailable, false)
+    assert.strictEqual(unsupported.iosAvailable, false)
+    assert.strictEqual((unsupported as any).summary.overall, 'blocked')
 
     console.log('system_status checks passed')
   } finally {

package/test/unit/utils/idb_health.test.ts

@@ -0,0 +1,74 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+
+import { isIDBInstalled, probeIdb } from '../../../src/utils/cli/idb/idb-helper.js'
+
+async function run() {
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-idb-health-'))
+  const idbPath = path.join(binDir, 'idb')
+  const python3Path = path.join(binDir, 'python3')
+  const pythonPath = path.join(binDir, 'python')
+  const pythonLog = path.join(binDir, 'python.log')
+  const originalIdbPath = process.env.MCP_IDB_PATH
+  const originalPath = process.env.PATH
+
+  try {
+    await fs.writeFile(idbPath, `#!/bin/sh
+if [ "$1" = "list-targets" ] && [ "$2" = "--json" ]; then
+  printf '{"targets":[]}\n'
+  exit 0
+fi
+if [ "$1" = "--version" ]; then
+  printf 'idb: error: unrecognized arguments: --version\n' >&2
+  exit 2
+fi
+exit 0
+`, { mode: 0o755 })
+
+    await fs.writeFile(python3Path, `#!/bin/sh
+printf 'python3 called\\n' >> "${pythonLog}"
+exit 0
+`, { mode: 0o755 })
+
+    await fs.writeFile(pythonPath, `#!/bin/sh
+printf 'python called\\n' >> "${pythonLog}"
+exit 0
+`, { mode: 0o755 })
+
+    process.env.MCP_IDB_PATH = idbPath
+    process.env.PATH = `${binDir}${path.delimiter}${originalPath || ''}`
+
+    const probe = probeIdb(idbPath)
+    assert.strictEqual(probe.ok, true)
+    assert.strictEqual(isIDBInstalled(), true)
+    assert(probe.raw === null || typeof probe.raw === 'string')
+
+    await fs.rm(pythonLog, { force: true }).catch(() => {})
+    const failedIdbPath = path.join(binDir, 'idb-failing')
+    await fs.writeFile(failedIdbPath, `#!/bin/sh
+if [ "$1" = "list-targets" ] && [ "$2" = "--json" ]; then
+  printf 'idb unavailable\\n' >&2
+  exit 2
+fi
+exit 2
+`, { mode: 0o755 })
+
+    const failureProbe = probeIdb(failedIdbPath)
+    assert.strictEqual(failureProbe.ok, false)
+    assert.strictEqual(await fs.readFile(pythonLog, 'utf8').catch(() => ''), '')
+
+    console.log('idb health probe test passed')
+  } finally {
+    if (originalIdbPath === undefined) delete process.env.MCP_IDB_PATH
+    else process.env.MCP_IDB_PATH = originalIdbPath
+
+    if (originalPath === undefined) delete process.env.PATH
+    else process.env.PATH = originalPath
+
+    await fs.rm(binDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+run().catch((error) => { console.error(error); process.exit(1) })

package/skills/rfc-review/SKILL.md

@@ -1,52 +0,0 @@
-# RFC Review skill
-
-name: rfc-review
-version: 0.1.1
-summary: Reusable workflow for reviewing RFCs/specs in this repository with a consistent readiness rubric and output template.
-
-# Purpose
-Help an agent review an RFC for clarity, implementation readiness, and alignment with the current codebase. Use a common template so reviews stay consistent across documents and reviewers.
-
-# Activation conditions
-Activate when an agent needs to:
-- review a new or revised RFC
-- assess whether an RFC is implementation-ready
-- identify whether feedback is an RFC issue or an implementation issue
-- compare a spec against the current `src/` contract surface and docs
-
-# Surface area (actions)
-- locate-rfc
-- compare-against-code
-- assess-contract-completeness
-- classify-gaps
-- produce-review
-
-# Core guidance
-1. Read the RFC first, then compare it against the relevant code, docs, and tests.
-2. Separate **spec gaps** from **implementation gaps**.
-3. Check for: problem clarity, scope boundaries, explicit contracts, acceptance criteria, non-goals, and consistency with existing behavior.
-4. Prefer precise feedback that names the missing contract, unclear rule, or inconsistent behavior.
-5. Use the shared review template in `references/rfc-review-template.md` for the final output.
-6. If the RFC is not ready, say exactly what must be clarified before implementation can start.
-7. Classify each blocker as either a **spec gap** or an **implementation contract gap** and stop at that boundary.
-
-# Inputs & outputs
-- review-rfc(input: { rfcPath, relatedPaths?, focusAreas? }) -> { verdict, risks, specGaps, implementationGaps, recommendations }
-- compare-against-code(input: { rfcPath, codePaths[] }) -> { matches, mismatches, notes }
-- produce-review(input: { rfcPath, findings[] }) -> { summary, verdict, checklist, nextStep }
-
-# Failure handling
-- If the RFC file is missing, stop and report the missing path explicitly.
-- If the RFC is ambiguous, classify each concern as either "spec" or "implementation" instead of blending them.
-- If the review cannot be grounded in the current repo, state that the RFC is not reviewable yet.
-
-# Progressive disclosure
-- Keep this file short.
-- Load the reference template only when writing the final review.
-
-# References
-- `references/rfc-review-template.md` — standard review format and verdict rubric
-- `references/rfc-review-checklist.md` — questions to apply while reviewing an RFC
-
-# License
-Same as repository (MIT).

package/skills/rfc-review/references/rfc-review-checklist.md

@@ -1,12 +0,0 @@
-# RFC Review Checklist
-
-Ask these questions while reviewing:
-
-1. Is the problem statement specific and grounded in current failures?
-2. Are non-goals explicit?
-3. Are contracts concrete enough to implement?
-4. Are acceptance criteria testable?
-5. Does the RFC define the source of truth for new fields or behaviors?
-6. Does it match existing code paths and public tool surfaces?
-7. Can each open concern be classified as a spec issue or an implementation issue?
-8. Is the RFC ready to implement without further interpretation?

package/skills/rfc-review/references/rfc-review-template.md

@@ -1,28 +0,0 @@
-# RFC Review Template
-
-Use this structure for every RFC review:
-
-## Verdict
-- Ready / Needs clarification / Needs implementation contract / Not ready
-
-## Summary
-- One short paragraph on the RFC's current quality.
-
-## What is good
-- List the strongest parts of the RFC.
-
-## Issues
-For each issue, include:
-- **Type:** spec / implementation / implementation contract / doc
-- **Severity:** low / medium / high
-- **Why it matters:** one sentence
-- **Fix:** exact change needed
-
-## Missing contract surfaces
-- List any API shapes, response fields, state transitions, or invariants that are still undefined.
-
-## Codebase alignment
-- Note whether the RFC matches current `src/`, docs, and tests.
-
-## Next step
-- State the smallest next action needed to move the RFC forward.