@expo/build-tools 21.0.1 → 21.0.2

package/dist/context.js

@@ -17,26 +17,6 @@ const packageManager_1 = require("./utils/packageManager");
 class SkipNativeBuildError extends Error {
 }
 exports.SkipNativeBuildError = SkipNativeBuildError;
-function logEnvComparison({ oldMergeOrderEnv, newMergeOrderEnv, }) {
-    const envNames = new Set([...Object.keys(oldMergeOrderEnv), ...Object.keys(newMergeOrderEnv)]);
-    const sameEnvNames = [];
-    const differentEnvNames = [];
-    for (const key of envNames) {
-        const hasOldValue = key in oldMergeOrderEnv;
-        const hasNewValue = key in newMergeOrderEnv;
-        if (hasOldValue === hasNewValue && oldMergeOrderEnv[key] === newMergeOrderEnv[key]) {
-            sameEnvNames.push(key);
-        }
-        else {
-            differentEnvNames.push(key);
-        }
-    }
-    if (differentEnvNames.length === 0) {
-        datadog_1.Datadog.log('BuildContext.updateEnv merge order produced same env');
-        return;
-    }
-    datadog_1.Datadog.log(`BuildContext.updateEnv merge order produced different env: compared_env_count=${envNames.size} different_env_count=${differentEnvNames.length} different_env_names=${differentEnvNames.join(',')} same_env_count=${sameEnvNames.length} same_env_names=${sameEnvNames.join(',')}`);
-}
 class BuildContext {
     workingdir;
     logger;
@@ -177,21 +157,11 @@ class BuildContext {
         if (this._job.triggeredBy !== common_1.BuildTrigger.GIT_BASED_INTEGRATION) {
             throw new Error('Updating environment variables is only allowed when build was triggered by a git-based integration.');
         }
-        const oldMergeOrderEnv = {
-            ...env,
-            ...this._env,
-            __EAS_BUILD_ENVS_DIR: this.buildEnvsDirectory,
-        };
-        const newMergeOrderEnv = {
+        this._env = {
             ...this._env,
             ...env,
             __EAS_BUILD_ENVS_DIR: this.buildEnvsDirectory,
         };
-        logEnvComparison({
-            oldMergeOrderEnv,
-            newMergeOrderEnv,
-        });
-        this._env = newMergeOrderEnv;
         this._env.PATH = this._env.PATH
             ? [this.buildExecutablesDirectory, this._env.PATH].join(':')
             : this.buildExecutablesDirectory;

package/dist/gcs/LoggerStream.d.ts

@@ -1,6 +1,6 @@
 import { bunyan } from '@expo/logger';
 import { Writable } from 'stream';
-import GCS from './client';
+import { GCS } from './client';
 declare class GCSLoggerStream extends Writable {
     writable: boolean;
     private readonly logger;
@@ -37,10 +37,6 @@ declare namespace GCSLoggerStream {
         compress?: CompressionMethod;
     }
     type UploadMethod = {
-        client: GCS;
-        key: string;
-        customTime: Date | null;
-    } | {
         signedUrl: GCS.SignedUrl;
     };
     interface Config {

package/dist/gcs/LoggerStream.js

@@ -11,7 +11,7 @@ const path_1 = __importDefault(require("path"));
 const stream_1 = require("stream");
 const util_1 = require("util");
 const zlib_1 = __importDefault(require("zlib"));
-const client_1 = __importDefault(require("./client"));
+const client_1 = require("./client");
 const pipe = (0, util_1.promisify)(stream_1.pipeline);
 class GCSLoggerStream extends stream_1.Writable {
     writable = true;
@@ -38,7 +38,7 @@ class GCSLoggerStream extends stream_1.Writable {
         this.temporaryCompressedLogsPath = `${this.temporaryLogsPath}.compressed`;
     }
     findNormalizedHeader(name) {
-        if (!this.uploadMethod || 'client' in this.uploadMethod) {
+        if (!this.uploadMethod) {
             return null;
         }
         const normalizedName = name.toLowerCase().replace('-', '');
@@ -145,24 +145,10 @@ class GCSLoggerStream extends stream_1.Writable {
         const srcGeneratorAsync = async () => {
             return await this.createCompressedStream(fs_extra_1.default.createReadStream(this.temporaryLogsPath, { end: size }));
         };
-        if ('signedUrl' in this.uploadMethod) {
-            return await client_1.default.uploadWithSignedUrl({
-                signedUrl: this.uploadMethod.signedUrl,
-                srcGeneratorAsync,
-            });
-        }
-        const { Location } = await this.uploadMethod.client.uploadFile({
-            key: this.uploadMethod.key,
-            src: await srcGeneratorAsync(),
-            streamOptions: {
-                metadata: {
-                    contentType: 'text/plain;charset=utf-8',
-                    ...(this.compress !== null ? { contentEncoding: this.compress } : {}),
-                    customTime: this.uploadMethod.customTime,
-                },
-            },
+        return await client_1.GCS.uploadWithSignedUrl({
+            signedUrl: this.uploadMethod.signedUrl,
+            srcGeneratorAsync,
         });
-        return Location;
     }
     async createCompressedStream(src) {
         if (!this.compress) {

package/dist/gcs/client.d.ts

@@ -1,58 +1,15 @@
-import { CreateWriteStreamOptions, File } from '@google-cloud/storage';
 import { Readable } from 'stream';
-import { RetryOptions } from './retry';
-interface SignedUrlParams {
-    key: string;
-    expirationTime: number;
-    contentType?: string;
-    extensionHeaders?: {
-        [key: string]: number | string | string[];
-    };
-}
 interface UploadWithSignedUrlParams {
     signedUrl: GCS.SignedUrl;
     srcGeneratorAsync: () => Promise<Readable>;
-    retryIntervalMs?: RetryOptions['retryIntervalMs'];
-    retries?: RetryOptions['retries'];
+    retryIntervalMs?: number;
+    retries?: number;
 }
-declare class GCS {
-    private readonly bucket;
-    private readonly client;
-    constructor(bucket: string);
-    static uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries, retryIntervalMs, }: UploadWithSignedUrlParams): Promise<string>;
-    formatHttpUrl(key: string): string;
-    uploadFile({ key, src, streamOptions, }: {
-        key: string;
-        src: Readable;
-        streamOptions?: CreateWriteStreamOptions;
-    }): Promise<{
-        Location: string;
-    }>;
-    deleteFile(key: string): Promise<void>;
-    createSignedUploadUrl({ key, expirationTime, contentType, extensionHeaders, }: SignedUrlParams): Promise<GCS.SignedUrl>;
-    createSignedDownloadUrl({ key, expirationTime, }: {
-        key: string;
-        expirationTime: number;
-    }): Promise<string>;
-    checkIfFileExists(key: string, fileHash?: string): Promise<boolean>;
-    listDirectory(prefix: string): Promise<string[]>;
-    moveFile(src: string, dest: string): Promise<void>;
-    deleteFiles(keys: string[]): Promise<void>;
-    downloadFile(key: string, destinationPath: string): Promise<void>;
-    getFile(key: string): File;
-}
-declare namespace GCS {
-    interface SignedUrl {
+export declare namespace GCS {
+    type SignedUrl = {
         url: string;
-        headers: {
-            [key: string]: string;
-        };
-    }
-    interface Config {
-        accessKeyId: string;
-        secretAccessKey: string;
-        region: string;
-        bucket: string;
-    }
+        headers: Record<string, string>;
+    };
+    function uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries, retryIntervalMs, }: UploadWithSignedUrlParams): Promise<string>;
 }
-export default GCS;
+export {};

package/dist/gcs/client.js

@@ -32,26 +32,14 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const storage_1 = require("@google-cloud/storage");
-const fs_extra_1 = __importDefault(require("fs-extra"));
+exports.GCS = void 0;
 const node_fetch_1 = __importStar(require("node-fetch"));
-const node_stream_1 = __importDefault(require("node:stream"));
-const node_util_1 = require("node:util");
 const url_1 = require("url");
 const retry_1 = require("./retry");
-const pipeline = (0, node_util_1.promisify)(node_stream_1.default.pipeline);
-class GCS {
-    bucket;
-    client = new storage_1.Storage();
-    constructor(bucket) {
-        this.bucket = bucket;
-        this.bucket = bucket;
-    }
-    static async uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries = 2, retryIntervalMs = 30_000, }) {
+var GCS;
+(function (GCS) {
+    async function uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries = 2, retryIntervalMs = 30_000, }) {
         let resp;
         try {
             resp = await (0, retry_1.retryOnGCSUploadFailure)(async () => {
@@ -61,18 +49,13 @@ class GCS {
                     headers: signedUrl.headers,
                     body: src,
                 });
-            }, {
-                retries,
-                retryIntervalMs,
-            });
+            }, { retries, retryIntervalMs });
         }
         catch (err) {
             if (err instanceof node_fetch_1.FetchError) {
                 throw new Error(`Failed to upload the file, reason: ${err.code}`);
             }
-            else {
-                throw err;
-            }
+            throw err;
         }
         if (!resp.ok) {
             let body;
@@ -83,91 +66,7 @@ class GCS {
             throw new Error(`Failed to upload file: status: ${resp.status} status text: ${resp.statusText}, body: ${body}`);
         }
         const url = new url_1.URL(signedUrl.url);
-        return `${url.protocol}//${url.host}${url.pathname}`; // strip query string
-    }
-    formatHttpUrl(key) {
-        return this.client.bucket(this.bucket).file(key).publicUrl();
-    }
-    async uploadFile({ key, src, streamOptions, }) {
-        const file = this.client.bucket(this.bucket).file(key);
-        await new Promise((res, rej) => {
-            src.pipe(file
-                .createWriteStream(streamOptions)
-                .on('error', err => {
-                rej(err);
-            })
-                .on('finish', () => {
-                res();
-            }));
-        });
-        return { Location: file.publicUrl() };
-    }
-    async deleteFile(key) {
-        try {
-            await this.client.bucket(this.bucket).file(key).delete();
-        }
-        catch (err) {
-            if (err.response?.statusCode === 404) {
-                return;
-            }
-            throw err;
-        }
-    }
-    async createSignedUploadUrl({ key, expirationTime, contentType, extensionHeaders = {}, }) {
-        const config = {
-            version: 'v4',
-            action: 'write',
-            expires: Date.now() + expirationTime,
-            contentType,
-            extensionHeaders,
-        };
-        const [url] = await this.client.bucket(this.bucket).file(key).getSignedUrl(config);
-        return {
-            url,
-            headers: {
-                ...(contentType ? { 'content-type': contentType } : {}),
-                ...extensionHeaders,
-            },
-        };
-    }
-    async createSignedDownloadUrl({ key, expirationTime, }) {
-        const options = {
-            version: 'v4',
-            action: 'read',
-            expires: Date.now() + expirationTime,
-        };
-        const [url] = await this.client.bucket(this.bucket).file(key).getSignedUrl(options);
-        return url;
-    }
-    async checkIfFileExists(key, fileHash) {
-        let metadata;
-        try {
-            [metadata] = await this.client.bucket(this.bucket).file(key).getMetadata();
-        }
-        catch (error) {
-            if (error.code === 404) {
-                return false;
-            }
-            throw error;
-        }
-        return fileHash ? metadata.etag === fileHash : true;
-    }
-    async listDirectory(prefix) {
-        const [files] = await this.client.bucket(this.bucket).getFiles({ prefix });
-        return files.map(x => this.formatHttpUrl(x.name));
-    }
-    async moveFile(src, dest) {
-        await this.client.bucket(this.bucket).file(src).move(dest);
-    }
-    async deleteFiles(keys) {
-        await Promise.all(keys.map(key => this.deleteFile(key)));
-    }
-    async downloadFile(key, destinationPath) {
-        const stream = this.client.bucket(this.bucket).file(key).createReadStream();
-        await pipeline(stream, fs_extra_1.default.createWriteStream(destinationPath));
-    }
-    getFile(key) {
-        return this.client.bucket(this.bucket).file(key);
+        return `${url.protocol}//${url.host}${url.pathname}`;
     }
-}
-exports.default = GCS;
+    GCS.uploadWithSignedUrl = uploadWithSignedUrl;
+})(GCS || (exports.GCS = GCS = {}));

package/dist/gcs/retry.d.ts

@@ -1,11 +1,12 @@
 import { Response } from 'node-fetch';
-export interface RetryOptions {
+type RetryOptions = {
     retries: number;
     retryIntervalMs: number;
-    shouldRetryOnError: (error: any) => boolean;
+    shouldRetryOnError: (error: unknown) => boolean;
     shouldRetryOnResponse: (response: Response) => boolean;
-}
+};
 export declare function retryOnGCSUploadFailure(fn: (attemptCount: number) => Promise<Response>, { retries, retryIntervalMs, }: {
     retries: RetryOptions['retries'];
     retryIntervalMs: RetryOptions['retryIntervalMs'];
 }): Promise<Response>;
+export {};

package/dist/gcs/retry.js

@@ -6,20 +6,24 @@ async function retryOnGCSUploadFailure(fn, { retries, retryIntervalMs, }) {
     return await retry(fn, {
         retries,
         retryIntervalMs,
-        shouldRetryOnError: e => {
-            return (e.code === 'ENOTFOUND' ||
-                e.code === 'EAI_AGAIN' ||
-                e.code === 'ECONNRESET' ||
-                e.code === 'ETIMEDOUT' ||
-                e.code === 'EPIPE');
+        shouldRetryOnError: err => {
+            return (isErrorWithCode(err) &&
+                (err.code === 'ENOTFOUND' ||
+                    err.code === 'EAI_AGAIN' ||
+                    err.code === 'ECONNRESET' ||
+                    err.code === 'ETIMEDOUT' ||
+                    err.code === 'EPIPE'));
         },
         shouldRetryOnResponse: resp => {
             return [408, 429, 500, 502, 503, 504].includes(resp.status);
         },
     });
 }
+function isErrorWithCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error;
+}
 /**
- * Wrapper used to execute an inner function and possibly retry it if it throws and error
+ * Wrapper used to execute an inner function and possibly retry it if it throws an error
  * @param fn Function to be executed and retried in case of error
  * @param retries How many times at most should the function be retried
  * @param retryIntervalMs Time interval between the retries

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as Builders from './builders';
 import GCSLoggerStream from './gcs/LoggerStream';
-import GCS from './gcs/client';
+import { GCS } from './gcs/client';
 export { Builders, GCS, GCSLoggerStream };
 export { ArtifactToUpload, Artifacts, BuildContext, BuildContextOptions, CacheManager, LogBuffer, SkipNativeBuildError, } from './context';
 export { PackageManager } from './utils/packageManager';

package/dist/index.js

@@ -44,8 +44,8 @@ const Builders = __importStar(require("./builders"));
 exports.Builders = Builders;
 const LoggerStream_1 = __importDefault(require("./gcs/LoggerStream"));
 exports.GCSLoggerStream = LoggerStream_1.default;
-const client_1 = __importDefault(require("./gcs/client"));
-exports.GCS = client_1.default;
+const client_1 = require("./gcs/client");
+Object.defineProperty(exports, "GCS", { enumerable: true, get: function () { return client_1.GCS; } });
 var context_1 = require("./context");
 Object.defineProperty(exports, "BuildContext", { enumerable: true, get: function () { return context_1.BuildContext; } });
 Object.defineProperty(exports, "SkipNativeBuildError", { enumerable: true, get: function () { return context_1.SkipNativeBuildError; } });

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -16,18 +16,17 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             logger.info('Starting serve-sim remote session.');
             await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
-            const { previewUrl, streamUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
+            const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                 baseDomain: ngrokTunnelDomain,
                 env,
                 logger,
                 timeoutMs: STARTUP_TIMEOUT_MS,
             });
             logger.info(`Preview URL: ${previewUrl}`);
-            logger.info(`Stream URL: ${streamUrl}`);
             await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
                 ctx,
                 deviceRunSessionId,
-                remoteConfig: { previewUrl, streamUrl },
+                remoteConfig: { previewUrl },
                 logger,
             });
             await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({

package/dist/steps/functions/uploadDeviceRunSessionScreenRecordings.js

@@ -25,8 +25,22 @@ const RecordingManifestSchema = zod_1.z.object({
     firstFrameWallClock: zod_1.z.object({
         iso8601: zod_1.z.string(),
     }),
+    width: zod_1.z.number().int().positive(),
+    height: zod_1.z.number().int().positive(),
     recording: zod_1.z.string(),
 });
+const recordingStartTimeFormatter = new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    fractionalSecondDigits: 3,
+    hourCycle: 'h23',
+    timeZone: 'UTC',
+    timeZoneName: 'short',
+});
 function createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -56,9 +70,11 @@ function createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx) {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const limit = (0, promise_limit_1.default)(5);
             await Promise.all(recordings.map(recording => limit(async () => {
-                const displayName = `${recording.deviceName} screen recording`;
                 try {
                     const metadata = RecordingManifestSchema.parse(JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(recording.directory, 'session.json'), 'utf-8')));
+                    const startedAt = recordingStartTimeFormatter.format(new Date(metadata.firstFrameWallClock.iso8601));
+                    const shortUdid = `${recording.udid.slice(0, 8)}-…`;
+                    const displayName = `${recording.deviceName} screen recording (${shortUdid}, started at ${startedAt})`;
                     const recordingPath = node_path_1.default.join(recording.directory, metadata.recording);
                     const { size } = await (0, promises_1.stat)(recordingPath);
                     const recordingId = node_path_1.default.basename(recording.directory);
@@ -70,11 +86,14 @@ function createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx) {
                         filename: `${recordingId}.mp4`,
                         kind: 'screen-recording',
                         metadata: {
+                            __eas_type: 'screen-recording',
                             __eas_screen_recording: '1',
                             udid: recording.udid,
                             deviceName: recording.deviceName,
                             runtimeDisplayName: recording.runtimeDisplayName,
                             firstFrameAt: metadata.firstFrameWallClock.iso8601,
+                            width: metadata.width,
+                            height: metadata.height,
                         },
                         size,
                         stream: (0, node_fs_1.createReadStream)(recordingPath),

package/dist/steps/utils/IosSimulatorRecordingUtils.js

@@ -13,7 +13,7 @@ const promises_2 = require("node:timers/promises");
 const sentry_1 = require("../../sentry");
 const IosSimulatorUtils_1 = require("../../utils/IosSimulatorUtils");
 const IOS_SIMULATOR_RECORDING_POLL_INTERVAL_MS = 2_000;
-const RECORD_SIM_FINISH_TIMEOUT_MS = 30_000;
+const RECORD_SIM_FINISH_TIMEOUT_MS = 70_000;
 const RECORD_SIM_FORCE_STOP_TIMEOUT_MS = 5_000;
 const RECORD_SIM_MAX_ATTEMPTS_PER_BOOT = 3;
 const RECORD_SIM_COMMAND = 'record-sim';
@@ -70,7 +70,11 @@ var IosSimulatorRecordingUtils;
             if (finished) {
                 return;
             }
-            logger.warn(`Forcing iOS Simulator recording process for ${recording.deviceName} to stop.`);
+            const recordSimOutput = recording.getOutput().trim();
+            const finishTimeoutSeconds = Math.round(RECORD_SIM_FINISH_TIMEOUT_MS / 1_000);
+            logger.warn({ recordSimOutput }, `Screen recording for ${recording.deviceName} did not finish within ${finishTimeoutSeconds} seconds and will be stopped.${recordSimOutput
+                ? `\nRecent recorder messages:\n${recordSimOutput}`
+                : '\nNo recorder messages were captured.'}`);
             recording.recordingProcess.kill('SIGKILL');
             const killed = await Promise.race([
                 recording.completionPromise.then(() => true),

package/dist/steps/utils/remoteDeviceRunSession.d.ts

@@ -65,7 +65,6 @@ export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, {
     timeoutMs: number;
 }): Promise<{
     previewUrl: string;
-    streamUrl: string;
 }>;
 export declare function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, rewriteHostHeader, logger, }: {
     port: number;

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -289,21 +289,20 @@ async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, time
         ],
         env,
     });
-    logger.info('Waiting for serve-sim to report tunnel and stream URLs.');
+    logger.info('Waiting for serve-sim to report tunnel URL.');
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         const output = serveSim.getOutput();
-        const previewUrl = matchLabeledUrl({ output, label: 'Tunnel', baseDomain });
-        const streamUrl = matchLabeledUrl({ output, label: 'Stream', baseDomain });
-        if (previewUrl && streamUrl) {
-            return { previewUrl, streamUrl };
+        const previewUrl = matchTunnelUrl({ output, baseDomain });
+        if (previewUrl) {
+            return { previewUrl };
         }
         await (0, retry_1.sleepAsync)(1_000);
     }
-    throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim to report Tunnel and Stream URLs. Last output:\n${serveSim.getOutput() || '<empty>'}`);
+    throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim to report Tunnel URL. Last output:\n${serveSim.getOutput() || '<empty>'}`);
 }
-function matchLabeledUrl({ output, label, baseDomain, }) {
-    const labelPattern = new RegExp(`${label}:\\s*(https:\\/\\/[a-z0-9-]+\\.${escapeRegExp(baseDomain)})`);
+function matchTunnelUrl({ output, baseDomain, }) {
+    const labelPattern = new RegExp(`Tunnel:\\s*(https:\\/\\/[a-z0-9-]+\\.${escapeRegExp(baseDomain)})`);
     const match = labelPattern.exec(output);
     return match ? match[1] : null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "21.0.1",
+  "version": "21.0.2",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -39,18 +39,17 @@
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
     "@expo/downloader": "21.0.0",
-    "@expo/eas-build-job": "21.0.1",
+    "@expo/eas-build-job": "21.0.2",
     "@expo/env": "^0.4.0",
     "@expo/logger": "21.0.0",
     "@expo/package-manager": "1.9.10",
-    "@expo/plist": "^0.2.0",
+    "@expo/plist": "^0.3.5",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "21.0.1",
-    "@expo/template-file": "21.0.0",
+    "@expo/steps": "21.0.2",
+    "@expo/template-file": "21.0.2",
     "@expo/turtle-spawn": "21.0.0",
     "@expo/xcpretty": "^4.3.1",
-    "@google-cloud/storage": "^7.11.2",
     "@ngrok/ngrok": "1.7.0",
     "@sentry/node": "7.77.0",
     "@urql/core": "^6.0.1",
@@ -61,7 +60,7 @@
     "gql.tada": "^1.8.13",
     "joi": "^17.13.1",
     "jose": "5.10.0",
-    "lodash": "^4.17.21",
+    "lodash": "^4.18.1",
     "node-fetch": "^2.7.0",
     "node-forge": "^1.3.1",
     "node-stream-zip": "1.15.0",
@@ -101,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "a62289b9888b71fe90e3022840643b182b732048"
+  "gitHead": "e9ebc41413ae2b5c7b4b92e91f45e9f65e3dbd23"
 }

package/resources/record-sim/Sources/RecordSim/RecordingModels.swift

@@ -59,8 +59,15 @@ public struct FirstFrameWallClock: Codable, Sendable {
     public let iso8601: String
 }
 
+public enum RecordingFinalizationStage: Sendable {
+    case captureStopped
+    case videoSaved
+}
+
 public struct RecordingManifest: Codable, Sendable {
     public let firstFrameWallClock: FirstFrameWallClock
+    public let width: Int
+    public let height: Int
     public let hlsVersion: Int?
     public let hlsTargetDurationSeconds: Int?
     public let hlsMediaSequence: Int?

package/resources/record-sim/Sources/RecordSim/RecordingOutputWriter.swift

@@ -100,7 +100,9 @@ final class RecordingOutputWriter: NSObject, AVAssetWriterDelegate {
     @discardableResult
     func writeManifest(
         configuration: SimulatorRecordingConfiguration,
-        firstFrameWallClock: Date
+        firstFrameWallClock: Date,
+        width: Int,
+        height: Int
     ) throws -> RecordingManifest {
         try stateQueue.sync {
             if let firstError {
@@ -121,6 +123,8 @@ final class RecordingOutputWriter: NSObject, AVAssetWriterDelegate {
                     unixMs: unixMs(firstFrameWallClock),
                     iso8601: iso8601(firstFrameWallClock)
                 ),
+                width: width,
+                height: height,
                 hlsVersion: segmented ? 7 : nil,
                 hlsTargetDurationSeconds: targetDuration,
                 hlsMediaSequence: segmented ? 0 : nil,

package/resources/record-sim/Sources/RecordSim/SimulatorRecorder.swift

@@ -7,6 +7,7 @@ import UniformTypeIdentifiers
 public final class SimulatorRecorder {
     public var onSegment: ((SegmentOutput) -> Void)?
     public var onSimulatorStopped: ((String) -> Void)?
+    public var onFinalizationStage: ((RecordingFinalizationStage) -> Void)?
 
     private static let callbackStalenessTimeout: TimeInterval = 5
     private static let firstFrameRewireInterval: TimeInterval = 1
@@ -26,6 +27,8 @@ public final class SimulatorRecorder {
     private var monotonicClock = MonotonicClock()
     private var firstAcceptedCaptureTime: CMTime?
     private var firstAcceptedWallClock: Date?
+    private var recordingWidth: Int?
+    private var recordingHeight: Int?
     private var lastPTS: CMTime?
     private var lastSeed: UInt32?
     private var lastFrameCallbackElapsed: TimeInterval?
@@ -113,6 +116,7 @@ public final class SimulatorRecorder {
             displaySource?.stop()
             displaySource = nil
         }
+        onFinalizationStage?(.captureStopped)
 
         return try writerQueue.sync {
             if let firstError {
@@ -139,12 +143,18 @@ public final class SimulatorRecorder {
             if let error = outputWriter.error {
                 throw error
             }
+            onFinalizationStage?(.videoSaved)
             guard let firstAcceptedWallClock else {
                 throw RecorderError.make(25, "Missing first frame wall-clock timestamp")
             }
+            guard let recordingWidth, let recordingHeight else {
+                throw RecorderError.make(27, "Missing recording dimensions")
+            }
             return try outputWriter.writeManifest(
                 configuration: configuration,
-                firstFrameWallClock: firstAcceptedWallClock
+                firstFrameWallClock: firstAcceptedWallClock,
+                width: recordingWidth,
+                height: recordingHeight
             )
         }
     }
@@ -590,6 +600,8 @@ public final class SimulatorRecorder {
         self.writer = writer
         self.input = input
         self.adaptor = adaptor
+        recordingWidth = width
+        recordingHeight = height
     }
 
     private func assetWriterSettings(width: Int, height: Int) -> [String: Any] {

package/resources/record-sim/Sources/record-sim/main.swift

@@ -10,15 +10,15 @@ struct CLIOptions {
     var codec: RecorderCodec = .h264
 }
 
-private var stopRequested: CInt = 0
+private var requestedStopSignal: CInt = 0
 private var simulatorStopped: CInt = 0
 
-private func handleStopSignal(_: CInt) {
-    stopRequested = 1
+private func handleStopSignal(_ signal: CInt) {
+    requestedStopSignal = signal
 }
 
 private func isStopRequested() -> Bool {
-    stopRequested != 0 || simulatorStopped != 0
+    requestedStopSignal != 0 || simulatorStopped != 0
 }
 
 func usage() -> String {
@@ -112,6 +112,14 @@ do {
         simulatorStopped = 1
         fputs("[record-sim] simulator stopped state=\(state); finalizing recording\n", stderr)
     }
+    recorder.onFinalizationStage = { stage in
+        switch stage {
+        case .captureStopped:
+            fputs("[record-sim] screen capture stopped; saving final video\n", stderr)
+        case .videoSaved:
+            fputs("[record-sim] final video saved; writing recording details\n", stderr)
+        }
+    }
     recorder.onSegment = { segment in
         switch segment.kind {
         case .initialization:
@@ -130,6 +138,14 @@ do {
         Thread.sleep(forTimeInterval: 0.1)
     }
 
+    if requestedStopSignal != 0 {
+        let signalName = switch requestedStopSignal {
+        case SIGINT: "SIGINT"
+        case SIGTERM: "SIGTERM"
+        default: "signal \(requestedStopSignal)"
+        }
+        fputs("[record-sim] received \(signalName); finishing recording\n", stderr)
+    }
     let manifest = try recorder.stop()
     if let recording = manifest.recording {
         fputs("[record-sim] done recording=\(recording)\n", stderr)

package/dist/gcs/__unit__/gcs.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/gcs/__unit__/gcs.test.js

@@ -1,335 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = require("crypto");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const path_1 = __importDefault(require("path"));
-const stream_1 = require("stream");
-const client_1 = __importDefault(require("../client"));
-jest.mock('node-fetch');
-class ErrorWithCode extends Error {
-    _code;
-    constructor(message, code) {
-        super(message);
-        if (code) {
-            this._code = code;
-        }
-    }
-    get code() {
-        return this._code;
-    }
-}
-class DNSError extends ErrorWithCode {
-    _code = 'ENOTFOUND';
-}
-const TEST_BUCKET = 'turtle-v2-test';
-let googleApplicationCredentials;
-beforeAll(() => {
-    googleApplicationCredentials = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-    process.env.GOOGLE_APPLICATION_CREDENTIALS = path_1.default.join(__dirname, 'mock-credentials.json');
-});
-afterAll(() => {
-    process.env.GOOGLE_APPLICATION_CREDENTIALS = googleApplicationCredentials;
-});
-describe('GCS client', () => {
-    describe('uploadWithPresignedURL function', () => {
-        it('should throw an error if upload fails', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: false,
-                status: 500,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock.mockImplementation(async () => res);
-            await expect(client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            })).rejects.toThrow();
-        });
-        it('should return stripped URL if successful', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock.mockImplementation(async () => res);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/cat.jpg');
-        });
-        it('should retry upload on DNS error up to 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed once');
-            })
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed twice', 'EAI_AGAIN');
-            })
-                .mockImplementation(async () => res);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/cat.jpg');
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should retry upload on retriable status codes error up to 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 503,
-                };
-            })
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 408,
-                };
-            })
-                .mockImplementation(async () => res);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/cat.jpg');
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should retry upload on retriable status codes and DNS errors error up to 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 503,
-                };
-            })
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed once');
-            })
-                .mockImplementation(async () => res);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/cat.jpg');
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should not retry upload on DNS error more than 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            const lastDNSError = new DNSError('failed thrice');
-            fetchMock
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed once');
-            })
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed twice', 'EAI_AGAIN');
-            })
-                .mockImplementationOnce(async () => {
-                throw lastDNSError;
-            })
-                .mockImplementation(async () => res);
-            await expect(client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            })).rejects.toThrow(lastDNSError);
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should not retry upload on retriable status code more than 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 503,
-                };
-            })
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 408,
-                };
-            })
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 504,
-                };
-            })
-                .mockImplementation(async () => res);
-            await expect(client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            })).rejects.toThrow();
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should not retry upload on other error codes', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            const nonDNSError = new ErrorWithCode('failed once', 'A_DIFFERENT_CODE');
-            fetchMock
-                .mockImplementationOnce(async () => {
-                throw nonDNSError;
-            })
-                .mockImplementation(async () => res);
-            await expect(client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            })).rejects.toThrow(nonDNSError);
-            expect(fetchMock).toHaveBeenCalledTimes(1);
-        });
-        it('retries upload with full stream', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const receivedBodies = [];
-            const recordBody = async (request) => {
-                let body = Buffer.from([]);
-                for await (const chunk of request.body) {
-                    body = Buffer.concat([body, chunk]);
-                }
-                receivedBodies.push(body);
-            };
-            fetchMock
-                .mockImplementationOnce(async (_path, request) => {
-                await recordBody(request);
-                return {
-                    ok: false,
-                    status: 503,
-                };
-            })
-                .mockImplementationOnce(async (_path, request) => {
-                await recordBody(request);
-                throw new DNSError('failed once');
-            })
-                .mockImplementation(async (_path, request) => {
-                await recordBody(request);
-                return {
-                    ok: true,
-                    status: 201,
-                };
-            });
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key: 'text.txt',
-                expirationTime: 30000,
-                contentType: 'text/plain',
-            });
-            const bufferToUpload = (0, crypto_1.randomBytes)(16);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => stream_1.Readable.from(bufferToUpload),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/text.txt');
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-            expect(receivedBodies.length).toBe(3);
-            for (const body of receivedBodies) {
-                // Here we're testing that each body received in every retry is the same.
-                // If we passed the same body instance to each of the retries
-                // each retry would consume a chunk of the same stream,
-                // causing the uploaded file to be corrupted (missing first bytes).
-                expect(body).toStrictEqual(bufferToUpload);
-            }
-        });
-    });
-});