dsh-adb 0.1.5 → 1.0.0

package/README.md

@@ -1,42 +1,50 @@
 # dsh-adb
 
-> ADB 设备·台架运维工具集 for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)
+> ADB device & bench operations for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)
 
-让 DSH agent 直接操作 Android 设备 / 车机台架：设备发现、结构化 logcat、apk 安装、文件 pull/push、性能快照。面向实车与台架联调场景，业务内通用（不限 Unity、不限具体车机协议）。
+Give DSH agents direct control over Android devices and automotive bench rigs: device discovery, structured logcat, APK install, file pull/push, and performance snapshots. Built for on-vehicle and bench debugging workflows — generic within the domain (no Unity, no vendor protocol lock-in).
 
-## 安装
+**English** | [简体中文](README.zh-CN.md)
+
+## Install
 
 ```sh
 dsh plugin --profile web add dsh-adb
 ```
 
-或从 GitHub 直装：`dsh plugin --profile web add github:SamXiaBing/dsh-adb`
+Or install directly from GitHub: `dsh plugin --profile web add github:SamXiaBing/dsh-adb`
+
+## Web device panel (v1.0.0)
 
-## 生态收录
+A "设备" tab in the conversation view ring (next to chat / trajectory / automation): device list with status, package-scoped performance snapshot (memory / frame stats / battery), and filtered logcat tail. Data flows over the package RPC channel; requires the plugin installed in a web profile and a GUI restart.
 
-- ✅ [npm](https://www.npmjs.com/package/dsh-adb) — `dsh-adb@0.1.0` 已发布（2026-08-14）
-- ✅ [awesome-deepseek-harness#87](https://github.com/0xsline/awesome-deepseek-harness/pull/87) — **已合并**
-- ✅ [awesome-dsh-plugin#85](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin/pull/85) — **已合并**
-- ⏳ [awesome-DSH-plugin#29](https://github.com/Alex-Yanggg/awesome-DSH-plugin/pull/29) — 待合并
+## Ecosystem
 
-Topics：`dsh-plugin` `dsh` `adb` `android` `automotive` `bench`
+- ✅ [npm](https://www.npmjs.com/package/dsh-adb) — `dsh-adb` published (latest: 1.0.0)
+- ✅ [awesome-deepseek-harness#87](https://github.com/0xsline/awesome-deepseek-harness/pull/87) — **merged**
+- ✅ [awesome-dsh-plugin#85](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin/pull/85) — **merged**
+- ✅ [awesome-DSH-plugin#29](https://github.com/Alex-Yanggg/awesome-DSH-plugin/pull/29) — **merged**
 
-## 工具
+Topics: `dsh-plugin` `dsh` `adb` `android` `automotive` `bench`
 
-| 工具 | 说明 |
+## Tools
+
+| Tool | Description |
 | --- | --- |
-| `adb_devices` | 列出设备（serial/state/product/model），先发现再操作 |
-| `adb_connect` / `adb_disconnect` | 无线台架连接（host:port，默认 5555） |
-| `adb_logcat` | 过滤读取（tag/级别/关键字/时间窗/tail）；`run_in_background` 后台连续采集，job_output 读增量、job_kill 停止 |
-| `adb_install` | 安装 apk（-r/-d/-g 选项），校验本地文件存在 |
-| `adb_file` | pull / push / ls / rm，设备隔离 |
-| `adb_perf_snapshot` | `dumpsys meminfo / gfxinfo / battery` 结构化快照（PSS/帧率百分位/卡顿率/电量） |
+| `adb_devices` | List devices (serial/state/product/model); run first to discover serials |
+| `adb_connect` / `adb_disconnect` | Wireless bench connection (host:port, default 5555) |
+| `adb_logcat` | Filtered read (tag/level/keyword/time-window/tail); `run_in_background` streams continuously as a job — read deltas with `job_output`, stop with `job_kill` |
+| `adb_install` | Install APKs (`-r`/`-d`/`-g` options); validates the local file exists |
+| `adb_file` | pull / push / ls / rm, per-device isolation |
+| `adb_perf_snapshot` | Structured `dumpsys meminfo / gfxinfo / battery` snapshots (PSS, frame percentiles, jank rate, battery) |
+| `adb_perf_baseline` | Perf regression: save a snapshot as a baseline (label/tags), compare current state and get a numeric diff (PSS, janky %, percentiles), list/delete baselines (stored locally under `baselineDir`) |
+| `adb_crash_report` | One-call crash scene: parsed logcat crash buffer + dropbox excerpt + process state + memory summary |
 
-错误码：`ADB_NOT_FOUND`、`ADB_UNAVAILABLE`、`DEVICE_NOT_FOUND`、`NO_DEVICES`、`CONNECT_FAILED`、`INSTALL_FAILED`、`ADB_EXIT_<code>` 等，均为结构化 `AdbError`。
+Errors are structured `AdbError` with stable codes: `ADB_NOT_FOUND`, `ADB_UNAVAILABLE`, `DEVICE_NOT_FOUND`, `NO_DEVICES`, `CONNECT_FAILED`, `INSTALL_FAILED`, `ADB_EXIT_<code>`, etc.
 
-## 配置
+## Configuration
 
-`cordis.patch.yml` 的 `config` 块（或 profile patch）：
+Set the `config` block in `cordis.patch.yml` (or a profile patch):
 
 ```yaml
 - id: dsh-adb
@@ -47,36 +55,35 @@ Topics：`dsh-plugin` `dsh` `adb` `android` `automotive` `bench`
     timeoutMs: 30000
 ```
 
-| 键 | 说明 | 默认 |
+| Key | Description | Default |
 | --- | --- | --- |
-| `adbPath` | adb 可执行文件绝对路径 | 自动探测 PATH / ANDROID_HOME / ANDROID_SDK_ROOT/platform-tools |
-| `defaultSerial` | 默认设备 serial | 无 |
-| `timeoutMs` | 命令超时 | 30000 |
+| `adbPath` | Absolute path to the adb executable | Auto-detect PATH / ANDROID_HOME / ANDROID_SDK_ROOT/platform-tools |
+| `defaultSerial` | Default target device serial | none |
+| `timeoutMs` | Per-command timeout | 30000 |
+| `baselineDir` | Directory for `adb_perf_baseline` storage | `~/.dsh/storages/dsh-adb` |
 
-## 开发
+## Development
 
 ```sh
-npm install            # 本机 NODE_ENV=production 时加 --include=dev
+npm install            # add --include=dev when NODE_ENV=production
 npm run build          # tsc → lib/
-npm test               # 解析器/错误分类单测（node --test）
-npm pack --dry-run     # 校验发布包内容（lib/ + cordis.patch.yml）
+npm test               # parser/classification unit tests (node --test)
+npm pack --dry-run     # verify publish contents (lib/ + cordis.patch.yml)
 ```
 
-注意：本机若设了 `NODE_ENV=production`，npm 会跳过 devDependencies，安装时用 `npm install --include=dev`。
-
-## 测试与验证
+## Testing & Verification
 
-- 原则：**提交即测** —— 全部已提交功能均有实测覆盖（单元 + headless 端到端 + 车机台架/真机）。
-- 验证设备：Android 13 车机台架 + Android 13 真机。
-- 版本化变更与每版验证记录见 [CHANGELOG.md](CHANGELOG.md)；测试方法与覆盖现状见 [docs/TESTING.md](docs/TESTING.md)。
+- Principle: **ship only what is tested** — every committed feature has unit and/or end-to-end coverage.
+- Verified on: Android 13 automotive bench + Android 13 phone.
+- Per-version changes and verification: [CHANGELOG.md](CHANGELOG.md); test methodology and coverage: [docs/TESTING.md](docs/TESTING.md) (Chinese).
 
-## 项目文档（供 AI 对话/协作者参考）
+## Project Docs (bilingual; for AI agents & contributors)
 
-- [docs/AGENTS.md](docs/AGENTS.md) — 进项目先读：定位、铁律、命令、环境事实、文档地图
-- [docs/REQUIREMENTS.md](docs/REQUIREMENTS.md) — 目的/范围/非目标/验收标准
-- [docs/TESTING.md](docs/TESTING.md) — 测试哲学（提交即测）、三层测试方法、E2E 步骤、回归清单
-- [docs/DEVELOPMENT-LOG.md](docs/DEVELOPMENT-LOG.md) — 进度时间线、4 个已修复 bug 教训、环境/生态经验
-- [PLAN.md](PLAN.md) — 里程碑与待办
+- [docs/AGENTS.md](docs/AGENTS.md) / [docs/AGENTS.en.md](docs/AGENTS.en.md) — read first: purpose, rules, commands, environment facts, doc map
+- [docs/REQUIREMENTS.md](docs/REQUIREMENTS.md) / [docs/REQUIREMENTS.en.md](docs/REQUIREMENTS.en.md) — purpose / scope / non-goals / acceptance criteria
+- [docs/TESTING.md](docs/TESTING.md) / [docs/TESTING.en.md](docs/TESTING.en.md) — testing philosophy, three test layers, E2E steps, regression checklist
+- [docs/DEVELOPMENT-LOG.md](docs/DEVELOPMENT-LOG.md) / [docs/DEVELOPMENT-LOG.en.md](docs/DEVELOPMENT-LOG.en.md) — timeline, fixed-bug lessons, environment & ecosystem notes
+- [PLAN.md](PLAN.md) / [PLAN.en.md](PLAN.en.md) — milestones & backlog
 
 ## License
 

package/README.zh-CN.md

@@ -0,0 +1,92 @@
+# dsh-adb
+
+> ADB 设备·台架运维工具集 for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)
+
+[English](README.md) | 简体中文
+
+让 DSH agent 直接操作 Android 设备 / 车机台架：设备发现、结构化 logcat、apk 安装、文件 pull/push、性能快照。面向实车与台架联调场景，业务内通用（不限 Unity、不限具体车机协议）。
+
+## 安装
+
+```sh
+dsh plugin --profile web add dsh-adb
+```
+
+或从 GitHub 直装：`dsh plugin --profile web add github:SamXiaBing/dsh-adb`
+
+## Web 设备面板（v1.0.0）
+
+会话视图页签「设备」（与 chat/轨迹/任务管理并列）：设备列表/状态、按包名的性能快照（内存/帧率/电量）、过滤 logcat 尾部。数据走 Package RPC；需装入 web profile 并重启 GUI 生效。
+
+## 生态收录
+
+- ✅ [npm](https://www.npmjs.com/package/dsh-adb) — `dsh-adb` 已发布（latest: 1.0.0）
+- ✅ [awesome-deepseek-harness#87](https://github.com/0xsline/awesome-deepseek-harness/pull/87) — **已合并**
+- ✅ [awesome-dsh-plugin#85](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin/pull/85) — **已合并**
+- ✅ [awesome-DSH-plugin#29](https://github.com/Alex-Yanggg/awesome-DSH-plugin/pull/29) — **已合并**
+
+Topics：`dsh-plugin` `dsh` `adb` `android` `automotive` `bench`
+
+## 工具
+
+| 工具 | 说明 |
+| --- | --- |
+| `adb_devices` | 列出设备（serial/state/product/model），先发现再操作 |
+| `adb_connect` / `adb_disconnect` | 无线台架连接（host:port，默认 5555） |
+| `adb_logcat` | 过滤读取（tag/级别/关键字/时间窗/tail）；`run_in_background` 后台连续采集，job_output 读增量、job_kill 停止 |
+| `adb_install` | 安装 apk（-r/-d/-g 选项），校验本地文件存在 |
+| `adb_file` | pull / push / ls / rm，设备隔离 |
+| `adb_perf_snapshot` | `dumpsys meminfo / gfxinfo / battery` 结构化快照（PSS/帧率百分位/卡顿率/电量） |
+| `adb_perf_baseline` | 性能回归：快照存基线（label/tags）、与当前状态数值对比（PSS/卡顿率/百分位）、list/delete（本地存储，`baselineDir`） |
+| `adb_crash_report` | 崩溃现场一键采集：crash buffer 解析 + dropbox 摘录 + 进程状态 + 内存摘要 |
+
+错误码：`ADB_NOT_FOUND`、`ADB_UNAVAILABLE`、`DEVICE_NOT_FOUND`、`NO_DEVICES`、`CONNECT_FAILED`、`INSTALL_FAILED`、`ADB_EXIT_<code>` 等，均为结构化 `AdbError`。
+
+## 配置
+
+`cordis.patch.yml` 的 `config` 块（或 profile patch）：
+
+```yaml
+- id: dsh-adb
+  name: dsh-adb
+  config:
+    adbPath: C:\Users\me\AppData\Local\Android\Sdk\platform-tools\adb.exe
+    defaultSerial: emulator-5554
+    timeoutMs: 30000
+```
+
+| 键 | 说明 | 默认 |
+| --- | --- | --- |
+| `adbPath` | adb 可执行文件绝对路径 | 自动探测 PATH / ANDROID_HOME / ANDROID_SDK_ROOT/platform-tools |
+| `defaultSerial` | 默认设备 serial | 无 |
+| `timeoutMs` | 命令超时 | 30000 |
+| `baselineDir` | `adb_perf_baseline` 基线存储目录 | `~/.dsh/storages/dsh-adb` |
+
+## 开发
+
+```sh
+npm install            # 本机 NODE_ENV=production 时加 --include=dev
+npm run build          # tsc → lib/
+npm test               # 解析器/错误分类单测（node --test）
+npm pack --dry-run     # 校验发布包内容（lib/ + cordis.patch.yml）
+```
+
+注意：本机若设了 `NODE_ENV=production`，npm 会跳过 devDependencies，安装时用 `npm install --include=dev`。
+
+## 测试与验证
+
+- 原则：**提交即测** —— 全部已提交功能均有实测覆盖（单元 + headless 端到端 + 车机台架/真机）。
+- 验证设备：Android 13 车机台架 + Android 13 真机。
+- 版本化变更与每版验证记录见 [CHANGELOG.md](CHANGELOG.md)；测试方法与覆盖现状见 [docs/TESTING.md](docs/TESTING.md)。
+
+## 项目文档（双语，供 AI 对话/协作者参考）
+
+- [docs/AGENTS.md](docs/AGENTS.md) / [docs/AGENTS.en.md](docs/AGENTS.en.md) — 进项目先读：定位、铁律、命令、环境事实、文档地图
+- [docs/REQUIREMENTS.md](docs/REQUIREMENTS.md) / [docs/REQUIREMENTS.en.md](docs/REQUIREMENTS.en.md) — 目的/范围/非目标/验收标准
+- [docs/TESTING.md](docs/TESTING.md) / [docs/TESTING.en.md](docs/TESTING.en.md) — 测试哲学（提交即测）、三层测试方法、E2E 步骤、回归清单
+- [docs/DEVELOPMENT-LOG.md](docs/DEVELOPMENT-LOG.md) / [docs/DEVELOPMENT-LOG.en.md](docs/DEVELOPMENT-LOG.en.md) — 进度时间线、4 个已修复 bug 教训、环境/生态经验
+- [PLAN.md](PLAN.md) / [PLAN.en.md](PLAN.en.md) — 里程碑与待办
+
+## License
+
+MIT

package/client.js

@@ -0,0 +1,156 @@
+/* dsh-adb Web device panel (client half) — plain JS, no build step.
+ * Registers a "设备" tab in conversation.view (beside chat/trajectory/automation)
+ * and talks to the Host half over the package RPC channel /dsh-adb.
+ * Uses only client builtins: React, ctx, styles, console.
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-adb',
+  factory: (require) => {
+    'use strict'
+    const module = { exports: {} }
+
+    const React = require('react')
+    const CHANNEL = '/dsh-adb'
+
+    function unwrap(value) {
+      if (typeof value !== 'object' || value === null || !('ok' in value)) {
+        throw new Error('dsh-adb host returned an invalid response.')
+      }
+      if (value.ok === true && 'value' in value) return value.value
+      if (value.ok === false && value.error) {
+        throw new Error(value.error.message ?? 'dsh-adb request failed.')
+      }
+      throw new Error('dsh-adb host returned an invalid response.')
+    }
+
+    function createRuntime(rpc) {
+      return {
+        listDevices: () => rpc.call(CHANNEL, 'listDevices', {}).then(unwrap),
+        perfSnapshot: (payload) => rpc.call(CHANNEL, 'perfSnapshot', payload).then(unwrap),
+        logcatTail: (payload) => rpc.call(CHANNEL, 'logcatTail', payload).then(unwrap),
+      }
+    }
+
+    const h = React.createElement
+    const ROW = { display: 'flex', alignItems: 'center', gap: 8, padding: '4px 0' }
+    const BTN = { padding: '3px 10px', cursor: 'pointer' }
+    const INPUT = { padding: '3px 6px' }
+
+    function MetricRows({ rows }) {
+      if (!rows || rows.length === 0) return h('div', null, '（无数据）')
+      return h('table', { style: { borderCollapse: 'collapse' } },
+        rows.map((row) => h('tr', { key: row[0] },
+          h('td', { style: { padding: '2px 12px 2px 0', color: 'var(--dsh-text-secondary, #888)' } }, row[0]),
+          h('td', { style: { padding: '2px 0' } }, String(row[1])),
+        )),
+      )
+    }
+
+    function DeviceView(props) {
+      const runtime = props.runtime
+      const [devices, setDevices] = React.useState([])
+      const [selected, setSelected] = React.useState(null)
+      const [pkg, setPkg] = React.useState('com.android.systemui')
+      const [snapshot, setSnapshot] = React.useState(null)
+      const [logEntries, setLogEntries] = React.useState([])
+      const [logTotal, setLogTotal] = React.useState(0)
+      const [level, setLevel] = React.useState('E')
+      const [tail, setTail] = React.useState('30')
+      const [error, setError] = React.useState(null)
+      const [busy, setBusy] = React.useState(false)
+
+      const refresh = () => {
+        setBusy(true); setError(null)
+        runtime.listDevices()
+          .then((value) => setDevices(value.devices ?? []))
+          .catch((e) => setError(String(e.message ?? e)))
+          .finally(() => setBusy(false))
+      }
+      React.useEffect(refresh, [])
+
+      const runSnapshot = () => {
+        if (!selected) return
+        setBusy(true); setError(null)
+        runtime.perfSnapshot({ serial: selected.serial, package: pkg })
+          .then(setSnapshot)
+          .catch((e) => setError(String(e.message ?? e)))
+          .finally(() => setBusy(false))
+      }
+
+      const runLogcat = () => {
+        if (!selected) return
+        setBusy(true); setError(null)
+        const n = parseInt(tail, 10)
+        runtime.logcatTail({ serial: selected.serial, level, tail: Number.isFinite(n) && n > 0 ? n : 30 })
+          .then((value) => { setLogEntries(value.entries ?? []); setLogTotal(value.total ?? 0) })
+          .catch((e) => setError(String(e.message ?? e)))
+          .finally(() => setBusy(false))
+      }
+
+      const snapshotRows = []
+      if (snapshot) {
+        const m = snapshot.meminfo; const g = snapshot.gfxinfo; const b = snapshot.battery
+        if (m) snapshotRows.push(['内存 PSS (KB)', m.totalPssKb], ['内存 RSS (KB)', m.totalRssKb], ['Java Heap (KB)', m.javaHeapKb], ['Native Heap (KB)', m.nativeHeapKb])
+        if (g) snapshotRows.push(['总帧数', g.totalFrames], ['卡顿帧 / %', `${g.jankyFrames} / ${g.jankyPercent}%`], ['P50/P90 (ms)', `${g.percentile50Ms} / ${g.percentile90Ms}`], ['P95/P99 (ms)', `${g.percentile95Ms} / ${g.percentile99Ms}`], ['Missed Vsync', g.missedVsync])
+        if (b) snapshotRows.push(['电量', `${b.levelPercent}%`], ['温度 (°C)', b.temperatureC])
+      }
+
+      return h('div', { style: { padding: 12, fontFamily: 'inherit', fontSize: 13 } },
+        h('div', { style: { ...ROW, justifyContent: 'space-between' } },
+          h('strong', null, 'ADB 设备'),
+          h('button', { style: BTN, onClick: refresh, disabled: busy }, busy ? '…' : '刷新'),
+        ),
+        error !== null && h('div', { style: { color: '#e5484d', margin: '6px 0' } }, String(error)),
+        devices.length === 0
+          ? h('div', { style: { color: 'var(--dsh-text-secondary, #888)', margin: '8px 0' } }, '未连接设备')
+          : h('div', null, devices.map((d) =>
+              h('button', {
+                key: d.serial,
+                onClick: () => setSelected(d),
+                style: { ...BTN, display: 'block', width: '100%', textAlign: 'left', margin: '2px 0',
+                  background: selected && selected.serial === d.serial ? 'var(--dsh-accent-soft, rgba(66,133,244,.15))' : 'transparent' },
+              }, `${d.serial} · ${d.state}${d.model ? ' · ' + d.model : ''}`),
+            )),
+
+        selected !== null && h('div', { style: { marginTop: 14, borderTop: '1px solid var(--dsh-border, #333)', paddingTop: 10 } },
+          h('div', { style: ROW },
+            h('label', null, '包名'),
+            h('input', { style: INPUT, value: pkg, onChange: (e) => setPkg(e.target.value), onKeyDown: (e) => { if (e.key === 'Enter') runSnapshot() } }),
+            h('button', { style: BTN, onClick: runSnapshot, disabled: busy }, '性能快照'),
+          ),
+          snapshot && h('div', { style: { marginTop: 8 } }, h(MetricRows, { rows: snapshotRows })),
+
+          h('div', { style: { ...ROW, marginTop: 12 } },
+            h('label', null, '级别'),
+            h('select', { style: INPUT, value: level, onChange: (e) => setLevel(e.target.value) },
+              ['V', 'D', 'I', 'W', 'E', 'F'].map((lv) => h('option', { key: lv, value: lv }, lv))),
+            h('label', null, '条数'),
+            h('input', { style: { ...INPUT, width: 56 }, value: tail, onChange: (e) => setTail(e.target.value) }),
+            h('button', { style: BTN, onClick: runLogcat, disabled: busy }, '获取日志'),
+          ),
+          h('div', { style: { color: 'var(--dsh-text-secondary, #888)', margin: '4px 0' } }, `logcat 共 ${logTotal} 条（显示 ${logEntries.length}）`),
+          h('div', { style: { maxHeight: 260, overflowY: 'auto', fontFamily: 'monospace', fontSize: 12, whiteSpace: 'pre-wrap' } },
+            logEntries.length === 0
+              ? h('div', null, '（暂无）')
+              : logEntries.map((e) => h('div', { key: `${e.time}-${e.pid}-${e.tid}-${e.message}` },
+                  `${e.time} ${e.pid} ${e.tid} ${e.level} ${e.tag}: ${e.message}`)),
+          ),
+        ),
+      )
+    }
+
+    function apply(ctx) {
+      const slots = ctx.get('slots')
+      const connection = ctx.get('connection')
+      if (slots === undefined || connection === undefined || connection.rpc === undefined) return
+      const runtime = createRuntime(connection.rpc)
+      slots.inject('conversation.view', () => slots.register(
+        { name: 'conversation.view', id: 'devices', order: 30, label: '设备' },
+        (props) => h(DeviceView, { ...props, runtime }),
+      ))
+    }
+
+    module.exports = { apply }
+    return module.exports
+  },
+})

package/lib/adb.js

@@ -117,7 +117,7 @@ export async function runAdb(ctx, cfg, argv, options = {}) {
 export function classifyFailure(result) {
     const stderr = result.stderr;
     const stdout = result.stdout;
-    if (/(?:error:\s*)?device ['"]?[^'\r\n]*['"]? not found/i.test(stderr)) {
+    if (/(?:error:\s*)?device ['"]?[^'\r\n]*['"]? not found|waiting for device/i.test(stderr)) {
         return new AdbError('DEVICE_NOT_FOUND', excerpt(stderr));
     }
     if (/no devices\/emulators found/i.test(stderr)) {

package/lib/baseline.d.ts

@@ -0,0 +1,43 @@
+import type { PerfSnapshot } from './tools/perf.js';
+/**
+ * Perf baseline store + numeric diff computation. Storage is a single JSON
+ * file under a configurable directory; diff logic is pure and unit-tested.
+ */
+export interface BaselineMeta {
+    id: string;
+    label: string;
+    createdAt: string;
+    device: string;
+    package: string;
+    tags?: string[];
+}
+export interface BaselineEntry extends BaselineMeta {
+    snapshot: PerfSnapshot;
+}
+export interface BaselineStoreData {
+    version: 1;
+    baselines: BaselineEntry[];
+}
+export interface BaselineStore {
+    list(): BaselineEntry[];
+    get(id: string): BaselineEntry | undefined;
+    latest(device: string, pkg: string): BaselineEntry | undefined;
+    save(entry: Omit<BaselineEntry, 'id' | 'createdAt'>): BaselineEntry;
+    delete(id: string): boolean;
+}
+export declare const DEFAULT_BASELINE_DIR: string;
+export declare function loadBaselines(dir: string): BaselineStoreData;
+export declare function saveBaselines(dir: string, data: BaselineStoreData): void;
+export declare function createStore(dir: string): BaselineStore;
+/** Human-readable names for diff fields. */
+export declare const FIELD_LABELS: Record<string, string>;
+export interface FieldDiff {
+    field: string;
+    label: string;
+    from?: number;
+    to?: number;
+    delta?: number;
+    deltaPercent?: number;
+}
+/** Numeric diff between two snapshots; only fields present in both are reported. */
+export declare function diffSnapshots(from: PerfSnapshot, to: PerfSnapshot): FieldDiff[];

package/lib/baseline.js

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { homedir } from 'node:os';
+export const DEFAULT_BASELINE_DIR = joinDefault();
+function joinDefault() {
+    return `${homedir().replace(/\\/g, '/')}/.dsh/storages/dsh-adb`;
+}
+function filePath(dir) {
+    return `${dir.replace(/\\/g, '/')}/baselines.json`;
+}
+function emptyData() {
+    return { version: 1, baselines: [] };
+}
+export function loadBaselines(dir) {
+    const file = filePath(dir);
+    if (!existsSync(file))
+        return emptyData();
+    let raw;
+    try {
+        raw = readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`baseline store unreadable at ${file}: ${describe(error)}`);
+    }
+    try {
+        const data = JSON.parse(raw);
+        if (data?.version !== 1 || !Array.isArray(data.baselines)) {
+            throw new Error('unexpected shape');
+        }
+        return data;
+    }
+    catch {
+        throw new Error(`baseline store corrupted at ${file}: not valid version-1 JSON`);
+    }
+}
+export function saveBaselines(dir, data) {
+    const file = filePath(dir);
+    try {
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, JSON.stringify(data, null, 2), 'utf8');
+    }
+    catch (error) {
+        throw new Error(`baseline store unwritable at ${file}: ${describe(error)}`);
+    }
+}
+export function createStore(dir) {
+    return {
+        list() {
+            return loadBaselines(dir).baselines;
+        },
+        get(id) {
+            return loadBaselines(dir).baselines.find((entry) => entry.id === id);
+        },
+        latest(device, pkg) {
+            const data = loadBaselines(dir);
+            const matches = data.baselines.filter((entry) => entry.device === device && entry.package === pkg);
+            if (matches.length === 0)
+                return undefined;
+            return matches.reduce((a, b) => (a.createdAt > b.createdAt ? a : b));
+        },
+        save(entry) {
+            const data = loadBaselines(dir);
+            const stored = {
+                ...entry,
+                id: `bl-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                createdAt: new Date().toISOString(),
+            };
+            data.baselines.push(stored);
+            saveBaselines(dir, data);
+            return stored;
+        },
+        delete(id) {
+            const data = loadBaselines(dir);
+            const before = data.baselines.length;
+            data.baselines = data.baselines.filter((entry) => entry.id !== id);
+            if (data.baselines.length === before)
+                return false;
+            saveBaselines(dir, data);
+            return true;
+        },
+    };
+}
+/** Human-readable names for diff fields. */
+export const FIELD_LABELS = {
+    'meminfo.totalPssKb': 'Total PSS (KB)',
+    'meminfo.totalRssKb': 'Total RSS (KB)',
+    'meminfo.javaHeapKb': 'Java Heap (KB)',
+    'meminfo.nativeHeapKb': 'Native Heap (KB)',
+    'meminfo.graphicsKb': 'Graphics (KB)',
+    'gfxinfo.totalFrames': 'Total frames',
+    'gfxinfo.jankyFrames': 'Janky frames',
+    'gfxinfo.jankyPercent': 'Janky %',
+    'gfxinfo.percentile50Ms': '50th percentile (ms)',
+    'gfxinfo.percentile90Ms': '90th percentile (ms)',
+    'gfxinfo.percentile95Ms': '95th percentile (ms)',
+    'gfxinfo.percentile99Ms': '99th percentile (ms)',
+    'gfxinfo.missedVsync': 'Missed vsync',
+    'battery.levelPercent': 'Battery level (%)',
+    'battery.temperatureC': 'Temperature (°C)',
+};
+const DIFF_FIELDS = [
+    ['meminfo', 'totalPssKb'],
+    ['meminfo', 'totalRssKb'],
+    ['meminfo', 'javaHeapKb'],
+    ['meminfo', 'nativeHeapKb'],
+    ['meminfo', 'graphicsKb'],
+    ['gfxinfo', 'totalFrames'],
+    ['gfxinfo', 'jankyFrames'],
+    ['gfxinfo', 'jankyPercent'],
+    ['gfxinfo', 'percentile50Ms'],
+    ['gfxinfo', 'percentile90Ms'],
+    ['gfxinfo', 'percentile95Ms'],
+    ['gfxinfo', 'percentile99Ms'],
+    ['gfxinfo', 'missedVsync'],
+    ['battery', 'levelPercent'],
+    ['battery', 'temperatureC'],
+];
+/** Numeric diff between two snapshots; only fields present in both are reported. */
+export function diffSnapshots(from, to) {
+    const diffs = [];
+    for (const [group, field] of DIFF_FIELDS) {
+        const fromGroup = from;
+        const toGroup = to;
+        const fromValue = fromGroup[group]?.[field];
+        const toValue = toGroup[group]?.[field];
+        if (fromValue === undefined || toValue === undefined)
+            continue;
+        const key = `${group}.${field}`;
+        const delta = toValue - fromValue;
+        diffs.push({
+            field: key,
+            label: FIELD_LABELS[key] ?? key,
+            from: fromValue,
+            to: toValue,
+            delta,
+            deltaPercent: fromValue === 0 ? undefined : (delta / fromValue) * 100,
+        });
+    }
+    return diffs;
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/index.d.ts

@@ -11,6 +11,8 @@ export interface Config {
     defaultSerial?: string;
     /** Per-command timeout in milliseconds. */
     timeoutMs?: number;
+    /** Directory for adb_perf_baseline storage. */
+    baselineDir?: string;
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -1,9 +1,13 @@
 import Schema from 'schemastery';
+import { DEFAULT_BASELINE_DIR } from './baseline.js';
 import { registerDeviceTools } from './tools/devices.js';
+import { registerCrashReportTool } from './tools/crash-report.js';
 import { registerFileTool } from './tools/file.js';
 import { registerInstallTool } from './tools/install.js';
 import { registerLogcatTool } from './tools/logcat.js';
 import { registerPerfTool } from './tools/perf.js';
+import { registerPerfBaselineTool } from './tools/perf-baseline.js';
+import { registerRpc } from './rpc.js';
 export const name = 'dsh-adb';
 /** The tool registry is a hard dependency: every tool registers through it. */
 export const inject = ['tools'];
@@ -11,6 +15,7 @@ export const Config = Schema.object({
     adbPath: Schema.string().description('adb 可执行文件绝对路径；缺省自动探测 PATH / ANDROID_HOME / ANDROID_SDK_ROOT / platform-tools'),
     defaultSerial: Schema.string().description('默认目标设备 serial'),
     timeoutMs: Schema.number().default(30000).description('adb 命令超时（毫秒）'),
+    baselineDir: Schema.string().description('adb_perf_baseline 基线存储目录；缺省 ~/.dsh/storages/dsh-adb'),
 });
 export function apply(ctx, config) {
     const cfg = config;
@@ -19,5 +24,11 @@ export function apply(ctx, config) {
     registerFileTool(ctx, cfg);
     registerLogcatTool(ctx, cfg);
     registerPerfTool(ctx, cfg);
-    ctx.logger.info('[dsh-adb] loaded: adb_devices / adb_connect / adb_disconnect / adb_logcat / adb_install / adb_file / adb_perf_snapshot');
+    registerPerfBaselineTool(ctx, cfg, config.baselineDir ?? DEFAULT_BASELINE_DIR);
+    registerCrashReportTool(ctx, cfg);
+    // The RPC channel needs the client connection, which mounts after this
+    // plugin starts in web compositions; register lazily so headless profiles
+    // (no connection) stay unaffected.
+    ctx.inject(['connection'], (readyCtx) => registerRpc(readyCtx, cfg));
+    ctx.logger.info('[dsh-adb] loaded: 9 tools + web device panel rpc');
 }

package/lib/rpc.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { AdbConfig } from './adb.js';
+export type RpcEndpointResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: {
+        message: string;
+    };
+};
+/**
+ * Package-private Client↔Host RPC endpoint dispatch for the Web device panel.
+ * Extracted from the connection handler so the endpoints are unit-testable
+ * against a fake adb backend.
+ */
+export declare function handleRpcEndpoint(ctx: Context, cfg: AdbConfig, endpoint: string, raw: unknown, signal: AbortSignal): Promise<RpcEndpointResult>;
+/**
+ * Register the Package-private Client↔Host RPC for the Web device panel
+ * (conversation.view tab "设备"). Called lazily once the client connection
+ * mounts; headless compositions (no connection) stay unaffected.
+ */
+export declare function registerRpc(ctx: Context, cfg: AdbConfig): void;

package/lib/rpc.js

@@ -0,0 +1,66 @@
+import { classifyFailure, runAdb } from './adb.js';
+import { parseDevices } from './parsers/devices.js';
+import { matchesLevel, parseLogcat } from './parsers/logcat.js';
+import { capturePerfSnapshot } from './tools/perf.js';
+/**
+ * Package-private Client↔Host RPC endpoint dispatch for the Web device panel.
+ * Extracted from the connection handler so the endpoints are unit-testable
+ * against a fake adb backend.
+ */
+export async function handleRpcEndpoint(ctx, cfg, endpoint, raw, signal) {
+    try {
+        const payload = (raw ?? {});
+        switch (endpoint) {
+            case 'listDevices': {
+                const result = await runAdb(ctx, cfg, ['devices', '-l'], { signal });
+                if (result.exitCode !== 0)
+                    throw classifyFailure(result);
+                return { ok: true, value: { server: 'ok', devices: parseDevices(result.stdout) } };
+            }
+            case 'perfSnapshot': {
+                const pkg = typeof payload.package === 'string' ? payload.package : undefined;
+                if (pkg === undefined)
+                    throw new Error('perfSnapshot requires a string "package"');
+                const serial = typeof payload.serial === 'string' ? payload.serial : undefined;
+                const snapshot = await capturePerfSnapshot(ctx, cfg, signal, { package: pkg, serial });
+                return { ok: true, value: snapshot };
+            }
+            case 'logcatTail': {
+                const serial = typeof payload.serial === 'string' ? payload.serial : undefined;
+                const level = typeof payload.level === 'string' ? payload.level : undefined;
+                const tail = typeof payload.tail === 'number' && payload.tail > 0 ? Math.floor(payload.tail) : 30;
+                const output = await runAdb(ctx, cfg, ['logcat', '-v', 'threadtime', '-d'], {
+                    signal,
+                    serial,
+                    maxBytes: 8 * 1024 * 1024,
+                });
+                if (output.exitCode !== 0)
+                    throw classifyFailure(output);
+                let entries = parseLogcat(output.stdout);
+                if (level !== undefined)
+                    entries = entries.filter((entry) => matchesLevel(entry, level));
+                const capped = entries.slice(-tail);
+                return { ok: true, value: { total: entries.length, truncated: entries.length > tail, entries: capped } };
+            }
+            default:
+                return { ok: false, error: { message: `unknown endpoint: ${endpoint}` } };
+        }
+    }
+    catch (error) {
+        return { ok: false, error: { message: error instanceof Error ? error.message : String(error) } };
+    }
+}
+/**
+ * Register the Package-private Client↔Host RPC for the Web device panel
+ * (conversation.view tab "设备"). Called lazily once the client connection
+ * mounts; headless compositions (no connection) stay unaffected.
+ */
+export function registerRpc(ctx, cfg) {
+    const connection = ctx.get('connection');
+    const rpc = connection?.rpc;
+    if (rpc === undefined)
+        return;
+    ctx.effect(() => rpc.handle('/dsh-adb', (endpoint, raw, signal) => handleRpcEndpoint(ctx, cfg, endpoint, raw, signal), 
+    // Browser-only channel: accept requests from the loopback web GUI.
+    { authority: 'loopback' }));
+}

package/lib/tools/crash-report.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type AdbConfig } from '../adb.js';
+/** adb_crash_report: collect a crash scene from an Android device. */
+export declare function registerCrashReportTool(ctx: Context, cfg: AdbConfig): void;

package/lib/tools/crash-report.js

@@ -0,0 +1,109 @@
+import { AdbError, classifyFailure, jsonOutput, runAdb } from '../adb.js';
+import { parseLogcat } from '../parsers/logcat.js';
+import { capturePerfSnapshot } from './perf.js';
+const DEFAULT_INCLUDE = ['crash-buffer', 'dropbox', 'processes'];
+function excerpt(text, maxLines) {
+    const lines = text.split(/\r?\n/).filter((line) => line !== '');
+    return { lines: lines.length, excerpt: lines.slice(-maxLines).join('\n') };
+}
+/** adb_crash_report: collect a crash scene from an Android device. */
+export function registerCrashReportTool(ctx, cfg) {
+    ctx.tools.register({
+        name: 'adb_crash_report',
+        description: 'Collect a crash scene from an Android device into one structured report: the logcat crash buffer (parsed entries), dropbox crash entries excerpt, process state excerpt, and (when a package is given) memory summary. Use it to gather crash context in one call instead of hunting through buffers.',
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                package: { type: 'string', description: 'App package id; enables the meminfo section and helps narrow the crash buffer.' },
+                serial: { type: 'string', description: 'Target device serial; defaults to the plugin defaultSerial.' },
+                since: { type: 'string', description: 'Only crash-buffer entries at/after this time, e.g. "08-15 10:00:00.000".' },
+                include: {
+                    type: 'array',
+                    items: { type: 'string', enum: ['crash-buffer', 'dropbox', 'processes', 'meminfo'] },
+                    description: 'Which sections to collect; defaults to crash-buffer, dropbox, processes (plus meminfo when package is given).',
+                },
+                tail: { type: 'integer', description: 'Cap for parsed crash-buffer entries and excerpt lines; defaults to 100.' },
+            },
+        },
+        output: jsonOutput(),
+        async execute(args, exec) {
+            const { since, tail } = args;
+            const tailCount = tail ?? 100;
+            const include = args.include ?? [
+                ...DEFAULT_INCLUDE,
+                ...(args.package !== undefined ? (['meminfo']) : []),
+            ];
+            const result = { collectedAt: new Date().toISOString() };
+            if (args.package !== undefined)
+                result.package = args.package;
+            if (include.includes('crash-buffer')) {
+                const output = await runAdb(ctx, cfg, ['logcat', '-b', 'crash', '-v', 'threadtime', '-d'], {
+                    signal: exec.signal,
+                    serial: args.serial,
+                    maxBytes: 8 * 1024 * 1024,
+                });
+                if (output.exitCode !== 0)
+                    throw classifyFailure(output);
+                let entries = parseLogcat(output.stdout);
+                if (since !== undefined)
+                    entries = entries.filter((entry) => entry.time >= since);
+                const truncated = entries.length > tailCount;
+                result.crashBuffer = {
+                    total: entries.length,
+                    truncated,
+                    entries: (truncated ? entries.slice(-tailCount) : entries).map((entry) => ({
+                        time: entry.time,
+                        pid: entry.pid,
+                        tid: entry.tid,
+                        level: entry.level,
+                        tag: entry.tag,
+                        message: entry.message,
+                    })),
+                };
+            }
+            if (include.includes('dropbox')) {
+                const output = await runAdb(ctx, cfg, ['shell', 'dumpsys', 'dropbox', '--print'], {
+                    signal: exec.signal,
+                    serial: args.serial,
+                    maxBytes: 4 * 1024 * 1024,
+                });
+                if (output.exitCode !== 0)
+                    throw classifyFailure(output);
+                const capped = excerpt(output.stdout, tailCount);
+                result.dropbox = {
+                    lines: capped.lines,
+                    truncated: capped.lines > tailCount,
+                    excerpt: capped.excerpt,
+                };
+            }
+            if (include.includes('processes')) {
+                const output = await runAdb(ctx, cfg, ['shell', 'dumpsys', 'activity', 'processes'], {
+                    signal: exec.signal,
+                    serial: args.serial,
+                    maxBytes: 2 * 1024 * 1024,
+                });
+                if (output.exitCode !== 0)
+                    throw classifyFailure(output);
+                const capped = excerpt(output.stdout, tailCount);
+                result.processes = {
+                    lines: capped.lines,
+                    truncated: capped.lines > tailCount,
+                    excerpt: capped.excerpt,
+                };
+            }
+            if (include.includes('meminfo')) {
+                if (args.package === undefined) {
+                    throw new AdbError('ARGS_INVALID', 'meminfo section requires a package');
+                }
+                const snapshot = await capturePerfSnapshot(ctx, cfg, exec.signal, {
+                    package: args.package,
+                    serial: args.serial,
+                    metrics: ['meminfo'],
+                });
+                result.meminfo = snapshot.meminfo;
+            }
+            return result;
+        },
+    });
+}

package/lib/tools/perf-baseline.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type AdbConfig } from '../adb.js';
+/** adb_perf_baseline: save/compare/list/delete perf snapshots as baselines. */
+export declare function registerPerfBaselineTool(ctx: Context, cfg: AdbConfig, baselineDir: string): void;

package/lib/tools/perf-baseline.js

@@ -0,0 +1,100 @@
+import { AdbError, jsonOutput } from '../adb.js';
+import { createStore, diffSnapshots } from '../baseline.js';
+import { capturePerfSnapshot } from './perf.js';
+function publicMeta(entry) {
+    return {
+        id: entry.id,
+        label: entry.label,
+        createdAt: entry.createdAt,
+        device: entry.device,
+        package: entry.package,
+        tags: entry.tags ?? [],
+    };
+}
+/** adb_perf_baseline: save/compare/list/delete perf snapshots as baselines. */
+export function registerPerfBaselineTool(ctx, cfg, baselineDir) {
+    ctx.tools.register({
+        name: 'adb_perf_baseline',
+        description: 'Manage performance baselines for regression checks: save a snapshot as a baseline (label + optional tags), compare the current device state against a baseline and get a numeric diff report (PSS, janky %, frame percentiles), list stored baselines, or delete one. Baselines are stored locally on the host under the configured baselineDir.',
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['command'],
+            properties: {
+                command: {
+                    type: 'string',
+                    enum: ['save', 'compare', 'list', 'delete'],
+                    description: 'save: capture + store a baseline; compare: diff current state against a baseline (id, or latest for device+package); list: stored baselines; delete: remove one by id.',
+                },
+                package: { type: 'string', description: 'App package id; required for save and compare.' },
+                serial: { type: 'string', description: 'Target device serial; defaults to the plugin defaultSerial.' },
+                metrics: {
+                    type: 'array',
+                    items: { type: 'string', enum: ['meminfo', 'gfxinfo', 'battery'] },
+                    description: 'Which metrics to capture; defaults to all three.',
+                },
+                label: { type: 'string', description: 'Baseline label for save, e.g. the build/version under test.' },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional tags for save, e.g. ["release", "before-optimization"].',
+                },
+                id: { type: 'string', description: 'Baseline id; required for delete, optional for compare (defaults to the latest for device+package).' },
+            },
+        },
+        output: jsonOutput(),
+        async execute(args, exec) {
+            const store = createStore(baselineDir);
+            const device = args.serial ?? cfg.defaultSerial ?? 'default';
+            if (args.command === 'list') {
+                const entries = store.list().map(publicMeta);
+                return { command: 'list', count: entries.length, baselines: entries };
+            }
+            if (args.command === 'delete') {
+                if (args.id === undefined)
+                    throw new AdbError('ARGS_INVALID', 'delete requires a baseline id');
+                const deleted = store.delete(args.id);
+                if (!deleted)
+                    throw new AdbError('BASELINE_NOT_FOUND', `no baseline with id ${args.id}`);
+                return { command: 'delete', deleted: true, id: args.id };
+            }
+            if (args.package === undefined) {
+                throw new AdbError('ARGS_INVALID', `${args.command} requires a package`);
+            }
+            if (args.command === 'save') {
+                const snapshot = await capturePerfSnapshot(ctx, cfg, exec.signal, {
+                    package: args.package,
+                    serial: args.serial,
+                    metrics: args.metrics,
+                });
+                const stored = store.save({
+                    label: args.label ?? `baseline-${new Date().toISOString().slice(0, 10)}`,
+                    device,
+                    package: args.package,
+                    ...(args.tags !== undefined && args.tags.length > 0 ? { tags: args.tags } : {}),
+                    snapshot,
+                });
+                return { command: 'save', saved: publicMeta(stored) };
+            }
+            // compare
+            const baseline = args.id !== undefined
+                ? store.get(args.id)
+                : store.latest(device, args.package);
+            if (baseline === undefined) {
+                throw new AdbError('BASELINE_NOT_FOUND', `no baseline for device ${device} package ${args.package}${args.id !== undefined ? ` (id ${args.id})` : ''}; save one with command=save first`);
+            }
+            const current = await capturePerfSnapshot(ctx, cfg, exec.signal, {
+                package: args.package,
+                serial: args.serial,
+                metrics: args.metrics,
+            });
+            const diffs = diffSnapshots(baseline.snapshot, current);
+            return {
+                command: 'compare',
+                baseline: publicMeta(baseline),
+                current: { package: current.package, metrics: current.metrics },
+                diffs,
+            };
+        },
+    });
+}

package/lib/tools/perf.d.ts

@@ -1,4 +1,19 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type AdbConfig } from '../adb.js';
+import { parseBattery, parseGfxinfo, parseMeminfo } from '../parsers/perf.js';
+export type PerfMetric = 'meminfo' | 'gfxinfo' | 'battery';
+export interface PerfSnapshot {
+    package: string;
+    metrics: PerfMetric[];
+    meminfo?: ReturnType<typeof parseMeminfo>;
+    gfxinfo?: ReturnType<typeof parseGfxinfo>;
+    battery?: ReturnType<typeof parseBattery>;
+}
+/** Shared capture: dumpsys meminfo / gfxinfo / battery for one app. */
+export declare function capturePerfSnapshot(ctx: Context, cfg: AdbConfig, signal: AbortSignal, args: {
+    package: string;
+    serial?: string;
+    metrics?: PerfMetric[];
+}): Promise<PerfSnapshot>;
 /** adb_perf_snapshot: dumpsys meminfo / gfxinfo / battery for one app. */
 export declare function registerPerfTool(ctx: Context, cfg: AdbConfig): void;

package/lib/tools/perf.js

@@ -1,5 +1,30 @@
 import { classifyFailure, jsonOutput, runAdb } from '../adb.js';
 import { parseBattery, parseGfxinfo, parseMeminfo } from '../parsers/perf.js';
+/** Shared capture: dumpsys meminfo / gfxinfo / battery for one app. */
+export async function capturePerfSnapshot(ctx, cfg, signal, args) {
+    const metrics = args.metrics ?? ['meminfo', 'gfxinfo', 'battery'];
+    const result = { package: args.package, metrics: [...metrics] };
+    for (const metric of metrics) {
+        // dumpsys battery is device-global and takes no package argument.
+        const argv = metric === 'battery'
+            ? ['shell', 'dumpsys', 'battery']
+            : ['shell', 'dumpsys', metric, args.package];
+        const output = await runAdb(ctx, cfg, argv, {
+            signal,
+            serial: args.serial,
+            maxBytes: 4 * 1024 * 1024,
+        });
+        if (output.exitCode !== 0)
+            throw classifyFailure(output);
+        if (metric === 'meminfo')
+            result.meminfo = parseMeminfo(output.stdout);
+        else if (metric === 'gfxinfo')
+            result.gfxinfo = parseGfxinfo(output.stdout);
+        else
+            result.battery = parseBattery(output.stdout);
+    }
+    return result;
+}
 /** adb_perf_snapshot: dumpsys meminfo / gfxinfo / battery for one app. */
 export function registerPerfTool(ctx, cfg) {
     ctx.tools.register({
@@ -21,28 +46,7 @@ export function registerPerfTool(ctx, cfg) {
         },
         output: jsonOutput(),
         async execute(args, exec) {
-            const metrics = args.metrics ?? ['meminfo', 'gfxinfo', 'battery'];
-            const result = { package: args.package, metrics: [...metrics] };
-            for (const metric of metrics) {
-                // dumpsys battery is device-global and takes no package argument.
-                const argv = metric === 'battery'
-                    ? ['shell', 'dumpsys', 'battery']
-                    : ['shell', 'dumpsys', metric, args.package];
-                const output = await runAdb(ctx, cfg, argv, {
-                    signal: exec.signal,
-                    serial: args.serial,
-                    maxBytes: 4 * 1024 * 1024,
-                });
-                if (output.exitCode !== 0)
-                    throw classifyFailure(output);
-                if (metric === 'meminfo')
-                    result.meminfo = parseMeminfo(output.stdout);
-                else if (metric === 'gfxinfo')
-                    result.gfxinfo = parseGfxinfo(output.stdout);
-                else
-                    result.battery = parseBattery(output.stdout);
-            }
-            return result;
+            return capturePerfSnapshot(ctx, cfg, exec.signal, args);
         },
     });
 }

package/package.json

@@ -1,11 +1,17 @@
 {
   "name": "dsh-adb",
-  "version": "0.1.5",
-  "description": "ADB device & bench operations for DeepSeek Harness: device discovery, structured logcat, apk install, file pull/push, performance snapshots",
+  "version": "1.0.0",
+  "description": "ADB device & bench operations for DeepSeek Harness: device discovery, structured logcat, apk install, file pull/push, performance snapshots, perf baselines, crash reports, web device panel",
   "type": "module",
   "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./client.js",
+    "./package.json": "./package.json"
+  },
   "files": [
     "lib",
+    "client.js",
     "cordis.patch.yml"
   ],
   "keywords": [
@@ -21,6 +27,9 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web"
     }
   },
   "scripts": {