mobile-debug-mcp 0.35.0 → 0.36.0

package/test/unit/observe/ios-trace-sessions.test.ts

@@ -0,0 +1,131 @@
+import assert from 'node:assert/strict'
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { IosTraceSessions } from '../../../src/observe/ios-trace/sessions.js'
+import { IosTraceNative, type IosRecording } from '../../../src/observe/ios-trace/native.js'
+import type { TraceClock } from '../../../src/observe/system-trace.js'
+import type { TraceCommandResult } from '../../../src/observe/ios-trace/process.js'
+
+const target = { platform: 'ios' as const, id: 'sim', simulator: true, osVersion: '26.4', model: 'fixture' }
+function fixture() {
+  let monitorTick = 0, exitOnMonitor = false, exportMessage = 'EXPORT_FAILED'
+  let now = 1000, failStart = false, failStop = false, failExport = false, monitor = '', stops = 0, starts = 0, validations = 0
+  const timers = new Map<ReturnType<typeof setTimeout>, () => void>(), recordings: IosRecording[] = [], directories: string[] = []
+  const time: TraceClock = { wall: () => now, mono: () => now, sleep: async ms => {now += ms},
+    schedule: fn => { const id = {} as ReturnType<typeof setTimeout>; timers.set(id,fn); return id }, clear: id => {timers.delete(id)} }
+  class Native extends IosTraceNative {
+    resolve = async () => ({ app_id:'fixture', pid:100, executable:'/fixture.app/Fixture',started_at:'fixture-start' })
+    async start(_d: string, _app: unknown, directory: string, _duration: number, own: (r: IosRecording) => void) {
+      starts++; directories.push(directory)
+      let alive = true, resolve!: (v: TraceCommandResult) => void
+      const done = new Promise<TraceCommandResult>(r => {resolve=r})
+      const recording: IosRecording = {file:path.join(directory,'capture.trace'), ready_at_ms:now,
+        recorder:{done, alive:()=>alive, line:async()=>{},signal:()=>{alive=false;resolve({code:0,output:'Reached specified time limit',timedOut:false})}}}
+      own(recording); recordings.push(recording)
+      await fs.mkdir(recording.file)
+      await fs.writeFile(path.join(recording.file,'data'),'sample')
+      if(failStart) throw new Error('READINESS_TIMEOUT')
+      return recording
+    }
+    async stop(r: IosRecording) {stops++; if(failStop) throw new Error('ACTION_TIMEOUT');r.recorder.signal('SIGINT');return r.recorder.done}
+    async monitor(device: string, app: {pid:number;executable:string}, recording: IosRecording) {
+      assert.equal(device,target.id);assert.equal(app.pid,100);assert.equal(app.executable,'/fixture.app/Fixture')
+      assert.equal(recording,recordings.at(-1),'Retries must retain the same owned recording')
+      now+=monitorTick
+      if(exitOnMonitor)recording.recorder.signal('SIGINT')
+      if(monitor)throw new Error(monitor)
+    }
+    async validate(r: IosRecording) {validations++;if(failExport)throw new Error(exportMessage);return {path:r.file,format:'instruments' as const,kind:'directory' as const,size_bytes:6,validation:{readable:true,schema:'time-sample',sample_rows:1}}}
+    shutdown() {for(const r of recordings)r.recorder.signal('SIGINT')}
+  }
+  const sessions = new IosTraceSessions(new Native(),time)
+  return {sessions,recordings,timers,flags:(v:{start?:boolean;stop?:boolean;export?:boolean;monitor?:string;monitorTick?:number;exitOnMonitor?:boolean;exportMessage?:string})=>{failStart=v.start??false;failStop=v.stop??false;failExport=v.export??false;monitor=v.monitor??'';monitorTick=v.monitorTick??0;exitOnMonitor=v.exitOnMonitor??false;exportMessage=v.exportMessage??'EXPORT_FAILED'},
+    tick:(ms:number)=>{now+=ms},counts:()=>({stops,starts,validations}),
+    cleanup:async()=>{await sessions.shutdown();for(const d of directories)await fs.rm(d,{recursive:true,force:true})}}
+}
+async function run() {
+  const f=fixture()
+  try {
+    const start=await f.sessions.start(target,'fixture')
+    await assert.rejects(()=>f.sessions.start(target,'fixture'),/TRACE_BUSY/)
+    assert.equal(start.state,'recording');assert.equal(start.recording_ready_at_ms,1000)
+    const finish=await f.sessions.link(start.trace_id,target,'journey')
+    for(const device of [{platform:'android',id:'sim'},{platform:'ios',id:'other'}])await assert.rejects(()=>f.sessions.link(start.trace_id,device,'wrong'),/TRACE_NOT_FOUND/)
+    const [a,b]=await Promise.all([f.sessions.control(start.trace_id,'stop'),f.sessions.control(start.trace_id,'stop')])
+    assert.equal(a.state,'completed');assert.deepEqual(a,b);assert.deepEqual(a.correlation_ids,['journey']);assert.equal((await finish()).coverage,'partial')
+    assert.equal(f.counts().validations,1)
+    await assert.rejects(()=>f.sessions.link(start.trace_id,target,'stale'),/TRACE_NOT_FOUND/)
+    await assert.rejects(()=>f.sessions.control('foreign','stop'),/TRACE_NOT_FOUND/)
+    assert.equal((await f.sessions.control(start.trace_id,'cancel')).artifact?.path,a.artifact?.path)
+    const cancelled=await f.sessions.start(target,'fixture')
+    const dir=path.dirname(f.recordings[1].file)
+    assert.equal((await f.sessions.control(cancelled.trace_id,'cancel')).state,'cancelled')
+    await assert.rejects(()=>fs.stat(dir),{code:'ENOENT'})
+    const expires=await f.sessions.start(target,'fixture',1000);f.tick(1001)
+    const expired=await f.sessions.control(expires.trace_id,'status')
+    assert.equal(expired.state,'completed');assert.equal(expired.completion_reason,'duration_limit')
+    f.tick(600001);await assert.rejects(()=>f.sessions.control(start.trace_id,'status'),/TRACE_NOT_FOUND/)
+  }finally{await f.cleanup()}
+  for(const failure of ['start','stop','export','monitor'] as const){
+    const f=fixture()
+    try{
+      if(failure==='start')f.flags({start:true})
+      const s=await f.sessions.start(target,'fixture')
+      if(failure==='start'){assert.equal(s.state,'failed');assert.equal(s.reason,'READINESS_TIMEOUT');assert.equal(s.cleanup.status,'complete');assert.equal(f.recordings[0].recorder.alive(),false);continue}
+      f.flags(failure==='monitor'?{monitor:'STORAGE_LIMIT'}:{[failure]:true})
+      const failed=await f.sessions.control(s.trace_id,failure==='monitor'?'status':'stop')
+      assert.equal(failed.state,'failed');assert.equal(failed.artifact,null)
+      if(failure==='monitor'){assert.equal(failed.reason,'STORAGE_LIMIT');assert.equal(failed.cleanup.status,'complete');continue}
+      f.flags({})
+      assert.equal((await f.sessions.control(s.trace_id,'stop')).state,'completed')
+      assert.equal(f.counts().starts,1,'Retry must not start a new recording')
+    }finally{await f.cleanup()}
+  }
+  const exportClassification=fixture()
+  try {
+    const s=await exportClassification.sessions.start(target,'fixture')
+    exportClassification.flags({export:true,exportMessage:'COMMAND_FAILED'})
+    const failed=await exportClassification.sessions.control(s.trace_id,'stop')
+    assert.equal(failed.reason,'TRACE_ARTIFACT_FAILED','Monitor classification must not alter export errors')
+    assert.match(failed.recovery!,/Retry stop/)
+  }finally{await exportClassification.cleanup()}
+  for(const reason of ['COMMAND_FAILED','ACTION_TIMEOUT','TARGET_DISCONNECTED','private unexpected output']) {
+    const f=fixture()
+    try {
+      const s=await f.sessions.start(target,'fixture')
+      f.flags({monitor:reason})
+      for(let n=0;n<2;n++)assert.equal((await f.sessions.control(s.trace_id,'status')).state,'recording')
+      assert.equal(f.counts().stops,0)
+      f.flags({});assert.equal((await f.sessions.control(s.trace_id,'status')).state,'recording')
+      f.flags({monitor:reason})
+      for(let n=0;n<2;n++)assert.equal((await f.sessions.control(s.trace_id,'status')).state,'recording','Successful poll must reset consecutive failure count')
+      const failed=await f.sessions.control(s.trace_id,'status')
+      assert.equal(failed.state,'failed');assert.equal(failed.reason,reason==='private unexpected output'?'TRACE_MONITOR_FAILED':reason)
+      assert.equal(failed.cleanup.status,'complete');assert.equal(failed.artifact,null)
+      assert.equal(f.counts().starts,1);assert.equal(f.recordings[0].recorder.alive(),false)
+      assert.ok(!JSON.stringify(failed).includes('private unexpected output'))
+    }finally{await f.cleanup()}
+  }
+  for(const reason of ['APP_IDENTITY_CHANGED','APP_NOT_RUNNING']) {
+    const f=fixture()
+    try {
+      const s=await f.sessions.start(target,'fixture');f.flags({monitor:reason})
+      const failed=await f.sessions.control(s.trace_id,'status')
+      assert.equal(failed.state,'failed');assert.equal(failed.reason,reason);assert.equal(failed.cleanup.status,'complete')
+    }finally{await f.cleanup()}
+  }
+  for(const ended of ['deadline','recorder'] as const) {
+    const f=fixture()
+    try {
+      const s=await f.sessions.start(target,'fixture',1000)
+      f.flags({monitor:'COMMAND_FAILED',monitorTick:ended==='deadline'?1001:0,exitOnMonitor:ended==='recorder'})
+      const result=await f.sessions.control(s.trace_id,'status')
+      assert.equal(result.state,'completed','A tolerated failed poll must still reconcile duration/recorder completion')
+      assert.equal(result.completion_reason,'duration_limit');assert.ok(result.artifact)
+    }finally{await f.cleanup()}
+  }
+  const shutdown=fixture()
+  try{const s=await shutdown.sessions.start(target,'fixture');assert.deepEqual(await shutdown.sessions.shutdown(),[]);assert.equal((await shutdown.sessions.control(s.trace_id,'status')).state,'cancelled');await assert.rejects(()=>shutdown.sessions.start(target,'fixture'),/TRACE_BUSY/)}finally{await shutdown.cleanup()}
+  console.log('PASS iOS trace lifecycle, linkage, failure cleanup, retries and expiry')
+}
+run().catch(error=>{console.error(error);process.exitCode=1})

package/test/unit/observe/readiness.test.ts

@@ -36,6 +36,6 @@ assert.equal(tracker.summary.capabilities.debugger_paused, true)
 assert.ok(tracker.deadline().limitations.includes('DEADLINE_EXCEEDED'))
 assert.equal(new ReadinessTracker('android', 'fixture').observe(sample(), 10000, 9000).state, 'unknown', 'no cross-request history')
 assert.ok(!JSON.stringify(tracker.summary).includes('Ready'), 'evidence contains codes rather than private labels')
-assert.equal(new ReadinessTracker('ios', 'fixture').summary.capabilities.debugger_paused, false)
+assert.equal(new ReadinessTracker('ios', 'fixture').summary.capabilities.debugger_paused, true)
 assert.ok(tracker.summary.limitations.includes('MANAGED_DEBUGGER_ONLY'))
 console.log('Readiness classifier: PASS')

package/test/unit/observe/system-trace-router.test.ts

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict'
+import { SystemTraceRouter } from '../../../src/observe/system-trace-router.js'
+import type { SystemTraceSessions, TraceResult } from '../../../src/observe/system-trace.js'
+import type { IosTraceSessions, IosTraceResult } from '../../../src/observe/ios-trace/sessions.js'
+import type { IosTraceNative } from '../../../src/observe/ios-trace/native.js'
+function backend(platform:'android'|'ios') {
+  let next=0,starts=0
+  const results=new Map<string,TraceResult|IosTraceResult>()
+  const api={
+    capabilities:async()=>({}),
+    start:async(device:string|{id:string})=>{
+      starts++
+      const result={trace_id:platform+ ++next,device:{platform,id:typeof device==='string'?device:device.id},state:'recording',cleanup:{status:'pending'}} as TraceResult|IosTraceResult
+      results.set(result.trace_id,result);return result
+    },
+    control:async(id:string,op:string)=>{
+      const result=results.get(id);if(!result)throw new Error('TRACE_NOT_FOUND')
+      if(op==='cancel'){result.cleanup.status='complete';result.state='cancelled'}
+      return result
+    },
+    link:async()=>async()=>({trace_id:'linked',coverage:'covered',clock_alignment:'unknown'}),
+    shutdown:async()=>[]
+  }
+  return {api,results,count:()=>starts}
+}
+async function run(){
+  const android=backend('android'),ios=backend('ios')
+  let release!:()=>void,gate=Promise.resolve()
+  const native={shutdown:()=>{},capabilities:async(device:string)=>{await gate;return {supported:true,device:{platform:'ios',id:device,simulator:true}}}} as unknown as IosTraceNative
+  const router=new SystemTraceRouter(android.api as unknown as SystemTraceSessions,ios.api as unknown as IosTraceSessions,native)
+  const a=await router.start('a'),b=await router.start('b',30000,{appId:'fixture'})
+  await assert.rejects(()=>router.link(b.trace_id,{platform:'android',id:'b'},'bad'),/TRACE_NOT_FOUND/)
+  await assert.rejects(()=>router.link(b.trace_id,{platform:'ios',id:'other'},'bad'),/TRACE_NOT_FOUND/)
+  await assert.rejects(()=>router.start('b',30000,{appId:'fixture'}),/TRACE_BUSY/)
+  await router.start('c');await router.start('d',30000,{appId:'fixture'})
+  await assert.rejects(()=>router.start('fifth'),/TRACE_BUSY/)
+  await router.control(a.trace_id,'cancel')
+  await router.start('freed')
+  await router.control(b.trace_id,'cancel')
+  gate=new Promise<void>(r=>{release=r})
+  const first=router.start('pending',30000,{appId:'fixture'})
+  await new Promise(r=>setImmediate(r))
+  await assert.rejects(()=>router.start('pending',30000,{appId:'fixture'}),/TRACE_BUSY/)
+  release();await first
+  assert.equal(ios.count(),3)
+  await router.shutdown();await assert.rejects(()=>router.start('closed'),/TRACE_BUSY/)
+  console.log('PASS cross-platform trace routing, pinned linkage, shared reservations and shutdown')
+}
+run().catch(error=>{console.error(error);process.exitCode=1})

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/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()
   }
 }