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 refused activity launch reports

morluto46111dd091f2
diff --git a/src/adb/AdbCommand.ts b/src/adb/AdbCommand.ts
index c3c9f7427..f3988ba97 100644
--- a/src/adb/AdbCommand.ts
+++ b/src/adb/AdbCommand.ts
@@ -63,10 +63,19 @@ class AdbProtocolError extends AnalysisProtocolError {
readonly commandFailure: ExecFileOutputFailure,
cause: unknown,
) {
- super(message, { cause });
+ super(message, {
+ cause,
+ capturedOutput: adbCommandCapturedOutput(commandFailure),
+ });
}
}
+/** Return the retained process result only for command failures owned here. */
+export const adbCommandOutputFailure = (
+ error: AnalysisError,
+): ExecFileOutputFailure | undefined =>
+ error instanceof AdbProtocolError ? error.commandFailure : undefined;
+
/** adb joins shell operands into a remote POSIX command; quote at that boundary. */
const quoteShellOperand = (value: string): string =>
/^[A-Za-z0-9_./:=@+,-]+$/u.test(value)
diff --git a/src/adb/AdbProvider.ts b/src/adb/AdbProvider.ts
index 1b9f23793..30b2ebc68 100644
--- a/src/adb/AdbProvider.ts
+++ b/src/adb/AdbProvider.ts
@@ -77,6 +77,8 @@ import {
runtimeControlCapabilityError,
} from "../process/RuntimeControlUnavailableError.js";
import {
+ adbCommandCapturedOutput,
+ adbCommandOutputFailure,
adbArguments,
runAdb,
runAdbCapture,
@@ -2848,11 +2850,37 @@ export class AdbProvider {
{ timeoutMs: SHELL_TIMEOUT_MS, maxOutputBytes: PM_PATH_MAX_OUTPUT_BYTES },
signal,
);
- if (!started.ok) return started;
- const verdict = parseAmStartOutput(
- started.value.stdout,
- started.value.stderr,
- );
+ let stdout: string;
+ let stderr: string;
+ let capturedOutput: ReturnType<typeof adbCommandCapturedOutput>;
+ let verdict: ReturnType<typeof parseAmStartOutput>;
+ if (started.ok) {
+ stdout = started.value.stdout;
+ stderr = started.value.stderr;
+ capturedOutput = { stdout, stderr, truncated: false };
+ verdict = parseAmStartOutput(stdout, stderr);
+ } else {
+ const commandFailure = adbCommandOutputFailure(started.error);
+ // AOSP ActivityManagerShellCommand returns 1 for class-not-found and
+ // emits its refusal report on stdout. Other exits remain command errors.
+ if (
+ commandFailure === undefined ||
+ commandFailure.code !== 1 ||
+ commandFailure.signal !== null ||
+ commandFailure.killed ||
+ commandFailure.outputTruncated ||
+ commandFailure.collectionFailure === true
+ )
+ return started;
+ stdout = commandFailure.stdout;
+ stderr = commandFailure.stderr;
+ capturedOutput = adbCommandCapturedOutput(commandFailure);
+ // Stderr carries adb transport diagnostics, not the Activity Manager
+ // report, so it cannot establish a target refusal on this path.
+ verdict = parseAmStartOutput(stdout);
+ if (verdict.status !== "refused" || verdict.startedActivity === null)
+ return started;
+ }
const result = {
...resultFields,
started_activity: verdict.startedActivity,
@@ -2877,22 +2905,15 @@ export class AdbProvider {
operation,
serial,
verdict.reason ?? "am start refused the intent",
- {
- capturedOutput: {
- stdout: started.value.stdout,
- stderr: started.value.stderr,
- truncated: false,
- },
- partialObservation,
- },
+ { capturedOutput, partialObservation },
),
);
}
return ok(
createAnalysisExecution(result, provider, {
rawResult: {
- stdout: started.value.stdout,
- stderr: started.value.stderr,
+ stdout,
+ stderr,
},
limitations: [
"Starting an activity changes device state; am start -W waits for launch completion but no lifecycle observation is captured",
diff --git a/src/domain/adb/adbDeviceAnalysis.test.ts b/src/domain/adb/adbDeviceAnalysis.test.ts
index 82ce18f8f..c67a9cc72 100644
--- a/src/domain/adb/adbDeviceAnalysis.test.ts
+++ b/src/domain/adb/adbDeviceAnalysis.test.ts
@@ -33,7 +33,7 @@ it("preserves ADB key, action and component admission when making advertised pat
.success,
},
{
- previous: /^[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]*)?$/u,
+ previous: /^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._$-]*)?$/u,
max: 512,
accepts: (component: string) =>
adbInputSchemas.start_adb_activity.safeParse({
@@ -52,6 +52,8 @@ it("preserves ADB key, action and component admission when making advertised pat
"-",
"android.intent.action.VIEW",
"com.example/.MainActivity",
+ "com.example/.Outer$InnerActivity",
+ "com.example.Outer$InnerActivity",
"com.example/",
"com.example/a/b",
"a\n",
diff --git a/src/domain/adb/adbDeviceAnalysis.ts b/src/domain/adb/adbDeviceAnalysis.ts
index b0effcf2b..9b068c73b 100644
--- a/src/domain/adb/adbDeviceAnalysis.ts
+++ b/src/domain/adb/adbDeviceAnalysis.ts
@@ -319,7 +319,7 @@ export const adbInputSchemas = {
.min(1)
.max(512)
.regex(
- /^[A-Za-z0-9._\x2d]+(\/[A-Za-z0-9._\x2d]*)?$/u,
+ /^[A-Za-z0-9._\x2d]+(?:\/[A-Za-z0-9._$\x2d]*)?$/u,
"Component must be package/activity form",
)
.optional()
diff --git a/tests/boundary/cli/adbCli.test.ts b/tests/boundary/cli/adbCli.test.ts
index d26123b9e..dfb947d63 100644
--- a/tests/boundary/cli/adbCli.test.ts
+++ b/tests/boundary/cli/adbCli.test.ts
@@ -143,6 +143,54 @@ it.each(["string:key", ":", "string"])(
},
);
+it.skipIf(process.platform === "win32")(
+ "starts an explicitly selected nested Android activity through the CLI",
+ async () => {
+ const workspace = await createTestWorkspace("rea-adb-nested-activity-cli-");
+ onTestFinished(() => removeTestWorkspace(workspace.root));
+ const adb = await workspace.write(
+ "adb",
+ `#!/bin/sh
+if [ "$1" = version ]; then
+ printf 'Android Debug Bridge version 1.0.41\\nVersion 34.0.5-cli\\n'
+ exit 0
+fi
+if [ "$1" = -s ] && [ "$3" = shell ]; then
+ printf '%s\\n' 'Starting: Intent { act=android.intent.action.MAIN cmp=com.example/.Outer$InnerActivity }' 'Status: ok' 'Activity: com.example/.Outer$InnerActivity' 'Complete'
+ exit 0
+fi
+exit 1
+`,
+ );
+ await chmod(adb, 0o755);
+
+ const result = await serve(
+ [
+ "start-adb-activity",
+ "emulator-5554",
+ "android.intent.action.MAIN",
+ "--component",
+ "com.example/.Outer$InnerActivity",
+ "--format",
+ "json",
+ "--full-output",
+ ],
+ { REA_ADB_PATH: adb },
+ );
+ expect(result.exitCode).toBe(0);
+ const output = JSON.parse(result.stdout);
+ expect(output.ok).toBe(true);
+ expect(
+ toolContract("start_adb_activity").outputSchema.parse(output.data)
+ .normalized_result,
+ ).toMatchObject({
+ component: "com.example/.Outer$InnerActivity",
+ started_activity:
+ "act=android.intent.action.MAIN cmp=com.example/.Outer$InnerActivity",
+ });
+ },
+);
+
it.each([
["bogus:key:value", "invalid_request"],
["string:key:value", "capability_unavailable"],
diff --git a/tests/boundary/mcp/adbStartMcp.test.ts b/tests/boundary/mcp/adbStartMcp.test.ts
index 098bcefc0..a6a853063 100644
--- a/tests/boundary/mcp/adbStartMcp.test.ts
+++ b/tests/boundary/mcp/adbStartMcp.test.ts
@@ -30,9 +30,10 @@ const createFakeAdb = async () => {
const stdoutFile = join(directory, "stdout");
const stderrFile = join(directory, "stderr");
const callsFile = join(directory, "calls");
+ const exitCodeFile = join(directory, "exit-code");
const fakeAdbSource = `#!/usr/bin/env node
const fs = require("node:fs");
-const [stdoutPath, stderrPath, callsPath] = ${JSON.stringify([stdoutFile, stderrFile, callsFile])};
+const [stdoutPath, stderrPath, callsPath, exitCodePath] = ${JSON.stringify([stdoutFile, stderrFile, callsFile, exitCodeFile])};
const args = process.argv.slice(2);
fs.appendFileSync(callsPath, args.join(" ") + "\\n");
if (args[0] === "version") {
@@ -42,6 +43,7 @@ if (args[0] === "version") {
} else {
process.stdout.write(fs.readFileSync(stdoutPath, "utf8"));
process.stderr.write(fs.readFileSync(stderrPath, "utf8"));
+ if (args.includes("start")) process.exitCode = Number(fs.readFileSync(exitCodePath, "utf8"));
}
`;
await writeFile(binary, fakeAdbSource);
@@ -49,9 +51,10 @@ if (args[0] === "version") {
return {
binary,
calls: async () => (await readFile(callsFile, "utf8")).trim().split("\n"),
- setReport: async (stdout: string, stderr: string) => {
+ setReport: async (stdout: string, stderr: string, exitCode = 0) => {
await writeFile(stdoutFile, stdout);
await writeFile(stderrFile, stderr);
+ await writeFile(exitCodeFile, String(exitCode));
},
};
};
@@ -243,3 +246,163 @@ it
);
},
);
+
+it.skipIf(process.platform === "win32")(
+ "retains nonzero Activity Manager refusals and leaves transport failures distinct through MCP",
+ async () => {
+ const fakeAdb = await createFakeAdb();
+ const stdout =
+ "Starting: Intent { act=android.intent.action.MAIN cmp=com.example/.Outer$InnerActivity }\n" +
+ "Error type 3\n" +
+ "Error: Activity class {com.example/com.example.Outer$InnerActivity} does not exist.\n";
+ await fakeAdb.setReport(stdout, "", 1);
+
+ const server = createServer(
+ {
+ kind: "session",
+ session: createTestBinarySession(() => {
+ throw new Error("ADB start must not open a deep-analysis provider");
+ }),
+ },
+ {
+ adbDeviceAnalysis: new AdbProvider({
+ environment: { REA_ADB_PATH: fakeAdb.binary },
+ }),
+ },
+ );
+ onTestFinished(() => server.close());
+ const [clientTransport, serverTransport] =
+ InMemoryTransport.createLinkedPair();
+ await server.connect(serverTransport);
+ const client = new Client({
+ name: "adb-start-refusal-mcp",
+ version: "0.0.0",
+ });
+ onTestFinished(() => client.close());
+ await client.connect(clientTransport);
+
+ const input = {
+ serial: "emulator-5554",
+ action: "android.intent.action.MAIN",
+ component: "com.example/.Outer$InnerActivity",
+ };
+ const advertised = (await client.listTools()).tools.find(
+ ({ name }) => name === "start_adb_activity",
+ );
+ if (advertised === undefined) throw new Error("Missing ADB activity tool");
+ const validateInput = new Ajv2020({
+ strict: false,
+ validateFormats: false,
+ }).compile(advertised.inputSchema);
+ expect(validateInput(input)).toBe(true);
+ const refused = await client.callTool({
+ name: "start_adb_activity",
+ arguments: input,
+ });
+ expect(refused.isError).toBe(true);
+ const refusal = analysisErrorProjectionSchema.parse(
+ JSON.parse(responseText(refused)).error,
+ );
+ expect(refusal).toMatchObject({
+ code: "unsupported_target",
+ details: {
+ path: "emulator-5554",
+ reason:
+ "Activity class {com.example/com.example.Outer$InnerActivity} does not exist.",
+ captured_output: { stdout, stderr: "", exit_code: 1, truncated: false },
+ partial_observation: {
+ provider_id: "adb",
+ operation: "start_adb_activity",
+ result: {
+ component: input.component,
+ started_activity:
+ "act=android.intent.action.MAIN cmp=com.example/.Outer$InnerActivity",
+ },
+ },
+ },
+ });
+
+ const transportStdout =
+ "Starting: Intent { act=android.intent.action.MAIN cmp=com.example/.Outer$InnerActivity }\n";
+ const transportStderr = "error: device offline\n";
+ await fakeAdb.setReport(transportStdout, transportStderr, 1);
+ const transport = await client.callTool({
+ name: "start_adb_activity",
+ arguments: input,
+ });
+ expect(transport.isError).toBe(true);
+ const transportError = analysisErrorProjectionSchema.parse(
+ JSON.parse(responseText(transport)).error,
+ );
+ expect(transportError).toMatchObject({
+ code: "unsupported_target",
+ details: { path: "emulator-5554", reason: "error: device offline" },
+ });
+ expect(transportError.details).not.toHaveProperty("partial_observation");
+
+ const incompleteStdout =
+ "Starting: Intent { act=android.intent.action.MAIN cmp=com.example/.Outer$InnerActivity }\n";
+ const incompleteStderr = "transport disconnected by peer\n";
+ await fakeAdb.setReport(incompleteStdout, incompleteStderr, 1);
+ const incomplete = await client.callTool({
+ name: "start_adb_activity",
+ arguments: input,
+ });
+ expect(incomplete.isError).toBe(true);
+ const incompleteError = analysisErrorProjectionSchema.parse(
+ JSON.parse(responseText(incomplete)).error,
+ );
+ expect(incompleteError).toMatchObject({
+ code: "unreadable_output",
+ details: {
+ captured_output: {
+ stdout: incompleteStdout,
+ stderr: incompleteStderr,
+ exit_code: 1,
+ truncated: false,
+ },
+ },
+ });
+ expect(incompleteError.details).not.toHaveProperty("partial_observation");
+
+ const stderrOnly =
+ "Error: Activity class {com.example/com.example.Outer$InnerActivity} does not exist.\n";
+ await fakeAdb.setReport("", stderrOnly, 1);
+ const stderrOnlyFailure = await client.callTool({
+ name: "start_adb_activity",
+ arguments: input,
+ });
+ expect(stderrOnlyFailure.isError).toBe(true);
+ const stderrOnlyError = analysisErrorProjectionSchema.parse(
+ JSON.parse(responseText(stderrOnlyFailure)).error,
+ );
+ expect(stderrOnlyError).toMatchObject({
+ code: "unreadable_output",
+ details: {
+ captured_output: {
+ stdout: "",
+ stderr: stderrOnly,
+ exit_code: 1,
+ truncated: false,
+ },
+ },
+ });
+ expect(stderrOnlyError.details).not.toHaveProperty("partial_observation");
+
+ const oversizedReport =
+ "Starting: Intent { act=android.intent.action.MAIN cmp=com.example/.Outer$InnerActivity }\n" +
+ "Error: " +
+ "x".repeat(70 * 1024);
+ await fakeAdb.setReport(oversizedReport, "", 1);
+ const truncated = await client.callTool({
+ name: "start_adb_activity",
+ arguments: input,
+ });
+ expect(truncated.isError).toBe(true);
+ const truncatedError = analysisErrorProjectionSchema.parse(
+ JSON.parse(responseText(truncated)).error,
+ );
+ expect(truncatedError.code).toBe("resource_constraint");
+ expect(truncatedError.details).not.toHaveProperty("partial_observation");
+ },
+);