Handle eas build locally thorugh buildCommand in launch.json

packages/vscode-extension/src/builders/buildAndroid.ts

@@ -93,7 +93,12 @@ export async function buildAndroid(
     getTelemetryReporter().sendTelemetryEvent("build:custom-build-requested", {
       platform: DevicePlatform.Android,
     });
-    const apkPath = await runExternalBuild(cancelToken, customBuild.android.buildCommand, env);
+    const apkPath = await runExternalBuild(
+      cancelToken,
+      customBuild.android.buildCommand,
+      env,
+      DevicePlatform.Android
+    );
     if (!apkPath) {
       throw new Error("Failed to build Android app using custom script.");
     }

packages/vscode-extension/src/builders/buildIOS.ts

@@ -93,7 +93,12 @@ export async function buildIos(
     });
     // We don't autoinstall Pods here to make custom build scripts more flexible
 
-    const appPath = await runExternalBuild(cancelToken, customBuild.ios.buildCommand, env);
+    const appPath = await runExternalBuild(
+      cancelToken,
+      customBuild.ios.buildCommand,
+      env,
+      DevicePlatform.IOS
+    );
     if (!appPath) {
       throw new Error("Failed to build iOS app using custom script.");
     }

packages/vscode-extension/src/builders/customBuild.ts

@@ -1,27 +1,66 @@
 import path from "path";
 import fs from "fs";
+import os from "os";
+import { mkdtemp } from "fs/promises";
 import { Logger } from "../Logger";
 import { command, lineReader } from "../utilities/subprocess";
 import { CancelToken } from "./cancelToken";
 import { getAppRootFolder } from "../utilities/extensionContext";
+import { extractTarApp, isApkFile, isAppFile } from "./utils";
+import { DevicePlatform } from "../common/DeviceManager";
 
 type Env = Record<string, string> | undefined;
 
-export async function runExternalBuild(cancelToken: CancelToken, buildCommand: string, env: Env) {
+// Extracts all paths from the last line, both Unix and Windows format
+const BUILD_PATH_REGEX = /(\/.*?\.\S*)|([a-zA-Z]:\\.*?\.\S*)/g;
+
+export async function runExternalBuild(
+  cancelToken: CancelToken,
+  buildCommand: string,
+  env: Env,
+  platform: DevicePlatform
+) {
   const output = await runExternalScript(buildCommand, env, cancelToken);
 
   if (!output) {
     return undefined;
   }
 
-  const binaryPath = output.lastLine;
+  let binaryPath = output.lastLine;
+
+  // We run regex to extract paths from the first line and we take the first one
+  const groups = output.lastLine.match(BUILD_PATH_REGEX);
+  if (groups?.[0]) {
+    binaryPath = groups[0];
+  }
+
   if (binaryPath && !fs.existsSync(binaryPath)) {
     Logger.error(
       `External script: ${buildCommand} failed to output any existing app path, got: ${binaryPath}`
     );
     return undefined;
   }
 
+  const shouldExtractArchive = binaryPath.endsWith(".tar.gz");
+  if (shouldExtractArchive) {
+    const tmpDirectory = await mkdtemp(path.join(os.tmpdir(), "rn-ide-custom-build-"));
+    const extractedFile = await extractTarApp(binaryPath, tmpDirectory, cancelToken, platform);
+
+    Logger.info(`External script: ${buildCommand} output app path: ${binaryPath}`);
+    return extractedFile;
+  }
+
+  if (platform === DevicePlatform.Android && !isApkFile(binaryPath)) {
+    Logger.error(`External script: ${buildCommand} failed to output .apk file, got: ${binaryPath}`);
+    return undefined;
+  }
+
+  if (platform === DevicePlatform.IOS && !isAppFile(binaryPath)) {
+    Logger.error(`External script: ${buildCommand} failed to output .app file, got: ${binaryPath}`);
+    return undefined;
+  }
+
+  Logger.info(`External script: ${buildCommand} output app path: ${binaryPath}`);
   return binaryPath;
 }
 

packages/vscode-extension/src/builders/eas.ts

@@ -1,15 +1,15 @@
 import path from "path";
 import os from "os";
-import { mkdtemp, readdir } from "fs/promises";
+import { mkdtemp } from "fs/promises";
 import maxBy from "lodash/maxBy";
 
 import { DevicePlatform } from "../common/DeviceManager";
 import { EasConfig } from "../common/LaunchConfig";
 import { Logger } from "../Logger";
 import { CancelToken } from "./cancelToken";
-import { exec } from "../utilities/subprocess";
 import { downloadBinary } from "../utilities/common";
 import { EASBuild, listEasBuilds, viewEasBuild } from "./easCommand";
+import { extractTarApp } from "./utils";
 
 export async function fetchEasBuild(
   cancelToken: CancelToken,
@@ -84,10 +84,6 @@ async function downloadAppFromEas(
   platform: DevicePlatform,
   cancelToken: CancelToken
 ) {
-  function isAppFile(name: string) {
-    return name.endsWith(".app");
-  }
-
   const { id, binaryUrl } = build;
 
   const tmpDirectory = await mkdtemp(path.join(os.tmpdir(), "rn-ide-eas-build-"));
@@ -107,27 +103,5 @@ async function downloadAppFromEas(
     return binaryPath;
   }
 
-  const { failed } = await cancelToken.adapt(
-    tarCommand({ archivePath: binaryPath, extractDir: tmpDirectory })
-  );
-  if (failed) {
-    Logger.error(`Failed to extract archive '${binaryPath}' to '${tmpDirectory}'.`);
-    return undefined;
-  }
-
-  // assuming that the archive contains only one .app file
-  const appName = (await readdir(tmpDirectory)).find(isAppFile);
-  if (!appName) {
-    Logger.error(`Failed to find .app in extracted archive '${binaryPath}'.`);
-    return undefined;
-  }
-
-  const appPath = path.join(tmpDirectory, appName);
-  Logger.debug(`Extracted app archive to '${appPath}'.`);
-  return appPath;
-}
-
-type TarCommandArgs = { archivePath: string; extractDir: string };
-function tarCommand({ archivePath, extractDir }: TarCommandArgs) {
-  return exec("tar", ["-xf", archivePath, "-C", extractDir]);
+  return await extractTarApp(binaryPath, tmpDirectory, cancelToken, DevicePlatform.IOS);
 }

packages/vscode-extension/src/builders/utils.ts

@@ -0,0 +1,52 @@
+import { readdir } from "fs/promises";
+import path from "path";
+import { Logger } from "../Logger";
+import { exec } from "../utilities/subprocess";
+import { CancelToken } from "./cancelToken";
+import { DevicePlatform } from "../common/DeviceManager";
+
+export function isAppFile(name: string) {
+  return name.endsWith(".app");
+}
+
+export function isApkFile(name: string) {
+  return name.endsWith(".apk");
+}
+
+export async function extractTarApp(
+  binaryPath: string,
+  pathToExtract: string,
+  cancelToken: CancelToken,
+  platform: DevicePlatform
+) {
+  const { failed } = await cancelToken.adapt(
+    tarCommand({ archivePath: binaryPath, extractDir: pathToExtract })
+  );
+
+  if (failed) {
+    Logger.error(`Failed to extract archive '${binaryPath}' to '${pathToExtract}'.`);
+    return undefined;
+  }
+
+  // assuming that the archive contains only one app file
+  const appName = (await readdir(pathToExtract)).find(
+    platform === DevicePlatform.Android ? isApkFile : isAppFile
+  );
+  if (!appName) {
+    Logger.error(
+      `Failed to find the ${
+        platform === DevicePlatform.Android ? ".apk" : ".app"
+      } file in extracted archive '${binaryPath}'.`
+    );
+    return undefined;
+  }
+
+  const appPath = path.join(pathToExtract, appName);
+  Logger.debug(`Extracted app archive to '${appPath}'.`);
+  return appPath;
+}
+
+type TarCommandArgs = { archivePath: string; extractDir: string };
+function tarCommand({ archivePath, extractDir }: TarCommandArgs) {
+  return exec("tar", ["-xf", archivePath, "-C", extractDir]);
+}