eoas 1.0.2 → 1.0.3

package/dist/commands/generate-certs.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class GenerateCerts extends Command {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}

package/dist/commands/generate-certs.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const code_signing_certificates_1 = require("@expo/code-signing-certificates");
+const core_1 = require("@oclif/core");
+const fs_extra_1 = require("fs-extra");
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importDefault(require("../lib/log"));
+const prompts_1 = require("../lib/prompts");
+class GenerateCerts extends core_1.Command {
+    static args = {};
+    static description = 'Generate private & public certificates for code signing';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {};
+    async run() {
+        const { certificateOutputDir } = await (0, prompts_1.promptAsync)({
+            message: 'In which directory would you like to store your code signing certificate (used by your expo app)?',
+            name: 'certificateOutputDir',
+            type: 'text',
+            initial: './certs',
+            validate: v => {
+                try {
+                    // eslint-disable-next-line
+                    (0, fs_extra_1.ensureDirSync)(path_1.default.join(process.cwd(), v));
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+        });
+        const { keyOutputDir } = await (0, prompts_1.promptAsync)({
+            message: 'In which directory would you like to store your key pair (used by your OTA Server) ?. ⚠️ Those certss are sensitive and should be kept private.',
+            name: 'keyOutputDir',
+            type: 'text',
+            initial: './certs',
+            validate: v => {
+                try {
+                    // eslint-disable-next-line
+                    (0, fs_extra_1.ensureDirSync)(path_1.default.join(process.cwd(), v));
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+        });
+        const { certificateCommonName } = await (0, prompts_1.promptAsync)({
+            message: 'Please enter your Organization name',
+            name: 'certificateCommonName',
+            type: 'text',
+            initial: 'Your Organization Name',
+            validate: v => {
+                return !!v;
+            },
+        });
+        const { certificateValidityDurationYears } = await (0, prompts_1.promptAsync)({
+            message: 'How many years should the certificate be valid for?',
+            name: 'certificateValidityDurationYears',
+            type: 'number',
+            initial: 10,
+            validate: v => {
+                return v > 0 && Number.isInteger(v);
+            },
+        });
+        const validityDurationYears = Math.floor(Number(certificateValidityDurationYears));
+        const certificateOutput = path_1.default.resolve(process.cwd(), certificateOutputDir);
+        const keyOutput = path_1.default.resolve(process.cwd(), keyOutputDir);
+        const validityNotBefore = new Date();
+        const validityNotAfter = new Date();
+        validityNotAfter.setFullYear(validityNotAfter.getFullYear() + validityDurationYears);
+        const keyPair = (0, code_signing_certificates_1.generateKeyPair)();
+        const certificate = (0, code_signing_certificates_1.generateSelfSignedCodeSigningCertificate)({
+            keyPair,
+            validityNotBefore,
+            validityNotAfter,
+            commonName: certificateCommonName,
+        });
+        const keyPairPEM = (0, code_signing_certificates_1.convertKeyPairToPEM)(keyPair);
+        const certificatePEM = (0, code_signing_certificates_1.convertCertificateToCertificatePEM)(certificate);
+        await Promise.all([
+            (0, fs_extra_1.writeFile)(path_1.default.join(keyOutput, 'public-key.pem'), keyPairPEM.publicKeyPEM),
+            (0, fs_extra_1.writeFile)(path_1.default.join(keyOutput, 'private-key.pem'), keyPairPEM.privateKeyPEM),
+            (0, fs_extra_1.writeFile)(path_1.default.join(certificateOutput, 'certificate.pem'), certificatePEM),
+        ]);
+        log_1.default.succeed(`Generated public and private keys output in ${keyOutputDir}. Please follow the documentation to securely store them and do not commit them to your repository.`);
+        log_1.default.succeed(`Generated code signing certificate output in ${certificateOutputDir}.`);
+    }
+}
+exports.default = GenerateCerts;

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}

package/dist/commands/init.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const expoConfig_1 = require("../lib/expoConfig");
+const log_1 = tslib_1.__importDefault(require("../lib/log"));
+const ora_1 = require("../lib/ora");
+const package_1 = require("../lib/package");
+const prompts_1 = require("../lib/prompts");
+const utils_1 = require("../lib/utils");
+class Init extends core_1.Command {
+    static args = {};
+    static description = 'Configure your existing expo project with Expo Open OTA';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {};
+    async run() {
+        const projectDir = process.cwd();
+        const hasExpo = (0, package_1.isExpoInstalled)(projectDir);
+        if (!hasExpo) {
+            log_1.default.error('Expo is not installed in this project. Please install Expo first.');
+            return;
+        }
+        const config = await (0, expoConfig_1.getPrivateExpoConfigAsync)(projectDir);
+        if (!config) {
+            log_1.default.error('Could not find Expo config in this project. Please make sure you have an Expo config.');
+            return;
+        }
+        const { updateUrl: promptedUrl } = await (0, prompts_1.promptAsync)({
+            message: 'Enter the URL of your update server (ex: https://customota.com)',
+            name: 'updateUrl',
+            type: 'text',
+            initial: (0, expoConfig_1.getExpoConfigUpdateUrl)(config),
+            validate: v => {
+                return !!v && (0, utils_1.isValidUpdateUrl)(v);
+            },
+        });
+        let manifestEndpoint = `${promptedUrl}/manifest`;
+        const updateUrl = (0, expoConfig_1.getExpoConfigUpdateUrl)(config);
+        if (updateUrl && !updateUrl.includes('expo.dev')) {
+            const confirmed = await (0, prompts_1.confirmAsync)({
+                message: `Expo config already has an update URL set to ${updateUrl}. Do you want to replace it?`,
+                name: 'replace',
+                type: 'confirm',
+            });
+            if (!confirmed) {
+                manifestEndpoint = updateUrl;
+            }
+        }
+        const confirmed = await (0, prompts_1.confirmAsync)({
+            message: 'Do you have already generated your certificates for code signing?',
+            name: 'certificates',
+            type: 'confirm',
+        });
+        if (!confirmed) {
+            log_1.default.fail('You need to generate your certificates first by using npx eoas generate-certs');
+            return;
+        }
+        const { codeSigningCertificatePath } = await (0, prompts_1.promptAsync)({
+            message: 'Enter the path to your code signing certificate (ex: ./certs/certificate.pem)',
+            name: 'codeSigningCertificatePath',
+            type: 'text',
+            initial: './certs/certificate.pem',
+            validate: v => {
+                try {
+                    const fullPath = path_1.default.resolve(projectDir, v);
+                    // eslint-disable-next-line
+                    const fileExists = fs_extra_1.default.existsSync(fullPath);
+                    if (!fileExists) {
+                        log_1.default.newLine();
+                        log_1.default.error('File does not exist');
+                        return false;
+                    }
+                    // eslint-disable-next-line
+                    const key = fs_extra_1.default.readFileSync(fullPath, 'utf8');
+                    if (!key) {
+                        log_1.default.error('Empty key');
+                        return false;
+                    }
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+        });
+        const newUpdateConfig = {
+            url: manifestEndpoint,
+            codeSigningMetadata: {
+                keyid: 'main',
+                alg: 'rsa-v1_5-sha256',
+            },
+            codeSigningCertificate: codeSigningCertificatePath,
+            enabled: true,
+            requestHeaders: {
+                'expo-channel-name': 'process.env.RELEASE_CHANNEL',
+            },
+        };
+        const updateConfigSpinner = (0, ora_1.ora)('Updating Expo config').start();
+        try {
+            await (0, expoConfig_1.createOrModifyExpoConfigAsync)(projectDir, {
+                updates: newUpdateConfig,
+            });
+            updateConfigSpinner.succeed('Expo config successfully updated do not forget to format the file with prettier or eslint');
+        }
+        catch (e) {
+            updateConfigSpinner.fail('Failed to update Expo config');
+            log_1.default.error(e);
+        }
+    }
+}
+exports.default = Init;

package/dist/commands/publish.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+import { Config } from '@oclif/core/lib/config';
+import { Client } from '../lib/vcs/vcs';
+export default class Publish extends Command {
+    vcsClient: Client;
+    constructor(argv: string[], config: Config);
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        platform: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        channel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        branch: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        nonInteractive: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    private sanitizeFlags;
+    run(): Promise<void>;
+}

package/dist/commands/publish.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 core_1 = require("@oclif/core");
+const form_data_1 = tslib_1.__importDefault(require("form-data"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const mime_1 = tslib_1.__importDefault(require("mime"));
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const assets_1 = require("../lib/assets");
+const auth_1 = require("../lib/auth");
+const expoConfig_1 = require("../lib/expoConfig");
+const log_1 = tslib_1.__importDefault(require("../lib/log"));
+const ora_1 = require("../lib/ora");
+const package_1 = require("../lib/package");
+const prompts_1 = require("../lib/prompts");
+const repo_1 = require("../lib/repo");
+const runtimeVersion_1 = require("../lib/runtimeVersion");
+const vcs_1 = require("../lib/vcs");
+const workflow_1 = require("../lib/workflow");
+class Publish extends core_1.Command {
+    vcsClient;
+    constructor(argv, config) {
+        super(argv, config);
+        this.vcsClient = (0, vcs_1.resolveVcsClient)(false);
+    }
+    static args = {};
+    static description = 'Publish a new update to the self-hosted update server';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        platform: core_1.Flags.string({
+            type: 'option',
+            options: Object.values(expoConfig_1.RequestedPlatform),
+            default: expoConfig_1.RequestedPlatform.All,
+            required: false,
+        }),
+        channel: core_1.Flags.string({
+            description: 'Name of the channel to publish the update to',
+            required: true,
+        }),
+        branch: core_1.Flags.string({
+            description: 'Name of the branch to point to',
+            required: true,
+        }),
+        nonInteractive: core_1.Flags.boolean({
+            description: 'Run command in non-interactive mode',
+            default: false,
+        }),
+    };
+    sanitizeFlags(flags) {
+        return {
+            platform: flags.platform,
+            branch: flags.branch,
+            nonInteractive: flags.nonInteractive,
+            channel: flags.channel,
+        };
+    }
+    async run() {
+        const credentials = (0, auth_1.retrieveExpoCredentials)();
+        if (!credentials.token && !credentials.sessionSecret) {
+            log_1.default.error('You are not logged to eas, please run `eas login`');
+            return;
+        }
+        const { flags } = await this.parse(Publish);
+        const { platform, nonInteractive, branch, channel } = this.sanitizeFlags(flags);
+        if (!branch) {
+            log_1.default.error('Branch name is required');
+            return;
+        }
+        if (!channel) {
+            log_1.default.error('Channel name is required');
+            return;
+        }
+        await this.vcsClient.ensureRepoExistsAsync();
+        await (0, repo_1.ensureRepoIsCleanAsync)(this.vcsClient, nonInteractive);
+        const projectDir = process.cwd();
+        const hasExpo = (0, package_1.isExpoInstalled)(projectDir);
+        if (!hasExpo) {
+            log_1.default.error('Expo is not installed in this project. Please install Expo first.');
+            return;
+        }
+        const privateConfig = await (0, expoConfig_1.getPrivateExpoConfigAsync)(projectDir, {
+            env: {
+                RELEASE_CHANNEL: channel,
+            },
+        });
+        const updateUrl = (0, expoConfig_1.getExpoConfigUpdateUrl)(privateConfig);
+        if (!updateUrl) {
+            log_1.default.error("Update url is not setup in your config. Please run 'eoas init' to setup the update url");
+            return;
+        }
+        let baseUrl;
+        try {
+            const parsedUrl = new URL(updateUrl);
+            baseUrl = parsedUrl.origin;
+        }
+        catch (e) {
+            log_1.default.error('Invalid URL', e);
+            return;
+        }
+        if (!nonInteractive) {
+            const confirmed = await (0, prompts_1.confirmAsync)({
+                message: `Is this the correct URL of your self-hosted update server? ${baseUrl}`,
+                name: 'export',
+                type: 'confirm',
+            });
+            if (!confirmed) {
+                log_1.default.error('Please run `eoas init` to setup the correct update url');
+            }
+        }
+        const runtimeSpinner = (0, ora_1.ora)('Resolving runtime version').start();
+        const runtimeVersions = [
+            ...(!platform || platform === expoConfig_1.RequestedPlatform.All || platform === expoConfig_1.RequestedPlatform.Ios
+                ? [
+                    (await (0, runtimeVersion_1.resolveRuntimeVersionAsync)({
+                        exp: privateConfig,
+                        platform: 'ios',
+                        workflow: await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.IOS, this.vcsClient),
+                        projectDir,
+                        env: {
+                            RELEASE_CHANNEL: channel,
+                        },
+                    }))?.runtimeVersion,
+                ]
+                : []),
+            ...(!platform || platform === expoConfig_1.RequestedPlatform.All || platform === expoConfig_1.RequestedPlatform.Android
+                ? [
+                    (await (0, runtimeVersion_1.resolveRuntimeVersionAsync)({
+                        exp: privateConfig,
+                        platform: 'android',
+                        workflow: await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.ANDROID, this.vcsClient),
+                        projectDir,
+                        env: {
+                            RELEASE_CHANNEL: channel,
+                        },
+                    }))?.runtimeVersion,
+                ]
+                : []),
+        ].filter(Boolean);
+        if (!runtimeVersions.length) {
+            runtimeSpinner.fail('Could not resolve runtime versions for the requested platforms');
+            log_1.default.error('Could not resolve runtime versions for the requested platforms');
+            return;
+        }
+        runtimeSpinner.succeed('Runtime versions resolved');
+        const exportSpinner = (0, ora_1.ora)("Exporting project's static files").start();
+        try {
+            await (0, spawn_async_1.default)('rm', ['-rf', 'dist'], { cwd: projectDir });
+            const { stdout } = await (0, spawn_async_1.default)('npx', ['expo', 'export', '--output-dir', 'dist'], {
+                cwd: projectDir,
+                env: {
+                    ...process.env,
+                    EXPO_NO_DOTENV: '1',
+                },
+            });
+            exportSpinner.succeed('Project exported successfully');
+            log_1.default.withInfo(stdout);
+        }
+        catch {
+            exportSpinner.fail('Failed to export the project');
+        }
+        const publicConfig = await (0, expoConfig_1.getPublicExpoConfigAsync)(projectDir, {
+            skipSDKVersionRequirement: true,
+        });
+        if (!publicConfig) {
+            log_1.default.error('Could not find Expo config in this project. Please make sure you have an Expo config.');
+            return;
+        }
+        // eslint-disable-next-line
+        fs_extra_1.default.writeJsonSync(path_1.default.join(projectDir, 'dist', 'expoConfig.json'), publicConfig, {
+            spaces: 2,
+        });
+        log_1.default.withInfo('expoConfig.json file created in dist directory');
+        const uploadFilesSpinner = (0, ora_1.ora)('Uploading files to the server').start();
+        const files = (0, assets_1.computeFilesRequests)(projectDir, platform || expoConfig_1.RequestedPlatform.All);
+        if (!files.length) {
+            uploadFilesSpinner.fail('No files to upload');
+        }
+        try {
+            const uploadUrls = await Promise.all(runtimeVersions.map(runtimeVersion => {
+                if (!runtimeVersion) {
+                    throw new Error('Runtime version is not resolved');
+                }
+                return (0, assets_1.requestUploadUrls)({
+                    fileNames: files.map(file => file.path),
+                }, `${baseUrl}/requestUploadUrl/${branch}`, credentials, runtimeVersion);
+            }));
+            const allItems = uploadUrls.flat();
+            await Promise.all(allItems.map(async (itm) => {
+                const isLocalBucketFileUpload = itm.requestUploadUrl.startsWith(`${baseUrl}/uploadLocalFile`);
+                const formData = new form_data_1.default();
+                let file;
+                try {
+                    file = fs_extra_1.default.createReadStream(path_1.default.join(projectDir, 'dist', itm.filePath));
+                }
+                catch {
+                    throw new Error(`Failed to read file ${itm.filePath}`);
+                }
+                formData.append(itm.fileName, file);
+                if (isLocalBucketFileUpload) {
+                    const response = await (0, node_fetch_1.default)(itm.requestUploadUrl, {
+                        method: 'PUT',
+                        headers: {
+                            ...formData.getHeaders(),
+                            ...(0, auth_1.getAuthExpoHeaders)(credentials),
+                        },
+                        body: formData,
+                    });
+                    if (!response.ok) {
+                        log_1.default.error('Failed to upload file', await response.text());
+                        throw new Error('Failed to upload file');
+                    }
+                    file.close();
+                    return;
+                }
+                const findFile = files.find(f => f.path === itm.filePath || f.name === itm.fileName);
+                if (!findFile) {
+                    log_1.default.error(`File ${itm.filePath} not found`);
+                    throw new Error(`File ${itm.filePath} not found`);
+                }
+                let contentType = mime_1.default.getType(findFile.ext);
+                if (!contentType) {
+                    contentType = 'application/octet-stream';
+                }
+                const buffer = await fs_extra_1.default.readFile(path_1.default.join(projectDir, 'dist', itm.filePath));
+                const response = await (0, node_fetch_1.default)(itm.requestUploadUrl, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': contentType,
+                        'Cache-Control': 'max-age=31556926',
+                    },
+                    body: buffer,
+                });
+                if (!response.ok) {
+                    log_1.default.error('Failed to upload file', await response.text());
+                    throw new Error('Failed to upload file');
+                }
+                file.close();
+            }));
+            uploadFilesSpinner.succeed('Files uploaded successfully');
+        }
+        catch {
+            uploadFilesSpinner.fail('Failed to upload static files');
+        }
+    }
+}
+exports.default = Publish;

package/dist/lib/assets.d.ts

@@ -0,0 +1,19 @@
+import Joi from 'joi';
+import { ExpoCredentials } from './auth';
+import { RequestedPlatform } from './expoConfig';
+export declare const MetadataJoi: Joi.ObjectSchema<any>;
+interface AssetToUpload {
+    path: string;
+    name: string;
+    ext: string;
+}
+export declare function computeFilesRequests(projectDir: string, requestedPlatform: RequestedPlatform): AssetToUpload[];
+export interface RequestUploadUrlItem {
+    requestUploadUrl: string;
+    fileName: string;
+    filePath: string;
+}
+export declare function requestUploadUrls(body: {
+    fileNames: string[];
+}, requestUploadUrl: string, auth: ExpoCredentials, runtimeVersion: string): Promise<RequestUploadUrlItem[]>;
+export {};

package/dist/lib/assets.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestUploadUrls = exports.computeFilesRequests = exports.MetadataJoi = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const joi_1 = tslib_1.__importDefault(require("joi"));
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const auth_1 = require("./auth");
+const expoConfig_1 = require("./expoConfig");
+const log_1 = tslib_1.__importDefault(require("./log"));
+const fileMetadataJoi = joi_1.default.object({
+    assets: joi_1.default.array()
+        .required()
+        .items(joi_1.default.object({ path: joi_1.default.string().required(), ext: joi_1.default.string().required() })),
+    bundle: joi_1.default.string().required(),
+}).optional();
+exports.MetadataJoi = joi_1.default.object({
+    version: joi_1.default.number().required(),
+    bundler: joi_1.default.string().required(),
+    fileMetadata: joi_1.default.object({
+        android: fileMetadataJoi,
+        ios: fileMetadataJoi,
+        web: fileMetadataJoi,
+    }).required(),
+}).required();
+function loadMetadata(distRoot) {
+    // eslint-disable-next-line
+    const fileContent = fs_extra_1.default.readFileSync(path_1.default.join(distRoot, 'metadata.json'), 'utf8');
+    let metadata;
+    try {
+        metadata = JSON.parse(fileContent);
+    }
+    catch (e) {
+        log_1.default.error(`Failed to read metadata.json: ${e.message}`);
+        throw e;
+    }
+    const { error } = exports.MetadataJoi.validate(metadata);
+    if (error) {
+        throw error;
+    }
+    // Check version and bundler by hand (instead of with Joi) so
+    // more informative error messages can be returned.
+    if (metadata.version !== 0) {
+        throw new Error('Only bundles with metadata version 0 are supported');
+    }
+    if (metadata.bundler !== 'metro') {
+        throw new Error('Only bundles created with Metro are currently supported');
+    }
+    const platforms = Object.keys(metadata.fileMetadata);
+    if (platforms.length === 0) {
+        log_1.default.warn('No updates were exported for any platform');
+    }
+    log_1.default.debug(`Loaded ${platforms.length} platform(s): ${platforms.join(', ')}`);
+    return metadata;
+}
+function computeFilesRequests(projectDir, requestedPlatform) {
+    const metadata = loadMetadata(path_1.default.join(projectDir, 'dist'));
+    const assets = [
+        { path: 'metadata.json', name: 'metadata.json', ext: 'json' },
+        { path: 'expoConfig.json', name: 'expoConfig.json', ext: 'json' },
+    ];
+    for (const platform of Object.keys(metadata.fileMetadata)) {
+        if (requestedPlatform !== expoConfig_1.RequestedPlatform.All && requestedPlatform !== platform) {
+            continue;
+        }
+        const bundle = metadata.fileMetadata[platform].bundle;
+        assets.push({ path: bundle, name: path_1.default.basename(bundle), ext: 'hbc' });
+        for (const asset of metadata.fileMetadata[platform].assets) {
+            assets.push({ path: asset.path, name: path_1.default.basename(asset.path), ext: asset.ext });
+        }
+    }
+    return assets;
+}
+exports.computeFilesRequests = computeFilesRequests;
+async function requestUploadUrls(body, requestUploadUrl, auth, runtimeVersion) {
+    const response = await (0, node_fetch_1.default)(`${requestUploadUrl}?runtimeVersion=${runtimeVersion}`, {
+        method: 'POST',
+        headers: {
+            ...(0, auth_1.getAuthExpoHeaders)(auth),
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to request upload URL`);
+    }
+    return await response.json();
+}
+exports.requestUploadUrls = requestUploadUrls;

package/dist/lib/auth.d.ts

@@ -0,0 +1,6 @@
+export interface ExpoCredentials {
+    token?: string;
+    sessionSecret?: string;
+}
+export declare function retrieveExpoCredentials(): ExpoCredentials;
+export declare function getAuthExpoHeaders(credentials: ExpoCredentials): Record<string, string>;

package/dist/lib/auth.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthExpoHeaders = exports.retrieveExpoCredentials = void 0;
+const tslib_1 = require("tslib");
+const os_1 = require("os");
+const path_1 = tslib_1.__importDefault(require("path"));
+function dotExpoHomeDirectory() {
+    const home = (0, os_1.homedir)();
+    if (!home) {
+        throw new Error("Can't determine your home directory; make sure your $HOME environment variable is set.");
+    }
+    let dirPath;
+    if (process.env.EXPO_STAGING) {
+        dirPath = path_1.default.join(home, '.expo-staging');
+    }
+    else if (process.env.EXPO_LOCAL) {
+        dirPath = path_1.default.join(home, '.expo-local');
+    }
+    else {
+        dirPath = path_1.default.join(home, '.expo');
+    }
+    return dirPath;
+}
+function getStateJsonPath() {
+    return path_1.default.join(dotExpoHomeDirectory(), 'state.json');
+}
+function getExpoSessionData() {
+    try {
+        const stateJsonPath = getStateJsonPath();
+        const stateJson = require(stateJsonPath);
+        return stateJson['auth'] || null;
+    }
+    catch {
+        return null;
+    }
+}
+function retrieveExpoCredentials() {
+    const token = process.env.EXPO_TOKEN;
+    const sessionData = getExpoSessionData();
+    const sessionSecret = sessionData?.sessionSecret;
+    return { token, sessionSecret };
+}
+exports.retrieveExpoCredentials = retrieveExpoCredentials;
+function getAuthExpoHeaders(credentials) {
+    if (credentials.token) {
+        return {
+            Authorization: `Bearer ${credentials.token}`,
+        };
+    }
+    if (credentials.sessionSecret) {
+        return {
+            'expo-session': credentials.sessionSecret,
+        };
+    }
+    return {};
+}
+exports.getAuthExpoHeaders = getAuthExpoHeaders;