feat: remote (and local) build caching

CONTRIBUTING.md

@@ -93,6 +93,8 @@ NPM_CONFIG_REGISTRY=http://localhost:4873 pnpm create @rnef/app --registry http:
 # Then use pnpm install with registry
 echo "node-linker=hoisted" > .npmrc
 NPM_CONFIG_REGISTRY=http://localhost:4873 pnpm install
+# Then link packages (see above)
+pnpm link --global ... 
 
 # Clean up
 pnpm verdaccio-reset

eslint.config.js

@@ -29,7 +29,7 @@ export default [
     rules: {},
   },
   {
-    ignores: ['**/template/**/*.mjs'],
+    ignores: ['**/template/**/*.mjs', '**/dist/**'],
   },
   {
     files: ['**/*.json'],

packages/cli/src/lib/commands/fingerprint.ts

@@ -1,10 +1,6 @@
 import { performance } from 'perf_hooks';
 import { outro, spinner } from '@clack/prompts';
-import {
-  logger,
-  nativeFingerprint,
-  resolveAbsolutePath,
-} from '@rnef/tools';
+import { logger, nativeFingerprint } from '@rnef/tools';
 
 type NativeFingerprintCommandOptions = {
   platform: 'ios' | 'android';
@@ -16,14 +12,13 @@ export async function nativeFingerprintCommand(
 ) {
   path = path ?? '.';
   const platform = options?.platform ?? 'ios';
-  const loader = spinner();
-  logger.debug(`Fingerprinting "${resolveAbsolutePath(path)}"...`);
 
   let start = 0;
   if (logger.isVerbose()) {
     start = performance.now();
   }
 
+  const loader = spinner();
   loader.start("Calculating fingerprint for the project's native parts");
   const fingerprint = await nativeFingerprint(path, { platform });
 
@@ -33,6 +28,7 @@ export async function nativeFingerprintCommand(
     logger.debug('Sources:', JSON.stringify(fingerprint.sources, null, 2));
     logger.debug(`Duration: ${(duration / 1000).toFixed(1)}s`);
   }
+
   loader.stop(`Fingerprint calculated: ${fingerprint.hash}`);
   outro('Success 🎉.');
 }

packages/plugin-platform-android/src/lib/commands/listAndroidTasks.ts

@@ -59,7 +59,7 @@ export const promptForTaskSelection = async (
 ): Promise<string> => {
   const tasks = await getGradleTasks(taskType, sourceDir);
   if (!tasks.length) {
-    throw new Error(`No actionable ${taskType} tasks were found...`);
+    throw new Error(`No actionable ${taskType} tasks were found`);
   }
   const task = checkCancelPrompt<string>(
     await select({

packages/plugin-platform-android/src/lib/commands/runAndroid/__tests__/runAndroid.test.ts

@@ -1,10 +1,10 @@
 import fs, { PathLike } from 'node:fs';
 import { vi, test, Mock } from 'vitest';
+import { logger } from '@rnef/tools';
 import { AndroidProjectConfig } from '@react-native-community/cli-types';
 import { select } from '@clack/prompts';
 import spawn from 'nano-spawn';
 import { runAndroid, type Flags } from '../runAndroid.js';
-import { logger } from '@rnef/tools';
 
 const actualFs = await vi.importMock('node:fs');
 
@@ -35,6 +35,9 @@ vi.mock('@clack/prompts', () => {
     isCancel: vi.fn(() => false),
     intro: vi.fn(),
     outro: mocks.outroMock,
+    log: {
+      warn: vi.fn(),
+    },
   };
 });
 
@@ -48,6 +51,7 @@ const args: Flags = {
   appIdSuffix: '',
   mainActivity: undefined,
   port: '8081',
+  remoteBuildCache: false,
 };
 const androidProject: AndroidProjectConfig = {
   appName: 'app',

packages/plugin-platform-android/src/lib/commands/runAndroid/fetchCachedBuild.ts

@@ -0,0 +1,91 @@
+import {
+  LocalBuild,
+  createRemoteBuildCache,
+  findFilesWithPattern,
+  formatArtifactName,
+  getProjectRoot,
+  nativeFingerprint,
+  queryLocalBuildCache,
+} from '@rnef/tools';
+import { spinner } from '@clack/prompts';
+import path from 'node:path';
+import color from 'picocolors';
+
+export type FetchCachedBuildOptions = {
+  mode: string;
+};
+
+export async function fetchCachedBuild({
+  mode,
+}: FetchCachedBuildOptions): Promise<LocalBuild | null> {
+  const loader = spinner();
+  loader.start('Looking for a local cached build');
+
+  const root = getProjectRoot();
+  const artifactName = await calculateArtifactName(mode);
+
+  const localBuild = queryLocalBuildCache(artifactName, { findBinary });
+  if (localBuild != null) {
+    loader.stop(
+      `Found local cached build: ${color.cyan(
+        path.relative(root, localBuild.binaryPath)
+      )}`
+    );
+    return localBuild;
+  }
+
+  const remoteBuildCache = createRemoteBuildCache();
+  if (!remoteBuildCache) {
+    loader.stop(`No CI provider detected, skipping.`);
+    return null;
+  }
+
+  loader.message(`Looking for a cached build on ${remoteBuildCache.name}`);
+  const remoteBuild = await remoteBuildCache.query(artifactName);
+  if (!remoteBuild) {
+    loader.stop(`No cached build found for "${artifactName}".`);
+    return null;
+  }
+
+  loader.message(`Downloading cached build from ${remoteBuildCache.name}`);
+  const fetchedBuild = await remoteBuildCache.fetch(remoteBuild);
+  const binaryPath = findBinary(fetchedBuild.path);
+  if (!binaryPath) {
+    loader.stop(`No binary found in "${artifactName}".`);
+    return null;
+  }
+
+  loader.stop(
+    `Downloaded cached build: ${color.cyan(path.relative(root, binaryPath))}.`
+  );
+
+  return {
+    name: fetchedBuild.name,
+    artifactPath: fetchedBuild.path,
+    binaryPath,
+  };
+}
+
+async function calculateArtifactName(mode: string) {
+  const root = getProjectRoot();
+  const fingerprint = await nativeFingerprint(root, { platform: 'android' });
+  return formatArtifactName({
+    platform: 'android',
+    mode,
+    hash: fingerprint.hash,
+  });
+}
+
+function findBinary(path: string): string | null {
+  const apks = findFilesWithPattern(path, /\.apk$/);
+  if (apks.length > 0) {
+    return apks[0];
+  }
+
+  const aabs = findFilesWithPattern(path, /\.aab$/);
+  if (aabs.length > 0) {
+    return aabs[0];
+  }
+
+  return null;
+}

packages/plugin-platform-android/src/lib/commands/runAndroid/runAndroid.ts

@@ -1,21 +1,22 @@
-import fs from 'fs';
+import fs from 'node:fs';
 import {
   AndroidProjectConfig,
   Config,
 } from '@react-native-community/cli-types';
 import { checkCancelPrompt, logger } from '@rnef/tools';
+import { intro, outro, select } from '@clack/prompts';
+import isInteractive from 'is-interactive';
 import { getDevices } from './adb.js';
 import { toPascalCase } from '../toPascalCase.js';
 import { tryLaunchAppOnDevice } from './tryLaunchAppOnDevice.js';
 import { tryInstallAppOnDevice } from './tryInstallAppOnDevice.js';
 import { listAndroidDevices, DeviceData } from './listAndroidDevices.js';
 import { tryLaunchEmulator } from './tryLaunchEmulator.js';
-import path from 'path';
+import path from 'node:path';
 import { BuildFlags, options } from '../buildAndroid/buildAndroid.js';
 import { promptForTaskSelection } from '../listAndroidTasks.js';
 import { runGradle } from '../runGradle.js';
-import { outro, select } from '@clack/prompts';
-import isInteractive from 'is-interactive';
+import { fetchCachedBuild } from './fetchCachedBuild.js';
 
 export interface Flags extends BuildFlags {
   appId: string;
@@ -25,6 +26,7 @@ export interface Flags extends BuildFlags {
   device?: string;
   binaryPath?: string;
   user?: string;
+  remoteBuildCache: boolean;
 }
 
 export type AndroidProject = NonNullable<Config['project']['android']>;
@@ -37,6 +39,8 @@ export async function runAndroid(
   args: Flags,
   projectRoot: string
 ) {
+  intro('Running Android app');
+
   normalizeArgs(args, projectRoot);
 
   const { deviceId } = args.interactive
@@ -48,6 +52,14 @@ export async function runAndroid(
     ? [await promptForTaskSelection(mainTaskType, androidProject.sourceDir)]
     : [...(args.tasks ?? []), `${mainTaskType}${toPascalCase(args.mode)}`];
 
+  if (!args.binaryPath && args.remoteBuildCache) {
+    const cachedBuild = await fetchCachedBuild({ mode: args.mode });
+    if (cachedBuild) {
+      // @todo replace with a more generic way to pass binary path
+      args.binaryPath = cachedBuild.binaryPath;
+    }
+  }
+
   if (deviceId) {
     await runGradle({ tasks, androidProject, args });
     if (!(await getDevices()).find((d) => d === deviceId)) {
@@ -64,7 +76,7 @@ export async function runAndroid(
         await selectAndLaunchDevice();
       } else {
         logger.debug(
-          'No booted devices or emulators found. Launching first available mulator...'
+          'No booted devices or emulators found. Launching first available emulator...'
         );
         await tryLaunchEmulator();
       }
@@ -73,6 +85,9 @@ export async function runAndroid(
     await runGradle({ tasks, androidProject, args });
 
     for (const device of await getDevices()) {
+      if (args.binaryPath) {
+        await tryInstallAppOnDevice(device, androidProject, args, tasks);
+      }
       await tryLaunchAppOnDevice(device, androidProject, args);
     }
   }
@@ -195,4 +210,8 @@ export const runOptions = [
     name: '--user <number>',
     description: 'Id of the User Profile you want to install the app on.',
   },
+  {
+    name: '--no-remote-build-cache',
+    description: 'Do not use remote build cacheing.',
+  },
 ];

packages/plugin-platform-android/src/lib/commands/runAndroid/tryInstallAppOnDevice.ts

@@ -37,7 +37,7 @@ export async function tryInstallAppOnDevice(
 
   const adbPath = getAdbPath();
   const loader = spinner();
-  loader.start(`Installing the app on "${device}"...`);
+  loader.start(`Installing the app on "${device}"`);
   const { stderr } = await spawn(adbPath, adbArgs, {
     stdio: ['ignore', 'ignore', 'pipe'],
   });

packages/plugin-platform-android/src/lib/commands/runAndroid/tryLaunchAppOnDevice.ts

@@ -46,7 +46,7 @@ export async function tryLaunchAppOnDevice(
   const adbPath = getAdbPath();
   logger.debug(`Running ${adbPath} ${adbArgs.join(' ')}.`);
   const loader = spinner();
-  loader.start(`Installing the app on "${device}"...`);
+  loader.start(`Installing the app on "${device}"`);
   const { stderr } = await spawn(adbPath, adbArgs, {
     stdio: ['ignore', 'ignore', 'pipe'],
   });

packages/plugin-platform-android/src/lib/commands/runGradle.ts

@@ -5,15 +5,17 @@ import spawn from 'nano-spawn';
 import type { BuildFlags } from './buildAndroid/buildAndroid.js';
 import { spinner } from '@clack/prompts';
 
+export type RunGradleArgs = {
+  tasks: string[];
+  androidProject: AndroidProject;
+  args: BuildFlags | Flags;
+};
+
 export async function runGradle({
   tasks,
   androidProject,
   args,
-}: {
-  tasks: string[];
-  androidProject: AndroidProject;
-  args: BuildFlags | Flags;
-}) {
+}: RunGradleArgs) {
   if ('binaryPath' in args) {
     return;
   }

packages/plugin-platform-android/template/.github/actions/rnef-remote-build-android/action.yml

@@ -13,14 +13,10 @@ inputs:
     description: "Path to the build output artifact"
     required: false
     default: "android/app/build/outputs/apk/debug/app-debug.apk"
-  artifact-name-prefix:
-    description: "Prefix for the artifact name"
+  mode:
+    description: "Build mode"
     required: false
-    default: "app-debug"
-  artifact-name-extension:
-    description: "File extension for the artifact name"
-    required: false
-    default: "apk"
+    default: "debug"
 
 outputs:
   artifact-url:
@@ -34,13 +30,18 @@ runs:
       id: fingerprint
       uses: ./.github/actions/rnef-native-fingerprint
       with:
-        platforms: android
+        platform: android
+
+    - name: Set artifact name
+      run: |
+        echo "ARTIFACT_NAME=rnef-android-${{ inputs.mode }}-${{ steps.fingerprint.outputs.hash}}" >> $GITHUB_ENV
+      shell: bash
 
     - name: Find artifact URL
       id: cached-url
       uses: ./.github/actions/find-artifact
       with:
-        name: ${{inputs.artifact-name-prefix}}-${{ steps.fingerprint.outputs.hash}}.${{inputs.artifact-name-extension}}
+        name: ${{ env.ARTIFACT_NAME }}
 
     - name: Post Cached Build (if found)
       if: ${{ steps.cached-url.outputs.artifact-url && github.event_name == 'pull_request' }}
@@ -68,12 +69,12 @@ runs:
         npx rnef build:android --tasks assembleDebug
       shell: bash
 
-    - name: Upload APK
+    - name: Upload Artifact
       id: upload-artifact
       if: ${{ !steps.cached-url.outputs.artifact-url }}
       uses: actions/upload-artifact@v4
       with:
-        name: ${{inputs.artifact-name-prefix}}-${{ steps.fingerprint.outputs.hash}}.${{inputs.artifact-name-extension}}
+        name: ${{ env.ARTIFACT_NAME }}
         path: ${{ inputs.artifact-output-path }}
         if-no-files-found: error
 

packages/plugin-platform-apple/package.json

@@ -24,6 +24,7 @@
     "is-interactive": "^2.0.0",
     "nano-spawn": "^0.2.0",
     "picocolors": "^1.1.1",
+    "tar": "^7.4.3",
     "tslib": "^2.3.0"
   },
   "devDependencies": {

packages/plugin-platform-apple/src/lib/commands/run/createRun.ts

@@ -17,7 +17,7 @@ import {
 } from '../../types/index.js';
 import { RunFlags } from './runOptions.js';
 import { selectFromInteractiveMode } from '../../utils/selectFromInteractiveMode.js';
-import { outro, spinner } from '@clack/prompts';
+import { intro, outro, spinner } from '@clack/prompts';
 import { runOnMac } from './runOnMac.js';
 import { runOnMacCatalyst } from './runOnMacCatalyst.js';
 import { cacheRecentDevice } from './recentDevices.js';
@@ -28,6 +28,8 @@ export const createRun = async (
   args: RunFlags,
   projectRoot: string
 ) => {
+  intro('Running on iOS');
+
   const { readableName: platformReadableName } = getPlatformInfo(platformName);
   const { xcodeProject, sourceDir } = projectConfig;