mobile-debug-mcp 0.34.0 → 0.36.0

package/dist/server/{journey-schema.js → schemas/journey-schema.js}

@@ -1,19 +1,12 @@
+import { verificationModeSchema, responseModeSchema, verificationModeJson } from '../../contracts/execution-controls.js';
+import { waitForSchema as waitFor, targetFields as target, exactlyOneTarget, targetJson, oneTargetJson } from '../../contracts/target.js';
+export { tapElementControlsSchema } from '../../contracts/target.js';
+import { selectorSchema as selector, selectorJson } from '../../contracts/selector.js';
 import { z } from 'zod';
 import { expectedStateSchema, expectedStateJson } from './condition-schema.js';
-const selector = z.object({
-    text: z.string().min(1).optional(), resource_id: z.string().min(1).optional(),
-    accessibility_id: z.string().min(1).optional(), contains: z.boolean().optional()
-}).strict().refine(value => !!(value.text || value.resource_id || value.accessibility_id), 'Selector requires a target');
-const verificationMode = z.enum(['none', 'light', 'full']);
+const verificationMode = verificationModeSchema;
 const timeoutMs = z.number().int().min(100).max(60000).optional();
 const pollIntervalMs = z.number().int().min(50).max(1000).optional();
-const waitFor = z.object({
-    condition: z.enum(['exists', 'visible', 'clickable']).optional(),
-    timeoutMs: z.number().int().min(100).max(10000).optional(), pollIntervalMs,
-    match: z.object({ index: z.number().int().nonnegative().optional() }).strict().optional()
-}).strict();
-const target = { selector: selector.optional(), elementId: z.string().min(1).optional() };
-const exactlyOneTarget = (value) => Number(!!value.selector) + Number(!!value.elementId) === 1;
 const assertion = z.union([
     z.object({ kind: z.literal('element_visible'), selector }).strict(),
     z.object({ kind: z.literal('element_absent'), selector }).strict(),
@@ -27,23 +20,15 @@ const step = z.union([
     z.object({ id, type: z.literal('wait'), selector, condition: z.enum(['exists', 'not_exists', 'visible', 'clickable']).optional(), timeoutMs, pollIntervalMs }).strict(),
     z.object({ id, type: z.literal('assert'), assertion, timeoutMs, pollIntervalMs }).strict()
 ]);
-export const tapElementControlsSchema = z.object({
-    elementId: z.string().min(1).optional(), selector: selector.optional(), waitFor: waitFor.optional()
-}).strict().refine(value => Number(!!value.elementId) + Number(!!value.selector) === 1 && (!value.elementId || !value.waitFor));
 export const journeySchema = z.object({
     platform: z.enum(['android', 'ios']), deviceId: z.string().min(1).optional(),
     systemTraceId: z.string().uuid().optional(),
-    responseMode: z.enum(['compact', 'debug']).default('compact'), captureOnFailure: z.boolean().default(false),
+    responseMode: responseModeSchema.default('compact'), captureOnFailure: z.boolean().default(false),
     defaults: z.object({ verificationMode: verificationMode.optional(), actionTimeoutMs: z.number().int().finite().optional(), verificationTimeoutMs: z.number().int().finite().optional() }).strict().optional(),
     steps: z.array(step).min(1).max(50)
 }).strict().refine(value => new Set(value.steps.map(step => step.id)).size === value.steps.length, 'Step IDs must be unique');
-const selectorJson = { type: 'object', additionalProperties: false, properties: {
-        text: { type: 'string', minLength: 1 }, resource_id: { type: 'string', minLength: 1 }, accessibility_id: { type: 'string', minLength: 1 }, contains: { type: 'boolean' }
-    }, anyOf: ['text', 'resource_id', 'accessibility_id'].map(key => ({ required: [key] })) };
-const targetJson = { selector: selectorJson, elementId: { type: 'string', minLength: 1 } };
-const oneTargetJson = [{ required: ['selector'], not: { required: ['elementId'] } }, { required: ['elementId'], not: { required: ['selector'] } }];
 const intervalJson = { timeoutMs: { type: 'integer', minimum: 100, maximum: 60000 }, pollIntervalMs: { type: 'integer', minimum: 50, maximum: 1000 } };
-const modeJson = { type: 'string', enum: ['none', 'light', 'full'] };
+const modeJson = verificationModeJson;
 const objectJson = (properties, required, extra = {}) => ({ type: 'object', additionalProperties: false, properties, required, ...extra });
 export const journeyStepsJson = {
     type: 'array', minItems: 1, maxItems: 50, items: { oneOf: [

package/dist/server/schemas/system-trace-schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+const target = { platform: z.enum(['android', 'ios']), deviceId: z.string().min(1).optional(), appId: z.string().regex(/^[a-zA-Z0-9._-]+$/).optional(), template: z.enum(['System Trace', 'Time Profiler', 'Animation Hitches', 'Hangs']).optional() };
+const validTarget = (value) => value.platform === 'ios' ? !!value.deviceId : value.appId === undefined && value.template === undefined;
+export const traceTargetSchema = z.object(target).strict().refine(validTarget);
+export const traceStartSchema = z.object({ ...target, durationMs: z.number().int().min(1000).max(120000).default(30000) }).strict().refine(validTarget).refine(value => value.platform !== 'ios' || !!value.appId);
+export const traceControlSchema = z.object({ traceId: z.string().uuid() }).strict();
+const properties = { platform: { type: 'string', enum: ['android', 'ios'] }, deviceId: { type: 'string', minLength: 1 }, appId: { type: 'string', minLength: 1, pattern: '^[a-zA-Z0-9._-]+$', description: 'iOS only: running development app bundle identifier; required for iOS start.' }, template: { type: 'string', enum: ['System Trace', 'Time Profiler', 'Animation Hitches', 'Hangs'], description: 'iOS only. Default Time Profiler; initial simulator support is Time Profiler only.' } };
+const platformRules = (start) => ({ oneOf: [
+        { properties: { platform: { const: 'android' } }, not: { anyOf: [{ required: ['appId'] }, { required: ['template'] }] } },
+        { properties: { platform: { const: 'ios' } }, required: start ? ['deviceId', 'appId'] : ['deviceId'] }
+    ] });
+export const systemTraceTools = [
+    { name: 'get_system_trace_capabilities', description: 'Probe Android Perfetto or iOS Instruments prerequisites without recording. iOS requires explicit booted simulator deviceId; reports template matrix and unknown profiling permissions.',
+        inputSchema: { type: 'object', additionalProperties: false, required: ['platform'], properties, ...platformRules(false) } },
+    { name: 'start_system_trace', description: 'Start bounded Android Perfetto or iOS simulator Time Profiler recording, returning an owned trace_id after readiness. iOS requires explicit deviceId and running appId. Run an existing journey with systemTraceId, then stop to retrieve a local artifact or cancel to discard. Traces can contain sensitive system metadata, logs and paths; local user-managed retention, no upload.',
+        inputSchema: { type: 'object', additionalProperties: false, required: ['platform'], properties: { ...properties, durationMs: { type: 'integer', minimum: 1000, maximum: 120000, default: 30000 } }, ...platformRules(true) } },
+    ...['get_system_trace_status', 'stop_system_trace', 'cancel_system_trace'].map(name => ({ name,
+        description: name === 'get_system_trace_status' ? 'Reconcile an owned trace and retrieve its state; finalise duration-completed capture.' :
+            name === 'stop_system_trace' ? 'Stop owned capture gracefully and retrieve a local Perfetto file or validated Instruments .trace bundle. Retry after a transfer/cleanup failure.' : 'Stop owned capture and discard partial files. Already completed local artifacts are retained.',
+        inputSchema: { type: 'object', additionalProperties: false, required: ['traceId'], properties: { traceId: { type: 'string', format: 'uuid' } } }
+    }))
+];