mobile-debug-mcp 0.34.0 → 0.36.0

package/test/unit/quality/agent-plugin-export.test.ts

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import { mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = fileURLToPath(new URL('../../../', import.meta.url))
+const temporary = await mkdtemp(path.join(os.tmpdir(), 'agent-plugin-export-'))
+const output = path.join(temporary, 'plugin')
+const exportPlugin = () => spawnSync(process.execPath, ['scripts/agent-plugin.mjs', '--export-antigravity', output], { cwd: root, encoding: 'utf8', timeout: 10000 })
+try {
+  const exported = exportPlugin()
+  assert.equal(exported.status, 0, exported.stderr)
+  assert.deepEqual((await readdir(output)).sort(), ['LICENSE', 'README.md', 'assets', 'mcp_config.json', 'plugin.json', 'skills'])
+  for (const directory of ['skills', 'assets']) {
+    const files = await readdir(path.join(output, directory), { recursive: true })
+    assert.ok(files.every(file => path.basename(file) !== '.DS_Store' && !path.basename(file).startsWith('._')), 'Export must exclude Finder metadata')
+  }
+  const manifest = JSON.parse(await readFile(path.join(output, 'plugin.json'), 'utf8'))
+  assert.equal(manifest.$schema, 'https://antigravity.google/schemas/v1/plugin.json')
+  assert.ok((await readFile(path.join(output, manifest.logo))).length > 0)
+  const config = JSON.parse(await readFile(path.join(output, 'mcp_config.json'), 'utf8'))
+  assert.equal(Object.keys(config.mcpServers).length, 1)
+  const server = config.mcpServers['mobile-debug-mcp']
+  assert.equal(server.command, 'npx')
+  assert.equal(server.cwd, '${PLUGIN_DATA}')
+  assert.equal('type' in server, false, 'Antigravity infers stdio transport; type causes a strict warning')
+  const skill = 'skills/mobile-debug-mcp/SKILL.md'
+  assert.deepEqual(await readFile(path.join(output, skill)), await readFile(path.join(root, 'agent-plugin', skill)))
+  assert.deepEqual(await readFile(path.join(output, 'LICENSE')), await readFile(path.join(root, 'LICENSE')))
+  await writeFile(path.join(output, 'keep.txt'), 'existing user data')
+  assert.notEqual(exportPlugin().status, 0, 'Existing destinations must not be overwritten or merged')
+  assert.equal(await readFile(path.join(output, 'keep.txt'), 'utf8'), 'existing user data')
+  console.log('PASS Antigravity export: native inventory, shared skill/license, no foreign manifests, overwrite refusal')
+} finally {
+  await rm(temporary, { recursive: true, force: true })
+}

package/test/unit/quality/architecture.test.ts

@@ -0,0 +1,60 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { architectureGraph } from '../../../scripts/architecture-graph.mjs'
+import { checkArchitecture } from '../../../scripts/check-architecture.mjs'
+
+const root = await mkdtemp(path.join(tmpdir(), 'mcp-architecture-'))
+try {
+  const files: Record<string, string> = {
+    'package.json': JSON.stringify({ type: 'module' }),
+    'tsconfig.json': JSON.stringify({ compilerOptions: {
+      module: 'NodeNext', moduleResolution: 'NodeNext', target: 'ES2022',
+      paths: { '@server/*': ['./src/server/*'] }
+    }, include: ['src/**/*.ts'] }),
+    'src/server/entry.ts': 'export const value = 1',
+    'src/contracts/bad.ts': "export { value } from '@server/entry.js'",
+    'src/interact/entry.ts': "export const load = () => import('../server/entry.js')",
+    'src/interact/adjustment/control-values.ts': "import { spawn } from 'node:child_process'; export const native = spawn",
+    'src/cycle/a.ts': "export { b } from './b.js'; export const a = 1",
+    'src/cycle/b.ts': "export const b = () => import('./a.js')",
+    'src/type-cycle/a.ts': "import type { B } from './b.js'; export interface A { b: B }",
+    'src/type-cycle/b.ts': "import { type A } from './a.js'; export interface B { a: A }",
+    'src/import-equals.ts': "import entry = require('./server/entry.js'); export { entry }",
+    'src/require.ts': "export const load = () => require('./server/entry.js')"
+  }
+  for (const [file, code] of Object.entries(files)) {
+    const target = path.join(root, file)
+    await mkdir(path.dirname(target), { recursive: true })
+    await writeFile(target, code)
+  }
+  const config = path.join(root, 'tsconfig.json')
+  const graph = await architectureGraph(config)
+  const edge = (source: string, target: string) => graph.find(item => item.source === source && item.target === target)
+  assert(edge('src/contracts/bad.ts', 'src/server/entry.ts'), 'Resolve aliased re-exports to .ts sources')
+  assert(edge('src/interact/entry.ts', 'src/server/entry.ts'), 'Resolve literal dynamic .js imports')
+  assert(edge('src/require.ts', 'src/server/entry.ts'), 'Resolve literal require calls')
+  assert(edge('src/interact/adjustment/control-values.ts', 'node:child_process'), 'Include Node builtins')
+  assert.deepEqual(edge('src/type-cycle/b.ts', 'src/type-cycle/a.ts')?.importKinds, ['type'])
+  assert(edge('src/import-equals.ts', 'src/server/entry.ts'), 'Resolve import-equals require syntax')
+  const rejected = spawnSync(process.execPath, ['scripts/check-architecture.mjs', config], { encoding: 'utf8' })
+  assert.equal(rejected.status, 1, rejected.stderr)
+  assert(rejected.stderr.includes('Production runtime dependencies must be cycle-free'))
+  const results = checkArchitecture(graph)
+  assert(results.every(result => result.violations.length > 0), 'Every rule must reject its deliberately broken fixture')
+  const cycles = JSON.stringify(results.at(-1)?.violations)
+  assert(cycles.includes('src/cycle/a.ts'), 'Catch a cycle through a re-export and dynamic import')
+  assert(!cycles.includes('src/type-cycle'), 'Type-only cycles are not runtime cycles')
+  assert(checkArchitecture([]).every(result => result.violations.length > 0), 'An empty graph must fail closed')
+
+  await writeFile(path.join(root, 'src/nonliteral.ts'), 'export const load = (name: string) => import(name)')
+  await assert.rejects(architectureGraph(config), /Nonliteral dependency/)
+  await rm(path.join(root, 'src/nonliteral.ts'))
+  await writeFile(path.join(root, 'src/unresolved.ts'), "import './missing.js'")
+  await assert.rejects(architectureGraph(config), /Unresolved dependency/)
+  console.log('PASS architecture negative controls: NodeNext, aliases, re-exports, dynamic/require imports, pure boundaries, runtime cycles, type-only cycles, empty and unresolved graphs')
+} finally {
+  await rm(root, { recursive: true, force: true })
+}

package/test/unit/quality/code-quality.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict'
+import { measure, compare } from '../../../scripts/code-quality.mjs'
+
+const file = 'src/interact/quality-fixture.ts'
+const inspect = (code: string) => measure(file, code)
+const has = (findings: Awaited<ReturnType<typeof inspect>>, rule: string) => findings.some(f => f.rule === rule)
+const baseline = (findings: Awaited<ReturnType<typeof inspect>>) => findings.map(({ line: _line, ...entry }) => ({ ...entry, reason: 'Test legacy exception' }))
+
+async function main() {
+  assert.deepEqual(await inspect('export const twice = (value: number) => value * 2'), [])
+  const hugeClass = await inspect(`export class Huge {\n${Array.from({ length: 301 }, (_, i) => `field${i} = ${i}`).join('\n')}\n}`)
+  assert(has(hugeClass, 'class-lines'))
+  const hugeFunction = await inspect(`export function work() {\n${Array.from({ length: 81 }, (_, i) => `console.log(${i})`).join('\n')}\n}`)
+  assert(has(hugeFunction, 'max-lines-per-function'))
+  assert(has(await inspect(`export const work = () => {\n${'console.log(1)\n'.repeat(81)}}`), 'max-lines-per-function'))
+  const hugeFile = await inspect(Array.from({ length: 501 }, (_, i) => `export const value${i} = ${i}`).join('\n'))
+  assert(has(hugeFile, 'max-lines'))
+  assert(!has(await inspect(`// A comment\n${'\n// comment\n'.repeat(600)}export const x = 1`), 'max-lines'))
+  const complex = await inspect(`export function decide(value: number) { ${'if(value) console.log(value);'.repeat(21)} }`)
+  assert(has(complex, 'complexity'))
+  assert(has(await inspect('export function nested(x: boolean) { if(x){if(x){if(x){if(x){if(x){console.log(x)}}}}} }'), 'max-depth'))
+  assert(has(await inspect("import { value } from '../server/tool-handlers.js'"), 'import-boundary'))
+  assert(has(await inspect("export { value } from '../server/common.js'"), 'import-boundary'))
+  assert(has(await inspect("type Args = import('../server/common.js').ToolCallArgs"), 'import-boundary'))
+  assert(has(await inspect("const transport = require('../server/common.js')"), 'import-boundary'))
+  assert(has(await inspect('/* eslint complexity: \"off\" */\nexport const value = 1'), 'inline-suppression'))
+  assert(!has(await inspect("import type { Value } from '../contracts/value.js'"), 'import-boundary'))
+  assert(has(await inspect('// eslint-disable\nexport const x = 1'), 'inline-suppression'))
+  assert(has(await inspect('// eslint-disable-next-line complexity\nexport function f() {}'), 'inline-suppression'))
+  const any = await inspect('export function legacy(value: any) { return value }')
+  assert(has(any, 'explicit-any'))
+  assert.deepEqual(compare(any, baseline(any)), [])
+  assert(compare(any, []).some(e => e.includes('explicit-any')))
+  const grown = await inspect('export function legacy(value: any): any { return value }')
+  assert(compare(grown, baseline(any)).some(e => e.includes('explicit-any')))
+  const renamed = await inspect('export function replacement(value: any) { return value }')
+  assert(compare(renamed, baseline(any)).length >= 2, 'renames do not inherit debt')
+  const moved = any.map(f => ({ ...f, file: 'src/interact/moved.ts' }))
+  assert(compare(moved, baseline(any)).length >= 2, 'moves do not inherit debt')
+  assert(compare([], baseline(any)).some(e => e.includes('obsolete')))
+  assert(compare(any, baseline(grown)).some(e => e.includes('Lower baseline')))
+  assert(compare(any, [...baseline(any), ...baseline(any)]).some(e => e.includes('Duplicate')))
+  assert(compare(any, [{ ...baseline(any)[0], reason: '' }]).some(e => e.includes('Invalid')))
+  const collision = await inspect('function same(x: number) {return x} function same(x: number) {return x}')
+  assert(has(collision, 'duplicate-symbol'))
+  assert(compare(collision, baseline(collision)).some(e => e.includes('duplicate-symbol')), 'identity collisions cannot be baseline exceptions')
+  const suppressed = await inspect('// eslint-disable max-lines-per-function\n'+`function huge(){\n${'console.log(1)\n'.repeat(81)}}`)
+  assert(has(suppressed, 'max-lines-per-function'), 'inline directives cannot hide metrics')
+  const typeDebt = await inspect('type First = any; type Second = number')
+  const shiftedTypeDebt = await inspect('type First = number; type Second = any')
+  assert(compare(shiftedTypeDebt, baseline(typeDebt)).length >= 2, 'unrelated type declarations cannot offset each other')
+  const java = await measure('src/debugger/java/Fixture.java', 'int field;\n'.repeat(501))
+  assert(has(java, 'max-lines'))
+  assert.deepEqual(await measure('src/debugger/java/Fixture.java', '// comment\n'.repeat(501)), [])
+  assert(!has(await inspect('class Accessor { get value() { return 1 } set value(value: number) { console.log(value) } }'), 'duplicate-symbol'))
+  console.log('PASS structural metrics, debt ratchet, boundaries and suppression protection')
+}
+main().catch(error => { console.error(error); process.exitCode = 1 })

package/test/unit/quality/interaction_boundaries.test.ts

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict'
+import { readdir, readFile } from 'node:fs/promises'
+import { measure } from '../../../scripts/code-quality.mjs'
+
+// Refactored interaction services must meet defaults even if someone adds a legacy allowance.
+const legacy = new Set(['android.ts', 'ios.ts', 'conditional-action.ts', 'classify.ts'])
+async function sourceFiles(directory = ''): Promise<string[]> {
+  const entries = await readdir(`src/interact/${directory}`, { withFileTypes: true })
+  const paths: string[] = []
+  for (const entry of entries) {
+    const relative = directory ? `${directory}/${entry.name}` : entry.name
+    if (entry.isDirectory()) paths.push(...await sourceFiles(relative))
+    else if (relative.endsWith('.ts') && !legacy.has(relative)) paths.push(relative)
+  }
+  return paths
+}
+const files = await sourceFiles()
+const baseline = JSON.parse(await readFile('scripts/code-quality-baseline.json', 'utf8')) as Array<{ file: string }>
+for (const file of files) {
+  const path = `src/interact/${file}`
+  assert.deepEqual(await measure(path, await readFile(path, 'utf8')), [], `${path} must meet default structural and typing limits`)
+  assert(!baseline.some(entry => entry.file === path), `${path} cannot inherit legacy exceptions`)
+}
+console.log(`PASS default quality limits and no legacy exceptions across ${files.length} interaction modules`)

package/test/unit/server/conditional_actions.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os'
 import path from 'node:path'
 import { handleToolCall, toolDefinitions } from '../../../src/server-core.js'
 import { ToolsObserve } from '../../../src/observe/index.js'
-import { ToolsNetwork } from '../../../src/network/index.js'
+import { ToolsNetwork } from '../../../src/observe/network/index.js'
 import { deriveSnapshotMetadata, getSnapshotSessionId, resetSnapshotMetadataForTests } from '../../../src/observe/snapshot-metadata.js'
 import { _setDeviceListersForTests, _resetDeviceListersForTests } from '../../../src/utils/resolve-device.js'
 import { runWithBudget } from '../../../src/utils/operation-budget.js'

package/test/unit/server/conditional_schema.test.ts

@@ -1,8 +1,8 @@
 import assert from 'node:assert/strict'
 import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv'
 import { toolDefinitions } from '../../../src/server/tool-definitions.js'
-import { conditionalTools, validateExpectedState } from '../../../src/server/condition-schema.js'
-import { journeySchema } from '../../../src/server/journey-schema.js'
+import { conditionalTools, validateExpectedState } from '../../../src/server/schemas/condition-schema.js'
+import { journeySchema } from '../../../src/server/schemas/journey-schema.js'
 
 const provider = new AjvJsonSchemaValidator()
 const expectedState = { snapshotSessionId: 'session-fixture', snapshotRevision: 1 }

package/test/unit/server/debugger-response.test.ts

@@ -0,0 +1,63 @@
+import assert from 'node:assert/strict'
+import { debuggerResponse } from '../../../src/server/handlers/debugger-response.js'
+import { handleDebugger } from '../../../src/server/handlers/debugger-handlers.js'
+import { debuggerContracts, debuggerTools } from '../../../src/server/schemas/debugger-schema.js'
+import { debuggerSessions } from '../../../src/debugger/sessions.js'
+import { DebuggerError } from '../../../src/debugger/worker.js'
+import { diagnostic } from '../../../src/debugger/diagnostics.js'
+
+const baseline = ['capabilities', 'attach', 'state']
+const payload = {
+  success: false, debug_session_id: 'session', device: { id: 'device' }, target: { pid: 42 }, capabilities: { locals: true },
+  state: 'paused', captured_at_ms: 123, reason: null, stop: { stop_id: 'stop', thread_id: 'thread' },
+  limitations: ['SHALLOW_LOCALS'], cleanup: { status: 'failed', remaining_resources: ['forward:tcp:123'] },
+  error: { code: 'DEBUGGER_CLEANUP_FAILED', retryable: false, diagnostic: diagnostic('cleanup', 'operation_failed') },
+  execution_state: 'unknown', result: { frames: [{ frame_id: 'frame' }], truncated: true, availability: 'unknown' },
+  breakpoints: [], events: [], next_cursor: 4, overflow: true, timed_out: false, future_field: { preserve: true }
+}
+const expected = structuredClone(payload) as Record<string, unknown>
+for (const key of ['device', 'target', 'capabilities']) delete expected[key]
+const before = structuredClone(payload)
+for (const tool of debuggerTools) {
+  const contract = debuggerContracts[tool.name]
+  assert.deepEqual(tool.inputSchema.properties.responseMode, { type: 'string', enum: ['compact', 'debug'], default: 'debug' })
+  const shape = contract.schema.shape
+  assert.equal(shape.responseMode.parse(undefined), 'debug')
+  for (const mode of ['compact', 'debug']) assert.equal(shape.responseMode.parse(mode), mode)
+  assert.equal(shape.responseMode.safeParse('full').success, false)
+  assert.deepEqual(debuggerResponse(contract.command, 'debug', payload), payload)
+  assert.deepEqual(debuggerResponse(contract.command, 'compact', payload), baseline.includes(contract.command) ? payload : expected)
+  const success = { ...payload, success: true, error: undefined, cleanup: { status: 'pending', remaining_resources: ['jdi_worker'] } }
+  assert.deepEqual(debuggerResponse(contract.command, 'compact', success), baseline.includes(contract.command) ? success : { ...expected, success: true, error: undefined, cleanup: success.cleanup })
+  const noSession = { ...payload, debug_session_id: null }
+  assert.deepEqual(debuggerResponse(contract.command, 'compact', noSession), noSession)
+}
+assert.deepEqual(payload, before, 'projection must not mutate nested or shared objects')
+
+// This self-running test has its own process; restore the singleton seam in finally.
+const original = debuggerSessions.command
+try {
+  debuggerSessions.command = async (_id, _command, args) => {
+    assert.ok(!Object.hasOwn(args!, 'responseMode'), 'presentation input must not reach worker')
+    return { ...payload, success: true } as unknown as Awaited<ReturnType<typeof original>>
+  }
+  for (const mode of [undefined, 'debug', 'compact']) {
+    const response = await handleDebugger('get_debugger_locals', { debugSessionId: 'session', stopId: 'stop', frameId: 'frame', ...(mode ? { responseMode: mode } : {}) })
+    assert.equal(response.isError, undefined)
+    assert.deepEqual(JSON.parse(response.content[0].text), { ...(mode === 'compact' ? expected : payload), success: true })
+  }
+  for (const code of ['DEBUGGER_STALE_REFERENCE', 'DEBUGGER_NOT_FOUND', 'DEBUGGER_WORKER_FAILED', 'DEBUGGER_TIMEOUT', 'DEBUGGER_CANCELLED']) {
+    debuggerSessions.command = async () => { throw new DebuggerError(code, diagnostic('command', 'unknown')) }
+    for (const responseMode of ['compact', 'debug']) {
+      const response = await handleDebugger('resume_debugger', { debugSessionId: 'absent', stopId: 'old', responseMode })
+      const value = JSON.parse(response.content[0].text)
+      assert.equal(response.isError, true)
+      assert.equal(value.error.code, code)
+      assert.equal(Object.hasOwn(value, 'capabilities'), responseMode === 'debug')
+      assert.equal(value.debug_session_id, 'absent')
+    }
+  }
+  const invalid = await handleDebugger('detach_debugger', { debugSessionId: 'session', responseMode: 'full' })
+  assert.equal(JSON.parse(invalid.content[0].text).error.code, 'INVALID_ARGUMENT')
+} finally { debuggerSessions.command = original }
+console.log('PASS debugger response defaults, exact retention, failures, immutable projection and argument isolation')

package/test/unit/server/system-trace.test.ts

@@ -8,6 +8,7 @@ import { withEvidence, bindSystemTrace, bindEvidenceDevice } from '../../../src/
 const parse = (r: any) => JSON.parse(r.content[0].text)
 async function run() {
   const originalLink = systemTraces.link, originalStart = systemTraces.start, originalControl = systemTraces.control
+  const originalCapabilities = systemTraces.iosCapabilities
   const originalApp = AndroidManage.prototype.startApp
   const id = '62a51510-c303-4a1b-af0e-f97cc976d740'
   let dispatched = 0, starts = 0
@@ -24,8 +25,16 @@ async function run() {
     }
     systemTraces.start = async () => { starts++; throw new Error('must not run') }
     const ios = await handleToolCall('start_system_trace', { platform: 'ios' })
-    assert.equal(parse(ios).error.code, 'UNSUPPORTED_PLATFORM'); assert.equal(starts, 0)
-    assert.equal(parse(await handleToolCall('get_system_trace_capabilities', { platform: 'ios' })).supported, false)
+    assert.equal(parse(ios).error.code, 'INVALID_ARGUMENT'); assert.equal(starts, 0)
+    assert.equal(parse(await handleToolCall('get_system_trace_capabilities', { platform: 'ios' })).error.code, 'INVALID_ARGUMENT')
+    for (const args of [{platform:'ios',deviceId:'sim'}, {platform:'android',appId:'fixture'}, {platform:'android',template:'Time Profiler'}, {platform:'ios',deviceId:'sim',appId:'fixture',template:'Other'}, {platform:'ios',deviceId:'sim',appId:'invalid bundle'}]) {
+      assert.equal(parse(await handleToolCall('start_system_trace', args)).error.code, 'INVALID_ARGUMENT')
+    }
+    systemTraces.iosCapabilities = async (deviceId, appId, template) => {
+      assert.equal(deviceId, 'sim'); assert.equal(appId, 'fixture'); assert.equal(template, 'Time Profiler')
+      return {supported: false, backend:'xctrace'} as any
+    }
+    assert.equal(parse(await handleToolCall('get_system_trace_capabilities', {platform:'ios',deviceId:'sim',appId:'fixture',template:'Time Profiler'})).backend, 'xctrace')
     for (const name of ['stop_system_trace', 'cancel_system_trace', 'get_system_trace_status']) {
       assert.equal(parse(await handleToolCall(name, { traceId: id, deviceId: 'wrong' })).error.code, 'INVALID_ARGUMENT')
       assert.equal(parse(await handleToolCall(name, { traceId: id })).error.code, 'TRACE_NOT_FOUND')
@@ -57,7 +66,7 @@ async function run() {
     assert.equal(independent.evidence.trace_context.trace_id, null)
     console.log('system trace tool contracts and journey evidence: PASS')
   } finally {
-    systemTraces.link = originalLink; systemTraces.start = originalStart; systemTraces.control = originalControl
+    systemTraces.iosCapabilities = originalCapabilities; systemTraces.link = originalLink; systemTraces.start = originalStart; systemTraces.control = originalControl
     AndroidManage.prototype.startApp = originalApp; _resetDeviceListersForTests()
   }
 }

package/test/unit/server/tool_definitions_parity.test.ts

@@ -0,0 +1,8 @@
+import assert from 'node:assert/strict'
+import { readFile } from 'node:fs/promises'
+import { toolDefinitions } from '../../../src/server/tool-definitions.js'
+
+// Captured before structural refactoring: changes require an intentional contract review.
+const baseline = JSON.parse(await readFile(new URL('../../fixtures/contracts/tool-definitions.json', import.meta.url), 'utf8'))
+assert.deepEqual(toolDefinitions, baseline, 'Public tool order, schemas, defaults and descriptions must remain compatible')
+console.log('PASS public tool-definition compatibility baseline')

package/dist/server/debugger-handlers.js

@@ -1,38 +0,0 @@
-import { debuggerContracts } from './debugger-schema.js';
-import { debuggerSessions, debuggerCapabilities } from '../debugger/sessions.js';
-import { DebuggerError, withDebuggerBudget } from '../debugger/worker.js';
-import { wrapResponse } from './common.js';
-function failure(code, summary = {}) {
-    return { ...wrapResponse({ debug_session_id: null, device: null, target: null, state: null,
-            captured_at_ms: Date.now(), capabilities: debuggerCapabilities, limitations: [], cleanup: null,
-            ...summary, success: false, error: { code, message: code, retryable: false } }), isError: true };
-}
-export async function handleDebugger(name, args, signal) {
-    const parsed = debuggerContracts[name].schema.safeParse(args);
-    if (!parsed.success)
-        return failure('INVALID_ARGUMENT');
-    const a = parsed.data;
-    const command = debuggerContracts[name].command;
-    try {
-        if (signal?.aborted)
-            throw new DebuggerError('DEBUGGER_CANCELLED');
-        const result = await withDebuggerBudget(a.timeoutMs, signal, async () => command === 'capabilities' ? await debuggerSessions.capabilities(a.deviceId, a.appId, a.processId) :
-            command === 'attach' ? await debuggerSessions.attach(a.deviceId, a.appId, a.processId, a.timeoutMs) :
-                await debuggerSessions.command(a.debugSessionId, command, { ...a, signal: command === 'events' ? signal : undefined }, a.timeoutMs));
-        if (signal?.aborted && command === 'capabilities')
-            throw new DebuggerError('DEBUGGER_CANCELLED');
-        return { ...wrapResponse(result), ...(!result.success ? { isError: true } : {}) };
-    }
-    catch (e) {
-        const code = e instanceof DebuggerError ? e.code : 'DEBUGGER_WORKER_FAILED';
-        let summary = {};
-        if (a.debugSessionId) {
-            try {
-                summary = debuggerSessions.summary(a.debugSessionId);
-            }
-            catch { /* Unknown session */ }
-        }
-        return failure(code, { debug_session_id: a.debugSessionId ?? null,
-            device: a.deviceId ? { platform: 'android', id: a.deviceId } : null, ...summary });
-    }
-}

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

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-const target = { platform: z.enum(['android', 'ios']), deviceId: z.string().min(1).optional() };
-export const traceTargetSchema = z.object(target).strict();
-export const traceStartSchema = z.object({ ...target, durationMs: z.number().int().min(1000).max(120000).default(30000) }).strict();
-export const traceControlSchema = z.object({ traceId: z.string().uuid() }).strict();
-const properties = { platform: { type: 'string', enum: ['android', 'ios'] }, deviceId: { type: 'string', minLength: 1 } };
-export const systemTraceTools = [
-    { name: 'get_system_trace_capabilities', description: 'Probe Android Perfetto prerequisites without recording. Device-wide system tracing is optional; iOS is unsupported.',
-        inputSchema: { type: 'object', additionalProperties: false, required: ['platform'], properties } },
-    { name: 'start_system_trace', description: 'Start bounded Android Perfetto recording, returning an owned trace_id. Run an existing journey with systemTraceId, then stop to retrieve a local artifact or cancel to discard. Device-wide traces may contain sensitive system annotations; no upload.',
-        inputSchema: { type: 'object', additionalProperties: false, required: ['platform'], properties: { ...properties, durationMs: { type: 'integer', minimum: 1000, maximum: 120000, default: 30000 } } } },
-    ...['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 artifact. 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' } } }
-    }))
-];