@react-native-harness/platform-android 1.3.0 → 1.4.0

package/dist/app-session.js

@@ -0,0 +1,214 @@
+import { createAppSessionEmitter, createBoundedLogBuffer, } from '@react-native-harness/platforms';
+import { escapeRegExp, logger, } from '@react-native-harness/tools';
+import { createAndroidCrashReporter } from './crash-reporter.js';
+const androidAppSessionLogger = logger.child('android-app-session');
+const APP_EXIT_POLL_INTERVAL_MS = 1000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const getLogcatArgs = (appUid, fromTime) => [
+    'logcat',
+    '-v',
+    'threadtime',
+    '-b',
+    'crash',
+    `--uid=${appUid}`,
+    '-T',
+    fromTime,
+];
+const getProcessPattern = (bundleId) => new RegExp(`Process:\\s*${escapeRegExp(bundleId)},\\s*PID:\\s*(\\d+)`);
+const getStartProcPattern = (bundleId) => new RegExp(`Start proc (\\d+):${escapeRegExp(bundleId)}(?:/|\\s)`);
+const getProcessDiedPattern = (bundleId) => new RegExp(`Process\\s+${escapeRegExp(bundleId)}\\s+\\(pid\\s+(\\d+)\\)\\s+has\\s+died`, 'i');
+const getObservedPid = (line, bundleId) => {
+    const match = line.match(getProcessPattern(bundleId)) ??
+        line.match(getStartProcPattern(bundleId)) ??
+        line.match(getProcessDiedPattern(bundleId));
+    return match?.[1] ? Number(match[1]) : undefined;
+};
+const isCrashSignal = (line, bundleId) => {
+    return (getProcessPattern(bundleId).test(line) ||
+        new RegExp(`>>>\\s*${escapeRegExp(bundleId)}\\s*<<<`).test(line) ||
+        getProcessDiedPattern(bundleId).test(line) ||
+        (line.includes(bundleId) &&
+            /fatal|crash|signal 11|signal 6|backtrace/i.test(line)));
+};
+const isExitedState = (state) => state.status === 'exited';
+export const createAndroidAppSession = async ({ appUid, bundleId, startApp, stopApp, getAppPid, getLogcatTimestamp, startLogcat, getDropboxOutput, getExitInfo, crashArtifactWriter, signal, }) => {
+    const emitter = createAppSessionEmitter();
+    const logBuffer = createBoundedLogBuffer();
+    let state = { status: 'running' };
+    let disposed = false;
+    let stopPolling = false;
+    let hasObservedProcess = false;
+    let exitNotification = null;
+    let pollDelayTimeout = null;
+    let resolvePollDelay = null;
+    const getCurrentPid = () => ('pid' in state ? state.pid : undefined);
+    const setRunning = (pid) => {
+        if (disposed || state.status === 'disposed' || state.status === 'exited') {
+            return;
+        }
+        if (pid !== undefined) {
+            hasObservedProcess = true;
+        }
+        state =
+            pid === undefined ? { status: 'running' } : { status: 'running', pid };
+    };
+    const scheduleExitNotification = () => {
+        if (exitNotification) {
+            return;
+        }
+        exitNotification = setTimeout(() => {
+            exitNotification = null;
+            if (!disposed && state.status === 'exited') {
+                emitter.emit({ type: 'app_exited' });
+            }
+        }, 0);
+    };
+    const waitForNextPoll = () => new Promise((resolve) => {
+        resolvePollDelay = () => {
+            resolvePollDelay = null;
+            pollDelayTimeout = null;
+            resolve();
+        };
+        pollDelayTimeout = setTimeout(() => {
+            resolvePollDelay?.();
+        }, APP_EXIT_POLL_INTERVAL_MS);
+    });
+    const cancelPendingPollDelay = () => {
+        if (pollDelayTimeout) {
+            clearTimeout(pollDelayTimeout);
+            pollDelayTimeout = null;
+        }
+        resolvePollDelay?.();
+    };
+    const setExited = (reason, pid) => {
+        if (disposed || state.status === 'disposed' || state.status === 'exited') {
+            return;
+        }
+        state = {
+            status: 'exited',
+            occurredAt: Date.now(),
+            pid: pid ?? getCurrentPid(),
+            reason,
+        };
+        scheduleExitNotification();
+    };
+    const setExitedPid = (pid) => {
+        if (state.status !== 'exited' || state.pid !== undefined) {
+            return;
+        }
+        state = {
+            status: 'exited',
+            occurredAt: state.occurredAt,
+            reason: state.reason,
+            pid,
+        };
+    };
+    const logcatTimestamp = await getLogcatTimestamp();
+    const sessionStartedAt = Date.now();
+    const logcatAbortController = new AbortController();
+    const logcatSignal = signal
+        ? AbortSignal.any([signal, logcatAbortController.signal])
+        : logcatAbortController.signal;
+    const logcatProcess = startLogcat(getLogcatArgs(appUid, logcatTimestamp), {
+        signal: logcatSignal,
+    });
+    // Aborting is nano-spawn's own cancellation path, so the resulting
+    // SubprocessError is settled the same way regardless of which of the
+    // merged stdout/stderr iterators observes it first. Without this, killing
+    // the underlying process directly can make both iterators reject at once,
+    // and nano-spawn's internal `Promise.race` only reports one of them,
+    // leaving the other an unhandled rejection.
+    logcatProcess.catch(() => undefined);
+    const crashReporter = createAndroidCrashReporter({
+        bundleId,
+        crashArtifactWriter,
+        getLogs: () => logBuffer.getLogs(),
+        getDropboxOutput,
+        getExitInfo,
+        minOccurredAt: sessionStartedAt,
+    });
+    const logTask = (async () => {
+        try {
+            for await (const rawLine of logcatProcess) {
+                const line = String(rawLine);
+                if (!disposed) {
+                    logBuffer.push(line);
+                }
+                const observedPid = getObservedPid(line, bundleId);
+                if (observedPid !== undefined) {
+                    if (state.status === 'running') {
+                        setRunning(observedPid);
+                    }
+                    else {
+                        setExitedPid(observedPid);
+                    }
+                }
+                if (state.status === 'running' && isCrashSignal(line, bundleId)) {
+                    setExited('observed-exit', observedPid);
+                }
+            }
+        }
+        catch (error) {
+            if (!disposed) {
+                androidAppSessionLogger.debug('Android logcat stream stopped', error);
+            }
+        }
+    })();
+    try {
+        await startApp();
+    }
+    catch (error) {
+        disposed = true;
+        stopPolling = true;
+        emitter.clear();
+        logcatAbortController.abort();
+        await Promise.allSettled([logTask]);
+        throw error;
+    }
+    const pollTask = (async () => {
+        await sleep(0);
+        while (!stopPolling) {
+            if (isExitedState(state)) {
+                return;
+            }
+            try {
+                const pid = await getAppPid();
+                if (pid != null) {
+                    setRunning(pid);
+                }
+                else if (hasObservedProcess) {
+                    setExited('process-gone');
+                    return;
+                }
+            }
+            catch (error) {
+                androidAppSessionLogger.debug('Android app session poll failed', error);
+            }
+            await waitForNextPoll();
+        }
+    })();
+    return {
+        dispose: async () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            stopPolling = true;
+            state = { status: 'disposed', occurredAt: Date.now() };
+            if (exitNotification) {
+                clearTimeout(exitNotification);
+                exitNotification = null;
+            }
+            cancelPendingPollDelay();
+            emitter.clear();
+            logcatAbortController.abort();
+            await stopApp();
+            await Promise.allSettled([logTask, pollTask]);
+        },
+        getState: async () => state,
+        getLogs: () => logBuffer.getLogs(),
+        getCrashDetails: crashReporter.getCrashDetails,
+        addListener: emitter.addListener,
+        removeListener: emitter.removeListener,
+    };
+};

package/dist/avd-config.d.ts

@@ -6,6 +6,7 @@ export type AvdConfig = {
     hwDeviceName?: string;
     diskDataPartitionSize?: string;
     vmHeapSize?: string;
+    hwCpuNcore?: string;
 };
 export type AvdCompatibilityResult = {
     compatible: true;

package/dist/avd-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"avd-config.d.ts","sourceRoot":"","sources":["../src/avd-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE7E,MAAM,MAAM,SAAS,GAAG;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAC9B;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE,GACpB;IAAE,UAAU,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MAI9C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,MAE/C,CAAC;AAkEF,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,KAAG,SAyCjD,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,MAAM,MAAM,KACX,OAAO,CAAC,SAAS,GAAG,IAAI,CAU1B,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,oCAI7B;IACD,QAAQ,EAAE,eAAe,CAAC;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,sBAAsB,CAAC;CAClC,KAAG,sBAmFH,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,yBAGzC;IACD,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,sBAAsB,CAAC;CAClC,KAAG;IACF,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,sBAAsB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,IAeH,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,8BAItC;IACD,GAAG,CAAC,EAAE,wBAAwB,CAAC;IAC/B,aAAa,EAAE,OAAO,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB,KAAG,OAWH,CAAC"}
+{"version":3,"file":"avd-config.d.ts","sourceRoot":"","sources":["../src/avd-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAG7E,MAAM,MAAM,SAAS,GAAG;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAC9B;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE,GACpB;IAAE,UAAU,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MAI9C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,MAE/C,CAAC;AAkEF,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,KAAG,SA4CjD,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,MAAM,MAAM,KACX,OAAO,CAAC,SAAS,GAAG,IAAI,CAU1B,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,oCAI7B;IACD,QAAQ,EAAE,eAAe,CAAC;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,sBAAsB,CAAC;CAClC,KAAG,sBA+FH,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,yBAGzC;IACD,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,sBAAsB,CAAC;CAClC,KAAG;IACF,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,sBAAsB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,IAeH,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,8BAItC;IACD,GAAG,CAAC,EAAE,wBAAwB,CAAC;IAC/B,aAAa,EAAE,OAAO,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB,KAAG,OAWH,CAAC"}

package/dist/avd-config.js

@@ -1,4 +1,5 @@
 import { access, readFile } from 'node:fs/promises';
+import { getEmulatorCpuCores } from './emulator-startup.js';
 export const getAvdDirectory = (name) => {
     return `${process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`}/${name}.avd`;
 };
@@ -81,6 +82,9 @@ export const parseAvdConfig = (contents) => {
             case 'vm.heapSize':
                 config.vmHeapSize = value;
                 break;
+            case 'hw.cpu.ncore':
+                config.hwCpuNcore = value;
+                break;
             default:
                 break;
         }
@@ -146,6 +150,13 @@ export const isAvdCompatible = ({ emulator, avdConfig, hostArch, }) => {
             reason: `Heap size mismatch: expected ${requestedAvdConfig.heapSize}, got ${avdConfig.vmHeapSize ?? 'missing'}.`,
         };
     }
+    if (normalizeConfigValue(avdConfig.hwCpuNcore ?? '') !==
+        normalizeConfigValue(String(getEmulatorCpuCores()))) {
+        return {
+            compatible: false,
+            reason: `CPU core count mismatch: expected ${getEmulatorCpuCores()}, got ${avdConfig.hwCpuNcore ?? 'missing'}.`,
+        };
+    }
     return { compatible: true };
 };
 export const getNormalizedAvdCacheConfig = ({ emulator, hostArch, }) => {

package/dist/crash-diagnostics.d.ts

@@ -0,0 +1,40 @@
+import type { AppCrashDetails, CrashArtifactWriter, CrashDetailsLookupOptions, CrashEnrichmentArtifact } from '@react-native-harness/platforms';
+export declare const DROPBOX_CRASH_TAGS: readonly ["data_app_crash", "data_app_native_crash"];
+export type DropboxEntry = {
+    tag: string;
+    timestamp: string;
+    content: string;
+    pid?: number;
+    processName?: string;
+};
+export type DropboxCrashArtifact = AppCrashDetails & {
+    artifactType: 'dropbox-crash' | 'dropbox-native-crash';
+    dropboxTag: string;
+    occurredAt: number;
+    score?: number;
+};
+type CollectDropboxArtifactsOptions = {
+    bundleId: string;
+    crashArtifactWriter?: CrashArtifactWriter;
+    getDropboxOutput: () => Promise<string>;
+    minOccurredAt?: number;
+};
+type WaitForDropboxArtifactsOptions = CollectDropboxArtifactsOptions & CrashDetailsLookupOptions;
+export declare const parseDropboxOutput: (output: string) => DropboxEntry[];
+export declare const collectDropboxArtifacts: ({ bundleId, crashArtifactWriter, getDropboxOutput, minOccurredAt, ...lookup }: WaitForDropboxArtifactsOptions) => Promise<DropboxCrashArtifact[]>;
+export declare const waitForDropboxArtifacts: (options: WaitForDropboxArtifactsOptions) => Promise<DropboxCrashArtifact[]>;
+export declare const filterExitInfo: ({ output, bundleId, pid, }: {
+    output: string;
+    bundleId: string;
+    pid?: number;
+}) => string | null;
+export declare const collectExitInfoArtifact: ({ bundleId, crashArtifactWriter, getExitInfo, pid, testFilePath, }: {
+    bundleId: string;
+    crashArtifactWriter?: CrashArtifactWriter;
+    getExitInfo: () => Promise<string>;
+    pid?: number;
+    testFilePath?: string;
+}) => Promise<CrashEnrichmentArtifact | null>;
+export declare const getBestDropboxArtifact: (artifacts: DropboxCrashArtifact[]) => DropboxCrashArtifact | null;
+export {};
+//# sourceMappingURL=crash-diagnostics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crash-diagnostics.d.ts","sourceRoot":"","sources":["../src/crash-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,iCAAiC,CAAC;AAWzC,eAAO,MAAM,kBAAkB,sDAGrB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG;IACnD,YAAY,EAAE,eAAe,GAAG,sBAAsB,CAAC;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,8BAA8B,GAAG;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,gBAAgB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,KAAK,8BAA8B,GAAG,8BAA8B,GAClE,yBAAyB,CAAC;AA2D5B,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,KAAG,YAAY,EAgD/D,CAAC;AAkKF,eAAO,MAAM,uBAAuB,GAAU,+EAM3C,8BAA8B,KAAG,OAAO,CAAC,oBAAoB,EAAE,CA6BjE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,SAAS,8BAA8B,KACtC,OAAO,CAAC,oBAAoB,EAAE,CAqBhC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,4BAI5B;IACD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,KAAG,MAAM,GAAG,IAgCZ,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,oEAM3C;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,WAAW,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,KAAG,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAmCzC,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,WAAW,oBAAoB,EAAE,KAChC,oBAAoB,GAAG,IAEpB,CAAC"}

package/dist/crash-diagnostics.js

@@ -0,0 +1,256 @@
+import { escapeRegExp, logger } from '@react-native-harness/tools';
+import { androidCrashParser } from './crash-parser.js';
+const crashDiagnosticsLogger = logger.child('android-crash-diagnostics');
+const DROPBOX_ENTRY_HEADER = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d{3})?) (\S+) \(text, \d+ bytes\)/;
+const DROPBOX_POLL_INTERVAL_MS = 1500;
+const DROPBOX_WAIT_TIMEOUT_MS = 10000;
+export const DROPBOX_CRASH_TAGS = [
+    'data_app_crash',
+    'data_app_native_crash',
+];
+const getDropboxArtifactType = (tag) => tag === 'data_app_native_crash' ? 'dropbox-native-crash' : 'dropbox-crash';
+const getDropboxFileName = (tag) => tag === 'data_app_native_crash'
+    ? 'dropbox-native-crash.txt'
+    : 'dropbox-crash.txt';
+const parseDropboxTimestamp = (timestamp) => {
+    const match = timestamp.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(?:\.(\d{3}))?$/);
+    if (!match) {
+        return 0;
+    }
+    const [, year, month, day, hour, minute, second, millis = '0'] = match;
+    return Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second), Number(millis));
+};
+const extractDropboxPid = (content) => {
+    const match = content.match(/^PID:\s*(\d+)/m) ?? content.match(/\bpid:\s*(\d+)/im);
+    return match ? Number(match[1]) : undefined;
+};
+const extractDropboxProcessName = (content, bundleId) => {
+    const processMatch = content.match(/^Process:\s*(\S+)/m);
+    const packageMatch = content.match(/^Package:\s*(\S+)/m);
+    if (processMatch?.[1] === bundleId) {
+        return processMatch[1];
+    }
+    if (packageMatch?.[1]?.startsWith(bundleId)) {
+        return bundleId;
+    }
+    return content.includes(bundleId) ? bundleId : undefined;
+};
+export const parseDropboxOutput = (output) => {
+    if (output.trim() === '') {
+        return [];
+    }
+    const sections = output.split(/^={10,}\s*$/m);
+    const entries = [];
+    for (const section of sections) {
+        const trimmedSection = section.trim();
+        if (trimmedSection === '') {
+            continue;
+        }
+        const lines = trimmedSection.split('\n');
+        const headerIndex = lines.findIndex((line) => DROPBOX_ENTRY_HEADER.test(line.trim()));
+        if (headerIndex === -1) {
+            continue;
+        }
+        const headerMatch = lines[headerIndex].trim().match(DROPBOX_ENTRY_HEADER);
+        if (!headerMatch) {
+            continue;
+        }
+        const [, timestamp, tag] = headerMatch;
+        const content = lines.slice(headerIndex + 1).join('\n').trim();
+        if (content === '') {
+            continue;
+        }
+        entries.push({
+            tag,
+            timestamp,
+            content,
+            pid: extractDropboxPid(content),
+        });
+    }
+    return entries;
+};
+const matchesDropboxEntry = ({ entry, bundleId, pid, }) => {
+    const processName = extractDropboxProcessName(entry.content, bundleId);
+    if (!processName) {
+        return false;
+    }
+    if (pid !== undefined && entry.pid !== undefined && entry.pid !== pid) {
+        return false;
+    }
+    return true;
+};
+const scoreDropboxEntry = ({ entry, bundleId, pid, occurredAt, }) => {
+    let score = 0;
+    if (extractDropboxProcessName(entry.content, bundleId) === bundleId) {
+        score += 100;
+    }
+    if (pid !== undefined && entry.pid === pid) {
+        score += 200;
+    }
+    const entryTimestamp = parseDropboxTimestamp(entry.timestamp);
+    if (entryTimestamp > 0) {
+        score -= Math.min(Math.abs(entryTimestamp - occurredAt) / 1000, 300);
+    }
+    if (entry.tag === 'data_app_native_crash') {
+        score += 25;
+    }
+    return score;
+};
+const toDropboxCrashArtifact = ({ entry, bundleId, pid, occurredAt, lookup, }) => {
+    const parsed = androidCrashParser.parse({
+        contents: entry.content,
+        bundleId,
+        pid: pid ?? entry.pid,
+    });
+    const artifactType = getDropboxArtifactType(entry.tag);
+    return {
+        ...parsed,
+        source: 'logs',
+        summary: entry.content,
+        rawLines: entry.content.split(/\r?\n/),
+        artifactType,
+        dropboxTag: entry.tag,
+        occurredAt,
+        score: scoreDropboxEntry({
+            entry,
+            bundleId,
+            pid: lookup?.pid ?? pid,
+            occurredAt: lookup?.occurredAt ?? occurredAt,
+        }),
+    };
+};
+const getMatchingDropboxEntries = ({ output, bundleId, pid, occurredAt, minOccurredAt, }) => parseDropboxOutput(output)
+    .filter((entry) => matchesDropboxEntry({ entry, bundleId, pid }))
+    .filter((entry) => {
+    const entryOccurredAt = parseDropboxTimestamp(entry.timestamp);
+    return (minOccurredAt === undefined ||
+        entryOccurredAt === 0 ||
+        entryOccurredAt >= minOccurredAt);
+})
+    .map((entry) => toDropboxCrashArtifact({
+    entry,
+    bundleId,
+    pid,
+    occurredAt: parseDropboxTimestamp(entry.timestamp) || occurredAt,
+}))
+    .sort((left, right) => {
+    if ((right.score ?? 0) !== (left.score ?? 0)) {
+        return (right.score ?? 0) - (left.score ?? 0);
+    }
+    return right.occurredAt - left.occurredAt;
+});
+const persistDropboxArtifact = ({ artifact, crashArtifactWriter, testFilePath, }) => {
+    if (!crashArtifactWriter) {
+        return artifact;
+    }
+    return {
+        ...artifact,
+        artifactPath: crashArtifactWriter.persistArtifact({
+            artifactKind: artifact.artifactType,
+            testFilePath,
+            source: {
+                kind: 'text',
+                fileName: getDropboxFileName(artifact.dropboxTag),
+                text: `${artifact.summary ?? ''}\n`,
+            },
+        }),
+    };
+};
+export const collectDropboxArtifacts = async ({ bundleId, crashArtifactWriter, getDropboxOutput, minOccurredAt, ...lookup }) => {
+    crashDiagnosticsLogger.debug('collecting dropbox crash artifacts: %o', {
+        bundleId,
+        pid: lookup.pid,
+        occurredAt: lookup.occurredAt,
+    });
+    let output = '';
+    try {
+        output = await getDropboxOutput();
+    }
+    catch (error) {
+        crashDiagnosticsLogger.debug('failed to read dropbox entries', error);
+        return [];
+    }
+    return getMatchingDropboxEntries({
+        output,
+        bundleId,
+        pid: lookup.pid,
+        occurredAt: lookup.occurredAt,
+        minOccurredAt,
+    }).map((artifact) => persistDropboxArtifact({
+        artifact,
+        crashArtifactWriter,
+        testFilePath: lookup.testFilePath,
+    }));
+};
+export const waitForDropboxArtifacts = async (options) => {
+    const deadline = Date.now() + DROPBOX_WAIT_TIMEOUT_MS;
+    let latestArtifacts = [];
+    while (Date.now() < deadline) {
+        latestArtifacts = await collectDropboxArtifacts(options);
+        if (latestArtifacts.length > 0) {
+            return latestArtifacts;
+        }
+        if (Date.now() >= deadline) {
+            return latestArtifacts;
+        }
+        await new Promise((resolve) => setTimeout(resolve, DROPBOX_POLL_INTERVAL_MS));
+    }
+    return latestArtifacts;
+};
+export const filterExitInfo = ({ output, bundleId, pid, }) => {
+    if (output.trim() === '' || /No exit info records/i.test(output)) {
+        return null;
+    }
+    const packagePattern = new RegExp(`\\bpackage=${escapeRegExp(bundleId)}\\b`, 'i');
+    if (!packagePattern.test(output)) {
+        return null;
+    }
+    const sections = output.split(/(?=ApplicationExitInfo\b)/);
+    const matchingSections = sections.filter((section) => {
+        if (!packagePattern.test(section)) {
+            return false;
+        }
+        if (pid === undefined) {
+            return true;
+        }
+        return new RegExp(`\\bpid=${pid}\\b`).test(section);
+    });
+    if (matchingSections.length === 0) {
+        return packagePattern.test(output) ? output.trim() : null;
+    }
+    return matchingSections.join('\n').trim();
+};
+export const collectExitInfoArtifact = async ({ bundleId, crashArtifactWriter, getExitInfo, pid, testFilePath, }) => {
+    let output = '';
+    try {
+        output = await getExitInfo();
+    }
+    catch (error) {
+        crashDiagnosticsLogger.debug('failed to read activity exit-info', error);
+        return null;
+    }
+    const filtered = filterExitInfo({ output, bundleId, pid });
+    if (!filtered) {
+        return null;
+    }
+    if (!crashArtifactWriter) {
+        return {
+            artifactType: 'exit-info',
+            artifactPath: filtered,
+        };
+    }
+    return {
+        artifactType: 'exit-info',
+        artifactPath: crashArtifactWriter.persistArtifact({
+            artifactKind: 'exit-info',
+            testFilePath,
+            source: {
+                kind: 'text',
+                fileName: 'exit-info.txt',
+                text: `${filtered}\n`,
+            },
+        }),
+    };
+};
+export const getBestDropboxArtifact = (artifacts) => [...artifacts].sort((left, right) => (right.score ?? 0) - (left.score ?? 0))[0] ??
+    null;

package/dist/crash-reporter.d.ts

@@ -0,0 +1,12 @@
+import type { AppCrashDetails, AppSessionLog, CrashArtifactWriter, CrashDetailsLookupOptions } from '@react-native-harness/platforms';
+export declare const createAndroidCrashReporter: ({ bundleId, crashArtifactWriter, getLogs, getDropboxOutput, getExitInfo, minOccurredAt, }: {
+    bundleId: string;
+    crashArtifactWriter?: CrashArtifactWriter;
+    getLogs: () => AppSessionLog[];
+    getDropboxOutput?: () => Promise<string>;
+    getExitInfo?: () => Promise<string>;
+    minOccurredAt?: number;
+}) => {
+    getCrashDetails: ({ occurredAt, pid, testFilePath, }: CrashDetailsLookupOptions) => Promise<AppCrashDetails | null>;
+};
+//# sourceMappingURL=crash-reporter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crash-reporter.d.ts","sourceRoot":"","sources":["../src/crash-reporter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,yBAAyB,EAE1B,MAAM,iCAAiC,CAAC;AAsKzC,eAAO,MAAM,0BAA0B,GAAI,2FAOxC;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,OAAO,EAAE,MAAM,aAAa,EAAE,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;0DAKI,yBAAyB,KAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;CAuE9D,CAAC"}