@yahoo/uds 0.1.12 → 0.1.14

package/cli/README.md

@@ -0,0 +1,135 @@
+# UDS ClI
+
+We leverage Bluebun, which is a CLI framework inspired by [Gluegun](https://github.com/infinitered/gluegun), but specifically designed to be used with [Bun](https://bun.sh), the new JS runtime.
+
+Bluebun relies on Bun APIs and is designed to be extremely fast, with no-dependencies.
+
+# Standalone executable
+
+We use Bun to build our standalone executable. See [Bun build docs](https://bun.sh/docs/bundler/executables) for more details. The uds package.json's `build:cli` script handles building the CLI. The bin is output to the `dist/uds` binary file and this path is defined in the package.json's bin field.
+
+# Commands
+
+## Command structure
+
+Commands are organized in a tree structure. The root command is the name of the CLI (uds), and then we can have subcommands under that, and subcommands under those, and so on.
+
+For example, a command structure might look like this:
+
+```
+cli/
+  commands/
+    pizza.ts        # pizza
+    help.ts         # pizza help
+    bake/
+      bake.ts       # pizza bake
+      cheese.ts     # pizza bake cheese
+      pepperoni.ts  # pizza bake pepperoni
+```
+
+## Command files
+
+Commands are exported as defaults from each command file. They look like this:
+
+```typescript
+import { type Props } from 'bluebun';
+
+export default {
+  name: 'bake',
+  description: 'Bake a pizza',
+  alias: ['b'],
+  run: async (props: Props) => {
+    // bake it!
+  },
+};
+```
+
+## Command properties
+
+Commands have the following properties:
+
+- `name` - the name of the command
+- `description` - a description of the command for the automatic help system
+- `alias` - an array of aliases for the command (can also be a single string)
+- `run` - the function that is run when the command is run, usually `async`
+
+## Props
+
+The `run` function is passed a `Props` object. This object contains the command path, the arguments, and the options, as well as a few other useful things.
+
+Here are the properties available on the `props` object if we were to run `uds bake cheese convection --sliced --temp=400 --time 30`:
+
+- `name` - the name of the CLI (uds)
+- `cliPath` - the path to the CLI (./uds-cli)
+- `argv` - the raw arguments passed to the CLI (e.g. `["/bin/bun", "/bin/uds", "bake", "cheese", "convection", "--sliced", "--temp=400", "--time", "30"]`)
+- `commandPath` - the path to the command that was run (e.g. `["bake", "cheese"]`)
+- `arguments` - the positional arguments passed to the command (e.g. `["convection"]`)
+- `options` - the options passed to the command (e.g. `{ sliced: true, temp: 400, time: 30 }`)
+- `first` - the first argument passed to the command (e.g. `"convection"`)
+- `second` - the second argument passed to the command (e.g. `undefined`)
+- `third` - the third argument passed to the command (e.g. `undefined`)
+
+Given these props, we might have a command that looks like this:
+
+```typescript
+import { type Props, spinStart, spinStop } from 'bluebun';
+import { createPizza, slice } from './_pizza';
+import { convectionBake, toasterBake, regularBake } from './_bakePizza';
+
+export default {
+  name: 'bake',
+  description: 'Bake a pizza',
+  alias: ['b'],
+  run: async (props: Props) => {
+    const { first, second, third, options } = props;
+
+    const pizza = createPizza();
+
+    spinStart('Baking pizza...');
+    if (first === 'convection') {
+      await convectionBake(pizza, options.temp, options.time);
+    } else if (first === 'toaster') {
+      await toasterBake(pizza, options.temp, options.time);
+    } else {
+      await regularBake(pizza, options.temp, options.time);
+    }
+    spinStop('✅ Pizza baked!');
+
+    spinStart('Slicing pizza...');
+    if (options.sliced) {
+      await slice(pizza);
+    }
+    spinStop('✅ Pizza sliced!');
+  },
+};
+```
+
+# Reference
+
+Bluebun comes with a number of built-in utilities that are useful. They're all exported from `bluebun` directly, so you can import them like this:
+
+```typescript
+import { inputKey } from 'bluebun';
+```
+
+Each of the following docs has usage examples and a Testing section that gives examples on how to write tests for them.
+
+## CLI
+
+- [run](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/run.md) - run the CLI and command
+- [cli](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/cli.md) - start the CLI without running the command
+- [commandHelp](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/commandHelp.md) - get a list of all commands and their descriptions
+
+## User Interaction
+
+- [ask](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/ask.md) - ask the user a question via a prompt
+- [cursor](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/cursor.md) - manipulate the cursor
+- [inputKey](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/inputKey.md) - wait for a single keypress
+- [inputKeys](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/inputKeys.md) - wait for and handle multiple keypresses
+
+## Output
+
+- [print](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/print.md) - print a string to the terminal
+- [spinner](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/spinner.md) - start and stop a spinner
+- [progress](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/progress.md) - start, update, and stop a progress bar
+- [styles and colors](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/styles.md) - style and colorize text

package/cli/commands/config/config.ts

@@ -0,0 +1,10 @@
+import { type Props } from 'bluebun';
+import { getCommandHelp } from '../../utils/getCommandHelp';
+
+export default {
+  name: 'config',
+  description: '',
+  run: async (props: Props) => {
+    await getCommandHelp(props);
+  },
+};

package/cli/commands/config/sync.ts

@@ -0,0 +1,22 @@
+import { Props } from 'bluebun';
+import { setupConfigWorker } from '../../utils/setupConfigWorker';
+import { SyncOptions } from '../../utils/types';
+
+interface SyncProps extends Props {
+  options: SyncOptions;
+}
+
+export default {
+  name: 'sync',
+  description: '🌈 Sync',
+  run: async ({ options }: SyncProps) => {
+    await setupConfigWorker({
+      ...options,
+      onUpdate: ({ worker }) => {
+        if (!options.watch) {
+          worker.terminate();
+        }
+      },
+    });
+  },
+};

package/cli/commands/expo/_setup.ts

@@ -0,0 +1,244 @@
+import { EasJsonAccessor, EasJsonUtils, Platform } from '@expo/eas-json';
+import { type Props, print } from 'bluebun';
+import { $, semver, which } from 'bun';
+
+export interface MobileProps extends Props {
+  options: {
+    profile: string;
+    platform: Platform;
+    jsEngine?: 'hermes' | 'jsc';
+    debug?: boolean;
+  };
+}
+
+export async function needsBinary(lib: string) {
+  return which(lib) === null;
+}
+
+export async function needsBrewFormula(formula: string) {
+  return (await $`brew list --formula | grep ${formula} | wc -l`.text()).trim() === '0';
+}
+
+export async function setup({
+  props,
+  env: envOpts,
+}: {
+  props: MobileProps;
+  env?: Partial<typeof Bun.env>;
+}) {
+  const { profile, platform, jsEngine = 'hermes', debug = false } = props.options;
+  const isIOS = platform === Platform.IOS;
+  const isAndroid = platform === Platform.ANDROID;
+
+  /* -------------------------------------------------------------------------- */
+  /*                                 XCODE SETUP                                */
+  /* -------------------------------------------------------------------------- */
+  if (isIOS) {
+    const xcodePath = await $`xcode-select -p`.text();
+    const needsXcode = !xcodePath.startsWith('/Applications');
+    const needsXcrun = await needsBinary('xcrun');
+
+    if (needsXcode) {
+      console.write(
+        'You must have XCode installed before continuing... Visit https://apps.apple.com/us/app/xcode/id497799835?mt=12 to download.',
+      );
+      throw new Error('XCode not installed');
+    }
+
+    /**
+     * Installing the XCode command line tools & simulators normally
+     * requires opening up XCode to install.
+     * This conditional is to avoid having to do that.
+     */
+    if (needsXcrun) {
+      /**
+       * https://developer.apple.com/documentation/xcode/installing-additional-simulator-runtimes#Install-and-manage-Simulator-runtimes-from-the-command-line
+       */
+      await $`xcodebuild -runFirstLaunch`;
+      await $`xcodebuild -downloadPlatform iOS`;
+    }
+  }
+
+  /* -------------------------------------------------------------------------- */
+  /*                            JAVA DEVELOPMENT KIT                            */
+  /* -------------------------------------------------------------------------- */
+  if (isAndroid) {
+    const jdkPath = await $`brew info --cask zulu17`.text();
+    const needsJdk = jdkPath.includes('unavailable');
+    if (needsJdk) {
+      console.write('Installing Java Development Kit for Android...');
+      await $`brew install --cask zulu17`;
+    }
+  }
+
+  /* -------------------------------------------------------------------------- */
+  /*                              EAS CONFIG SETUP                              */
+  /* -------------------------------------------------------------------------- */
+  /**
+   * eas.json is used to define build profiles for different environments.
+   * For example, you may have a profile for development, staging, and production.
+   *
+   * The EAS CLI is used to build and run an app locally based on the eas.json,
+   * but it isn't opinionated about how you define your profiles.
+   *
+   * We however want to enforce some conventions to make it easier to get started.
+   * We also want to store our builds outside of EAS ecosystem since they auto
+   * delete after 30 days & our builds infrequently.
+   *
+   */
+  const appDirectory = Bun.env.PWD;
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(appDirectory);
+  const easProfiles = await EasJsonUtils.getBuildProfileNamesAsync(easJsonAccessor);
+
+  if (!easProfiles.includes(profile)) {
+    const profileNames = easProfiles.join(', ');
+    const suggestion = `Please add one or use ${profileNames}.`;
+
+    if (!profile) {
+      print(`No profile name was provided. ${suggestion}`);
+    } else {
+      print(
+        `A profile with name ${profile} does not exist as a key in eas.json > build object.\n${suggestion}`,
+      );
+    }
+    process.exit(0);
+  }
+
+  const easJsonConfig = await EasJsonUtils.getBuildProfileAsync(easJsonAccessor, platform, profile);
+  const easCliConfig = await EasJsonUtils.getCliConfigAsync(easJsonAccessor);
+  const easCliVersion = easCliConfig?.version ?? 'latest';
+
+  /* -------------------------------------------------------------------------- */
+  /*                                EAS CLI SETUP                               */
+  /* -------------------------------------------------------------------------- */
+  /**
+   * EAS CLI is used to build and run an app locally.
+   */
+  const needsEasCli = await needsBinary('eas');
+  if (needsEasCli) {
+    await $`bun install eas-cli@${easCliVersion} -g`.quiet();
+  } else {
+    const currentEasCliVersion = await $`eas --version`.text();
+    if (!semver.satisfies(currentEasCliVersion, easCliVersion)) {
+      await $`bun install eas-cli@${easCliVersion} -g`.quiet();
+    }
+  }
+
+  const {
+    APP_BUNDLE_IDENTIFIER,
+    APP_ANDROID_BUNDLE_IDENTIFIER: androidId = APP_BUNDLE_IDENTIFIER as string,
+    APP_APPLE_BUNDLE_IDENTIFIER: appleId = APP_BUNDLE_IDENTIFIER as string,
+  } = easJsonConfig.env ?? {};
+
+  // TODO: Add additional checks for ensuring this value adheres to Android formatting specs
+  if (isAndroid && !androidId) {
+    throw new Error(`
+      APP_ANDROID_BUNDLE_IDENTIFIER must be defined in eas.json within the ${profile} > env config.
+      See https://docs.expo.dev/build-reference/variables/#setting-plaintext-environment-variables-in-easjson for information about env variables in eas.json
+
+      This env variable is used to populate the package key in your app.config.(js|ts) > android
+      The format of this env variable must use DNS notation unique name for your app, which is a valid  Android Application ID.
+
+      For example you could use, com.company.app, where com.company is our domain and app is our app.
+
+      We recommend having the release build use the simplest identifier such as com.company.app and your debug variants
+      adding additional context such as com.company.app_debug. When publishing, the release identifier must be unique on the Play Store.
+
+      The name may only contain lowercase and uppercase letters (a-z, A-Z), numbers (0-9) and underscores (_),
+      separated by periods (.). Each component of the name should start with a lowercase letter.
+
+      These formatting rules only applies to Android. iOS has different requirements.
+
+      See https://docs.expo.dev/versions/latest/config/app/#package for more details on formatting.
+      See https://docs.expo.dev/build-reference/variants/ for information about build variants.
+      `);
+  }
+
+  // TODO: Add additional checks for ensuring this value adheres to Uniform Type Identifier
+  if (isIOS && !appleId) {
+    throw new Error(`
+      APP_APPLE_BUNDLE_IDENTIFIER must be defined in eas.json within the ${profile} > env config.
+      See https://docs.expo.dev/build-reference/variables/#setting-plaintext-environment-variables-in-easjson for information about env variables in eas.json
+
+      This env variable is used to populate the package key in your app.config.(js|ts) > ios
+      The format of this env variable must use DNS notation unique name for your app, which is a valid Android Application ID.
+
+      For example you could use, com.company.app, where com.company is our domain and app is our app.
+
+      We recommend having the release build use the simplest identifier such as com.company.app and your debug variants
+      adding additional context such as com.company.app-debug. When publishing, the release identifier must be unique to the App Store.
+
+      The string format should be Uniform Type Identifier(UTI), which is alphanumeric characters (A-Z,a-z,0-9), hyphen (-), and period (.)
+
+      These formatting rules only applies to iOS. Android has different requirements.
+
+      See https://docs.expo.dev/versions/latest/config/app/#bundleidentifier for more details on formatting.
+      See https://docs.expo.dev/build-reference/variants/ for information about build variants.
+      `);
+  }
+
+  const outputName = `${platform}-${profile}-${jsEngine}`;
+  const prebuildsDir = `${appDirectory}/prebuilds`; // TODO: make this configurable
+  const outputDir = `${prebuildsDir}/${outputName}`;
+  const outputFileBase = `${outputDir}/${outputName}`;
+
+  /* -------------------------------------------------------------------------- */
+  /*                            ENVIRONMENT VARIABLES                           */
+  /* -------------------------------------------------------------------------- */
+  let envVars = Bun.env;
+
+  envVars = {
+    ...envVars,
+    APP_ANDROID_BUNDLE_IDENTIFIER: androidId,
+    APP_APPLE_BUNDLE_IDENTIFIER: appleId,
+    RCT_NO_LAUNCH_PACKAGER: '1',
+    EXPO_NO_TELEMETRY: '1',
+    EXPO_NO_WEB_SETUP: '1',
+  };
+
+  if (debug) {
+    envVars = {
+      ...envVars,
+      DEBUG: '*',
+      EAS_LOCAL_BUILD_SKIP_CLEANUP: '1',
+      EXPO_PROFILE: '1',
+    };
+  }
+
+  if (envOpts) {
+    envVars = { ...envVars, ...envOpts };
+  }
+
+  /** Change the default environment variables for shells created by this instance. */
+  $.env(envVars);
+
+  const output = {
+    name: outputName,
+    dir: outputDir,
+    prebuildsDir: prebuildsDir,
+    fileBase: outputFileBase,
+    artifact: isIOS ? `${outputFileBase}.tar.gz` : `${outputFileBase}.zip`,
+    app: isIOS ? `${outputFileBase}.app` : 'todo fix android',
+    get launchFile() {
+      return isIOS ? this.artifact : this.apk.signed;
+    },
+    apk: {
+      contents: `${outputFileBase}/build`,
+      rebuilt: `${outputFileBase}/binary-rebuilt.apk`,
+      rebuiltAligned: `${outputFileBase}/binary-rebuilt-aligned.apk`,
+      signed: `${outputFileBase}/binary.apk`,
+      test: `${outputFileBase}/testBinary.apk`,
+    },
+  };
+
+  return {
+    scheme: isIOS ? appleId : androidId,
+    channel: easJsonConfig.channel,
+    debug,
+    profile,
+    platform,
+    jsEngine,
+    appDirectory,
+    output,
+  };
+}

package/cli/commands/expo/build.ts

@@ -0,0 +1,96 @@
+import { $, semver } from 'bun';
+import { setup, needsBinary, needsBrewFormula, type MobileProps } from './_setup';
+
+export default {
+  name: 'build',
+  description: '🚀 Build',
+  run: async (props: MobileProps) => {
+    const { platform, profile, output } = await setup({
+      props,
+    });
+
+    /* ----- Homebrew, Fastlane, and Cocoapods are only required for builds. ---- */
+    /* -------------------------------------------------------------------------- */
+    /*                               HOMEBREW SETUP                               */
+    /* -------------------------------------------------------------------------- */
+    const needsBrew = await needsBinary('brew');
+    if (needsBrew) {
+      console.write('Installing brew...');
+      await $`/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"`;
+      console.write('Installing brew...Complete');
+
+      /**
+       * This logic was ported from the homebrew installer script
+       * https://github.com/Homebrew/install/blob/master/install.sh#L153C5-L153C63.
+       * However, their script just alerts users to the fact that they need to add
+       * brew to their path, but doesn't do it for them. This logic attempts to do that
+       * so we can automatically proceed to the next steps of auto-installing
+       * the necessary dependencies for local development.
+       */
+      const machineArch = await $`uname -m`.text();
+      const isLinux = (await $`uname`.text()) === 'Linux';
+      const shellType = await $`echo $SHELL`.text();
+      const homebrewPrefix = machineArch.includes('arm64') ? '/opt/homebrew' : '/usr/local';
+      let shellRcFile;
+
+      if (isLinux) {
+        shellRcFile = shellType.includes('zsh') ? '.zshrc' : '.bashrc';
+      } else {
+        shellRcFile = shellType.includes('zsh') ? '.zprofile' : '.bash_profile';
+      }
+
+      const shellRcPath = `${Bun.env.HOME}/${shellRcFile}`;
+      let shellRcContents = '';
+      try {
+        shellRcContents = await Bun.file(shellRcPath).text();
+      } catch (err) {
+        // Ignore if it doesn't exist. We create it below.
+      }
+
+      if (!shellRcContents.includes('homebrew')) {
+        console.write('Adding brew to $PATH...');
+        const newShellRcContents = `${shellRcContents}\neval "$(${homebrewPrefix}/bin/brew shellenv)"`;
+        await Bun.write(shellRcPath, newShellRcContents);
+      }
+    }
+
+    /* -------------------------------------------------------------------------- */
+    /*                               FASTLANE SETUP                               */
+    /* -------------------------------------------------------------------------- */
+    const needsFastlane = await needsBrewFormula('fastlane');
+    if (needsFastlane) {
+      console.write('Installing fastlane...');
+      await $`brew install fastlane`;
+    }
+
+    /* -------------------------------------------------------------------------- */
+    /*                               COCOAPODS SETUP                              */
+    /* -------------------------------------------------------------------------- */
+    const needsCocoapods = await needsBrewFormula('cocoapods');
+    /** https://github.com/facebook/react-native/issues/42698#issuecomment-1915670708 */
+    const validCocoapodsVersion = '1.14.3';
+
+    const installCocoapods = async () =>
+      await $`brew install ${import.meta.dirname}/install/cocoapods.rb`;
+
+    if (needsCocoapods) {
+      console.write('Installing cocoapods...');
+      await installCocoapods();
+    } else {
+      const cocoapodsVersion = await $`pod --version`.text();
+      const needsDowngrade = semver.satisfies(cocoapodsVersion, `>${validCocoapodsVersion}`);
+      if (needsDowngrade) {
+        await $`brew unlink cocoapods`;
+        await $`brew uninstall cocoapods`;
+        console.write(
+          `Downgrading cocoapods from ${cocoapodsVersion} to ${validCocoapodsVersion}...`,
+        );
+        await installCocoapods();
+        await $`brew link cocoapods`;
+      }
+    }
+
+    await $`eas build --local --non-interactive --json --clear-cache --platform ${platform} --profile ${profile} --output ${output.artifact}`;
+    console.write('You can now run your dev command to start the app!');
+  },
+};

package/cli/commands/expo/dev.ts

@@ -0,0 +1,82 @@
+import { Props } from 'bluebun';
+import { $, sleep } from 'bun';
+import { setup, type MobileProps } from './_setup';
+
+interface MobileStartProps extends Props {
+  options: MobileProps['options'] & {
+    // Clear the cache when starting dev server
+    clear?: boolean;
+  };
+}
+
+type SimDevice = { udid: string; name: string; state: 'Booted' | 'Shutdown' };
+type SimList = {
+  devices: {
+    [key: string]: SimDevice[];
+  };
+};
+
+export default {
+  name: 'dev',
+  description: '🚧 Dev',
+  run: async (props: MobileStartProps) => {
+    const { platform, scheme, output } = await setup({
+      props,
+      env: {
+        EXPO_USE_METRO_WORKSPACE_ROOT: '1',
+      },
+    });
+
+    const extraArgs = [];
+
+    if (props.options.clear) {
+      extraArgs.push('--clear');
+    }
+    const extrArgsString = extraArgs.join(' ');
+
+    try {
+      /**
+       * Get list of devices.
+       * If there is a booted device, open the simulator on that device.
+       * If no booted device is found, open the simulator on iPhone 15 Pro Max.
+       * * https://github.com/expo/orbit/blob/main/packages/eas-shared/src/run/ios/simulator.ts#L98
+       *
+       * TODO:
+       * Should we open app on all booted devices if there are multiple open?
+       * Should we prompt user to pick from one of the booted devices?
+       * Should we prompt user to pick a device if there are no booted devices?
+       */
+      if (platform === 'ios') {
+        const deviceList =
+          (await $`xcrun simctl list devices available --json -e`.json()) as SimList;
+        const devices = Object.values(deviceList?.devices).flatMap((item) => item);
+        const bootedDevice = devices.find((device: SimDevice) => device.state === 'Booted');
+        if (!bootedDevice) {
+          const iphone15ProMax = devices.find((device) => device.name === 'iPhone 15 Pro Max');
+          const iphone15Udid = iphone15ProMax?.udid;
+          await $`open -a Simulator --args -CurrentDeviceUDID ${iphone15Udid}`;
+        }
+      }
+
+      /**
+       * In dev mode we use a debug build, which requires a metro server to serve
+       * the Javascript bundle.
+       *
+       * To avoid the, "Could not find metro server" error screen on launch,
+       * we delay the launch of the app until after the metro server has started.
+       */
+      sleep(3000).then(async () => {
+        /**
+         * Launch the app on the booted device
+         * https://github.com/expo/eas-cli?tab=readme-ov-file#eas-buildrun
+         */
+        await $`eas build:run --platform ${platform} --path ${output.launchFile}`;
+      });
+
+      console.write('Starting Metro server...');
+      await $`expo start --${platform} --dev-client --localhost --scheme ${scheme} ${extrArgsString}`;
+    } catch (err) {
+      throw err;
+    }
+  },
+};

package/cli/commands/expo/expo.ts

@@ -0,0 +1,23 @@
+import { type Props } from 'bluebun';
+import { getCommandHelp } from '../../utils/getCommandHelp';
+
+export default {
+  name: 'expo',
+  description: '',
+  run: async (props: Props) => {
+    switch (props?.first) {
+      case 'build':
+        return require('./build').default.run(props);
+      case 'dev':
+        return require('./dev').default.run(props);
+      case 'launch':
+        return require('./launch').default.run(props);
+      case 'update':
+        return require('./update').default.run(props);
+      default: {
+        await getCommandHelp(props);
+        break;
+      }
+    }
+  },
+};

package/cli/commands/expo/install/cocoapods.rb

@@ -0,0 +1,35 @@
+class Cocoapods < Formula
+  desc "Dependency manager for Cocoa projects"
+  homepage "https://cocoapods.org/"
+  url "https://github.com/CocoaPods/CocoaPods/archive/refs/tags/1.14.3.tar.gz"
+  sha256 "de05766e5771e0cef7af89f73b0e42a1f1c52a76ce1288592cd9511bcd688a9e"
+  license "MIT"
+  revision 1
+
+  bottle do
+    sha256 cellar: :any,                 arm64_sonoma:   "0fb8e638fb4901b6c578c44ae1af0098a0b3530e7a339bf43f2fb67f2819d412"
+    sha256 cellar: :any,                 arm64_ventura:  "e3d0c8624df429cb30c5cf818f3a358d4f678b374410e9fbc8fde090889f9b61"
+    sha256 cellar: :any,                 arm64_monterey: "a6df519bae3f51b1609cfcd017b4d47cb688200780ffb9b27d57a5dc05ea93de"
+    sha256 cellar: :any,                 sonoma:         "5c2ee41824fcb154b46f9fa967f203fbf9009d2051f8c898375d69d333052988"
+    sha256 cellar: :any,                 ventura:        "91459cb108161201a81fdd0e96a126e9843be8213112c208051e8e72ce9736f9"
+    sha256 cellar: :any,                 monterey:       "316b0954e21f76c013d8c581c589e4f884231687eb2253a9f9a38a77a87728a6"
+    sha256 cellar: :any_skip_relocation, x86_64_linux:   "2d5be1290e8161d9a49b3fd191fc8423aac29f61fbc84148c8ba08cdc03d8d84"
+  end
+
+  depends_on "pkg-config" => :build
+  depends_on "ruby"
+  uses_from_macos "libffi", since: :catalina
+
+  def install
+    ENV["GEM_HOME"] = libexec
+    system "gem", "build", "cocoapods.gemspec"
+    system "gem", "install", "cocoapods-#{version}.gem"
+    # Other executables don't work currently.
+    bin.install libexec/"bin/pod", libexec/"bin/xcodeproj"
+    bin.env_script_all_files(libexec/"bin", GEM_HOME: ENV["GEM_HOME"])
+  end
+
+  test do
+    system "#{bin}/pod", "list"
+  end
+end

package/cli/commands/expo/launch.ts

@@ -0,0 +1,15 @@
+import { $ } from 'bun';
+import type { MobileProps } from './_setup';
+import { setup } from './_setup';
+
+export default {
+  name: 'launch',
+  description: '🚀 Launch',
+  run: async (props: MobileProps) => {
+    const { platform, output } = await setup({
+      props,
+    });
+
+    await $`eas build:run --platform ${platform} --path ${output.launchFile}`;
+  },
+};