dsh-adb 1.0.0 → 1.2.0

package/lib/index.d.ts

@@ -13,6 +13,8 @@ export interface Config {
     timeoutMs?: number;
     /** Directory for adb_perf_baseline storage. */
     baselineDir?: string;
+    /** Directory for adb_device_report storage; defaults to <baselineDir>/reports. */
+    reportDir?: string;
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -2,12 +2,14 @@ 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 { registerDeviceReportTool } from './tools/device-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';
+import { registerSkills } from './skill.js';
 export const name = 'dsh-adb';
 /** The tool registry is a hard dependency: every tool registers through it. */
 export const inject = ['tools'];
@@ -16,9 +18,11 @@ export const Config = Schema.object({
     defaultSerial: Schema.string().description('默认目标设备 serial'),
     timeoutMs: Schema.number().default(30000).description('adb 命令超时（毫秒）'),
     baselineDir: Schema.string().description('adb_perf_baseline 基线存储目录；缺省 ~/.dsh/storages/dsh-adb'),
+    reportDir: Schema.string().description('adb_device_report 报告存储目录；缺省 ~/.dsh/storages/dsh-adb/reports'),
 });
 export function apply(ctx, config) {
     const cfg = config;
+    const reportDir = config.reportDir ?? `${(config.baselineDir ?? DEFAULT_BASELINE_DIR).replace(/\\/g, '/')}/reports`;
     registerDeviceTools(ctx, cfg);
     registerInstallTool(ctx, cfg);
     registerFileTool(ctx, cfg);
@@ -26,9 +30,11 @@ export function apply(ctx, config) {
     registerPerfTool(ctx, cfg);
     registerPerfBaselineTool(ctx, cfg, config.baselineDir ?? DEFAULT_BASELINE_DIR);
     registerCrashReportTool(ctx, cfg);
+    registerDeviceReportTool(ctx, cfg, reportDir);
+    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));
-    ctx.logger.info('[dsh-adb] loaded: 9 tools + web device panel rpc');
+    ctx.inject(['connection'], (readyCtx) => registerRpc(readyCtx, cfg, reportDir));
+    ctx.logger.info('[dsh-adb] loaded: 10 tools + web device panel rpc');
 }

package/lib/parsers/sysinfo.d.ts

@@ -0,0 +1,18 @@
+/** Pure parsers for device-system info (packages, getprop, processes, meminfo, wm). */
+export declare function parsePackageList(text: string): string[];
+export declare function parseGetprop(text: string): Record<string, string>;
+export interface ProcessEntry {
+    pid: string;
+    name: string;
+    /** Resident set size in KB (Android `ps -A` column 4), when numeric. */
+    rss?: number;
+}
+/** Parse `ps -A` output (Android toybox: USER PID PPID VSZ RSS WCHAN ADDR S NAME). */
+export declare function parseProcessList(text: string): ProcessEntry[];
+/** Parse /proc/meminfo "MemTotal: 123456 kB" into KB. */
+export declare function parseMemTotal(text: string): number | undefined;
+/** Parse `wm size` -> "Physical size: 1080x2400". */
+export declare function parseWmSize(text: string): {
+    width: number;
+    height: number;
+} | undefined;

package/lib/parsers/sysinfo.js

@@ -0,0 +1,56 @@
+/** Pure parsers for device-system info (packages, getprop, processes, meminfo, wm). */
+export function parsePackageList(text) {
+    const names = [];
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line.startsWith('package:'))
+            continue;
+        const name = line.slice('package:'.length);
+        if (name !== '')
+            names.push(name);
+    }
+    return names;
+}
+export function parseGetprop(text) {
+    const props = {};
+    for (const rawLine of text.split(/\r?\n/)) {
+        const match = /^\[([^\]]+)\]:\s*\[([^\]]*)\]$/.exec(rawLine.trim());
+        if (match === null)
+            continue;
+        props[match[1]] = match[2];
+    }
+    return props;
+}
+/** Parse `ps -A` output (Android toybox: USER PID PPID VSZ RSS WCHAN ADDR S NAME). */
+export function parseProcessList(text) {
+    const entries = [];
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line === '' || /^USER\s+PID/.test(line))
+            continue;
+        const parts = line.split(/\s+/);
+        // Android ps: index 1 = PID, index 4 = RSS, last = NAME (comm may be in brackets)
+        if (parts.length < 2)
+            continue;
+        const pid = parts[1];
+        const name = parts[parts.length - 1];
+        if (pid !== undefined && name !== undefined && /^\d+$/.test(pid)) {
+            const rssRaw = parts[4];
+            const rss = rssRaw !== undefined && /^\d+$/.test(rssRaw) ? Number(rssRaw) : undefined;
+            entries.push({ pid, name, ...(rss !== undefined ? { rss } : {}) });
+        }
+    }
+    return entries;
+}
+/** Parse /proc/meminfo "MemTotal: 123456 kB" into KB. */
+export function parseMemTotal(text) {
+    const match = /^MemTotal:\s+(\d+)\s*kB/im.exec(text);
+    return match === null ? undefined : Number(match[1]);
+}
+/** Parse `wm size` -> "Physical size: 1080x2400". */
+export function parseWmSize(text) {
+    const match = /Physical size:\s+(\d+)x(\d+)/.exec(text);
+    if (match === null)
+        return undefined;
+    return { width: Number(match[1]), height: Number(match[2]) };
+}

package/lib/report-store.d.ts

@@ -0,0 +1,18 @@
+import type { DeviceReport } from './report.js';
+/**
+ * Device health report store: one JSON file per report under a configurable
+ * directory (`<baselineDir>/reports` by default). Read/write helpers are pure
+ * fs functions so the store is unit-testable like the baseline store.
+ * Filename: `<serial>--<epoch-ms>.json`; the id is the epoch prefix.
+ */
+export interface StoredReportMeta {
+    id: string;
+    collectedAt: string;
+    serial: string;
+    file: string;
+}
+export declare const DEFAULT_REPORT_DIR: string;
+export declare function reportFileFor(serial: string): string;
+export declare function listReports(dir: string): StoredReportMeta[];
+export declare function saveReport(dir: string, report: DeviceReport): StoredReportMeta;
+export declare function loadReport(dir: string, file: string): DeviceReport;

package/lib/report-store.js

@@ -0,0 +1,55 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+export const DEFAULT_REPORT_DIR = `${homedir().replace(/\\/g, '/')}/.dsh/storages/dsh-adb/reports`;
+const FILE_PATTERN = /^(.+)--(\d+)\.json$/;
+/** Parse a report filename back into its meta; undefined for foreign files. */
+function parseMeta(file) {
+    const match = FILE_PATTERN.exec(file);
+    if (match === null)
+        return undefined;
+    return { id: match[2], collectedAt: '', serial: match[1], file };
+}
+export function reportFileFor(serial) {
+    const safeSerial = serial.replace(/[^A-Za-z0-9._-]/g, '_');
+    return `${safeSerial}--${Date.now()}.json`;
+}
+export function listReports(dir) {
+    if (!existsSync(dir))
+        return [];
+    const metas = [];
+    for (const name of readdirSync(dir)) {
+        const meta = parseMeta(name);
+        if (meta !== undefined)
+            metas.push(meta);
+    }
+    // Newest first by epoch id.
+    return metas.sort((a, b) => (Number(a.id) < Number(b.id) ? 1 : -1));
+}
+export function saveReport(dir, report) {
+    try {
+        mkdirSync(dir, { recursive: true });
+        const file = reportFileFor(report.serial);
+        writeFileSync(join(dir, file), JSON.stringify(report, null, 2), 'utf8');
+        return { id: String(Date.now()), collectedAt: report.collectedAt, serial: report.serial, file };
+    }
+    catch (error) {
+        throw new Error(`report store unwritable at ${dir}: ${describe(error)}`);
+    }
+}
+export function loadReport(dir, file) {
+    try {
+        const raw = readFileSync(join(dir, file), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== 'object' || !Array.isArray(parsed.errors) || typeof parsed.collectedAt !== 'string') {
+            throw new Error('unexpected shape');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`report store unreadable at ${join(dir, file)}: ${describe(error)}`);
+    }
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/report.d.ts

@@ -0,0 +1,103 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type AdbConfig } from './adb.js';
+import { type LogcatEntry, type LogLevel } from './parsers/logcat.js';
+import { type ProcessEntry } from './parsers/sysinfo.js';
+/**
+ * One-click device health report ("体检"): collect device identity, top
+ * processes, crash buffer, the worrying logcat window (W/E/F), and storage
+ * usage into one structured snapshot. Every section degrades independently —
+ * a failing section lands in `errors` instead of killing the whole report,
+ * so a half-alive device still yields whatever could be read.
+ *
+ * Evidence → signal: raw crash/logcat counts are noisy (boot markers, one
+ * mDNS error repeating thousands of times), so the report classifies crashes
+ * into real crashes vs. startup markers, aggregates logcat by tag, and emits a
+ * compact health summary the agent can reason from instead of 17k raw lines.
+ */
+export type ReportSection = 'device' | 'processes' | 'crash' | 'logcat' | 'storage';
+export declare const REPORT_SECTIONS: readonly ReportSection[];
+export interface ReportDeviceInfo {
+    model?: string;
+    manufacturer?: string;
+    release?: string;
+    sdk?: string;
+    fingerprint?: string;
+    resolution?: string;
+    memTotalKb?: number;
+}
+/** A real crash with the following same-pid lines (its stack trace) attached. */
+export interface CrashChain {
+    signature: LogcatEntry;
+    following: LogcatEntry[];
+}
+export interface CrashSummary {
+    total: number;
+    realCrashCount: number;
+    bootMarkerCount: number;
+    otherCount: number;
+    /** Real crashes, each with its contiguous same-pid tail. */
+    chains: CrashChain[];
+}
+export interface TagAggregate {
+    tag: string;
+    level: LogLevel;
+    count: number;
+    sample: LogcatEntry;
+}
+export interface LogcatSummary {
+    total: number;
+    byTag: TagAggregate[];
+}
+export type HealthVerdict = 'ok' | 'attention';
+export interface HealthSummary {
+    verdict: HealthVerdict;
+    /** Human/agent-readable lines: device, memory hogs, notable signals. */
+    lines: string[];
+    /** Concrete issues that drove the verdict (empty when ok). */
+    issues: string[];
+}
+export interface DeviceReport {
+    collectedAt: string;
+    serial: string;
+    device?: ReportDeviceInfo;
+    processes?: ProcessEntry[];
+    crashBuffer?: CrashSummary;
+    logcat?: LogcatSummary;
+    storage?: {
+        lines: number;
+        truncated: boolean;
+        excerpt: string;
+    };
+    health?: HealthSummary;
+    errors: Array<{
+        section: string;
+        message: string;
+    }>;
+}
+export interface CollectDeviceReportArgs {
+    serial?: string;
+    include?: ReportSection[];
+    /** Cap for crash chains, logcat tag aggregates, and the process/df lists; defaults to 10. */
+    tail?: number;
+}
+export declare function isRealCrash(entry: LogcatEntry): boolean;
+export declare function isBootMarker(entry: LogcatEntry): boolean;
+/**
+ * Classify crash-buffer entries into real crashes vs. MediaTek boot markers
+ * vs. everything else, grouping each real crash with the contiguous same-pid
+ * lines that follow it (the stack trace).
+ */
+export declare function classifyCrashBuffer(entries: LogcatEntry[]): CrashSummary;
+/**
+ * Aggregate logcat entries by tag+level, keeping one sample line per group and
+ * sorting by count descending. Turns "16987 lines" into "AOSP-MdnsDiscovery ×16200".
+ */
+export declare function aggregateByTag(entries: LogcatEntry[], topN?: number): LogcatSummary;
+/**
+ * Compact health summary: verdict + a few lines the agent (or user) can reason
+ * from directly, instead of raw counts. Signals are intentionally coarse —
+ * the report is a triage surface, not a root-cause tool.
+ */
+export declare function buildHealthSummary(report: Pick<DeviceReport, 'device' | 'crashBuffer' | 'logcat' | 'processes'>): HealthSummary;
+/** Collect the one-click device health report with per-section degradation. */
+export declare function collectDeviceReport(ctx: Context, cfg: AdbConfig, signal: AbortSignal, args?: CollectDeviceReportArgs): Promise<DeviceReport>;

package/lib/report.js

@@ -0,0 +1,192 @@
+import { classifyFailure, runAdb } from './adb.js';
+import { matchesLevel, parseLogcat } from './parsers/logcat.js';
+import { parseGetprop, parseMemTotal, parseProcessList, parseWmSize } from './parsers/sysinfo.js';
+export const REPORT_SECTIONS = ['device', 'processes', 'crash', 'logcat', 'storage'];
+function excerpt(text, maxLines) {
+    const lines = text.split(/\r?\n/).filter((line) => line !== '');
+    return {
+        lines: lines.length,
+        truncated: lines.length > maxLines,
+        excerpt: lines.slice(-maxLines).join('\n'),
+    };
+}
+// ---- Evidence → signal pure helpers (unit-tested) ----
+const REAL_CRASH = /FATAL EXCEPTION|Fatal signal|beginning of crash|SIGSEGV|SIGABRT|SIGBUS|SIGFPE|SIGILL|SIGTRAP/i;
+const BOOT_MARKER = /mtk-brm-(?:commit|change|merge)-id|libimsma_adapt|SmartRatSwitch.*mtk-brm/i;
+export function isRealCrash(entry) {
+    return REAL_CRASH.test(entry.message) || REAL_CRASH.test(entry.tag);
+}
+export function isBootMarker(entry) {
+    return BOOT_MARKER.test(entry.message) || BOOT_MARKER.test(entry.tag);
+}
+/**
+ * Classify crash-buffer entries into real crashes vs. MediaTek boot markers
+ * vs. everything else, grouping each real crash with the contiguous same-pid
+ * lines that follow it (the stack trace).
+ */
+export function classifyCrashBuffer(entries) {
+    const chains = [];
+    for (let i = 0; i < entries.length; i++) {
+        if (!isRealCrash(entries[i]))
+            continue;
+        const following = [];
+        const pid = entries[i].pid;
+        for (let j = i + 1; j < entries.length && entries[j].pid === pid; j++) {
+            following.push(entries[j]);
+        }
+        chains.push({ signature: entries[i], following });
+    }
+    const bootMarkerCount = entries.filter(isBootMarker).length;
+    return {
+        total: entries.length,
+        realCrashCount: chains.length,
+        bootMarkerCount,
+        otherCount: entries.length - chains.length - bootMarkerCount,
+        chains,
+    };
+}
+/**
+ * Aggregate logcat entries by tag+level, keeping one sample line per group and
+ * sorting by count descending. Turns "16987 lines" into "AOSP-MdnsDiscovery ×16200".
+ */
+export function aggregateByTag(entries, topN = 10) {
+    const counts = new Map();
+    for (const entry of entries) {
+        const key = `${entry.tag}\u0000${entry.level}`;
+        const existing = counts.get(key);
+        if (existing !== undefined) {
+            existing.count++;
+            continue;
+        }
+        counts.set(key, { tag: entry.tag, level: entry.level, count: 1, sample: entry });
+    }
+    const byTag = [...counts.values()].sort((a, b) => b.count - a.count).slice(0, topN);
+    return { total: entries.length, byTag };
+}
+const NETWORK_SIGNAL = /WifiHAL|NETWORK_ABNORMAL|MdnsDiscovery|multicast mDNS|sendto failed: EPERM/i;
+const THERMAL_NOISE = /PowerKeeper\.Thermal/i;
+/**
+ * Compact health summary: verdict + a few lines the agent (or user) can reason
+ * from directly, instead of raw counts. Signals are intentionally coarse —
+ * the report is a triage surface, not a root-cause tool.
+ */
+export function buildHealthSummary(report) {
+    const lines = [];
+    const issues = [];
+    const device = report.device;
+    if (device) {
+        const parts = [device.model, `Android ${device.release ?? '?'}`].filter(Boolean);
+        if (device.memTotalKb !== undefined)
+            parts.push(`内存 ${Math.round(device.memTotalKb / 1024)}MB`);
+        lines.push(`设备：${parts.join(' · ')}`);
+    }
+    const crash = report.crashBuffer;
+    if (crash && crash.total > 0) {
+        if (crash.realCrashCount > 0) {
+            const tags = [...new Set(crash.chains.map((chain) => chain.signature.tag))].join(', ');
+            issues.push(`真实崩溃 ${crash.realCrashCount} 起（${tags}）`);
+            lines.push(`崩溃：${crash.realCrashCount} 真实崩溃 + ${crash.bootMarkerCount} 启动标记 + ${crash.otherCount} 其他（共 ${crash.total}）`);
+        }
+        else {
+            lines.push(`崩溃：无真实崩溃（${crash.bootMarkerCount} 启动标记 + ${crash.otherCount} 其他，共 ${crash.total}）`);
+        }
+    }
+    const logcat = report.logcat;
+    if (logcat && logcat.total > 0) {
+        const top = logcat.byTag[0];
+        if (top)
+            lines.push(`W/E/F 日志：共 ${logcat.total} 条，主要来源 ${top.tag}(${top.level}) ×${top.count}${logcat.byTag.length > 1 ? ` 等 ${logcat.byTag.length} 个来源` : ''}`);
+        const net = logcat.byTag.find((agg) => NETWORK_SIGNAL.test(agg.tag) || NETWORK_SIGNAL.test(agg.sample.message));
+        if (net)
+            issues.push(`网络异常信号（${net.tag}: ${net.sample.message.slice(0, 80)}）`);
+        const thermal = logcat.byTag.find((agg) => THERMAL_NOISE.test(agg.tag));
+        if (thermal)
+            lines.push('注：PowerKeeper.Thermal 为 MIUI 解析噪音，可忽略');
+    }
+    if (report.processes && report.processes.length > 0) {
+        const top = report.processes.slice(0, 3);
+        lines.push(`内存大户：${top.map((p) => `${p.name}(${p.rss}KB)`).join(', ')}`);
+    }
+    const verdict = issues.length > 0 ? 'attention' : 'ok';
+    return { verdict, lines, issues };
+}
+// ---- Section collectors ----
+/** Device identity block: getprop + wm size + /proc/meminfo. */
+async function collectDevice(ctx, cfg, signal, serial) {
+    const [getpropOut, sizeOut, memOut] = await Promise.all([
+        runAdb(ctx, cfg, ['shell', 'getprop'], { signal, serial, maxBytes: 2 * 1024 * 1024 }),
+        runAdb(ctx, cfg, ['shell', 'wm', 'size'], { signal, serial }),
+        runAdb(ctx, cfg, ['shell', 'cat', '/proc/meminfo'], { signal, serial }),
+    ]);
+    for (const result of [getpropOut, sizeOut, memOut]) {
+        if (result.exitCode !== 0)
+            throw classifyFailure(result);
+    }
+    const props = parseGetprop(getpropOut.stdout);
+    const size = parseWmSize(sizeOut.stdout);
+    return {
+        model: props['ro.product.model'],
+        manufacturer: props['ro.product.manufacturer'],
+        release: props['ro.build.version.release'],
+        sdk: props['ro.build.version.sdk'],
+        fingerprint: props['ro.build.fingerprint'],
+        resolution: size === undefined ? undefined : `${size.width}x${size.height}`,
+        memTotalKb: parseMemTotal(memOut.stdout),
+    };
+}
+/** Top processes by RSS (memory hogs first). */
+async function collectProcesses(ctx, cfg, signal, serial, tail) {
+    const result = await runAdb(ctx, cfg, ['shell', 'ps', '-A'], { signal, serial, maxBytes: 2 * 1024 * 1024 });
+    if (result.exitCode !== 0)
+        throw classifyFailure(result);
+    return parseProcessList(result.stdout)
+        .filter((entry) => entry.rss !== undefined)
+        .sort((a, b) => (b.rss ?? 0) - (a.rss ?? 0))
+        .slice(0, tail);
+}
+/** Crash buffer classified into real crashes vs. boot markers. */
+async function collectCrash(ctx, cfg, signal, serial) {
+    const result = await runAdb(ctx, cfg, ['logcat', '-b', 'crash', '-v', 'threadtime', '-d'], { signal, serial, maxBytes: 8 * 1024 * 1024 });
+    if (result.exitCode !== 0)
+        throw classifyFailure(result);
+    return classifyCrashBuffer(parseLogcat(result.stdout));
+}
+/** The worrying logcat window: W/E/F entries from the main buffer, aggregated by tag. */
+async function collectLogcat(ctx, cfg, signal, serial, tail) {
+    const result = await runAdb(ctx, cfg, ['logcat', '-v', 'threadtime', '-d'], { signal, serial, maxBytes: 8 * 1024 * 1024 });
+    if (result.exitCode !== 0)
+        throw classifyFailure(result);
+    const entries = parseLogcat(result.stdout).filter((entry) => matchesLevel(entry, 'W'));
+    return aggregateByTag(entries, tail);
+}
+/** Storage usage excerpt (`df`). */
+async function collectStorage(ctx, cfg, signal, serial, tail) {
+    const result = await runAdb(ctx, cfg, ['shell', 'df'], { signal, serial, maxBytes: 1024 * 1024 });
+    if (result.exitCode !== 0)
+        throw classifyFailure(result);
+    return excerpt(result.stdout, tail);
+}
+/** Collect the one-click device health report with per-section degradation. */
+export async function collectDeviceReport(ctx, cfg, signal, args = {}) {
+    const serial = args.serial ?? cfg.defaultSerial;
+    const tail = args.tail !== undefined && args.tail > 0 ? Math.floor(args.tail) : 10;
+    const include = args.include ?? [...REPORT_SECTIONS];
+    const report = { collectedAt: new Date().toISOString(), serial: serial ?? 'default', errors: [] };
+    const guard = async (section, collect, assign) => {
+        try {
+            assign(await collect());
+        }
+        catch (error) {
+            report.errors.push({ section, message: error instanceof Error ? error.message : String(error) });
+        }
+    };
+    await Promise.all([
+        include.includes('device') && guard('device', () => collectDevice(ctx, cfg, signal, serial), (v) => { report.device = v; }),
+        include.includes('processes') && guard('processes', () => collectProcesses(ctx, cfg, signal, serial, tail), (v) => { report.processes = v; }),
+        include.includes('crash') && guard('crash', () => collectCrash(ctx, cfg, signal, serial), (v) => { report.crashBuffer = v; }),
+        include.includes('logcat') && guard('logcat', () => collectLogcat(ctx, cfg, signal, serial, tail), (v) => { report.logcat = v; }),
+        include.includes('storage') && guard('storage', () => collectStorage(ctx, cfg, signal, serial, tail), (v) => { report.storage = v; }),
+    ]);
+    report.health = buildHealthSummary(report);
+    return report;
+}

package/lib/rpc.d.ts

@@ -9,15 +9,10 @@ export type RpcEndpointResult = {
         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>;
+export declare function handleRpcEndpoint(ctx: Context, cfg: AdbConfig, reportDir: string, 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;
+export declare function registerRpc(ctx: Context, cfg: AdbConfig, reportDir: string): void;