fire-pilot-rn 1.0.0

package/src/commands/login.ts

@@ -0,0 +1,119 @@
+import inquirer from 'inquirer';
+import { runLive, runSilent } from '../utils/runner';
+import { logger } from '../utils/logger';
+
+export async function loginCommand(): Promise<void> {
+  logger.title('Firebase Account Manager');
+
+  // ── Get current logged-in accounts ──────────────────────────
+  logger.step('Fetching logged-in Firebase accounts...');
+  const accountsRaw = runSilent('firebase', ['login:list']);
+
+  // Parse emails from output
+  const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+  const accounts: string[] = accountsRaw.match(emailRegex) ?? [];
+
+  if (accounts.length > 0) {
+    logger.info('Currently logged-in accounts:');
+    accounts.forEach((acc, i) => console.log(`   ${i + 1}. ${acc}`));
+  } else {
+    logger.warn('No accounts logged in yet.');
+  }
+
+  console.log('');
+
+  // ── Ask what the user wants to do (loop until cancel) ──────
+  let continueMenu = true;
+  let currentAccounts = accounts;
+
+  while (continueMenu) {
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What do you want to do?',
+        choices: [
+          { name: '🔑  Login with a new Google account', value: 'login' },
+          { name: '🔄  Switch to a different account',   value: 'switch' },
+          { name: '📋  List all logged-in accounts',     value: 'list' },
+          { name: '🚪  Logout from current account',     value: 'logout' },
+          { name: '⬅️   Continue to next step',           value: 'cancel' },
+        ],
+      },
+    ]);
+
+    if (action === 'cancel') {
+      continueMenu = false;
+    }
+
+    // ── Login ────────────────────────────────────────────────────
+    else if (action === 'login') {
+      logger.info('Opening browser to add a new Google account...');
+      runLive('firebase', ['login:add']);
+      logger.success('Account added!');
+      // Refresh account list after login
+      const refreshed = runSilent('firebase', ['login:list']);
+      currentAccounts = refreshed.match(emailRegex) ?? [];
+      if (currentAccounts.length > 0) {
+        logger.info('Logged-in accounts:');
+        currentAccounts.forEach((acc, i) => console.log(`   ${i + 1}. ${acc}`));
+        console.log('');
+      }
+    }
+
+    // ── Switch account ───────────────────────────────────────────
+    else if (action === 'switch') {
+      if (currentAccounts.length === 0) {
+        logger.error('No accounts found. Use "Login with a new Google account" to add one.');
+      } else if (currentAccounts.length === 1) {
+        logger.warn(`Only one account is registered: ${currentAccounts[0]}`);
+        logger.info('Use "🔑  Login with a new Google account" to add more accounts first.');
+        console.log('');
+      } else {
+        const { selectedAccount } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'selectedAccount',
+            message: 'Select the account to switch to:',
+            choices: currentAccounts,
+          },
+        ]);
+        runLive('firebase', ['login:use', selectedAccount]);
+        logger.success(`Switched to: ${selectedAccount}`);
+      }
+    }
+
+    // ── List accounts ─────────────────────────────────────────────
+    else if (action === 'list') {
+      const refreshed = runSilent('firebase', ['login:list']);
+      currentAccounts = refreshed.match(emailRegex) ?? [];
+      if (currentAccounts.length > 0) {
+        logger.info('All logged-in accounts:');
+        currentAccounts.forEach((acc, i) => console.log(`   ${i + 1}. ${acc}`));
+      } else {
+        logger.warn('No accounts are currently logged in.');
+      }
+      console.log('');
+    }
+
+    // ── Logout ───────────────────────────────────────────────────
+    else if (action === 'logout') {
+      const { confirmLogout } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirmLogout',
+          message: 'Are you sure you want to logout?',
+          default: false,
+        },
+      ]);
+
+      if (confirmLogout) {
+        runLive('firebase', ['logout']);
+        logger.success('Logged out successfully!');
+        // Refresh after logout
+        const refreshed = runSilent('firebase', ['login:list']);
+        currentAccounts = refreshed.match(emailRegex) ?? [];
+      }
+    }
+  }
+}

package/src/commands/setup.ts

@@ -0,0 +1,313 @@
+import { existsSync, mkdirSync, readdirSync } from 'fs';
+import * as path from 'path';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { checkAllTools } from '../utils/checker';
+import { loginCommand } from './login';
+import { shaCommand } from './sha';
+import { enableCommand } from './enable';
+import { runCheckedOutput, runLive } from '../utils/runner';
+import { logger } from '../utils/logger';
+
+type FirebaseProject = {
+  projectId: string;
+  displayName: string;
+};
+
+type FirebaseApp = {
+  appId: string;
+  displayName?: string;
+  packageName?: string;
+  bundleId?: string;
+};
+
+type AppSetupAnswers = {
+  platforms: Array<'ANDROID' | 'IOS'>;
+  appDisplayName: string;
+  androidPackageName?: string;
+  iosBundleId?: string;
+};
+
+function parseFirebaseResult<T>(output: string, label: string): T {
+  try {
+    const parsed = JSON.parse(output) as { result?: T };
+
+    if (parsed.result === undefined) {
+      throw new Error('Missing result field');
+    }
+
+    return parsed.result;
+  } catch {
+    throw new Error(`Could not parse Firebase ${label} output.`);
+  }
+}
+
+function getAndroidConfigPath(cwd: string): string {
+  const androidAppDir = path.join(cwd, 'android', 'app');
+  return existsSync(androidAppDir)
+    ? path.join(androidAppDir, 'google-services.json')
+    : path.join(cwd, 'google-services.json');
+}
+
+function getIosConfigPath(cwd: string): string {
+  const iosDir = path.join(cwd, 'ios');
+
+  if (!existsSync(iosDir)) {
+    return path.join(cwd, 'GoogleService-Info.plist');
+  }
+
+  const xcodeProject = readdirSync(iosDir).find((entry) => entry.endsWith('.xcodeproj'));
+
+  if (xcodeProject) {
+    const appDir = path.join(iosDir, path.basename(xcodeProject, '.xcodeproj'));
+
+    if (existsSync(appDir)) {
+      return path.join(appDir, 'GoogleService-Info.plist');
+    }
+  }
+
+  return path.join(iosDir, 'GoogleService-Info.plist');
+}
+
+function validateMobileIdentifier(value: string): true | string {
+  return /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)+$/.test(value.trim())
+    ? true
+    : 'Enter a valid identifier like com.example.app';
+}
+
+function listFirebaseProjects(): FirebaseProject[] {
+  const output = runCheckedOutput('firebase', ['projects:list', '--json']);
+  return parseFirebaseResult<FirebaseProject[]>(output, 'project list');
+}
+
+function listFirebaseApps(platform: 'ANDROID' | 'IOS', projectId: string): FirebaseApp[] {
+  const output = runCheckedOutput('firebase', ['apps:list', platform, '--project', projectId, '--json']);
+  return parseFirebaseResult<FirebaseApp[]>(output, `${platform} app list`);
+}
+
+function ensureFirebaseApp(
+  platform: 'ANDROID' | 'IOS',
+  projectId: string,
+  displayName: string,
+  identifier: string,
+): FirebaseApp {
+  const existingApps = listFirebaseApps(platform, projectId);
+  const match = existingApps.find((app) =>
+    platform === 'ANDROID' ? app.packageName === identifier : app.bundleId === identifier,
+  );
+
+  if (match) {
+    logger.success(`${platform} app already exists: ${match.appId}`);
+    return match;
+  }
+
+  logger.step(`Creating Firebase ${platform} app...`);
+  const identifierFlag = platform === 'ANDROID' ? '--package-name' : '--bundle-id';
+  const output = runCheckedOutput('firebase', [
+    'apps:create',
+    platform,
+    displayName,
+    identifierFlag,
+    identifier,
+    '--project',
+    projectId,
+    '--json',
+  ]);
+
+  return parseFirebaseResult<FirebaseApp>(output, `${platform} app creation`);
+}
+
+function exportFirebaseConfig(platform: 'ANDROID' | 'IOS', appId: string, outputPath: string): void {
+  mkdirSync(path.dirname(outputPath), { recursive: true });
+  logger.step(`Writing ${path.basename(outputPath)}...`);
+  runLive('firebase', ['apps:sdkconfig', platform, appId, '-o', outputPath]);
+  logger.success(`Saved ${platform} config to ${outputPath}`);
+}
+
+export async function setupCommand(full: boolean): Promise<void> {
+  logger.title('FirePilot RN — Firebase Setup Wizard');
+  console.log('This wizard will set up Firebase for your React Native project.\n');
+
+  // ── STEP 1: Check & install all tools ───────────────────────
+  await checkAllTools();
+
+  // ── STEP 2: Firebase login ───────────────────────────────────
+  logger.step('STEP 2 — Firebase Login');
+  const { doLogin } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'doLogin',
+    message: 'Do you want to manage your Firebase login now?',
+    default: true,
+  }]);
+  if (doLogin) await loginCommand();
+
+  // ── STEP 3: Create or select Firebase project ────────────────
+  logger.step('STEP 3 — Firebase Project');
+  logger.info('Fetching your existing Firebase projects...');
+  const existingProjects = listFirebaseProjects();
+
+  const { projectAction } = await inquirer.prompt([{
+    type: 'list',
+    name: 'projectAction',
+    message: 'What do you want to do?',
+    choices: [
+      { name: '➕  Create a new Firebase project', value: 'create' },
+      { name: '✅  Use an existing project',        value: 'existing' },
+    ],
+  }]);
+
+  let projectId = '';
+
+  if (projectAction === 'create') {
+    const { newProjectId } = await inquirer.prompt([{
+      type: 'input',
+      name: 'newProjectId',
+      message: 'Enter new Firebase project ID:',
+      validate: (val: string) =>
+        val.trim().length > 0 ? true : 'Project ID cannot be empty',
+    }]);
+    projectId = newProjectId.trim();
+
+    const spinner = ora(`Creating Firebase project: ${projectId}...`).start();
+    try {
+      runLive('firebase', ['projects:create', projectId]);
+      spinner.succeed(`Project "${projectId}" created!`);
+    } catch (e: any) {
+      spinner.fail('Project creation failed!');
+      // ── Real-Time Diagnostics (like fire_pilot) ──────────────
+      if (e.message.includes('quota')) {
+        logger.error('REASON: Firebase project quota exceeded.');
+        logger.info('Fix: Delete old projects at https://console.firebase.google.com');
+      } else if (e.message.includes('already exists')) {
+        logger.error('REASON: A project with this ID already exists.');
+        logger.info('Fix: Choose a different project ID.');
+      } else {
+        logger.error('REASON: ' + e.message);
+      }
+      process.exit(1);
+    }
+  } else {
+    if (existingProjects.length === 0) {
+      logger.error('No Firebase projects found for the current account.');
+      process.exit(1);
+    }
+
+    const { existingId } = await inquirer.prompt([{
+      type: 'list',
+      name: 'existingId',
+      message: 'Select the Firebase project to use:',
+      choices: existingProjects.map((project) => ({
+        name: `${project.displayName} (${project.projectId})`,
+        value: project.projectId,
+      })),
+    }]);
+    projectId = existingId;
+  }
+
+  // ── STEP 4: Install @react-native-firebase/app ───────────────
+  logger.step('STEP 4 — Install React Native Firebase Core');
+  const spinner2 = ora('Installing @react-native-firebase/app...').start();
+  try {
+    runLive('npm', ['install', '@react-native-firebase/app']);
+    spinner2.succeed('@react-native-firebase/app installed!');
+  } catch {
+    spinner2.fail('Installation failed. Run manually: npm install @react-native-firebase/app');
+  }
+
+  // ── STEP 5: Create apps and download config files ───────────
+  logger.step('STEP 5 — Firebase App Setup');
+  const defaultDisplayName = path.basename(process.cwd());
+  const { platforms, appDisplayName, androidPackageName, iosBundleId } = await inquirer.prompt<AppSetupAnswers>([
+    {
+      type: 'checkbox',
+      name: 'platforms',
+      message: 'Create or configure Firebase apps for:',
+      choices: [
+        { name: 'Android', value: 'ANDROID', checked: true },
+        { name: 'iOS', value: 'IOS', checked: true },
+      ],
+      validate: (selected: string[]) =>
+        selected.length > 0 ? true : 'Select at least one platform',
+    },
+    {
+      type: 'input',
+      name: 'appDisplayName',
+      message: 'Enter the Firebase app display name:',
+      default: defaultDisplayName,
+      validate: (value: string) => value.trim().length > 0 ? true : 'Display name cannot be empty',
+    },
+    {
+      type: 'input',
+      name: 'androidPackageName',
+      message: 'Enter the Android package name:',
+      when: (answers: { platforms: string[] }) => answers.platforms.includes('ANDROID'),
+      validate: validateMobileIdentifier,
+    },
+    {
+      type: 'input',
+      name: 'iosBundleId',
+      message: 'Enter the iOS bundle identifier:',
+      when: (answers: { platforms: string[] }) => answers.platforms.includes('IOS'),
+      validate: validateMobileIdentifier,
+    },
+  ]);
+
+  let androidAppId: string | undefined;
+
+  if (platforms.includes('ANDROID')) {
+    if (!androidPackageName) {
+      logger.error('Android package name is required to create or configure the Android app.');
+      process.exit(1);
+    }
+
+    const androidApp = ensureFirebaseApp('ANDROID', projectId, appDisplayName.trim(), androidPackageName.trim());
+    androidAppId = androidApp.appId;
+    exportFirebaseConfig('ANDROID', androidAppId, getAndroidConfigPath(process.cwd()));
+  }
+
+  if (platforms.includes('IOS')) {
+    if (!iosBundleId) {
+      logger.error('iOS bundle identifier is required to create or configure the iOS app.');
+      process.exit(1);
+    }
+
+    const iosApp = ensureFirebaseApp('IOS', projectId, appDisplayName.trim(), iosBundleId.trim());
+    exportFirebaseConfig('IOS', iosApp.appId, getIosConfigPath(process.cwd()));
+  }
+
+  // ── STEP 6: SHA keys (only if --full) ───────────────────────
+  if (full) {
+    logger.step('STEP 6 — SHA Key Registration');
+    const { doSha } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'doSha',
+      message: 'Do you want to register Android SHA keys now?',
+      default: true,
+    }]);
+    if (doSha && androidAppId) {
+      await shaCommand({ projectId, appId: androidAppId });
+    } else if (doSha) {
+      logger.warn('Skipping SHA registration because no Android app was configured in this run.');
+    }
+  }
+
+  // ── STEP 7: Enable Firebase features ────────────────────────
+  logger.step('STEP 7 — Enable Firebase Features');
+  const { doFeatures } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'doFeatures',
+    message: 'Do you want to install additional Firebase features (Auth, Firestore, etc)?',
+    default: true,
+  }]);
+  if (doFeatures) await enableCommand();
+
+  // ── DONE ─────────────────────────────────────────────────────
+  console.log('\n' + '─'.repeat(60));
+  logger.success('🎉 Firebase setup complete for your React Native project!');
+  console.log('─'.repeat(60));
+  logger.info('Next steps:');
+  console.log('   1. Verify google-services.json and GoogleService-Info.plist were written to your project');
+  console.log('   2. Follow platform setup at https://rnfirebase.io');
+  console.log('   3. Run your app: npx react-native run-android');
+  console.log('─'.repeat(60) + '\n');
+} 

package/src/commands/sha.ts

@@ -0,0 +1,177 @@
+import * as os from 'os';
+import * as path from 'path';
+import inquirer from 'inquirer';
+import { runLive, runSilent, resolveJavaTool } from '../utils/runner';
+import { logger } from '../utils/logger';
+
+type FirebaseProject = {
+  projectId: string;
+  projectNumber: string;
+  displayName: string;
+};
+
+type FirebaseAndroidApp = {
+  appId: string;
+  displayName?: string;
+  packageName?: string;
+};
+
+function parseFirebaseJson<T>(output: string, label: string): T[] {
+  try {
+    const parsed = JSON.parse(output) as { result?: T[] };
+    return parsed.result ?? [];
+  } catch {
+    logger.error(`Could not parse Firebase ${label} output.`);
+    process.exit(1);
+  }
+}
+
+type ShaCommandOptions = {
+  projectId?: string;
+  appId?: string;
+};
+
+type ProjectPromptAnswer = {
+  projectId: string;
+};
+
+type AndroidAppPromptAnswer = {
+  appId: string;
+};
+
+export async function shaCommand(options: ShaCommandOptions = {}): Promise<void> {
+  logger.title('SHA Key Registration');
+
+  // ── Check keytool exists ─────────────────────────────────────
+  const keytoolPath = resolveJavaTool('keytool');
+
+  if (!keytoolPath) {
+    logger.error('Java keytool not found!');
+    logger.info('Install Java from: https://adoptium.net');
+    process.exit(1);
+  }
+
+  // ── Find the Android debug keystore ─────────────────────────
+  const keystorePath = path.join(os.homedir(), '.android', 'debug.keystore');
+  logger.info(`Looking for keystore at: ${keystorePath}`);
+
+  // ── Extract SHA keys ─────────────────────────────────────────
+  logger.step('Extracting SHA-1 and SHA-256 from debug keystore...');
+  const output = runSilent(keytoolPath, [
+    '-list', '-v',
+    '-keystore', keystorePath,
+    '-alias',   'androiddebugkey',
+    '-storepass', 'android',
+    '-keypass',   'android',
+  ]);
+
+  if (!output) {
+    logger.error('Could not read keystore. Make sure you have run your React Native Android app at least once.');
+    process.exit(1);
+  }
+
+  // ── Parse SHA-1 and SHA-256 ──────────────────────────────────
+  const sha1Match   = output.match(/SHA1:\s+([A-F0-9:]+)/i);
+  const sha256Match = output.match(/SHA256:\s+([A-F0-9:]+)/i);
+
+  if (!sha1Match || !sha256Match) {
+    logger.error('SHA keys not found in keystore output.');
+    process.exit(1);
+  }
+
+  const sha1   = sha1Match[1].trim();
+  const sha256 = sha256Match[1].trim();
+
+  logger.success(`SHA-1:   ${sha1}`);
+  logger.success(`SHA-256: ${sha256}`);
+
+  let projectId = options.projectId;
+
+  if (!projectId) {
+    logger.step('Fetching your Firebase projects...');
+    const projectOutput = runSilent('firebase', ['projects:list', '--json']);
+    const projects = parseFirebaseJson<FirebaseProject>(projectOutput, 'project list');
+
+    if (projects.length === 0) {
+      logger.error('No Firebase projects found for the current account.');
+      process.exit(1);
+    }
+
+    const projectAnswer = await inquirer.prompt<ProjectPromptAnswer>([
+      {
+        type: 'list',
+        name: 'projectId',
+        message: 'Select your Firebase project:',
+        choices: projects.map((project) => ({
+          name: `${project.displayName} (${project.projectId})`,
+          value: project.projectId,
+        })),
+      },
+    ]);
+
+    projectId = projectAnswer.projectId;
+  }
+
+  if (!projectId) {
+    logger.error('Firebase project selection failed.');
+    process.exit(1);
+  }
+
+  const selectedProjectId = projectId;
+
+  // ── Show Android apps for the chosen project ─────────────────
+  let appId = options.appId;
+
+  if (!appId) {
+    logger.step('Fetching Android apps for the selected Firebase project...');
+    const appsOutput = runSilent('firebase', ['apps:list', 'ANDROID', '--project', selectedProjectId, '--json']);
+    const androidApps = parseFirebaseJson<FirebaseAndroidApp>(appsOutput, 'Android app list');
+
+    if (androidApps.length === 0) {
+      logger.error(`No Android apps found in Firebase project ${selectedProjectId}.`);
+      logger.info('Create an Android app in Firebase Console first, then rerun this command.');
+      process.exit(1);
+    }
+
+    const appAnswer = await inquirer.prompt<AndroidAppPromptAnswer>([
+      {
+        type: 'list',
+        name: 'appId',
+        message: 'Select your Firebase Android app:',
+        choices: androidApps.map((app) => ({
+          name: `${app.displayName || 'Unnamed Android App'}${app.packageName ? ` (${app.packageName})` : ''} [${app.appId}]`,
+          value: app.appId,
+        })),
+      },
+    ]);
+
+    appId = appAnswer.appId;
+  }
+
+  if (!appId) {
+    logger.error('Firebase Android app selection failed.');
+    process.exit(1);
+  }
+
+  const selectedAppId = appId;
+
+  // ── Register SHA keys ────────────────────────────────────────
+  logger.step('Registering SHA-1 key with Firebase...');
+  runLive('firebase', [
+    'apps:android:sha:create',
+    '--project', selectedProjectId,
+    selectedAppId,
+    sha1,
+  ]);
+
+  logger.step('Registering SHA-256 key with Firebase...');
+  runLive('firebase', [
+    'apps:android:sha:create',
+    '--project', selectedProjectId,
+    selectedAppId,
+    sha256,
+  ]);
+
+  logger.success('Both SHA keys registered successfully!');
+  logger.info('Go to Firebase Console → Project Settings → Your Android App to verify.');
+}

package/src/index.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { setupCommand }  from './commands/setup';
+import { loginCommand }  from './commands/login';
+import { shaCommand }    from './commands/sha';
+import { enableCommand } from './commands/enable';
+
+const program = new Command();
+
+program
+  .name('fire-pilot-rn')
+  .description('🔥 Elite Firebase setup orchestrator for React Native')
+  .version('1.0.0');
+
+// ── Parent command: firebase ─────────────────────────────────
+const firebase = program.command('firebase');
+
+// firebase setup --full
+firebase
+  .command('setup')
+  .description('The complete Pilot experience: Tools → Login → Project → Deps → SHA')
+  .option('--full', 'Run the complete setup including SHA key registration')
+  .action((options) => {
+    setupCommand(options.full ?? false).catch((err) => {
+      console.error('Error:', err.message);
+      process.exit(1);
+    });
+  });
+
+// firebase login
+firebase
+  .command('login')
+  .description('Manage and switch between multiple Google accounts')
+  .action(() => {
+    loginCommand().catch((err) => {
+      console.error('Error:', err.message);
+      process.exit(1);
+    });
+  });
+
+// firebase sha add
+firebase
+  .command('sha')
+  .command('add')
+  .description('Automatically extract and add SHA keys to your Firebase project')
+  .action(() => {
+    shaCommand().catch((err) => {
+      console.error('Error:', err.message);
+      process.exit(1);
+    });
+  });
+
+// firebase enable <feature>
+firebase
+  .command('enable [feature]')
+  .description('Quickly enable Firebase features (auth, firestore, storage, etc.)')
+  .action((feature?: string) => {
+    enableCommand(feature).catch((err) => {
+      console.error('Error:', err.message);
+      process.exit(1);
+    });
+  });
+
+program.parse(process.argv);