@donotuse/eas-cli 18.5.0-rc.1

package/build/build/local.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalBuildMode = void 0;
+exports.runLocalBuildAsync = runLocalBuildAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const api_1 = require("../api");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const ora_1 = require("../ora");
+const PLUGIN_PACKAGE_NAME = 'eas-cli-local-build-plugin';
+const PLUGIN_PACKAGE_VERSION = eas_build_job_1.version; // should match version of @expo/eas-build-job
+var LocalBuildMode;
+(function (LocalBuildMode) {
+    /**
+     * Local build that users can run on their own machines. Instead
+     * of sending build request to EAS Servers it's passing it as an argument
+     * to local-build-plugin, that will run the build locally.
+     *
+     * Triggered when running `eas build --local`.
+     */
+    LocalBuildMode["LOCAL_BUILD_PLUGIN"] = "local-build-plugin";
+    /**
+     * Type of local build that is not accessible to users directly. When
+     * cloud build is triggered by git based integration, we are running
+     * in this mode. Instead of sending build request to EAS Servers it's
+     * printing it to the stdout as JSON, so EAS Build worker can read it.
+     */
+    LocalBuildMode["INTERNAL"] = "internal";
+})(LocalBuildMode || (exports.LocalBuildMode = LocalBuildMode = {}));
+async function runLocalBuildAsync(job, metadata, options, env) {
+    const { command, args } = await getCommandAndArgsAsync(job, metadata);
+    let spinner;
+    if (!options.verbose) {
+        spinner = (0, ora_1.ora)().start(options.skipNativeBuild ? 'Preparing project' : 'Building project');
+    }
+    let childProcess;
+    const interruptHandler = () => {
+        if (childProcess) {
+            childProcess.kill();
+        }
+    };
+    process.on('SIGINT', interruptHandler);
+    try {
+        const mergedEnv = {
+            ...env,
+            ...process.env,
+            EAS_LOCAL_BUILD_WORKINGDIR: options.workingdir ?? process.env.EAS_LOCAL_BUILD_WORKINGDIR,
+            __API_SERVER_URL: (0, api_1.getExpoApiBaseUrl)(),
+            ...(options.skipCleanup || options.skipNativeBuild
+                ? { EAS_LOCAL_BUILD_SKIP_CLEANUP: '1' }
+                : {}),
+            ...(options.skipNativeBuild ? { EAS_LOCAL_BUILD_SKIP_NATIVE_BUILD: '1' } : {}),
+            ...(options.artifactsDir ? { EAS_LOCAL_BUILD_ARTIFACTS_DIR: options.artifactsDir } : {}),
+            ...(options.artifactPath ? { EAS_LOCAL_BUILD_ARTIFACT_PATH: options.artifactPath } : {}),
+        };
+        // log command execution to assist in debugging local builds
+        log_1.default.debug('Running local build, using local-build-plugin', {
+            command,
+            args,
+            env: mergedEnv,
+        });
+        const spawnPromise = (0, spawn_async_1.default)(command, args, {
+            stdio: options.verbose ? 'inherit' : 'pipe',
+            env: mergedEnv,
+        });
+        childProcess = spawnPromise.child;
+        await spawnPromise;
+    }
+    finally {
+        process.removeListener('SIGINT', interruptHandler);
+        spinner?.stop();
+    }
+}
+async function getCommandAndArgsAsync(job, metadata) {
+    const jobAndMetadataBase64 = Buffer.from(JSON.stringify({ job, metadata })).toString('base64');
+    if (process.env.EAS_LOCAL_BUILD_PLUGIN_PATH) {
+        return {
+            command: process.env.EAS_LOCAL_BUILD_PLUGIN_PATH,
+            args: [jobAndMetadataBase64],
+        };
+    }
+    else {
+        const args = [`${PLUGIN_PACKAGE_NAME}@${PLUGIN_PACKAGE_VERSION}`, jobAndMetadataBase64];
+        if (await isAtLeastNpm7Async()) {
+            // npx shipped with npm >= 7.0.0 requires the "-y" flag to run commands without
+            // prompting the user to install a package that is used for the first time
+            args.unshift('-y');
+        }
+        return {
+            command: 'npx',
+            args,
+        };
+    }
+}
+async function isAtLeastNpm7Async() {
+    const version = (await (0, spawn_async_1.default)('npm', ['--version'])).stdout.trim();
+    return semver_1.default.gte(version, '7.0.0');
+}

package/build/build/metadata.d.ts

@@ -0,0 +1,8 @@
+import { Metadata, Platform } from '@expo/eas-build-job';
+import { BuildContext } from './context';
+export declare function collectMetadataAsync<T extends Platform>(ctx: BuildContext<T>, runtimeAndFingerprintMetadata: {
+    runtimeVersion?: string | undefined;
+    fingerprintHash?: string | undefined;
+}): Promise<Metadata>;
+export declare function getReactNativeVersionAsync(projectDir: string): Promise<string | undefined>;
+export declare function truncateGitCommitMessage(msg: string | undefined, maxLength?: number): string | undefined;

package/build/build/metadata.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectMetadataAsync = collectMetadataAsync;
+exports.getReactNativeVersionAsync = getReactNativeVersionAsync;
+exports.truncateGitCommitMessage = truncateGitCommitMessage;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const resolve_from_1 = tslib_1.__importDefault(require("resolve-from"));
+const version_1 = require("./android/version");
+const version_2 = require("./ios/version");
+const local_1 = require("./local");
+const types_1 = require("./types");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const projectUtils_1 = require("../project/projectUtils");
+const UpdatesModule_1 = require("../update/android/UpdatesModule");
+const UpdatesModule_2 = require("../update/ios/UpdatesModule");
+const easCli_1 = require("../utils/easCli");
+const User_1 = require("../user/User");
+async function collectMetadataAsync(ctx, runtimeAndFingerprintMetadata) {
+    const channelObject = await resolveChannelAsync(ctx);
+    const distribution = ctx.buildProfile.distribution ?? types_1.BuildDistributionType.STORE;
+    const metadata = {
+        trackingContext: ctx.analyticsEventProperties,
+        ...(await maybeResolveVersionsAsync(ctx)),
+        cliVersion: easCli_1.easCliVersion,
+        workflow: ctx.workflow,
+        credentialsSource: ctx.buildProfile.credentialsSource,
+        sdkVersion: ctx.exp.sdkVersion,
+        runtimeVersion: runtimeAndFingerprintMetadata?.runtimeVersion,
+        fingerprintHash: runtimeAndFingerprintMetadata?.fingerprintHash,
+        reactNativeVersion: await getReactNativeVersionAsync(ctx.projectDir),
+        ...channelObject,
+        distribution,
+        appName: ctx.exp.name,
+        appIdentifier: resolveAppIdentifier(ctx),
+        buildProfile: ctx.buildProfileName,
+        gitCommitHash: await ctx.vcsClient.getCommitHashAsync(),
+        gitCommitMessage: truncateGitCommitMessage((await ctx.vcsClient.getLastCommitMessageAsync()) ?? undefined),
+        isGitWorkingTreeDirty: ctx.localBuildOptions.localBuildMode === local_1.LocalBuildMode.INTERNAL
+            ? false
+            : await ctx.vcsClient.hasUncommittedChangesAsync(),
+        username: (0, User_1.getActorUsername)(ctx.user) ?? undefined,
+        message: ctx.message,
+        ...(ctx.platform === eas_build_job_1.Platform.IOS && {
+            iosEnterpriseProvisioning: resolveIosEnterpriseProvisioning(ctx),
+        }),
+        runWithNoWaitFlag: ctx.noWait,
+        runFromCI: ctx.runFromCI,
+        customWorkflowName: ctx.customBuildConfigMetadata?.workflowName,
+        developmentClient: ctx.developmentClient,
+        requiredPackageManager: ctx.requiredPackageManager ?? undefined,
+        selectedImage: ctx.buildProfile.image,
+        customNodeVersion: ctx.buildProfile.node,
+        simulator: 'simulator' in ctx.buildProfile && ctx.buildProfile.simulator,
+    };
+    return (0, eas_build_job_1.sanitizeMetadata)(metadata);
+}
+async function maybeResolveVersionsAsync(ctx) {
+    if (ctx.platform === eas_build_job_1.Platform.IOS) {
+        const iosContext = ctx;
+        const resolvedVersion = await (0, version_2.maybeResolveVersionsAsync)(ctx.projectDir, ctx.exp, iosContext.ios.targets, ctx.vcsClient);
+        if (iosContext.ios.buildNumberOverride) {
+            return {
+                ...resolvedVersion,
+                appBuildVersion: iosContext.ios.buildNumberOverride,
+            };
+        }
+        return resolvedVersion;
+    }
+    else if (ctx.platform === eas_build_job_1.Platform.ANDROID) {
+        const androidCtx = ctx;
+        const resolvedVersion = await (0, version_1.maybeResolveVersionsAsync)(ctx.projectDir, ctx.exp, androidCtx.buildProfile, ctx.vcsClient);
+        if (androidCtx.android.versionCodeOverride) {
+            return {
+                ...resolvedVersion,
+                appBuildVersion: androidCtx.android.versionCodeOverride,
+            };
+        }
+        return resolvedVersion;
+    }
+    else {
+        throw new Error(`Unsupported platform ${ctx.platform}`);
+    }
+}
+function resolveAppIdentifier(ctx) {
+    if (ctx.platform === eas_build_job_1.Platform.IOS) {
+        return ctx.ios.bundleIdentifier;
+    }
+    else {
+        return ctx.android.applicationId;
+    }
+}
+async function resolveChannelAsync(ctx) {
+    if (!(0, projectUtils_1.isExpoUpdatesInstalled)(ctx.projectDir)) {
+        return null;
+    }
+    if (ctx.buildProfile.channel) {
+        return { channel: ctx.buildProfile.channel };
+    }
+    const channel = await getNativeChannelAsync(ctx);
+    if (channel) {
+        return { channel };
+    }
+    return null;
+}
+async function getNativeChannelAsync(ctx) {
+    switch (ctx.platform) {
+        case eas_build_job_1.Platform.ANDROID: {
+            return (await (0, UpdatesModule_1.readChannelSafelyAsync)(ctx.projectDir)) ?? undefined;
+        }
+        case eas_build_job_1.Platform.IOS: {
+            return (await (0, UpdatesModule_2.readChannelSafelyAsync)(ctx.projectDir)) ?? undefined;
+        }
+    }
+    return undefined;
+}
+async function getReactNativeVersionAsync(projectDir) {
+    try {
+        const reactNativePackageJsonPath = (0, resolve_from_1.default)(projectDir, 'react-native/package.json');
+        return (await fs_extra_1.default.readJson(reactNativePackageJsonPath)).version;
+    }
+    catch (err) {
+        log_1.default.debug('Failed to resolve react-native version:');
+        log_1.default.debug(err);
+        return undefined;
+    }
+}
+function resolveIosEnterpriseProvisioning(ctx) {
+    return ctx.buildProfile.enterpriseProvisioning;
+}
+function truncateGitCommitMessage(msg, maxLength = 4096) {
+    if (msg === undefined) {
+        return undefined;
+    }
+    return msg.length > maxLength ? `${msg.substring(0, maxLength - 3)}...` : msg;
+}

package/build/build/queries.d.ts

@@ -0,0 +1,22 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { PaginatedQueryOptions } from '../commandUtils/pagination';
+import { BuildFilter, BuildFragment } from '../graphql/generated';
+export declare const BUILDS_LIMIT = 50;
+export declare function listAndRenderBuildsOnAppAsync(graphqlClient: ExpoGraphqlClient, { projectId, projectDisplayName, filter, paginatedQueryOptions, }: {
+    projectId: string;
+    projectDisplayName: string;
+    filter?: BuildFilter;
+    paginatedQueryOptions: PaginatedQueryOptions;
+}): Promise<void>;
+export declare function listAndSelectBuildOnAppAsync(graphqlClient: ExpoGraphqlClient, { projectId, title, filter, paginatedQueryOptions, selectPromptDisabledFunction, selectPromptWarningMessage, }: {
+    projectId: string;
+    title: string;
+    filter?: BuildFilter;
+    paginatedQueryOptions: PaginatedQueryOptions;
+    selectPromptDisabledFunction?: (build: BuildFragment) => boolean;
+    selectPromptWarningMessage?: string;
+}): Promise<BuildFragment | null>;
+export declare function getLatestBuildAsync(graphqlClient: ExpoGraphqlClient, { projectId, filter, }: {
+    projectId: string;
+    filter?: BuildFilter;
+}): Promise<BuildFragment | null>;

package/build/build/queries.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILDS_LIMIT = void 0;
+exports.listAndRenderBuildsOnAppAsync = listAndRenderBuildsOnAppAsync;
+exports.listAndSelectBuildOnAppAsync = listAndSelectBuildOnAppAsync;
+exports.getLatestBuildAsync = getLatestBuildAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const formatBuild_1 = require("./utils/formatBuild");
+const generated_1 = require("../graphql/generated");
+const BuildQuery_1 = require("../graphql/queries/BuildQuery");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const date_1 = require("../utils/date");
+const json_1 = require("../utils/json");
+const queries_1 = require("../utils/queries");
+exports.BUILDS_LIMIT = 50;
+async function listAndRenderBuildsOnAppAsync(graphqlClient, { projectId, projectDisplayName, filter, paginatedQueryOptions, }) {
+    if (paginatedQueryOptions.nonInteractive) {
+        const builds = await BuildQuery_1.BuildQuery.viewBuildsOnAppAsync(graphqlClient, {
+            appId: projectId,
+            limit: paginatedQueryOptions.limit ?? exports.BUILDS_LIMIT,
+            offset: paginatedQueryOptions.offset,
+            filter,
+        });
+        renderPageOfBuilds({ builds, projectDisplayName, paginatedQueryOptions });
+    }
+    else {
+        await (0, queries_1.paginatedQueryWithConfirmPromptAsync)({
+            limit: paginatedQueryOptions.limit ?? exports.BUILDS_LIMIT,
+            offset: paginatedQueryOptions.offset,
+            queryToPerform: (limit, offset) => BuildQuery_1.BuildQuery.viewBuildsOnAppAsync(graphqlClient, {
+                appId: projectId,
+                limit,
+                offset,
+                filter,
+            }),
+            promptOptions: {
+                title: 'Load more builds?',
+                renderListItems: builds => {
+                    renderPageOfBuilds({ builds, projectDisplayName, paginatedQueryOptions });
+                },
+            },
+        });
+    }
+}
+async function listAndSelectBuildOnAppAsync(graphqlClient, { projectId, title, filter, paginatedQueryOptions, selectPromptDisabledFunction, selectPromptWarningMessage, }) {
+    if (paginatedQueryOptions.nonInteractive) {
+        const builds = await BuildQuery_1.BuildQuery.viewBuildsOnAppAsync(graphqlClient, {
+            appId: projectId,
+            limit: paginatedQueryOptions.limit ?? exports.BUILDS_LIMIT,
+            offset: paginatedQueryOptions.offset,
+            filter,
+        });
+        if (builds.length === 0) {
+            throw new Error('No builds found for this project.');
+        }
+        const buildList = builds
+            .map(b => `${b.id} (platform: ${b.platform}, status: ${b.status}${b.buildProfile ? `, profile: ${b.buildProfile}` : ''})`)
+            .join('\n  ');
+        throw new Error(`Unable to select a build in non-interactive mode. Available builds:\n  ${buildList}`);
+    }
+    else {
+        const selectedBuild = await (0, queries_1.paginatedQueryWithSelectPromptAsync)({
+            limit: paginatedQueryOptions.limit ?? exports.BUILDS_LIMIT,
+            offset: paginatedQueryOptions.offset,
+            queryToPerform: (limit, offset) => BuildQuery_1.BuildQuery.viewBuildsOnAppAsync(graphqlClient, {
+                appId: projectId,
+                limit,
+                offset,
+                filter,
+            }),
+            promptOptions: {
+                title,
+                getIdentifierForQueryItem: build => build.id,
+                makePartialChoiceObject: createBuildToPartialChoiceMaker(selectPromptDisabledFunction),
+                selectPromptWarningMessage,
+            },
+        });
+        return selectedBuild ?? null;
+    }
+}
+function createBuildToPartialChoiceMaker(selectPromptDisabledFunction) {
+    return (build) => {
+        const splitCommitMessage = build.gitCommitMessage?.split('\n');
+        const formattedCommitData = build.gitCommitHash && splitCommitMessage && splitCommitMessage.length > 0
+            ? `${build.gitCommitHash.slice(0, 7)} "${chalk_1.default.bold(splitCommitMessage[0] + (splitCommitMessage.length > 1 ? '…' : ''))}"`
+            : null;
+        const descriptionItems = [
+            { name: 'Version', value: build.appVersion ? chalk_1.default.bold(build.appVersion) : null },
+            { name: 'Commit', value: formattedCommitData },
+            {
+                name: 'Message',
+                value: build.message
+                    ? chalk_1.default.bold(build.message.length > 200 ? `${build.message.slice(0, 200)}...` : build.message)
+                    : null,
+            },
+            {
+                name: build.platform === generated_1.AppPlatform.Ios ? 'Build number' : 'Version code',
+                value: build.appBuildVersion ? chalk_1.default.bold(build.appBuildVersion) : null,
+            },
+            { name: 'Profile', value: build.buildProfile ? chalk_1.default.bold(build.buildProfile) : null },
+        ];
+        const filteredDescriptionArray = descriptionItems
+            .filter(item => item.value)
+            .map(item => `${chalk_1.default.bold(item.name)}: ${item.value}`);
+        return {
+            title: `${chalk_1.default.bold(`ID:`)} ${build.id} (${chalk_1.default.bold(`${(0, date_1.fromNow)(new Date(build.completedAt))} ago`)})`,
+            description: filteredDescriptionArray.length > 0 ? filteredDescriptionArray.join('\n') : '',
+            disabled: selectPromptDisabledFunction?.(build),
+        };
+    };
+}
+async function getLatestBuildAsync(graphqlClient, { projectId, filter, }) {
+    const builds = await BuildQuery_1.BuildQuery.viewBuildsOnAppAsync(graphqlClient, {
+        appId: projectId,
+        limit: 1,
+        offset: 0,
+        filter,
+    });
+    if (builds.length === 0) {
+        return null;
+    }
+    return builds[0];
+}
+function renderPageOfBuilds({ builds, projectDisplayName, paginatedQueryOptions, }) {
+    if (paginatedQueryOptions.json) {
+        (0, json_1.printJsonOnlyOutput)(builds);
+    }
+    else {
+        const list = builds.map(build => (0, formatBuild_1.formatGraphQLBuild)(build)).join(`\n\n${chalk_1.default.dim('———')}\n\n`);
+        log_1.default.addNewLineIfNone();
+        log_1.default.log(chalk_1.default.bold(`Builds for ${projectDisplayName}:`));
+        log_1.default.log(`\n${list}`);
+    }
+}

package/build/build/runBuildAndSubmit.d.ts

@@ -0,0 +1,44 @@
+import { Env } from '@expo/eas-build-job';
+import { ResourceClass } from '@expo/eas-json';
+import { LoggerLevel } from '@expo/logger';
+import { LocalBuildOptions } from './local';
+import { Analytics } from '../analytics/AnalyticsManager';
+import { DynamicConfigContextFn } from '../commandUtils/context/DynamicProjectConfigContextField';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { BuildFragment } from '../graphql/generated';
+import { RequestedPlatform } from '../platform';
+import { Actor } from '../user/User';
+import { ProfileData } from '../utils/profiles';
+import { Client } from '../vcs/vcs';
+export interface BuildFlags {
+    requestedPlatform: RequestedPlatform;
+    profile?: string;
+    nonInteractive: boolean;
+    wait: boolean;
+    clearCache: boolean;
+    json: boolean;
+    autoSubmit: boolean;
+    submitProfile?: string;
+    localBuildOptions: LocalBuildOptions;
+    resourceClass?: ResourceClass;
+    message?: string;
+    buildLoggerLevel?: LoggerLevel;
+    freezeCredentials: boolean;
+    isVerboseLoggingEnabled?: boolean;
+    whatToTest?: string;
+}
+export declare function runBuildAndSubmitAsync({ graphqlClient, analytics, vcsClient, projectDir, flags, actor, getDynamicPrivateProjectConfigAsync, downloadSimBuildAutoConfirm, envOverride, }: {
+    graphqlClient: ExpoGraphqlClient;
+    analytics: Analytics;
+    vcsClient: Client;
+    projectDir: string;
+    flags: BuildFlags;
+    actor: Actor;
+    getDynamicPrivateProjectConfigAsync: DynamicConfigContextFn;
+    downloadSimBuildAutoConfirm?: boolean;
+    envOverride?: Env;
+}): Promise<{
+    buildIds: string[];
+    buildProfiles?: ProfileData<'build'>[];
+}>;
+export declare function downloadAndRunAsync(build: BuildFragment): Promise<void>;