dsh-adb 1.2.0 → 1.4.0

package/README.md

@@ -40,6 +40,8 @@ Topics: `dsh-plugin` `dsh` `adb` `android` `automotive` `bench`
 | `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_device_report` | One-click health report: device identity + top-RSS processes + crash buffer (real crashes w/ stacks vs. boot markers) + W/E/F logcat aggregated by tag + storage + health verdict; each section degrades independently; persisted under `reportDir` |
+| `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 |
 
 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.
 

package/README.zh-CN.md

@@ -40,6 +40,8 @@ Topics：`dsh-plugin` `dsh` `adb` `android` `automotive` `bench`
 | `adb_perf_baseline` | 性能回归：快照存基线（label/tags）、与当前状态数值对比（PSS/卡顿率/百分位）、list/delete（本地存储，`baselineDir`） |
 | `adb_crash_report` | 崩溃现场一键采集：crash buffer 解析 + dropbox 摘录 + 进程状态 + 内存摘要 |
 | `adb_device_report` | 一键体检：设备信息 + Top RSS 进程 + 崩溃缓冲（真实崩溃带堆栈/启动标记分类）+ W/E/F 日志按 tag 聚合 + 存储用量 + 健康结论；每节独立降级；落盘到 `reportDir` |
+| `adb_wait_for` | 等待原语：等设备上线 / 启动完成 / 进程出现 / logcat 出现关键字，轮询到预算上限，替代盲目 sleep；超时返回 `matched:false` |
+| `adb_operation_ledger` | 操作回滚台账（record/list/rollback）：追加记录安装/推送等操作，查询历史，或回滚到最近一次成功安装的 APK（`adb install -r`）；落盘 `operations.json` —— agent 自主改设备的信任基础 |
 
 错误码：`ADB_NOT_FOUND`、`ADB_UNAVAILABLE`、`DEVICE_NOT_FOUND`、`NO_DEVICES`、`CONNECT_FAILED`、`INSTALL_FAILED`、`ADB_EXIT_<code>` 等，均为结构化 `AdbError`。
 

package/lib/index.js

@@ -8,6 +8,8 @@ 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 { registerWaitTool } from './tools/wait.js';
+import { registerOperationLedgerTool } from './tools/operation-ledger.js';
 import { registerRpc } from './rpc.js';
 import { registerSkills } from './skill.js';
 export const name = 'dsh-adb';
@@ -31,10 +33,12 @@ export function apply(ctx, config) {
     registerPerfBaselineTool(ctx, cfg, config.baselineDir ?? DEFAULT_BASELINE_DIR);
     registerCrashReportTool(ctx, cfg);
     registerDeviceReportTool(ctx, cfg, reportDir);
+    registerWaitTool(ctx, cfg);
+    registerOperationLedgerTool(ctx, cfg, config.baselineDir ?? DEFAULT_BASELINE_DIR);
     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: 10 tools + web device panel rpc');
+    ctx.logger.info('[dsh-adb] loaded: 12 tools + web device panel rpc');
 }

package/lib/operation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Device operation ledger ("回滚台账"): append-only record of device-modifying
+ * operations (install / uninstall / push / rm / replace), persisted as one
+ * JSON file, so the agent can list what it did and roll an app back to the
+ * last known-good APK. Storage mirrors the baseline store pattern; the
+ * rollback decision logic is pure and unit-tested.
+ */
+export type OperationKind = 'install' | 'uninstall' | 'push' | 'rm' | 'replace' | 'other';
+export interface OperationEntry {
+    id: string;
+    createdAt: string;
+    device: string;
+    kind: OperationKind;
+    /** App package id for install/uninstall/replace. */
+    package?: string;
+    /** Local APK path for install/replace (the rollback source). */
+    apk?: string;
+    /** Device path for push/rm. */
+    remotePath?: string;
+    result: 'ok' | 'failed';
+    note?: string;
+}
+export interface LedgerStoreData {
+    version: 1;
+    operations: OperationEntry[];
+}
+export interface LedgerStore {
+    list(): OperationEntry[];
+    record(entry: Omit<OperationEntry, 'id' | 'createdAt'>): OperationEntry;
+    /** The most recent successful install/replace of `package` on `device`, if any. */
+    latestGoodInstall(device: string, pkg: string): OperationEntry | undefined;
+    /** All successful install/replace entries for `device` + `package`, newest first. */
+    installHistory(device: string, pkg: string): OperationEntry[];
+}
+export declare function loadLedger(dir: string): LedgerStoreData;
+export declare function saveLedger(dir: string, data: LedgerStoreData): void;
+export declare function createLedgerStore(dir: string): LedgerStore;
+export declare function describe(error: unknown): string;

package/lib/operation.js

@@ -0,0 +1,75 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+function filePath(dir) {
+    return `${dir.replace(/\\/g, '/')}/operations.json`;
+}
+function emptyData() {
+    return { version: 1, operations: [] };
+}
+export function loadLedger(dir) {
+    const file = filePath(dir);
+    if (!existsSync(file))
+        return emptyData();
+    let raw;
+    try {
+        raw = readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`operation ledger unreadable at ${file}: ${describe(error)}`);
+    }
+    try {
+        const data = JSON.parse(raw);
+        if (data?.version !== 1 || !Array.isArray(data.operations)) {
+            throw new Error('unexpected shape');
+        }
+        return data;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`operation ledger corrupted at ${file}: ${reason}`);
+    }
+}
+export function saveLedger(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(`operation ledger unwritable at ${file}: ${describe(error)}`);
+    }
+}
+export function createLedgerStore(dir) {
+    return {
+        list() {
+            return loadLedger(dir).operations;
+        },
+        record(entry) {
+            const data = loadLedger(dir);
+            const stored = {
+                ...entry,
+                result: entry.result ?? 'ok',
+                id: `op-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                createdAt: new Date().toISOString(),
+            };
+            data.operations.push(stored);
+            saveLedger(dir, data);
+            return stored;
+        },
+        latestGoodInstall(device, pkg) {
+            return this.installHistory(device, pkg)[0];
+        },
+        installHistory(device, pkg) {
+            return loadLedger(dir).operations
+                .filter((entry) => entry.device === device
+                && entry.package === pkg
+                && (entry.kind === 'install' || entry.kind === 'replace')
+                && entry.result === 'ok'
+                && entry.apk !== undefined && entry.apk !== '')
+                .sort((a, b) => (a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : 0));
+        },
+    };
+}
+export function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/tools/operation-ledger.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type AdbConfig } from '../adb.js';
+import { type OperationKind } from '../operation.js';
+/** Validate a record payload; throws AdbError with a stable code on invalid input. */
+export declare function validateLedgerRecord(args: {
+    kind?: OperationKind;
+    apk?: string;
+    remotePath?: string;
+}): void;
+/**
+ * adb_operation_ledger: append-only device operation ledger (回滚台账). Records
+ * device-modifying operations (install/uninstall/push/rm/replace) so the agent
+ * can list what it did and roll an app back to the last known-good APK. The
+ * ledger is the trust base for "agent modifies the device": without it the
+ * agent cannot undo what it changed. Persisted under the baseline dir as
+ * operations.json.
+ */
+export declare function registerOperationLedgerTool(ctx: Context, cfg: AdbConfig, ledgerDir: string): void;

package/lib/tools/operation-ledger.js

@@ -0,0 +1,119 @@
+import { existsSync } from 'node:fs';
+import { AdbError, classifyFailure, jsonOutput, runAdb } from '../adb.js';
+import { createLedgerStore } from '../operation.js';
+const KINDS = ['install', 'uninstall', 'push', 'rm', 'replace', 'other'];
+/** Validate a record payload; throws AdbError with a stable code on invalid input. */
+export function validateLedgerRecord(args) {
+    if (args.kind === undefined)
+        throw new AdbError('ARGS_INVALID', 'record requires a "kind"');
+    if ((args.kind === 'install' || args.kind === 'replace') && (args.apk === undefined || !existsSync(args.apk))) {
+        throw new AdbError('LOCAL_FILE_NOT_FOUND', `install/replace record requires an existing local apk path, got: ${args.apk ?? '(none)'}`);
+    }
+    if ((args.kind === 'push' || args.kind === 'rm') && args.remotePath === undefined) {
+        throw new AdbError('ARGS_INVALID', 'push/rm record requires a "remotePath"');
+    }
+}
+/**
+ * adb_operation_ledger: append-only device operation ledger (回滚台账). Records
+ * device-modifying operations (install/uninstall/push/rm/replace) so the agent
+ * can list what it did and roll an app back to the last known-good APK. The
+ * ledger is the trust base for "agent modifies the device": without it the
+ * agent cannot undo what it changed. Persisted under the baseline dir as
+ * operations.json.
+ */
+export function registerOperationLedgerTool(ctx, cfg, ledgerDir) {
+    ctx.tools.register({
+        name: 'adb_operation_ledger',
+        description: 'Append-only device operation ledger (回滚台账): record device-modifying operations (install/uninstall/push/rm/replace), list the history for a device and/or package, or roll an app back to its last known-good APK (re-installs the stored APK with -r). Use it after installs/pushes so the agent can undo its own device changes — the trust base for agent-driven device modification. Persisted under the baseline dir as operations.json.',
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['command'],
+            properties: {
+                command: {
+                    type: 'string',
+                    enum: ['record', 'list', 'rollback'],
+                    description: 'record: append one operation; list: show history (optionally filtered by serial/package); rollback: re-install the last known-good APK for a device+package.',
+                },
+                serial: { type: 'string', description: 'Target device serial; defaults to the plugin defaultSerial.' },
+                kind: {
+                    type: 'string',
+                    enum: [...KINDS],
+                    description: 'Operation kind for record (install/uninstall/push/rm/replace/other).',
+                },
+                package: { type: 'string', description: 'App package id (install/uninstall/replace); required for rollback.' },
+                apk: { type: 'string', description: 'Local APK path for install/replace — the rollback source. Must exist for record+install/replace.' },
+                remotePath: { type: 'string', description: 'Device path for push/rm.' },
+                result: { type: 'string', enum: ['ok', 'failed'], description: 'Outcome of the recorded operation; defaults to ok.' },
+                note: { type: 'string', description: 'Free-form note (build id, reason, etc.).' },
+                limit: { type: 'integer', description: 'Cap for list entries; defaults to 20.' },
+            },
+        },
+        output: jsonOutput(),
+        async execute(args, exec) {
+            const store = createLedgerStore(ledgerDir);
+            const device = args.serial ?? cfg.defaultSerial ?? 'default';
+            if (args.command === 'list') {
+                const limit = args.limit !== undefined && args.limit > 0 ? Math.floor(args.limit) : 20;
+                let entries = store.list();
+                if (args.serial !== undefined)
+                    entries = entries.filter((entry) => entry.device === args.serial);
+                if (args.package !== undefined)
+                    entries = entries.filter((entry) => entry.package === args.package);
+                return {
+                    command: 'list',
+                    count: entries.length,
+                    truncated: entries.length > limit,
+                    entries: entries.slice(-limit).reverse().map((entry) => ({
+                        id: entry.id,
+                        createdAt: entry.createdAt,
+                        device: entry.device,
+                        kind: entry.kind,
+                        ...(entry.package !== undefined ? { package: entry.package } : {}),
+                        ...(entry.apk !== undefined ? { apk: entry.apk } : {}),
+                        ...(entry.remotePath !== undefined ? { remotePath: entry.remotePath } : {}),
+                        result: entry.result,
+                        ...(entry.note !== undefined ? { note: entry.note } : {}),
+                    })),
+                };
+            }
+            if (args.command === 'record') {
+                validateLedgerRecord(args);
+                const kind = args.kind;
+                const stored = store.record({
+                    device,
+                    kind,
+                    ...(args.package !== undefined ? { package: args.package } : {}),
+                    ...(args.apk !== undefined ? { apk: args.apk } : {}),
+                    ...(args.remotePath !== undefined ? { remotePath: args.remotePath } : {}),
+                    result: args.result ?? 'ok',
+                    ...(args.note !== undefined ? { note: args.note } : {}),
+                });
+                return { command: 'record', recorded: { id: stored.id, createdAt: stored.createdAt } };
+            }
+            // rollback
+            if (args.package === undefined) {
+                throw new AdbError('ARGS_INVALID', 'rollback requires a "package"');
+            }
+            const target = store.latestGoodInstall(device, args.package);
+            if (target === undefined) {
+                throw new AdbError('LEDGER_EMPTY', `no recorded good install for device ${device} package ${args.package}; record installs with command=record first`);
+            }
+            if (target.apk === undefined || !existsSync(target.apk)) {
+                throw new AdbError('APK_MISSING', `rollback source missing: ${target.apk ?? '(none)'} (recorded ${target.createdAt})`);
+            }
+            const result = await runAdb(ctx, cfg, ['install', '-r', target.apk], { signal: exec.signal, serial: args.serial });
+            if (result.exitCode !== 0)
+                throw classifyFailure(result);
+            return {
+                command: 'rollback',
+                rolledBack: {
+                    to: target.apk,
+                    from: target.createdAt,
+                    note: target.note,
+                },
+                message: `reinstalled ${target.apk} on ${device}`,
+            };
+        },
+    });
+}

package/lib/tools/wait.d.ts

@@ -0,0 +1,42 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type AdbConfig } from '../adb.js';
+import { type AdbDevice } from '../parsers/devices.js';
+import { type LogcatEntry } from '../parsers/logcat.js';
+import { type ProcessEntry } from '../parsers/sysinfo.js';
+/**
+ * adb_wait_for: wait until a device reaches a condition, instead of sleeping a
+ * fixed number of seconds. Conditions: device-online, boot-complete, process
+ * (a process appears), logcat-pattern (a keyword appears). Polls at
+ * `intervalMs` until `timeoutMs`, then returns `matched: false` (not an error)
+ * so the agent can react to the timeout instead of guessing.
+ */
+export type WaitCondition = 'device-online' | 'boot-complete' | 'process' | 'logcat-pattern';
+export interface WaitArgs {
+    serial?: string;
+    condition: WaitCondition;
+    /** Substring matched against process names (condition=process) or logcat tag/message (condition=logcat-pattern). */
+    pattern?: string;
+    /** Overall wait budget in milliseconds; defaults to 30000, capped at 300000. */
+    timeoutMs?: number;
+    /** Poll interval in milliseconds; defaults to 1000. */
+    intervalMs?: number;
+}
+export interface WaitResult {
+    condition: WaitCondition;
+    matched: boolean;
+    waitedMs: number;
+    attempts: number;
+    reason?: string;
+}
+/** device-online: the serial is present in `adb devices -l` with state `device`. */
+export declare function checkDeviceOnline(devices: AdbDevice[], serial?: string): boolean;
+/** boot-complete: `getprop sys.boot_completed` output is exactly "1". */
+export declare function checkBootComplete(getpropOut: string): boolean;
+/** process: any process name contains the pattern. */
+export declare function checkProcessPresent(processes: ProcessEntry[], pattern: string): boolean;
+/** logcat-pattern: any entry's tag or message contains the keyword. */
+export declare function checkLogcatKeyword(entries: LogcatEntry[], keyword: string): boolean;
+/** Wait until the condition holds or the budget expires (returns matched:false on timeout). */
+export declare function waitForCondition(ctx: Context, cfg: AdbConfig, signal: AbortSignal, args: WaitArgs): Promise<WaitResult>;
+/** adb_wait_for: wait until a device condition holds (online / boot complete / process / logcat keyword). */
+export declare function registerWaitTool(ctx: Context, cfg: AdbConfig): void;

package/lib/tools/wait.js

@@ -0,0 +1,144 @@
+import { classifyFailure, jsonOutput, runAdb } from '../adb.js';
+import { parseDevices } from '../parsers/devices.js';
+import { parseLogcat } from '../parsers/logcat.js';
+import { parseProcessList } from '../parsers/sysinfo.js';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_TIMEOUT_MS = 300_000;
+const DEFAULT_INTERVAL_MS = 1_000;
+// ---- Pure condition checks (unit-tested) ----
+/** device-online: the serial is present in `adb devices -l` with state `device`. */
+export function checkDeviceOnline(devices, serial) {
+    return devices.some((device) => {
+        if (serial !== undefined && device.serial !== serial)
+            return false;
+        return device.state === 'device';
+    });
+}
+/** boot-complete: `getprop sys.boot_completed` output is exactly "1". */
+export function checkBootComplete(getpropOut) {
+    return getpropOut.trim() === '1';
+}
+/** process: any process name contains the pattern. */
+export function checkProcessPresent(processes, pattern) {
+    return processes.some((entry) => entry.name.includes(pattern));
+}
+/** logcat-pattern: any entry's tag or message contains the keyword. */
+export function checkLogcatKeyword(entries, keyword) {
+    return entries.some((entry) => entry.tag.includes(keyword) || entry.message.includes(keyword));
+}
+// ---- Poll loop ----
+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 });
+    });
+}
+/** Run one adb probe for the condition; returns true when satisfied. */
+async function probe(ctx, cfg, args, signal) {
+    const serial = args.serial;
+    switch (args.condition) {
+        case 'device-online': {
+            const result = await runAdb(ctx, cfg, ['devices', '-l'], { signal, maxBytes: 1024 * 1024 });
+            if (result.exitCode !== 0)
+                throw classifyFailure(result);
+            return checkDeviceOnline(parseDevices(result.stdout), args.serial);
+        }
+        case 'boot-complete': {
+            const result = await runAdb(ctx, cfg, ['shell', 'getprop', 'sys.boot_completed'], { signal, serial });
+            if (result.exitCode !== 0)
+                throw classifyFailure(result);
+            return checkBootComplete(result.stdout);
+        }
+        case 'process': {
+            const result = await runAdb(ctx, cfg, ['shell', 'ps', '-A'], { signal, serial, maxBytes: 2 * 1024 * 1024 });
+            if (result.exitCode !== 0)
+                throw classifyFailure(result);
+            return checkProcessPresent(parseProcessList(result.stdout), args.pattern);
+        }
+        case 'logcat-pattern': {
+            const result = await runAdb(ctx, cfg, ['logcat', '-v', 'threadtime', '-d'], { signal, serial, maxBytes: 8 * 1024 * 1024 });
+            if (result.exitCode !== 0)
+                throw classifyFailure(result);
+            return checkLogcatKeyword(parseLogcat(result.stdout), args.pattern);
+        }
+        default:
+            throw new Error(`unknown condition: ${String(args.condition)}`);
+    }
+}
+/** Validate args that fail fast — before the poll loop so they surface as errors, not timeouts. */
+function validateArgs(args) {
+    if (!['device-online', 'boot-complete', 'process', 'logcat-pattern'].includes(args.condition)) {
+        throw new Error(`unknown condition: ${String(args.condition)}`);
+    }
+    if ((args.condition === 'process' || args.condition === 'logcat-pattern') && (args.pattern === undefined || args.pattern === '')) {
+        throw new Error(`condition "${args.condition}" requires a non-empty "pattern"`);
+    }
+}
+/** Wait until the condition holds or the budget expires (returns matched:false on timeout). */
+export async function waitForCondition(ctx, cfg, signal, args) {
+    validateArgs(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;
+    let attempts = 0;
+    let lastProbe;
+    while (true) {
+        attempts++;
+        try {
+            const satisfied = await probe(ctx, cfg, args, signal);
+            if (satisfied) {
+                return { condition: args.condition, matched: true, waitedMs: Date.now() - start, attempts };
+            }
+        }
+        catch (error) {
+            // A transient probe failure (device offline mid-wait) is not terminal:
+            // keep polling until the budget, but record the reason.
+            lastProbe = error instanceof Error ? error.message : String(error);
+        }
+        if (Date.now() >= deadline) {
+            return {
+                condition: args.condition,
+                matched: false,
+                waitedMs: timeoutMs,
+                attempts,
+                ...(lastProbe !== undefined ? { reason: lastProbe } : { reason: `condition not met within ${timeoutMs}ms` }),
+            };
+        }
+        await sleep(Math.min(intervalMs, deadline - Date.now()), signal);
+    }
+}
+/** adb_wait_for: wait until a device condition holds (online / boot complete / process / logcat keyword). */
+export function registerWaitTool(ctx, cfg) {
+    ctx.tools.register({
+        name: 'adb_wait_for',
+        description: 'Wait until a device reaches a condition, then return — instead of sleeping a fixed number of seconds. Conditions: device-online (device is in `adb devices` with state `device`), boot-complete (sys.boot_completed=1), process (a process whose name contains `pattern` appears in ps), logcat-pattern (a keyword appears in logcat tag/message). Polls every `intervalMs` up to `timeoutMs`; on timeout returns matched:false (not an error) so you can react. Use it to sequence multi-step device flows: install → wait for process → snapshot.',
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['condition'],
+            properties: {
+                condition: {
+                    type: 'string',
+                    enum: ['device-online', 'boot-complete', 'process', 'logcat-pattern'],
+                    description: 'Which condition to wait for.',
+                },
+                serial: { type: 'string', description: 'Target device serial; defaults to the plugin defaultSerial. For device-online, omit serial to wait for ANY device to come online.' },
+                pattern: { type: 'string', description: 'Required for process (process-name substring) and logcat-pattern (keyword).' },
+                timeoutMs: { type: 'integer', description: 'Overall wait budget in milliseconds; defaults to 30000, capped at 300000.' },
+                intervalMs: { type: 'integer', description: 'Poll interval in milliseconds; defaults to 1000, minimum 250.' },
+            },
+        },
+        output: jsonOutput(),
+        async execute(args, exec) {
+            return waitForCondition(ctx, cfg, exec.signal, args);
+        },
+    });
+}

package/package.json

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