@expo/build-tools 20.5.1 → 21.0.1

package/dist/steps/utils/PosthogClient.d.ts

@@ -0,0 +1,46 @@
+import { bunyan } from '@expo/logger';
+import { type BuildStepEnv } from '@expo/steps';
+import { Response } from 'node-fetch';
+import { PosthogUtils } from './PosthogUtils';
+export declare class PosthogRetryableError extends Error {
+}
+export declare class PosthogClient {
+    private readonly host;
+    private readonly apiKey;
+    private readonly projectId;
+    private constructor();
+    static fromEnv({ apiKeyOverride, projectIdOverride, env, }: {
+        apiKeyOverride: string | undefined;
+        projectIdOverride: string | undefined;
+        env: BuildStepEnv;
+    }): {
+        client: PosthogClient;
+    } | {
+        client: undefined;
+        missing: PosthogUtils.Credential[];
+    };
+    static forIngestion({ apiKeyOverride, hostOverride, env, }: {
+        apiKeyOverride: string | undefined;
+        hostOverride: string | undefined;
+        env: BuildStepEnv;
+    }): PosthogClient | undefined;
+    captureEventAsync({ event, distinctId, properties, signal, }: {
+        event: string;
+        distinctId: string | undefined;
+        properties: Record<string, unknown> | undefined;
+        signal: AbortSignal | undefined;
+    }): Promise<void>;
+    requestAsync(method: 'GET' | 'POST' | 'PATCH', path: string, { action, forbiddenScope, body, signal, }: {
+        action: string;
+        forbiddenScope: string;
+        body?: unknown;
+        signal: AbortSignal | undefined;
+    }): Promise<Response>;
+    runQueryAsync(query: string, logger: bunyan, signal: AbortSignal | undefined): Promise<unknown>;
+    cliConfig(): {
+        host: string;
+        env: Record<string, string>;
+    };
+    private apiUrl;
+    private authHeaders;
+}

package/dist/steps/utils/PosthogClient.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PosthogClient = exports.PosthogRetryableError = void 0;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const zod_1 = require("zod");
+const PosthogUtils_1 = require("./PosthogUtils");
+const POSTHOG_DEFAULT_HOST = 'https://us.posthog.com';
+const SYSTEM_DISTINCT_ID = 'eas-workflow';
+const QueryResponseSchema = zod_1.z.object({ results: zod_1.z.array(zod_1.z.array(zod_1.z.unknown())) });
+class PosthogRetryableError extends Error {
+}
+exports.PosthogRetryableError = PosthogRetryableError;
+class PosthogClient {
+    host;
+    apiKey;
+    projectId;
+    constructor(host, apiKey, projectId) {
+        this.host = host;
+        this.apiKey = apiKey;
+        this.projectId = projectId;
+    }
+    static fromEnv({ apiKeyOverride, projectIdOverride, env, }) {
+        const apiKey = apiKeyOverride || env.POSTHOG_CLI_API_KEY;
+        const projectId = projectIdOverride || env.POSTHOG_CLI_PROJECT_ID;
+        if (!apiKey || !projectId) {
+            return {
+                client: undefined,
+                missing: [
+                    ...(apiKey ? [] : [PosthogUtils_1.PosthogUtils.API_CREDENTIALS.apiKey]),
+                    ...(projectId ? [] : [PosthogUtils_1.PosthogUtils.API_CREDENTIALS.projectId]),
+                ],
+            };
+        }
+        return {
+            client: new PosthogClient((env.POSTHOG_CLI_HOST || POSTHOG_DEFAULT_HOST).replace(/\/+$/, ''), apiKey, projectId),
+        };
+    }
+    static forIngestion({ apiKeyOverride, hostOverride, env, }) {
+        const apiKey = apiKeyOverride || env.EXPO_PUBLIC_POSTHOG_API_KEY || env.POSTHOG_API_KEY;
+        if (!apiKey) {
+            return undefined;
+        }
+        return new PosthogClient((hostOverride || env.EXPO_PUBLIC_POSTHOG_HOST || POSTHOG_DEFAULT_HOST).replace(/\/+$/, ''), apiKey, '');
+    }
+    async captureEventAsync({ event, distinctId, properties, signal, }) {
+        let response;
+        try {
+            response = await (0, node_fetch_1.default)(`${this.host}/i/v0/e/`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    api_key: this.apiKey,
+                    event,
+                    distinct_id: distinctId ?? SYSTEM_DISTINCT_ID,
+                    properties: distinctId !== undefined
+                        ? properties
+                        : { ...properties, $process_person_profile: false },
+                    timestamp: new Date().toISOString(),
+                }),
+                signal,
+            });
+        }
+        catch (error) {
+            if (signal?.aborted) {
+                throw error;
+            }
+            throw new eas_build_job_1.UserError('EAS_POSTHOG_CAPTURE_FAILED', `Sending PostHog event "${event}" failed.`, {
+                cause: error,
+            });
+        }
+        if (!response.ok) {
+            throw new eas_build_job_1.UserError('EAS_POSTHOG_CAPTURE_FAILED', `Sending PostHog event "${event}" failed with ${await PosthogUtils_1.PosthogUtils.readErrorAsync(response)}.`);
+        }
+    }
+    async requestAsync(method, path, { action, forbiddenScope, body, signal, }) {
+        let response;
+        try {
+            response = await (0, node_fetch_1.default)(this.apiUrl(path), {
+                method,
+                headers: this.authHeaders(),
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal,
+            });
+        }
+        catch (error) {
+            if (signal?.aborted) {
+                throw error;
+            }
+            throw new eas_build_job_1.UserError('EAS_POSTHOG_REQUEST_FAILED', `${action} failed.`, { cause: error });
+        }
+        if (response.status === 403) {
+            throw new eas_build_job_1.UserError('EAS_POSTHOG_FORBIDDEN', `${action} was forbidden (403). The personal API key likely lacks the "${forbiddenScope}" scope.`);
+        }
+        if (!response.ok) {
+            throw new eas_build_job_1.UserError('EAS_POSTHOG_REQUEST_FAILED', `${action} failed with ${await PosthogUtils_1.PosthogUtils.readErrorAsync(response)}.`);
+        }
+        return response;
+    }
+    async runQueryAsync(query, logger, signal) {
+        let response;
+        try {
+            response = await (0, node_fetch_1.default)(this.apiUrl('/query/'), {
+                method: 'POST',
+                headers: this.authHeaders(),
+                body: JSON.stringify({ query: { kind: 'HogQLQuery', query }, refresh: 'blocking' }),
+                signal,
+            });
+        }
+        catch (error) {
+            if (signal?.aborted) {
+                throw error;
+            }
+            logger.debug(error);
+            logger.warn('Running the PostHog query failed with a network error; will retry on the next poll.');
+            throw new PosthogRetryableError();
+        }
+        if (response.status === 403) {
+            throw new eas_build_job_1.UserError('EAS_POSTHOG_FORBIDDEN', 'Running the PostHog query was forbidden (403). The personal API key likely lacks the "query:read" scope.');
+        }
+        if (response.status >= 500 || response.status === 429) {
+            logger.warn(`Running the PostHog query failed with status ${response.status}; will retry on the next poll.`);
+            throw new PosthogRetryableError();
+        }
+        if (!response.ok) {
+            throw new eas_build_job_1.UserError('EAS_POSTHOG_REQUEST_FAILED', `Running the PostHog query failed with ${await PosthogUtils_1.PosthogUtils.readErrorAsync(response)}.`);
+        }
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch (error) {
+            logger.debug(error);
+            logger.warn('The PostHog query response was not valid JSON; will retry on the next poll.');
+            throw new PosthogRetryableError();
+        }
+        const parsed = QueryResponseSchema.safeParse(body);
+        return parsed.success ? parsed.data.results[0]?.[0] : undefined;
+    }
+    cliConfig() {
+        return {
+            host: this.host,
+            env: { POSTHOG_CLI_API_KEY: this.apiKey, POSTHOG_CLI_PROJECT_ID: this.projectId },
+        };
+    }
+    apiUrl(path) {
+        return `${this.host}/api/projects/${encodeURIComponent(this.projectId)}${path}`;
+    }
+    authHeaders() {
+        return { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' };
+    }
+}
+exports.PosthogClient = PosthogClient;

package/dist/steps/utils/PosthogUtils.d.ts

@@ -0,0 +1,41 @@
+import { UserError } from '@expo/eas-build-job';
+import { bunyan } from '@expo/logger';
+import { Response } from 'node-fetch';
+export declare namespace PosthogUtils {
+    interface Credential {
+        label: string;
+        envVar: string;
+        input: string;
+    }
+    const API_CREDENTIALS: {
+        apiKey: {
+            label: string;
+            envVar: string;
+            input: string;
+        };
+        projectId: {
+            label: string;
+            envVar: string;
+            input: string;
+        };
+    };
+    function missingCredentialsError(missing: Credential[]): UserError;
+    const DEFAULT_POLL_TIMEOUT_SECONDS = 600;
+    const DEFAULT_POLL_INTERVAL_SECONDS = 30;
+    function assertPollBoundsPositive({ timeoutSeconds, intervalSeconds, errorCode, }: {
+        timeoutSeconds: number;
+        intervalSeconds: number;
+        errorCode: string;
+    }): void;
+    function waitForNextPollAsync({ intervalSeconds, deadline, signal, }: {
+        intervalSeconds: number;
+        deadline: number;
+        signal: AbortSignal | undefined;
+    }): Promise<boolean>;
+    function failOrLogError({ logger, ignoreError, error, }: {
+        logger: bunyan;
+        ignoreError: boolean;
+        error: unknown;
+    }): void;
+    function readErrorAsync(response: Response): Promise<string>;
+}

package/dist/steps/utils/PosthogUtils.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PosthogUtils = void 0;
+const promises_1 = require("node:timers/promises");
+const eas_build_job_1 = require("@expo/eas-build-job");
+var PosthogUtils;
+(function (PosthogUtils) {
+    PosthogUtils.API_CREDENTIALS = {
+        apiKey: { label: 'personal API key', envVar: 'POSTHOG_CLI_API_KEY', input: 'api_key' },
+        projectId: { label: 'project id', envVar: 'POSTHOG_CLI_PROJECT_ID', input: 'project_id' },
+    };
+    function missingCredentialsError(missing) {
+        const labels = missing.map(credential => credential.label).join(', ');
+        const envVars = missing.map(credential => credential.envVar).join(', ');
+        const inputs = missing.map(credential => credential.input).join(', ');
+        return new eas_build_job_1.UserError('EAS_POSTHOG_MISSING_CREDENTIALS', `Missing PostHog credentials: ${labels}. Set the environment variables (${envVars}) or step inputs (${inputs}) on EAS, or re-run "eas integrations:posthog:connect" with error tracking enabled.`);
+    }
+    PosthogUtils.missingCredentialsError = missingCredentialsError;
+    PosthogUtils.DEFAULT_POLL_TIMEOUT_SECONDS = 600;
+    PosthogUtils.DEFAULT_POLL_INTERVAL_SECONDS = 30;
+    function assertPollBoundsPositive({ timeoutSeconds, intervalSeconds, errorCode, }) {
+        if (timeoutSeconds <= 0 || intervalSeconds <= 0) {
+            throw new eas_build_job_1.UserError(errorCode, '"timeout_seconds" and "interval_seconds" must be greater than 0.');
+        }
+    }
+    PosthogUtils.assertPollBoundsPositive = assertPollBoundsPositive;
+    async function waitForNextPollAsync({ intervalSeconds, deadline, signal, }) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            return false;
+        }
+        await (0, promises_1.setTimeout)(Math.min(intervalSeconds * 1000, remainingMs), undefined, { signal });
+        return true;
+    }
+    PosthogUtils.waitForNextPollAsync = waitForNextPollAsync;
+    function failOrLogError({ logger, ignoreError, error, }) {
+        if (!ignoreError ||
+            (error instanceof eas_build_job_1.UserError && error.errorCode === 'EAS_POSTHOG_FORBIDDEN')) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn({ err: error }, `${message} Ignoring error.`);
+    }
+    PosthogUtils.failOrLogError = failOrLogError;
+    async function readErrorAsync(response) {
+        const text = await response.text().catch(() => '');
+        if (text) {
+            try {
+                const body = JSON.parse(text);
+                if (typeof body === 'object' && body !== null) {
+                    const { detail } = body;
+                    if (typeof detail === 'string' && detail !== '') {
+                        return `status ${response.status}: ${detail} (${text})`;
+                    }
+                }
+            }
+            catch {
+                return `status ${response.status}: ${text}`;
+            }
+            return `status ${response.status}: ${text}`;
+        }
+        return `status ${response.status}`;
+    }
+    PosthogUtils.readErrorAsync = readErrorAsync;
+})(PosthogUtils || (exports.PosthogUtils = PosthogUtils = {}));

package/dist/steps/utils/agentDeviceArtifacts.d.ts

@@ -0,0 +1,27 @@
+import { type bunyan } from '@expo/logger';
+import { z } from 'zod';
+import { CustomBuildContext } from '../../customBuildContext';
+declare const AgentDeviceArtifactSchema: z.ZodObject<{
+    id: z.ZodString;
+    artifactType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    filename: z.ZodString;
+}, z.core.$strip>;
+export type AgentDeviceArtifact = z.infer<typeof AgentDeviceArtifactSchema>;
+export declare function pollAgentDeviceArtifactsForUploadAsync(ctx: CustomBuildContext, { deviceRunSessionId, daemonUrl, daemonToken, logger, }: {
+    deviceRunSessionId: string;
+    daemonUrl: string;
+    daemonToken: string;
+    logger: bunyan;
+}): Promise<void>;
+export declare function listAgentDeviceArtifactsAsync({ daemonUrl, daemonToken, }: {
+    daemonUrl: string;
+    daemonToken: string;
+}): Promise<AgentDeviceArtifact[]>;
+export declare function uploadAgentDeviceArtifactAsync(ctx: CustomBuildContext, { deviceRunSessionId, daemonUrl, daemonToken, artifact, logger, }: {
+    deviceRunSessionId: string;
+    daemonUrl: string;
+    daemonToken: string;
+    artifact: AgentDeviceArtifact;
+    logger: bunyan;
+}): Promise<void>;
+export {};

package/dist/steps/utils/agentDeviceArtifacts.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollAgentDeviceArtifactsForUploadAsync = pollAgentDeviceArtifactsForUploadAsync;
+exports.listAgentDeviceArtifactsAsync = listAgentDeviceArtifactsAsync;
+exports.uploadAgentDeviceArtifactAsync = uploadAgentDeviceArtifactAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_2 = require("node:stream/promises");
+const zod_1 = require("zod");
+const sentry_1 = require("../../sentry");
+const artifacts_1 = require("../../utils/artifacts");
+const retry_1 = require("../../utils/retry");
+const deviceRunSessionArtifacts_1 = require("./deviceRunSessionArtifacts");
+const AGENT_DEVICE_ARTIFACT_UPLOAD_POLL_INTERVAL_MS = 5_000;
+const AgentDeviceArtifactSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    artifactType: zod_1.z.string().nullish(),
+    filename: zod_1.z.string(),
+});
+const AgentDeviceArtifactsListResponseSchema = zod_1.z.object({
+    artifacts: zod_1.z.array(AgentDeviceArtifactSchema),
+});
+class AgentDeviceArtifactsUnsupportedError extends eas_build_job_1.SystemError {
+    constructor() {
+        super('agent-device daemon does not expose artifact inventory.');
+    }
+}
+async function pollAgentDeviceArtifactsForUploadAsync(ctx, { deviceRunSessionId, daemonUrl, daemonToken, logger, }) {
+    logger.info('Started polling agent-device daemon for artifacts.');
+    const uploadedArtifactIds = new Set();
+    let listArtifactsErrorCount = 0;
+    for (;;) {
+        try {
+            const artifacts = await listAgentDeviceArtifactsAsync({ daemonUrl, daemonToken });
+            listArtifactsErrorCount = 0;
+            for (const artifact of artifacts) {
+                if (uploadedArtifactIds.has(artifact.id)) {
+                    continue;
+                }
+                try {
+                    await uploadAgentDeviceArtifactAsync(ctx, {
+                        deviceRunSessionId,
+                        daemonUrl,
+                        daemonToken,
+                        artifact,
+                        logger,
+                    });
+                    uploadedArtifactIds.add(artifact.id);
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    sentry_1.Sentry.capture('Could not upload agent-device remote session artifact', error);
+                    logger.warn({ err: error }, 'Could not upload agent-device remote session artifact.');
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof AgentDeviceArtifactsUnsupportedError) {
+                logger.warn('agent-device daemon does not expose artifact inventory; remote session artifact uploads are disabled.');
+                return;
+            }
+            const error = err instanceof Error ? err : new Error(String(err));
+            listArtifactsErrorCount += 1;
+            if (listArtifactsErrorCount === 1 || listArtifactsErrorCount % 5 === 0) {
+                sentry_1.Sentry.capture('Could not list agent-device remote session artifacts', error);
+                logger.warn({ err: error, failedArtifactListCount: listArtifactsErrorCount }, 'Could not list agent-device remote session artifacts.');
+            }
+        }
+        await (0, retry_1.sleepAsync)(AGENT_DEVICE_ARTIFACT_UPLOAD_POLL_INTERVAL_MS);
+    }
+}
+async function listAgentDeviceArtifactsAsync({ daemonUrl, daemonToken, }) {
+    const response = await (0, node_fetch_1.default)(new URL('/artifacts', daemonUrl).toString(), {
+        headers: { Authorization: `Bearer ${daemonToken}` },
+    });
+    if (response.status === 404) {
+        throw new AgentDeviceArtifactsUnsupportedError();
+    }
+    if (!response.ok) {
+        throw new eas_build_job_1.SystemError(`Failed to list agent-device artifacts: ${response.status} ${response.statusText}`);
+    }
+    const result = AgentDeviceArtifactsListResponseSchema.safeParse(await response.json());
+    if (!result.success) {
+        throw new eas_build_job_1.SystemError(`Invalid agent-device artifacts response: ${result.error.message}`);
+    }
+    return result.data.artifacts;
+}
+async function uploadAgentDeviceArtifactAsync(ctx, { deviceRunSessionId, daemonUrl, daemonToken, artifact, logger, }) {
+    logger.info(`Downloading artifact ${artifact.filename}.`);
+    const temporaryDirectory = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), 'agent-device-artifact-'));
+    try {
+        const temporaryArtifactPath = node_path_1.default.join(temporaryDirectory, node_path_1.default.basename(artifact.filename));
+        await downloadAgentDeviceArtifactToFileAsync({
+            artifact,
+            daemonUrl,
+            daemonToken,
+            destinationPath: temporaryArtifactPath,
+        });
+        const { size } = await (0, promises_1.stat)(temporaryArtifactPath);
+        logger.info(`Uploading artifact ${artifact.filename} (${(0, artifacts_1.formatBytes)(size)}).`);
+        await (0, deviceRunSessionArtifacts_1.uploadDeviceRunSessionArtifactAsync)(ctx, {
+            deviceRunSessionId,
+            artifactId: artifact.id,
+            name: `${artifact.filename} (${artifact.id})`,
+            filename: artifact.filename,
+            kind: artifact.artifactType ?? undefined,
+            size,
+            stream: (0, node_fs_1.createReadStream)(temporaryArtifactPath),
+        });
+    }
+    finally {
+        await (0, promises_1.rm)(temporaryDirectory, { recursive: true, force: true });
+    }
+}
+async function downloadAgentDeviceArtifactToFileAsync({ artifact, daemonUrl, daemonToken, destinationPath, }) {
+    const response = await (0, node_fetch_1.default)(new URL(`/artifacts/${encodeURIComponent(artifact.id)}`, daemonUrl).toString(), {
+        headers: { Authorization: `Bearer ${daemonToken}` },
+    });
+    if (!response.ok) {
+        throw new eas_build_job_1.SystemError(`Failed to download agent-device artifact ${artifact.id}: ${response.status} ${response.statusText}`);
+    }
+    if (!response.body) {
+        throw new eas_build_job_1.SystemError(`Agent-device artifact ${artifact.id} response did not include a readable body.`);
+    }
+    await (0, promises_2.pipeline)(response.body, (0, node_fs_1.createWriteStream)(destinationPath));
+}

package/dist/steps/utils/android/gradle.d.ts

@@ -8,4 +8,9 @@ export declare function runGradleCommand({ logger, gradleCommand, androidDir, en
     env: BuildStepEnv;
     extraEnv?: BuildStepEnv;
 }): Promise<void>;
+export declare function getGradleShellCommand({ gradleCommand, oomScoreAdj, verboseFlag, }: {
+    gradleCommand: string;
+    oomScoreAdj?: number;
+    verboseFlag: string;
+}): string;
 export declare function resolveGradleCommand(job: Android.Job, command?: string): string;

package/dist/steps/utils/android/gradle.js

@@ -4,17 +4,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runGradleCommand = runGradleCommand;
+exports.getGradleShellCommand = getGradleShellCommand;
 exports.resolveGradleCommand = resolveGradleCommand;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
-const assert_1 = __importDefault(require("assert"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 async function runGradleCommand({ logger, gradleCommand, androidDir, env, extraEnv, }) {
     const verboseFlag = env['EAS_VERBOSE'] === '1' ? '--info' : '';
     logger.info(`Running 'gradlew ${gradleCommand} ${verboseFlag}' in ${androidDir}`);
     await fs_extra_1.default.chmod(path_1.default.join(androidDir, 'gradlew'), 0o755);
-    const spawnPromise = (0, turtle_spawn_1.default)('bash', ['-c', `./gradlew ${gradleCommand} --profile ${verboseFlag}`], {
+    const shouldResetOOMScore = env.EAS_BUILD_RUNNER === 'eas-build' && process.platform === 'linux';
+    await (0, turtle_spawn_1.default)('bash', [
+        '-c',
+        getGradleShellCommand({
+            gradleCommand,
+            oomScoreAdj: shouldResetOOMScore ? 0 : undefined,
+            verboseFlag,
+        }),
+    ], {
         cwd: androidDir,
         logger,
         lineTransformer: (line) => {
@@ -31,67 +39,10 @@ async function runGradleCommand({ logger, gradleCommand, androidDir, env, extraE
             LC_ALL: 'C.UTF-8',
         },
     });
-    if (env.EAS_BUILD_RUNNER === 'eas-build' && process.platform === 'linux') {
-        adjustOOMScore(spawnPromise, logger);
-    }
-    await spawnPromise;
-}
-/**
- * OOM Killer sometimes kills worker server while build is exceeding memory limits.
- * `oom_score_adj` is a value between -1000 and 1000 and it defaults to 0.
- * It defines which process is more likely to get killed (higher value more likely).
- *
- * This function sets oom_score_adj for Gradle process and all its child processes.
- */
-function adjustOOMScore(spawnPromise, logger) {
-    setTimeout(async () => {
-        try {
-            (0, assert_1.default)(spawnPromise.child.pid);
-            const pids = await getParentAndDescendantProcessPidsAsync(spawnPromise.child.pid);
-            await Promise.all(pids.map(async (pid) => {
-                // Value 800 is just a guess here. It's probably higher than most other
-                // process. I didn't want to set it any higher, because I'm not sure if OOM Killer
-                // can start killing processes when there is still enough memory left.
-                const oomScoreOverride = 800;
-                await fs_extra_1.default.writeFile(`/proc/${pid}/oom_score_adj`, `${oomScoreOverride}\n`);
-            }));
-        }
-        catch (err) {
-            logger.debug({ err, stderr: err?.stderr }, 'Failed to override oom_score_adj');
-        }
-    }, 
-    // Wait 20 seconds to make sure all child processes are started
-    20000);
 }
-async function getChildrenPidsAsync(parentPids) {
-    try {
-        const result = await (0, turtle_spawn_1.default)('pgrep', ['-P', parentPids.join(',')], {
-            stdio: 'pipe',
-        });
-        return result.stdout
-            .toString()
-            .split('\n')
-            .map(i => Number(i.trim()))
-            .filter(i => i);
-    }
-    catch {
-        return [];
-    }
-}
-async function getParentAndDescendantProcessPidsAsync(ppid) {
-    const children = new Set([ppid]);
-    let shouldCheckAgain = true;
-    while (shouldCheckAgain) {
-        const pids = await getChildrenPidsAsync([...children]);
-        shouldCheckAgain = false;
-        for (const pid of pids) {
-            if (!children.has(pid)) {
-                shouldCheckAgain = true;
-                children.add(pid);
-            }
-        }
-    }
-    return [...children];
+function getGradleShellCommand({ gradleCommand, oomScoreAdj, verboseFlag, }) {
+    const oomScoreAdjPrefix = oomScoreAdj === undefined ? '' : `echo ${oomScoreAdj} > /proc/$$/oom_score_adj || true; `;
+    return `${oomScoreAdjPrefix}exec ./gradlew ${gradleCommand} --profile ${verboseFlag}`;
 }
 function resolveGradleCommand(job, command) {
     if (command) {

package/dist/steps/utils/argentArtifacts.d.ts

@@ -8,15 +8,17 @@ declare const ArgentArtifactSchema: z.ZodObject<{
     isDirectory: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type ArgentArtifact = z.infer<typeof ArgentArtifactSchema>;
-export declare function pollArgentArtifactsForUploadAsync(ctx: CustomBuildContext, { deviceRunSessionId, toolsUrl, toolsAuthToken, logger, }: {
+export declare function pollArgentArtifactsForUploadAsync(ctx: CustomBuildContext, { deviceRunSessionId, toolsUrl, toolsAuthToken, logger, signal, }: {
     deviceRunSessionId: string;
     toolsUrl: string;
     toolsAuthToken?: string;
     logger: bunyan;
-}): Promise<never>;
-export declare function listArgentArtifactsAsync({ toolsUrl, toolsAuthToken, }: {
+    signal: AbortSignal;
+}): Promise<void>;
+export declare function listArgentArtifactsAsync({ toolsUrl, toolsAuthToken, signal, }: {
     toolsUrl: string;
     toolsAuthToken?: string;
+    signal?: AbortSignal;
 }): Promise<ArgentArtifact[]>;
 export declare function uploadArgentArtifactAsync(ctx: CustomBuildContext, { deviceRunSessionId, toolsUrl, toolsAuthToken, artifact, logger, }: {
     deviceRunSessionId: string;