eas-cli-local-build-plugin 0.0.141 → 0.0.142

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "eas-cli-local-build-plugin",
-  "version": "0.0.141",
+  "version": "0.0.142",
   "description": "Tool for running EAS compatible builds on a local machine.",
   "main": "dist/main.js",
+  "files": [
+    "dist"
+  ],
   "bin": {
     "eas-cli-local-build-plugin": "./bin/run"
   },
@@ -20,7 +23,7 @@
   "bugs": "https://github.com/expo/eas-build/issues",
   "license": "BUSL-1.1",
   "dependencies": {
-    "@expo/build-tools": "0.1.184",
+    "@expo/build-tools": "0.1.185",
     "@expo/bunyan": "^4.0.0",
     "@expo/eas-build-job": "0.2.106",
     "@expo/spawn-async": "^1.7.0",

package/src/android.ts

@@ -1,45 +0,0 @@
-import { bunyan } from '@expo/logger';
-import { Android, BuildPhase, Env } from '@expo/eas-build-job';
-import { Builders, BuildContext, ArtifactType, Artifacts } from '@expo/build-tools';
-import omit from 'lodash/omit';
-
-import logger, { logBuffer } from './logger';
-import { BuildParams } from './types';
-import { prepareArtifacts } from './artifacts';
-import config from './config';
-import { runGlobalExpoCliCommandAsync } from './expoCli';
-
-export async function buildAndroidAsync(
-  job: Android.Job,
-  { workingdir, env: baseEnv, metadata }: BuildParams
-): Promise<Artifacts> {
-  const versionName = job.version?.versionName;
-  const versionCode = job.version?.versionCode;
-  const env: Env = {
-    ...baseEnv,
-    ...(versionCode && { EAS_BUILD_ANDROID_VERSION_CODE: versionCode }),
-    ...(versionName && { EAS_BUILD_ANDROID_VERSION_NAME: versionName }),
-  };
-  const ctx = new BuildContext<Android.Job>(job, {
-    workingdir,
-    logger,
-    logBuffer,
-    runGlobalExpoCliCommand: runGlobalExpoCliCommandAsync,
-    uploadArtifacts: async (type: ArtifactType, paths: string[], logger?: bunyan) => {
-      if (type !== ArtifactType.APPLICATION_ARCHIVE) {
-        return null;
-      } else {
-        return await prepareArtifacts(paths, logger);
-      }
-    },
-    env,
-    metadata,
-    skipNativeBuild: config.skipNativeBuild,
-  });
-
-  await ctx.runBuildPhase(BuildPhase.START_BUILD, async () => {
-    ctx.logger.info({ job: omit(ctx.job, 'secrets') }, 'Starting build');
-  });
-
-  return await Builders.androidBuilder(ctx);
-}

package/src/artifacts.ts

@@ -1,56 +0,0 @@
-import path from 'path';
-
-import { bunyan } from '@expo/logger';
-import fs from 'fs-extra';
-import tar from 'tar';
-
-import config from './config';
-
-export async function prepareArtifacts(artifactPaths: string[], logger?: bunyan): Promise<string> {
-  const l = logger?.child({ phase: 'PREPARE_ARTIFACTS' });
-  l?.info('Preparing artifacts');
-  let suffix;
-  let localPath;
-  if (artifactPaths.length === 1 && !(await fs.lstat(artifactPaths[0])).isDirectory()) {
-    [localPath] = artifactPaths;
-    suffix = path.extname(artifactPaths[0]);
-  } else {
-    const parentDir = artifactPaths.reduce(
-      (acc, item) => getCommonParentDir(acc, item),
-      artifactPaths[0]
-    );
-    const relativePathsToArchive = artifactPaths.map((absolute) =>
-      path.relative(parentDir, absolute)
-    );
-
-    const archivePath = path.join(config.workingdir, 'artifacts.tar.gz');
-    await tar.c(
-      {
-        gzip: true,
-        file: archivePath,
-        cwd: parentDir,
-      },
-      relativePathsToArchive
-    );
-    suffix = '.tar.gz';
-    localPath = archivePath;
-  }
-  const artifactName = `build-${Date.now()}${suffix}`;
-  const destPath = config.artifactPath ?? path.join(config.artifactsDir, artifactName);
-  await fs.copy(localPath, destPath);
-  l?.info({ phase: 'PREPARE_ARTIFACTS' }, `Writing artifacts to ${destPath}`);
-  return destPath;
-}
-
-function getCommonParentDir(path1: string, path2: string): string {
-  const normalizedPath1 = path.normalize(path1);
-  const normalizedPath2 = path.normalize(path2);
-  let current = path.dirname(normalizedPath1);
-  while (current !== '/') {
-    if (normalizedPath2.startsWith(current)) {
-      return current;
-    }
-    current = path.dirname(current);
-  }
-  return '/';
-}

package/src/build.ts

@@ -1,88 +0,0 @@
-import path from 'path';
-
-import { Job, Platform, ArchiveSourceType, Metadata, Workflow } from '@expo/eas-build-job';
-import pickBy from 'lodash/pickBy';
-import fs from 'fs-extra';
-import chalk from 'chalk';
-import { Artifacts, SkipNativeBuildError } from '@expo/build-tools';
-import nullthrows from 'nullthrows';
-
-import { buildAndroidAsync } from './android';
-import config from './config';
-import { buildIosAsync } from './ios';
-import { prepareWorkingdirAsync } from './workingdir';
-
-export async function buildAsync(job: Job, metadata: Metadata): Promise<void> {
-  const workingdir = await prepareWorkingdirAsync();
-
-  try {
-    let username = metadata.username;
-    if (!username && job.type === Workflow.MANAGED) {
-      username = job.username;
-    }
-
-    // keep in sync with worker env vars
-    // https://github.com/expo/turtle-v2/blob/main/src/services/worker/src/env.ts
-    const unfilteredEnv: Record<string, string | undefined> = {
-      ...process.env,
-      ...job.builderEnvironment?.env,
-      EAS_BUILD: '1',
-      EAS_BUILD_RUNNER: 'local-build-plugin',
-      EAS_BUILD_PLATFORM: job.platform,
-      EAS_BUILD_WORKINGDIR: path.join(workingdir, 'build'),
-      EAS_BUILD_PROFILE: metadata.buildProfile,
-      EAS_BUILD_GIT_COMMIT_HASH: metadata.gitCommitHash,
-      EAS_BUILD_USERNAME: username,
-      ...(job.platform === Platform.ANDROID && {
-        EAS_BUILD_ANDROID_VERSION_CODE: job.version?.versionCode,
-        EAS_BUILD_ANDROID_VERSION_NAME: job.version?.versionName,
-      }),
-      ...(job.platform === Platform.IOS && {
-        EAS_BUILD_IOS_BUILD_NUMBER: job.version?.buildNumber,
-        EAS_BUILD_IOS_APP_VERSION: job.version?.appVersion,
-      }),
-    };
-    const env = pickBy(unfilteredEnv, (val?: string): val is string => !!val);
-
-    let artifacts: Artifacts | undefined;
-    switch (job.platform) {
-      case Platform.ANDROID: {
-        artifacts = await buildAndroidAsync(job, { env, workingdir, metadata });
-        break;
-      }
-      case Platform.IOS: {
-        artifacts = await buildIosAsync(job, { env, workingdir, metadata });
-        break;
-      }
-    }
-    if (!config.skipNativeBuild) {
-      console.log();
-      console.log(chalk.green('Build successful'));
-      console.log(
-        chalk.green(
-          `You can find the build artifacts in ${nullthrows(artifacts.APPLICATION_ARCHIVE)}`
-        )
-      );
-    }
-  } catch (e: any) {
-    if (e instanceof SkipNativeBuildError) {
-      console.log(e.message);
-      return;
-    }
-    console.error();
-    console.error(chalk.red(`Build failed`));
-    if (config.logger.level === 'debug') {
-      console.error(e.innerError);
-    }
-    throw e;
-  } finally {
-    if (!config.skipCleanup) {
-      await fs.remove(workingdir);
-    } else {
-      console.error(chalk.yellow(`Skipping cleanup, ${workingdir} won't be removed.`));
-    }
-    if (job.projectArchive.type === ArchiveSourceType.PATH) {
-      await fs.remove(job.projectArchive.path);
-    }
-  }
-}

package/src/checkRuntime.ts

@@ -1,131 +0,0 @@
-import { Job, Platform } from '@expo/eas-build-job';
-import chalk from 'chalk';
-import spawnAsync from '@expo/spawn-async';
-import fs from 'fs-extra';
-
-interface Validator {
-  platform?: Platform;
-  checkAsync: (job: Job) => Promise<void>;
-}
-
-function warn(msg: string): void {
-  console.log(chalk.yellow(msg));
-}
-
-function error(msg: string): void {
-  console.error(chalk.red(msg));
-}
-
-const validators: Validator[] = [
-  {
-    async checkAsync(job: Job) {
-      if (job.platform === Platform.IOS && process.platform !== 'darwin') {
-        throw new Error('iOS builds can only be run on macOS.');
-      } else if (
-        job.platform === Platform.ANDROID &&
-        !['linux', 'darwin'].includes(process.platform)
-      ) {
-        throw new Error('Android builds are supported only on Linux and macOS');
-      }
-    },
-  },
-  {
-    async checkAsync(job: Job) {
-      try {
-        const version = (await spawnAsync('node', ['--version'], { stdio: 'pipe' })).stdout.trim();
-        const sanitizedVersion = version.startsWith('v') ? version.slice(1) : version;
-        const versionFromJob = job.builderEnvironment?.node;
-        if (versionFromJob) {
-          const sanitizedVersionFromJob = versionFromJob.startsWith('v')
-            ? versionFromJob.slice(1)
-            : versionFromJob;
-          if (sanitizedVersion !== sanitizedVersionFromJob) {
-            warn(
-              'Node.js version in your eas.json does not match the Node.js currently installed in your system'
-            );
-          }
-        }
-      } catch (err) {
-        error("Node.js is not available, make sure it's installed and in your PATH");
-        throw err;
-      }
-    },
-  },
-  {
-    async checkAsync(job: Job) {
-      const versionFromJob = job.builderEnvironment?.yarn;
-      if (!versionFromJob) {
-        return;
-      }
-      try {
-        const version = (await spawnAsync('yarn', ['--version'], { stdio: 'pipe' })).stdout.trim();
-        if (versionFromJob !== version) {
-          warn(
-            'Yarn version in your eas.json does not match the yarn currently installed in your system'
-          );
-        }
-      } catch {
-        warn("Yarn is not available, make sure it's installed and in your PATH");
-      }
-    },
-  },
-  {
-    platform: Platform.ANDROID,
-    async checkAsync(_) {
-      if (!process.env.ANDROID_NDK_HOME) {
-        warn(
-          'ANDROID_NDK_HOME environment variable was not specified, continuing build without NDK'
-        );
-        return;
-      }
-      if (!(await fs.pathExists(process.env.ANDROID_NDK_HOME))) {
-        throw new Error(`NDK was not found under ${process.env.ANDROID_NDK_HOME}`);
-      }
-    },
-  },
-  {
-    platform: Platform.IOS,
-    async checkAsync() {
-      try {
-        await spawnAsync('fastlane', ['--version'], {
-          stdio: 'pipe',
-          env: {
-            ...process.env,
-            FASTLANE_DISABLE_COLORS: '1',
-            FASTLANE_SKIP_UPDATE_CHECK: '1',
-            SKIP_SLOW_FASTLANE_WARNING: 'true',
-            FASTLANE_HIDE_TIMESTAMP: 'true',
-          },
-        });
-      } catch (err) {
-        error("Fastlane is not available, make sure it's installed and in your PATH");
-        throw err;
-      }
-    },
-  },
-  {
-    platform: Platform.IOS,
-    async checkAsync(job: Job) {
-      try {
-        const version = (await spawnAsync('pod', ['--version'], { stdio: 'pipe' })).stdout.trim();
-        const versionFromJob = job.platform === Platform.IOS && job.builderEnvironment?.cocoapods;
-        if (versionFromJob && versionFromJob !== version) {
-          warn(
-            'Cocoapods version in your eas.json does not match the version currently installed in your system'
-          );
-        }
-      } catch (err) {
-        error("Cocoapods is not available, make sure it's installed and in your PATH");
-        throw err;
-      }
-    },
-  },
-];
-
-export async function checkRuntimeAsync(job: Job): Promise<void> {
-  for (const validator of validators) {
-    if (validator.platform === job.platform || !validator.platform) {
-      await validator.checkAsync(job);
-    }
-  }
-}

package/src/config.ts

@@ -1,30 +0,0 @@
-import path from 'path';
-
-import { v4 as uuidv4 } from 'uuid';
-import envPaths from 'env-paths';
-
-const { temp } = envPaths('eas-build-local');
-
-const envLoggerLevel = process.env.EAS_LOCAL_BUILD_LOGGER_LEVEL;
-const envWorkingdir = process.env.EAS_LOCAL_BUILD_WORKINGDIR;
-const envSkipCleanup = process.env.EAS_LOCAL_BUILD_SKIP_CLEANUP;
-const envSkipNativeBuild = process.env.EAS_LOCAL_BUILD_SKIP_NATIVE_BUILD;
-const envArtifactsDir = process.env.EAS_LOCAL_BUILD_ARTIFACTS_DIR;
-const envArtifactPath = process.env.EAS_LOCAL_BUILD_ARTIFACT_PATH;
-
-if (envLoggerLevel && !['debug', 'info', 'warn', 'error'].includes(envLoggerLevel)) {
-  throw new Error(
-    'Invalid value for EAS_LOCAL_BUILD_LOGGER_LEVEL, one of info, warn, or error is expected'
-  );
-}
-
-export default {
-  workingdir: envWorkingdir ?? path.join(temp, uuidv4()),
-  skipCleanup: envSkipCleanup === '1',
-  skipNativeBuild: envSkipNativeBuild === '1',
-  artifactsDir: envArtifactsDir ?? process.cwd(),
-  artifactPath: envArtifactPath,
-  logger: {
-    level: (envLoggerLevel ?? 'info') as 'debug' | 'info' | 'warn' | 'error',
-  },
-};

package/src/exit.ts

@@ -1,39 +0,0 @@
-import logger from './logger';
-
-const handlers: (() => void | Promise<void>)[] = [];
-let shouldExitStatus = false;
-
-export function listenForInterrupts(): void {
-  let handlerInProgress = false;
-  const handleExit = async (): Promise<void> => {
-    try {
-      // when eas-cli calls childProcess.kill() local build receives
-      // signal twice in some cases
-      if (handlerInProgress) {
-        return;
-      }
-      handlerInProgress = true;
-      logger.error({ phase: 'ABORT' }, 'Received termination signal.');
-      shouldExitStatus = true;
-      await Promise.allSettled(
-        handlers.map((handler) => {
-          return handler();
-        })
-      );
-    } finally {
-      handlerInProgress = false;
-    }
-    process.exit(1);
-  };
-
-  process.on('SIGTERM', handleExit);
-  process.on('SIGINT', handleExit);
-}
-
-export function registerHandler(fn: () => void | Promise<void>): void {
-  handlers.push(fn);
-}
-
-export function shouldExit(): boolean {
-  return shouldExitStatus;
-}

package/src/expoCli.ts

@@ -1,24 +0,0 @@
-import spawnAsync, { SpawnOptions, SpawnPromise, SpawnResult } from '@expo/turtle-spawn';
-
-const EXPO_CLI_VERSION = '6.0.5';
-
-export function runGlobalExpoCliCommandAsync(
-  expoCliArgs: string[],
-  options: SpawnOptions,
-  npmVersionAtLeast7: boolean
-): SpawnPromise<SpawnResult> {
-  if (process.env.EXPO_CLI_PATH) {
-    const expoCliBinPath = process.env.EXPO_CLI_PATH;
-    const expoCliCommandWithArgs = expoCliArgs.join(' ');
-    options?.logger?.debug(`${expoCliBinPath} ${expoCliCommandWithArgs}`);
-    return spawnAsync('bash', ['-c', `${expoCliBinPath} ${expoCliCommandWithArgs}`], options);
-  } else {
-    const args = [`expo-cli@${EXPO_CLI_VERSION}`, ...expoCliArgs];
-    if (npmVersionAtLeast7) {
-      // npx shipped with npm >= 7.0.0 requires the "-y" flag to run commands without
-      // prompting the user to install a package that is used for the first time
-      args.unshift('-y');
-    }
-    return spawnAsync('npx', args, options);
-  }
-}

package/src/ios.ts

@@ -1,45 +0,0 @@
-import { Ios, BuildPhase, Env } from '@expo/eas-build-job';
-import { Builders, BuildContext, ArtifactType, Artifacts } from '@expo/build-tools';
-import { bunyan } from '@expo/logger';
-import omit from 'lodash/omit';
-
-import { runGlobalExpoCliCommandAsync } from './expoCli';
-import logger, { logBuffer } from './logger';
-import { BuildParams } from './types';
-import { prepareArtifacts } from './artifacts';
-import config from './config';
-
-export async function buildIosAsync(
-  job: Ios.Job,
-  { workingdir, env: baseEnv, metadata }: BuildParams
-): Promise<Artifacts> {
-  const buildNumber = job.version?.buildNumber;
-  const appVersion = job.version?.appVersion;
-  const env: Env = {
-    ...baseEnv,
-    ...(buildNumber && { EAS_BUILD_IOS_BUILD_NUMBER: buildNumber }),
-    ...(appVersion && { EAS_BUILD_IOS_APP_VERSION: appVersion }),
-  };
-  const ctx = new BuildContext<Ios.Job>(job, {
-    workingdir,
-    logger,
-    logBuffer,
-    runGlobalExpoCliCommand: runGlobalExpoCliCommandAsync,
-    uploadArtifacts: async (type: ArtifactType, paths: string[], logger?: bunyan) => {
-      if (type !== ArtifactType.APPLICATION_ARCHIVE) {
-        return null;
-      } else {
-        return await prepareArtifacts(paths, logger);
-      }
-    },
-    env,
-    metadata,
-    skipNativeBuild: config.skipNativeBuild,
-  });
-
-  await ctx.runBuildPhase(BuildPhase.START_BUILD, async () => {
-    ctx.logger.info({ job: omit(ctx.job, 'secrets') }, 'Starting build');
-  });
-
-  return await Builders.iosBuilder(ctx);
-}

package/src/logger.ts

@@ -1,138 +0,0 @@
-import { Writable } from 'stream';
-
-import bunyan from '@expo/bunyan';
-import chalk from 'chalk';
-import omit from 'lodash/omit';
-import { LogBuffer } from '@expo/build-tools';
-
-import config from './config';
-
-interface Log {
-  msg: string;
-  level: number;
-  err?: any;
-  marker?: string;
-  phase: string;
-  source: 'stdout' | 'stderr';
-}
-const MAX_LINES_IN_BUFFER = 100;
-
-interface CachedLog {
-  msg: string;
-  phase: string;
-}
-
-class BuildCliLogBuffer extends Writable implements LogBuffer {
-  public writable = true;
-  public buffer: CachedLog[] = [];
-
-  constructor(private readonly numberOfLines: number) {
-    super();
-  }
-
-  public write(rec: any): boolean {
-    if (
-      // verify required fields
-      typeof rec !== 'object' ||
-      typeof rec?.msg !== 'string' ||
-      typeof rec?.phase !== 'string' ||
-      // use only logs from spawn commands
-      (rec?.source !== 'stdout' && rec?.source !== 'stderr') ||
-      // skip all short lines (it could potentially be some loader)
-      (rec?.msg ?? '').length < 3
-    ) {
-      return true;
-    }
-    if (this.buffer.length >= this.numberOfLines) {
-      this.buffer.shift();
-    }
-    this.buffer.push({ msg: rec.msg, phase: rec.phase });
-    return true;
-  }
-
-  public getLogs(): string[] {
-    return this.buffer.map(({ msg }) => msg);
-  }
-
-  public getPhaseLogs(buildPhase: string): string[] {
-    return this.buffer.filter(({ phase }) => phase === buildPhase).map(({ msg }) => msg);
-  }
-}
-
-class PrettyStream extends Writable {
-  write(rawLog: string): boolean {
-    const log = JSON.parse(rawLog) as Log;
-    if (log.marker) {
-      return true;
-    }
-    const msg = this.formatMessage(log);
-    if (log.level >= bunyan.ERROR || log.source === 'stderr') {
-      console.error(msg);
-    } else {
-      console.log(msg);
-    }
-
-    const extraProperties = omit(log, [
-      'msg',
-      'err',
-      'level',
-      'phase',
-      'marker',
-      'source',
-      'time',
-      'id',
-      'v',
-      'pid',
-      'hostname',
-      'name',
-    ]);
-    if (Object.keys(extraProperties).length !== 0) {
-      const str = JSON.stringify(extraProperties, null, 2);
-      // substring removes `{\n` and `\n}`
-      console.log(chalk.gray(str.substring(2, str.length - 2)));
-    }
-    if (log?.err?.stack) {
-      console.error(chalk.red(log.err.stack));
-    }
-    return true;
-  }
-
-  private formatMessage(log: Log): string {
-    const phase = log.phase;
-    switch (log.level) {
-      case bunyan.DEBUG:
-        return `[${phase}] ${chalk.gray(log.msg)}`;
-      case bunyan.INFO: {
-        const msg = log.source === 'stderr' ? chalk.red(log.msg) : log.msg;
-        return `[${phase}] ${msg}`;
-      }
-      case bunyan.WARN:
-        return `[${phase}] ${chalk.yellow(log.msg)}`;
-      case bunyan.ERROR:
-        return `[${phase}] ${chalk.red(log.msg)}`;
-      case bunyan.FATAL:
-        return `[${phase}] ${chalk.red(log.msg)}`;
-      default:
-        return log.msg;
-    }
-  }
-}
-
-export const logBuffer = new BuildCliLogBuffer(MAX_LINES_IN_BUFFER);
-
-const defaultlogger = bunyan.createLogger({
-  name: 'eas-build-cli',
-  serializers: bunyan.stdSerializers,
-  streams: [
-    {
-      level: config.logger.level,
-      stream: new PrettyStream(),
-    },
-    {
-      level: 'info',
-      stream: logBuffer,
-    },
-  ],
-});
-
-export default defaultlogger;

package/src/main.ts

@@ -1,23 +0,0 @@
-import chalk from 'chalk';
-
-import { parseInputAsync } from './parseInput';
-import { buildAsync } from './build';
-import { listenForInterrupts, shouldExit } from './exit';
-import { checkRuntimeAsync } from './checkRuntime';
-
-listenForInterrupts();
-
-async function main(): Promise<void> {
-  try {
-    const { job, metadata } = await parseInputAsync();
-    await checkRuntimeAsync(job);
-    await buildAsync(job, metadata);
-  } catch (err: any) {
-    if (!shouldExit()) {
-      console.error(chalk.red(err.message));
-      process.exit(1);
-    }
-  }
-}
-
-void main();

package/src/parseInput.ts

@@ -1,85 +0,0 @@
-import {
-  Job,
-  sanitizeJob,
-  ArchiveSourceType,
-  Metadata,
-  sanitizeMetadata,
-} from '@expo/eas-build-job';
-import Joi from 'joi';
-import chalk from 'chalk';
-import fs from 'fs-extra';
-
-import { registerHandler } from './exit';
-
-const packageJson = require('../package.json');
-
-interface Params {
-  job: Job;
-  metadata: Metadata;
-}
-
-const ParamsSchema = Joi.object<Params>({
-  job: Joi.object().unknown(),
-  metadata: Joi.object().unknown(),
-});
-
-export async function parseInputAsync(): Promise<Params> {
-  if (process.argv.findIndex((arg) => arg === '--version' || arg === '-v') !== -1) {
-    console.log(packageJson.version);
-    process.exit(0);
-  }
-  const rawInput = process.argv[2];
-
-  if (!rawInput) {
-    displayHelp();
-    process.exit(1);
-  }
-  let parsedParams;
-  try {
-    parsedParams = JSON.parse(Buffer.from(rawInput, 'base64').toString('utf8'));
-  } catch (err) {
-    console.error(`${chalk.red('The input passed as a argument is not base64 encoded json.')}`);
-    throw err;
-  }
-  const params = validateParams(parsedParams);
-  registerHandler(async () => {
-    if (params.job.projectArchive.type === ArchiveSourceType.PATH) {
-      await fs.remove(params.job.projectArchive.path);
-    }
-  });
-  return params;
-}
-
-function validateParams(params: object): Params {
-  const { value, error } = ParamsSchema.validate(params, {
-    stripUnknown: true,
-    convert: true,
-    abortEarly: false,
-  });
-  if (error) {
-    throw error;
-  }
-  try {
-    const job = sanitizeJob(value.job);
-    const metadata = sanitizeMetadata(value.metadata);
-    return { ...value, job, metadata };
-  } catch (err) {
-    console.log(`Currently using ${packageJson.name}@${packageJson.version}.`);
-    console.error(
-      chalk.red(
-        `Job object has incorrect format, update to latest versions of ${chalk.bold(
-          'eas-cli'
-        )} and ${chalk.bold(packageJson.name)} to make sure you are using compatible packages.`
-      )
-    );
-    throw err;
-  }
-}
-
-function displayHelp(): void {
-  console.log(
-    `This tool is not intended for standalone use, it will be used internally by ${chalk.bold(
-      'eas-cli'
-    )} when building with flag ${chalk.bold('--local')}.`
-  );
-}

package/src/types.ts

@@ -1,7 +0,0 @@
-import { Metadata } from '@expo/eas-build-job';
-
-export interface BuildParams {
-  workingdir: string;
-  env: Record<string, string>;
-  metadata: Metadata;
-}

package/src/workingdir.ts

@@ -1,29 +0,0 @@
-import path from 'path';
-
-import chalk from 'chalk';
-import fs from 'fs-extra';
-
-import config from './config';
-import logger from './logger';
-import { registerHandler } from './exit';
-
-export async function prepareWorkingdirAsync(): Promise<string> {
-  const { workingdir } = config;
-  logger.info({ phase: 'SETUP_WORKINGDIR' }, `Preparing workingdir ${workingdir}`);
-
-  if ((await fs.pathExists(workingdir)) && (await fs.readdir(workingdir)).length > 0) {
-    throw new Error('Workingdir is not empty.');
-  }
-  await fs.mkdirp(path.join(workingdir, 'artifacts'));
-  await fs.mkdirp(path.join(workingdir, 'build'));
-  registerHandler(async () => {
-    if (!config.skipCleanup) {
-      await fs.remove(workingdir);
-    } else {
-      console.error(
-        chalk.yellow("EAS_LOCAL_BUILD_SKIP_CLEANUP is set, working dir won't be removed.")
-      );
-    }
-  });
-  return workingdir;
-}

package/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["src/**/__mocks__/**/*.ts", "src/**/__test__/**/*.ts"]
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist"
-  },
-  "include": [
-    "src/**/*"
-  ]
-}