Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(adb): retain cancellation at screen publication

morluto461eb1612822
diff --git a/docs/adb-device-analysis.md b/docs/adb-device-analysis.md
index 539a6f847..b18e7b4fb 100644
--- a/docs/adb-device-analysis.md
+++ b/docs/adb-device-analysis.md
@@ -175,6 +175,9 @@ and during shutdown.
- Cancellation during a package pull preserves caller-selected output. The
error includes partial observations identifying completed artifacts and the
interrupted local path; remaining APKs were not attempted.
+- Screen capture checks cancellation before publishing its exclusive output.
+ If cancellation arrives after publication, the error retains the committed
+ file's path, digest and dimensions; the file remains available as evidence.
- Bugreports collect into isolated staging and publish with exclusive creation;
filename collisions select the next numeric suffix. If publication fails, the
completed archive remains in staging. The error's partial observation gives
diff --git a/src/adb/AdbProvider.ts b/src/adb/AdbProvider.ts
index ea15a1fd1..fc6ce5282 100644
--- a/src/adb/AdbProvider.ts
+++ b/src/adb/AdbProvider.ts
@@ -2379,6 +2379,8 @@ export class AdbProvider {
signal,
);
if (!captured.ok) return captured;
+ if (signal?.aborted === true)
+ return err(new AnalysisCancelledError(operation));
const dimensions = parsePngDimensions(captured.value.stdout);
if (dimensions.width === null)
return err(
@@ -2400,25 +2402,30 @@ export class AdbProvider {
const sha256 = createHash("sha256")
.update(captured.value.stdout)
.digest("hex");
- return ok(
- createAnalysisExecution(
- {
- client,
- serial: input.serial,
- local_path: localPath,
- bytes: captured.value.stdout.byteLength,
- sha256,
- width: dimensions.width,
- height: dimensions.height,
- },
- provider,
- {
- limitations: [
- "The capture is one frame at read time; no recording or interaction occurred",
- ],
- },
- ),
+ const execution = createAnalysisExecution(
+ {
+ client,
+ serial: input.serial,
+ local_path: localPath,
+ bytes: captured.value.stdout.byteLength,
+ sha256,
+ width: dimensions.width,
+ height: dimensions.height,
+ },
+ provider,
+ {
+ limitations: [
+ "The capture is one frame at read time; no recording or interaction occurred",
+ ],
+ },
);
+ if (signal?.aborted)
+ return err(
+ new AnalysisCancelledError(operation, {
+ partialObservation: executionEvidence(execution, operation, input),
+ }),
+ );
+ return ok(execution);
}
private async collectBugreport(
diff --git a/tests/boundary/providers/adb/adbScreenPublicationCancellation.test.ts b/tests/boundary/providers/adb/adbScreenPublicationCancellation.test.ts
new file mode 100644
index 000000000..72aa620cd
--- /dev/null
+++ b/tests/boundary/providers/adb/adbScreenPublicationCancellation.test.ts
@@ -0,0 +1,119 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { afterEach, expect, onTestFinished, test, vi } from "vitest";
+
+import { AdbProvider } from "../../../../src/adb/AdbProvider.js";
+import { parseEvidence } from "../../../../src/domain/evidence.js";
+import {
+ execFileBytes,
+ execFileOutput,
+} from "../../../../src/process/ExecFileOutput.js";
+import { createTestTempDirectory } from "../../../fixtures/temporaryDirectory.js";
+
+vi.mock(
+ "../../../../src/process/ExecFileOutput.js",
+ async (importOriginal) => ({
+ ...(await importOriginal<
+ typeof import("../../../../src/process/ExecFileOutput.js")
+ >()),
+ execFileBytes: vi.fn(),
+ execFileOutput: vi.fn(),
+ }),
+);
+vi.mock("node:fs/promises", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("node:fs/promises")>();
+ return { ...actual, writeFile: vi.fn(actual.writeFile) };
+});
+
+afterEach(() => vi.restoreAllMocks());
+
+const fixture = async () => {
+ const root = await createTestTempDirectory("rea-adb-screen-cancel-");
+ const binary = join(root, "adb");
+ const stdout = `Android Debug Bridge version 1.0.41\nVersion 34.0.5-stub\nInstalled as ${binary}\n`;
+ vi.mocked(execFileOutput).mockResolvedValue({
+ stdout,
+ stderr: "",
+ stdoutBytes: Buffer.byteLength(stdout),
+ stderrBytes: 0,
+ });
+ const provider = new AdbProvider({ environment: { REA_ADB_PATH: binary } });
+ onTestFinished(() => provider.close());
+ return {
+ root,
+ provider,
+ png: Buffer.from(
+ "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jv4sAAAAASUVORK5CYII=",
+ "base64",
+ ),
+ };
+};
+
+test("does not publish a screen capture cancelled before the commit point", async () => {
+ const f = await fixture();
+ const controller = new AbortController();
+ vi.mocked(execFileBytes).mockImplementationOnce(async () => {
+ controller.abort();
+ return { stdout: f.png, stderr: Buffer.alloc(0) };
+ });
+ const output = join(f.root, "captures");
+ const result = await f.provider.execute(
+ {
+ operation: "capture_adb_screen",
+ input: { serial: "device", output_directory: output },
+ },
+ { signal: controller.signal },
+ );
+ expect(result.ok).toBe(false);
+ if (result.ok) throw new Error("expected cancellation");
+ expect(result.error._tag).toBe("AnalysisCancelledError");
+ await expect(readFile(join(output, "screen.png"))).rejects.toMatchObject({
+ code: "ENOENT",
+ });
+ await f.provider.close();
+});
+
+test("retains a committed screen capture receipt when cancellation arrives after commit", async () => {
+ const f = await fixture();
+ const controller = new AbortController();
+ vi.mocked(execFileBytes).mockResolvedValueOnce({
+ stdout: f.png,
+ stderr: Buffer.alloc(0),
+ });
+ const actualFs =
+ await vi.importActual<typeof import("node:fs/promises")>(
+ "node:fs/promises",
+ );
+ vi.mocked(writeFile).mockImplementationOnce(async (...args) => {
+ await actualFs.writeFile(...args);
+ controller.abort();
+ });
+ const output = join(f.root, "captures");
+ const result = await f.provider.execute(
+ {
+ operation: "capture_adb_screen",
+ input: { serial: "device", output_directory: output },
+ },
+ { signal: controller.signal },
+ );
+ expect(result.ok).toBe(false);
+ if (result.ok) throw new Error("expected cancellation");
+ expect(result.error._tag).toBe("AnalysisCancelledError");
+ const evidence = parseEvidence(result.error.partialObservation);
+ expect(evidence).toMatchObject({
+ provider: { id: "adb" },
+ operation: "capture_adb_screen",
+ confidence: "observed",
+ parameters: { serial: "device", output_directory: output },
+ normalized_result: {
+ local_path: join(output, "screen.png"),
+ bytes: f.png.byteLength,
+ sha256: createHash("sha256").update(f.png).digest("hex"),
+ width: 1,
+ height: 1,
+ },
+ });
+ expect(await readFile(join(output, "screen.png"))).toEqual(f.png);
+ await f.provider.close();
+});