eas-cli 16.14.1 → 16.16.0

package/build/commandUtils/workflow/fetchLogs.d.ts

@@ -0,0 +1,2 @@
+import { WorkflowJobResult } from './types';
+export declare function fetchRawLogsForJobAsync(job: WorkflowJobResult): Promise<string | null>;

package/build/commandUtils/workflow/fetchLogs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRawLogsForJobAsync = void 0;
+// This function is in a separate module for testing purposes
+async function fetchRawLogsForJobAsync(job) {
+    const firstLogFileUrl = job.turtleJobRun?.logFileUrls?.[0];
+    if (!firstLogFileUrl) {
+        return null;
+    }
+    const response = await fetch(firstLogFileUrl, {
+        method: 'GET',
+    });
+    const rawLogs = await response.text();
+    return rawLogs;
+}
+exports.fetchRawLogsForJobAsync = fetchRawLogsForJobAsync;

package/build/commandUtils/workflow/stateMachine.d.ts

@@ -0,0 +1,44 @@
+import { WorkflowJobResult, WorkflowLogs } from './types';
+import { ExpoGraphqlClient } from '../context/contextUtils/createGraphqlClient';
+export declare enum WorkflowCommandSelectionStateValue {
+    WORKFLOW_RUN_SELECTION = "WORKFLOW_RUN_SELECTION",
+    WORKFLOW_JOB_SELECTION = "WORKFLOW_JOB_SELECTION",
+    WORKFLOW_STEP_SELECTION = "WORKFLOW_STEP_SELECTION",
+    FINISH = "FINISH",
+    ERROR = "ERROR"
+}
+export type WorkflowCommandSelectionState = {
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string;
+    nonInteractive: boolean;
+    allSteps: boolean;
+    state: WorkflowCommandSelectionStateValue;
+    runId?: string;
+    jobId?: string;
+    step?: string;
+    job?: WorkflowJobResult;
+    logs?: WorkflowLogs | null;
+    message?: string;
+};
+export type WorkflowCommandSelectionStateParameters = Omit<WorkflowCommandSelectionState, 'graphqlClient' | 'projectId' | 'state' | 'nonInteractive' | 'allSteps'>;
+export type WorkflowCommandSelectionAction = (prevState: WorkflowCommandSelectionState) => Promise<WorkflowCommandSelectionState>;
+export declare function moveToNewWorkflowCommandSelectionState(previousState: WorkflowCommandSelectionState, newStateValue: WorkflowCommandSelectionStateValue, parameters: WorkflowCommandSelectionStateParameters): WorkflowCommandSelectionState;
+export declare function moveToWorkflowRunSelectionState(previousState: WorkflowCommandSelectionState, params?: {
+    runId?: string | undefined;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowJobSelectionState(previousState: WorkflowCommandSelectionState, params: {
+    jobId?: string | undefined;
+    runId?: string | undefined;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowStepSelectionState(previousState: WorkflowCommandSelectionState, params: {
+    job: WorkflowJobResult;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowSelectionFinishedState(previousState: WorkflowCommandSelectionState, params: {
+    step: string;
+    logs: WorkflowLogs;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowSelectionErrorState(previousState: WorkflowCommandSelectionState, message: string): WorkflowCommandSelectionState;
+export declare const workflowRunSelectionAction: WorkflowCommandSelectionAction;
+export declare const workflowJobSelectionAction: WorkflowCommandSelectionAction;
+export declare const workflowStepSelectionAction: WorkflowCommandSelectionAction;
+export declare const executeWorkflowSelectionActionsAsync: WorkflowCommandSelectionAction;

package/build/commandUtils/workflow/stateMachine.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorkflowSelectionActionsAsync = exports.workflowStepSelectionAction = exports.workflowJobSelectionAction = exports.workflowRunSelectionAction = exports.moveToWorkflowSelectionErrorState = exports.moveToWorkflowSelectionFinishedState = exports.moveToWorkflowStepSelectionState = exports.moveToWorkflowJobSelectionState = exports.moveToWorkflowRunSelectionState = exports.moveToNewWorkflowCommandSelectionState = exports.WorkflowCommandSelectionStateValue = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("./utils");
+const AppQuery_1 = require("../../graphql/queries/AppQuery");
+const WorkflowJobQuery_1 = require("../../graphql/queries/WorkflowJobQuery");
+const WorkflowRunQuery_1 = require("../../graphql/queries/WorkflowRunQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+/*
+ * State machine types and functions for moving between different workflow command states
+ */
+var WorkflowCommandSelectionStateValue;
+(function (WorkflowCommandSelectionStateValue) {
+    WorkflowCommandSelectionStateValue["WORKFLOW_RUN_SELECTION"] = "WORKFLOW_RUN_SELECTION";
+    WorkflowCommandSelectionStateValue["WORKFLOW_JOB_SELECTION"] = "WORKFLOW_JOB_SELECTION";
+    WorkflowCommandSelectionStateValue["WORKFLOW_STEP_SELECTION"] = "WORKFLOW_STEP_SELECTION";
+    WorkflowCommandSelectionStateValue["FINISH"] = "FINISH";
+    WorkflowCommandSelectionStateValue["ERROR"] = "ERROR";
+})(WorkflowCommandSelectionStateValue || (exports.WorkflowCommandSelectionStateValue = WorkflowCommandSelectionStateValue = {}));
+const workflowCommandSelectionAllowedStateTransitions = {
+    WORKFLOW_JOB_SELECTION: [
+        WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION,
+        WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION,
+        WorkflowCommandSelectionStateValue.ERROR,
+        WorkflowCommandSelectionStateValue.FINISH,
+    ],
+    WORKFLOW_RUN_SELECTION: [
+        WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION,
+        WorkflowCommandSelectionStateValue.ERROR,
+    ],
+    WORKFLOW_STEP_SELECTION: [
+        WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION,
+        WorkflowCommandSelectionStateValue.ERROR,
+        WorkflowCommandSelectionStateValue.FINISH,
+    ],
+    ERROR: [WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION],
+    FINISH: [],
+};
+function moveToNewWorkflowCommandSelectionState(previousState, newStateValue, parameters) {
+    if (!workflowCommandSelectionAllowedStateTransitions[previousState.state].includes(newStateValue)) {
+        const errorMessage = `Invalid state transition from ${previousState.state} to ${newStateValue}. Allowed transitions from ${previousState.state}: ${workflowCommandSelectionAllowedStateTransitions[previousState.state].join(', ')}`;
+        throw new Error(errorMessage);
+    }
+    return {
+        ...previousState,
+        state: newStateValue,
+        ...parameters,
+    };
+}
+exports.moveToNewWorkflowCommandSelectionState = moveToNewWorkflowCommandSelectionState;
+function moveToWorkflowRunSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION, {
+        runId: params?.runId,
+        jobId: undefined,
+    });
+}
+exports.moveToWorkflowRunSelectionState = moveToWorkflowRunSelectionState;
+function moveToWorkflowJobSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION, params);
+}
+exports.moveToWorkflowJobSelectionState = moveToWorkflowJobSelectionState;
+function moveToWorkflowStepSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION, params);
+}
+exports.moveToWorkflowStepSelectionState = moveToWorkflowStepSelectionState;
+function moveToWorkflowSelectionFinishedState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.FINISH, params);
+}
+exports.moveToWorkflowSelectionFinishedState = moveToWorkflowSelectionFinishedState;
+function moveToWorkflowSelectionErrorState(previousState, message) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.ERROR, {
+        message,
+    });
+}
+exports.moveToWorkflowSelectionErrorState = moveToWorkflowSelectionErrorState;
+// eslint-disable-next-line async-protect/async-suffix
+const workflowRunSelectionAction = async (prevState) => {
+    const { graphqlClient, projectId, runId, jobId, allSteps } = prevState;
+    log_1.default.debug(`workflowRunSelectionAction: runId = ${runId}, jobId = ${jobId}, allSteps = ${allSteps}`);
+    if (runId) {
+        return moveToWorkflowJobSelectionState(prevState, { runId });
+    }
+    const runs = await AppQuery_1.AppQuery.byIdWorkflowRunsFilteredByStatusAsync(graphqlClient, projectId, undefined, 20);
+    if (runs.length === 0) {
+        return moveToWorkflowSelectionErrorState(prevState, 'No workflow runs found');
+    }
+    const processedRuns = (0, utils_1.processWorkflowRuns)(runs);
+    const choices = processedRuns.map(run => (0, utils_1.choiceFromWorkflowRun)(run));
+    const selectedId = (await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'selectedRun',
+        message: 'Select a workflow run:',
+        choices,
+    })).selectedRun;
+    return moveToWorkflowJobSelectionState(prevState, { runId: selectedId });
+};
+exports.workflowRunSelectionAction = workflowRunSelectionAction;
+// eslint-disable-next-line async-protect/async-suffix
+const workflowJobSelectionAction = async (prevState) => {
+    const { graphqlClient, runId, jobId, nonInteractive, allSteps } = prevState;
+    log_1.default.debug(`workflowJobSelectionAction: runId = ${runId}, jobId = ${jobId}, allSteps = ${allSteps}`);
+    if (jobId) {
+        let workflowJobResult = undefined;
+        try {
+            workflowJobResult = await WorkflowJobQuery_1.WorkflowJobQuery.byIdAsync(graphqlClient, jobId, {
+                useCache: false,
+            });
+            return moveToWorkflowStepSelectionState(prevState, { job: workflowJobResult });
+        }
+        catch { }
+        if (nonInteractive && !workflowJobResult) {
+            return moveToWorkflowSelectionErrorState(prevState, 'No workflow job found that matched the provided ID');
+        }
+        else {
+            // The passed in ID may be a run ID, pass it back to run selection action
+            return moveToWorkflowRunSelectionState(prevState, { runId: jobId });
+        }
+    }
+    else {
+        // No job ID was passed in
+        if (nonInteractive) {
+            return moveToWorkflowSelectionErrorState(prevState, 'No workflow job ID provided in non-interactive mode');
+        }
+        else if (!runId) {
+            // If no jobId or runId, we should go back to run selection
+            return moveToWorkflowRunSelectionState(prevState);
+        }
+        const workflowRunResult = await WorkflowRunQuery_1.WorkflowRunQuery.withJobsByIdAsync(graphqlClient, runId, {
+            useCache: false,
+        });
+        if (!workflowRunResult) {
+            return moveToWorkflowSelectionErrorState(prevState, 'No workflow run found that matched the provided ID');
+        }
+        const choices = [
+            ...workflowRunResult.jobs.map((job, i) => (0, utils_1.choiceFromWorkflowJob)(job, i)),
+            {
+                title: 'Go back and select a different workflow run',
+                value: -1,
+            },
+        ];
+        const selectedJobIndex = (await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'selectedJob',
+            message: 'Select a job:',
+            choices,
+        })).selectedJob;
+        if (selectedJobIndex === -1) {
+            return moveToWorkflowRunSelectionState(prevState);
+        }
+        const selectedJob = workflowRunResult.jobs[selectedJobIndex];
+        return moveToWorkflowStepSelectionState(prevState, { job: selectedJob });
+    }
+};
+exports.workflowJobSelectionAction = workflowJobSelectionAction;
+// eslint-disable-next-line async-protect/async-suffix
+const workflowStepSelectionAction = async (prevState) => {
+    const { job, allSteps } = prevState;
+    log_1.default.debug(`workflowStepSelectionAction: job = ${job?.id}, allSteps = ${allSteps}`);
+    if (!job) {
+        return moveToWorkflowSelectionErrorState(prevState, 'No job found');
+    }
+    const logs = await (0, utils_1.processLogsFromJobAsync)(job);
+    if (!logs) {
+        return moveToWorkflowSelectionErrorState(prevState, 'No logs found');
+    }
+    if (allSteps) {
+        return moveToWorkflowSelectionFinishedState(prevState, { step: '', logs });
+    }
+    const choices = [
+        ...(0, utils_1.choicesFromWorkflowLogs)(logs),
+        {
+            title: 'Go back and select a different workflow job',
+            value: 'go-back',
+        },
+    ];
+    const selectedStep = (await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'selectedStep',
+        message: 'Select a step:',
+        choices,
+    })).selectedStep ?? '';
+    if (selectedStep === 'go-back') {
+        return moveToWorkflowJobSelectionState(prevState, {
+            runId: job.workflowRun.id,
+            jobId: undefined,
+        });
+    }
+    return moveToWorkflowSelectionFinishedState(prevState, { step: selectedStep, logs });
+};
+exports.workflowStepSelectionAction = workflowStepSelectionAction;
+const executeWorkflowSelectionActionsAsync = async (prevState) => {
+    let currentState = prevState;
+    while (currentState.state !== WorkflowCommandSelectionStateValue.FINISH &&
+        currentState.state !== WorkflowCommandSelectionStateValue.ERROR) {
+        log_1.default.debug(`${currentState.state}`);
+        switch (currentState.state) {
+            case WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION:
+                currentState = await (0, exports.workflowJobSelectionAction)(currentState);
+                break;
+            case WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION:
+                currentState = await (0, exports.workflowRunSelectionAction)(currentState);
+                break;
+            case WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION:
+                currentState = await (0, exports.workflowStepSelectionAction)(currentState);
+                break;
+        }
+    }
+    return currentState;
+};
+exports.executeWorkflowSelectionActionsAsync = executeWorkflowSelectionActionsAsync;

package/build/commandUtils/workflow/types.d.ts

@@ -0,0 +1,39 @@
+import { WorkflowJobByIdQuery, WorkflowRunByIdWithJobsQuery } from '../../graphql/generated';
+export declare enum WorkflowTriggerType {
+    MANUAL = "Manual",
+    GITHUB = "GitHub",
+    SCHEDULED = "Scheduled",
+    OTHER = "Other"
+}
+export type WorkflowRunResult = {
+    id: string;
+    status: string;
+    gitCommitMessage: string | null;
+    gitCommitHash: string | null;
+    triggerType: WorkflowTriggerType;
+    trigger: string | null;
+    startedAt: string;
+    finishedAt: string;
+    workflowId: string;
+    workflowName: string | null;
+    workflowFileName: string;
+};
+export type WorkflowResult = {
+    id: string;
+    name?: string | null | undefined;
+    fileName: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type WorkflowJobResult = WorkflowRunByIdWithJobsQuery['workflowRuns']['byId']['jobs'][number] | WorkflowJobByIdQuery['workflowJobs']['byId'];
+export type WorkflowRunWithJobsResult = WorkflowRunResult & {
+    jobs: WorkflowJobResult[];
+    logs?: string;
+};
+export type WorkflowLogLine = {
+    time: string;
+    msg: string;
+    result?: string;
+    marker?: string;
+};
+export type WorkflowLogs = Map<string, WorkflowLogLine[]>;

package/build/commandUtils/workflow/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowTriggerType = void 0;
+/*
+ * Utility types for workflow commands
+ */
+var WorkflowTriggerType;
+(function (WorkflowTriggerType) {
+    WorkflowTriggerType["MANUAL"] = "Manual";
+    WorkflowTriggerType["GITHUB"] = "GitHub";
+    WorkflowTriggerType["SCHEDULED"] = "Scheduled";
+    WorkflowTriggerType["OTHER"] = "Other";
+})(WorkflowTriggerType || (exports.WorkflowTriggerType = WorkflowTriggerType = {}));

package/build/commandUtils/workflow/utils.d.ts

@@ -0,0 +1,12 @@
+import { WorkflowJobResult, WorkflowLogs, WorkflowRunResult, WorkflowTriggerType } from './types';
+import { WorkflowRunFragment } from '../../graphql/generated';
+import { Choice } from '../../prompts';
+export declare function computeTriggerInfoForWorkflowRun(run: WorkflowRunFragment): {
+    triggerType: WorkflowTriggerType;
+    trigger: string | null;
+};
+export declare function choiceFromWorkflowRun(run: WorkflowRunResult): Choice;
+export declare function choiceFromWorkflowJob(job: WorkflowJobResult, index: number): Choice;
+export declare function choicesFromWorkflowLogs(logs: WorkflowLogs): Choice[];
+export declare function processWorkflowRuns(runs: WorkflowRunFragment[]): WorkflowRunResult[];
+export declare function processLogsFromJobAsync(job: WorkflowJobResult): Promise<WorkflowLogs | null>;

package/build/commandUtils/workflow/utils.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processLogsFromJobAsync = exports.processWorkflowRuns = exports.choicesFromWorkflowLogs = exports.choiceFromWorkflowJob = exports.choiceFromWorkflowRun = exports.computeTriggerInfoForWorkflowRun = void 0;
+const fetchLogs_1 = require("./fetchLogs");
+const types_1 = require("./types");
+const generated_1 = require("../../graphql/generated");
+function computeTriggerInfoForWorkflowRun(run) {
+    let triggerType = types_1.WorkflowTriggerType.OTHER;
+    let trigger = '';
+    if (run.actor?.__typename === 'Robot') {
+        if (run.actor.firstName?.startsWith('GitHub App · ')) {
+            trigger = `${run.requestedGitRef ?? ''}@${run.gitCommitHash?.substring(0, 12) ?? ''}`;
+        }
+    }
+    else if (run.actor?.__typename === 'User') {
+        trigger = run.actor.username;
+    }
+    switch (run.triggerEventType) {
+        case generated_1.WorkflowRunTriggerEventType.Manual:
+            triggerType = types_1.WorkflowTriggerType.MANUAL;
+            break;
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestLabeled:
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestOpened:
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestReopened:
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestSynchronize:
+        case generated_1.WorkflowRunTriggerEventType.GithubPush:
+            triggerType = types_1.WorkflowTriggerType.GITHUB;
+            break;
+        case generated_1.WorkflowRunTriggerEventType.Schedule:
+            triggerType = types_1.WorkflowTriggerType.SCHEDULED;
+            trigger = run.triggeringSchedule ?? '';
+            break;
+    }
+    return { triggerType, trigger };
+}
+exports.computeTriggerInfoForWorkflowRun = computeTriggerInfoForWorkflowRun;
+function choiceFromWorkflowRun(run) {
+    const titleArray = [
+        run.workflowFileName,
+        run.status,
+        run.startedAt,
+        run.triggerType,
+        run.trigger,
+    ];
+    return {
+        title: titleArray.join(' - '),
+        value: run.id,
+        description: `ID: ${run.id}, Message: ${run.gitCommitMessage?.split('\n')[0] ?? ''}`,
+    };
+}
+exports.choiceFromWorkflowRun = choiceFromWorkflowRun;
+function choiceFromWorkflowJob(job, index) {
+    return {
+        title: `${job.name} - ${job.status}`,
+        value: index,
+        description: `ID: ${job.id}`,
+    };
+}
+exports.choiceFromWorkflowJob = choiceFromWorkflowJob;
+function choicesFromWorkflowLogs(logs) {
+    return Array.from(logs.keys()).map(step => {
+        const logLines = logs.get(step);
+        const stepStatus = logLines?.filter((line) => line.marker === 'end-step')[0]?.result ?? '';
+        return {
+            title: `${step} - ${stepStatus}`,
+            value: step,
+        };
+    });
+}
+exports.choicesFromWorkflowLogs = choicesFromWorkflowLogs;
+function processWorkflowRuns(runs) {
+    return runs.map(run => {
+        const finishedAt = run.status === generated_1.WorkflowRunStatus.InProgress ? null : run.updatedAt;
+        const { triggerType, trigger } = computeTriggerInfoForWorkflowRun(run);
+        return {
+            id: run.id,
+            status: run.status,
+            gitCommitMessage: run.gitCommitMessage?.split('\n')[0] ?? null,
+            gitCommitHash: run.gitCommitHash ?? null,
+            startedAt: run.createdAt,
+            finishedAt,
+            triggerType,
+            trigger,
+            workflowId: run.workflow.id,
+            workflowName: run.workflow.name ?? null,
+            workflowFileName: run.workflow.fileName,
+        };
+    });
+}
+exports.processWorkflowRuns = processWorkflowRuns;
+async function processLogsFromJobAsync(job) {
+    const rawLogs = await (0, fetchLogs_1.fetchRawLogsForJobAsync)(job);
+    if (!rawLogs) {
+        return null;
+    }
+    const logs = new Map();
+    const logKeys = new Set();
+    rawLogs.split('\n').forEach(line => {
+        try {
+            const parsedLine = JSON.parse(line);
+            const { result, marker } = parsedLine;
+            const { buildStepDisplayName, buildStepInternalId, time, msg } = parsedLine;
+            const stepId = buildStepDisplayName ?? buildStepInternalId;
+            if (stepId) {
+                if (!logKeys.has(stepId)) {
+                    logKeys.add(stepId);
+                    logs.set(stepId, []);
+                }
+                logs.get(stepId)?.push({ time, msg, result, marker });
+            }
+        }
+        catch { }
+    });
+    return logs;
+}
+exports.processLogsFromJobAsync = processLogsFromJobAsync;

package/build/commands/deploy/index.js

@@ -14,11 +14,11 @@ const log_1 = tslib_1.__importStar(require("../../log"));
 const ora_1 = require("../../ora");
 const projectUtils_1 = require("../../project/projectUtils");
 const json_1 = require("../../utils/json");
-const progress_1 = require("../../utils/progress");
 const WorkerAssets = tslib_1.__importStar(require("../../worker/assets"));
 const deployment_1 = require("../../worker/deployment");
 const upload_1 = require("../../worker/upload");
 const logs_1 = require("../../worker/utils/logs");
+const MAX_UPLOAD_SIZE = 5e8; // 500MB
 const isDirectory = (directoryPath) => node_fs_1.default.promises
     .stat(directoryPath)
     .then(stat => stat.isDirectory())
@@ -96,14 +96,11 @@ class WorkerDeploy extends EasCommand_1.default {
             }
         }
         async function uploadTarballAsync(tarPath, uploadUrl) {
+            const payload = { filePath: tarPath };
             const { response } = await (0, upload_1.uploadAsync)({
-                url: uploadUrl,
-                filePath: tarPath,
-                compress: false,
-                headers: {
-                    accept: 'application/json',
-                },
-            });
+                baseURL: uploadUrl,
+                method: 'POST',
+            }, payload);
             if (response.status === 413) {
                 throw new Error('Upload failed! (Payload too large)\n' +
                     `The files in "${path.relative(projectDir, projectDist.path)}" (at: ${projectDir}) exceed the maximum file size (10MB gzip).`);
@@ -116,7 +113,7 @@ class WorkerDeploy extends EasCommand_1.default {
                 if (!json.success || !json.result || typeof json.result !== 'object') {
                     throw new Error(json.message ? `Upload failed: ${json.message}` : 'Upload failed!');
                 }
-                const { id, fullName, token } = json.result;
+                const { id, fullName, token, upload } = json.result;
                 if (typeof token !== 'string') {
                     throw new Error('Upload failed: API failed to return a deployment token');
                 }
@@ -126,56 +123,57 @@ class WorkerDeploy extends EasCommand_1.default {
                 else if (typeof fullName !== 'string') {
                     throw new Error('Upload failed: API failed to return a script name');
                 }
+                else if (!Array.isArray(upload) && upload !== undefined) {
+                    throw new Error('Upload failed: API returned invalid asset upload instructions');
+                }
                 const baseURL = new URL('/', uploadUrl).toString();
-                return { id, fullName, baseURL, token };
+                return { id, fullName, baseURL, token, upload };
             }
         }
-        async function uploadAssetsAsync(assetMap, deployParams) {
-            const uploadParams = [];
-            const assetPath = projectDist.type === 'server' ? projectDist.clientPath : projectDist.path;
-            if (!assetPath) {
-                return;
+        async function uploadAssetsAsync(assetFiles, deployParams) {
+            const baseURL = new URL('/asset/', deployParams.baseURL);
+            const uploadInit = { baseURL, method: 'POST' };
+            uploadInit.baseURL.searchParams.set('token', deployParams.token);
+            const uploadPayloads = [];
+            if (deployParams.upload) {
+                const assetsBySHA512 = assetFiles.reduce((map, asset) => {
+                    map.set(asset.sha512, asset);
+                    return map;
+                }, new Map());
+                const payloads = deployParams.upload
+                    .map(instruction => instruction.sha512.map(sha512 => {
+                    const asset = assetsBySHA512.get(sha512);
+                    if (!asset) {
+                        // NOTE(@kitten): This should never happen
+                        throw new Error(`Uploading assets failed: API instructed us to upload an asset that does not exist`);
+                    }
+                    return asset;
+                }))
+                    .filter(assets => assets && assets.length > 0)
+                    .map(assets => (assets.length > 1 ? { multipart: assets } : { asset: assets[0] }));
+                uploadPayloads.push(...payloads);
             }
-            for await (const asset of WorkerAssets.listAssetMapFilesAsync(assetPath, assetMap)) {
-                const uploadURL = new URL(`/asset/${asset.sha512}`, deployParams.baseURL);
-                uploadURL.searchParams.set('token', deployParams.token);
-                uploadParams.push({ url: uploadURL.toString(), filePath: asset.path });
+            else {
+                // NOTE(@kitten): Legacy format which uploads assets one-by-one
+                uploadPayloads.push(...assetFiles.map(asset => ({ asset })));
             }
-            const progress = {
-                total: uploadParams.length,
-                pending: 0,
-                percent: 0,
-                transferred: 0,
-            };
-            const updateProgress = (0, progress_1.createProgressTracker)({
-                total: progress.total,
-                message(ratio) {
-                    const percent = `${Math.floor(ratio * 100)}`;
-                    const details = chalk_1.default.dim(`(${progress.pending} Pending, ${progress.transferred} Completed, ${progress.total} Total)`);
-                    return `Uploading assets: ${percent.padStart(3)}% ${details}`;
-                },
-                completedMessage: 'Uploaded assets',
-            });
+            const progressTotal = uploadPayloads.reduce((acc, payload) => acc + ('multipart' in payload ? payload.multipart.length : 1), 0);
+            const progressTracker = (0, upload_1.createProgressBar)(`Uploading ${progressTotal} assets`);
             try {
-                for await (const signal of (0, upload_1.batchUploadAsync)(uploadParams)) {
-                    if ('response' in signal) {
-                        progress.pending--;
-                        progress.percent = ++progress.transferred / progress.total;
-                    }
-                    else {
-                        progress.pending++;
-                    }
-                    updateProgress({ progress });
+                for await (const signal of (0, upload_1.batchUploadAsync)(uploadInit, uploadPayloads, progressTracker.update)) {
+                    progressTracker.update(signal.progress);
                 }
             }
             catch (error) {
-                updateProgress({ isComplete: true, error });
+                progressTracker.stop();
                 throw error;
             }
-            updateProgress({ isComplete: true });
+            finally {
+                progressTracker.stop();
+            }
         }
-        let assetMap;
         let tarPath;
+        let assetFiles;
         let deployResult;
         let progress = (0, ora_1.ora)('Preparing project').start();
         try {
@@ -189,9 +187,9 @@ class WorkerDeploy extends EasCommand_1.default {
                     'In case of conflict, the EAS environment variable values will be used: ' +
                     manifestResult.conflictingVariableNames.join(' '));
             }
-            assetMap = await WorkerAssets.createAssetMapAsync(projectDist.type === 'server' ? projectDist.clientPath : projectDist.path);
+            assetFiles = await WorkerAssets.collectAssetsAsync(projectDist.type === 'server' ? projectDist.clientPath : projectDist.path, { maxFileSize: MAX_UPLOAD_SIZE });
             tarPath = await WorkerAssets.packFilesIterableAsync(emitWorkerTarballAsync({
-                assetMap,
+                assetMap: WorkerAssets.assetsToAssetsMap(assetFiles),
                 manifest: manifestResult.manifest,
             }));
             if (flags.dryRun) {
@@ -232,7 +230,7 @@ class WorkerDeploy extends EasCommand_1.default {
             }
             throw error;
         }
-        await uploadAssetsAsync(assetMap, deployResult);
+        await uploadAssetsAsync(assetFiles, deployResult);
         await finalizeDeployAsync(deployResult);
         let deploymentAlias = null;
         if (flags.aliasName) {

package/build/commands/workflow/cancel.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
-const workflows_1 = require("../../commandUtils/workflows");
+const utils_1 = require("../../commandUtils/workflow/utils");
 const generated_1 = require("../../graphql/generated");
 const WorkflowRunMutation_1 = require("../../graphql/mutations/WorkflowRunMutation");
 const AppQuery_1 = require("../../graphql/queries/AppQuery");
@@ -44,7 +44,7 @@ class WorkflowRunCancel extends EasCommand_1.default {
             }
             // Run the workflow run list query and select runs to cancel
             const queryResult = await AppQuery_1.AppQuery.byIdWorkflowRunsFilteredByStatusAsync(graphqlClient, projectId, generated_1.WorkflowRunStatus.InProgress, 50);
-            const runs = (0, workflows_1.processWorkflowRuns)(queryResult);
+            const runs = (0, utils_1.processWorkflowRuns)(queryResult);
             if (runs.length === 0) {
                 log_1.default.warn('No workflow runs to cancel');
                 return;
@@ -53,10 +53,7 @@ class WorkflowRunCancel extends EasCommand_1.default {
                 type: 'multiselect',
                 name: 'selectedRuns',
                 message: 'Select IN_PROGRESS workflow runs to cancel',
-                choices: runs.map(run => ({
-                    title: `${run.id} - ${run.workflowFileName}, ${run.gitCommitMessage ?? ''}, ${run.startedAt}`,
-                    value: run.id,
-                })),
+                choices: runs.map(run => (0, utils_1.choiceFromWorkflowRun)(run)),
             });
             answers.selectedRuns.forEach((id) => {
                 workflowRunIds.add(id);