fix(schematics): read the signed-in account on firebase-tools 15.26+ (#3769)

firebase-tools 15.26 runs non-interactively when it detects an AI
agent or when stdin is not a terminal, and in that mode login()
returns undefined instead of the signed-in account. `ng add` and
`ng deploy` crashed reading `.email` from it.

getActiveAccount passes `interactive: true`, which returns the account
without a prompt once one is signed in. The `firebase login` and
`firebase login:add` commands setup starts get `--interactive` for the
same reason. Setup no longer passes its options to login(), since they
carry the Angular project name, which firebase-tools rejects as a
project id for names like `myApp`.

The Quickstart stops telling readers to install firebase-tools 14, and
says what a stopped run leaves behind.

Fixes #3768

The Quickstart changes are left out, since docs are not backported.
(cherry picked from commit 38dfc3f)

Author: armando-navarro

src/schematics/deploy/actions.jasmine.ts

@@ -115,15 +115,46 @@ const initMocks = () => {
 describe('Deploy Angular apps', () => {
   beforeEach(() => initMocks());
 
+  /** Spies on `login()` and keeps a `login.list()`, which `spyOn` would otherwise drop. */
+  const spyOnLogin = (accounts: { user: Record<string, any> }[]) =>
+    Object.assign(spyOn(firebaseMock, 'login'), { list: () => Promise.resolve(accounts), add: login.add, use: login.use });
+
+  const signedIn = [{ user: { email: 'foo@bar.baz' } }];
+
   it('should call login', async () => {
-    const spy = spyOn(firebaseMock, 'login').and.resolveTo({ email: 'foo@bar.baz' });
+    const spy = spyOnLogin(signedIn).and.resolveTo({ email: 'foo@bar.baz' });
     await deploy(
       firebaseMock, context, STATIC_BUILD_TARGET, undefined,
       undefined, undefined, { projectId: FIREBASE_PROJECT, preview: false }
     );
     expect(spy).toHaveBeenCalled();
   });
 
+  it('should read the signed-in account with interactive, which firebase-tools 15.26+ needs under an AI agent', async () => {
+    const spy = spyOnLogin(signedIn).and.resolveTo({ email: 'foo@bar.baz' });
+    await deploy(
+      firebaseMock, context, STATIC_BUILD_TARGET, undefined,
+      undefined, undefined, { projectId: FIREBASE_PROJECT, preview: false }
+    );
+    expect(spy).toHaveBeenCalledWith(jasmine.objectContaining({ interactive: true }));
+  });
+
+  it('should deploy when login returns no account for a signed-in user', async () => {
+    spyOnLogin(signedIn).and.resolveTo(undefined);
+    await expectAsync(deploy(
+      firebaseMock, context, STATIC_BUILD_TARGET, undefined,
+      undefined, undefined, { projectId: FIREBASE_PROJECT, preview: false }
+    )).toBeResolved();
+  });
+
+  it('should say to run firebase login when no account is signed in', async () => {
+    spyOnLogin([]).and.resolveTo(undefined);
+    await expectAsync(deploy(
+      firebaseMock, context, STATIC_BUILD_TARGET, undefined,
+      undefined, undefined, { projectId: FIREBASE_PROJECT, preview: false }
+    )).toBeRejectedWithError(/Run `firebase login`/);
+  });
+
   it('should not call login', async () => {
     const spy = spyOn(firebaseMock, 'login');
     await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined,  undefined, undefined, { preview: false }, FIREBASE_TOKEN);

src/schematics/deploy/actions.ts

@@ -10,6 +10,7 @@ import open from 'open';
 import { satisfies } from 'semver';
 import tripleBeam from 'triple-beam';
 import * as winston from 'winston';
+import { getActiveAccount } from '../firebaseTools.js';
 import { BuildTarget, CloudRunOptions, DeployBuilderSchema, FSHost, FirebaseTools } from '../interfaces';
 import { firebaseFunctionsDependencies } from '../versions.json';
 import { DEFAULT_FUNCTION_NAME, defaultFunction, defaultPackage, dockerfile, functionGen2 } from './functions-templates';
@@ -547,6 +548,12 @@ export const deployToCloudRun = async (
   });
 };
 
+/** Whether the Firebase CLI has at least one signed-in account. */
+const isSignedIn = async (firebaseTools: FirebaseTools) => {
+  const accounts = await firebaseTools.login.list();
+  return Array.isArray(accounts) && accounts.length > 0;
+};
+
 export default async function deploy(
   firebaseTools: FirebaseTools,
   context: BuilderContext,
@@ -560,9 +567,16 @@ export default async function deploy(
   const legacyNgDeploy = !options.version || options.version < 2;
 
   if (!firebaseToken && !process.env.GOOGLE_APPLICATION_CREDENTIALS) {
-    await firebaseTools.login();
-    const user = await firebaseTools.login({ projectRoot: context.workspaceRoot });
-    console.log(`Logged into Firebase as ${user.email}.`);
+    if (!await isSignedIn(firebaseTools)) {
+      await firebaseTools.login();
+      if (!await isSignedIn(firebaseTools)) {
+        throw new Error('No Firebase account is signed in. Run `firebase login`, then run `ng deploy` again.');
+      }
+    }
+    const user = await getActiveAccount(firebaseTools, context.workspaceRoot);
+    if (user) {
+      console.log(`Logged into Firebase as ${user.email}.`);
+    }
   }
 
   if (!firebaseToken && process.env.GOOGLE_APPLICATION_CREDENTIALS) {

src/schematics/firebaseTools.ts

@@ -8,6 +8,14 @@ declare global {
     var firebaseTools: FirebaseTools|undefined;
 }
 
+/**
+ * The account firebase-tools uses in `projectRoot`. Call it only once an account is signed in.
+ * Without `interactive`, firebase-tools 15.26+ returns undefined whenever it runs non-interactively,
+ * as it does under an AI agent.
+ */
+export const getActiveAccount = (firebaseTools: FirebaseTools, projectRoot: string) =>
+    firebaseTools.login({ projectRoot, interactive: true });
+
 export const getFirebaseTools = () => globalThis.firebaseTools ?
     Promise.resolve(globalThis.firebaseTools) :
     new Promise<FirebaseTools>((resolve, reject) => {

src/schematics/interfaces.ts

@@ -125,7 +125,7 @@ export interface FirebaseTools {
     list(): Promise<{user: Record<string, any>}[] | { users: undefined }>;
     add(): Promise<Record<string, any>>;
     use(email: string, options?: unknown): Promise<string>;
-  } & ((options?: unknown) => Promise<Record<string, any>>);
+  } & ((options?: unknown) => Promise<Record<string, any> | undefined>);
 
   deploy(config: FirebaseDeployConfig): Promise<any>;
 

src/schematics/setup/index.ts

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { asWindowsPath, normalize } from '@angular-devkit/core';
 import { SchematicContext, Tree, chain } from '@angular-devkit/schematics';
 import { addRootProvider } from '@schematics/angular/utility';
-import { getFirebaseTools } from '../firebaseTools';
+import { getActiveAccount, getFirebaseTools } from '../firebaseTools';
 import {
   DataConnectConnectorConfig,
   DeployOptions, FEATURES, FirebaseApp, FirebaseJSON, FirebaseProject,
@@ -86,7 +86,7 @@ export const ngAddSetupProject = (
     );
 
     const user = await userPrompt({ projectRoot });
-    const defaultUser = await firebaseTools.login(options);
+    const defaultUser = await getActiveAccount(firebaseTools, projectRoot);
     if (user.email !== defaultUser?.email) {
       await firebaseTools.login.use(user.email, { projectRoot });
     }

src/schematics/setup/prompts.ts

@@ -1,7 +1,7 @@
 import { spawnSync } from 'child_process';
 import * as fuzzy from 'fuzzy';
 import * as inquirer from 'inquirer';
-import { getFirebaseTools } from '../firebaseTools';
+import { getActiveAccount, getFirebaseTools } from '../firebaseTools';
 import { FEATURES, FirebaseApp, FirebaseProject, featureOptions } from '../interfaces';
 import { shortAppId } from '../utils';
 
@@ -96,21 +96,26 @@ export const userPrompt = async (options: { projectRoot: string }): Promise<Reco
   const firebaseTools = await getFirebaseTools();
   let loginList = await firebaseTools.login.list();
   if (!Array.isArray(loginList) || loginList.length === 0) {
-    spawnSync('firebase login', { shell: true, cwd: options.projectRoot, stdio: 'inherit' });
-    return await firebaseTools.login(options);
+    // `--interactive` because firebase-tools 15.26+ otherwise skips the sign-in under an AI agent.
+    spawnSync('firebase login --interactive', { shell: true, cwd: options.projectRoot, stdio: 'inherit' });
+    loginList = await firebaseTools.login.list();
+    if (!Array.isArray(loginList) || loginList.length === 0) {
+      throw new Error('No Firebase account is signed in. Run `firebase login`, then run `ng add @angular/fire` again.');
+    }
+    return loginList[0].user;
   } else {
-    const defaultUser = await firebaseTools.login(options);
+    const defaultUser = await getActiveAccount(firebaseTools, options.projectRoot);
     const choices = loginList.map(({user}) => ({ name: user.email, value: user }));
     const newChoice = { name: '[Login in with another account]', value: NEW_OPTION };
     const { user } = await inquirer.prompt({
       type: 'list',
       name: 'user',
       choices: [newChoice].concat(choices as any), // TODO types
       message: 'Which Firebase account would you like to use?',
-      default: choices.find(it => it.value.email === defaultUser.email)?.value,
+      default: choices.find(it => it.value.email === defaultUser?.email)?.value,
     }) as any;
     if (user === NEW_OPTION) {
-      spawnSync('firebase login:add', { shell: true, cwd: options.projectRoot, stdio: 'inherit' });
+      spawnSync('firebase login:add --interactive', { shell: true, cwd: options.projectRoot, stdio: 'inherit' });
       loginList = await firebaseTools.login.list();
       if (!Array.isArray(loginList)) {
         throw new Error("firebase login:list did not respond as expected");