Support Firebase global active project selection in init

Author: marcusschiesser

.changeset/brand-agentpond-init.md

@@ -0,0 +1,5 @@
+---
+"agentpond": patch
+---
+
+Show AgentPond branding before the bundled Skills setup flow.

.changeset/detect-cancelled-skill-install.md

@@ -0,0 +1,5 @@
+---
+"agentpond": patch
+---
+
+Stop Firebase setup when AgentPond skill installation is cancelled or incomplete.

.changeset/follow-firebase-active-project.md

@@ -0,0 +1,6 @@
+---
+"@agentpond/firebase": patch
+"agentpond": patch
+---
+
+Honor active Firebase CLI project selections even when `.firebaserc` is absent.

apps/cli/src/commands/init.ts

@@ -1,5 +1,7 @@
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
+import { join } from "node:path";
 import {
 	firebaseCliProjectConfigFromCwd,
 	firebaseProjectDirectory,
@@ -19,6 +21,22 @@ export const AGENTPOND_INIT_SKILLS = [
 	"agentpond",
 ] as const;
 
+export function agentPondCliHeader(): string {
+	return [
+		"AgentPond",
+		"Store agent traces remotely. Analyze them locally.",
+	].join("\n");
+}
+
+export function agentPondInitHeader(projectId: string): string {
+	return [
+		agentPondCliHeader(),
+		"",
+		`Firebase project: ${projectId}`,
+		"Installing AgentPond skills...",
+	].join("\n");
+}
+
 export const FIREBASE_INSTRUMENTATION_PROMPT = `Use $agentpond-instrumentation to inspect this Firebase project and add
 OpenInference tracing to its trusted server-side AI application.
 
@@ -86,6 +104,8 @@ export function registerInitCommand(
 				);
 			}
 
+			console.log(agentPondInitHeader(project.projectId));
+
 			await (options.installSkills ?? installSkillsWithBundledCli)({
 				cwd: project.root,
 				source: AGENTPOND_SKILLS_SOURCE,
@@ -94,7 +114,7 @@ export function registerInitCommand(
 
 			console.log(
 				[
-					`AgentPond skills installed for Firebase project: ${project.projectId}`,
+					`AgentPond skills ready for Firebase project: ${project.projectId}`,
 					"",
 					"Paste this prompt into your coding agent:",
 					"",
@@ -126,6 +146,16 @@ export async function installSkillsWithBundledCli(
 	if (exitCode !== 0) {
 		throw new CliError(`Skills CLI exited with status ${exitCode}`);
 	}
+
+	const missingSkills = request.skills.filter(
+		(skill) =>
+			!existsSync(join(request.cwd, ".agents", "skills", skill, "SKILL.md")),
+	);
+	if (missingSkills.length > 0) {
+		throw new CliError(
+			`AgentPond skill installation was cancelled or did not complete. Missing: ${missingSkills.join(", ")}`,
+		);
+	}
 }
 
 async function runSkillsProcess(

apps/cli/tests/cli.test.ts

@@ -28,6 +28,7 @@ import {
 	listenOnAvailablePort,
 } from "../src/commands/dev.js";
 import {
+	agentPondInitHeader,
 	FIREBASE_INSTRUMENTATION_PROMPT,
 	installSkillsWithBundledCli,
 	MANUAL_SETUP_URL,
@@ -155,7 +156,8 @@ test("CLI init installs AgentPond skills for a nested Firebase project", async (
 		assert.equal(
 			output,
 			[
-				"AgentPond skills installed for Firebase project: firebase-demo",
+				agentPondInitHeader("firebase-demo"),
+				"AgentPond skills ready for Firebase project: firebase-demo",
 				"",
 				"Paste this prompt into your coding agent:",
 				"",
@@ -203,6 +205,51 @@ test("CLI init detects a Firebase project from its root", async () => {
 	}
 });
 
+test("CLI init follows Firebase CLI global active project selections", async () => {
+	const cwd = process.cwd();
+	const root = realpathSync(
+		mkdtempSync(join(tmpdir(), "agentpond-cli-init-firebase-active-")),
+	);
+	const configHome = mkdtempSync(
+		join(tmpdir(), "agentpond-cli-init-firebase-config-"),
+	);
+	const originalConfigHome = process.env.XDG_CONFIG_HOME;
+	const originalExitCode = process.exitCode;
+	let installCwd: string | undefined;
+	process.exitCode = undefined;
+	try {
+		mkdirSync(join(configHome, "configstore"), { recursive: true });
+		writeFileSync(join(root, "firebase.json"), "{}", "utf8");
+		writeFileSync(
+			join(configHome, "configstore", "firebase-tools.json"),
+			JSON.stringify({ activeProjects: { [root]: "firebase-active-demo" } }),
+			"utf8",
+		);
+		process.env.XDG_CONFIG_HOME = configHome;
+		process.chdir(root);
+
+		const output = await captureStdout(() =>
+			main(["node", "agentpond", "init"], {
+				installSkills: async (request) => {
+					installCwd = request.cwd;
+				},
+			}),
+		);
+
+		assert.equal(process.exitCode, undefined);
+		assert.equal(installCwd, root);
+		assert.match(
+			output,
+			/AgentPond skills ready for Firebase project: firebase-active-demo/,
+		);
+	} finally {
+		if (originalConfigHome === undefined) delete process.env.XDG_CONFIG_HOME;
+		else process.env.XDG_CONFIG_HOME = originalConfigHome;
+		process.chdir(cwd);
+		process.exitCode = originalExitCode;
+	}
+});
+
 test("CLI init rejects non-Firebase projects without creating files", async () => {
 	const cwd = process.cwd();
 	const root = realpathSync(
@@ -346,7 +393,7 @@ test("CLI init does not print a prompt when skill installation fails", async ()
 		});
 
 		assert.equal(process.exitCode, 1);
-		assert.equal(output, "");
+		assert.equal(output, [agentPondInitHeader("firebase-demo"), ""].join("\n"));
 		assert.equal(existsSync(join(root, ".agentpond")), false);
 	} finally {
 		process.chdir(cwd);
@@ -355,17 +402,23 @@ test("CLI init does not print a prompt when skill installation fails", async ()
 });
 
 test("CLI init invokes the bundled Skills CLI directly without agent flags", async () => {
+	const root = mkdtempSync(join(tmpdir(), "agentpond-cli-skills-install-"));
 	let processRequest: SkillsProcessRequest | undefined;
 	await installSkillsWithBundledCli(
 		{
-			cwd: "/firebase/root",
+			cwd: root,
 			source: "marcusschiesser/agentpond",
 			skills: ["agentpond-instrumentation", "agentpond"],
 		},
 		{
 			cliPath: "/package/skills/bin/cli.mjs",
 			run: async (request) => {
 				processRequest = request;
+				for (const skill of ["agentpond-instrumentation", "agentpond"]) {
+					const skillDir = join(root, ".agents", "skills", skill);
+					mkdirSync(skillDir, { recursive: true });
+					writeFileSync(join(skillDir, "SKILL.md"), "---\n---\n", "utf8");
+				}
 				return 0;
 			},
 		},
@@ -382,12 +435,27 @@ test("CLI init invokes the bundled Skills CLI directly without agent flags", asy
 			"--skill",
 			"agentpond",
 		],
-		cwd: "/firebase/root",
+		cwd: root,
 	});
 	assert.equal(processRequest?.args.includes("--agent"), false);
 	assert.equal(processRequest?.args.includes("--yes"), false);
 });
 
+test("CLI init treats a cancelled Skills installation as incomplete", async () => {
+	const root = mkdtempSync(join(tmpdir(), "agentpond-cli-skills-cancelled-"));
+
+	await assert.rejects(
+		installSkillsWithBundledCli(
+			{ cwd: root, source: "test/source", skills: ["agentpond"] },
+			{
+				cliPath: "/package/skills/bin/cli.mjs",
+				run: async () => 0,
+			},
+		),
+		/installation was cancelled or did not complete.*agentpond/,
+	);
+});
+
 test("CLI trace creation builds a Langfuse-compatible OTEL root span", () => {
 	const resourceSpans = manualTraceResourceSpans(
 		{

docs/getting-started/firebase.md

@@ -53,6 +53,6 @@ Firebase owns project selection. Do not use `npx agentpond env init` or `npx age
 ## Troubleshooting
 
 - **Firebase is not detected:** Run the command from a directory below the Firebase root and confirm `.firebaserc` or `firebase.json` exists.
-- **Project ID is missing:** Run `firebase use <alias-or-project-id>` and retry.
+- **Project ID is missing:** Run `firebase use <alias-or-project-id>` and retry. AgentPond follows both `.firebaserc` aliases and the Firebase CLI's global active-project selection.
 - **No trusted server runtime exists:** Add or select a server runtime before using the Firebase Admin exporter; never move it into client code.
 - **No traces appear:** Confirm the instrumented code path ran, the provider flushed, Firebase Admin selected the default app and bucket, and then rerun `npx agentpond sync`.

packages/firebase/src/firebase-env.ts

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import { findAncestorDirectory } from "@agentpond/core";
 
 export type FirebaseCliProjectConfig = {
@@ -31,12 +32,12 @@ export function firebaseCliProjectConfigFromCwd(
 
 	const runtimeConfig = firebaseRuntimeConfig(env.FIREBASE_CONFIG);
 	const projectId =
-		firebaseProjectIdFromRc(root) ??
+		firebaseProjectIdFromCli(root, env) ??
 		runtimeConfig?.projectId ??
 		firebaseProjectIdFromEnv(env);
 	if (!projectId) {
 		throw new Error(
-			"Could not determine Firebase project id. Run firebase use <project> to write .firebaserc, or set FIREBASE_CONFIG, GCLOUD_PROJECT, GCP_PROJECT, or GOOGLE_CLOUD_PROJECT.",
+			"Could not determine Firebase project id. Run firebase use <project> to select a project, or set FIREBASE_CONFIG, GCLOUD_PROJECT, GCP_PROJECT, or GOOGLE_CLOUD_PROJECT.",
 		);
 	}
 
@@ -95,23 +96,64 @@ function firebaseFunctionsSources(functions: unknown): string[] {
 	return [];
 }
 
-function firebaseProjectIdFromRc(root: string): string | undefined {
+function firebaseProjectIdFromCli(
+	root: string,
+	env: NodeJS.ProcessEnv,
+): string | undefined {
+	const activeProject = firebaseActiveProjectFromConfigStore(root, env);
+	if (!activeProject) return firebaseProjectIdFromRc(root);
+	return firebaseProjectIdFromRc(root, activeProject) ?? activeProject;
+}
+
+function firebaseProjectIdFromRc(
+	root: string,
+	alias = "default",
+): string | undefined {
 	const rcPath = join(root, ".firebaserc");
 	if (!existsSync(rcPath)) return undefined;
 	try {
 		const rcData = JSON.parse(readFileSync(rcPath, "utf8")) as {
-			projects?: { default?: unknown };
+			projects?: Record<string, unknown>;
 		};
-		const projectId = rcData.projects?.default;
+		const projectId = rcData.projects?.[alias];
 		return typeof projectId === "string" && projectId ? projectId : undefined;
 	} catch (error) {
 		throw new Error(
-			"Could not read Firebase project id from .firebaserc projects.default",
+			`Could not read Firebase project id from .firebaserc projects.${alias}`,
 			{ cause: error },
 		);
 	}
 }
 
+function firebaseActiveProjectFromConfigStore(
+	root: string,
+	env: NodeJS.ProcessEnv,
+): string | undefined {
+	const configHome =
+		env.XDG_CONFIG_HOME ||
+		(env.HOME ? join(env.HOME, ".config") : join(homedir(), ".config"));
+	const configPath = join(configHome, "configstore", "firebase-tools.json");
+	if (!existsSync(configPath)) return undefined;
+
+	try {
+		const config = JSON.parse(readFileSync(configPath, "utf8")) as {
+			activeProjects?: Record<string, unknown>;
+		};
+		let currentDir = resolve(root);
+		while (true) {
+			const activeProject = config.activeProjects?.[currentDir];
+			if (typeof activeProject === "string" && activeProject) {
+				return activeProject;
+			}
+			const parentDir = dirname(currentDir);
+			if (parentDir === currentDir) return undefined;
+			currentDir = parentDir;
+		}
+	} catch {
+		return undefined;
+	}
+}
+
 function firebaseProjectIdFromEnv(env: NodeJS.ProcessEnv): string | undefined {
 	return (
 		firebaseRuntimeConfig(env.FIREBASE_CONFIG)?.projectId ??

packages/firebase/tests/firebase.test.ts

@@ -100,6 +100,61 @@ test("Firebase CLI project config reads .firebaserc from cwd", () => {
 	});
 });
 
+test("Firebase CLI project config reads global active project selections", () => {
+	const cwd = mkdtempSync(join(tmpdir(), "agentpond-firebase-active-project-"));
+	const configHome = mkdtempSync(
+		join(tmpdir(), "agentpond-firebase-config-home-"),
+	);
+	mkdirSync(join(configHome, "configstore"), { recursive: true });
+	writeFileSync(join(cwd, "firebase.json"), "{}", "utf8");
+	writeFileSync(
+		join(configHome, "configstore", "firebase-tools.json"),
+		JSON.stringify({ activeProjects: { [cwd]: "demo-project" } }),
+		"utf8",
+	);
+
+	assert.deepEqual(
+		firebaseCliProjectConfigFromCwd(cwd, {
+			XDG_CONFIG_HOME: configHome,
+		} as NodeJS.ProcessEnv),
+		{
+			projectId: "demo-project",
+			root: cwd,
+		},
+	);
+});
+
+test("Firebase CLI project config resolves globally selected aliases", () => {
+	const cwd = mkdtempSync(join(tmpdir(), "agentpond-firebase-active-alias-"));
+	const configHome = mkdtempSync(
+		join(tmpdir(), "agentpond-firebase-config-home-"),
+	);
+	mkdirSync(join(configHome, "configstore"), { recursive: true });
+	writeFileSync(join(cwd, "firebase.json"), "{}", "utf8");
+	writeFileSync(
+		join(cwd, ".firebaserc"),
+		JSON.stringify({
+			projects: { default: "prod-project", dev: "dev-project" },
+		}),
+		"utf8",
+	);
+	writeFileSync(
+		join(configHome, "configstore", "firebase-tools.json"),
+		JSON.stringify({ activeProjects: { [cwd]: "dev" } }),
+		"utf8",
+	);
+
+	assert.deepEqual(
+		firebaseCliProjectConfigFromCwd(cwd, {
+			XDG_CONFIG_HOME: configHome,
+		} as NodeJS.ProcessEnv),
+		{
+			projectId: "dev-project",
+			root: cwd,
+		},
+	);
+});
+
 test("Firebase CLI project config walks up to Firebase project roots", () => {
 	const root = mkdtempSync(join(tmpdir(), "agentpond-firebase-monorepo-"));
 	const cwd = join(root, "packages", "functions");

skills/agentpond/SKILL.md

@@ -24,6 +24,10 @@ firebase use <alias-or-project-id>
 npx agentpond sync
 ```
 
+AgentPond follows the Firebase CLI's active project selection, including
+selections stored globally when the project has no `.firebaserc`.
+If skill installation is cancelled, `init` stops without printing the coding-agent prompt.
+
 For non-Firebase storage, inspect and select an existing AgentPond environment:
 
 ```bash