mobile-debug-mcp 0.34.0 → 0.35.0

package/src/server/common.ts

@@ -1,27 +1,9 @@
-import { currentEvidenceActionId } from '../observe/evidence.js'
 import { recordTiming } from '../utils/timing.js'
-import type {
-  ActionTrace,
-  ActionExecutionResult,
-  ActionFailureCode,
-  ActionTargetResolved,
-  FailureClass,
-  RecoveryState,
-  TraceResult,
-  TraceStage,
-  TraceStep
-} from '../types.js'
-import { ToolsObserve } from '../observe/index.js'
-import { isConditionBlocked } from '../interact/conditional-action.js'
-
-export const DEFAULT_MAX_RECOVERY_ATTEMPTS = 3
-export const DEFAULT_MAX_RETRY_DEPTH = 3
-
 export function wrapResponse<T>(data: T, includeSerializationTiming = true) {
   const start = performance.now()
   let text = JSON.stringify(data, null, 2)
   const elapsed = performance.now() - start
-  const value = data as any
+  const value = data as { timing?: { serialization_ms?: number } } | null
   if (includeSerializationTiming && value && typeof value === 'object' && value.timing && typeof value.timing === 'object') {
     value.timing.serialization_ms = (value.timing.serialization_ms ?? 0) + elapsed
     recordTiming('serialization_ms', elapsed)
@@ -86,351 +68,17 @@ export function getArrayArg<T>(args: ToolCallArgs, key: string): T[] | undefined
   return Array.isArray(value) ? value as T[] : undefined
 }
 
-let actionSequence = 0
-
-export function nextActionId(actionType: string, timestamp: number) {
-  const current = currentEvidenceActionId()
-  if (current) return current
-  actionSequence += 1
-  return `${actionType}_${timestamp}_${actionSequence}`
-}
-
-export async function captureActionFingerprint(platform?: 'android' | 'ios', deviceId?: string): Promise<string | null> {
-  if (isConditionBlocked()) return null
-  if (!platform) return null
-  try {
-    const result = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId }) as any
-    return result?.fingerprint ?? null
-  } catch {
-    return null
-  }
-}
-
-export function createTraceStep({
-  stage,
-  timestamp,
-  result,
-  attemptIndex,
-  cycleId,
-  metadata
-}: {
-  stage: TraceStage
-  timestamp: number
-  result: TraceResult
-  attemptIndex: number
-  cycleId?: number
-  metadata?: Record<string, unknown>
-}): TraceStep {
-  return {
-    stage,
-    timestamp,
-    result,
-    attempt_index: attemptIndex,
-    ...(cycleId !== undefined ? { cycle_id: cycleId } : {}),
-    ...(metadata ? { metadata } : {})
-  }
-}
-
-export function buildActionTrace({
-  actionId,
-  actionType,
-  sourceModule,
-  selector,
-  resolved,
-  success,
-  failure,
-  details,
-  recovery,
-  attempts = 1,
-  steps
-}: {
-  actionId: string
-  actionType: string
-  sourceModule: 'server' | 'interact'
-  selector: Record<string, unknown> | null
-  resolved?: Partial<ActionTargetResolved> | null
-  success: boolean
-  failure?: { failureCode: ActionFailureCode; retryable: boolean }
-  details?: Record<string, unknown>
-  recovery?: RecoveryState
-  attempts?: number
-  steps?: TraceStep[]
-}): ActionTrace {
-  if (steps && steps.length > 0) {
-    return {
-      action_id: actionId,
-      steps,
-      final_outcome: success ? 'success' : 'failure',
-      attempts: Math.max(1, Math.floor(attempts || steps.length))
-    }
-  }
-
-  const start = Date.now()
-  const builtSteps: TraceStep[] = []
-  let attemptIndex = 0
-  const totalAttempts = Math.max(1, Math.floor(attempts || 1))
-
-  if (selector || resolved) {
-    const stageResult: TraceResult = resolved ? 'success' : 'failure'
-    builtSteps.push(createTraceStep({
-      stage: 'resolve',
-      timestamp: start,
-      result: stageResult,
-      attemptIndex: attemptIndex++,
-      metadata: {
-        action_type: actionType,
-        source_module: sourceModule,
-        selector: selector ?? null,
-        resolved: resolved ? normalizeResolvedTarget(resolved) : null
-      }
-    }))
-  }
-
-  builtSteps.push(createTraceStep({
-    stage: 'execute',
-    timestamp: Date.now(),
-    result: success ? 'success' : 'failure',
-    attemptIndex: attemptIndex++,
-    metadata: {
-      action_type: actionType,
-      source_module: sourceModule,
-      ...(failure ? { failure_code: failure.failureCode, retryable: failure.retryable } : {})
-    }
-  }))
-
-  const hasStabilizeDetails = Boolean(details && (
-    Object.prototype.hasOwnProperty.call(details, 'stabilization_attempts') ||
-    Object.prototype.hasOwnProperty.call(details, 'stable_observation_count') ||
-    Object.prototype.hasOwnProperty.call(details, 'snapshot_freshness_ms')
-  ))
-  const hasVerifyDetails = Boolean(details && (
-    Object.prototype.hasOwnProperty.call(details, 'within_tolerance') ||
-    Object.prototype.hasOwnProperty.call(details, 'converged') ||
-    Object.prototype.hasOwnProperty.call(details, 'observed_state')
-  ))
-
-  if (hasStabilizeDetails) {
-    builtSteps.push(createTraceStep({
-      stage: 'stabilize',
-      timestamp: Date.now(),
-      result: success ? 'success' : 'failure',
-      attemptIndex: attemptIndex++,
-      metadata: {
-        stabilization_attempts: (details?.stabilization_attempts as number | undefined) ?? null,
-        stable_observation_count: (details?.stable_observation_count as number | undefined) ?? null,
-        snapshot_freshness_ms: (details?.snapshot_freshness_ms as number | undefined) ?? null
-      }
-    }))
-  }
-
-  if (hasVerifyDetails) {
-    builtSteps.push(createTraceStep({
-      stage: 'verify',
-      timestamp: Date.now(),
-      result: success ? 'success' : 'failure',
-      attemptIndex: attemptIndex++,
-      metadata: {
-        within_tolerance: details?.within_tolerance ?? null,
-        converged: details?.converged ?? null,
-        actual_state: details?.actual_state ?? null,
-        reason: details?.reason ?? null
-      }
-    }))
-  }
-
-  if (failure) {
-    builtSteps.push(createTraceStep({
-      stage: 'recover',
-      timestamp: Date.now(),
-      result: failure.retryable ? 'retry' : 'failure',
-      attemptIndex: attemptIndex++,
-      metadata: {
-        failure_class: recovery?.failure_class ?? mapFailureCodeToFailureClass(failure.failureCode),
-        runtime_code: failure.failureCode,
-        retry_allowed: failure.retryable,
-        recovery_attempts: recovery?.recovery_attempts ?? 0,
-        retry_depth: recovery?.retry_depth ?? 0
-      }
-    }))
-  }
-
-  if (!builtSteps.length) {
-    builtSteps.push(createTraceStep({
-      stage: 'execute',
-      timestamp: start,
-      result: success ? 'success' : 'failure',
-      attemptIndex: 0,
-      metadata: { action_type: actionType, source_module: sourceModule }
-    }))
-  }
-
-  return {
-    action_id: actionId,
-    steps: builtSteps,
-    final_outcome: success ? 'success' : 'failure',
-    attempts: totalAttempts
-  }
-}
-
-export function normalizeResolvedTarget(value: Partial<ActionTargetResolved> | null = null): ActionTargetResolved | null {
-  if (!value) return null
-  return {
-    elementId: value.elementId ?? null,
-    text: value.text ?? null,
-    resource_id: value.resource_id ?? null,
-    accessibility_id: value.accessibility_id ?? null,
-    class: value.class ?? null,
-    bounds: value.bounds ?? null,
-    index: value.index ?? null,
-    state: value.state ?? null
-  }
-}
-
-export function inferGenericFailure(message: string | undefined): { failureCode: ActionFailureCode; retryable: boolean } {
-  if (message && /timeout/i.test(message)) return { failureCode: 'TIMEOUT', retryable: true }
-  if (message && /semantic mismatch/i.test(message)) return { failureCode: 'SEMANTIC_MISMATCH', retryable: false }
-  return { failureCode: 'UNKNOWN', retryable: false }
-}
-
-export function inferScrollFailure(message: string | undefined): { failureCode: ActionFailureCode; retryable: boolean } {
-  if (message && /unchanged|no change|end of list/i.test(message)) return { failureCode: 'NAVIGATION_NO_CHANGE', retryable: true }
-  if (message && /timeout/i.test(message)) return { failureCode: 'TIMEOUT', retryable: true }
-  return { failureCode: 'UNKNOWN', retryable: false }
-}
-
-const ACTION_LIFECYCLE_STATE_BY_OUTCOME = {
-  success: 'pending_verification',
-  failure: 'failed'
-} as const
-
-export function determineActionLifecycleState({
-  success,
-  failure
-}: {
-  success: boolean
-  failure?: { failureCode: ActionFailureCode; retryable: boolean }
-}): NonNullable<ActionExecutionResult['lifecycle_state']> {
-  if (failure) return ACTION_LIFECYCLE_STATE_BY_OUTCOME.failure
-  if (success) return ACTION_LIFECYCLE_STATE_BY_OUTCOME.success
-  return ACTION_LIFECYCLE_STATE_BY_OUTCOME.success
-}
-
-function mapFailureCodeToFailureClass(code: ActionFailureCode): FailureClass {
-  switch (code) {
-    case 'ELEMENT_NOT_FOUND':
-    case 'AMBIGUOUS_TARGET':
-    case 'STALE_REFERENCE':
-      return 'TargetResolutionFailure'
-    case 'ELEMENT_NOT_INTERACTABLE':
-    case 'PRECONDITION_FAILED':
-    case 'PRECONDITION_UNAVAILABLE':
-    case 'ACTION_TIMEOUT':
-      return 'ExecutionFailure'
-    case 'TIMEOUT':
-    case 'ACTION_REJECTED':
-    case 'NAVIGATION_NO_CHANGE':
-    case 'UNKNOWN':
-      return 'ExecutionFailure'
-    case 'VERIFICATION_FAILED':
-    case 'EXPECT_STATE_MISMATCH':
-    case 'ASSERTION_TIMEOUT':
-      return 'VerificationFailure'
-    case 'CONTROL_CONVERGENCE_FAILED':
-      return 'ControlConvergenceFailure'
-    case 'SEMANTIC_MISMATCH':
-      return 'SemanticMismatchFailure'
-  }
-}
-
-function buildRecoveryState(failureCode: ActionFailureCode, retryable: boolean): RecoveryState {
-  return {
-    failure_class: mapFailureCodeToFailureClass(failureCode),
-    runtime_code: failureCode,
-    recovery_attempts: 0,
-    max_recovery_attempts: DEFAULT_MAX_RECOVERY_ATTEMPTS,
-    retry_depth: 0,
-    max_retry_depth: DEFAULT_MAX_RETRY_DEPTH,
-    is_terminal: false,
-    retry_allowed: retryable
-  }
-}
-
-export function buildActionExecutionResult({
-  actionType,
-  device,
-  selector,
-  resolved,
-  success,
-  uiFingerprintBefore,
-  uiFingerprintAfter,
-  failure,
-  details,
-  sourceModule,
-  traceSteps
-}: {
-  actionType: string
-  device?: ActionExecutionResult['device']
-  selector: Record<string, unknown> | null
-  resolved?: Partial<ActionTargetResolved> | null
-  success: boolean
-  uiFingerprintBefore: string | null
-  uiFingerprintAfter: string | null
-  failure?: { failureCode: ActionFailureCode; retryable: boolean }
-  details?: Record<string, unknown>
-  sourceModule: 'server' | 'interact'
-  traceSteps?: TraceStep[]
-}): ActionExecutionResult {
-  const timestampMs = Date.now()
-  const timestamp = new Date(timestampMs).toISOString()
-  const actionId = nextActionId(actionType, timestampMs)
-  const recoveryState = failure ? buildRecoveryState(failure.failureCode, failure.retryable) : undefined
-  const attempts = typeof details?.attempts === 'number' && Number.isFinite(details.attempts)
-    ? Math.max(1, Math.floor(details.attempts))
-    : 1
-  return {
-    action_id: actionId,
-    timestamp,
-    action_type: actionType,
-    lifecycle_state: determineActionLifecycleState({ success, failure }),
-    source_module: sourceModule,
-    ...(device ? { device } : {}),
-    target: {
-      selector,
-      resolved: normalizeResolvedTarget(resolved)
-    },
-    success,
-    ...(failure ? { failure_code: failure.failureCode, retryable: failure.retryable } : {}),
-    ...(recoveryState ? { recovery: recoveryState } : {}),
-    trace: buildActionTrace({
-      actionId,
-      actionType,
-      sourceModule,
-      selector,
-      resolved,
-      success,
-      failure,
-      details,
-      recovery: recoveryState,
-      attempts,
-      steps: traceSteps
-    }),
-    ui_fingerprint_before: uiFingerprintBefore,
-    ui_fingerprint_after: uiFingerprintAfter,
-    ...(details ? { details } : {})
-  }
-}
-
 export function wrapToolError(name: string, error: unknown) {
   const message = error instanceof Error
     ? error.message
     : typeof error === 'object' && error !== null
       ? (() => {
-          try {
-            return JSON.stringify(error, null, 2)
-          } catch {
-            return '[unserializable error object]'
-          }
-        })()
+        try {
+          return JSON.stringify(error, null, 2)
+        } catch {
+          return '[unserializable error object]'
+        }
+      })()
       : String(error)
   return {
     content: [{
@@ -444,3 +92,5 @@ export function wrapToolError(name: string, error: unknown) {
     }]
   }
 }
+
+export { DEFAULT_MAX_RECOVERY_ATTEMPTS, DEFAULT_MAX_RETRY_DEPTH, nextActionId, captureActionFingerprint, createTraceStep, buildActionTrace, normalizeResolvedTarget, inferGenericFailure, inferScrollFailure, determineActionLifecycleState, buildActionExecutionResult } from '../runtime/action-results.js'

package/src/server/definitions/assert.ts

@@ -0,0 +1,164 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js'
+
+export const assertTools: Tool[] = [
+{
+    name: 'expect_screen',
+    description: `Purpose:
+Deterministically verify that the intended navigation outcome of an action has occurred.
+
+Inputs:
+- fingerprint: preferred exact-match screen fingerprint
+- screen: exact semantic screen identifier when a fingerprint is not available
+
+Output Structure:
+- success: true when the expected screen matches the observed screen
+- observed_screen: current fingerprint and screen identifier
+- expected_screen: the expected fingerprint and/or screen identifier
+- confidence: 1 for an exact match, otherwise 0
+
+Recommended Usage:
+1. Define the expected screen before executing the action
+2. Resolve the target element or screen state
+3. Call an action tool such as tap_element
+4. If needed, wait for transition using wait_for_*
+5. Call expect_screen as the final verification step
+6. If success=false, treat the outcome as unverified and follow the action tool retry guidance
+
+Verification Guidance:
+- Primary and authoritative verification tool for navigation outcomes
+- Prefer fingerprint whenever you have one
+- Use screen only as a fallback exact match against known identifiers
+- Works best when the expected screen identifier is known ahead of time
+- If the expected screen is not already known, capture or define it before executing the action
+
+Constraints:
+- Returns structured binary success/failure only
+- Must not rely on natural-language interpretation or reasoning
+
+Failure Handling:
+- success=false means the expected screen was not reached; retry or recover using the action tool's failure strategy`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        platform: { type: 'string', enum: ['android', 'ios'], description: 'Optional platform override (android|ios)' },
+        fingerprint: { type: 'string', description: 'Expected screen fingerprint. Preferred verification mechanism.' },
+        screen: { type: 'string', description: 'Expected exact screen identifier when no fingerprint is available.' },
+        deviceId: { type: 'string', description: 'Optional device id/udid to target' }
+      }
+    }
+  },
+{
+    name: 'expect_element_visible',
+    description: `Purpose:
+Deterministically verify that the intended UI outcome of an action has occurred by confirming a target element is visible.
+
+Inputs:
+- selector: required selector used to resolve the target element
+- element_id: optional previously resolved element identifier used only as context
+
+Output Structure:
+- success: true when the element is visible
+- selector: selector used for verification
+- element_id: resolved element identifier when available
+- element: minimal resolved element info when visible
+- failure_code: TIMEOUT or UNKNOWN when verification fails
+- retryable: true when failure_code=TIMEOUT
+
+Recommended Usage:
+1. Define the expected element state before executing the action
+2. Resolve the target element or triggering control
+3. Call an action tool such as tap_element
+4. If needed, wait for UI availability using wait_for_*
+5. Call expect_element_visible as the final verification step
+6. If success=false, follow the action tool retry guidance
+
+Verification Guidance:
+- Primary and authoritative verification tool for expected element appearance or visibility
+- Use this when the screen should stay the same but the UI should reveal or update a specific element
+- selector is the primary input; element_id is an optional optimization only
+- The tool resolves the selector internally when needed
+
+Constraints:
+- Returns structured binary success/failure only
+- Must not rely on natural-language interpretation or reasoning
+
+Failure Handling:
+- TIMEOUT → retry verification once or retry the action after re-resolving
+- UNKNOWN → capture a snapshot and stop`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        selector: {
+          type: 'object',
+          properties: {
+            text: { type: 'string' },
+            resource_id: { type: 'string' },
+            accessibility_id: { type: 'string' },
+            contains: { type: 'boolean', default: false }
+          }
+        },
+        element_id: { type: 'string', description: 'Optional previously resolved element identifier.' },
+        timeout_ms: { type: 'number', default: 5000 },
+        poll_interval_ms: { type: 'number', default: 300 },
+        platform: { type: 'string', enum: ['android', 'ios'], description: 'Optional platform override' },
+        deviceId: { type: 'string', description: 'Optional device serial/udid' }
+      },
+      required: ['selector']
+    }
+  },
+{
+    name: 'expect_state',
+    description: `Purpose:
+Verify a readable UI state property on the currently visible element.
+
+Inputs:
+- selector or element_id
+- property
+- expected
+- platform/deviceId (optional)
+
+Supported properties:
+- checked, selected, focused, expanded, enabled, text_value, value, raw_value
+
+Verification Guidance:
+- Use this when the UI element is visible but its state must also be confirmed
+- Prefer the canonical property names above
+- The tool compares the normalized readable state and returns the observed value when available
+
+Constraints:
+- Returns structured success/failure only
+- Does not infer a state when the property is unavailable
+
+Failure Handling:
+- ELEMENT_NOT_FOUND → re-resolve the element or wait for UI stabilization
+- UNKNOWN → capture a snapshot and stop`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        selector: {
+          type: 'object',
+          properties: {
+            text: { type: 'string' },
+            resource_id: { type: 'string' },
+            accessibility_id: { type: 'string' },
+            contains: { type: 'boolean', default: false }
+          }
+        },
+        element_id: { type: 'string', description: 'Optional previously resolved element identifier.' },
+        property: { type: 'string', description: 'Readable state property to verify.' },
+        expected: {
+          description: 'Expected normalized state value.',
+          oneOf: [
+            { type: 'boolean' },
+            { type: 'number' },
+            { type: 'string' },
+            { type: 'object' }
+          ]
+        },
+        platform: { type: 'string', enum: ['android', 'ios'], description: 'Optional platform override' },
+        deviceId: { type: 'string', description: 'Optional device serial/udid' }
+      },
+      required: ['property', 'expected']
+    }
+  }
+]

package/src/server/definitions/diagnostic.ts

@@ -0,0 +1,120 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js'
+
+export const diagnosticTools: Tool[] = [
+{
+    name: 'get_system_status',
+    description: 'Quick healthcheck of local mobile debugging environment (adb, devices, logs, env, iOS).',
+    inputSchema: { type: 'object', properties: {} }
+  },
+{
+    name: 'classify_action_outcome',
+    description: `Classify the outcome of the most recent action into exactly one of: success, no_op, backend_failure, ui_failure, unknown.
+
+Use the runtime action result's \`action_type\` as \`actionType\` so the classifier can distinguish local-state actions from side-effect actions.
+Use this when the intended outcome is not already fully verified by the UI signal alone.
+For backend/API activity, compare get_screen_fingerprint before and after the action and call get_network_activity immediately after the action if the outcome is still ambiguous.
+
+HOW TO GATHER INPUTS before calling:
+1. Call wait_for_screen_change or compare get_screen_fingerprint before/after — set uiChanged accordingly.
+2. If you checked for a specific element with wait_for_ui, set expectedElementVisible.
+3. Pass actionType from the action response when available.
+4. Only provide networkRequests if you already collected them or want to classify a side-effect action with backend evidence.
+
+RULES (applied in order — stop at first match):
+1. If uiChanged=true OR expectedElementVisible=true → outcome=success
+2. If actionType is missing → outcome=unknown
+3. If any request has status=failure or retryable → outcome=backend_failure
+4. If actionType maps to a local-state action → outcome=no_op; prefer state-based verification and avoid default network fallback
+5. If actionType maps to a side-effect action and no networkRequests were supplied → outcome=unknown
+6. If no requests returned → outcome=no_op
+7. If all requests succeeded → outcome=ui_failure
+8. Otherwise → outcome=unknown
+
+BEHAVIOUR after outcome:
+- success → continue
+- no_op → retry with richer state verification or re-resolve the element
+- backend_failure → stop and report the failing endpoint
+- ui_failure → stop and report failure
+- unknown → take one recovery step (e.g. capture_debug_snapshot), then stop`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        uiChanged: {
+          type: 'boolean',
+          description: 'true if the screen fingerprint or activity changed after the action. Use wait_for_screen_change or compare get_screen_fingerprint before and after.'
+        },
+        expectedElementVisible: {
+          type: 'boolean',
+          description: 'true if the element you expected to appear is now visible (from wait_for_ui). Omit if you did not check for a specific element.'
+        },
+        actionType: {
+          type: 'string',
+          description: 'The runtime action_type from the action response (for example tap, tap_element, swipe, type_text, press_back, start_app).'
+        },
+        networkRequests: {
+          type: 'array',
+          description: 'Optional network evidence collected after the action. Use it when the expected outcome is backend/API activity or when the UI signal is ambiguous.',
+          items: {
+            type: 'object',
+            properties: {
+              endpoint: { type: 'string', description: 'Request endpoint or full URL' },
+              status: { type: 'string', enum: ['success', 'failure', 'retryable'], description: 'Outcome of the request' }
+            },
+            required: ['endpoint', 'status']
+          }
+        },
+        hasLogErrors: {
+          type: 'boolean',
+          description: 'true if structured log errors were observed (e.g. from read_log_stream). Optional — include if you have already read logs.'
+        }
+      },
+      required: ['uiChanged']
+    }
+  },
+{
+    name: 'run_journey',
+    description: 'Run an ordered, bounded sequence of start_app, tap, wait, and deterministic assertion steps against one device. Stops after the first failed step.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        platform: { type: 'string', enum: ['android', 'ios'] },
+        deviceId: { type: 'string' },
+        responseMode: { type: 'string', enum: ['compact', 'debug'], default: 'compact' },
+        steps: { type: 'array', minItems: 1, maxItems: 50, items: { type: 'object', properties: { id: { type: 'string' }, type: { type: 'string', enum: ['start_app', 'tap', 'wait', 'assert'] } }, required: ['id', 'type'] } }
+      },
+      required: ['platform', 'steps']
+    }
+  },
+{
+    name: 'get_network_activity',
+    description: `Returns structured network events captured from platform logs since the last action.
+
+Call this immediately after an action when you want backend evidence for a side-effect flow, only if the result is still ambiguous.
+Do not call more than once per action.
+
+Events are filtered to significant (non-background) requests only.
+Each event includes endpoint, method, statusCode, networkError, status, and durationMs.
+
+status values:
+- success: HTTP 2xx or request detected with no error signal
+- failure: HTTP 4xx
+- retryable: HTTP 5xx, network error (timeout, dns_error, tls_error, etc.)
+
+Returns { requests: [], count: 0 } when no credible network signals are found.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        platform: {
+          type: 'string',
+          enum: ['android', 'ios'],
+          description: 'Platform to read network logs from'
+        },
+        deviceId: {
+          type: 'string',
+          description: 'Device Serial (Android) or UDID (iOS). Defaults to connected/booted device.'
+        }
+      },
+      required: ['platform']
+    }
+  }
+]