@windypro-rourou/dsh-logcat 0.6.6 → 0.7.0

package/lib/index.js

@@ -21,6 +21,7 @@ import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { createInterface } from 'node:readline'
 import { WebSocket, WebSocketServer } from 'ws'
+import { INJECTOR_JAR_BASE64 } from './injector-jar.js'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 
 /** This package's manifest (name + version), read from the installed location. */
@@ -358,6 +359,392 @@ class DeviceStream {
   }
 }
 
+/** Incremental Annex-B H.264 parser: groups NAL units into access units and emits AVCC frames. */
+class H264Framer {
+  constructor(onFrame, onInit) {
+    this.buf = Buffer.alloc(0)
+    this.parts = []
+    this.hasVcl = false
+    this.hasIdr = false
+    this.sps = null
+    this.pps = null
+    this.initSent = false
+    this.onFrame = onFrame
+    this.onInit = onInit
+  }
+
+  /** Exponential-Golomb ue(v) reading, starting at byte `fromByte` of `nal`. */
+  readUe(nal, fromByte) {
+    const bitAt = (p) => ((nal[p >> 3] >> (7 - (p & 7))) & 1)
+    const total = nal.length * 8
+    let pos = fromByte * 8
+    let zeros = 0
+    while (pos < total && bitAt(pos) === 0) { zeros += 1; pos += 1 }
+    if (pos >= total) return -1
+    pos += 1
+    let value = 0
+    for (let k = 0; k < zeros && pos < total; k++) { value = (value << 1) | bitAt(pos); pos += 1 }
+    return (1 << zeros) - 1 + value
+  }
+
+  /** Feed raw bytes; complete access units are emitted as AVCC frames. */
+  push(chunk) {
+    this.buf = this.buf.length === 0 ? chunk : Buffer.concat([this.buf, chunk])
+    if (this.buf.length > 8 * 1024 * 1024) { this.buf = this.buf.subarray(this.buf.length - 1024 * 1024) } // runaway guard
+    const nals = []
+    let lastStart = -1
+    let i = 0
+    while (i + 3 <= this.buf.length) {
+      const is4 = i + 4 <= this.buf.length && this.buf[i] === 0 && this.buf[i + 1] === 0 && this.buf[i + 2] === 0 && this.buf[i + 3] === 1
+      const is3 = !is4 && this.buf[i] === 0 && this.buf[i + 1] === 0 && this.buf[i + 2] === 1
+      if (is4 || is3) {
+        if (lastStart >= 0) nals.push([lastStart, i])
+        lastStart = i
+        i += is4 ? 4 : 3
+        continue
+      }
+      i += 1
+    }
+    if (lastStart < 0) return
+    for (const [s, e] of nals) this.handleNal(this.buf.subarray(s, e))
+    // Keep the trailing NAL (possibly incomplete) for the next chunk.
+    this.buf = this.buf.subarray(lastStart)
+  }
+
+  /** Classify one NAL (with its start code) and fold it into the current access unit. */
+  handleNal(raw) {
+    let off = 0
+    if (raw.length >= 4 && raw[0] === 0 && raw[1] === 0 && raw[2] === 0 && raw[3] === 1) off = 4
+    else if (raw.length >= 3 && raw[0] === 0 && raw[1] === 0 && raw[2] === 1) off = 3
+    const nal = raw.subarray(off)
+    if (nal.length === 0) return
+    const type = nal[0] & 0x1f
+    if (type === 7) {
+      if (this.hasVcl) this.flush()
+      this.sps = Buffer.from(nal)
+      this.sendInitIfReady()
+      return
+    }
+    if (type === 8) {
+      if (this.hasVcl) this.flush()
+      this.pps = Buffer.from(nal)
+      this.sendInitIfReady()
+      return
+    }
+    if (type === 9 || type === 6) {
+      // AUD / SEI: a new access unit begins; SEI is dropped (not needed for decoding).
+      if (this.hasVcl) this.flush()
+      return
+    }
+    if (type === 1 || type === 5) {
+      const firstMb = this.readUe(nal, 1)
+      if (firstMb === 0 && this.hasVcl) this.flush()
+      this.parts.push(nal)
+      this.hasVcl = true
+      if (type === 5) this.hasIdr = true
+      return
+    }
+    if (this.hasVcl) this.parts.push(nal)
+  }
+
+  /** Emit the buffered access unit as one AVCC frame (4-byte length prefixes). */
+  flush() {
+    if (!this.hasVcl || this.parts.length === 0) {
+      this.parts = []
+      this.hasVcl = false
+      this.hasIdr = false
+      return
+    }
+    let size = 0
+    for (const p of this.parts) size += 4 + p.length
+    const out = Buffer.allocUnsafe(size)
+    let o = 0
+    for (const p of this.parts) {
+      out.writeUInt32BE(p.length, o)
+      p.copy(out, o + 4)
+      o += 4 + p.length
+    }
+    const key = this.hasIdr
+    this.parts = []
+    this.hasVcl = false
+    this.hasIdr = false
+    this.onFrame(out, key)
+  }
+
+  /** Build the avcC description + codec string once SPS and PPS are known. */
+  buildInit() {
+    if (this.sps === null || this.pps === null) return null
+    const sps = this.sps
+    const pps = this.pps
+    const avcC = Buffer.alloc(11 + sps.length + pps.length)
+    let o = 0
+    avcC[o++] = 1
+    avcC[o++] = sps[1]
+    avcC[o++] = sps[2]
+    avcC[o++] = sps[3]
+    avcC[o++] = 0xfc | 3 // lengthSizeMinusOne
+    avcC[o++] = 0xe0 | 1 // numOfSequenceParameterSets
+    avcC.writeUInt16BE(sps.length, o); o += 2
+    sps.copy(avcC, o); o += sps.length
+    avcC[o++] = 1 // numOfPictureParameterSets
+    avcC.writeUInt16BE(pps.length, o); o += 2
+    pps.copy(avcC, o); o += pps.length
+    return { codec: 'avc1.' + sps.subarray(1, 4).toString('hex'), avcC: avcC.subarray(0, o) }
+  }
+
+  sendInitIfReady() {
+    if (this.initSent) return
+    const init = this.buildInit()
+    if (init === null) return
+    this.initSent = true
+    this.onInit(init)
+  }
+}
+
+/** One H.264 screen stream (screenrecord child) per device. */
+/** Where the embedded injector dex is deployed on the device. */
+const REMOTE_JAR = '/data/local/tmp/dsh-injector.jar'
+
+/**
+ * Map a stock `input ...` shell command onto the injector's protocol.
+ * Returns null for anything the injector cannot do (notably `input text`).
+ */
+function mapInputCommand(command) {
+  const match = /^input\s+(tap|swipe|keyevent)\s+([\d.\s]+)$/.exec(String(command).trim())
+  if (match === null) return null
+  const args = match[2].trim().replace(/\s+/g, ' ')
+  if (args === '') return null
+  return (match[1] === 'keyevent' ? 'key ' : match[1] + ' ') + args
+}
+
+/**
+ * Long-lived input injector.
+ *
+ * Every call to the stock `input` command boots a fresh app_process (a Java VM): measured
+ * ~480ms on the reference device, which is exactly the lag the panel's touch controls had.
+ * This keeps one Injector process alive per device and streams gestures into its stdin, so a
+ * tap costs a few milliseconds instead. Any failure falls back to the stock command.
+ */
+class InputChannel {
+  constructor(adb, serial) {
+    this.adb = adb
+    this.serial = serial
+    this.child = null
+    this.ready = false
+    this.starting = null
+    this.pending = null
+    this.buffer = ''
+    this.deployed = false
+    this.onReady = null
+  }
+
+  /** Start (and deploy, once) the injector. Resolves true when it answered READY. */
+  start() {
+    if (this.ready && this.child !== null) return Promise.resolve(true)
+    if (this.starting !== null) return this.starting
+    this.starting = this.launch().finally(() => { this.starting = null })
+    return this.starting
+  }
+
+  async launch() {
+    if (!this.deployed) {
+      // Written over a plain shell command: `adb push` speaks the sync protocol, which drops
+      // out on flaky USB links, whereas a shell write is a single round-trip.
+      const write = await runAdbFull(this.adb, ['-s', this.serial, 'shell', `echo ${INJECTOR_JAR_BASE64} | base64 -d > ${REMOTE_JAR}`], 25000)
+      if (write.ok !== true) return false
+      this.deployed = true
+    }
+    let child
+    try {
+      child = spawn(this.adb, ['-s', this.serial, 'shell', `CLASSPATH=${REMOTE_JAR} app_process /system/bin dsh.Injector`], { windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] })
+    } catch { return false }
+    this.child = child
+    this.buffer = ''
+    child.stdout.on('data', (chunk) => this.onData(String(chunk)))
+    child.stderr.on('data', () => { /* diagnostics only */ })
+    const dead = () => { this.child = null; this.ready = false; this.deployed = false }
+    child.on('exit', dead)
+    child.on('error', dead)
+    // READY means the VM is up and InputManager resolved; anything slower counts as failure.
+    const ok = await new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(false), 8000)
+      this.onReady = () => { clearTimeout(timer); resolve(true) }
+      child.on('exit', () => { clearTimeout(timer); resolve(false) })
+    })
+    if (!ok) {
+      try { child.kill() } catch { /* gone */ }
+      this.child = null
+      return false
+    }
+    this.ready = true
+    return true
+  }
+
+  onData(text) {
+    this.buffer += text
+    let index
+    while ((index = this.buffer.indexOf('\n')) >= 0) {
+      const line = this.buffer.slice(0, index).trim()
+      this.buffer = this.buffer.slice(index + 1)
+      if (line === '') continue
+      if (line === 'READY') {
+        const fire = this.onReady
+        this.onReady = null
+        if (fire !== null) fire()
+        continue
+      }
+      const pending = this.pending
+      if (pending !== null) {
+        this.pending = null
+        clearTimeout(pending.timer)
+        pending.resolve(line)
+      }
+    }
+  }
+
+  /** Send one gesture; resolves { error, ms } — or null when the injector is unusable. */
+  send(line) {
+    const child = this.child
+    if (!this.ready || child === null) return Promise.resolve(null)
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => { this.pending = null; resolve(null) }, 4000)
+      this.pending = {
+        timer,
+        resolve: (reply) => {
+          const error = /^ERR/.test(reply) ? reply.slice(4).trim() : ''
+          const ms = Number((/^OK\s+(\d+)/.exec(reply) ?? [])[1] ?? 0)
+          resolve({ error, ms })
+        },
+      }
+      try {
+        child.stdin.write(line + '\n')
+      } catch {
+        clearTimeout(timer)
+        this.pending = null
+        resolve(null)
+      }
+    })
+  }
+
+  dispose() {
+    this.ready = false
+    if (this.child !== null) {
+      try { this.child.kill() } catch { /* gone */ }
+      this.child = null
+    }
+    if (this.pending !== null) {
+      clearTimeout(this.pending.timer)
+      this.pending.resolve('')
+      this.pending = null
+    }
+  }
+}
+
+class VideoStream {
+  constructor(adb, serial, opts, handlers) {
+    this.adb = adb
+    this.serial = serial
+    this.opts = opts                 // { size, bitRate }
+    this.onFrame = handlers.onFrame
+    this.onInit = handlers.onInit
+    this.onState = handlers.onState
+    this.child = null
+    this.stopped = false
+    this.restartTimer = null
+    this.framer = null
+    this.frames = 0
+    this.bytes = 0
+    this.startedAt = 0
+    this.lastError = ''
+    this.lastFrameAt = 0
+    this.lastIdle = false
+    this.watchTimer = null
+  }
+
+  start() {
+    if (this.stopped || this.child !== null) return
+    const args = ['-s', this.serial, 'exec-out', 'screenrecord',
+      '--output-format=h264', '--size', this.opts.size,
+      '--bit-rate', String(this.opts.bitRate), '--time-limit', '179', '-']
+    let child
+    try {
+      child = spawn(this.adb, args, { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] })
+    } catch (error) {
+      this.lastError = error instanceof Error ? error.message : String(error)
+      this.scheduleRestart(3000)
+      return
+    }
+    this.child = child
+    this.startedAt = Date.now()
+    this.frames = 0
+    this.bytes = 0
+    this.framer = new H264Framer(
+      (frame, key) => { this.frames += 1; this.lastFrameAt = Date.now(); this.onFrame(frame, key) },
+      (init) => this.onInit(init),
+    )
+    // Watch for an idle stream (device asleep / static screen) so the panel can hint the user.
+    if (this.watchTimer !== null) clearInterval(this.watchTimer)
+    this.watchTimer = setInterval(() => {
+      const idle = Date.now() - (this.lastFrameAt || this.startedAt) > 2500
+      if (idle !== this.lastIdle) {
+        this.lastIdle = idle
+        this.onState({ running: true, idle })
+      }
+    }, 2500)
+    // screenrecord produces frames only when the screen changes: the first probe
+    // also flips the idle flag off as soon as a frame arrives.
+    let stderrText = ''
+    child.stderr.on('data', (c) => {
+      stderrText = (stderrText + String(c)).slice(-600)
+      this.lastError = stderrText.trim().slice(-300)
+    })
+    child.stdout.on('data', (chunk) => {
+      this.bytes += chunk.length
+      if (this.framer !== null) this.framer.push(chunk)
+    })
+    const done = () => {
+      this.child = null
+      if (this.stopped) return
+      // --time-limit reached (or the encoder exited): restart promptly, the stream continues.
+      this.onState({ running: true, restarted: true, error: this.lastError })
+      this.scheduleRestart(120)
+    }
+    child.on('exit', done)
+    child.on('error', done)
+    this.onState({ running: true, restarted: false })
+  }
+
+  scheduleRestart(ms) {
+    if (this.stopped) return
+    if (this.restartTimer !== null) clearTimeout(this.restartTimer)
+    this.restartTimer = setTimeout(() => { this.restartTimer = null; this.start() }, ms)
+  }
+
+  stop() {
+    this.stopped = true
+    if (this.restartTimer !== null) clearTimeout(this.restartTimer)
+    this.restartTimer = null
+    if (this.watchTimer !== null) { clearInterval(this.watchTimer); this.watchTimer = null }
+    if (this.child !== null) {
+      try { this.child.kill() } catch { /* gone */ }
+      this.child = null
+    }
+    this.onState({ running: false })
+  }
+
+  stats() {
+    const sec = (Date.now() - this.startedAt) / 1000
+    return {
+      size: this.opts.size,
+      bitRate: this.opts.bitRate,
+      fps: sec > 0 ? Math.round((this.frames / sec) * 10) / 10 : 0,
+      mbps: sec > 0 ? Math.round((this.bytes * 8 / sec / 1e6) * 100) / 100 : 0,
+      idle: Date.now() - (this.lastFrameAt || this.startedAt) > 2500,
+      error: this.lastError || undefined,
+    }
+  }
+}
+
 /** The adb engine: device poll, per-device ring buffers, ws fan-out. */
 export class AdbEngine {
   constructor() {
@@ -378,6 +765,9 @@ export class AdbEngine {
     this.eventsStreams = new Map()  // serial -> DeviceStream (-b events)
     this.lastCrash = new Map()      // serial -> ms timestamp (snapshot throttle)
     this.screenLoops = new Map()    // serial -> { timer, busy } (1fps screen stream)
+    this.videoStreams = new Map()   // serial -> VideoStream (H.264 screenrecord stream)
+    this.displays = new Map()       // serial -> { width, height, rotation, at } (oriented display)
+    this.inputChannels = new Map()  // serial -> InputChannel (long-lived gesture injector)
   }
 
   /** Serial -> filesystem-safe directory name. */
@@ -432,6 +822,10 @@ export class AdbEngine {
     this.eventsStreams.clear()
     for (const loop of this.screenLoops.values()) clearInterval(loop.timer)
     this.screenLoops.clear()
+    for (const stream of this.videoStreams.values()) stream.stop()
+    this.videoStreams.clear()
+    for (const channel of this.inputChannels.values()) channel.dispose()
+    this.inputChannels.clear()
     for (const ws of this.clients) {
       try { ws.close(1001, 'plugin disposed') } catch { /* closed */ }
     }
@@ -447,6 +841,8 @@ export class AdbEngine {
       const next = parseDevices(output)
       const changed = this.syncDevices(next)
       if (changed) this.broadcast({ type: 'devices', devices: this.deviceList() })
+      if (this.videoStreams.size > 0) void this.followRotation()
+      void this.warmInput()
     } finally {
       this.polling = false
     }
@@ -476,6 +872,11 @@ export class AdbEngine {
           clearInterval(sloop.timer)
           this.screenLoops.delete(serial)
         }
+        const vstream = this.videoStreams.get(serial)
+        if (vstream !== undefined) {
+          vstream.stop()
+          this.videoStreams.delete(serial)
+        }
         changed = true
       }
     }
@@ -507,6 +908,11 @@ export class AdbEngine {
           clearInterval(sloop.timer)
           this.screenLoops.delete(serial)
         }
+        const vstream = this.videoStreams.get(serial)
+        if (vstream !== undefined) {
+          vstream.stop()
+          this.videoStreams.delete(serial)
+        }
         this.broadcast({ type: 'device-state', serial, state: info.state })
       }
     }
@@ -689,6 +1095,8 @@ export class AdbEngine {
 
   /** Start / stop the screen-stream loop for a device (panel live view). */
   setScreen(serial, on) {
+    if (on) void this.displayState(serial)
+    if (on) void this.ensureInput(serial)
     const existing = this.screenLoops.get(serial)
     if (on) {
       if (existing === undefined && this.adb !== null && this.devices.get(serial)?.state === 'device') {
@@ -728,6 +1136,167 @@ export class AdbEngine {
     } catch { /* frame dropped */ }
   }
 
+  /**
+   * Start / stop the H.264 screen stream (screenrecord) for a device — the
+   * 30fps path used by the panel's live view. `opts.size` / `opts.bitRate`
+   * restart the encoder when they change.
+   */
+  /**
+   * Current *oriented* display geometry of a device. screenrecord always encodes against the
+   * panel's natural orientation, so a landscape app ends up letterboxed inside a portrait
+   * frame (measured: 80% black bars) and the encoded pixels no longer match the touch
+   * coordinate space. Callers use this to swap the requested stream size instead.
+   * Cheap: `grep -m1` makes the device-side dumpsys exit early.
+   */
+  async displayState(serial, maxAgeMs = 1200) {
+    const cached = this.displays.get(serial)
+    const now = Date.now()
+    if (cached !== undefined && now - cached.at < maxAgeMs) return cached
+    let next = cached ?? null
+    try {
+      const out = await runAdb(this.adb, ['-s', serial, 'shell', 'dumpsys display | grep -m1 mOverrideDisplayInfo'], 6000)
+      if (typeof out === 'string' && out !== '') {
+        const size = /real (\d+) x (\d+)/.exec(out)
+        const rot = /rotation (\d+)/.exec(out)
+        if (size !== null) {
+          next = { width: Number(size[1]), height: Number(size[2]), rotation: rot === null ? 0 : Number(rot[1]), at: now }
+        }
+      }
+    } catch { /* keep the last known geometry */ }
+    if (next !== null) this.displays.set(serial, next)
+    return next
+  }
+
+  /** Swap a stream size when the device's current rotation contradicts it (the letterbox case). */
+  async orientedSize(serial, size) {
+    const [w, h] = String(size).split('x').map(Number)
+    if (!Number.isFinite(w) || !Number.isFinite(h) || w <= 0 || h <= 0) return size
+    const disp = await this.displayState(serial)
+    if (disp === null) return size
+    if ((w > h) === (disp.width > disp.height)) return size
+    return `${h}x${w}`
+  }
+
+  /** Latest known oriented geometry per device (exposed to the panel for touch mapping). */
+  displaySnapshot() {
+    const out = {}
+    for (const [serial, d] of this.displays) out[serial] = { width: d.width, height: d.height, rotation: d.rotation }
+    return out
+  }
+
+  /**
+   * Keep the gesture injector warm while a screen stream is live. A failed start (device
+   * briefly offline, adb hiccup) used to be permanent because nothing retried until the next
+   * user gesture; this repairs the channel in the background.
+   */
+  async warmInput() {
+    const now = Date.now()
+    if (now - (this.lastWarmAt ?? 0) < 8000) return
+    this.lastWarmAt = now
+    const serials = new Set([...this.streams.keys(), ...this.videoStreams.keys()])
+    for (const serial of serials) {
+      const channel = this.inputChannels.get(serial)
+      if (channel !== undefined && channel.ready) continue
+      await this.ensureInput(serial)
+    }
+  }
+
+  /** screenrecord cannot rotate mid-stream: rebuild the encoder when the display turns. */
+  async followRotation() {
+    for (const [serial, stream] of [...this.videoStreams]) {
+      const baseSize = stream.opts.baseSize
+      if (typeof baseSize !== 'string') continue
+      const want = await this.orientedSize(serial, baseSize)
+      if (want === stream.opts.size) continue
+      const bitRate = stream.opts.bitRate
+      stream.stop()
+      this.videoStreams.delete(serial)
+      await this.setVideo(serial, true, { size: baseSize, bitRate })
+    }
+  }
+
+  /** Deploy/start (once) and reuse the long-lived injector for a device. */
+  async ensureInput(serial) {
+    if (this.adb === null || this.devices.get(serial)?.state !== 'device') return null
+    let channel = this.inputChannels.get(serial)
+    if (channel === undefined) {
+      channel = new InputChannel(this.adb, serial)
+      this.inputChannels.set(serial, channel)
+    }
+    const ready = await channel.start()
+    if (!ready) {
+      channel.dispose()
+      this.inputChannels.delete(serial)
+      return null
+    }
+    return channel
+  }
+
+  /**
+   * Fast path for `input tap|swipe|keyevent` through the long-lived injector. Returns null
+   * when the command is not injectable or the helper is unavailable — the caller then falls
+   * back to the stock shell command.
+   */
+  async tryInject(serial, command) {
+    const mapped = mapInputCommand(command)
+    if (mapped === null) return null
+    const channel = await this.ensureInput(serial)
+    if (channel === null) return null
+    const result = await channel.send(mapped)
+    if (result === null || result.error !== '') return null
+    return result
+  }
+
+  /** Devices whose gesture injector is live (diagnostics + panel hint). */
+  inputReady() {
+    const out = []
+    for (const [serial, channel] of this.inputChannels) if (channel.ready) out.push(serial)
+    return out
+  }
+
+  async setVideo(serial, on, opts = {}) {
+    const existing = this.videoStreams.get(serial)
+    if (!on) {
+      if (existing !== undefined) {
+        existing.stop()
+        this.videoStreams.delete(serial)
+      }
+      this.broadcast({ type: 'video-state', serial, running: false })
+      return
+    }
+    // Warm the gesture injector while the stream starts, so the first tap is already fast.
+    void this.ensureInput(serial)
+    const baseSize = typeof opts.size === 'string' && /^\d{2,4}x\d{2,4}$/.test(opts.size) ? opts.size : '540x1200'
+    // Follow the current rotation: a landscape device must be encoded WxH-swapped, otherwise
+    // screenrecord letterboxes it into a portrait frame.
+    const size = await this.orientedSize(serial, baseSize)
+    const bitRate = Math.min(Math.max(Number(opts.bitRate) || 2500000, 200000), 20000000)
+    if (existing !== undefined) {
+      if (existing.opts.size === size && existing.opts.bitRate === bitRate) return
+      existing.stop()
+      this.videoStreams.delete(serial)
+    }
+    if (this.adb === null || this.devices.get(serial)?.state !== 'device') {
+      this.broadcast({ type: 'video-state', serial, running: false, error: 'device not attached' })
+      return
+    }
+    const stream = new VideoStream(this.adb, serial, { size, bitRate, baseSize }, {
+      onFrame: (frame, key) => this.broadcastBinary({ type: 'svideo', serial, key, ts: Date.now() }, frame),
+      onInit: (init) => this.broadcast({ type: 'svideo-init', serial, codec: init.codec, avcC: init.avcC.toString('base64'), size }),
+      onState: (state) => this.broadcast({ type: 'video-state', serial, size, bitRate, display: this.displaySnapshot()[serial], ...state }),
+    })
+    this.videoStreams.set(serial, stream)
+    stream.start()
+    this.broadcast({ type: 'video-state', serial, running: true, size, bitRate })
+  }
+
+  /** Live encoder stats per device (fps / Mbps / active tier). */
+  videoStats() {
+    const out = {}
+    for (const [serial, stream] of this.videoStreams) out[serial] = stream.stats()
+    return out
+  }
+
   /** Broadcast a binary frame: 4-byte header length + JSON header + payload. */
   broadcastBinary(header, payload) {
     const headerBuf = Buffer.from(JSON.stringify(header), 'utf8')
@@ -902,6 +1471,11 @@ function makeRoutes(engine) {
           streaming: [...engine.streams.keys()],
           eventsStreaming: [...engine.eventsStreams.keys()],
           screenCapable: true,
+          videoCapable: true,
+          videoStreaming: [...engine.videoStreams.keys()],
+          videoStats: engine.videoStats(),
+          displays: engine.displaySnapshot(),
+          inputInjected: engine.inputReady(),
           currentPackage: engine.currentPackage,
           currentVersion: OWN_MANIFEST.version,
           latestVersion,
@@ -952,6 +1526,13 @@ function makeRoutes(engine) {
         if (serial === '' || command === '') { writeJson(res, 400, { error: 'serial and command are required' }); return }
         const timeoutMs = typeof body.timeoutMs === 'number' ? body.timeoutMs : 15000
         try {
+          // Gestures go through the long-lived injector when possible: the stock `input`
+          // command costs a JVM boot (~480ms) per call, this costs a few milliseconds.
+          const injected = await engine.tryInject(serial, command)
+          if (injected !== null) {
+            writeJson(res, 200, { ok: true, code: 0, stdout: '', stderr: '', injected: true, ms: injected.ms })
+            return
+          }
           const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', command], timeoutMs)
           writeJson(res, 200, result)
         } catch (error) {
@@ -1148,6 +1729,11 @@ function makeRoutes(engine) {
         if (engine.adb === null) { writeJson(res, 500, { error: 'adb not found' }); return }
         if (serial === '' || !engine.devices.has(serial)) { writeJson(res, 400, { error: 'device not attached' }); return }
         if (!Number.isInteger(code) || code <= 0) { writeJson(res, 400, { error: `unknown key: ${key || '(none)'}` }); return }
+        const injected = await engine.tryInject(serial, `input keyevent ${code}`)
+        if (injected !== null) {
+          writeJson(res, 200, { ok: true, code: 0, stdout: '', stderr: '', injected: true, ms: injected.ms })
+          return
+        }
         const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', `input keyevent ${code}`], 15000)
         writeJson(res, 200, { ok: result.ok, code: result.code, stdout: result.stdout, stderr: result.stderr })
       },
@@ -1340,6 +1926,9 @@ function makeRoutes(engine) {
           } else if (frame?.type === 'screen' && typeof frame.serial === 'string') {
             // Panel toggles the per-device live screen stream (1fps screencap).
             engine.setScreen(frame.serial, frame.on === true)
+          } else if (frame?.type === 'video' && typeof frame.serial === 'string') {
+            // Panel toggles the H.264 screen stream (screenrecord → 30fps path).
+            void engine.setVideo(frame.serial, frame.on === true, { size: frame.size, bitRate: frame.bitRate })
           }
         })
         ws.on('close', () => { engine.clients.delete(ws) })
@@ -3068,6 +3657,7 @@ export function apply(ctx, config) {
       devices: engine.deviceList(),
       streaming: [...engine.streams.keys()],
       eventsStreaming: [...engine.eventsStreams.keys()],
+      videoStreaming: [...engine.videoStreams.keys()],
       bufferSizes: Object.fromEntries([...engine.buffers.entries()].map(([s, b]) => [s, b.length])),
       currentPackage: engine.currentPackage,
     }),

package/lib/injector-jar.js

@@ -0,0 +1,6 @@
+// Auto-generated - do not edit by hand.
+// Base64 of lib/injector.jar (dex of tmp-inject/src/dsh/Injector.java): the long-lived
+// app_process input injector. Embedded so the host can deploy it with a single shell write,
+// without relying on db push (its sync protocol is fragile on flaky USB links).
+// Rebuild with: node tmp-build-injector.mjs
+export const INJECTOR_JAR_BASE64 = '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'