@expo/build-tools 20.1.0 → 20.3.0

package/dist/steps/functions/maestroResultParser.js

@@ -4,10 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseJUnitTestCases = parseJUnitTestCases;
+exports.isFileAttrRun = isFileAttrRun;
+exports.junitFileHasFileAttrs = junitFileHasFileAttrs;
+exports.parseMaestroResultsFromFileAttrs = parseMaestroResultsFromFileAttrs;
+exports.parseFailedFlowsFromFileAttrs = parseFailedFlowsFromFileAttrs;
 exports.parseMaestroResults = parseMaestroResults;
 exports.parseFailedFlowsFromJUnit = parseFailedFlowsFromJUnit;
 exports.mergeJUnitReports = mergeJUnitReports;
 exports.copyLatestAttemptXml = copyLatestAttemptXml;
+const results_1 = require("@expo/results");
 const fast_xml_parser_1 = require("fast-xml-parser");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
@@ -19,6 +24,11 @@ const xmlParser = new fast_xml_parser_1.XMLParser({
     // Ensure single-element arrays are always arrays
     isArray: name => ['testsuite', 'testcase', 'property'].includes(name),
 });
+// A `file=` attribute counts as present only when it is a non-empty string.
+function fileAttrOf(tc) {
+    const f = tc?.['@_file'];
+    return typeof f === 'string' && f.length > 0 ? f : undefined;
+}
 function parseJUnitContent(content) {
     const results = [];
     try {
@@ -37,6 +47,7 @@ function parseJUnitContent(content) {
                 if (!name) {
                     continue;
                 }
+                const file = fileAttrOf(tc);
                 const timeStr = tc['@_time'];
                 const timeSeconds = timeStr ? parseFloat(timeStr) : 0;
                 const duration = Number.isFinite(timeSeconds) ? Math.round(timeSeconds * 1000) : 0;
@@ -70,7 +81,7 @@ function parseJUnitContent(content) {
                         .filter(Boolean)
                     : [];
                 delete properties['tags'];
-                results.push({ name, status, duration, errorMessage, tags, properties });
+                results.push({ name, file, status, duration, errorMessage, tags, properties });
             }
         }
     }
@@ -103,6 +114,119 @@ async function parseJUnitTestCases(junitDirectory) {
     const perFile = await Promise.all(xmlFiles.map(f => parseJUnitFile(path_1.default.join(junitDirectory, f))));
     return perFile.flat();
 }
+// ---------------------------------------------------------------------------
+// Maestro >= 2.6.0 code path: every <testcase> carries a `file=` attribute with
+// its flow's own path (all-or-none per run). Callers check the report first
+// (isFileAttrRun / junitFileHasFileAttrs) and route here; the legacy name→path
+// scan is then never consulted.
+// ---------------------------------------------------------------------------
+function isFileAttrRun(testcases) {
+    return testcases.length > 0 && testcases.every(tc => tc.file !== undefined);
+}
+// Unreadable or attribute-less reports ⇒ false: the caller then takes the
+// legacy path, whose own guards degrade safely.
+async function junitFileHasFileAttrs(junitFile) {
+    return isFileAttrRun(await parseJUnitFile(junitFile));
+}
+async function fileExists(absPath) {
+    return (await (0, results_1.asyncResult)(promises_1.default.stat(absPath))).ok;
+}
+// Group by `file=` so two same-named flows in different files stay separate.
+async function parseMaestroResultsFromFileAttrs(junitDirectory) {
+    let junitEntries;
+    try {
+        junitEntries = await promises_1.default.readdir(junitDirectory);
+    }
+    catch {
+        return [];
+    }
+    const xmlFiles = junitEntries.filter(f => f.endsWith('.xml')).sort();
+    const entries = [];
+    for (const xmlFile of xmlFiles) {
+        const fileResults = await parseJUnitFile(path_1.default.join(junitDirectory, xmlFile));
+        for (const result of fileResults) {
+            entries.push({ result, sourceFile: xmlFile });
+        }
+    }
+    const byPath = new Map();
+    for (const entry of entries) {
+        // Callers verify the report with isFileAttrRun/junitFileHasFileAttrs first;
+        // skip (rather than emit an undefined path) if that contract is violated.
+        const flowPath = entry.result.file;
+        if (flowPath === undefined) {
+            continue;
+        }
+        const group = byPath.get(flowPath) ?? [];
+        group.push(entry);
+        byPath.set(flowPath, group);
+    }
+    const results = [];
+    for (const [flowPath, group] of byPath) {
+        // retryCount is derived from each entry's source filename (`attempt-N`);
+        // a single entry from `report.xml` (no marker) collapses to attempt 0.
+        const sorted = group
+            .map(entry => {
+            const match = entry.sourceFile.match(ATTEMPT_PATTERN);
+            const attemptIndex = match ? parseInt(match[1], 10) : 0;
+            return { ...entry, attemptIndex };
+        })
+            .sort((a, b) => a.attemptIndex - b.attemptIndex);
+        for (const { result, attemptIndex } of sorted) {
+            results.push({
+                name: result.name,
+                path: flowPath,
+                status: result.status,
+                errorMessage: result.errorMessage,
+                duration: result.duration,
+                retryCount: attemptIndex,
+                tags: result.tags,
+                properties: result.properties,
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Returns the `file=` paths of the failing testcases in the given attempt's
+ * JUnit file, or `null` when the result cannot be trusted (caller then falls
+ * back to dumb retry — re-run everything; never the legacy scan).
+ *
+ * Callers verify the report carries `file=` attributes first
+ * (junitFileHasFileAttrs).
+ */
+async function parseFailedFlowsFromFileAttrs(args) {
+    // Same hardening as the legacy parser: fast-xml-parser is lenient — a
+    // truncated XML could drop testcases, and trusting that partial failing set
+    // would skip retries for cut-off flows.
+    let content;
+    try {
+        content = await promises_1.default.readFile(args.junitFile, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    if (fast_xml_parser_1.XMLValidator.validate(content) !== true) {
+        return null;
+    }
+    const testcases = parseJUnitContent(content);
+    if (!isFileAttrRun(testcases)) {
+        return null;
+    }
+    const failing = testcases.filter(tc => tc.status === 'failed');
+    if (failing.length === 0) {
+        return [];
+    }
+    // Each failing testcase is self-identifying via `file=`, so duplicate flow
+    // names retry correctly. path.resolve (not join): `file=` may be absolute
+    // when the flow lives outside the working directory.
+    const paths = [...new Set(failing.map(tc => tc.file))];
+    for (const p of paths) {
+        if (!(await fileExists(path_1.default.resolve(args.workingDirectory, p)))) {
+            return null;
+        }
+    }
+    return paths;
+}
 async function parseMaestroResults(junitDirectory, nameToPath) {
     let junitEntries;
     try {
@@ -251,6 +375,10 @@ async function mergeJUnitReports(args) {
         }
         const match = filename.match(ATTEMPT_PATTERN);
         const attemptIndex = match ? parseInt(match[1], 10) : 0;
+        // Maestro >= 2.6.0 reports: key by `file=` so two same-named flows in
+        // different files merge separately. Legacy reports keep name keying.
+        const allCases = testsuites.flatMap((suite) => Array.isArray(suite?.testcase) ? suite.testcase : []);
+        const useFileKeys = allCases.length > 0 && allCases.every((tc) => fileAttrOf(tc) !== undefined);
         const testcasesByName = new Map();
         for (const suite of testsuites) {
             const cases = suite?.testcase;
@@ -262,9 +390,10 @@ async function mergeJUnitReports(args) {
                 if (typeof name !== 'string') {
                     continue;
                 }
-                const group = testcasesByName.get(name) ?? [];
+                const key = useFileKeys ? fileAttrOf(tc) : name;
+                const group = testcasesByName.get(key) ?? [];
                 group.push(tc);
-                testcasesByName.set(name, group);
+                testcasesByName.set(key, group);
             }
         }
         if (testcasesByName.size === 0) {

package/dist/steps/functions/maestroTests.js

@@ -157,20 +157,17 @@ function createMaestroTestsBuildFunction() {
             catch (err) {
                 throw new eas_build_job_1.SystemError('Failed to create JUnit report directory', { cause: err });
             }
-            // null → duplicate flow names; retry-failed-only disabled, fall through to
-            // dumb retry (re-run everything) on failure.
-            const nameToPath = await (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
-                inputFlowPaths: flowPaths,
-                projectRoot: stepCtx.workingDirectory,
-                logger,
-            });
+            // Legacy-only (Maestro < 2.6.0 reports carry no `file=` attribute): the
+            // flow scan is built lazily in the retry branch below and memoized so
+            // retries share one scan. Never runs when the report has `file=`.
+            let nameToPathPromise;
             // Retry loop. spawn-async error shapes:
             //   ENOENT/EACCES → infra (binary missing/not executable) → SystemError.
             //   numeric err.status → maestro exited non-zero → retry.
             //   else (signal-only, OOM kill, unknown) → infra → SystemError, never
             //     downgraded to "tests failed".
             // Retry-failed-only (junit mode): after a failed attempt, subset to the failing
-            // flows. parseFailedFlowsFromJUnit returns null when the JUnit cannot be
+            // flows. The failed-flow parsers return null when the JUnit cannot be
             // trusted; we then fall through to dumb retry (re-run everything).
             let flowsToRun = flowPaths;
             let lastAttemptExitCode = null;
@@ -213,11 +210,27 @@ function createMaestroTestsBuildFunction() {
                 if (lastAttemptExitCode === 0 || attempt === retries) {
                     break;
                 }
-                if (retryFailedOnly && outputFormat === 'junit' && outputPath && nameToPath) {
-                    const failed = await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({
-                        junitFile: outputPath,
-                        nameToPath,
-                    });
+                if (retryFailedOnly && outputFormat === 'junit' && outputPath) {
+                    let failed;
+                    if (await (0, maestroResultParser_1.junitFileHasFileAttrs)(outputPath)) {
+                        failed = await (0, maestroResultParser_1.parseFailedFlowsFromFileAttrs)({
+                            junitFile: outputPath,
+                            workingDirectory: stepCtx.workingDirectory,
+                        });
+                    }
+                    else {
+                        // Legacy (Maestro < 2.6.0): map failed testcase names back to flow
+                        // paths via the flow-file scan. DELETE this arm once the fleet is
+                        // on >= 2.6.0.
+                        const nameToPath = await (nameToPathPromise ??= (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
+                            inputFlowPaths: flowPaths,
+                            projectRoot: stepCtx.workingDirectory,
+                            logger,
+                        }));
+                        failed = nameToPath
+                            ? await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({ junitFile: outputPath, nameToPath })
+                            : null;
+                    }
                     if (failed !== null && failed.length > 0) {
                         flowsToRun = failed;
                         logger.info(`Test failed; retrying ${failed.length} failed flow(s): ${failed.join(', ')}`);

package/dist/steps/functions/repack.d.ts

@@ -13,7 +13,9 @@ export declare function resolveAndroidSigningOptionsAsync({ job, tmpDir, }: {
 /**
  * Resolves iOS signing options from the job secrets.
  */
-export declare function resolveIosSigningOptionsAsync({ job, logger, }: {
+export declare function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }: {
     job: Job;
     logger: bunyan;
+    useAppEntitlements?: boolean;
+    entitlementsPath?: string;
 }): Promise<IosSigningOptions | undefined>;

package/dist/steps/functions/repack.js

@@ -48,6 +48,16 @@ function createRepackBuildFunction() {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
                 required: false,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ios_signing_use_source_app_entitlements',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ios_signing_app_entitlements_path',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+            }),
             steps_1.BuildStepInput.createProvider({
                 id: 'repack_version',
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
@@ -116,6 +126,8 @@ function createRepackBuildFunction() {
                         iosSigningOptions: await resolveIosSigningOptionsAsync({
                             job: stepsCtx.global.staticContext.job,
                             logger: stepsCtx.logger,
+                            useAppEntitlements: inputs.ios_signing_use_source_app_entitlements.value,
+                            entitlementsPath: inputs.ios_signing_app_entitlements_path.value,
                         }),
                         logger: stepsCtx.logger,
                         spawnAsync: repackSpawnAsync,
@@ -219,7 +231,7 @@ async function resolveAndroidSigningOptionsAsync({ job, tmpDir, }) {
 /**
  * Resolves iOS signing options from the job secrets.
  */
-async function resolveIosSigningOptionsAsync({ job, logger, }) {
+async function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }) {
     const iosJob = job;
     const buildCredentials = iosJob.secrets?.buildCredentials;
     if (iosJob.simulator || buildCredentials == null) {
@@ -235,5 +247,7 @@ async function resolveIosSigningOptionsAsync({ job, logger, }) {
         provisioningProfile,
         keychainPath: credentials.keychainPath,
         signingIdentity: credentials.applicationTargetProvisioningProfile.data.certificateCommonName,
+        useAppEntitlements,
+        entitlementsPath,
     };
 }

package/dist/steps/functions/reportMaestroTestResults.js

@@ -57,41 +57,60 @@ function createReportMaestroTestResultsFunction(ctx) {
                 logger.info('No JUnit directory provided, skipping test results report');
                 return;
             }
-            const flowPathRaw = inputs.flow_path.value;
-            let nameToPath = null;
-            if (flowPathRaw !== undefined) {
-                const parsed = FlowPathSchema.safeParse(flowPathRaw);
-                if (parsed.success) {
-                    nameToPath = await (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
-                        inputFlowPaths: parsed.data,
-                        projectRoot: stepsCtx.workingDirectory,
-                        logger,
-                    });
+            try {
+                // Maestro >= 2.6.0 stamps every <testcase> with its flow's path in a
+                // `file=` attribute; older reports need the legacy flow-file scan to
+                // map testcase names back to paths.
+                const usedFileAttrs = (0, maestroResultParser_1.isFileAttrRun)(await (0, maestroResultParser_1.parseJUnitTestCases)(junitDirectory));
+                let flowResults;
+                if (usedFileAttrs) {
+                    flowResults = await (0, maestroResultParser_1.parseMaestroResultsFromFileAttrs)(junitDirectory);
                 }
                 else {
-                    logger.warn('Ignoring malformed flow_path input (expected a non-empty array of non-empty strings).');
+                    // Legacy (Maestro < 2.6.0) — DELETE this arm once the fleet is on >= 2.6.0.
+                    const flowPathRaw = inputs.flow_path.value;
+                    let nameToPath = null;
+                    if (flowPathRaw !== undefined) {
+                        const parsed = FlowPathSchema.safeParse(flowPathRaw);
+                        if (parsed.success) {
+                            nameToPath = await (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
+                                inputFlowPaths: parsed.data,
+                                projectRoot: stepsCtx.workingDirectory,
+                                logger,
+                            });
+                        }
+                        else {
+                            logger.warn('Ignoring malformed flow_path input (expected a non-empty array of non-empty strings).');
+                        }
+                    }
+                    flowResults = await (0, maestroResultParser_1.parseMaestroResults)(junitDirectory, nameToPath);
                 }
-            }
-            try {
-                const flowResults = await (0, maestroResultParser_1.parseMaestroResults)(junitDirectory, nameToPath);
                 if (flowResults.length === 0) {
                     logger.info('No maestro test results found, skipping report');
                     return;
                 }
-                // Detect truly conflicting results: same (name, retryCount) pair means different flow files
-                // share the same name (Maestro config override), which we can't disambiguate.
-                // Same name with different retryCount is expected (per-attempt results from retries).
+                // Detect truly conflicting results: the same (path, retryCount) twice means two
+                // flow files resolved to the same path, which we can't disambiguate and the API
+                // rejects as a duplicate. Same path with different retryCount is expected
+                // (per-attempt results from retries).
                 const seen = new Set();
                 const conflicting = new Set();
                 for (const r of flowResults) {
-                    const key = `${r.name}:${r.retryCount}`;
+                    const key = `${r.path}:${r.retryCount}`;
                     if (seen.has(key)) {
-                        conflicting.add(r.name);
+                        conflicting.add(r.path);
                     }
                     seen.add(key);
                 }
                 if (conflicting.size > 0) {
-                    logger.error(`Duplicate test case names found in JUnit output: ${[...conflicting].join(', ')}. Skipping report. Ensure each Maestro flow has a unique name.`);
+                    const conflictList = [...conflicting].join(', ');
+                    logger.error(usedFileAttrs
+                        ? `The same flow file was reported more than once in a single attempt: ` +
+                            `${conflictList}. Skipping report. Check for duplicate flow_path entries ` +
+                            `or leftover XML files in the JUnit report directory.`
+                        : `Duplicate Maestro flow names found: ${conflictList}. Skipping report. ` +
+                            `Give each flow a unique name, or upgrade Maestro to >= 2.6.0 (flows are ` +
+                            `then identified by file path, so duplicate names are fine).`);
                     return;
                 }
                 const testCaseResults = flowResults.flatMap(f => {

package/dist/steps/functions/restoreBuildCache.js

@@ -159,12 +159,15 @@ async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets,
         return;
     }
     try {
-        const gradlePropertiesPath = path_1.default.join(workingDirectory, 'android', 'gradle.properties');
-        const gradlePropertiesContent = await fs_1.default.promises.readFile(gradlePropertiesPath, 'utf-8');
-        await fs_1.default.promises.writeFile(gradlePropertiesPath, `${gradlePropertiesContent}\n\norg.gradle.caching=true\n`);
-        // Configure cache cleanup via init script (works with both Gradle 8 and 9,
-        // org.gradle.cache.cleanup property was removed in Gradle 9)
-        const initScriptDir = path_1.default.join(os_1.default.homedir(), '.gradle', 'init.d');
+        // Enable build cache via user-level gradle.properties.
+        // This avoids mutating android/gradle.properties which affects fingerprinting.
+        const gradleUserHome = path_1.default.join(os_1.default.homedir(), '.gradle');
+        await fs_1.default.promises.mkdir(gradleUserHome, { recursive: true });
+        const userGradlePropertiesPath = path_1.default.join(gradleUserHome, 'gradle.properties');
+        await fs_1.default.promises.appendFile(userGradlePropertiesPath, '\norg.gradle.caching=true\n');
+        // Configure cache cleanup via init script.
+        // Works with both Gradle 8 and 9 (org.gradle.cache.cleanup property was removed in Gradle 9).
+        const initScriptDir = path_1.default.join(gradleUserHome, 'init.d');
         await fs_1.default.promises.mkdir(initScriptDir, { recursive: true });
         await fs_1.default.promises.writeFile(path_1.default.join(initScriptDir, 'eas-cache-cleanup.gradle'), [
             'def cacheDir = new File(System.getProperty("user.home"), ".gradle/caches/build-cache-1")',

package/dist/steps/functions/startAgentDeviceRemoteSession.d.ts

@@ -1,3 +1,3 @@
 import { BuildFunction } from '@expo/steps';
-import { CustomBuildContext } from '../../customBuildContext';
+import { type CustomBuildContext } from '../../customBuildContext';
 export declare function createStartAgentDeviceRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -7,9 +7,12 @@ exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDevic
 const eas_build_job_1 = require("@expo/eas-build-job");
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+const sentry_1 = require("../../sentry");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
+const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstackincubator/agent-device.git';
 const SRC_DIR = '/tmp/agent-device-src';
 const DAEMON_JSON_PATH = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device', 'daemon.json');
@@ -43,29 +46,11 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
                 await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
             }
-            logger.info(packageVersion
-                ? `Cloning agent-device @ v${packageVersion} into ${SRC_DIR}.`
-                : `Cloning agent-device (latest) into ${SRC_DIR}.`);
-            await cloneAgentDeviceAsync({ packageVersion, env, logger });
-            logger.info('Installing agent-device dependencies.');
-            await (0, turtle_spawn_1.default)('bun', ['install', '--production'], {
-                cwd: SRC_DIR,
-                env,
-                logger,
-            });
             logger.info('Launching agent-device daemon.');
-            (0, remoteDeviceRunSession_1.spawnDetached)({
-                command: 'bun',
-                args: ['run', 'src/daemon.ts'],
-                cwd: SRC_DIR,
-                env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
-            });
+            const daemonProcess = await startAgentDeviceDaemonAsync({ packageVersion, env, logger });
             logger.info(`Waiting for daemon credentials at ${DAEMON_JSON_PATH}.`);
-            const { port: daemonPort, token: daemonToken } = await (0, remoteDeviceRunSession_1.waitForFileAsync)({
-                filePath: DAEMON_JSON_PATH,
-                timeoutMs: STARTUP_TIMEOUT_MS,
-                description: 'agent-device daemon credentials',
-                parse: parseDaemonInfo,
+            const { port: daemonPort, token: daemonToken } = await waitForDaemonInfoAsync({
+                daemonProcess,
             });
             logger.info(`Daemon is listening on port ${daemonPort}; loaded auth token.`);
             const agentDeviceRemoteSessionUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
@@ -80,7 +65,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             // on Darwin. Android sessions go without a preview URL.
             let webPreviewUrl;
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+                const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                     baseDomain: ngrokTunnelDomain,
                     env,
                     logger,
@@ -106,6 +91,64 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
         },
     });
 }
+async function startAgentDeviceDaemonAsync({ packageVersion, env, logger, }) {
+    const packageSpec = createAgentDevicePackageSpec(packageVersion);
+    try {
+        logger.info(`Installing ${packageSpec} globally with Bun.`);
+        await (0, turtle_spawn_1.default)('bun', ['add', '--global', packageSpec], {
+            env,
+            logger,
+        });
+        const daemonPath = getGlobalAgentDeviceDaemonPath(env);
+        if (!node_fs_1.default.existsSync(daemonPath)) {
+            throw new eas_build_job_1.SystemError(`Expected agent-device daemon entry at ${daemonPath}.`);
+        }
+        logger.info(`Launching daemon from ${daemonPath}.`);
+        return (0, remoteDeviceRunSession_1.spawnDetached)({
+            command: 'node',
+            args: [daemonPath],
+            env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
+        });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        const bunVersion = await getBunVersionForDiagnosticsAsync(env);
+        sentry_1.Sentry.capture('Failed to start agent-device daemon from global Bun package; falling back to git clone', error, {
+            level: 'warning',
+            tags: {
+                phase: 'agent-device-daemon-start',
+                fallback: 'git-clone',
+            },
+            extras: {
+                packageSpec,
+                packageVersion: packageVersion ?? 'latest',
+                bunVersion,
+                bunInstallConfigured: Boolean(env.BUN_INSTALL?.trim()),
+            },
+        });
+        logger.warn(`Failed to start daemon from global ${packageSpec}; falling back to git clone: ${error.message}`);
+        return await startAgentDeviceDaemonFromGitAsync({ packageVersion, env, logger });
+    }
+}
+async function startAgentDeviceDaemonFromGitAsync({ packageVersion, env, logger, }) {
+    logger.info(packageVersion
+        ? `Cloning agent-device @ v${packageVersion} into ${SRC_DIR}.`
+        : `Cloning agent-device (latest) into ${SRC_DIR}.`);
+    await cloneAgentDeviceAsync({ packageVersion, env, logger });
+    logger.info('Installing agent-device dependencies.');
+    await (0, turtle_spawn_1.default)('bun', ['install', '--production'], {
+        cwd: SRC_DIR,
+        env,
+        logger,
+    });
+    logger.info('Launching daemon from cloned agent-device source.');
+    return (0, remoteDeviceRunSession_1.spawnDetached)({
+        command: 'bun',
+        args: ['run', 'src/daemon.ts'],
+        cwd: SRC_DIR,
+        env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
+    });
+}
 async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {
     const branchArgs = packageVersion ? ['--branch', `v${packageVersion}`] : [];
     await (0, turtle_spawn_1.default)('git', ['clone', '--depth', '1', ...branchArgs, AGENT_DEVICE_REPO_URL, SRC_DIR], {
@@ -113,6 +156,42 @@ async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {
         logger,
     });
 }
+async function waitForDaemonInfoAsync({ daemonProcess, }) {
+    try {
+        return await (0, remoteDeviceRunSession_1.waitForFileAsync)({
+            filePath: DAEMON_JSON_PATH,
+            timeoutMs: STARTUP_TIMEOUT_MS,
+            description: 'agent-device daemon credentials',
+            parse: parseDaemonInfo,
+        });
+    }
+    catch (err) {
+        const output = daemonProcess.getOutput();
+        throw new eas_build_job_1.SystemError(`${err instanceof Error
+            ? err.message
+            : `Timed out waiting for agent-device daemon credentials.`}${output ? `\nagent-device daemon output:\n${output}` : ''}`);
+    }
+}
+async function getBunVersionForDiagnosticsAsync(env) {
+    try {
+        const result = await (0, turtle_spawn_1.default)('bun', ['--version'], { stdio: 'pipe', env, cwd: node_os_1.default.tmpdir() });
+        return result.stdout.trim() || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function createAgentDevicePackageSpec(packageVersion) {
+    const versionSpec = packageVersion ? packageVersion.replace(/^v(?=\d)/, '') : 'latest';
+    return `${AGENT_DEVICE_PACKAGE_NAME}@${versionSpec}`;
+}
+function getGlobalAgentDeviceDaemonPath(env) {
+    return node_path_1.default.join(getBunInstallDirectory(env), 'install', 'global', 'node_modules', AGENT_DEVICE_PACKAGE_NAME, 'dist', 'src', 'internal', 'daemon.js');
+}
+function getBunInstallDirectory(env) {
+    const bunInstall = env.BUN_INSTALL?.trim();
+    return bunInstall ? bunInstall : node_path_1.default.join(node_os_1.default.homedir(), '.bun');
+}
 function parseDaemonInfo(raw) {
     const parsed = JSON.parse(raw);
     if (!parsed ||

package/dist/steps/functions/startArgentRemoteSession.d.ts

@@ -1,3 +1,8 @@
+import { type bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { CustomBuildContext } from '../../customBuildContext';
 export declare function createStartArgentRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
+export declare function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, }: {
+    packageVersion: string | undefined;
+    logger: bunyan;
+}): void;