@donotuse/eas-cli 18.5.0-rc.1

package/build/worker/upload.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadAsync = uploadAsync;
+exports.callUploadApiAsync = callUploadApiAsync;
+exports.batchUploadAsync = batchUploadAsync;
+exports.createProgressBar = createProgressBar;
+const tslib_1 = require("tslib");
+const cli_progress_1 = tslib_1.__importDefault(require("cli-progress"));
+const https = tslib_1.__importStar(require("https"));
+const https_proxy_agent_1 = tslib_1.__importDefault(require("https-proxy-agent"));
+const node_fetch_1 = tslib_1.__importStar(require("node-fetch"));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_os_1 = tslib_1.__importDefault(require("node:os"));
+const node_stream_1 = require("node:stream");
+const promise_retry_1 = tslib_1.__importDefault(require("promise-retry"));
+const multipart_1 = require("./utils/multipart");
+const MAX_CONCURRENCY = Math.min(10, Math.max(node_os_1.default.availableParallelism() * 2, 20));
+const MAX_RETRIES = 4;
+let sharedAgent;
+const getAgent = () => {
+    if (sharedAgent) {
+        return sharedAgent;
+    }
+    else if (process.env.https_proxy) {
+        return (sharedAgent = (0, https_proxy_agent_1.default)(process.env.https_proxy));
+    }
+    else {
+        return (sharedAgent = new https.Agent({
+            keepAlive: true,
+            maxSockets: MAX_CONCURRENCY,
+            maxTotalSockets: MAX_CONCURRENCY,
+            scheduling: 'lifo',
+            timeout: 4_000,
+        }));
+    }
+};
+async function uploadAsync(init, payload, onProgressUpdate) {
+    return await (0, promise_retry_1.default)(async (retry) => {
+        if (onProgressUpdate) {
+            onProgressUpdate(0);
+        }
+        const headers = new node_fetch_1.Headers(init.headers);
+        const url = new URL(`${init.baseURL}`);
+        let errorPrefix;
+        let body;
+        let method = init.method || 'POST';
+        if ('asset' in payload) {
+            const { asset } = payload;
+            errorPrefix = `Upload of "${asset.normalizedPath}" failed`;
+            if (asset.type) {
+                headers.set('content-type', asset.type);
+            }
+            if (asset.size) {
+                headers.set('content-length', `${asset.size}`);
+            }
+            method = 'POST';
+            url.pathname = `/asset/${asset.sha512}`;
+            body = node_stream_1.Readable.from((0, multipart_1.createReadStreamAsync)(asset), { objectMode: false });
+        }
+        else if ('filePath' in payload) {
+            const { filePath } = payload;
+            errorPrefix = 'Worker deployment failed';
+            body = node_fs_1.default.createReadStream(filePath);
+        }
+        else if ('multipart' in payload) {
+            const { multipart } = payload;
+            errorPrefix = `Upload of ${multipart.length} assets failed`;
+            headers.set('content-type', multipart_1.multipartContentType);
+            method = 'PATCH';
+            url.pathname = '/asset/batch';
+            body = node_stream_1.Readable.from((0, multipart_1.createMultipartBodyFromFilesAsync)(multipart, onProgressUpdate), {
+                objectMode: false,
+            });
+        }
+        let response;
+        try {
+            response = await (0, node_fetch_1.default)(url, {
+                method,
+                body,
+                headers,
+                agent: getAgent(),
+                signal: init.signal,
+            });
+        }
+        catch (error) {
+            return retry(error);
+        }
+        const getErrorMessageAsync = async () => {
+            const rayId = response.headers.get('cf-ray');
+            const contentType = response.headers.get('Content-Type');
+            if (contentType?.startsWith('text/html')) {
+                // NOTE(@kitten): We've received a CDN error most likely. There's not much we can do
+                // except for quoting the Request ID, so a user can send it to us. We can check
+                // why a request was blocked by looking up a WAF event via the "Ray ID" here:
+                // https://dash.cloudflare.com/e6f39f67f543faa6038768e8f37e4234/expo.app/security/events
+                let message = `CDN firewall has aborted the upload with ${response.statusText}.`;
+                if (rayId) {
+                    message += `\nReport this error quoting Request ID ${rayId}`;
+                }
+                return `${errorPrefix}: ${message}`;
+            }
+            else {
+                const json = await response.json().catch(() => null);
+                return json?.error ?? `${errorPrefix}: ${response.statusText}`;
+            }
+        };
+        if (response.status === 408 ||
+            response.status === 409 ||
+            response.status === 429 ||
+            (response.status >= 500 && response.status <= 599)) {
+            return retry(new Error(await getErrorMessageAsync()));
+        }
+        else if (response.status === 413) {
+            const message = `${errorPrefix}: File size exceeded the upload limit`;
+            throw new Error(message);
+        }
+        else if (!response.ok) {
+            throw new Error(await getErrorMessageAsync());
+        }
+        else if (onProgressUpdate) {
+            onProgressUpdate(1);
+        }
+        return {
+            payload,
+            response,
+        };
+    }, {
+        retries: MAX_RETRIES,
+        minTimeout: 50,
+        randomize: false,
+    });
+}
+async function callUploadApiAsync(url, init) {
+    return await (0, promise_retry_1.default)(async (retry) => {
+        let response;
+        try {
+            response = await (0, node_fetch_1.default)(url, {
+                ...init,
+                agent: getAgent(),
+            });
+        }
+        catch (error) {
+            return retry(error);
+        }
+        if (response.status >= 500 && response.status <= 599) {
+            retry(new Error(`Deployment failed: ${response.statusText}`));
+        }
+        try {
+            return await response.json();
+        }
+        catch (error) {
+            retry(error);
+        }
+    });
+}
+async function* batchUploadAsync(init, payloads, onProgressUpdate) {
+    const progressTracker = new Array(payloads.length).fill(0);
+    const controller = new AbortController();
+    const queue = new Set();
+    const initWithSignal = { ...init, signal: controller.signal };
+    const getProgressValue = () => {
+        const progress = progressTracker.reduce((acc, value) => acc + value, 0);
+        return progress / payloads.length;
+    };
+    const sendProgressUpdate = onProgressUpdate &&
+        (() => {
+            onProgressUpdate(getProgressValue());
+        });
+    try {
+        let index = 0;
+        while (index < payloads.length || queue.size > 0) {
+            while (queue.size < MAX_CONCURRENCY && index < payloads.length) {
+                const currentIndex = index++;
+                const payload = payloads[currentIndex];
+                const onChildProgressUpdate = sendProgressUpdate &&
+                    ((progress) => {
+                        progressTracker[currentIndex] = progress;
+                        sendProgressUpdate();
+                    });
+                const uploadPromise = uploadAsync(initWithSignal, payload, onChildProgressUpdate).finally(() => {
+                    queue.delete(uploadPromise);
+                    progressTracker[currentIndex] = 1;
+                });
+                queue.add(uploadPromise);
+                yield { payload, progress: getProgressValue() };
+            }
+            yield {
+                ...(await Promise.race(queue)),
+                progress: getProgressValue(),
+            };
+        }
+        if (queue.size > 0) {
+            controller.abort();
+        }
+    }
+    catch (error) {
+        if (error.name !== 'AbortError') {
+            throw error;
+        }
+    }
+}
+function createProgressBar(label = 'Uploading assets') {
+    const queueProgressBar = new cli_progress_1.default.SingleBar({ format: `|{bar}| {percentage}% ${label}` }, cli_progress_1.default.Presets.rect);
+    queueProgressBar.start(1, 0);
+    return {
+        update(progress) {
+            queueProgressBar.update(progress);
+        },
+        stop() {
+            queueProgressBar.stop();
+        },
+    };
+}

package/build/worker/utils/logs.d.ts

@@ -0,0 +1,36 @@
+import type { WorkerDeploymentAliasFragment, WorkerDeploymentFragment } from '../../graphql/generated';
+export declare const EXPO_BASE_DOMAIN: string;
+export declare function getDeploymentUrlFromFullName(deploymentFullName: string): string;
+export declare function getDashboardUrl(projectId: string): string;
+type WorkerDeploymentData = {
+    /** Used to generate the dashboard URL to `expo.dev` */
+    projectId: string;
+    /** The actual deployment information */
+    deployment: Pick<WorkerDeploymentFragment, 'deploymentIdentifier' | 'url'>;
+    /** All modified aliases of the deployment, if any */
+    aliases?: (WorkerDeploymentAliasFragment | null)[];
+    /** The production promoting alias of the deployment, if any */
+    production?: WorkerDeploymentAliasFragment | null;
+};
+export declare function formatWorkerDeploymentTable(data: WorkerDeploymentData): string;
+type WorkerDeploymentOutput = {
+    /** The absolute URL to the dashboard on `expo.dev` */
+    dashboardUrl: string;
+    /** The deployment identifier */
+    identifier: string;
+    /** The deployment URL */
+    url: string;
+    /** Custom aliases, if assigned */
+    aliases?: {
+        id: string;
+        url: string;
+        name: string;
+    }[];
+    /** The production alias, if assigned */
+    production?: {
+        id: string;
+        url: string;
+    };
+};
+export declare function formatWorkerDeploymentJson(data: WorkerDeploymentData): WorkerDeploymentOutput;
+export {};

package/build/worker/utils/logs.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPO_BASE_DOMAIN = void 0;
+exports.getDeploymentUrlFromFullName = getDeploymentUrlFromFullName;
+exports.getDashboardUrl = getDashboardUrl;
+exports.formatWorkerDeploymentTable = formatWorkerDeploymentTable;
+exports.formatWorkerDeploymentJson = formatWorkerDeploymentJson;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+exports.EXPO_BASE_DOMAIN = process.env.EXPO_STAGING ? 'staging.expo' : 'expo';
+function getDeploymentUrlFromFullName(deploymentFullName) {
+    return `https://${deploymentFullName}.${exports.EXPO_BASE_DOMAIN}.app`;
+}
+function getDashboardUrl(projectId) {
+    return `https://${exports.EXPO_BASE_DOMAIN}.dev/projects/${projectId}/hosting/deployments`;
+}
+function formatWorkerDeploymentTable(data) {
+    const fields = [
+        { label: 'Dashboard', value: getDashboardUrl(data.projectId) },
+        { label: 'Deployment URL', value: data.deployment.url },
+    ];
+    if (data.aliases?.length) {
+        const alias = data.aliases.filter(Boolean)[0];
+        if (alias) {
+            fields.push({ label: 'Alias URL', value: alias.url });
+        }
+    }
+    if (data.production) {
+        fields.push({ label: 'Production URL', value: data.production.url });
+    }
+    const lastUrlField = fields[fields.length - 1];
+    lastUrlField.value = chalk_1.default.cyan(lastUrlField.value);
+    return (0, formatFields_1.default)(fields);
+}
+function formatWorkerDeploymentJson(data) {
+    const aliases = !data.aliases
+        ? []
+        : data.aliases.filter(Boolean);
+    return {
+        dashboardUrl: getDashboardUrl(data.projectId),
+        identifier: data.deployment.deploymentIdentifier,
+        url: data.deployment.url,
+        aliases: !aliases.length
+            ? undefined
+            : aliases.map(alias => ({ id: alias.id, url: alias.url, name: alias.aliasName })),
+        production: !data.production
+            ? undefined
+            : {
+                id: data.production.id,
+                url: data.production.url,
+            },
+    };
+}

package/build/worker/utils/multipart.d.ts

@@ -0,0 +1,11 @@
+export declare function createReadStreamAsync(fileEntry: MultipartFileEntry): AsyncGenerator<Uint8Array>;
+export interface MultipartFileEntry {
+    sha512: string;
+    path: string;
+    type: string | null;
+    size: number;
+}
+export declare const multipartContentType = "multipart/form-data; boundary=----formdata-eas-cli";
+type OnProgressUpdateCallback = (progress: number) => void;
+export declare function createMultipartBodyFromFilesAsync(entries: MultipartFileEntry[], onProgressUpdate?: OnProgressUpdateCallback): AsyncGenerator<Uint8Array>;
+export {};

package/build/worker/utils/multipart.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multipartContentType = void 0;
+exports.createReadStreamAsync = createReadStreamAsync;
+exports.createMultipartBodyFromFilesAsync = createMultipartBodyFromFilesAsync;
+const tslib_1 = require("tslib");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const CRLF = '\r\n';
+const BOUNDARY_HYPHEN_CHARS = '--';
+const BOUNDARY_ID = '----formdata-eas-cli';
+const FORM_FOOTER = `${BOUNDARY_HYPHEN_CHARS}${BOUNDARY_ID}${BOUNDARY_HYPHEN_CHARS}${CRLF}${CRLF}`;
+const encodeName = (input) => {
+    return input.replace(/["\n\\]/g, (c) => {
+        switch (c) {
+            case '\\':
+                return '\\\\';
+            case '"':
+                return '%22';
+            case '\n':
+                return '%0A';
+            default:
+                return `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
+        }
+    });
+};
+async function* createReadStreamAsync(fileEntry) {
+    let handle;
+    try {
+        handle = await node_fs_1.default.promises.open(fileEntry.path);
+        const hash = (0, node_crypto_1.createHash)('sha512');
+        // NOTE(@kitten): fs.createReadStream() was previously used here as an async iterator
+        // However, if an early 'end' event is emitted, the async iterator may abort too early and cut off file contents
+        let bytesTotal = 0;
+        while (bytesTotal < fileEntry.size) {
+            const read = await handle.read();
+            const output = read.buffer.subarray(0, read.bytesRead);
+            bytesTotal += output.byteLength;
+            if (bytesTotal > fileEntry.size) {
+                throw new RangeError(`Asset "${fileEntry.path}" was modified during the upload (length mismatch)`);
+            }
+            if (output.byteLength) {
+                hash.update(output);
+            }
+            if (bytesTotal === fileEntry.size) {
+                const sha512 = hash.digest('hex');
+                if (sha512 !== fileEntry.sha512) {
+                    throw new Error(`Asset "${fileEntry.path}" was modified during the upload (checksum mismatch)`);
+                }
+            }
+            if (output.byteLength) {
+                yield output;
+            }
+            else {
+                break;
+            }
+        }
+        if (bytesTotal < fileEntry.size) {
+            throw new RangeError(`Asset "${fileEntry.path}" was modified during the upload (length mismatch)`);
+        }
+    }
+    finally {
+        await handle?.close();
+    }
+}
+const makeFormHeader = (params) => {
+    const name = encodeName(params.name);
+    let header = BOUNDARY_HYPHEN_CHARS + BOUNDARY_ID + CRLF;
+    header += `Content-Disposition: form-data; name="${name}"; filename="${name}"`;
+    if (params.contentType) {
+        header += `${CRLF}Content-Type: ${params.contentType}`;
+    }
+    if (params.contentLength) {
+        header += `${CRLF}Content-Length: ${params.contentLength}`;
+    }
+    header += CRLF;
+    header += CRLF;
+    return header;
+};
+exports.multipartContentType = `multipart/form-data; boundary=${BOUNDARY_ID}`;
+async function* createMultipartBodyFromFilesAsync(entries, onProgressUpdate) {
+    const encoder = new TextEncoder();
+    for (let idx = 0; idx < entries.length; idx++) {
+        const entry = entries[idx];
+        const header = makeFormHeader({
+            name: entry.sha512,
+            contentType: entry.type,
+            contentLength: entry.size,
+        });
+        yield encoder.encode(header);
+        yield* createReadStreamAsync(entry);
+        yield encoder.encode(CRLF);
+        if (onProgressUpdate) {
+            onProgressUpdate((idx + 1) / entries.length);
+        }
+    }
+    yield encoder.encode(FORM_FOOTER);
+}

package/package.json

@@ -0,0 +1,246 @@
+{
+  "name": "@donotuse/eas-cli",
+  "version": "18.5.0-rc.1",
+  "description": "EAS command line tool",
+  "keywords": [
+    "cli",
+    "eas",
+    "expo"
+  ],
+  "homepage": "https://github.com/expo/eas-cli",
+  "bugs": "https://github.com/expo/eas-cli/issues",
+  "license": "MIT",
+  "author": "Expo <support@expo.dev>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/expo/eas-cli.git",
+    "directory": "packages/eas-cli"
+  },
+  "bin": {
+    "eas": "./bin/run"
+  },
+  "files": [
+    "/bin",
+    "/build",
+    "/oclif.manifest.json",
+    "/schema"
+  ],
+  "scripts": {
+    "postpack": "rimraf oclif.manifest.json",
+    "prepack": "yarn rebuild && node ./scripts/prepack.js",
+    "rebuild": "rimraf build *.tsbuildinfo && yarn build",
+    "build": "yarn typecheck-for-build && yarn copy-new-templates",
+    "build-allow-unused": "tsc --project tsconfig.allowUnused.json",
+    "watch": "yarn typecheck-for-build --watch --preserveWatchOutput",
+    "watch-allow-unused": "yarn build-allow-unused --watch --preserveWatchOutput",
+    "typecheck": "tsc",
+    "typecheck-for-build": "tsc --project tsconfig.build.json",
+    "test": "jest",
+    "version": "yarn run -T oclif readme && node scripts/patch-readme && git add README.md",
+    "generate-graphql-code": "graphql-codegen --config graphql-codegen.yml",
+    "verify-graphql-code": "./scripts/verify-graphql.sh",
+    "clean": "rimraf dist build tmp node_modules yarn-error.log *.tsbuildinfo",
+    "copy-new-templates": "rimraf build/commandUtils/new/templates && mkdir -p build/commandUtils/new && cp -r src/commandUtils/new/templates build/commandUtils/new"
+  },
+  "dependencies": {
+    "@expo/apple-utils": "./expo-apple-utils-2.1.15-rc.1.tgz",
+    "@expo/code-signing-certificates": "0.0.5",
+    "@expo/config": "10.0.6",
+    "@expo/config-plugins": "9.0.12",
+    "@expo/eas-build-job": "18.4.0",
+    "@expo/eas-json": "18.4.0",
+    "@expo/env": "^1.0.0",
+    "@expo/json-file": "8.3.3",
+    "@expo/logger": "18.0.1",
+    "@expo/multipart-body-parser": "2.0.0",
+    "@expo/osascript": "2.1.4",
+    "@expo/package-manager": "1.9.10",
+    "@expo/pkcs12": "0.1.3",
+    "@expo/plist": "0.2.0",
+    "@expo/plugin-help": "5.1.23",
+    "@expo/plugin-warn-if-update-available": "2.5.1",
+    "@expo/prebuild-config": "8.0.17",
+    "@expo/results": "1.0.0",
+    "@expo/rudder-sdk-node": "1.1.1",
+    "@expo/spawn-async": "1.7.2",
+    "@expo/steps": "18.4.0",
+    "@expo/timeago.js": "1.0.0",
+    "@oclif/core": "^4.8.3",
+    "@oclif/plugin-autocomplete": "^3.2.40",
+    "@segment/ajv-human-errors": "^2.1.2",
+    "@urql/core": "4.0.11",
+    "@urql/exchange-retry": "1.2.0",
+    "ajv": "8.11.0",
+    "ajv-formats": "2.1.1",
+    "better-opn": "3.0.2",
+    "bplist-parser": "^0.3.0",
+    "chalk": "4.1.2",
+    "cli-progress": "3.12.0",
+    "dateformat": "4.6.3",
+    "diff": "7.0.0",
+    "dotenv": "16.3.1",
+    "env-paths": "2.2.0",
+    "envinfo": "7.11.0",
+    "fast-deep-equal": "3.1.3",
+    "fast-glob": "3.3.2",
+    "figures": "3.2.0",
+    "form-data": "^4.0.4",
+    "fs-extra": "11.2.0",
+    "getenv": "1.0.0",
+    "gradle-to-js": "2.0.1",
+    "graphql": "16.8.1",
+    "graphql-tag": "2.12.6",
+    "https-proxy-agent": "5.0.1",
+    "ignore": "5.3.0",
+    "indent-string": "4.0.0",
+    "invariant": "^2.2.2",
+    "jks-js": "1.1.0",
+    "joi": "17.11.0",
+    "keychain": "1.5.0",
+    "log-symbols": "4.1.0",
+    "mime": "3.0.0",
+    "minimatch": "5.1.2",
+    "minizlib": "3.0.1",
+    "nanoid": "3.3.8",
+    "node-fetch": "2.6.7",
+    "node-forge": "1.3.1",
+    "node-stream-zip": "1.15.0",
+    "nullthrows": "1.1.1",
+    "ora": "5.1.0",
+    "pkg-dir": "4.2.0",
+    "pngjs": "7.0.0",
+    "promise-limit": "2.7.0",
+    "promise-retry": "2.0.1",
+    "prompts": "2.4.2",
+    "qrcode-terminal": "0.12.0",
+    "resolve-from": "5.0.0",
+    "semver": "7.5.4",
+    "set-interval-async": "3.0.3",
+    "slash": "3.0.0",
+    "tar": "7.5.7",
+    "tar-stream": "3.1.7",
+    "terminal-link": "2.1.1",
+    "ts-deepmerge": "6.2.0",
+    "tslib": "2.6.2",
+    "turndown": "7.1.2",
+    "untildify": "4.0.0",
+    "uuid": "9.0.1",
+    "wrap-ansi": "7.0.0",
+    "yaml": "2.6.0",
+    "zod": "^4.1.3"
+  },
+  "devDependencies": {
+    "@graphql-codegen/cli": "5.0.0",
+    "@graphql-codegen/introspection": "4.0.0",
+    "@graphql-codegen/typescript": "4.0.1",
+    "@graphql-codegen/typescript-operations": "4.0.1",
+    "@tsconfig/node20": "20.1.8",
+    "@types/cli-progress": "3.11.5",
+    "@types/dateformat": "3.0.1",
+    "@types/diff": "6.0.0",
+    "@types/envinfo": "7.8.3",
+    "@types/express": "4.17.15",
+    "@types/fs-extra": "11.0.4",
+    "@types/getenv": "^1.0.0",
+    "@types/invariant": "^2.2.37",
+    "@types/mime": "3.0.1",
+    "@types/node-fetch": "2.6.12",
+    "@types/node-forge": "1.3.1",
+    "@types/pngjs": "6.0.4",
+    "@types/promise-retry": "1.1.3",
+    "@types/prompts": "2.4.2",
+    "@types/semver": "7.5.6",
+    "@types/tar": "6.1.10",
+    "@types/tar-stream": "3.1.3",
+    "@types/tough-cookie": "4.0.2",
+    "@types/uuid": "9.0.7",
+    "@types/wrap-ansi": "3.0.0",
+    "axios": "1.11.0",
+    "eslint-plugin-graphql": "4.0.0",
+    "express": "4.20.0",
+    "jest": "29.7.0",
+    "memfs": "3.4.13",
+    "mockdate": "3.0.5",
+    "nock": "13.4.0",
+    "rimraf": "3.0.2",
+    "ts-mockito": "2.6.1",
+    "ts-node": "10.9.2",
+    "typescript": "5.5.4"
+  },
+  "oclif": {
+    "additionalHelpFlags": [
+      "-h"
+    ],
+    "additionalVersionFlags": [
+      "-v"
+    ],
+    "bin": "eas",
+    "commands": "./build/commands",
+    "plugins": [
+      "@oclif/plugin-autocomplete",
+      "@expo/plugin-help",
+      "@expo/plugin-warn-if-update-available"
+    ],
+    "topics": {
+      "account": {
+        "description": "manage account"
+      },
+      "branch": {
+        "description": "manage update branches"
+      },
+      "build": {
+        "description": "build app binaries"
+      },
+      "channel": {
+        "description": "manage update channels"
+      },
+      "device": {
+        "description": "manage Apple devices for Internal Distribution"
+      },
+      "env": {
+        "description": "manage project and account environment variables"
+      },
+      "metadata": {
+        "description": "manage store configuration"
+      },
+      "project": {
+        "description": "manage project"
+      },
+      "release": {
+        "description": "manage update releases"
+      },
+      "secret": {
+        "description": "manage project and account secrets"
+      },
+      "update": {
+        "description": "manage individual updates"
+      },
+      "webhook": {
+        "description": "manage webhooks"
+      },
+      "workflow": {
+        "description": "manage workflows"
+      }
+    },
+    "update": {
+      "node": {
+        "version": "20.19.4"
+      },
+      "s3": {
+        "templates": {
+          "target": {
+            "unversioned": "<%- bin %>-<%- platform %>-<%- arch %><%- ext %>",
+            "versioned": "<%- bin %>-<%- platform %>-<%- arch %><%- ext %>"
+          }
+        }
+      }
+    },
+    "warn-if-update-available": {
+      "message": "<%= chalk('★') %> <%= chalk.bold(config.name + '@' + latest) %> <%= chalk.bold('is now available.') %>\n<%= chalk.dim('To upgrade, run:') %>\n<%= chalk.dim(chalk.bold('npm install -g eas-cli')) %>\n<%= chalk.dim('Proceeding with outdated version.') %>\n",
+      "timeoutInDays": 0.5
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}