fix: install Android tools only when a flow needs them

packages/platform-android/src/__tests__/environment.test.ts

@@ -1,24 +1,149 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import {
+  ensureAndroidAdbAvailable,
+  ensureAndroidEmulatorAvailable,
   getAndroidSdkRoot,
   getAndroidSystemImagePackage,
   getDefaultUnixAndroidSdkRoot,
   getHostAndroidSystemImageArch,
   getRequiredAndroidSdkPackages,
 } from '../environment.js';
+import * as tools from '@react-native-harness/tools';
 
 describe('Android environment', () => {
   beforeEach(() => {
     vi.restoreAllMocks();
     vi.unstubAllEnvs();
   });
 
+  it('skips bootstrapping command-line tools when adb is already installed', async () => {
+    const sdkRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'android-sdk-'));
+    const adbPath = path.join(sdkRoot, 'platform-tools', 'adb');
+
+    fs.mkdirSync(path.dirname(adbPath), { recursive: true });
+    fs.writeFileSync(adbPath, '');
+
+    const spawnSpy = vi.spyOn(tools, 'spawn');
+
+    await expect(
+      ensureAndroidAdbAvailable({
+        env: { ANDROID_HOME: sdkRoot },
+      }),
+    ).resolves.toBe(sdkRoot);
+
+    expect(spawnSpy).not.toHaveBeenCalled();
+
+    fs.rmSync(sdkRoot, { force: true, recursive: true });
+  });
+
+  it('installs only platform-tools when adb is missing', async () => {
+    const sdkRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'android-sdk-'));
+    const sdkManagerDirectory = path.join(
+      sdkRoot,
+      'cmdline-tools',
+      'latest',
+      'bin',
+    );
+
+    fs.mkdirSync(sdkManagerDirectory, { recursive: true });
+    fs.writeFileSync(path.join(sdkManagerDirectory, 'sdkmanager'), '');
+    fs.writeFileSync(path.join(sdkManagerDirectory, 'avdmanager'), '');
+
+    const spawnSpy = vi.spyOn(tools, 'spawn').mockImplementation((async (
+      command: string,
+      args?: readonly string[],
+    ) => {
+      if (command === 'bash' && typeof args?.[1] === 'string') {
+        const commandString = args[1];
+
+        if (commandString.includes('platform-tools')) {
+          const adbPath = path.join(sdkRoot, 'platform-tools', 'adb');
+          fs.mkdirSync(path.dirname(adbPath), { recursive: true });
+          fs.writeFileSync(adbPath, '');
+        }
+      }
+
+      return {} as Awaited<ReturnType<typeof tools.spawn>>;
+    }) as typeof tools.spawn);
+
+    await expect(
+      ensureAndroidAdbAvailable({
+        env: { ANDROID_HOME: sdkRoot },
+      }),
+    ).resolves.toBe(sdkRoot);
+
+    expect(spawnSpy).toHaveBeenCalledWith(
+      'bash',
+      ['-lc', expect.stringContaining('platform-tools')],
+      expect.any(Object),
+    );
+    expect(
+      spawnSpy.mock.calls.some(
+        ([command, args]) =>
+          command === 'bash' &&
+          typeof args?.[1] === 'string' &&
+          args[1].includes('platform-tools') &&
+          args[1].includes('emulator'),
+      ),
+    ).toBe(false);
+
+    fs.rmSync(sdkRoot, { force: true, recursive: true });
+  });
+
+  it('installs emulator only when emulator is missing', async () => {
+    const sdkRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'android-sdk-'));
+    const sdkManagerDirectory = path.join(
+      sdkRoot,
+      'cmdline-tools',
+      'latest',
+      'bin',
+    );
+
+    fs.mkdirSync(sdkManagerDirectory, { recursive: true });
+    fs.writeFileSync(path.join(sdkManagerDirectory, 'sdkmanager'), '');
+    fs.writeFileSync(path.join(sdkManagerDirectory, 'avdmanager'), '');
+
+    const spawnSpy = vi.spyOn(tools, 'spawn').mockImplementation((async (
+      command: string,
+      args?: readonly string[],
+    ) => {
+      if (command === 'bash' && typeof args?.[1] === 'string') {
+        const commandString = args[1];
+
+        if (commandString.includes('emulator')) {
+          const emulatorPath = path.join(sdkRoot, 'emulator', 'emulator');
+          fs.mkdirSync(path.dirname(emulatorPath), { recursive: true });
+          fs.writeFileSync(emulatorPath, '');
+        }
+      }
+
+      return {} as Awaited<ReturnType<typeof tools.spawn>>;
+    }) as typeof tools.spawn);
+
+    await expect(
+      ensureAndroidEmulatorAvailable({
+        env: { ANDROID_HOME: sdkRoot },
+      }),
+    ).resolves.toBe(sdkRoot);
+
+    expect(spawnSpy).toHaveBeenCalledWith(
+      'bash',
+      ['-lc', expect.stringContaining('emulator')],
+      expect.any(Object),
+    );
+
+    fs.rmSync(sdkRoot, { force: true, recursive: true });
+  });
+
   it('uses the default Unix SDK root when env vars are missing', () => {
     expect(
       getDefaultUnixAndroidSdkRoot({
         platform: 'darwin',
         homeDirectory: '/Users/tester',
-      })
+      }),
     ).toBe('/Users/tester/Library/Android/sdk');
 
     expect(
@@ -27,8 +152,8 @@ describe('Android environment', () => {
         {
           platform: 'linux',
           homeDirectory: '/home/tester',
-        }
-      )
+        },
+      ),
     ).toBe('/home/tester/Android/Sdk');
   });
 
@@ -42,8 +167,8 @@ describe('Android environment', () => {
         {
           platform: 'darwin',
           homeDirectory: '/Users/tester',
-        }
-      )
+        },
+      ),
     ).toBe('/env/android-home');
 
     expect(
@@ -54,19 +179,19 @@ describe('Android environment', () => {
         {
           platform: 'linux',
           homeDirectory: '/home/tester',
-        }
-      )
+        },
+      ),
     ).toBe('/env/android-sdk-root');
   });
 
   it('selects Android packages using the host architecture', () => {
     expect(getHostAndroidSystemImageArch('x64')).toBe('x86_64');
     expect(getHostAndroidSystemImageArch('arm64')).toBe('arm64-v8a');
     expect(getAndroidSystemImagePackage(35, 'x86_64')).toBe(
-      'system-images;android-35;default;x86_64'
+      'system-images;android-35;default;x86_64',
     );
     expect(getAndroidSystemImagePackage(35, 'arm64-v8a')).toBe(
-      'system-images;android-35;default;arm64-v8a'
+      'system-images;android-35;default;arm64-v8a',
     );
   });
 
@@ -76,7 +201,7 @@ describe('Android environment', () => {
         apiLevel: 34,
         includeEmulator: true,
         architecture: 'x86_64',
-      })
+      }),
     ).toEqual([
       'platform-tools',
       'emulator',