dsh-mobilecode 0.7.0 → 0.8.0

package/README.md

@@ -202,7 +202,57 @@ classified adb boundary (argv-based, quoted, replay-safe):
 - `device_backtrace` — a thread/crash dump without a debugger: sends SIGQUIT
   (`kill -3`), waits for ART to write the trace, reads the newest `/data/anr`
   entry, and falls back to the logcat crash buffer when `/data/anr` is unreadable
-  (`engine: "anr-trace" | "logcat-crash"`). Pass `package_name` or `pid`.
+  (`engine: "anr-trace" | "logcat-crash"`). SIGQUIT refusal (system-uid or
+  non-debuggable process) degrades to the crash buffer with an explanatory note
+  instead of failing. Pass `package_name` or `pid`.
+- `device_display` — read or change a device's **DPI and resolution**
+  (`wm density` / `wm size`): `get` reports physical + override values, `set`
+  overrides density and/or `width`x`height`, `reset` restores. Layouts reflow
+  instantly — re-observe with `device_screen` after a change.
+- `device_avd_create` — create a **second virtual device** via `avdmanager`;
+  `clone_from` copies an existing AVD's full hardware config (same image, DPI,
+  RAM) so both players behave identically. Boot the new AVD with `device_boot`
+  (a running emulator holds 5554, so device #2 lands on `emulator-5556`).
+- `device_batch` — fire 1..16 input actions **concurrently across devices**
+  (each step carries its own serial + the same fields `device_input` takes).
+  The co-op primitive for "both players press attack on the same frame"; a
+  failing step never blocks the others, and per-step results say what landed.
+- `device_pair_capture` — capture **both devices at the same instant**: one
+  call, parallel screenshots + UI digests, both attached as real image blocks
+  so a vision model watches both players at once. `ocr: true` adds PaddleOCR.
+
+**Co-op mesh (v0.8.0)** — two emulators cannot multicast-discover each other
+(each sits behind its own slirp NAT), but every one of them reaches the host at
+`10.0.2.2`. So the plugin hosts a LocalSend-style JSON pub/sub **hub**: games
+join it and talk through it, and the AI model reads and steers the same wire.
+
+- **Identity**: `POST /mesh/join {serial?, name?, role?}` — the serial pins a
+  stable, random, LocalSend-style callsign (`amber-fox`, `brisk-owl`…); the
+  join returns a per-process token that authorizes every later call.
+- **Sessions**: `POST /mesh/link {with: [names…]}` (2–8 members), then
+  `POST /mesh/send {session, body}` and `GET /mesh/poll?id&token&after&wait`
+  (long-polls up to 30 s). `GET /mesh/peers` shows the roster; `POST /mesh/leave`
+  departs. Everything is JSON, 64 KiB per message.
+- **Network conditions**: each session carries a policy — `latencyMs`,
+  `jitterMs`, `dropPct`, `dupPct`, `throttleKbps` (size-proportional delay) —
+  enforced per recipient by the hub. This is desync testing without touching
+  app code: make player B lag 400 ms with 100 ms jitter and watch the pair cope.
+- **Agent side**: `mesh_status` (who joined, sessions, policies, undelivered
+  mail), `mesh_send` (ghost a message as any peer — the other game receives it
+  as if its partner sent it), `mesh_log` (every join/link/send/drop/dup/tune
+  event, timestamped), `mesh_tune` (set the policy), `mesh_reset`.
+- **Security**: the routes are loopback-only (emulators reach the host loopback
+  via slirp); a request presenting browser headers (`Origin`/`Sec-Fetch-*`)
+  must additionally pass the trusted-browser stream fence, so a random web page
+  can never join a game or read its messages.
+- **Client SDK**: `sdk/mesh-client.mjs` — a ~90-line dependency-free `fetch`
+  client (`join/link/send/inbox`) for Node/Deno/Bun/WebView/React-Native game
+  code; plain HTTP works from any other engine (Unity, Godot, Kotlin).
+
+Typical loop: `device_avd_create` + `device_boot` a clone → both apps
+`join` → `mesh_link` → `device_batch` inputs at both → `device_pair_capture`
+to watch → `mesh_log` to see the traffic → `mesh_tune` to inject real-world
+network pain.
 
 **Conversation surface (v0.7.0)** — the transcript integration ported from
 dsh-android's UI/UX:
@@ -257,7 +307,9 @@ plus the live-stream routes `GET /stream/status`, `POST /stream/grant`,
 `POST /stream/devices` (online devices **and** configured AVDs),
 `POST /stream/still` (one `screencap` as a data URL up to 4 MB),
 `POST /stream/device-action` (the `device_action` verbs over the panel fence)
-and `GET /stream/{token}` (the multipart frame body). Every stream error carries
+and `GET /stream/{token}` (the multipart frame body) — plus the co-op mesh
+routes `POST /mesh/join`, `GET /mesh/peers`, `POST /mesh/{link,send,leave}`,
+`GET /mesh/poll` (see **Co-op mesh** above). Every stream error carries
 a machine-readable `code` next to the HTTP status — `token_invalid`,
 `stream_not_running`, `stream_start_failed`, `devices_unavailable`,
 `device_not_found`, `device_offline`, `unknown_action`, `bad_request`,
@@ -292,8 +344,14 @@ say *why* instead of "something failed".
   lifecycle (park → halt → settle → execute; one project at a time; process
   exit/signal hooks; win32 taskkill tree-kill).
 - `lib/index.js` — host half: engine, `/api/dsh-mobilecode/*` routes (run
-  controls + welcome / doctor / ocr / settings), agent tools, system-prompt
+  controls + welcome / doctor / ocr / settings + mesh), agent tools, system-prompt
   guidance section, `ctx.provide('mobilecode', handle)`.
+- `lib/mesh-hub.js` — the co-op mesh core: peer identity (serial-pinned
+  callsigns + HMAC tokens), sessions, per-session network policy
+  (latency/jitter/drop/dup/throttle), a long-poll inbox, and an event log.
+  Pure + injectable clock/RNG, so `test/mesh-hub.mjs` covers it offline.
+- `sdk/mesh-client.mjs` — dependency-free `fetch` client (join/link/send/
+  poll/inbox/leave) for game code running inside the emulators.
 - `lib/setup.js` — settings store (~/.dsh/mobilecode/settings.json), the plugin
   doctor (health checks + auto-fix), and the detached PaddleOCR installer
   (writes an install script to disk and spawns it via cmd.exe, so the install

package/lib/device-build.js

@@ -1335,3 +1335,124 @@ export async function ocrImage(pngPath, lang = "ch") {
   }
   return []
 }
+
+// ── AVD creation + display overrides (v0.8.0) ────────────────────────────────
+
+/** avdmanager.bat from the SDK cmdline-tools, or undefined. */
+export function avdmanagerBinary() {
+  const sdk = androidSdk()
+  if (!sdk) return undefined
+  const exe = process.platform === "win32" ? "avdmanager.bat" : "avdmanager"
+  const roots = [path.join(sdk, "cmdline-tools", "latest"), path.join(sdk, "cmdline-tools")]
+  for (const root of roots) {
+    const direct = path.join(root, "bin", exe)
+    if (existsSync(direct)) return direct
+    if (!existsSync(path.join(root, "bin"))) {
+      try {
+        for (const entry of readdirSync(root)) {
+          const candidate = path.join(root, entry, "bin", exe)
+          if (existsSync(candidate)) return candidate
+        }
+      } catch { /* nothing to enumerate */ }
+    }
+  }
+  return undefined
+}
+
+/** Installed system-image packages as `system-images;<api>;<tag>;<abi>` ids. */
+export async function installedSystemImages() {
+  const sdk = androidSdk()
+  if (!sdk) return []
+  const ids = []
+  const base = path.join(sdk, "system-images")
+  for (const api of readdirSafe(base)) {
+    for (const tag of readdirSafe(path.join(base, api))) {
+      for (const abi of readdirSafe(path.join(base, api, tag))) {
+        ids.push(`system-images;${api};${tag};${abi}`)
+      }
+    }
+  }
+  return ids.sort()
+}
+
+function readdirSafe(dir) {
+  try { return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) } catch { return [] }
+}
+
+/** config.ini path of a created AVD. */
+export function avdConfigPath(name) {
+  return path.join(os.homedir(), ".android", "avd", `${name}.avd`, "config.ini")
+}
+
+function parseIni(text) {
+  const entries = []
+  for (const line of String(text).split(/\r?\n/)) {
+    const match = /^\s*([\w.]+)\s*=\s*(.*)$/.exec(line)
+    if (match) entries.push([match[1], match[2].trim()])
+  }
+  return entries
+}
+
+/**
+ * Merge an AVD config for hardware-parity cloning: identity/path keys of the
+ * NEW avd stay theirs; every other key (hw.*, image.sysdir, runtime perms)
+ * comes from the source. Pure so it can be unit-tested.
+ */
+export function mergeAvdConfig(newText, sourceText) {
+  const KEEP = new Set(["avd.id", "avd.name", "path", "path.rel", "basedir", "displayname"])
+  const base = parseIni(newText)
+  const source = new Map(parseIni(sourceText).filter(([key]) => !KEEP.has(key)))
+  const seen = new Set()
+  const lines = base.map(([key, value]) => {
+    seen.add(key)
+    return source.has(key) ? `${key}=${source.get(key)}` : `${key}=${value}`
+  })
+  for (const [key, value] of source) if (!seen.has(key)) lines.push(`${key}=${value}`)
+  return lines.join("\n") + "\n"
+}
+
+/**
+ * Create an AVD via avdmanager. `cloneConfigText` (optional) is the source
+ * AVD's config.ini — merged in afterwards for hardware parity. Throws with
+ * avdmanager's own error text on failure.
+ */
+export async function createAvd({ name, imageId, deviceProfile, cloneConfigText }) {
+  const binary = avdmanagerBinary()
+  if (!binary) throw new Error("avdmanager not found in the SDK cmdline-tools — install it via sdkmanager.")
+  const args = ["create", "avd", "-n", name, "-k", imageId]
+  if (deviceProfile) args.push("-d", deviceProfile)
+  args.push("--force")
+  const result = await captureFull(binary, args, { env: javaEnv() })
+  if (result.code !== 0) {
+    const text = [result.out, result.err].filter(Boolean).join("\n")
+    throw new Error(`avdmanager failed (exit ${result.code}):\n${text.slice(-600)}`)
+  }
+  const configPath = avdConfigPath(name)
+  if (!existsSync(configPath)) throw new Error(`AVD "${name}" was created but config.ini is missing at ${configPath}.`)
+  if (cloneConfigText) {
+    const merged = mergeAvdConfig(readFileSync(configPath, "utf8"), cloneConfigText)
+    writeFileSync(configPath, merged)
+  }
+  return { name, configPath }
+}
+
+/** avdmanager/`sdkmanager` are Java tools: make sure JAVA_HOME-less shells still find java. */
+function javaEnv() {
+  return { ANDROID_HOME: androidSdk(), ANDROID_SDK_ROOT: androidSdk() }
+}
+
+/** Parse `wm density` output → {physical, override|null}. */
+export function parseWmDensity(text) {
+  const physical = Number(/Physical density:\s*(\d+)/.exec(text)?.[1]) || undefined
+  const override = Number(/Override density:\s*(\d+)/.exec(text)?.[1]) || undefined
+  return { physical, override: override && override !== physical ? override : null }
+}
+
+/** Parse `wm size` output → {physical:{width,height}, override|null}. */
+export function parseWmSize(text) {
+  const toSize = (m) => (m ? { width: Number(m[1]), height: Number(m[2]) } : undefined)
+  const physical = toSize(/Physical size:\s*(\d+)x(\d+)/.exec(text))
+  const override = toSize(/Override size:\s*(\d+)x(\d+)/.exec(text))
+  const same = override && physical && override.width === physical.width && override.height === physical.height
+  return { physical, override: same ? null : (override ?? null) }
+}