Prompt to install skills on firebase init

CHANGELOG.md

@@ -0,0 +1 @@
+- Added a prompt to `firebase init` to install Agent Skills for Firebase.

src/agentSkills.spec.ts

@@ -0,0 +1,71 @@
+import { expect } from "chai";
+import * as sinon from "sinon";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as utils from "./utils";
+import * as prompt from "./prompt";
+import { promptForAgentSkills, installAgentSkills } from "./agentSkills";
+
+describe("agentSkills", () => {
+  let sandbox: sinon.SinonSandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe("promptForAgentSkills", () => {
+    it("should return true if user confirms", async () => {
+      sandbox.stub(prompt, "confirm").resolves(true);
+      const result = await promptForAgentSkills();
+      expect(result).to.be.true;
+    });
+
+    it("should return false if user declines", async () => {
+      sandbox.stub(prompt, "confirm").resolves(false);
+      const result = await promptForAgentSkills();
+      expect(result).to.be.false;
+    });
+  });
+
+  describe("installAgentSkills", () => {
+    let testRoot: string;
+
+    beforeEach(() => {
+      testRoot = fs.mkdtempSync(path.join(os.tmpdir(), "agent-skills-test-"));
+    });
+
+    afterEach(() => {
+      fs.rmSync(testRoot, { recursive: true, force: true });
+    });
+
+    it("should install skills locally and create .agents directory", async () => {
+      await installAgentSkills({ cwd: testRoot });
+
+      const agentsDir = path.join(testRoot, ".agents");
+      const skillsDir = path.join(agentsDir, "skills");
+      const lockFile = path.join(testRoot, "skills-lock.json");
+
+      expect(fs.existsSync(agentsDir), "Expected .agents directory to exist").to.be.true;
+      expect(fs.existsSync(skillsDir), "Expected .agents/skills directory to exist").to.be.true;
+      expect(fs.existsSync(lockFile), "Expected skills-lock.json to exist").to.be.true;
+
+      // Check if at least one skill was installed (e.g., firebase-basics)
+      const skills = fs.readdirSync(skillsDir);
+      expect(skills.length).to.be.greaterThan(0);
+      expect(skills).to.include("firebase-basics");
+    }).timeout(60000);
+
+    it("should skip if npx is not available", async () => {
+      sandbox.stub(utils, "commandExistsSync").withArgs("npx").returns(false);
+
+      await installAgentSkills({ cwd: testRoot });
+
+      expect(fs.existsSync(path.join(testRoot, ".agents"))).to.be.false;
+    });
+  });
+});

src/agentSkills.ts

@@ -0,0 +1,76 @@
+import { spawn, spawnSync } from "child_process";
+import * as utils from "./utils";
+import * as prompt from "./prompt";
+import { getErrMsg } from "./error";
+
+export async function promptForAgentSkills(): Promise<boolean> {
+  return prompt.confirm({
+    message: "Would you like to install agent skills for Firebase?",
+    default: true,
+  });
+}
+
+export interface InstallAgentSkillsOptions {
+  cwd: string;
+  global?: boolean;
+  background?: boolean;
+  agentName?: string;
+}
+
+export async function installAgentSkills(options: InstallAgentSkillsOptions): Promise<void> {
+  if (!utils.commandExistsSync("npx")) {
+    return;
+  }
+
+  const args = [
+    "-y", // npx -y to auto-confirm package install
+    "skills",
+    "add",
+    "firebase/agent-skills",
+    "--skill",
+    "*",
+    "-y",
+  ];
+
+  if (options.agentName) {
+    args.push("-a", options.agentName);
+  }
+
+  if (options.global) {
+    args.push("-g");
+  }
+
+  if (options.background) {
+    utils.logBullet("Installing Agent skills in the background...");
+    try {
+      const child = spawn("npx", args, {
+        cwd: options.cwd,
+        stdio: "ignore",
+        detached: true,
+        shell: process.platform === "win32",
+      });
+      child.unref();
+      utils.logSuccess("Agent skills installation started");
+    } catch (err: unknown) {
+      utils.logWarning(`Could not start Agent skills installation: ${getErrMsg(err)}`);
+    }
+  } else {
+    utils.logBullet("Adding Agent skills...");
+    try {
+      const result = spawnSync("npx", args, {
+        cwd: options.cwd,
+        stdio: "ignore",
+        shell: process.platform === "win32",
+      });
+      if (result.error) {
+        throw result.error;
+      }
+      if (result.status !== 0) {
+        throw new Error(`npx skills add exited with code ${result.status}`);
+      }
+      utils.logSuccess("Added Agent skills");
+    } catch (err: unknown) {
+      utils.logWarning(`Could not add Agent skills: ${getErrMsg(err)}`);
+    }
+  }
+}

src/commands/init.ts

@@ -212,7 +212,7 @@
 
   const setup: Setup = {
     config: config.src,
     rcfile: config.readProjectFile(".firebaserc", {
       json: true,
       fallback: {},
     }),
@@ -277,6 +277,9 @@
     setup.features = setup.features.filter((f) => f !== "dataconnect:sdk");
   }
 
+  // Always prompt for agent skills at the end of init
+  setup.features.push("agentSkills");
+
   await init(setup, config, options);
   await postInitSaves(setup, config);
 
@@ -288,7 +291,7 @@
   }
 }
 
 export async function postInitSaves(setup: Setup, config: Config): Promise<void> {
   logger.info();
   config.writeProjectFile("firebase.json", setup.config);
   config.writeProjectFile(".firebaserc", setup.rcfile);

src/firebase_studio/migrate.spec.ts

@@ -8,9 +8,11 @@
 import * as track from "../track";
 import * as secrets from "../apphosting/secrets";
 import * as utils from "../utils";
+import * as agentSkills from "../agentSkills";
 
 describe("migrate", () => {
   let sandbox: sinon.SinonSandbox;
+  let installSkillsStub: sinon.SinonStub;
   const testRoot = "/test/root";
 
   beforeEach(() => {
@@ -23,9 +25,9 @@
 
   describe("extractMetadata", () => {
     beforeEach(() => {
       sandbox.stub(fs, "readFile").callsFake(async (p: any) => {
         const pStr = p.toString();
         if (pStr.endsWith("metadata.json")) {
           return JSON.stringify({ projectId: "original-project" });
         }
         if (pStr.endsWith("blueprint.md")) {
@@ -114,6 +116,7 @@
         .resolves({ backends: [], unreachable: [] });
 
       commandStub = sandbox.stub(utils, "commandExistsSync").returns(false);
+      commandStub.withArgs("npx").returns(true);
       trackStub = sandbox.stub(track, "trackGA4").resolves();
       confirmStub = sandbox.stub(prompt, "confirm").resolves(true);
       selectStub = sandbox.stub(prompt, "select").resolves("local");
@@ -124,6 +127,7 @@
           // No-op for testing
         },
       } as unknown as import("child_process").ChildProcess);
+      installSkillsStub = sandbox.stub(agentSkills, "installAgentSkills").resolves();
     });
 
     it("should fail if the directory does not exist", async () => {
@@ -234,23 +238,13 @@
         ),
       ).to.be.true;
 
-      const cp = require("child_process");
       expect(
-        (cp.spawnSync as sinon.SinonStub).calledWith(
-          "npx",
-          [
-            "-y",
-            "skills",
-            "add",
-            "firebase/agent-skills",
-            "-a",
-            "gemini-cli",
-            "--skill",
-            "*",
-            "-y",
-          ],
-          sinon.match.any,
-        ),
+        installSkillsStub.calledWith({
+          cwd: testRoot,
+          global: false,
+          background: false,
+          agentName: "gemini-cli",
+        }),
       ).to.be.true;
     });
 
@@ -395,6 +389,8 @@
         throw new Error(`Unexpected readFile: ${pStr}`);
       });
 
+      commandStub.withArgs("npx").returns(false);
+
       await migrate(testRoot);
 
       expect(
@@ -536,24 +532,13 @@
 
       await migrate(testRoot);
 
-      const cp = require("child_process");
       expect(
-        (cp.spawnSync as sinon.SinonStub).calledWith(
-          "npx",
-          [
-            "-y",
-            "skills",
-            "add",
-            "firebase/agent-skills",
-            "-a",
-            "gemini-cli",
-            "--skill",
-            "*",
-            "-y",
-            "-g",
-          ],
-          sinon.match.any,
-        ),
+        installSkillsStub.calledWith({
+          cwd: testRoot,
+          global: true,
+          background: false,
+          agentName: "gemini-cli",
+        }),
       ).to.be.true;
     });