dsh-adb 1.0.0 → 1.2.0

package/lib/rpc.js

@@ -1,47 +1,134 @@
+import { readFileSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { classifyFailure, runAdb } from './adb.js';
 import { parseDevices } from './parsers/devices.js';
-import { matchesLevel, parseLogcat } from './parsers/logcat.js';
+import { matchesKeyword, matchesLevel, parseLogcat } from './parsers/logcat.js';
+import { parseGetprop, parseMemTotal, parsePackageList, parseProcessList, parseWmSize, } from './parsers/sysinfo.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) {
+import { collectDeviceReport, REPORT_SECTIONS } from './report.js';
+import { saveReport } from './report-store.js';
+async function requireDevice(ctx, cfg, argv, options) {
+    const result = await runAdb(ctx, cfg, argv, { signal: options.signal, serial: options.serial, maxBytes: options.maxBytes });
+    if (result.exitCode !== 0)
+        throw classifyFailure(result);
+    return result.stdout;
+}
+function serialOf(payload) {
+    return typeof payload.serial === 'string' ? payload.serial : undefined;
+}
+export async function handleRpcEndpoint(ctx, cfg, reportDir, 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) } };
+                const stdout = await requireDevice(ctx, cfg, ['devices', '-l'], { signal });
+                return { ok: true, value: { server: 'ok', devices: parseDevices(stdout) } };
             }
-            case 'perfSnapshot': {
+            case 'listPackages': {
+                const stdout = await requireDevice(ctx, cfg, ['shell', 'pm', 'list', 'packages'], {
+                    signal,
+                    serial: serialOf(payload),
+                    maxBytes: 4 * 1024 * 1024,
+                });
+                return { ok: true, value: { packages: parsePackageList(stdout) } };
+            }
+            case 'deviceInfo': {
+                const serial = serialOf(payload);
+                const getprop = parseGetprop(await requireDevice(ctx, cfg, ['shell', 'getprop'], { signal, serial, maxBytes: 2 * 1024 * 1024 }));
+                const size = parseWmSize(await requireDevice(ctx, cfg, ['shell', 'wm', 'size'], { signal, serial }));
+                const memTotalKb = parseMemTotal(await requireDevice(ctx, cfg, ['shell', 'cat', '/proc/meminfo'], { signal, serial }));
+                return {
+                    ok: true,
+                    value: {
+                        model: getprop['ro.product.model'],
+                        manufacturer: getprop['ro.product.manufacturer'],
+                        release: getprop['ro.build.version.release'],
+                        sdk: getprop['ro.build.version.sdk'],
+                        resolution: size === undefined ? undefined : `${size.width}x${size.height}`,
+                        memTotalKb,
+                    },
+                };
+            }
+            case 'processList': {
+                const stdout = await requireDevice(ctx, cfg, ['shell', 'ps', '-A'], {
+                    signal,
+                    serial: serialOf(payload),
+                    maxBytes: 2 * 1024 * 1024,
+                });
+                let processes = parseProcessList(stdout);
                 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 };
+                if (pkg !== undefined)
+                    processes = processes.filter((entry) => entry.name.includes(pkg));
+                processes = processes.slice(0, 100);
+                return { ok: true, value: { total: processes.length, processes } };
             }
-            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'], {
+            case 'logcatTail':
+            case 'logcatDelta': {
+                const serial = serialOf(payload);
+                const stdout = await requireDevice(ctx, cfg, ['logcat', '-v', 'threadtime', '-d'], {
                     signal,
                     serial,
                     maxBytes: 8 * 1024 * 1024,
                 });
-                if (output.exitCode !== 0)
-                    throw classifyFailure(output);
-                let entries = parseLogcat(output.stdout);
+                const since = typeof payload.since === 'string' ? payload.since : undefined;
+                const level = typeof payload.level === 'string' ? payload.level : undefined;
+                const keyword = typeof payload.keyword === 'string' ? payload.keyword : undefined;
+                const pid = typeof payload.pid === 'string' ? payload.pid : undefined;
+                const tail = typeof payload.tail === 'number' && payload.tail > 0 ? Math.floor(payload.tail) : 200;
+                let entries = parseLogcat(stdout);
+                // threadtime timestamps ("MM-DD HH:MM:SS.mmm") sort lexicographically.
+                if (since !== undefined)
+                    entries = entries.filter((entry) => entry.time > since);
                 if (level !== undefined)
                     entries = entries.filter((entry) => matchesLevel(entry, level));
+                if (keyword !== undefined)
+                    entries = entries.filter((entry) => matchesKeyword(entry, keyword));
+                if (pid !== undefined)
+                    entries = entries.filter((entry) => entry.pid === pid);
                 const capped = entries.slice(-tail);
                 return { ok: true, value: { total: entries.length, truncated: entries.length > tail, entries: capped } };
             }
+            case 'perfSnapshot': {
+                const pkg = typeof payload.package === 'string' ? payload.package : undefined;
+                if (pkg === undefined)
+                    throw new Error('perfSnapshot requires a string "package"');
+                const snapshot = await capturePerfSnapshot(ctx, cfg, signal, { package: pkg, serial: serialOf(payload) });
+                return { ok: true, value: snapshot };
+            }
+            case 'screenshot': {
+                const serial = serialOf(payload);
+                const devicePath = `/data/local/tmp/dsh-shot-${Date.now()}.png`;
+                const localPath = join(tmpdir(), `dsh-shot-${Date.now()}.png`);
+                try {
+                    await requireDevice(ctx, cfg, ['shell', 'screencap', '-p', devicePath], { signal, serial });
+                    await requireDevice(ctx, cfg, ['pull', devicePath, localPath], { signal, serial });
+                    const bytes = readFileSync(localPath);
+                    return { ok: true, value: { mime: 'image/png', bytes: bytes.length, dataUrl: `data:image/png;base64,${bytes.toString('base64')}` } };
+                }
+                finally {
+                    try {
+                        unlinkSync(localPath);
+                    }
+                    catch { /* temp cleanup is best-effort */ }
+                }
+            }
+            case 'perfSample': {
+                const pkg = typeof payload.package === 'string' ? payload.package : undefined;
+                if (pkg === undefined)
+                    throw new Error('perfSample requires a string "package"');
+                const snapshot = await capturePerfSnapshot(ctx, cfg, signal, { package: pkg, serial: serialOf(payload), metrics: ['meminfo', 'battery'] });
+                return { ok: true, value: { package: pkg, meminfo: snapshot.meminfo, battery: snapshot.battery } };
+            }
+            case 'deviceReport': {
+                const include = Array.isArray(payload.include)
+                    ? payload.include.filter((item) => typeof item === 'string' && REPORT_SECTIONS.includes(item))
+                    : undefined;
+                const tail = typeof payload.tail === 'number' ? payload.tail : undefined;
+                const report = await collectDeviceReport(ctx, cfg, signal, { serial: serialOf(payload), include, tail });
+                const saved = saveReport(reportDir, report);
+                return { ok: true, value: { ...report, savedTo: saved.file } };
+            }
             default:
                 return { ok: false, error: { message: `unknown endpoint: ${endpoint}` } };
         }
@@ -55,12 +142,12 @@ export async function handleRpcEndpoint(ctx, cfg, endpoint, raw, signal) {
  * (conversation.view tab "设备"). Called lazily once the client connection
  * mounts; headless compositions (no connection) stay unaffected.
  */
-export function registerRpc(ctx, cfg) {
+export function registerRpc(ctx, cfg, reportDir) {
     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), 
+    ctx.effect(() => rpc.handle('/dsh-adb', (endpoint, raw, signal) => handleRpcEndpoint(ctx, cfg, reportDir, endpoint, raw, signal), 
     // Browser-only channel: accept requests from the loopback web GUI.
     { authority: 'loopback' }));
 }

package/lib/skill.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from '@deepseek-ai/cordis';
+/** Runtime skill: automated crash-scene collection + analysis for automotive/Android devices. */
+export declare const CRASH_ANALYSIS_SKILL: {
+    name: string;
+    description: string;
+    whenToUse: string;
+    content: string;
+};
+export declare function registerSkills(ctx: Context): void;

package/lib/skill.js

@@ -0,0 +1,40 @@
+/** Runtime skill: automated crash-scene collection + analysis for automotive/Android devices. */
+export const CRASH_ANALYSIS_SKILL = {
+    name: 'dsh-adb-crash-analysis',
+    description: '采集车机/安卓设备崩溃现场（crash buffer / dropbox / 进程 / 内存）并输出结构化分析报告',
+    whenToUse: '遇到车机应用崩溃、ANR、无响应，或需要系统性采集崩溃上下文做稳定性分析时',
+    content: `# 车机崩溃现场分析
+
+用 dsh-adb 采集崩溃现场并给出结构化结论。适合实车/台架联调与稳定性回归。
+
+## 流程
+
+1. **确认设备**：调用 \`adb_devices\` 拿到设备 serial；多设备时用 \`-s <serial>\` 显式指定。
+2. **采集崩溃现场**：调用 \`adb_crash_report\`（package 为目标应用，如 com.example.hmi），一次拿到：
+   - crashBuffer：logcat crash 缓冲区的结构化条目（AndroidRuntime 堆栈、native crash）
+   - dropbox：系统 dropbox 的崩溃条目摘录
+   - processes：当前进程状态摘录
+   - meminfo：目标应用内存摘要（PSS/堆）
+3. **定位主崩溃**：从 crashBuffer 里找 \`FATAL EXCEPTION\` 或 \`AndroidRuntime\` E 级条目；提取崩溃线程、异常类型（如 NullPointerException / RuntimeException / SIGSEGV）、首次出现时间与最后出现时间。
+4. **交叉验证**：
+   - 有堆栈 → 结合进程状态判断是否仍在运行/重启循环
+   - 内存异常（PSS 过高/持续增长）→ 用 \`adb_perf_snapshot\` 补充 meminfo/gfxinfo
+   - dropbox 有 \`SYSTEM_TOMBSTONE\`/ANR 条目 → 一并纳入
+5. **输出报告**（结构化）：
+   - 崩溃进程与包名、时间线（首现/末现）、异常类型与关键堆栈（截断到可读）
+   - 根因线索（代码位置、资源、并发、内存）与置信度
+   - 建议动作（修代码 / 加防护 / 复测方案）
+
+## 与定时任务组合（dsh-automation）
+
+在 dsh-automation 中建每日/每版本任务，prompt 指向本流程：
+「按 dsh-adb-crash-analysis 流程，对 <设备> 上 <包名> 采集崩溃现场并输出分析报告，保留可审计历史。」
+配合 \`adb_crash_report\` 的 since 参数可只采集指定时间窗口之后的崩溃。
+`,
+};
+export function registerSkills(ctx) {
+    const skills = ctx.get('skills');
+    if (skills === undefined)
+        return;
+    ctx.effect(() => skills.register(CRASH_ANALYSIS_SKILL));
+}

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

@@ -0,0 +1,10 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type AdbConfig } from '../adb.js';
+/**
+ * adb_device_report: one-click device health check ("体检"). Collects device
+ * identity, top RSS processes, crash buffer, the W/E/F logcat window, and
+ * storage usage into one structured report, persists it under the report
+ * store, and returns it for the agent to diagnose (pair with the
+ * dsh-adb-crash-analysis skill).
+ */
+export declare function registerDeviceReportTool(ctx: Context, cfg: AdbConfig, reportDir: string): void;

package/lib/tools/device-report.js

@@ -0,0 +1,52 @@
+import { jsonOutput } from '../adb.js';
+import { collectDeviceReport, REPORT_SECTIONS } from '../report.js';
+import { saveReport } from '../report-store.js';
+/**
+ * adb_device_report: one-click device health check ("体检"). Collects device
+ * identity, top RSS processes, crash buffer, the W/E/F logcat window, and
+ * storage usage into one structured report, persists it under the report
+ * store, and returns it for the agent to diagnose (pair with the
+ * dsh-adb-crash-analysis skill).
+ */
+export function registerDeviceReportTool(ctx, cfg, reportDir) {
+    ctx.tools.register({
+        name: 'adb_device_report',
+        description: 'One-click device health report: collect device identity, top memory processes, the crash buffer (classified into real crashes vs. boot markers, with stack chains), the warning/error logcat window (aggregated by tag), storage usage, and a compact health summary (verdict + issues) into one structured snapshot, persist it to the report store, and return it. Each section degrades independently — a failing section lands in errors instead of failing the whole report. Pair the result with the dsh-adb-crash-analysis skill to diagnose the device state.',
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                serial: { type: 'string', description: 'Target device serial; defaults to the plugin defaultSerial.' },
+                include: {
+                    type: 'array',
+                    items: { type: 'string', enum: [...REPORT_SECTIONS] },
+                    description: 'Which sections to collect; defaults to all five (device, processes, crash, logcat, storage).',
+                },
+                tail: { type: 'integer', description: 'Cap for crash/logcat entries and the process/storage lists; defaults to 100.' },
+            },
+        },
+        output: jsonOutput(),
+        async execute(args, exec) {
+            const report = await collectDeviceReport(ctx, cfg, exec.signal, args);
+            let saved;
+            try {
+                saved = saveReport(reportDir, report);
+            }
+            catch {
+                // Persistence is best-effort: the report is still returned to the agent.
+            }
+            return {
+                collectedAt: report.collectedAt,
+                serial: report.serial,
+                ...(report.device !== undefined ? { device: report.device } : {}),
+                ...(report.processes !== undefined ? { topProcesses: report.processes } : {}),
+                ...(report.crashBuffer !== undefined ? { crashBuffer: report.crashBuffer } : {}),
+                ...(report.logcat !== undefined ? { logcat: report.logcat } : {}),
+                ...(report.storage !== undefined ? { storage: report.storage } : {}),
+                ...(report.health !== undefined ? { health: report.health } : {}),
+                errors: report.errors,
+                ...(saved !== undefined ? { savedTo: saved.file } : {}),
+            };
+        },
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-adb",
-  "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",
+  "version": "1.2.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, web device panel (autocomplete, live logcat, profiler)",
   "type": "module",
   "main": "lib/index.js",
   "exports": {