dsh-adb 1.5.0 → 1.6.1

package/README.md

@@ -20,7 +20,7 @@ A "设备" tab in the conversation view ring (next to chat / trajectory / automa
 
 ## Ecosystem
 
-- ✅ [npm](https://www.npmjs.com/package/dsh-adb) — `dsh-adb` published (latest: 1.1.0)
+- ✅ [npm](https://www.npmjs.com/package/dsh-adb) — `dsh-adb` published (latest: 1.6.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**
@@ -43,9 +43,57 @@ Topics: `dsh-plugin` `dsh` `adb` `android` `automotive` `bench`
 | `adb_wait_for` | Wait until a device condition holds — device-online / boot-complete / process appeared / logcat keyword — polling up to a budget, instead of sleeping a fixed number of seconds; returns `matched:false` on timeout |
 | `adb_operation_ledger` | Append-only device operation ledger (record/list/rollback): record installs/pushes/etc., list history, or roll an app back to its last known-good APK (`adb install -r`); persisted as `operations.json` — the trust base for agent-driven device modification |
 | `adb_screenshot` | Capture the device screen into a local PNG (screencap → pull), returning the saved path, byte size, and pixel dimensions — durable evidence for crash scenes / UI states / test frames |
+| `adb_watch_crash` | Watch the crash buffer for NEW real crashes (foreground poll or background job; boot markers ignored; `matched:false` on timeout) — the first link of the monitor→capture→attribute chain |
 
 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.
 
+## Usage: adb_watch_crash (Crash Watchdog)
+
+Watch the device's crash buffer for **new** real crashes. On start, it reads the current buffer and remembers every existing crash signature (seed), so only crashes that appear *after* the watch begins are reported. Boot markers (`mtk-brm-*`) are not crashes and are ignored.
+
+**Foreground mode** (default) — blocks until a new crash appears or the budget expires:
+
+```json
+// Agent calls:
+{ "name": "adb_watch_crash", "args": { "timeoutMs": 60000 } }
+
+// New crash detected:
+{ "matched": true, "waitedMs": 3200, "crashes": [{ "time": "08-26 06:22:56.714", "pid": "2947", "tag": "AndroidRuntime", "message": "FATAL EXCEPTION: WM.task-1", "stack": ["AndroidRuntime: Process: com.miui.weather2, PID: 2947", "..."] }] }
+
+// No new crash within budget (not an error):
+{ "matched": false, "waitedMs": 60000, "crashes": [], "reason": "no new crash within 60000ms" }
+```
+
+**Background mode** (`run_in_background`) — returns a job id immediately, keeps polling:
+
+```json
+// Start watching in the background:
+{ "name": "adb_watch_crash", "args": { "run_in_background": true, "timeoutMs": 300000 } }
+// → { "kind": "background", "jobId": "adb-watch-crash-1" }
+
+// Read latest detections with job_output:
+// [adb_watch_crash] detected 1 new crash(es) after 5400ms
+// - 08-26 06:22:56.714 pid=2947 AndroidRuntime: FATAL EXCEPTION: WM.task-1
+//     AndroidRuntime: Process: com.miui.weather2, PID: 2947
+//     ...
+```
+
+**Chain with crash capture** — when a crash is detected, pair with `adb_crash_report` and `adb_screenshot` to capture the scene:
+
+```
+1. adb_watch_crash (watch for new crash)
+2. → crash detected → adb_crash_report (full crash scene: buffer + dropbox + process + memory)
+3.                    → adb_screenshot (screen state at crash time)
+```
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `serial` | string | defaultSerial | Target device serial |
+| `timeoutMs` | integer | 60000 | Watch budget (max 600000 = 10 min) |
+| `intervalMs` | integer | 1000 | Poll interval (min 250) |
+| `withStacks` | boolean | true | Include same-pid stack lines per crash |
+| `run_in_background` | boolean | false | Run as a background job; read via `job_output` |
+
 ## Configuration
 
 Set the `config` block in `cordis.patch.yml` (or a profile patch):
@@ -80,7 +128,7 @@ npm pack --dry-run     # verify publish contents (lib/ + cordis.patch.yml)
 ## Testing & Verification
 
 - 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.
+- Verified on: Android 13 automotive bench + Android 14 phone (Redmi K50 Pro) + emulator.
 - Per-version changes and verification: [CHANGELOG.md](CHANGELOG.md); test methodology and coverage: [docs/TESTING.md](docs/TESTING.md) (Chinese).
 
 ## Project Docs (bilingual; for AI agents & contributors)

package/README.zh-CN.md

@@ -20,7 +20,7 @@ dsh plugin --profile web add dsh-adb
 
 ## 生态收录
 
-- ✅ [npm](https://www.npmjs.com/package/dsh-adb) — `dsh-adb` 已发布（latest: 1.1.0）
+- ✅ [npm](https://www.npmjs.com/package/dsh-adb) — `dsh-adb` 已发布（latest: 1.6.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) — **已合并**
@@ -43,9 +43,57 @@ Topics：`dsh-plugin` `dsh` `adb` `android` `automotive` `bench`
 | `adb_wait_for` | 等待原语：等设备上线 / 启动完成 / 进程出现 / logcat 出现关键字，轮询到预算上限，替代盲目 sleep；超时返回 `matched:false` |
 | `adb_operation_ledger` | 操作回滚台账（record/list/rollback）：追加记录安装/推送等操作，查询历史，或回滚到最近一次成功安装的 APK（`adb install -r`）；落盘 `operations.json` —— agent 自主改设备的信任基础 |
 | `adb_screenshot` | 截图落盘 PNG（screencap → pull），返回路径/字节数/像素尺寸 —— 崩溃现场、UI 状态、测试前后对比的持久证据 |
+| `adb_watch_crash` | 崩溃看门狗：监控 crash buffer 的**新**真实崩溃（前台轮询或后台 job；启动标记不算；超时返回 `matched:false`）—— 「盯崩溃→采集→归因」链第一环 |
 
 错误码：`ADB_NOT_FOUND`、`ADB_UNAVAILABLE`、`DEVICE_NOT_FOUND`、`NO_DEVICES`、`CONNECT_FAILED`、`INSTALL_FAILED`、`ADB_EXIT_<code>` 等，均为结构化 `AdbError`。
 
+## 用法：adb_watch_crash（崩溃看门狗）
+
+监控设备 crash buffer 里的**新**真实崩溃。启动时先读一遍当前 buffer，记住所有已有崩溃签名（seed），所以只报 watch 开始**之后**新出现的崩溃。启动标记（`mtk-brm-*`）不算崩溃，自动忽略。
+
+**前台模式**（默认）——阻塞到新崩溃出现或预算耗尽：
+
+```json
+// Agent 调用：
+{ "name": "adb_watch_crash", "args": { "timeoutMs": 60000 } }
+
+// 检测到新崩溃：
+{ "matched": true, "waitedMs": 3200, "crashes": [{ "time": "08-26 06:22:56.714", "pid": "2947", "tag": "AndroidRuntime", "message": "FATAL EXCEPTION: WM.task-1", "stack": ["AndroidRuntime: Process: com.miui.weather2, PID: 2947", "..."] }] }
+
+// 预算内无新崩溃（不是错误）：
+{ "matched": false, "waitedMs": 60000, "crashes": [], "reason": "no new crash within 60000ms" }
+```
+
+**后台模式**（`run_in_background`）——立即返回 job id，持续轮询：
+
+```json
+// 启动后台监控：
+{ "name": "adb_watch_crash", "args": { "run_in_background": true, "timeoutMs": 300000 } }
+// → { "kind": "background", "jobId": "adb-watch-crash-1" }
+
+// 用 job_output 读最新检测结果：
+// [adb_watch_crash] detected 1 new crash(es) after 5400ms
+// - 08-26 06:22:56.714 pid=2947 AndroidRuntime: FATAL EXCEPTION: WM.task-1
+//     AndroidRuntime: Process: com.miui.weather2, PID: 2947
+//     ...
+```
+
+**与现场采集衔接**——检测到崩溃后，配 `adb_crash_report` 和 `adb_screenshot` 抓现场：
+
+```
+1. adb_watch_crash（盯新崩溃）
+2. → 崩溃出现 → adb_crash_report（采集完整现场：buffer + dropbox + 进程 + 内存）
+3.             → adb_screenshot（截取崩溃时的屏幕状态）
+```
+
+| 参数 | 类型 | 默认 | 说明 |
+| --- | --- | --- | --- |
+| `serial` | string | defaultSerial | 目标设备 serial |
+| `timeoutMs` | integer | 60000 | 监控预算（上限 600000 = 10 分钟） |
+| `intervalMs` | integer | 1000 | 轮询间隔（最小 250） |
+| `withStacks` | boolean | true | 是否包含同 pid 堆栈行 |
+| `run_in_background` | boolean | false | 后台 job 模式，用 `job_output` 读结果 |
+
 ## 配置
 
 `cordis.patch.yml` 的 `config` 块（或 profile patch）：
@@ -82,7 +130,7 @@ npm pack --dry-run     # 校验发布包内容（lib/ + cordis.patch.yml）
 ## 测试与验证
 
 - 原则：**提交即测** —— 全部已提交功能均有实测覆盖（单元 + headless 端到端 + 车机台架/真机）。
-- 验证设备：Android 13 车机台架 + Android 13 真机。
+- 验证设备：Android 13 车机台架 + Android 14 真机（Redmi K50 Pro）+ 模拟器。
 - 版本化变更与每版验证记录见 [CHANGELOG.md](CHANGELOG.md)；测试方法与覆盖现状见 [docs/TESTING.md](docs/TESTING.md)。
 
 ## 项目文档（双语，供 AI 对话/协作者参考）

package/lib/index.js

@@ -11,6 +11,7 @@ import { registerPerfBaselineTool } from './tools/perf-baseline.js';
 import { registerWaitTool } from './tools/wait.js';
 import { registerOperationLedgerTool } from './tools/operation-ledger.js';
 import { registerScreenshotTool } from './tools/screenshot.js';
+import { registerWatchCrashTool } from './tools/watch-crash.js';
 import { registerRpc } from './rpc.js';
 import { registerSkills } from './skill.js';
 export const name = 'dsh-adb';
@@ -40,10 +41,11 @@ export function apply(ctx, config) {
     registerWaitTool(ctx, cfg);
     registerOperationLedgerTool(ctx, cfg, baselineDir);
     registerScreenshotTool(ctx, cfg, screenshotDir);
+    registerWatchCrashTool(ctx, cfg);
     registerSkills(ctx);
     // 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, reportDir));
-    ctx.logger.info('[dsh-adb] loaded: 13 tools + web device panel rpc');
+    ctx.logger.info('[dsh-adb] loaded: 14 tools + web device panel rpc');
 }

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

@@ -0,0 +1,46 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type AdbConfig } from '../adb.js';
+import { parseLogcat } from '../parsers/logcat.js';
+import { type CrashChain } from '../report.js';
+/**
+ * adb_watch_crash: watch the crash buffer for NEW real crashes. Foreground:
+ * poll until a new real crash appears or the budget expires (returns
+ * matched:false on timeout, not an error). Background: run as a job that keeps
+ * polling; job_output returns a text summary of each newly detected crash.
+ *
+ * Reuses the crash classification from the health report (real crash vs. boot
+ * markers), so "a new crash" means a real one — not another mtk-brm line.
+ */
+export interface WatchCrashArgs {
+    serial?: string;
+    /** Overall watch budget in milliseconds; defaults to 60000, capped at 600000. */
+    timeoutMs?: number;
+    /** Poll interval in milliseconds; defaults to 1000. */
+    intervalMs?: number;
+    /** Include the following same-pid lines (stack) per crash in the result. */
+    withStacks?: boolean;
+    run_in_background?: boolean;
+}
+export interface CrashDetection {
+    matched: boolean;
+    waitedMs: number;
+    crashes: Array<{
+        time: string;
+        pid: string;
+        tag: string;
+        message: string;
+        stack: string[];
+    }>;
+}
+/** A stable identity for one crash occurrence: time+pid+tag+message. */
+export declare function crashSignature(chain: CrashChain): string;
+/** Map crash chains to the public detection shape. */
+export declare function chainToDetection(chain: CrashChain, withStacks: boolean): CrashDetection['crashes'][number];
+/** One poll: return chains not seen in `seen`, and update `seen`. */
+export declare function detectNewCrashes(entries: ReturnType<typeof parseLogcat>, seen: Set<string>, withStacks: boolean): CrashDetection['crashes'];
+/** Poll the crash buffer until a new real crash appears or the budget expires. */
+export declare function watchForCrash(ctx: Context, cfg: AdbConfig, signal: AbortSignal, args: WatchCrashArgs): Promise<CrashDetection>;
+/** Format detected crashes as a job_output-friendly text block. */
+export declare function formatCrashDetections(detection: CrashDetection): string;
+/** adb_watch_crash: watch the crash buffer for NEW real crashes (foreground poll or background job). */
+export declare function registerWatchCrashTool(ctx: Context, cfg: AdbConfig): void;

package/lib/tools/watch-crash.js

@@ -0,0 +1,199 @@
+import { AdbError, classifyFailure, jsonOutput, runAdb } from '../adb.js';
+import { parseLogcat } from '../parsers/logcat.js';
+import { classifyCrashBuffer } from '../report.js';
+const DEFAULT_TIMEOUT_MS = 60_000;
+const MAX_TIMEOUT_MS = 600_000;
+const DEFAULT_INTERVAL_MS = 1_000;
+/** A stable identity for one crash occurrence: time+pid+tag+message. */
+export function crashSignature(chain) {
+    const sig = chain.signature;
+    return `${sig.time}|${sig.pid}|${sig.tag}|${sig.message}`;
+}
+/** Map crash chains to the public detection shape. */
+export function chainToDetection(chain, withStacks) {
+    return {
+        time: chain.signature.time,
+        pid: chain.signature.pid,
+        tag: chain.signature.tag,
+        message: chain.signature.message,
+        stack: withStacks ? chain.following.map((entry) => `${entry.tag}: ${entry.message}`) : [],
+    };
+}
+/** One poll: return chains not seen in `seen`, and update `seen`. */
+export function detectNewCrashes(entries, seen, withStacks) {
+    const summary = classifyCrashBuffer(entries);
+    const fresh = [];
+    for (const chain of summary.chains) {
+        const key = crashSignature(chain);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        fresh.push(chainToDetection(chain, withStacks));
+    }
+    return fresh;
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error('tool call aborted'));
+            return;
+        }
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(new Error('tool call aborted'));
+        }, { once: true });
+    });
+}
+/** Poll the crash buffer until a new real crash appears or the budget expires. */
+export async function watchForCrash(ctx, cfg, signal, args) {
+    const timeoutMs = Math.min(Math.floor(args.timeoutMs ?? DEFAULT_TIMEOUT_MS), MAX_TIMEOUT_MS);
+    const intervalMs = Math.max(Math.floor(args.intervalMs ?? DEFAULT_INTERVAL_MS), 250);
+    const start = Date.now();
+    const deadline = start + timeoutMs;
+    const seen = new Set();
+    const withStacks = args.withStacks ?? true;
+    let lastError;
+    // Seed: remember every crash already in the buffer, so only NEW ones match.
+    try {
+        const seed = await runAdb(ctx, cfg, ['logcat', '-b', 'crash', '-v', 'threadtime', '-d'], { signal, serial: args.serial, maxBytes: 8 * 1024 * 1024 });
+        if (seed.exitCode !== 0)
+            throw classifyFailure(seed);
+        for (const chain of classifyCrashBuffer(parseLogcat(seed.stdout)).chains) {
+            seen.add(crashSignature(chain));
+        }
+    }
+    catch (error) {
+        lastError = error instanceof Error ? error.message : String(error);
+    }
+    while (true) {
+        try {
+            const result = await runAdb(ctx, cfg, ['logcat', '-b', 'crash', '-v', 'threadtime', '-d'], { signal, serial: args.serial, maxBytes: 8 * 1024 * 1024 });
+            if (result.exitCode !== 0)
+                throw classifyFailure(result);
+            const fresh = detectNewCrashes(parseLogcat(result.stdout), seen, withStacks);
+            if (fresh.length > 0) {
+                return { matched: true, waitedMs: Date.now() - start, crashes: fresh };
+            }
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+        }
+        if (Date.now() >= deadline) {
+            return {
+                matched: false,
+                waitedMs: timeoutMs,
+                crashes: [],
+                ...(lastError !== undefined ? { reason: lastError } : { reason: `no new crash within ${timeoutMs}ms` }),
+            };
+        }
+        await sleep(Math.min(intervalMs, deadline - Date.now()), signal);
+    }
+}
+/** Format detected crashes as a job_output-friendly text block. */
+export function formatCrashDetections(detection) {
+    const lines = [`[adb_watch_crash] ${detection.matched ? `detected ${detection.crashes.length} new crash(es) after ${detection.waitedMs}ms` : `no new crash within ${detection.waitedMs}ms`}`];
+    for (const crash of detection.crashes) {
+        lines.push(`- ${crash.time} pid=${crash.pid} ${crash.tag}: ${crash.message}`);
+        for (const line of crash.stack)
+            lines.push(`    ${line}`);
+    }
+    return lines.join('\n');
+}
+/** adb_watch_crash: watch the crash buffer for NEW real crashes (foreground poll or background job). */
+export function registerWatchCrashTool(ctx, cfg) {
+    ctx.tools.register({
+        name: 'adb_watch_crash',
+        description: 'Watch the crash buffer for NEW real crashes. Foreground: poll until a new real crash (FATAL EXCEPTION / Fatal signal / SIG*) appears or the budget expires — returns matched:false on timeout (not an error), so you can react. Background (run_in_background): keeps polling as a job; job_output returns a text summary of each newly detected crash. Boot markers (mtk-brm) are not crashes. Pair with adb_crash_report / adb_screenshot to capture the scene when a crash is detected.',
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                serial: { type: 'string', description: 'Target device serial; defaults to the plugin defaultSerial.' },
+                timeoutMs: { type: 'integer', description: 'Overall watch budget in ms; defaults to 60000, capped at 600000.' },
+                intervalMs: { type: 'integer', description: 'Poll interval in ms; defaults to 1000, minimum 250.' },
+                withStacks: { type: 'boolean', description: 'Include the following same-pid lines (stack) per crash; defaults to true.' },
+                run_in_background: { type: 'boolean', description: 'Run as a background job and return a job id immediately.' },
+            },
+        },
+        output: jsonOutput(),
+        async execute(args, exec) {
+            if (args.run_in_background === true) {
+                return startBackgroundWatch(ctx, cfg, args, exec);
+            }
+            return watchForCrash(ctx, cfg, exec.signal, args);
+        },
+    });
+}
+function startBackgroundWatch(ctx, cfg, args, exec) {
+    const jobs = ctx.get('jobs');
+    if (jobs === undefined) {
+        throw new AdbError('JOBS_UNAVAILABLE', 'background jobs unavailable: load @deepseek-ai/dsh-jobs and @deepseek-ai/dsh-tool-jobs');
+    }
+    if (exec.signal.aborted) {
+        const error = new Error('tool call aborted');
+        error.name = 'AbortError';
+        throw error;
+    }
+    // The background loop must outlive the tool call: no exec.signal in the loop.
+    const controller = new AbortController();
+    let latestDetection;
+    let done = false;
+    const id = jobs.start({
+        kind: 'adb-watch-crash',
+        label: `watch-crash${args.serial !== undefined ? ` ${args.serial}` : ''}`,
+        ...(exec.agent !== undefined ? { owner: exec.agent } : {}),
+        run: () => {
+            const loop = (async () => {
+                const start = Date.now();
+                const timeoutMs = Math.min(Math.floor(args.timeoutMs ?? DEFAULT_TIMEOUT_MS), MAX_TIMEOUT_MS);
+                const intervalMs = Math.max(Math.floor(args.intervalMs ?? DEFAULT_INTERVAL_MS), 250);
+                const seen = new Set();
+                const withStacks = args.withStacks ?? true;
+                const deadline = start + timeoutMs;
+                let lastError;
+                try {
+                    const seed = await runAdb(ctx, cfg, ['logcat', '-b', 'crash', '-v', 'threadtime', '-d'], { signal: controller.signal, serial: args.serial, maxBytes: 8 * 1024 * 1024 });
+                    if (seed.exitCode !== 0)
+                        throw classifyFailure(seed);
+                    for (const chain of classifyCrashBuffer(parseLogcat(seed.stdout)).chains) {
+                        seen.add(crashSignature(chain));
+                    }
+                }
+                catch (error) {
+                    lastError = error instanceof Error ? error.message : String(error);
+                }
+                while (!done && Date.now() < deadline) {
+                    try {
+                        const result = await runAdb(ctx, cfg, ['logcat', '-b', 'crash', '-v', 'threadtime', '-d'], { signal: controller.signal, serial: args.serial, maxBytes: 8 * 1024 * 1024 });
+                        if (result.exitCode !== 0)
+                            throw classifyFailure(result);
+                        const fresh = detectNewCrashes(parseLogcat(result.stdout), seen, withStacks);
+                        if (fresh.length > 0) {
+                            latestDetection = { matched: true, waitedMs: Date.now() - start, crashes: fresh };
+                        }
+                    }
+                    catch (error) {
+                        lastError = error instanceof Error ? error.message : String(error);
+                    }
+                    await sleep(Math.min(intervalMs, deadline - Date.now()), controller.signal).catch(() => { });
+                }
+                done = true;
+                if (latestDetection === undefined) {
+                    latestDetection = {
+                        matched: false,
+                        waitedMs: timeoutMs,
+                        crashes: [],
+                        ...(lastError !== undefined ? { reason: lastError } : { reason: `no new crash within ${timeoutMs}ms` }),
+                    };
+                }
+            })();
+            return {
+                cancel: () => { done = true; },
+                done: loop.then(() => ({ exitCode: 0, signal: null })),
+                readOutput: () => latestDetection === undefined ? '' : formatCrashDetections(latestDetection),
+            };
+        },
+    });
+    return { kind: 'background', jobId: id };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-adb",
-  "version": "1.5.0",
-  "description": "ADB device & bench operations for DeepSeek Harness: device discovery, structured logcat, apk install, file pull/push, performance snapshots, perf baselines, crash reports, one-click device health reports, condition waits, operation ledger w/ rollback, screenshots, web device panel (autocomplete, live logcat, profiler)",
+  "version": "1.6.1",
+  "description": "ADB device & bench operations for DeepSeek Harness: device discovery, structured logcat, apk install, file pull/push, performance snapshots, perf baselines, crash reports, one-click device health reports, condition waits, operation ledger w/ rollback, screenshots, crash watchdog, web device panel (autocomplete, live logcat, profiler)",
   "type": "module",
   "main": "lib/index.js",
   "exports": {