@11agents/cli 0.1.38 → 0.1.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@11agents/cli",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "description": "11agents local runtime and telemetry CLI",
   "type": "module",
   "bin": {

package/src/commands/runtime.js

@@ -149,6 +149,14 @@ function createRetryState() {
   return { failures: 0 }
 }
 
+function healthFromScan(scan, extra = {}) {
+  const base = scan?.health && typeof scan.health === 'object' ? scan.health : {}
+  return {
+    ...base,
+    ...extra,
+  }
+}
+
 async function heartbeatRegisteredRuntime(registration, flags, deps) {
   const config = configFromFlags(flags)
   const machineKey = registration?.machine?.machine_key || machineOverride(flags) || ''
@@ -158,9 +166,9 @@ async function heartbeatRegisteredRuntime(registration, flags, deps) {
     body: {
       machine_key: machineKey,
       runtime_providers: (registration?.runtimes || []).map(runtime => runtime.provider).filter(Boolean),
-      health: {
+      health: healthFromScan(registration?.local_scan, {
         heartbeat_at: new Date().toISOString(),
-      },
+      }),
     },
     config,
   })
@@ -254,7 +262,7 @@ export async function registerRuntime(flags = {}, deps = {}) {
     config,
   })
   log(JSON.stringify(result, null, 2))
-  return result
+  return { ...result, local_scan: scan }
 }
 
 export async function heartbeatRuntime(flags = {}, deps = {}) {
@@ -268,9 +276,9 @@ export async function heartbeatRuntime(flags = {}, deps = {}) {
     body: {
       machine_key: scan.machine.machine_key,
       runtime_providers: scan.runtimes.map(runtime => runtime.provider),
-      health: {
+      health: healthFromScan(scan, {
         heartbeat_at: new Date().toISOString(),
-      },
+      }),
     },
     config,
   })

package/src/mobile-device-scan.js

@@ -0,0 +1,258 @@
+import os from 'node:os'
+import path from 'node:path'
+import { access, readFile } from 'node:fs/promises'
+import { constants } from 'node:fs'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { fileURLToPath } from 'node:url'
+
+const execFileAsync = promisify(execFile)
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CLI_ROOT = path.resolve(__dirname, '..')
+const BUNDLED_DEVICES_CSV = path.join(CLI_ROOT, 'mobile-runtime', 'data-templates', 'devices.example.csv')
+
+export const DEVICE_IDENTITY_PROPS = [
+  'ro.serialno',
+  'ro.boot.serialno',
+  'ro.vendor.boot.serialno',
+  'ro.product.serialno',
+]
+
+function defaultMobileHome(env = process.env, homeDir = os.homedir()) {
+  return path.resolve(env.ELEVENAGENTS_MOBILE_HOME || path.join(homeDir, '.11agents', 'mobile'))
+}
+
+function cleanIdentity(value = '') {
+  return String(value || '').trim().toLowerCase()
+}
+
+function cleanStatus(value = '') {
+  return String(value || '').trim().toLowerCase()
+}
+
+function isActiveRegistryRow(row) {
+  const status = cleanStatus(row.status || 'active')
+  return status !== 'inactive' && status !== 'disabled'
+}
+
+function deviceSortKey(device) {
+  const match = /^D(\d{2})$/i.exec(device.device_id || '')
+  if (match) return Number(match[1])
+  const fallback = String(device.device_id || device.adb_transport || device.adb_serial || device.hardware_id || '')
+  return 1000 + (fallback.charCodeAt(0) || 0)
+}
+
+function parseCsvLine(line = '') {
+  const out = []
+  let value = ''
+  let quoted = false
+  for (let i = 0; i < line.length; i += 1) {
+    const ch = line[i]
+    if (ch === '"') {
+      if (quoted && line[i + 1] === '"') {
+        value += '"'
+        i += 1
+      } else {
+        quoted = !quoted
+      }
+      continue
+    }
+    if (ch === ',' && !quoted) {
+      out.push(value)
+      value = ''
+      continue
+    }
+    value += ch
+  }
+  out.push(value)
+  return out
+}
+
+export function parseDeviceRegistryCsv(text = '') {
+  const lines = String(text || '').split(/\r?\n/).filter(line => line.trim().length)
+  if (!lines.length) return []
+  const headers = parseCsvLine(lines[0])
+  return lines.slice(1).map(line => {
+    const values = parseCsvLine(line)
+    return Object.fromEntries(headers.map((header, index) => [header, values[index] || '']))
+  })
+}
+
+async function canExecute(filePath, accessFn = access) {
+  try {
+    await accessFn(filePath, constants.X_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function resolveAdbBin({ env = process.env, homeDir = os.homedir(), access: accessFn = access } = {}) {
+  if (env.ADB_BIN && await canExecute(env.ADB_BIN, accessFn)) return env.ADB_BIN
+
+  const pathValue = env.PATH || ''
+  for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+    const candidate = path.join(dir, process.platform === 'win32' ? 'adb.exe' : 'adb')
+    if (await canExecute(candidate, accessFn)) return candidate
+  }
+
+  const candidates = [
+    path.join(homeDir, 'Library', 'Android', 'sdk', 'platform-tools', process.platform === 'win32' ? 'adb.exe' : 'adb'),
+    '/usr/local/bin/adb',
+    '/opt/homebrew/bin/adb',
+  ]
+  for (const candidate of candidates) {
+    if (await canExecute(candidate, accessFn)) return candidate
+  }
+
+  return ''
+}
+
+async function loadDeviceRegistry({ env, homeDir, devicesCsvPath, readFile: read = readFile } = {}) {
+  const preferred = devicesCsvPath || path.join(defaultMobileHome(env, homeDir), 'data', 'devices.csv')
+  for (const candidate of [preferred, BUNDLED_DEVICES_CSV]) {
+    try {
+      const content = await read(candidate, 'utf8')
+      return parseDeviceRegistryCsv(content).filter(isActiveRegistryRow)
+    } catch {}
+  }
+  return []
+}
+
+export function parseAdbDevices(text = '') {
+  const devices = []
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (!trimmed || /^List of devices attached/i.test(trimmed)) continue
+    const parts = trimmed.split(/\s+/)
+    if (!parts[0]) continue
+    devices.push({
+      transport: parts[0],
+      state: parts[1] || 'unknown',
+    })
+  }
+  return devices
+}
+
+async function adbExec(exec, adbBin, args, timeout = 5000) {
+  return exec(adbBin, args, { timeout })
+}
+
+async function readDeviceHardwareId({ exec, adbBin, transport }) {
+  for (const prop of DEVICE_IDENTITY_PROPS) {
+    try {
+      const { stdout } = await adbExec(exec, adbBin, ['-s', transport, 'shell', 'getprop', prop], 2500)
+      const value = String(stdout || '').trim()
+      const clean = cleanIdentity(value)
+      if (clean && !['unknown', 'null', 'none'].includes(clean)) return value
+    } catch {}
+  }
+  return ''
+}
+
+function registryIdentityCandidates(row) {
+  return [
+    row.hardware_id,
+    row.physical_id,
+    row.adb_serial,
+  ].map(cleanIdentity).filter(Boolean)
+}
+
+function publicDeviceRow(row, transport, hardwareId) {
+  return {
+    device_id: String(row.device_id || ''),
+    hardware_id: String(row.hardware_id || row.physical_id || hardwareId || row.adb_serial || ''),
+    adb_serial: String(row.adb_serial || ''),
+    adb_transport: transport.transport,
+    adb_state: transport.state,
+    online: transport.state === 'device',
+  }
+}
+
+function unknownDeviceRow(transport, hardwareId) {
+  return {
+    device_id: '',
+    hardware_id: hardwareId || '',
+    adb_serial: '',
+    adb_transport: transport.transport,
+    adb_state: transport.state,
+    online: transport.state === 'device',
+  }
+}
+
+export async function scanConnectedMobileDevices({
+  env = process.env,
+  homeDir = os.homedir(),
+  devicesCsvPath,
+  execFile: exec = execFileAsync,
+  access: accessFn = access,
+  readFile: read = readFile,
+} = {}) {
+  const adbBin = await resolveAdbBin({ env, homeDir, access: accessFn })
+  if (!adbBin) {
+    return {
+      devices: [],
+      scan: { status: 'adb_missing', scanned_at: new Date().toISOString() },
+    }
+  }
+
+  let transports = []
+  try {
+    const { stdout } = await adbExec(exec, adbBin, ['devices'], 5000)
+    transports = parseAdbDevices(stdout)
+  } catch (error) {
+    return {
+      devices: [],
+      scan: {
+        status: 'adb_failed',
+        scanned_at: new Date().toISOString(),
+        error: error instanceof Error ? error.message : String(error),
+      },
+    }
+  }
+
+  const registry = await loadDeviceRegistry({ env, homeDir, devicesCsvPath, readFile: read })
+  const transportDetails = []
+  const transportByIdentity = new Map()
+  for (const transport of transports) {
+    const hardwareId = transport.state === 'device'
+      ? await readDeviceHardwareId({ exec, adbBin, transport: transport.transport })
+      : ''
+    const detail = { ...transport, hardware_id: hardwareId }
+    transportDetails.push(detail)
+    for (const identity of [transport.transport, hardwareId].map(cleanIdentity).filter(Boolean)) {
+      if (!transportByIdentity.has(identity)) transportByIdentity.set(identity, detail)
+    }
+  }
+
+  const matchedTransports = new Set()
+  const devices = []
+  for (const row of registry) {
+    let match = null
+    for (const identity of registryIdentityCandidates(row)) {
+      match = transportByIdentity.get(identity)
+      if (match) break
+    }
+    if (!match) continue
+    matchedTransports.add(match.transport)
+    devices.push(publicDeviceRow(row, match, match.hardware_id))
+  }
+
+  for (const transport of transportDetails) {
+    if (!matchedTransports.has(transport.transport)) {
+      devices.push(unknownDeviceRow(transport, transport.hardware_id))
+    }
+  }
+
+  devices.sort((a, b) => deviceSortKey(a) - deviceSortKey(b))
+  return {
+    devices,
+    scan: {
+      status: 'ok',
+      scanned_at: new Date().toISOString(),
+      adb_path: adbBin,
+      connected_count: devices.length,
+    },
+  }
+}

package/src/runtime-scan.js

@@ -4,6 +4,7 @@ import { access } from 'node:fs/promises'
 import { constants } from 'node:fs'
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
+import { scanConnectedMobileDevices } from './mobile-device-scan.js'
 
 const execFileAsync = promisify(execFile)
 
@@ -69,6 +70,7 @@ export async function buildRuntimeScan({
   cliVersion = 'dev',
   lookupExecutable: lookup = lookupExecutable,
   readVersion = readRuntimeVersion,
+  scanMobileDevices = scanConnectedMobileDevices,
 } = {}) {
   const host = hostname()
   const runtimes = []
@@ -97,6 +99,22 @@ export async function buildRuntimeScan({
     })
   }
 
+  const health = {
+    scan_at: new Date().toISOString(),
+  }
+  try {
+    const mobile = await scanMobileDevices({ env })
+    health.mobile_devices = Array.isArray(mobile?.devices) ? mobile.devices : []
+    if (mobile?.scan) health.mobile_device_scan = mobile.scan
+  } catch (error) {
+    health.mobile_devices = []
+    health.mobile_device_scan = {
+      status: 'failed',
+      scanned_at: new Date().toISOString(),
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+
   return {
     machine: {
       machine_key: machineKeyFromEnv(env, host),
@@ -107,8 +125,6 @@ export async function buildRuntimeScan({
       capabilities: ['local_runtime'],
     },
     runtimes,
-    health: {
-      scan_at: new Date().toISOString(),
-    },
+    health,
   }
 }