@donotuse/eas-cli 18.5.0-rc.1

package/build/vcs/local.d.ts

@@ -0,0 +1,25 @@
+import { Ignore as SingleFileIgnore } from 'ignore';
+export declare const EASIGNORE_FILENAME = ".easignore";
+/**
+ * Ignore wraps the 'ignore' package to support multiple .gitignore files
+ * in subdirectories.
+ *
+ * Inconsistencies with git behavior:
+ * - if parent .gitignore has ignore rule and child has exception to that rule,
+ *   file will still be ignored,
+ * - node_modules is always ignored,
+ * - if .easignore exists, .gitignore files are not used.
+ */
+export declare class Ignore {
+    private readonly rootDir;
+    ignoreMapping: (readonly [string, SingleFileIgnore])[];
+    private constructor();
+    static createForCopyingAsync(rootDir: string): Promise<Ignore>;
+    /** Does not include the default .git and node_modules ignore rules. */
+    static createForCheckingAsync(rootDir: string): Promise<Ignore>;
+    initIgnoreAsync({ defaultIgnore }: {
+        defaultIgnore: string;
+    }): Promise<void>;
+    ignores(relativePath: string): boolean;
+}
+export declare function makeShallowCopyAsync(_src: string, dst: string): Promise<void>;

package/build/vcs/local.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ignore = exports.EASIGNORE_FILENAME = void 0;
+exports.makeShallowCopyAsync = makeShallowCopyAsync;
+const tslib_1 = require("tslib");
+const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const ignore_1 = tslib_1.__importDefault(require("ignore"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+exports.EASIGNORE_FILENAME = '.easignore';
+const GITIGNORE_FILENAME = '.gitignore';
+/**
+ * Ignore wraps the 'ignore' package to support multiple .gitignore files
+ * in subdirectories.
+ *
+ * Inconsistencies with git behavior:
+ * - if parent .gitignore has ignore rule and child has exception to that rule,
+ *   file will still be ignored,
+ * - node_modules is always ignored,
+ * - if .easignore exists, .gitignore files are not used.
+ */
+class Ignore {
+    rootDir;
+    ignoreMapping = [];
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    static async createForCopyingAsync(rootDir) {
+        const ignore = new Ignore(rootDir);
+        await ignore.initIgnoreAsync({
+            defaultIgnore: `
+.git
+node_modules
+`,
+        });
+        return ignore;
+    }
+    /** Does not include the default .git and node_modules ignore rules. */
+    static async createForCheckingAsync(rootDir) {
+        const ignore = new Ignore(rootDir);
+        await ignore.initIgnoreAsync({
+            defaultIgnore: ``,
+        });
+        return ignore;
+    }
+    async initIgnoreAsync({ defaultIgnore }) {
+        const easIgnorePath = path_1.default.join(this.rootDir, exports.EASIGNORE_FILENAME);
+        if (await fs_extra_1.default.pathExists(easIgnorePath)) {
+            this.ignoreMapping = [
+                ['', (0, ignore_1.default)().add(defaultIgnore)],
+                ['', (0, ignore_1.default)().add(await fs_extra_1.default.readFile(easIgnorePath, 'utf-8'))],
+            ];
+            log_1.default.debug('initializing ignore mapping with .easignore', {
+                ignoreMapping: this.ignoreMapping,
+            });
+            return;
+        }
+        const ignoreFilePaths = (await (0, fast_glob_1.default)(`**/${GITIGNORE_FILENAME}`, {
+            cwd: this.rootDir,
+            ignore: ['node_modules'],
+            followSymbolicLinks: false,
+        }))
+            // ensure that parent dir is before child directories
+            .sort((a, b) => a.length - b.length && a.localeCompare(b));
+        const ignoreMapping = await Promise.all(ignoreFilePaths.map(async (filePath) => {
+            return [
+                filePath.slice(0, filePath.length - GITIGNORE_FILENAME.length),
+                (0, ignore_1.default)().add(await fs_extra_1.default.readFile(path_1.default.join(this.rootDir, filePath), 'utf-8')),
+            ];
+        }));
+        this.ignoreMapping = [['', (0, ignore_1.default)().add(defaultIgnore)], ...ignoreMapping];
+        log_1.default.debug('initializing ignore mapping with .gitignore files', {
+            ignoreFilePaths,
+            ignoreMapping: this.ignoreMapping,
+        });
+    }
+    ignores(relativePath) {
+        for (const [prefix, ignore] of this.ignoreMapping) {
+            if (relativePath.startsWith(prefix) && ignore.ignores(relativePath.slice(prefix.length))) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.Ignore = Ignore;
+async function makeShallowCopyAsync(_src, dst) {
+    // `node:fs` on Windows adds a namespace prefix (e.g. `\\?\`) to the path provided
+    // to the `filter` function in `fs.cp`. We need to ensure that we compare the right paths
+    // (both with prefix), otherwise the `relativePath` ends up being wrong and causes no files
+    // to be ignored.
+    const src = path_1.default.toNamespacedPath(path_1.default.normalize(_src));
+    log_1.default.debug('makeShallowCopyAsync', { src, dst });
+    const ignore = await Ignore.createForCopyingAsync(src);
+    log_1.default.debug('makeShallowCopyAsync ignoreMapping', { ignoreMapping: ignore.ignoreMapping });
+    await promises_1.default.cp(src, dst, {
+        recursive: true,
+        // Preserve symlinks without re-resolving them to their original targets
+        verbatimSymlinks: true,
+        filter: (_srcFilePath) => {
+            const srcFilePath = path_1.default.toNamespacedPath(_srcFilePath);
+            if (srcFilePath === src) {
+                return true;
+            }
+            const relativePath = path_1.default.relative(src, srcFilePath);
+            const shouldCopyTheItem = !ignore.ignores(relativePath);
+            log_1.default.debug(shouldCopyTheItem ? 'copying' : 'skipping', {
+                src,
+                srcFilePath,
+                relativePath,
+            });
+            return shouldCopyTheItem;
+        },
+    });
+}

package/build/vcs/vcs.d.ts

@@ -0,0 +1,25 @@
+export declare abstract class Client {
+    abstract makeShallowCopyAsync(destinationPath: string): Promise<void>;
+    abstract getRootPathAsync(): Promise<string>;
+    ensureRepoExistsAsync(): Promise<void>;
+    isCommitRequiredAsync(): Promise<boolean>;
+    hasUncommittedChangesAsync(): Promise<boolean | undefined>;
+    commitAsync(_arg: {
+        commitMessage: string;
+        commitAllFiles?: boolean;
+        nonInteractive: boolean;
+    }): Promise<void>;
+    trackFileAsync(_file: string): Promise<void>;
+    showDiffAsync(): Promise<void>;
+    /** (optional) print list of changed files */
+    showChangedFilesAsync(): Promise<void>;
+    getCommitHashAsync(): Promise<string | undefined>;
+    getBranchNameAsync(): Promise<string | null>;
+    getLastCommitMessageAsync(): Promise<string | null>;
+    isFileIgnoredAsync(_filePath: string): Promise<boolean>;
+    /**
+     * Whether this VCS client can get the last commit message.
+     * Used for EAS Update - implementation can be false for noVcs client.
+     */
+    abstract canGetLastCommitMessage(): boolean;
+}

package/build/vcs/vcs.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+class Client {
+    // (optional) ensureRepoExistsAsync should verify whether repository exists and tooling is installed
+    // it's not required for minimal support, but lack of validation might cause the failure at a later stage.
+    async ensureRepoExistsAsync() { }
+    // (optional) checks whether commit is necessary before calling makeShallowCopyAsync
+    //
+    // If it's not implemented method `makeShallowCopyAsync` needs to be able to include uncommitted changes
+    // when creating copy
+    async isCommitRequiredAsync() {
+        return false;
+    }
+    // (optional) hasUncommittedChangesAsync should check whether there are changes in local repository
+    async hasUncommittedChangesAsync() {
+        return undefined;
+    }
+    // (optional) commitAsync commits changes
+    //
+    // - Should be implemented if hasUncommittedChangesAsync is implemented
+    // - If it's not implemented method `makeShallowCopyAsync` needs to be able to include uncommitted changes
+    // in project copy
+    async commitAsync(_arg) {
+        // it should not be called unless hasUncommittedChangesAsync is implemented
+        throw new Error('commitAsync is not implemented');
+    }
+    // (optional) mark file as tracked, if this method is called on file, the next call to
+    // `commitAsync({ commitAllFiles: false })` should commit that file
+    async trackFileAsync(_file) { }
+    // (optional) print diff of the changes that will be commited in the next call to
+    // `commitAsync({ commitAllFiles: false })`
+    async showDiffAsync() { }
+    /** (optional) print list of changed files */
+    async showChangedFilesAsync() { }
+    // (optional) returns hash of the last commit
+    // used for metadata - implementation can be safely skipped
+    async getCommitHashAsync() {
+        return undefined;
+    }
+    // (optional) returns name of the current branch
+    // used for EAS Update - implementation can be safely skipped
+    async getBranchNameAsync() {
+        return null;
+    }
+    // (optional) returns message of the last commit
+    // used for EAS Update - implementation can be safely skipped
+    async getLastCommitMessageAsync() {
+        return null;
+    }
+    // (optional) checks if the file is ignored, an implementation should ensure
+    // that if file exists and `isFileIgnoredAsync` returns true, then that file
+    // should not be included in the project tarball.
+    //
+    // @param filePath has to be a relative normalized path pointing to a file
+    // located under the root of the repository
+    async isFileIgnoredAsync(_filePath) {
+        return false;
+    }
+}
+exports.Client = Client;

package/build/webhooks/formatWebhook.d.ts

@@ -0,0 +1,2 @@
+import { WebhookFragment } from '../graphql/generated';
+export declare function formatWebhook(webhook: WebhookFragment): string;

package/build/webhooks/formatWebhook.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatWebhook = formatWebhook;
+const tslib_1 = require("tslib");
+const formatFields_1 = tslib_1.__importDefault(require("../utils/formatFields"));
+function formatWebhook(webhook) {
+    return (0, formatFields_1.default)([
+        { label: 'ID', value: webhook.id },
+        { label: 'Event', value: webhook.event },
+        { label: 'URL', value: webhook.url },
+        { label: 'Created at', value: new Date(webhook.createdAt).toLocaleString() },
+        { label: 'Updated at', value: new Date(webhook.updatedAt).toLocaleString() },
+    ]);
+}

package/build/webhooks/input.d.ts

@@ -0,0 +1,9 @@
+import { WebhookFragment, WebhookInput, WebhookType } from '../graphql/generated';
+export declare function prepareInputParamsAsync({ event: maybeEvent, url: maybeUrl, secret: maybeSecret, 'non-interactive': nonInteractive, }: {
+    event?: WebhookType;
+    url?: string;
+    secret?: string;
+    'non-interactive': boolean;
+}, existingWebhook?: WebhookFragment): Promise<WebhookInput>;
+export declare function validateURL(url: string): boolean;
+export declare function validateSecret(secret: string): boolean;

package/build/webhooks/input.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareInputParamsAsync = prepareInputParamsAsync;
+exports.validateURL = validateURL;
+exports.validateSecret = validateSecret;
+const tslib_1 = require("tslib");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const url_1 = require("url");
+const generated_1 = require("../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+async function prepareInputParamsAsync({ event: maybeEvent, url: maybeUrl, secret: maybeSecret, 'non-interactive': nonInteractive, }, existingWebhook) {
+    let event = maybeEvent;
+    let url = maybeUrl;
+    let secret = maybeSecret;
+    if (!event) {
+        if (nonInteractive) {
+            throw new Error('Must supply event flag in non-interative mode');
+        }
+        const choices = [
+            { title: 'Build', value: generated_1.WebhookType.Build },
+            { title: 'Submit', value: generated_1.WebhookType.Submit },
+        ];
+        ({ event } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'event',
+            message: 'Webhook event type:',
+            choices,
+            initial: existingWebhook?.event
+                ? choices.findIndex(choice => choice.value === existingWebhook.event)
+                : undefined,
+        }));
+    }
+    if (!url || !validateURL(url)) {
+        const urlValidationMessage = 'The provided webhook URL is invalid and must be an absolute URL, including a scheme.';
+        if (url && !validateURL(url)) {
+            log_1.default.error(urlValidationMessage);
+        }
+        if (nonInteractive) {
+            throw new Error('Must supply url flag in non-interative mode');
+        }
+        ({ url } = await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'url',
+            message: 'Webhook URL:',
+            initial: url ? undefined : existingWebhook?.url,
+            validate: (value) => validateURL(value) || urlValidationMessage,
+        }));
+    }
+    if (!secret || !validateSecret(secret)) {
+        const secretValidationMessage = 'Webhook secret has be at least 16 and not more than 1000 characters long';
+        if (secret && !validateSecret(secret)) {
+            log_1.default.error(secretValidationMessage);
+        }
+        if (nonInteractive) {
+            throw new Error('Must supply secret flag in non-interative mode');
+        }
+        ({ secret } = await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'secret',
+            message: 'Webhook secret:',
+            validate: (value) => validateSecret(value) || secretValidationMessage,
+        }));
+    }
+    return {
+        event: (0, nullthrows_1.default)(event),
+        url: (0, nullthrows_1.default)(url),
+        secret: (0, nullthrows_1.default)(secret),
+    };
+}
+function validateURL(url) {
+    try {
+        // eslint-disable-next-line no-new
+        new url_1.URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validateSecret(secret) {
+    return secret.length >= 16 && secret.length <= 1000;
+}

package/build/worker/assets.d.ts

@@ -0,0 +1,54 @@
+import { GzipOptions } from 'minizlib';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+interface AssetMapOptions {
+    maxFileSize: number;
+}
+export interface AssetFileEntry {
+    normalizedPath: string;
+    path: string;
+    size: number;
+    sha512: string;
+    type: string | null;
+}
+/** Collects assets from a given target path */
+export declare function collectAssetsAsync(assetPath: string | undefined, options: AssetMapOptions): Promise<AssetFileEntry[]>;
+export interface RoutesConfigEntry {
+    headers?: Record<string, unknown>;
+    redirects?: Record<string, unknown>[];
+}
+export declare function getRoutesConfigAsync(assetPath: string | undefined): Promise<RoutesConfigEntry | null>;
+/** Mapping of normalized file paths to a SHA512 hash */
+export type AssetMap = Record<string, string | {
+    sha512: string;
+    size: number;
+}>;
+/** Converts array of asset entries into AssetMap (as sent to deployment-api) */
+export declare function assetsToAssetsMap(assets: AssetFileEntry[]): AssetMap;
+export interface Manifest {
+    env: Record<string, string | undefined>;
+}
+export interface CreateManifestResult {
+    conflictingVariableNames: string[] | undefined;
+    manifest: Manifest;
+}
+interface CreateManifestParams {
+    projectId: string;
+    projectDir: string;
+    environment?: string;
+}
+/** Creates a manifest configuration sent up for deployment */
+export declare function createManifestAsync(params: CreateManifestParams, graphqlClient: ExpoGraphqlClient): Promise<CreateManifestResult>;
+interface WorkerFileEntry {
+    normalizedPath: string;
+    path: string;
+    data: Buffer | string;
+}
+/** Reads worker files while normalizing sourcemaps and providing normalized paths */
+export declare function listWorkerFilesAsync(workerPath: string, options?: {
+    skipSourceMaps?: boolean;
+}): AsyncGenerator<WorkerFileEntry>;
+/** Entry of a normalized (gzip-safe) path and file data */
+export type FileEntry = readonly [normalizedPath: string, data: Buffer | string];
+/** Packs file entries into a tar.gz file (path to tgz returned) */
+export declare function packFilesIterableAsync(iterable: Iterable<FileEntry> | AsyncIterable<FileEntry>, options?: GzipOptions): Promise<string>;
+export {};

package/build/worker/assets.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectAssetsAsync = collectAssetsAsync;
+exports.getRoutesConfigAsync = getRoutesConfigAsync;
+exports.assetsToAssetsMap = assetsToAssetsMap;
+exports.createManifestAsync = createManifestAsync;
+exports.listWorkerFilesAsync = listWorkerFilesAsync;
+exports.packFilesIterableAsync = packFilesIterableAsync;
+const tslib_1 = require("tslib");
+const env_1 = require("@expo/env");
+const mime_1 = tslib_1.__importDefault(require("mime"));
+const minizlib_1 = require("minizlib");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = tslib_1.__importStar(require("node:fs"));
+const node_os_1 = tslib_1.__importDefault(require("node:os"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const promises_1 = require("node:stream/promises");
+const tar_stream_1 = require("tar-stream");
+const EnvironmentVariablesQuery_1 = require("../graphql/queries/EnvironmentVariablesQuery");
+const EXPO_ROUTES_PATHS = new Set(['_expo/routes.json', '_expo/.routes.json', '.expo-routes.json']);
+/** Returns whether a file or folder is ignored */
+function isIgnoredName(name) {
+    switch (name) {
+        // macOS system files
+        case '.DS_Store':
+        case '.AppleDouble':
+        case '.Trashes':
+        case '__MACOSX':
+        case '.LSOverride':
+            return true;
+        default:
+            // Backup file name convention
+            return name.endsWith('~');
+    }
+}
+/** Creates a temporary file write path */
+async function createTempWritePathAsync() {
+    const basename = node_path_1.default.basename(__filename, node_path_1.default.extname(__filename));
+    const tmpdir = await node_fs_1.default.promises.realpath(node_os_1.default.tmpdir());
+    const random = (0, node_crypto_1.randomBytes)(4).toString('hex');
+    return node_path_1.default.resolve(tmpdir, `tmp-${basename}-${process.pid}-${random}`);
+}
+/** Computes a SHA512 hash for a file */
+async function computeSha512HashAsync(filePath) {
+    const hash = (0, node_crypto_1.createHash)('sha512', { encoding: 'hex' });
+    await (0, promises_1.pipeline)(node_fs_1.default.createReadStream(filePath), hash);
+    return `${hash.read()}`;
+}
+/** Lists plain files in base path recursively and outputs normalized paths */
+function listFilesRecursively(basePath) {
+    async function* recurseAsync(parentPath) {
+        const target = parentPath ? node_path_1.default.resolve(basePath, parentPath) : basePath;
+        const entries = await node_fs_1.default.promises.readdir(target, { withFileTypes: true });
+        for (const dirent of entries) {
+            const normalizedPath = parentPath ? `${parentPath}/${dirent.name}` : dirent.name;
+            if (isIgnoredName(dirent.name)) {
+                continue;
+            }
+            else if (dirent.isFile()) {
+                const absolutePath = node_path_1.default.resolve(target, dirent.name);
+                const stats = await node_fs_1.default.promises.stat(absolutePath);
+                yield {
+                    normalizedPath,
+                    path: absolutePath,
+                    size: stats.size,
+                };
+            }
+            else if (dirent.isDirectory()) {
+                yield* recurseAsync(normalizedPath);
+            }
+        }
+    }
+    return recurseAsync();
+}
+async function determineMimeTypeAsync(filePath) {
+    let contentType = mime_1.default.getType(node_path_1.default.basename(filePath));
+    if (!contentType) {
+        const fileContent = await node_fs_1.default.promises.readFile(filePath, 'utf-8');
+        try {
+            // check if file is valid JSON without an extension, e.g. for the apple app site association file
+            const parsedData = JSON.parse(fileContent);
+            if (parsedData) {
+                contentType = 'application/json';
+            }
+        }
+        catch { }
+    }
+    return contentType;
+}
+/** Collects assets from a given target path */
+async function collectAssetsAsync(assetPath, options) {
+    const assets = [];
+    if (assetPath) {
+        for await (const file of listFilesRecursively(assetPath)) {
+            if (file.size > options.maxFileSize) {
+                throw new Error(`Upload of "${file.normalizedPath}" aborted: File size is greater than the upload limit (>500MB)`);
+            }
+            else if (EXPO_ROUTES_PATHS.has(file.normalizedPath)) {
+                continue;
+            }
+            const sha512$ = computeSha512HashAsync(file.path);
+            const contentType$ = determineMimeTypeAsync(file.path);
+            assets.push({
+                normalizedPath: file.normalizedPath,
+                path: file.path,
+                size: file.size,
+                sha512: await sha512$,
+                type: await contentType$,
+            });
+        }
+    }
+    return assets;
+}
+async function getRoutesConfigAsync(assetPath) {
+    if (assetPath) {
+        for (const candidatePath of EXPO_ROUTES_PATHS) {
+            const targetPath = node_path_1.default.resolve(assetPath, candidatePath);
+            let json;
+            try {
+                json = JSON.parse(await node_fs_1.default.promises.readFile(targetPath, 'utf8'));
+            }
+            catch {
+                continue;
+            }
+            if (typeof json === 'object' && json) {
+                return json;
+            }
+        }
+    }
+    return null;
+}
+/** Converts array of asset entries into AssetMap (as sent to deployment-api) */
+function assetsToAssetsMap(assets) {
+    return assets.reduce((map, entry) => {
+        map[entry.normalizedPath] = {
+            sha512: entry.sha512,
+            size: entry.size,
+        };
+        return map;
+    }, Object.create(null));
+}
+/** Creates a manifest configuration sent up for deployment */
+async function createManifestAsync(params, graphqlClient) {
+    // Resolve .env file variables
+    const { env } = (0, env_1.parseProjectEnv)(params.projectDir, { mode: 'production' });
+    // Maybe load EAS Environment Variables (based on `--environment` arg)
+    let conflictingVariableNames;
+    if (params.environment) {
+        const loadedVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+            appId: params.projectId,
+            environment: params.environment,
+        });
+        // Load EAS Env vars into `env` object, keeping track of conflicts
+        conflictingVariableNames = [];
+        for (const variable of loadedVariables) {
+            if (variable.value != null) {
+                if (env[variable.name] != null) {
+                    conflictingVariableNames.push(variable.name);
+                }
+                env[variable.name] = variable.value;
+            }
+        }
+    }
+    const manifest = { env };
+    return { conflictingVariableNames, manifest };
+}
+/** Reads worker files while normalizing sourcemaps and providing normalized paths */
+async function* listWorkerFilesAsync(workerPath, options) {
+    for await (const file of listFilesRecursively(workerPath)) {
+        if (options?.skipSourceMaps && file.normalizedPath.endsWith('.map')) {
+            continue;
+        }
+        yield {
+            normalizedPath: file.normalizedPath,
+            path: file.path,
+            data: await node_fs_1.default.promises.readFile(file.path),
+        };
+    }
+}
+/** Packs file entries into a tar.gz file (path to tgz returned) */
+async function packFilesIterableAsync(iterable, options) {
+    const writePath = `${await createTempWritePathAsync()}.tar.gz`;
+    const write = (0, node_fs_1.createWriteStream)(writePath);
+    const gzip = new minizlib_1.Gzip({ portable: true, ...options });
+    const tar = (0, tar_stream_1.pack)();
+    const writeTask$ = (0, promises_1.pipeline)(tar, gzip, write);
+    for await (const file of iterable) {
+        tar.entry({ name: file[0], type: 'file' }, file[1]);
+    }
+    tar.finalize();
+    await writeTask$;
+    return writePath;
+}

package/build/worker/deployment.d.ts

@@ -0,0 +1,61 @@
+import { DeploymentsMutation } from './mutations';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { WorkerDeploymentAliasFragment, WorkerDeploymentFragment } from '../graphql/generated';
+import { selectPaginatedAsync } from '../utils/relay';
+export declare function getSignedDeploymentUrlAsync(graphqlClient: ExpoGraphqlClient, options: {
+    appId: string;
+    deploymentIdentifier?: string | null;
+    /** Callback which is invoked when the project is going to setup the dev domain */
+    onSetupDevDomain?: () => any;
+    /** If the terminal is running in non interactive mode or not */
+    nonInteractive?: boolean;
+}): Promise<string>;
+/**
+ * Assign a dev domain name to a project.
+ *   - When running in interactive mode, it will prompt the user with a suggested domain name.
+ *   - When running in non interactive mode, it will auto-assign the suggested domain name.
+ */
+export declare function assignDevDomainNameAsync({ graphqlClient, appId, nonInteractive, }: {
+    graphqlClient: ExpoGraphqlClient;
+    appId: string;
+    nonInteractive?: boolean;
+}): ReturnType<typeof DeploymentsMutation.assignDevDomainNameAsync>;
+export declare function assignWorkerDeploymentAliasAsync({ graphqlClient, appId, deploymentId, aliasName, }: {
+    graphqlClient: ExpoGraphqlClient;
+    appId: string;
+    deploymentId: string;
+    aliasName: string;
+}): ReturnType<typeof DeploymentsMutation.assignAliasAsync>;
+export declare function assignWorkerDeploymentProductionAsync({ graphqlClient, appId, deploymentId, }: {
+    graphqlClient: ExpoGraphqlClient;
+    appId: string;
+    deploymentId: string;
+}): ReturnType<typeof DeploymentsMutation.assignAliasAsync>;
+export declare function selectWorkerDeploymentOnAppAsync({ graphqlClient, appId, selectTitle, pageSize, }: {
+    graphqlClient: ExpoGraphqlClient;
+    appId: string;
+    selectTitle?: string;
+    pageSize?: number;
+}): ReturnType<typeof selectPaginatedAsync<WorkerDeploymentFragment>>;
+export declare function deleteWorkerDeploymentAliasAsync({ graphqlClient, appId, aliasName, }: {
+    graphqlClient: ExpoGraphqlClient;
+    appId: string;
+    aliasName: string;
+}): Promise<{
+    aliasName?: string;
+    id: string;
+}>;
+export declare function selectWorkerDeploymentAliasOnAppAsync({ graphqlClient, appId, selectTitle, pageSize, }: {
+    graphqlClient: ExpoGraphqlClient;
+    appId: string;
+    selectTitle?: string;
+    pageSize?: number;
+}): ReturnType<typeof selectPaginatedAsync<WorkerDeploymentAliasFragment>>;
+export declare function deleteWorkerDeploymentAsync({ graphqlClient, appId, deploymentIdentifier, }: {
+    graphqlClient: ExpoGraphqlClient;
+    appId: string;
+    deploymentIdentifier: string;
+}): Promise<{
+    deploymentIdentifier: string;
+    id: string;
+}>;