dsh-mobile-use 1.0.1 → 1.0.4

package/mirror.js

@@ -20,11 +20,26 @@ import { mkdir, readdir, rm, stat, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { homedir } from 'node:os'
 
-import { LiveStream, packFrame } from './stream.js?v=141'
+import { LiveStream, packFrame } from './stream.js?v=149'
 
 /** 客户端与宿主共用的路由前缀。 */
 export const ROUTE = '/dsh-mobile-use'
 
+/**
+ * 节拍器回调兜底：异常冒到 host 顶层会直接把整个 DSH 带走（2026-10-27 事故），
+ * 所以单拍出错只记一行，不停服务、不退进程。
+ * @param {string} where - 出问题的路径。
+ * @param {() => void} run - 这一拍要做的事。
+ * @returns {void}
+ */
+function guard(where, run) {
+  try {
+    run()
+  } catch (error) {
+    console.error(`[dsh-mobile-use] ${where}:`, error)
+  }
+}
+
 /** 最近一次标注里动效拼图的字节数，0 表示没凑够帧。 */
 let lastStripBytes = 0
 
@@ -41,6 +56,10 @@ const LIVE_FPS = 3
 const PUSH_TICK_MS = 200
 /** 同时在飞的截图数：单张约 0.65s，3 张并发实测 4 帧/秒以上。 */
 const CAPTURE_PARALLEL = 2
+/** 没人看多久之后收掉分段录制：跟抓帧的空转宽限同一个数，别留两个口径。 */
+const WATCH_GRACE_MS = 6000
+/** 本进程的随机标识：设备端 pid 文件名带上它，多开/重启时不会互相覆盖。 */
+const REC_TAG = Math.random().toString(36).slice(2, 8)
 
 /** 环形缓冲：10 秒一段，留 18 段 ≈ 3 分钟，超出的由 ffmpeg 自己覆盖。 */
 const SEGMENT_SECONDS = 10
@@ -229,6 +248,9 @@ function pngToJpeg(png) {
   })
 }
 
+/** 单个 MJPEG 连接的待写上限：慢客户端不能把宿主进程的堆吃光。 */
+const MAX_LIVE_QUEUE = 2 * 1024 * 1024
+
 /**
  * 往一个 MJPEG 连接写一帧。
  * @param {import('node:http').ServerResponse} res - 连接。
@@ -238,6 +260,12 @@ function pngToJpeg(png) {
  */
 function writeFrame(res, frame, drop) {
   try {
+    /* 慢客户端只许拖垮自己：待写超过上限就直接断连，让它重连，别在宿主里攒队列。 */
+    if (res.writableLength > MAX_LIVE_QUEUE) {
+      drop()
+      res.destroy()
+      return
+    }
     res.write(`--frame\r\ncontent-type: image/jpeg\r\ncontent-length: ${frame.length}\r\n\r\n`)
     res.write(frame)
     res.write('\r\n')
@@ -263,11 +291,17 @@ export class Mirror {
     this.height = 0
     this.watchers = new Set()
     this.lastWatchAt = 0
+    /* 并发 start 的单飞句柄：见 start()。 */
+    this.startPromise = null
     this.dropped = 0
     this.seq = 0
     this.waiters = []
     this.grabMs = 0
     this.recording = false
+    /* 分段录制的收尾：请求停止标记 + 设备端 pid 文件名（只杀自己这一次录屏）。 */
+    this.recorderStopRequested = false
+    this.recorderPidFile = ''
+    this.recorderSeq = 0
     this.stopping = false
     this.startedAt = 0
     this.error = ''
@@ -293,24 +327,36 @@ export class Mirror {
    * @returns {boolean} 有观看者（或刚有人来看）为真。
    */
   anyoneWatching() {
-    return this.watchers.size > 0 || Date.now() - this.lastWatchAt < 6000
+    return this.watchers.size > 0 || Date.now() - this.lastWatchAt < WATCH_GRACE_MS
   }
 
   async start() {
     if (this.timer !== null || this.stopping) return
-    await mkdir(this.dir, { recursive: true })
-    this.startedAt = Date.now()
-    this.error = ''
-    const size = await this.adb(['-s', this.serial, 'shell', 'wm', 'size'], { timeout: 6000 })
-    const found = /(\d+)x(\d+)/.exec(String(size.out ?? ''))
-    if (found !== null) this.physical = { w: Number(found[1]), h: Number(found[2]) }
-    await this.snapshot()
-    this.alignScreen()
-    this.timer = setInterval(() => this.pump(), 200)
-    this.timer.unref?.()
-    this.pushTimer = setInterval(() => this.push(), PUSH_TICK_MS)
-    this.pushTimer.unref?.()
-    void this.startRecorder()
+    /* 并发 start（页面重载 + /frame 同时到）只许跑一次：起两套定时器后，停的时候必漏一套。 */
+    if (this.startPromise !== null) return this.startPromise
+    this.startPromise = (async () => {
+      await mkdir(this.dir, { recursive: true })
+      this.startedAt = Date.now()
+      this.error = ''
+      const size = await this.adb(['-s', this.serial, 'shell', 'wm', 'size'], { timeout: 6000 })
+      const found = /(\d+)x(\d+)/.exec(String(size.out ?? ''))
+      if (found !== null) this.physical = { w: Number(found[1]), h: Number(found[2]) }
+      await this.snapshot()
+      this.alignScreen()
+      /* 等到这里再判一次：await 期间可能已经有人 stop 了。 */
+      if (this.stopping) return
+      this.timer = setInterval(() => guard('pump', () => this.pump()), 200)
+      this.timer.unref?.()
+      this.pushTimer = setInterval(() => guard('push', () => this.push()), PUSH_TICK_MS)
+      this.pushTimer.unref?.()
+      /* 录制跟观看者对齐：起服务时没人看就先不录，等 /frame 或 /live 把人带来再开。 */
+      this.ensureRecorder()
+    })().catch((error) => {
+      this.error = String(error?.message ?? error)
+    }).finally(() => {
+      this.startPromise = null
+    })
+    return this.startPromise
   }
 
   /**
@@ -328,22 +374,24 @@ export class Mirror {
     this.screen = landscape ? { w: long, h: short } : { w: short, h: long }
   }
 
-  /** 有人在看才抓帧；没人看就空转并顺手关掉转码进程。 @returns {void} */
+  /** 有人在看才抓帧；没人看就空转，宽限期过了顺手把分段录制也收掉。 @returns {void} */
   pump() {
     if (this.stopping) return
     if (!this.anyoneWatching()) {
       if (this.inflight === 0) {
         if (this.idleSince === 0) this.idleSince = Date.now()
       }
+      this.ensureRecorder()
       return
     }
     this.idleSince = 0
+    this.ensureRecorder()
     /* 桥接帧够新就别再抓屏：两种源尺寸不同，混进同一池子画面会跳。 */
     if (this.bridgeFresh !== null && this.bridgeFresh()) return
     /* 每个节拍最多补一张，让 3 张在飞时错开完成，画面才匀。 */
     if (this.inflight < CAPTURE_PARALLEL) {
       this.inflight += 1
-      void this.grab().finally(() => { this.inflight -= 1 })
+      void this.grab().catch((error) => { this.error = String(error?.message ?? error) }).finally(() => { this.inflight -= 1 })
     }
   }
 
@@ -878,24 +926,76 @@ export class Mirror {
     return frame
   }
 
+  /**
+   * 该录就录、该停就停：只有有人在看才保留分段录制，没人看超过宽限期就收掉。
+   * 由 pump() 每 200ms 调一次，重复调用无副作用。
+   * @returns {void}
+   */
+  ensureRecorder() {
+    if (this.stopping) return
+    if (this.anyoneWatching()) {
+      if (!this.recording) void this.startRecorder()
+      return
+    }
+    if (!this.recording) return
+    const idleAt = this.idleSince > 0 ? this.idleSince : this.lastWatchAt
+    if (idleAt > 0 && Date.now() - idleAt < WATCH_GRACE_MS) return
+    this.stopRecorder()
+  }
+
+  /**
+   * 请求停掉分段录制：只按自己记下的设备端 pid 收尾，不碰别人的 screenrecord。
+   * @returns {void}
+   */
+  stopRecorder() {
+    this.recorderStopRequested = true
+    const pidFile = this.recorderPidFile
+    this.recorderPidFile = ''
+    if (pidFile !== '') void this.killOwnRecorder(pidFile)
+  }
+
+  /**
+   * 精确杀自己这一次录屏：pid 取自启动时写下的设备端文件，并核对进程名还是 screenrecord。
+   * pid 拿不到（文件为空/读不到）就退化为不杀，只记一条错误，交给下一段自己超时结束。
+   * @param {string} pidFile - 启动时写下的 pid 文件绝对路径。
+   * @returns {Promise<string>} 设备端回话：`killed:<pid>` 或 `skip:<原因>`。
+   */
+  async killOwnRecorder(pidFile) {
+    const safe = String(pidFile).replace(/[^\w./-]/g, '')
+    if (safe === '') return 'skip:no-pid-file'
+    const script = `p='${safe}'; r=$(cat "$p" 2>/dev/null); rm -f "$p"; if [ -n "$r" ] && [ "$(cat /proc/$r/comm 2>/dev/null)" = 'screenrecord' ]; then kill -9 "$r"; echo killed:$r; else echo skip:$r; fi`
+    const result = await this.adb(['-s', this.serial, 'shell', script], { timeout: 8000, direct: true }).catch(() => null)
+    const out = String(result?.out ?? '').trim()
+    if (out.startsWith('killed:')) return out
+    this.error = this.error || `录屏收尾没拿到 pid（${out || '没有回话'}），没杀设备端进程`
+    return out || 'skip:no-reply'
+  }
+
   /**
    * 循环分段录制：设备上录 10s 一段，拉回本机，只留最近 18 段。
+   * 每段启动时把 pid 写进设备端文件，停止时按 pid 精确 kill。
    * @returns {Promise<void>} 停了才返回。
    */
   async startRecorder() {
     if (this.recording || this.stopping) return
     this.recording = true
-    const remote = `/sdcard/dsh-${this.serial.replace(/[^\w.-]/g, '_')}.mp4`
-    while (!this.stopping) {
+    this.recorderStopRequested = false
+    const safeSerial = this.serial.replace(/[^\w.-]/g, '_')
+    const remote = `/sdcard/dsh-${safeSerial}.mp4`
+    while (!this.stopping && !this.recorderStopRequested) {
       const started = Date.now()
-      const recorded = await this.adb([
-        '-s', this.serial, 'shell', 'screenrecord',
-        '--time-limit', String(SEGMENT_SECONDS),
-        '--bit-rate', '2000000', '--size', this.recordSize(), remote,
-      ], { timeout: (SEGMENT_SECONDS + 20) * 1000, direct: true })
-      if (this.stopping) break
+      this.recorderSeq += 1
+      const pidFile = `/data/local/tmp/dsh-mobile-use-rec-${safeSerial}-${REC_TAG}-${this.recorderSeq}.pid`
+      this.recorderPidFile = pidFile
+      /* exec 让 shell 的 pid 就是 screenrecord 的 pid：停的时候按这个 pid 精确 kill。 */
+      const command = `sh -c 'echo $$ > ${pidFile}; exec screenrecord --time-limit ${SEGMENT_SECONDS} --bit-rate 2000000 --size ${this.recordSize()} ${remote}'`
+      const recorded = await this.adb(['-s', this.serial, 'shell', command], {
+        timeout: (SEGMENT_SECONDS + 20) * 1000,
+        direct: true,
+      }).catch((error) => ({ ok: false, err: String(error?.message ?? error) }))
+      if (this.stopping || this.recorderStopRequested) break
       if (!recorded.ok) {
-        this.error = recorded.err.trim().slice(0, 200) || '录制失败'
+        this.error = String(recorded.err ?? '').trim().slice(0, 200) || '录制失败'
         await new Promise((resolve) => setTimeout(resolve, 1500))
         continue
       }
@@ -914,6 +1014,7 @@ export class Mirror {
       if (spent < SEGMENT_SECONDS * 1000) await new Promise((resolve) => setTimeout(resolve, Math.max(0, 400 - spent)))
     }
     this.recording = false
+    this.recorderStopRequested = false
   }
 
   /** 本机只留最近 18 段（约 3 分钟）。 @returns {Promise<void>} 删完。 */
@@ -961,9 +1062,10 @@ export class Mirror {
     return this.latest
   }
 
-  /** 停掉两条子进程并断开观看者。 @returns {void} */
+  /** 停掉两条子进程、收掉分段录制并断开观看者；重复调用无副作用。 @returns {void} */
   stop() {
     this.stopping = true
+    this.stopRecorder()
     if (this.timer !== null) clearInterval(this.timer)
     this.timer = null
     if (this.pushTimer !== null) clearInterval(this.pushTimer)
@@ -1017,6 +1119,11 @@ export function setupMirror(ctx, tools) {
     let stream = streams.get(serial)
     if (stream === undefined) {
       stream = new LiveStream({ serial, adb: tools.adb.path })
+      /* 空闲回收前先问一句：镜像还有人在看（/live 常连或刚拉过帧）就别停。 */
+      stream.stillWanted = () => {
+        const mirror = mirrors.get(serial)
+        return mirror !== undefined && mirror.anyoneWatching()
+      }
       streams.set(serial, stream)
     }
     return stream
@@ -1095,6 +1202,11 @@ export function setupMirror(ctx, tools) {
     if (rect !== null && Number(rect.w) > 0) {
       lines.push(`圈选区域（设备坐标）：x=${Math.round(rect.x)} y=${Math.round(rect.y)} w=${Math.round(rect.w)} h=${Math.round(rect.h)}`)
     }
+    /* 圈是画在冻结帧上的：把「画面是几秒前的」交出去，免得把那一刻的控件位置当成现在。 */
+    const frozenMs = Number(input.frozen_ms)
+    if (Number.isFinite(frozenMs) && frozenMs >= 1) {
+      lines.push(`这张图是一张 ${(frozenMs / 1000).toFixed(1)} 秒前冻结的画面，圈的位置以那一帧为准。`)
+    }
     if (tools.uiInRect !== undefined && rect !== null) {
       const inside = await tools.uiInRect(String(input.serial ?? ''), rect).catch(() => [])
       if (inside.length > 0) lines.push(`圈选区域内的控件：\n${inside.join('\n')}`)
@@ -1347,7 +1459,7 @@ export function setupMirror(ctx, tools) {
       }
       child.on('error', (error) => finish({ ok: false, reason: String(error && error.message ? error.message : error).slice(0, 200) }))
       child.on('exit', (code) => finish(code === 0 ? { ok: true } : { ok: false, reason: '退出码 ' + code }))
-      const tick = () => {
+      const tick = () => guard('gesture-tick', () => {
         if (index >= frames.length) {
           child.stdin.end()
           return
@@ -1355,13 +1467,13 @@ export function setupMirror(ctx, tools) {
         child.stdin.write(stampFrame(frames[index], start + (index * step) / 1000))
         index += 1
         setTimeout(tick, step)
-      }
+      })
       tick()
-      setTimeout(() => {
+      setTimeout(() => guard('gesture-timeout', () => {
         if (done) return
         child.kill('SIGKILL')
         finish({ ok: false, reason: '注入超时' })
-      }, ms + 4000)
+      }), ms + 4000)
     })
   }
 
@@ -1531,7 +1643,9 @@ export function setupMirror(ctx, tools) {
         })
         res.flushHeaders()
         let closed = false
-        const unsubscribe = stream.subscribe((bytes) => {
+        /* 先占位再订阅：subscribe 可能同步补发初始化段，那时 unsubscribe 还没赋值。 */
+        let unsubscribe = () => {}
+        unsubscribe = stream.subscribe((bytes) => {
           if (closed) return
           /* 积压超过 2 MB 就断开重连：宁可重连一次，也不要让延迟越滚越大。 */
           if (res.writableLength > 2 << 20) {
@@ -1588,6 +1702,8 @@ export function setupMirror(ctx, tools) {
           void stream.enableJpeg()
           /* 录屏到时长会停；每次有人拉帧都把它续上，否则画面就只剩抓帧那一路。 */
           void stream.start()
+          /* start() 会清空闲定时器，所以续命之后重新排一次：面板关掉 20 秒后自动停录。 */
+          stream.scheduleIdleStop()
         })
         const pump = () => {
           const jpeg = stream.jpeg
@@ -1636,6 +1752,8 @@ export function setupMirror(ctx, tools) {
           fps: mirror.measuredFps(),
           live: mirror.latest !== null,
           watchers: mirror.watchers.size,
+          /* 录制是后台行为：状态里如实报，别让人以为没人看时也在录。 */
+          recording: mirror.recording,
           dropped: mirror.dropped,
           grabMs: mirror.grabMs,
           pushed: mirror.pushed,
@@ -1867,6 +1985,7 @@ export function setupMirror(ctx, tools) {
       return {
         serial: chosen,
         live: mirror.latest !== null,
+        recording: mirror.recording,
         frames: mirror.frames,
         fps: mirror.measuredFps(),
         bufferedSeconds: segments.length * SEGMENT_SECONDS,
@@ -1879,6 +1998,12 @@ export function setupMirror(ctx, tools) {
       return mirror === undefined ? [] : mirror.segments()
     },
     stopAll() {
+      /* 先停 H.264 直播：每个实例都有自己的设备端录屏和 ffmpeg 子进程，比抓帧泵重得多。
+         只清 mirrors 会把这些子进程留在设备上继续录，卸载插件后还在跑。 */
+      for (const stream of streams.values()) {
+        try { stream.stop() } catch { /* 已经停了 */ }
+      }
+      streams.clear()
       for (const mirror of mirrors.values()) mirror.stop()
       mirrors.clear()
       for (const res of events) {

package/ocr.js

@@ -10,7 +10,7 @@
  * @module dsh-mobile-use/ocr
  */
 
-import { spawn } from 'node:child_process'
+import { spawn, spawnSync } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -18,7 +18,11 @@ import { fileURLToPath } from 'node:url'
 const HERE = dirname(fileURLToPath(import.meta.url))
 const WORKER = join(HERE, 'ocr_worker.py')
 const IDLE_MS = 45_000
-const CALL_TIMEOUT_MS = 8_000
+/** 一次 ocrImage 的总时限：启动 + 识别共用，避免两边各自超时叠成半分钟。 */
+const CALL_TIMEOUT_MS = 15_000
+/** 启动 worker 的单独上限：worker 卡在 import Vision 时要尽快放弃。 */
+const START_TIMEOUT_MS = 8_000
+const PYTHON = '/usr/bin/python3'
 
 let worker = null
 let ready = null
@@ -27,9 +31,46 @@ let seq = 0
 const pending = new Map()
 let buffer = ''
 
-/** python3 是否存在（不存在就没有 OCR）。 */
+/**
+ * 探一次本机能不能跑 OCR：平台、worker 文件、python 能否 import Vision 三个条件。
+ * 结果缓存，插件生命周期内只探一次（worker 起不来时也别每次调用都 spawn 一次 python）。
+ * @returns {{ available: boolean, reason: string }} 可用性；不可用时 `reason` 说明原因。
+ */
+function probe() {
+  if (process.platform !== 'darwin') return { available: false, reason: `本机是 ${process.platform}，Vision OCR 只有 macOS 有` }
+  if (!existsSync(WORKER)) return { available: false, reason: `缺少 ${WORKER}` }
+  if (!existsSync(PYTHON)) return { available: false, reason: `缺少 ${PYTHON}` }
+  /* 只探 import：worker 真正用到的 Vision/Quartz 都在这里，缺 pyobjc 会在启动后立刻崩。 */
+  const check = spawnSync(PYTHON, ['-c', 'import Vision, Quartz, Foundation'], { timeout: 5000, stdio: 'ignore' })
+  if (check.error) {
+    return { available: false, reason: `${PYTHON} 起不来：${String(check.error.message ?? check.error).slice(0, 120)}` }
+  }
+  if (check.status !== 0) return { available: false, reason: `${PYTHON} 缺 Vision/Quartz（pyobjc-framework-Vision）` }
+  return { available: true, reason: '' }
+}
+
+let availability = null
+
+/**
+ * 本机 OCR 状态：可用性和不可用原因。
+ * @returns {{ available: boolean, reason: string }} `reason` 可直接写进工具结果，让上层回退到文本树/截图。
+ */
+export function ocrStatus() {
+  if (availability === null) availability = probe()
+  return availability
+}
+
+/** python3 与 Vision 是否可用（不存在就没有 OCR）。 @returns {boolean} 可用为 true。 */
 export function ocrAvailable() {
-  return existsSync(WORKER) && existsSync('/usr/bin/python3')
+  return ocrStatus().available
+}
+
+/**
+ * 拿不可用原因；可用时返回空串。
+ * @returns {string} 人话原因，例如「本机是 linux，Vision OCR 只有 macOS 有」。
+ */
+export function ocrReason() {
+  return ocrStatus().reason
 }
 
 function kill() {
@@ -57,13 +98,22 @@ function armIdle() {
 
 function start() {
   if (ready) return ready
+  const state = ocrStatus()
+  if (!state.available) return Promise.reject(new Error(`本机没有 OCR：${state.reason}`))
   ready = new Promise((resolve, reject) => {
-    const child = spawn('/usr/bin/python3', [WORKER], { stdio: ['pipe', 'pipe', 'pipe'] })
+    let settled = false
+    const fail = (error) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      reject(error)
+      kill()
+    }
+    const child = spawn(PYTHON, [WORKER], { stdio: ['pipe', 'pipe', 'pipe'] })
     worker = child
     const timer = setTimeout(() => {
-      reject(new Error('OCR 进程启动超时'))
-      kill()
-    }, 15_000)
+      fail(new Error('OCR 进程启动超时'))
+    }, START_TIMEOUT_MS)
     child.stdout.setEncoding('utf8')
     child.stdout.on('data', (chunk) => {
       buffer += chunk
@@ -78,8 +128,11 @@ function start() {
           continue
         }
         if (message.ready === true) {
-          clearTimeout(timer)
-          resolve()
+          if (!settled) {
+            settled = true
+            clearTimeout(timer)
+            resolve()
+          }
           continue
         }
         const entry = pending.get(message.path)
@@ -92,15 +145,16 @@ function start() {
     child.stderr.setEncoding('utf8')
     child.stderr.on('data', () => {})
     child.on('error', (error) => {
-      clearTimeout(timer)
-      reject(error)
-      kill()
+      fail(error)
     })
-    child.on('exit', () => {
-      clearTimeout(timer)
+    child.on('exit', (code, signal) => {
+      /* 关键：ready 之前就退出时必须 reject，否则 start() 的 Promise 永远挂着，
+         上层 ocrImage 的 await 也跟着挂死（非 macOS / 缺 pyobjc 时的实际表现）。 */
+      fail(new Error(`OCR 进程启动时退出（code=${String(code)}, signal=${String(signal)}）`))
       if (worker === child) {
         worker = null
         ready = null
+        buffer = ''
         for (const [, entry] of pending) entry.reject(new Error('OCR 进程退出'))
         pending.clear()
       }
@@ -116,13 +170,17 @@ function start() {
  *   `x/y/w/h` 是归一化坐标，原点在**左下角**（Vision 的习惯）。
  */
 export async function ocrImage(path) {
+  /* 启动和识别共用一个 deadline：启动慢了，识别就少等，整体最多 CALL_TIMEOUT_MS。 */
+  const deadline = Date.now() + CALL_TIMEOUT_MS
   await start()
   armIdle()
+  const left = deadline - Date.now()
+  if (left <= 0) throw new Error('OCR 超时')
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
       pending.delete(path)
       reject(new Error('OCR 超时'))
-    }, CALL_TIMEOUT_MS)
+    }, left)
     pending.set(path, {
       resolve: (result) => {
         clearTimeout(timer)
@@ -133,7 +191,20 @@ export async function ocrImage(path) {
         reject(error)
       },
     })
-    worker.stdin.write(`${path}\n`)
+    /* worker 可能在 start() resolve 之后、这里之前就退了：写不进去就明确失败，别抛同步异常。 */
+    if (worker === null) {
+      pending.delete(path)
+      clearTimeout(timer)
+      reject(new Error('OCR 进程已退出'))
+      return
+    }
+    try {
+      worker.stdin.write(`${path}\n`)
+    } catch (error) {
+      pending.delete(path)
+      clearTimeout(timer)
+      reject(error instanceof Error ? error : new Error(String(error)))
+    }
   })
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-use",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "private": false,
   "description": "真机调试插件：界面文本树、动效数据、实时画面侧栏与圈选标注",
   "type": "module",
@@ -40,7 +40,8 @@
     "ocr_worker.py",
     ".env.example",
     "THIRD_PARTY_NOTICES.md",
-    "docs"
+    "docs",
+    "test"
   ],
   "license": "MIT",
   "author": "dsh-mobile-use contributors",
@@ -60,5 +61,8 @@
     "uiautomator",
     "mirror",
     "debugging"
-  ]
+  ],
+  "scripts": {
+    "test": "node test/coords.test.mjs && node test/symbols.test.mjs && node test/timers.test.mjs"
+  }
 }