dsh-mobilecode 0.4.0 → 0.6.0

package/lib/device-build.js

@@ -97,17 +97,20 @@ export function exec(command, args, options, onLine) {
   return { child, exit }
 }
 
-/** Run a command purely for its stdout, e.g. a `-json` query. Empty string on failure. */
-export async function capture(command, args, options = {}) {
+/** Run a command, capturing stdout AND stderr. Resolves {code, out, err}. */
+export async function captureFull(command, args, options = {}) {
   const out = []
+  const err = []
   const running = launch(command, args, {
     cwd: options.cwd,
     env: options.env ? { ...process.env, ...options.env } : undefined,
-    stdio: ["ignore", "pipe", "ignore"],
+    stdio: ["ignore", "pipe", "pipe"],
     windowsHide: true,
   })
   running.stdout?.setEncoding("utf8")
+  running.stderr?.setEncoding("utf8")
   running.stdout?.on("data", (chunk) => out.push(chunk))
+  running.stderr?.on("data", (chunk) => err.push(chunk))
   let timer
   if (options.timeoutMs) {
     timer = setTimeout(() => running.kill(), options.timeoutMs)
@@ -118,9 +121,18 @@ export async function capture(command, args, options = {}) {
     running.once("close", (value) => resolve(value ?? -1))
   })
   if (timer) clearTimeout(timer)
-  if (code !== 0) return ""
   const text = out.join("")
-  return options.maxBytes && Buffer.byteLength(text) > options.maxBytes ? text.slice(0, options.maxBytes) : text
+  return {
+    code,
+    out: options.maxBytes && Buffer.byteLength(text) > options.maxBytes ? text.slice(0, options.maxBytes) : text,
+    err: err.join(""),
+  }
+}
+
+/** Run a command purely for its stdout, e.g. a `-json` query. Empty string on failure. */
+export async function capture(command, args, options = {}) {
+  const result = await captureFull(command, args, options)
+  return result.code === 0 ? result.out : ""
 }
 
 /** Direct child pids of `pid`. POSIX only; returns nothing when pgrep is unavailable. */
@@ -715,6 +727,231 @@ export function adb() {
   return exe ?? "adb"
 }
 
+// ── classified adb boundary (Wi-Fi resilience; pattern credited to boheastill/phone-eye) ──
+
+/** Wi-Fi adb serials end in `ip:port` (`192.168.1.23:5555`); USB/emulator serials never do. */
+export function isWifiSerial(serial) {
+  return /:\d+$/.test(serial)
+}
+
+const ADB_TRANSPORT_RE = /no devices|device (?:'.*?' )?not found|device offline|device unauthorized|device still connecting|error: closed|cannot connect to daemon|failed to start daemon/i
+
+/** Why an adb command failed: 'multi-device', 'transport' (transient — a reconnect may fix it), or undefined (real command error). */
+export function classifyAdbFailure(result) {
+  const text = `${result.err}\n${result.out}`
+  if (/more than one device/i.test(text)) return "multi-device"
+  if (ADB_TRANSPORT_RE.test(text)) return "transport"
+  return undefined
+}
+
+/**
+ * Commands that may be auto-replayed after a reconnect: read-only probes only.
+ * Anything else (input/am/pm-mutate/install/screencap-to-file) must never
+ * replay — a replayed `input tap` could double-tap a payment button.
+ */
+export function replaySafeAdb(args) {
+  return /^(exec-out (screencap|cat|uiautomator|logcat|getprop|dumpsys)|shell (screencap|uiautomator|dumpsys|getprop|wm|settings get|pm list|ime list|cat|df|dmesg|logcat|true)|logcat( |$)|emu avd name)/.test(args.join(" "))
+}
+
+function adbFailTail(result) {
+  const text = `${result.err}\n${result.out}`.trim().split(/\r?\n/).filter(Boolean).slice(-3).join(" | ")
+  return text.slice(-300)
+}
+
+async function adbConnect(serial) {
+  const result = await captureFull(adb(), ["connect", serial], { timeoutMs: 15_000 })
+  return /connected|already connected/i.test(`${result.out}\n${result.err}`)
+}
+
+/** Attach a Wi-Fi device: `adb connect <ip>:<port>`; true on success. Never throws (returns false with no side effect). */
+export async function adbConnectSerial(serial) {
+  return adbConnect(serial)
+}
+
+/**
+ * Pair a Wi-Fi device (Android 11+ requires pairing before the first connect):
+ * `adb pair <ip>:<pair-port> <code>`. Resolves when pairing succeeded.
+ */
+export async function adbPair(serial, code) {
+  const result = await captureFull(adb(), ["pair", serial, String(code)], { timeoutMs: 20_000 })
+  if (/successfully paired/i.test(`${result.out}\n${result.err}`)) return true
+  throw new Error(`adb pair ${serial} failed: ${adbFailTail(result) || "no output"}`)
+}
+
+/**
+ * Parse `adb mdns services` output for the pairing service the device advertises
+ * while its "pair using QR code" dialog is open. Returns the `ip:port` the
+ * pairing broadcast listens on, or undefined.
+ */
+export function parseMdnsPairing(output) {
+  const line = String(output).split(/\r?\n/).find((row) => row.includes("_adb-tls-pairing._tcp"))
+  if (line === undefined) return undefined
+  const address = /(\d{1,3}(?:\.\d{1,3}){3}:\d+)/.exec(line)?.[1] ?? /(\[[0-9a-f:]+\]:\d+)/.exec(line)?.[1]
+  return address ?? undefined
+}
+
+/** A Wi-Fi QR code the device scanner accepts: `WIFI:T:ADB;S:<name>;P:<password>;;`. */
+export function generateQrAdbWifi(name, password) {
+  return `WIFI:T:ADB;S:${name};P:${password};;`
+}
+
+/**
+ * Poll `adb mdns services` until the phone's pairing dialog advertises
+ * `_adb-tls-pairing._tcp` (resolves to its `ip:port`), or undefined on timeout.
+ * Requires adb with mdns support (>= 31). Non-serial, read-only.
+ */
+export async function waitForMdnsPairing(timeoutMs = 60_000, pollMs = 1_500) {
+  const deadline = Date.now() + timeoutMs
+  for (;;) {
+    const result = await captureFull(adb(), ["mdns", "services"], { timeoutMs: 5_000 }).catch(() => null)
+    if (result && result.code === 0) {
+      const address = parseMdnsPairing(result.out)
+      if (address !== undefined) return address
+    }
+    if (Date.now() >= deadline) return undefined
+    await new Promise((resolve) => setTimeout(resolve, pollMs))
+  }
+}
+
+const QR_NAME_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+/** Random ADB QR name (ADB_WIFI_xxxxxxxxxxxxxx-yyyyyy) + 21-char password, matching Android's own structure. */
+export function randomQrCredentials(prefix = "ADB_WIFI") {
+  const pick = (n) => Array.from({ length: n }, () => QR_NAME_CHARS[Math.floor(Math.random() * QR_NAME_CHARS.length)]).join("")
+  return { name: `${prefix}_${pick(14)}-${pick(6)}`, password: pick(21) }
+}
+
+/**
+ * The single classified boundary for every serial-targeted adb command.
+ * On a transient transport failure with a Wi-Fi serial (ip:port) it attempts
+ * exactly one `adb connect`; only read-only commands are then replayed, while
+ * side-effectful ones raise "reconnected — call again". USB serials get a
+ * classified, actionable message instead of an empty result.
+ */
+export async function adbRun(serial, args, options = {}) {
+  const argv = ["-s", serial, ...args]
+  let result = await captureFull(adb(), argv, options)
+  if (result.code === 0) return result.out
+  const kind = classifyAdbFailure(result)
+  if (kind === "multi-device") throw new Error("adb: more than one device/emulator attached — pass an explicit serial (see adb devices)")
+  if (kind !== "transport" || !isWifiSerial(serial)) {
+    throw new Error(kind === "transport"
+      ? `device ${serial} unreachable (${adbFailTail(result)}). For Wi-Fi adb run: adb connect <ip>:5555`
+      : `adb ${String(args[0])} failed on ${serial} (exit ${result.code}): ${adbFailTail(result)}`)
+  }
+  if (!(await adbConnect(serial))) {
+    throw new Error(`device ${serial} unreachable — adb connect failed; check the phone's Wi-Fi IP or replug USB once`)
+  }
+  if (!replaySafeAdb(args)) {
+    throw new Error(`device ${serial} reconnected over Wi-Fi; command not auto-replayed (side effects) — call again`)
+  }
+  result = await captureFull(adb(), argv, options)
+  if (result.code !== 0) throw new Error(`device ${serial} still failing after reconnect (exit ${result.code}): ${adbFailTail(result)}`)
+  return result.out
+}
+
+/** Quote one value for the device shell (`adb shell` rejoins argv through sh -c): '…' with ' → '\''; control chars refused. */
+export function shQuoteDevice(text) {
+  if (/[\x00-\x1f]/.test(text)) throw new Error(`refusing control characters in adb shell argument: ${JSON.stringify(text.slice(0, 40))}`)
+  return `'${text.replace(/'/g, `'\\''`)}'`
+}
+
+/** Build the `am start` argv from intent parts; values are device-shell quoted so metacharacters stay inert. */
+export function adbIntentArgs({ action, uri, component } = {}) {
+  const parts = ["shell", "am", "start"]
+  for (const [flag, value] of [["-a", action], ["-d", uri], ["-n", component]]) {
+    if (value === undefined || String(value) === "") continue
+    parts.push(flag, shQuoteDevice(String(value)))
+  }
+  return parts
+}
+
+// ── perf / app-info parsers (pattern credited to newborne/dsh-adb-ultimate) ──
+
+/** Parse `cat /proc/meminfo` into {totalKb, availableKb, usedKb, usedPercent}. */
+export function parseMeminfo(output) {
+  const grab = (name) => {
+    const match = new RegExp(`^${name}:\\s*(\\d+)`, "m").exec(String(output))
+    return match ? Number(match[1]) : undefined
+  }
+  const totalKb = grab("MemTotal")
+  const availableKb = grab("MemAvailable")
+  if (totalKb === undefined) return undefined
+  const usedKb = availableKb === undefined ? undefined : totalKb - availableKb
+  return {
+    totalKb,
+    availableKb,
+    usedKb,
+    usedPercent: usedKb !== undefined && totalKb > 0 ? Math.round((usedKb / totalKb) * 1000) / 10 : undefined,
+  }
+}
+
+/** Parse `dumpsys battery` into {level, temperatureC, status, health, powered}. */
+export function parseBattery(output) {
+  const grab = (name) => {
+    const match = new RegExp(`^\\s*${name}:\\s*(.+)`, "m").exec(String(output))
+    return match ? match[1].trim() : undefined
+  }
+  const levelRaw = grab("level")
+  const tempRaw = grab("temperature")
+  const level = levelRaw ? Number(levelRaw) : undefined
+  const tempRawNum = tempRaw ? Number(tempRaw) : undefined
+  return {
+    level,
+    temperatureC: tempRawNum !== undefined && Number.isFinite(tempRawNum) ? Math.round(tempRawNum) / 10 : undefined,
+    status: grab("status"),
+    health: grab("health"),
+    powered: grab("AC powered") === "true" || grab("USB powered") === "true" || grab("Wireless powered") === "true",
+  }
+}
+
+/** Parse `cat /proc/cpuinfo` into {cores, hardware}. */
+export function parseCpuinfo(output) {
+  const text = String(output)
+  const cores = (text.match(/^processor\s*:/gm) ?? []).length
+  const hardware = /^Hardware\s*:\s*(.+)$/m.exec(text)?.[1]?.trim()
+  return { cores: cores > 0 ? cores : undefined, hardware }
+}
+
+/** Parse `dumpsys package <pkg>` into {versionName, versionCode, minSdk, targetSdk, permissions, activities}. */
+export function parseAppInfo(output, packageName) {
+  const text = String(output)
+  const grab = (name) => {
+    const match = new RegExp(`${name}=(\\S+)`, "m").exec(text)
+    return match ? match[1] : undefined
+  }
+  const permissions = []
+  const textLines = text.split(/\r?\n/)
+  const headerIndex = textLines.findIndex((line) => line.trim() === "requested permissions:")
+  if (headerIndex >= 0) {
+    for (let i = headerIndex + 1; i < textLines.length; i += 1) {
+      const trimmed = textLines[i].trim()
+      if (trimmed === "" || !/^(android\.permission\.|com\.[^\s]+\.permission\.)[A-Z0-9_.]+$/.test(trimmed)) break
+      permissions.push(trimmed)
+    }
+  }
+  const activities = []
+  const resolverIndex = textLines.findIndex((line) => line.trim() === "Activity Resolver Table:")
+  if (resolverIndex >= 0) {
+    // Real resolver-table rows are `<hex> pkg/.Activity filter <hex>` (or `pkg/.Activity (hex)`):
+    //  5f60459 com.android.settings/.Settings$ApnEditorActivity filter 4e9281e
+    // MIME-type headers (vnd.android.cursor.item/telephony-carrier:) contain a `-` so the
+    // component class [\w.$]+ cannot span it, keeping them out of the match.
+    for (let i = resolverIndex + 1; i < textLines.length && activities.length < 20; i += 1) {
+      const match = /([A-Za-z_][\w.$]*\/[\w.$]+)\s+(?:filter\s+[0-9a-f]+|\([0-9a-f]+\))/i.exec(textLines[i].trim())
+      if (match && !activities.includes(match[1])) activities.push(match[1])
+    }
+  }
+  return {
+    package: packageName,
+    versionName: grab("versionName"),
+    versionCode: grab("versionCode"),
+    minSdk: grab("minSdk"),
+    targetSdk: grab("targetSdk"),
+    permissions: [...new Set(permissions)].slice(0, 60),
+    activities: activities.slice(0, 20),
+  }
+}
+
 /** SDK emulator binary (emulator.exe on Windows), or undefined. */
 export function emulatorBinary() {
   const sdk = androidSdk()
@@ -736,13 +973,13 @@ export async function androidAvds() {
 
 /** True once the serial has finished booting (sys.boot_completed == 1). */
 export async function androidBooted(serial) {
-  const output = await capture(adb(), ["-s", serial, "shell", "getprop", "sys.boot_completed"])
+  const output = await adbRun(serial, ["shell", "getprop", "sys.boot_completed"]).catch(() => "")
   return output.trim() === "1"
 }
 
 /** AVD name of an emulator serial (`adb emu avd name`); undefined for physical/offline. */
 export async function avdName(serial) {
-  const output = await capture(adb(), ["-s", serial, "emu", "avd", "name"])
+  const output = await adbRun(serial, ["emu", "avd", "name"]).catch(() => "")
   const line = output
     .split(/\r?\n/)
     .map((item) => item.trim())
@@ -771,14 +1008,14 @@ export function bootEmulator(avd) {
 
 /** True when the ADBKeyboard IME is installed (the only way to type non-ASCII over adb). */
 export async function adbKeyboardReady(serial) {
-  const output = await capture(adb(), ["-s", serial, "shell", "ime", "list", "-s"])
+  const output = await adbRun(serial, ["shell", "ime", "list", "-s"]).catch(() => "")
   return /com\.android\.adbkeyboard/i.test(output)
 }
 
 /** Type one string via the ADBKeyboard broadcast (base64, so any codepoint survives the shell). */
 export async function typeViaAdbKeyboard(serial, text) {
   const msg = Buffer.from(text, "utf8").toString("base64")
-  await exec(adb(), ["-s", serial, "shell", "am", "broadcast", "-a", "ADB_INPUT_B64", "--es", "msg", msg]).exit
+  await adbRun(serial, ["shell", "am", "broadcast", "-a", "ADB_INPUT_B64", "--es", "msg", msg])
 }
 
 /** True when every codepoint is safe for `adb shell input text` (printable ASCII, no shell metachars). */
@@ -819,14 +1056,14 @@ export async function androidDevice() {
 
 /** Primary CPU ABI of a device, e.g. `arm64-v8a`. */
 export async function androidAbi(serial) {
-  const output = await capture(adb(), ["-s", serial, "shell", "getprop", "ro.product.cpu.abi"])
+  const output = await adbRun(serial, ["shell", "getprop", "ro.product.cpu.abi"]).catch(() => "")
   const abi = output.trim()
   return /^[a-z0-9_-]+$/i.test(abi) ? abi : undefined
 }
 
 /** Free space on the device's data partition in megabytes, when `df` reports it. */
 export async function androidFreeMb(serial) {
-  return parseFreeMb(await capture(adb(), ["-s", serial, "shell", "df", "-k", "/data"]))
+  return parseFreeMb(await adbRun(serial, ["shell", "df", "-k", "/data"]).catch(() => ""))
 }
 
 /** Second line of `df -k`: Filesystem 1K-blocks Used Available Use% Mounted. */
@@ -931,7 +1168,7 @@ export async function devices(serial) {
 /** Local path of a fresh screenshot of the serial. undefined on failure. */
 export async function screenCapture(serial, outDir) {
   const remote = "/sdcard/dsh-mobilecode-shot.png"
-  await exec(adb(), ["-s", serial, "shell", "screencap", "-p", remote]).exit
+  await adbRun(serial, ["shell", "screencap", "-p", remote])
   const name = `screen-${serial}-${Date.now()}.png`
   const local = path.join(outDir ?? os.tmpdir(), name)
   const pulled = await new Promise((resolve) => {
@@ -952,8 +1189,8 @@ export async function screenCapture(serial, outDir) {
  */
 export async function uiDump(serial) {
   const remote = "/sdcard/dsh-mobilecode-ui.xml"
-  await exec(adb(), ["-s", serial, "shell", "uiautomator", "dump", remote]).exit
-  const xml = await capture(adb(), ["-s", serial, "shell", "cat", remote])
+  await adbRun(serial, ["shell", "uiautomator", "dump", remote])
+  const xml = await adbRun(serial, ["shell", "cat", remote])
   const items = []
   const node = /<node[^>]*>/g
   for (const match of xml.match(node) ?? []) {
@@ -975,7 +1212,7 @@ export async function uiDump(serial) {
 
 /** Foreground activity, e.g. "com.foo/.MainActivity", or undefined. */
 export async function foregroundActivity(serial) {
-  const output = await capture(adb(), ["-s", serial, "shell", "dumpsys", "activity", "activities"])
+  const output = await adbRun(serial, ["shell", "dumpsys", "activity", "activities"]).catch(() => "")
   const line = output.split("\n").find((item) => /topResumedActivity|mResumedActivity/.test(item))
   const match = /ActivityRecord\{[^}]*\s([^\s}]+)\}/.exec(line ?? "")
   return match?.[1] ?? undefined
@@ -983,14 +1220,14 @@ export async function foregroundActivity(serial) {
 
 /** Kernel log (dmesg). Requires adb root — works on emulators, usually not on real devices. */
 export async function dmesg(serial) {
-  return capture(adb(), ["-s", serial, "shell", "dmesg"])
+  return adbRun(serial, ["shell", "dmesg"])
 }
 
 /** logcat snapshot, filtered by buffer/level/package-like substring. */
 export async function logcat(serial, { buffer = "main", lines = 200, filter } = {}) {
-  const args = ["-s", serial, "logcat", "-d", "-t", String(lines)]
+  const args = ["logcat", "-d", "-t", String(lines)]
   if (buffer && buffer !== "all") args.push("-b", buffer)
-  let output = await capture(adb(), args)
+  let output = await adbRun(serial, args)
   if (filter) output = output.split("\n").filter((line) => line.toLowerCase().includes(filter.toLowerCase())).join("\n")
   return output
 }