mobile-debug-mcp 0.21.5 → 0.23.0

package/test/observe/unit/get_screen_fingerprint.test.ts

@@ -1,69 +0,0 @@
-import { AndroidObserve } from '../../../src/observe/index.js'
-
-async function run() {
-  console.log('Starting get_screen_fingerprint unit tests...')
-
-  const origGet = (AndroidObserve as any).prototype.getUITree
-  const origCurrent = (AndroidObserve as any).prototype.getCurrentScreen
-
-  // Test 1: stable identical screens produce same fingerprint
-  ;(AndroidObserve as any).prototype.getUITree = async function() {
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [
-        { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0,0,1080,100], resourceId: 'id/title' },
-        { text: 'Sign in', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0,200,200,260], resourceId: 'id/signin' }
-      ]
-    }
-  }
-
-  ;(AndroidObserve as any).prototype.getCurrentScreen = async function() {
-    return { device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true }, package: 'com.example', activity: 'com.example.MainActivity', shortActivity: 'MainActivity' }
-  }
-
-  const ai = new AndroidObserve()
-  const a = await ai.getScreenFingerprint('mock')
-  const b = await ai.getScreenFingerprint('mock')
-  console.log('Test 1:', a.fingerprint === b.fingerprint ? 'PASS' : 'FAIL')
-
-  // Test 2: change in UI text changes fingerprint
-  ;(AndroidObserve as any).prototype.getUITree = async function() {
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [
-        { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0,0,1080,100], resourceId: 'id/title' },
-        { text: 'Profile', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0,200,200,260], resourceId: 'id/signin' }
-      ]
-    }
-  }
-
-  const c = await ai.getScreenFingerprint('mock')
-  console.log('Test 2:', a.fingerprint !== c.fingerprint ? 'PASS' : 'FAIL')
-
-  // Test 3: dynamic text ignored (timestamp) should not change fingerprint
-  ;(AndroidObserve as any).prototype.getUITree = async function() {
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [
-        { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0,0,1080,100], resourceId: 'id/title' },
-        { text: 'Sign in', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0,200,200,260], resourceId: 'id/signin' },
-        { text: '12:34', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [900,10,1080,40], resourceId: null }
-      ]
-    }
-  }
-
-  const d = await ai.getScreenFingerprint('mock')
-  console.log('Test 3:', a.fingerprint === d.fingerprint ? 'PASS' : 'FAIL')
-
-  // Restore
-  ;(AndroidObserve as any).prototype.getUITree = origGet
-  ;(AndroidObserve as any).prototype.getCurrentScreen = origCurrent
-}
-
-run().catch(console.error)

package/test/observe/unit/ios-getlogs.test.ts

@@ -1,67 +0,0 @@
-import { iOSObserve } from '../../../src/observe/ios'
-import assert from 'assert'
-
-// Lightweight unit tests: verify predicate construction and meta extraction logic using internal functions
-// Since getLogs executes xcrun, run tests in SKIP_DEVICE_TESTS=1 environment by stubbing execCommand where possible.
-
-import * as iosUtils from '../../../src/utils/ios/utils'
-
-function stubExecCommand(original: any, expectedArgsChecker: (args: string[]) => boolean, output: string) {
-  return async function (args: string[], deviceId?: string) {
-    if (!expectedArgsChecker(args)) throw new Error('Unexpected args: ' + JSON.stringify(args))
-    return { output, device: { platform: 'ios', id: deviceId || 'booted' } }
-  }
-}
-
-describe('iOS getLogs predicate and meta', () => {
-  let obs: iOSObserve
-  beforeEach(() => {
-    obs = new iOSObserve()
-  })
-
-  it('uses simple process name predicate when appId provided', async () => {
-    const bundle = 'com.ideamechanics.modul8'
-    // stub execCommand twice: first for pgrep, second for log show
-    const pgrepOutput = '12345\n'
-    const logOutput = '2026-03-31 09:21:20.085 Module[12345:678] <Info> Modul8: Test message'
-
-    const orig = (iosUtils as any).execCommand
-    try {
-      (iosUtils as any).execCommand = stubExecCommand(orig, (args) => args.includes('pgrep'), pgrepOutput)
-      // second replacement for the log show call
-      let called = false
-      (iosUtils as any).execCommand = async function (args: string[]) {
-        if (args.includes('pgrep')) return { output: pgrepOutput, device: { platform: 'ios', id: 'booted' } }
-        if (args.includes('log') && args.includes('show')) { called = true; return { output: logOutput, device: { platform: 'ios', id: 'booted' } } }
-        throw new Error('Unexpected args: ' + JSON.stringify(args))
-      }
-
-      const res = await obs.getLogs({ appId: bundle, deviceId: 'booted' })
-      assert(res.meta.processNameUsed === 'modul8' || res.meta.processNameUsed === 'Modul8' || !!res.meta.processNameUsed)
-      assert(res.meta.detectedPid === 12345)
-      assert(res.source === 'pid')
-      assert(res.logCount === 1)
-      assert(res.logs[0].message.includes('Test message'))
-      assert(called, 'log show must have been called')
-    } finally {
-      (iosUtils as any).execCommand = orig
-    }
-  })
-
-  it('falls back to broad when no appId', async () => {
-    const logOutput = '2026-03-31 09:21:20.085 SomeOther[222:333] <Info> Other: Hello'
-    const orig = (iosUtils as any).execCommand
-    try {
-      (iosUtils as any).execCommand = async function (args: string[]) {
-        if (args.includes('log') && args.includes('show')) return { output: logOutput, device: { platform: 'ios', id: 'booted' } }
-        throw new Error('Unexpected args: ' + JSON.stringify(args))
-      }
-      const obs = new iOSObserve()
-      const res = await obs.getLogs({ deviceId: 'booted' })
-      assert(res.source === 'broad')
-      assert(res.logCount === 1)
-    } finally {
-      (iosUtils as any).execCommand = orig
-    }
-  })
-})

package/test/observe/unit/scroll_to_element.test.ts

@@ -1,129 +0,0 @@
-import { ToolsInteract } from '../../../src/interact/index.js'
-import { ToolsObserve } from '../../../src/observe/index.js'
-
-const origGet = (ToolsObserve as any).getUITreeHandler
-const origSwipe = (ToolsInteract as any).swipeHandler
-
-async function runTests() {
-  // Use a stable logger to avoid test harness replacing console.log between calls
-  console.log = (...args: any[]) => { try { process.stdout.write(args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n') } catch {} }
-  console.log('Starting tests for scroll_to_element...')
-
-  // Test 1: Element found immediately
-  console.log('\nTest 1: Element found immediately')
-  (ToolsObserve as any).getUITreeHandler = async () => ({
-    device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-    screen: '',
-    resolution: { width: 1080, height: 1920 },
-    elements: [{
-      text: 'Target',
-      type: 'Button',
-      contentDescription: null,
-      clickable: true,
-      enabled: true,
-      visible: true,
-      bounds: [0, 0, 100, 100],
-      resourceId: null
-    }]
-  })
-
-  const res1 = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: 'Target' }, direction: 'down', maxScrolls: 5, scrollAmount: 0.7 })
-  console.log('Result:', res1.success === true ? 'PASS' : 'FAIL')
-  console.log('scrollsPerformed:', (res1 as any).scrollsPerformed)
-
-  // Test 2: Element found after scrolling
-  console.log('\nTest 2: Element found after scrolling')
-  let calls = 0
-  (ToolsObserve as any).getUITreeHandler = async () => {
-    calls++
-    if (calls < 3) {
-      return {
-        device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-        screen: '',
-        resolution: { width: 1080, height: 1920 },
-        elements: []
-      }
-    }
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [{
-        text: 'Target',
-        type: 'Button',
-        contentDescription: null,
-        clickable: true,
-        enabled: true,
-        visible: true,
-        bounds: [0, 0, 100, 100],
-        resourceId: null
-      }]
-    }
-  }
-
-  // Stub swipe so it doesn't try to call adb/idb
-  (ToolsInteract as any).swipeHandler = async () => ({ success: true })
-
-  const res2 = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: 'Target' }, direction: 'down', maxScrolls: 5, scrollAmount: 0.7 })
-  console.log('Result:', res2.success === true ? 'PASS' : 'FAIL')
-  console.log('calls:', calls, calls >= 3 ? 'PASS' : 'FAIL')
-
-  // Test 3: UI unchanged stops early
-  console.log('\nTest 3: UI unchanged stops early')
-  (ToolsObserve as any).getUITreeHandler = async () => ({
-    device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-    screen: '',
-    resolution: { width: 1080, height: 1920 },
-    elements: []
-  })
-
-  (ToolsInteract as any).swipeHandler = async () => ({ success: true })
-
-  const res3 = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: 'Missing' }, direction: 'down', maxScrolls: 5, scrollAmount: 0.7 })
-  console.log('Result:', res3.success === false && (res3 as any).attempts === 1 ? 'PASS' : 'FAIL')
-  console.log('Reason:', (res3 as any).reason || JSON.stringify(res3))
-
-  // Test 4: Offscreen element scrolls into view
-  console.log('\nTest 4: Offscreen element scrolls into view')
-  const ai = new (await import('../../../src/interact/index.js')).AndroidInteract()
-  const origObserveGet = ai['observe'].getUITree
-  const origAiSwipe = ai.swipe
-  let swiped = false
-  let swipeCalled = 0
-  ;(ai['observe'] as any).getUITree = async () => {
-    if (!swiped) {
-      return {
-        device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-        screen: '',
-        resolution: { width: 1080, height: 1920 },
-        elements: [ { text: null, type: 'android.view.View', resourceId: null, contentDescription: null, bounds: [0,0,1080,200], visible: true } ]
-      }
-    }
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [{ text: 'OffscreenTarget', type: 'android.widget.Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [100,400,300,460], resourceId: null }]
-    }
-  }
-  ;(ai as any).swipe = async () => { swipeCalled++; swiped = true; return { success: true } }
-
-  const r4 = await ai.scrollToElement({ text: 'OffscreenTarget' }, 'down', 3, 0.7, 'mock')
-  const ok4 = r4 && (r4 as any).success === true && (r4 as any).scrollsPerformed === 1 && swipeCalled === 1
-  console.log('Result:', ok4 ? 'PASS' : 'FAIL')
-  console.log('  success:', (r4 as any).success, 'scrollsPerformed:', (r4 as any).scrollsPerformed, 'swipeCalled:', swipeCalled)
-
-  ;(ai['observe'] as any).getUITree = origObserveGet
-  ;(ai as any).swipe = origAiSwipe
-
-  // Restore
-  (ToolsObserve as any).getUITreeHandler = origGet
-  ;(ToolsInteract as any).swipeHandler = origSwipe
-}
-
-// Ensure console.log is a function (some test runners replace it)
-if (typeof console.log !== 'function') {
-  console.log = (...args: any[]) => { try { process.stdout.write(args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n') } catch { /* swallow */ } }
-}
-
-runTests().catch(console.error)

package/test/observe/unit/wait_for_element_mock.ts

@@ -1,2 +0,0 @@
-// wait_for_element tests removed — tool deprecated
-console.log('wait_for_element unit tests removed');

package/test/observe/unit/wait_for_ui_edge_cases.test.ts

@@ -1,41 +0,0 @@
-import { ToolsInteract } from '../../../../src/interact/index.js'
-import * as Observe from '../../../../src/observe/index.js'
-
-async function run() {
-  console.log('Unit: wait_for_ui edge cases')
-
-  const origFind = (ToolsInteract as any).findElementHandler
-  const origFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
-
-  try {
-    // 1) Immediate absence should pass for match='absent'
-    (ToolsInteract as any).findElementHandler = async () => ({ found: false })
-    const r1 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Nothing', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 200, match: 'absent', platform: 'android' })
-    console.log('Immediate absent test:', r1 && (r1 as any).success ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r1 as any).poll_count, duration_ms: (r1 as any).duration_ms, stable_duration_ms: (r1 as any).stable_duration_ms, matchSource: (r1 as any).matchSource }, null, 2))
-
-    // 2) Boundary stability: condition becomes true and stays exactly long enough
-    // Use pollInterval 100ms and stability 300ms -> need ~3 consecutive trues
-    let seq2 = [false, true, true, true]
-    (ToolsInteract as any).findElementHandler = async () => ({ found: seq2.shift() ?? true })
-    const r2 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Boundary', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 300, match: 'present', platform: 'android' })
-    console.log('Boundary stability test:', r2 && (r2 as any).success ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r2 as any).poll_count, duration_ms: (r2 as any).duration_ms, stable_duration_ms: (r2 as any).stable_duration_ms, matchSource: (r2 as any).matchSource }, null, 2))
-
-    // 3) Long flicker that never stabilizes should timeout/fail
-    // Sequence toggles true/false repeatedly
-    let seq3 = [false, true, false, true, false, true, false]
-    (ToolsInteract as any).findElementHandler = async () => ({ found: seq3.shift() ?? false })
-    const r3 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Flicker', timeoutMs: 1200, pollIntervalMs: 150, stability_ms: 400, match: 'present', platform: 'android' })
-    console.log('Long flicker timeout test:', !(r3 && (r3 as any).success) ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r3 as any).poll_count, duration_ms: (r3 as any).duration_ms, stable_duration_ms: (r3 as any).stable_duration_ms, matchSource: (r3 as any).matchSource }, null, 2))
-
-    // 4) Very short stability requirement should pass quickly
-    (ToolsInteract as any).findElementHandler = async () => ({ found: true })
-    const r4 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'ShortStable', timeoutMs: 2000, pollIntervalMs: 200, stability_ms: 50, match: 'present', platform: 'android' })
-    console.log('Short stability test:', r4 && (r4 as any).success ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r4 as any).poll_count, duration_ms: (r4 as any).duration_ms, stable_duration_ms: (r4 as any).stable_duration_ms, matchSource: (r4 as any).matchSource }, null, 2))
-
-  } finally {
-    (ToolsInteract as any).findElementHandler = origFind
-    (Observe as any).ToolsObserve.getScreenFingerprintHandler = origFp
-  }
-}
-
-run().catch(e=>{ console.error(e); process.exit(1) })

package/test/observe/unit/wait_for_ui_stability.test.ts

@@ -1,30 +0,0 @@
-import { ToolsInteract } from '../../../../src/interact/index.js'
-import * as Observe from '../../../../src/observe/index.js'
-
-async function run() {
-  console.log('Unit: wait_for_ui stability behavior')
-
-  const origFind = (ToolsInteract as any).findElementHandler
-  const origFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
-
-  try {
-    // Simulate UI flicker: present, absent, present, then stable
-    const seq = [false, true, false, true, true, true]
-    (ToolsInteract as any).findElementHandler = async () => ({ found: seq.shift() ?? true })
-
-    const res = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'X', timeoutMs: 5000, pollIntervalMs: 100, stability_ms: 500, platform: 'android' })
-    const ok = res && (res as any).success
-    console.log('Flicker stability test:', ok ? 'PASS' : 'FAIL', JSON.stringify((res as any).telemetry || {}, null, 2))
-
-    // Simulate immediate stable presence
-    (ToolsInteract as any).findElementHandler = async () => ({ found: true })
-    const res2 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Y', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 300, platform: 'android' })
-    console.log('Immediate stable test:', res2 && (res2 as any).success ? 'PASS' : 'FAIL', JSON.stringify((res2 as any).telemetry || {}, null, 2))
-
-  } finally {
-    (ToolsInteract as any).findElementHandler = origFind
-    (Observe as any).ToolsObserve.getScreenFingerprintHandler = origFp
-  }
-}
-
-run().catch(e=>{ console.error(e); process.exit(1) })

package/test/system/adb_version.test.ts

@@ -1,25 +0,0 @@
-import assert from 'assert'
-import * as androidUtils from '../../src/utils/android/utils.js'
-import * as systemStatus from '../../src/system/index.js'
-
-const origEnsure = (androidUtils as any).ensureAdbAvailable
-
-function mockEnsure(returnVal: any) {
-  (androidUtils as any).ensureAdbAvailable = () => returnVal
-}
-
-function restoreEnsure() {
-  (androidUtils as any).ensureAdbAvailable = origEnsure
-}
-
-describe('adb version parsing', () => {
-  afterEach(() => {
-    restoreEnsure()
-  })
-
-  it('uses only the first line of multi-line adb --version output', async () => {
-    mockEnsure({ adbCmd: 'adb', ok: true, version: 'Android Debug Bridge version 1.0.41\nRevision 8f3b7' })
-    const res = await systemStatus.getSystemStatus()
-    assert.strictEqual(res.adbVersion, 'Android Debug Bridge version 1.0.41')
-  })
-})

package/test/system/get_system_status.test.ts

@@ -1,52 +0,0 @@
-import assert from 'assert'
-import { ensureAdbAvailable } from '../../src/utils/android/utils.js'
-import { getXcrunCmd } from '../../src/utils/ios/utils.js'
-
-// We import the server handler module to access the internal get_system_status implementation.
-import * as server from '../../src/server.js'
-
-// Small helper to call the tool handler similarly to how the MCP transport would.
-async function callGetSystemStatus() {
-  const req = { params: { name: 'get_system_status', arguments: {} } }
-  // @ts-ignore - use the handler exported from server
-  const handler = (server as any).defaultRequestHandler || (server as any).callToolHandler || (server as any).__callTool
-  if (!handler) {
-    // fallback: require the module and call the exported server instance's request handler
-    // The server code registers the handler directly; we will emulate by requiring compiled code in dist if available.
-    try {
-      const dist = await import('../../dist/server.js')
-      // Try to execute by sending a call via the server instance if exported
-      if (dist && dist.server && typeof dist.server._handleCall === 'function') {
-        return dist.server._handleCall(req)
-      }
-    } catch {
-      // best effort only
-    }
-    throw new Error('Cannot locate server call handler for tests')
-  }
-
-  return handler(req)
-}
-
-describe('get_system_status tool (unit)', () => {
-  it('returns structured result without throwing', async () => {
-    const res = await callGetSystemStatus()
-    // Handler returns { content: [{ type: 'text', text: JSON.stringify(...) }] }
-    assert(res && res.content && Array.isArray(res.content))
-    const textBlock = res.content.find((c: any) => c.type === 'text')
-    assert(textBlock && textBlock.text)
-    const payload = JSON.parse(textBlock.text)
-    assert(typeof payload.success === 'boolean')
-    assert(Array.isArray(payload.issues))
-  }).timeout(5000)
-
-  it('detects adb availability helper works', () => {
-    const adb = ensureAdbAvailable()
-    assert(adb && typeof adb.ok === 'boolean')
-  })
-
-  it('detects xcrun command helper exists', () => {
-    const cmd = getXcrunCmd()
-    assert(typeof cmd === 'string')
-  })
-})

package/test/system/system_status.test.ts

@@ -1,109 +0,0 @@
-import assert from 'assert'
-import child_process from 'child_process'
-
-import * as androidUtils from '../../src/utils/android/utils.js'
-import * as iosUtils from '../../src/utils/ios/utils.js'
-import * as systemStatus from '../../src/system/index.js'
-
-const origExecSync = child_process.execSync
-const origEnsure = (androidUtils as any).ensureAdbAvailable
-const origGetXcrun = (iosUtils as any).getXcrunCmd
-
-function mockExec(behaviour: (cmd: string) => string) {
-  (child_process as any).execSync = (cmd: string) => {
-    const s = typeof cmd === 'string' ? cmd : (Array.isArray(cmd) ? cmd.join(' ') : String(cmd))
-    const out = behaviour(s)
-    if (out instanceof Error) throw out
-    return out
-  }
-}
-
-function restoreExec() {
-  (child_process as any).execSync = origExecSync
-}
-
-function mockEnsure(returnVal: any) {
-  (androidUtils as any).ensureAdbAvailable = () => returnVal
-}
-
-function restoreEnsure() {
-  (androidUtils as any).ensureAdbAvailable = origEnsure
-}
-
-function mockGetXcrun(val: string) {
-  (iosUtils as any).getXcrunCmd = () => val
-}
-
-function restoreGetXcrun() {
-  (iosUtils as any).getXcrunCmd = origGetXcrun
-}
-
-describe('system_status checks', () => {
-  afterEach(() => {
-    restoreExec(); restoreEnsure(); restoreGetXcrun()
-  })
-
-  it('reports healthy system when adb and xcrun present', async () => {
-    mockEnsure({ adbCmd: 'adb', ok: true, version: '8.1.0' })
-    mockGetXcrun('xcrun')
-
-    mockExec((cmd) => {
-      if (cmd.startsWith('adb devices')) return 'List of devices attached\nemulator-5554\tdevice'
-      if (cmd.includes('adb logcat')) return 'I/Tag: ok'
-      if (cmd.includes('adb shell pm path')) return 'package:/data/app/com.example-1/base.apk'
-      if (cmd.startsWith('xcrun --version')) return 'xcrun version 123'
-      if (cmd.includes('simctl list devices booted --json')) return JSON.stringify({ devices: {} })
-      return ''
-    })
-
-    const res = await systemStatus.getSystemStatus()
-    assert.strictEqual(res.success, true)
-    assert.strictEqual(res.adbAvailable, true)
-    assert.strictEqual(typeof res.adbVersion, 'string')
-  })
-
-  it('reports adb missing', async () => {
-    mockEnsure({ adbCmd: 'adb', ok: false, error: 'not found' })
-    mockGetXcrun('xcrun')
-    mockExec((cmd) => {
-      if (cmd.startsWith('xcrun --version')) return 'xcrun version'
-      return ''
-    })
-
-    const res = await systemStatus.getSystemStatus()
-    assert.strictEqual(res.success, false)
-    assert(res.issues.some((i: string) => i.includes('ADB')))
-  })
-
-  it('detects unauthorized/offline devices', async () => {
-    mockEnsure({ adbCmd: 'adb', ok: true, version: '8.1.0' })
-    mockGetXcrun('xcrun')
-    mockExec((cmd) => {
-      if (cmd.startsWith('adb devices')) return 'List of devices attached\nserial1\tunauthorized\nserial2\toffline\n'
-      if (cmd.startsWith('xcrun --version')) return 'xcrun version'
-      return ''
-    })
-
-    const res = await systemStatus.getSystemStatus()
-    assert.strictEqual(res.success, false)
-    assert(res.issues.some((i: string) => i.includes('unauthorized')))
-    assert(res.issues.some((i: string) => i.includes('offline')))
-  })
-
-  it('handles missing xcrun gracefully', async () => {
-    mockEnsure({ adbCmd: 'adb', ok: true, version: '8.1.0' })
-    mockGetXcrun('xcrun')
-    mockExec((cmd) => {
-      if (cmd.startsWith('adb devices')) return 'List of devices attached\nemulator-5554\tdevice'
-      if (cmd.startsWith('xcrun --version')) throw new Error('not found')
-      return ''
-    })
-
-    const res = await systemStatus.getSystemStatus()
-    // Expect iOS check to be false and Android to be healthy
-    assert.strictEqual(res.iosAvailable, false)
-    assert.strictEqual(res.adbAvailable, true)
-    // overall success may still be true (Android ok) but issues should include an xcrun-related message
-    assert(res.issues.some((i: string) => i.toLowerCase().includes('xcrun') || i.toLowerCase().includes('ios')))
-  })
-})