@react-native-harness/platform-android 1.0.0 → 1.1.0-rc.1

package/dist/app-monitor.js

@@ -0,0 +1,358 @@
+import { escapeRegExp, getEmitter, logger, spawn, SubprocessError } from '@react-native-harness/tools';
+import * as adb from './adb.js';
+import { androidCrashParser } from './crash-parser.js';
+const getLogcatArgs = (uid, fromTime) => ['logcat', '-v', 'threadtime', '-b', 'crash', `--uid=${uid}`, '-T', fromTime];
+const MAX_RECENT_LOG_LINES = 200;
+const MAX_RECENT_CRASH_ARTIFACTS = 10;
+const CRASH_ARTIFACT_SETTLE_DELAY_MS = 100;
+const startProcPattern = (bundleId) => new RegExp(`Start proc (\\d+):${escapeRegExp(bundleId)}(?:/|\\s)`);
+const processPattern = (bundleId) => new RegExp(`Process:\\s*${escapeRegExp(bundleId)},\\s*PID:\\s*(\\d+)`);
+const nativeCrashPattern = (bundleId) => new RegExp(`>>>\\s*${escapeRegExp(bundleId)}\\s*<<<`);
+const processDiedPattern = (bundleId) => new RegExp(`Process\\s+${escapeRegExp(bundleId)}\\s+\\(pid\\s+(\\d+)\\)\\s+has\\s+died`, 'i');
+const getSignal = (line) => {
+    const namedSignalMatch = line.match(/\b(SIG[A-Z0-9]+)\b/);
+    if (namedSignalMatch) {
+        return namedSignalMatch[1];
+    }
+    const signalNumberMatch = line.match(/signal\s+(\d+)/i);
+    if (signalNumberMatch) {
+        return `signal ${signalNumberMatch[1]}`;
+    }
+    return undefined;
+};
+const getAndroidLogLineCrashDetails = ({ line, bundleId, pid, }) => {
+    const fatalExceptionMatch = line.match(/FATAL EXCEPTION:\s*(.+)$/i);
+    const processMatch = line.match(processPattern(bundleId));
+    return {
+        source: 'logs',
+        summary: line.trim(),
+        signal: getSignal(line),
+        exceptionType: fatalExceptionMatch?.[1]?.trim(),
+        processName: processMatch ? bundleId : line.includes(bundleId) ? bundleId : undefined,
+        pid: pid ?? (processMatch ? Number(processMatch[1]) : undefined),
+        rawLines: [line],
+    };
+};
+const CRASH_BLOCK_HEADER = '--------- beginning of crash';
+const getLatestCrashBlock = (recentLogLines) => {
+    const lines = recentLogLines.map(({ line }) => line);
+    let latestCrashHeaderIndex = -1;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (/FATAL EXCEPTION:|Process:\s+.+,\s+PID:/i.test(lines[index])) {
+            latestCrashHeaderIndex = index;
+            break;
+        }
+    }
+    const blockStartIndex = Math.max(lines.lastIndexOf(CRASH_BLOCK_HEADER), latestCrashHeaderIndex);
+    if (blockStartIndex === -1) {
+        return lines;
+    }
+    return lines.slice(blockStartIndex);
+};
+const getCrashBlockForArtifact = ({ artifact, recentLogLines, }) => {
+    const targetIndex = recentLogLines.findIndex(({ line, occurredAt }) => line === artifact.triggerLine &&
+        (artifact.triggerOccurredAt === undefined ||
+            occurredAt === artifact.triggerOccurredAt));
+    if (targetIndex === -1) {
+        return artifact.rawLines ?? [];
+    }
+    let blockStartIndex = targetIndex;
+    for (let index = targetIndex; index >= 0; index -= 1) {
+        const { line } = recentLogLines[index];
+        if (line === CRASH_BLOCK_HEADER) {
+            blockStartIndex = index;
+            break;
+        }
+    }
+    let blockEndIndex = recentLogLines.length;
+    for (let index = targetIndex + 1; index < recentLogLines.length; index += 1) {
+        if (recentLogLines[index].line === CRASH_BLOCK_HEADER) {
+            blockEndIndex = index;
+            break;
+        }
+    }
+    return recentLogLines
+        .slice(blockStartIndex, blockEndIndex)
+        .map(({ line }) => line);
+};
+const hydrateCrashArtifact = ({ artifact, recentLogLines, }) => {
+    const rawLines = getCrashBlockForArtifact({ artifact, recentLogLines });
+    if (rawLines.length === 0) {
+        return artifact;
+    }
+    const parsedDetails = androidCrashParser.parse({
+        contents: rawLines.join('\n'),
+        bundleId: artifact.processName ?? '',
+        pid: artifact.pid,
+    });
+    return {
+        ...artifact,
+        ...parsedDetails,
+        artifactType: artifact.artifactType,
+        artifactPath: artifact.artifactPath,
+        rawLines,
+    };
+};
+const createCrashArtifact = ({ details, recentLogLines, }) => {
+    const occurredAt = Date.now();
+    const rawLines = getLatestCrashBlock(recentLogLines);
+    const triggerOccurredAt = [...recentLogLines]
+        .reverse()
+        .find(({ line }) => line === details.summary)?.occurredAt;
+    const contents = rawLines.length > 0
+        ? rawLines.join('\n')
+        : (details.rawLines ?? []).join('\n');
+    const parsedDetails = details.processName !== undefined
+        ? androidCrashParser.parse({
+            contents,
+            bundleId: details.processName,
+            pid: details.pid,
+        })
+        : details;
+    return {
+        ...parsedDetails,
+        occurredAt,
+        triggerLine: details.summary ?? '',
+        triggerOccurredAt,
+        artifactType: 'logcat',
+        rawLines: rawLines.length > 0 ? rawLines : parsedDetails.rawLines ?? details.rawLines,
+    };
+};
+const persistCrashArtifact = ({ details, crashArtifactWriter, }) => {
+    if (!crashArtifactWriter || details.artifactType !== 'logcat') {
+        return details;
+    }
+    const artifactBody = details.rawLines?.join('\n');
+    if (!artifactBody) {
+        return details;
+    }
+    return {
+        ...details,
+        artifactPath: crashArtifactWriter.persistArtifact({
+            artifactKind: details.artifactType,
+            source: {
+                kind: 'text',
+                fileName: 'logcat.txt',
+                text: `${artifactBody}\n`,
+            },
+        }),
+    };
+};
+const getLatestCrashArtifact = ({ crashArtifacts, recentLogLines, processName, pid, occurredAt, }) => {
+    const matchingByPid = pid
+        ? crashArtifacts.filter((artifact) => artifact.pid === pid)
+        : [];
+    const matchingByProcess = processName
+        ? crashArtifacts.filter((artifact) => artifact.processName === processName)
+        : [];
+    const candidates = matchingByPid.length > 0
+        ? matchingByPid
+        : matchingByProcess.length > 0
+            ? matchingByProcess
+            : crashArtifacts;
+    const sortedCandidates = [...candidates].sort((left, right) => Math.abs(left.occurredAt - occurredAt) - Math.abs(right.occurredAt - occurredAt));
+    const artifact = sortedCandidates[0];
+    if (!artifact) {
+        return null;
+    }
+    return hydrateCrashArtifact({
+        artifact,
+        recentLogLines,
+    });
+};
+const createAndroidLogEvent = (line, bundleId) => {
+    const startMatch = line.match(startProcPattern(bundleId));
+    if (startMatch) {
+        return {
+            type: 'app_started',
+            pid: Number(startMatch[1]),
+            source: 'logs',
+            line,
+        };
+    }
+    const processMatch = line.match(processPattern(bundleId));
+    if (processMatch) {
+        return {
+            type: 'possible_crash',
+            pid: Number(processMatch[1]),
+            source: 'logs',
+            line,
+            crashDetails: getAndroidLogLineCrashDetails({
+                line,
+                bundleId,
+                pid: Number(processMatch[1]),
+            }),
+        };
+    }
+    if (nativeCrashPattern(bundleId).test(line)) {
+        return {
+            type: 'possible_crash',
+            source: 'logs',
+            line,
+            crashDetails: getAndroidLogLineCrashDetails({
+                line,
+                bundleId,
+            }),
+        };
+    }
+    const diedMatch = line.match(processDiedPattern(bundleId));
+    if (diedMatch) {
+        return {
+            type: 'app_exited',
+            pid: Number(diedMatch[1]),
+            source: 'logs',
+            line,
+            crashDetails: getAndroidLogLineCrashDetails({
+                line,
+                bundleId,
+                pid: Number(diedMatch[1]),
+            }),
+        };
+    }
+    if (line.includes(bundleId) &&
+        /fatal|crash|signal 11|signal 6|backtrace/i.test(line)) {
+        return {
+            type: 'possible_crash',
+            source: 'logs',
+            line,
+            crashDetails: getAndroidLogLineCrashDetails({
+                line,
+                bundleId,
+            }),
+        };
+    }
+    return null;
+};
+export const createAndroidAppMonitor = ({ adbId, bundleId, appUid, crashArtifactWriter, }) => {
+    const emitter = getEmitter();
+    let isStarted = false;
+    let logcatProcess = null;
+    let logTask = null;
+    let recentLogLines = [];
+    let recentCrashArtifacts = [];
+    const emit = (event) => {
+        emitter.emit(event);
+    };
+    const recordLogLine = (line) => {
+        recentLogLines = [...recentLogLines, { line, occurredAt: Date.now() }].slice(-MAX_RECENT_LOG_LINES);
+    };
+    const recordCrashArtifact = (details) => {
+        if (!details) {
+            return;
+        }
+        recentCrashArtifacts = [
+            ...recentCrashArtifacts,
+            createCrashArtifact({
+                details,
+                recentLogLines,
+            }),
+        ].slice(-MAX_RECENT_CRASH_ARTIFACTS);
+    };
+    const stopProcess = async (child) => {
+        if (!child) {
+            return;
+        }
+        try {
+            (await child.nodeChildProcess).kill();
+        }
+        catch {
+            // Ignore termination failures for background monitors.
+        }
+    };
+    const startLogcat = async () => {
+        const logcatTimestamp = await adb.getLogcatTimestamp(adbId);
+        logcatProcess = spawn('adb', ['-s', adbId, ...getLogcatArgs(appUid, logcatTimestamp)], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        const currentProcess = logcatProcess;
+        if (!currentProcess) {
+            return;
+        }
+        logTask = (async () => {
+            try {
+                for await (const line of currentProcess) {
+                    recordLogLine(line);
+                    emit({ type: 'log', source: 'logs', line });
+                    const event = createAndroidLogEvent(line, bundleId);
+                    if (event) {
+                        if (event.type === 'possible_crash' || event.type === 'app_exited') {
+                            recordCrashArtifact(event.crashDetails);
+                        }
+                        emit(event);
+                    }
+                }
+            }
+            catch (error) {
+                if (!(error instanceof SubprocessError && error.signalName === 'SIGTERM')) {
+                    logger.debug('Android logcat monitor stopped', error);
+                }
+            }
+        })();
+    };
+    const start = async () => {
+        if (isStarted) {
+            return;
+        }
+        try {
+            await startLogcat();
+            isStarted = true;
+        }
+        catch (error) {
+            const currentProcess = logcatProcess;
+            const currentTask = logTask;
+            logcatProcess = null;
+            logTask = null;
+            await stopProcess(currentProcess);
+            await currentTask;
+            throw error;
+        }
+    };
+    const stop = async () => {
+        if (!isStarted) {
+            return;
+        }
+        isStarted = false;
+        const currentProcess = logcatProcess;
+        const currentTask = logTask;
+        logcatProcess = null;
+        logTask = null;
+        await stopProcess(currentProcess);
+        await currentTask;
+    };
+    const dispose = async () => {
+        await stop();
+        emitter.clearAllListeners();
+        recentLogLines = [];
+        recentCrashArtifacts = [];
+    };
+    const addListener = (listener) => {
+        emitter.addListener(listener);
+    };
+    const removeListener = (listener) => {
+        emitter.removeListener(listener);
+    };
+    return {
+        start,
+        stop,
+        dispose,
+        addListener,
+        removeListener,
+        getCrashDetails: async (options) => {
+            await new Promise((resolve) => setTimeout(resolve, CRASH_ARTIFACT_SETTLE_DELAY_MS));
+            const details = getLatestCrashArtifact({
+                crashArtifacts: recentCrashArtifacts,
+                recentLogLines,
+                ...options,
+            });
+            if (!details) {
+                return null;
+            }
+            return persistCrashArtifact({
+                details,
+                crashArtifactWriter,
+            });
+        },
+    };
+};
+export { createAndroidLogEvent };

package/dist/config.d.ts

@@ -1,4 +1,11 @@
 import { z } from 'zod';
+export declare const AndroidAppLaunchOptionsSchema: z.ZodObject<{
+    extras: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+}, "strip", z.ZodTypeAny, {
+    extras?: Record<string, string | number | boolean> | undefined;
+}, {
+    extras?: Record<string, string | number | boolean> | undefined;
+}>;
 export declare const AndroidEmulatorAVDConfigSchema: z.ZodObject<{
     apiLevel: z.ZodNumber;
     profile: z.ZodString;
@@ -170,6 +177,13 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
     }>]>;
     bundleId: z.ZodString;
     activityName: z.ZodDefault<z.ZodString>;
+    appLaunchOptions: z.ZodOptional<z.ZodObject<{
+        extras: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+    }, "strip", z.ZodTypeAny, {
+        extras?: Record<string, string | number | boolean> | undefined;
+    }, {
+        extras?: Record<string, string | number | boolean> | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     device: {
@@ -188,6 +202,9 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
     };
     bundleId: string;
     activityName: string;
+    appLaunchOptions?: {
+        extras?: Record<string, string | number | boolean> | undefined;
+    } | undefined;
 }, {
     name: string;
     device: {
@@ -206,11 +223,15 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
     };
     bundleId: string;
     activityName?: string | undefined;
+    appLaunchOptions?: {
+        extras?: Record<string, string | number | boolean> | undefined;
+    } | undefined;
 }>;
 export type AndroidEmulator = z.infer<typeof AndroidEmulatorSchema>;
 export type PhysicalAndroidDevice = z.infer<typeof PhysicalAndroidDeviceSchema>;
 export type AndroidDevice = z.infer<typeof AndroidDeviceSchema>;
 export type AndroidPlatformConfig = z.infer<typeof AndroidPlatformConfigSchema>;
+export type AndroidAppLaunchOptions = z.infer<typeof AndroidAppLaunchOptionsSchema>;
 export type AndroidEmulatorAVDConfig = z.infer<typeof AndroidEmulatorAVDConfigSchema>;
 export declare const isAndroidDeviceEmulator: (device: AndroidDevice) => device is AndroidEmulator;
 export declare const isAndroidDevicePhysical: (device: AndroidDevice) => device is PhysicalAndroidDevice;

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAKzC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAItC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG9B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQtC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,eAEZ,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,qBAEZ,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,eAAe,CAInC;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,qBAAqB,CAIzC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,6BAA6B;;;;;;EAIxC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAKzC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAItC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG9B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,eAEZ,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,qBAEZ,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,eAAe,CAInC;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,qBAAqB,CAIzC"}

package/dist/config.js

@@ -1,4 +1,9 @@
 import { z } from 'zod';
+export const AndroidAppLaunchOptionsSchema = z.object({
+    extras: z
+        .record(z.union([z.string(), z.boolean(), z.number().int().safe()]))
+        .optional(),
+});
 export const AndroidEmulatorAVDConfigSchema = z.object({
     apiLevel: z.number().min(1, 'API level is required'),
     profile: z.string().min(1, 'Profile is required'),
@@ -27,6 +32,7 @@ export const AndroidPlatformConfigSchema = z.object({
         .string()
         .min(1, 'Activity name is required')
         .default('.MainActivity'),
+    appLaunchOptions: AndroidAppLaunchOptionsSchema.optional(),
 });
 export const isAndroidDeviceEmulator = (device) => {
     return device.type === 'emulator';

package/dist/crash-parser.d.ts

@@ -0,0 +1,11 @@
+import type { AppCrashDetails } from '@react-native-harness/platforms';
+type ParseAndroidCrashReportOptions = {
+    contents: string;
+    bundleId: string;
+    pid?: number;
+};
+export declare const androidCrashParser: {
+    parse({ contents, bundleId, pid, }: ParseAndroidCrashReportOptions): AppCrashDetails;
+};
+export {};
+//# sourceMappingURL=crash-parser.d.ts.map

package/dist/crash-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crash-parser.d.ts","sourceRoot":"","sources":["../src/crash-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAGvE,KAAK,8BAA8B,GAAG;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AA4BF,eAAO,MAAM,kBAAkB;wCAK1B,8BAA8B,GAAG,eAAe;CAyBpD,CAAC"}

package/dist/crash-parser.js

@@ -0,0 +1,39 @@
+import { escapeRegExp } from '@react-native-harness/tools';
+const getSignal = (contents) => {
+    const namedSignalMatch = contents.match(/\b(SIG[A-Z0-9]+)\b/);
+    if (namedSignalMatch) {
+        return namedSignalMatch[1];
+    }
+    const signalNumberMatch = contents.match(/signal\s+(\d+)/i);
+    if (signalNumberMatch) {
+        return `signal ${signalNumberMatch[1]}`;
+    }
+    return undefined;
+};
+const getStackTrace = (rawLines) => {
+    const frames = rawLines.filter((line) => /^\S.*(?:\s+at\s+|\s+#\d+\s+pc\s+)/.test(line.trim()) ||
+        /^\S.*AndroidRuntime:\s+at\s+/.test(line.trim()) ||
+        /^\S.*AndroidRuntime:\s+Caused by:/.test(line.trim()));
+    return frames.length > 0 ? frames : undefined;
+};
+export const androidCrashParser = {
+    parse({ contents, bundleId, pid, }) {
+        const rawLines = contents.split(/\r?\n/);
+        const processPattern = new RegExp(`Process:\\s*${escapeRegExp(bundleId)},\\s*PID:\\s*(\\d+)`);
+        const fatalExceptionMatch = contents.match(/FATAL EXCEPTION:\s*(.+)$/im);
+        const processMatch = contents.match(processPattern);
+        const runtimeExceptionLine = rawLines.find((line) => /AndroidRuntime: (?:java\.|kotlin\.|[\w$.]+(?:Exception|Error):)/.test(line));
+        const exceptionType = fatalExceptionMatch?.[1]?.trim() ??
+            runtimeExceptionLine?.match(/AndroidRuntime:\s+(.+)$/)?.[1]?.trim();
+        return {
+            source: 'logs',
+            summary: contents.trim(),
+            signal: getSignal(contents),
+            exceptionType,
+            processName: processMatch ? bundleId : contents.includes(bundleId) ? bundleId : undefined,
+            pid: pid ?? (processMatch ? Number(processMatch[1]) : undefined),
+            rawLines,
+            stackTrace: getStackTrace(rawLines),
+        };
+    },
+};

package/dist/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AACtD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAKrB,QAAA,MAAM,gBAAgB,GACpB,QAAQ,qBAAqB,EAC7B,eAAe,MAAM,KACpB,OAAO,CAAC,qBAAqB,CAiD/B,CAAC;AAEF,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AACtD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAMrB,QAAA,MAAM,gBAAgB,GACpB,QAAQ,qBAAqB,EAC7B,eAAe,MAAM,KACpB,OAAO,CAAC,qBAAqB,CA+D/B,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/runner.js

@@ -3,6 +3,7 @@ import { AndroidPlatformConfigSchema, } from './config.js';
 import { getAdbId } from './adb-id.js';
 import * as adb from './adb.js';
 import { getDeviceName } from './utils.js';
+import { createAndroidAppMonitor } from './app-monitor.js';
 const getAndroidRunner = async (config, harnessConfig) => {
     const parsedConfig = AndroidPlatformConfigSchema.parse(config);
     const adbId = await getAdbId(parsedConfig.device);
@@ -17,24 +18,35 @@ const getAndroidRunner = async (config, harnessConfig) => {
         adb.reversePort(adbId, 8081),
         adb.reversePort(adbId, 8080),
         adb.reversePort(adbId, harnessConfig.webSocketPort),
+        adb.setHideErrorDialogs(adbId, true),
     ]);
+    const appUid = await adb.getAppUid(adbId, parsedConfig.bundleId);
     return {
-        startApp: async () => {
-            await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName);
+        startApp: async (options) => {
+            await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName, options ??
+                parsedConfig.appLaunchOptions);
         },
-        restartApp: async () => {
+        restartApp: async (options) => {
             await adb.stopApp(adbId, parsedConfig.bundleId);
-            await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName);
+            await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName, options ??
+                parsedConfig.appLaunchOptions);
         },
         stopApp: async () => {
             await adb.stopApp(adbId, parsedConfig.bundleId);
         },
         dispose: async () => {
             await adb.stopApp(adbId, parsedConfig.bundleId);
+            await adb.setHideErrorDialogs(adbId, false);
         },
         isAppRunning: async () => {
             return await adb.isAppRunning(adbId, parsedConfig.bundleId);
         },
+        createAppMonitor: (options) => createAndroidAppMonitor({
+            adbId,
+            bundleId: parsedConfig.bundleId,
+            appUid,
+            crashArtifactWriter: options?.crashArtifactWriter,
+        }),
     };
 };
 export default getAndroidRunner;