fix(tracking): Detect more coding agents

### Description
Refactors the AI agent detection logic to improve type safety and maintainability.

Key changes:
- Defined CONSTANT_CASE constants for all supported AI agents in src/env.ts.
- Introduced an AiAgents union type for better type safety.
- Refactored detectAIAgent() to use these constants and return the new type.
- Incorporated detection for GOOGLE_AI_STUDIO via the APPLET_DIR environment variable.
- Updated apiv2.ts to use the normalized UNKNOWN constant.
- Added 18 unit tests in src/env.spec.ts with Sinon stubs and module reloading.

### Scenarios Tested
- Unit Testing (src/env.spec.ts): Verified detection of all AI agents (Antigravity, Claude, Cline, Codex, Cursor, Gemini, OpenCode, Replit, Copilot, Google AI Studio) and alternative environment variables.
- Verified isFirebaseStudio() and isFirebaseMcp() logic.

### Sample Commands
N/A

Author: richieforeman

src/apiv2.ts

@@ -9,7 +9,7 @@ import util from "util";
 
 import * as auth from "./auth";
 import { FirebaseError } from "./error";
-import { isFirebaseMcp, detectAIAgent } from "./env";
+import { isFirebaseMcp, detectAIAgent, UNKNOWN } from "./env";
 import { logger } from "./logger";
 import { responseToError } from "./responseToError";
 import * as FormData from "form-data";
@@ -21,7 +21,7 @@ const CLI_VERSION: string = pkg.version;
 
 export const standardHeaders: () => Record<string, string> = () => {
   const agent = detectAIAgent();
-  const agentStr = agent === "unknown" ? "" : ` agent-name/${agent}`;
+  const agentStr = agent === UNKNOWN ? "" : ` agent-name/${agent}`;
   const platform = isFirebaseMcp() ? "FirebaseMCP" : "FirebaseCLI";
   const clientVersion = `${platform}/${CLI_VERSION}${agentStr}`;
   return {

src/env.spec.ts

@@ -0,0 +1,141 @@
+import { expect } from "chai";
+import * as sinon from "sinon";
+import * as fsutils from "./fsutils";
+
+describe("env", () => {
+  let env: typeof import("./env");
+
+  beforeEach(() => {
+    // Reload the env module to reset internal caches
+    delete require.cache[require.resolve("./env")];
+    env = require("./env") as typeof import("./env");
+  });
+
+  describe("detectAIAgent", () => {
+    let envStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      // Stub process.env to an empty object for isolation
+      envStub = sinon.stub(process, "env").value({});
+    });
+
+    afterEach(() => {
+      envStub.restore();
+    });
+
+    it("should return UNKNOWN when no agent env vars are set", () => {
+      expect(env.detectAIAgent()).to.equal(env.UNKNOWN);
+    });
+
+    it("should detect antigravity", () => {
+      process.env["ANTIGRAVITY_CLI_ALIAS"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.ANTIGRAVITY);
+    });
+
+    it("should detect claude_code", () => {
+      process.env["CLAUDECODE"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.CLAUDE_CODE);
+    });
+
+    it("should detect claude_code_cowork", () => {
+      process.env["CLAUDECODE"] = "true";
+      process.env["CLAUDE_CODE_IS_COWORK"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.CLAUDE_CODE_COWORK);
+    });
+
+    it("should detect cline", () => {
+      process.env["CLINE_ACTIVE"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.CLINE);
+    });
+
+    it("should detect codex_cli", () => {
+      process.env["CODEX_SANDBOX"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.CODEX_CLI);
+    });
+
+    it("should detect cursor", () => {
+      process.env["CURSOR_AGENT"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.CURSOR);
+    });
+
+    it("should detect gemini_cli", () => {
+      process.env["GEMINI_CLI"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.GEMINI_CLI);
+    });
+
+    it("should detect open_code", () => {
+      process.env["OPENCODE"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.OPEN_CODE);
+    });
+
+    it("should detect replit", () => {
+      process.env["REPLIT_USER"] = "user";
+      expect(env.detectAIAgent()).to.equal(env.REPLIT);
+    });
+
+    it("should detect copilot", () => {
+      process.env["COPILOT_MODEL"] = "gpt-4";
+      expect(env.detectAIAgent()).to.equal(env.COPILOT);
+    });
+
+    it("should detect google_ai_studio", () => {
+      process.env["APPLET_DIR"] = "/some/path";
+      expect(env.detectAIAgent()).to.equal(env.GOOGLE_AI_STUDIO);
+    });
+
+    it("should detect cursor via alternative env vars", () => {
+      process.env["CURSOR_TRACE_ID"] = "123";
+      expect(env.detectAIAgent()).to.equal(env.CURSOR);
+
+      delete process.env["CURSOR_TRACE_ID"];
+      process.env["CODEX_THREAD_ID"] = "456";
+      expect(env.detectAIAgent()).to.equal(env.CURSOR);
+
+      delete process.env["CODEX_THREAD_ID"];
+      process.env["CODEX_SANDBOX_NETWORK_DISABLED"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.CURSOR);
+    });
+
+    it("should detect open_code via OPENCODE_CLIENT", () => {
+      process.env["OPENCODE_CLIENT"] = "true";
+      expect(env.detectAIAgent()).to.equal(env.OPEN_CODE);
+    });
+
+    it("should detect replit via REPL_ID", () => {
+      process.env["REPL_ID"] = "abc-123";
+      expect(env.detectAIAgent()).to.equal(env.REPLIT);
+    });
+  });
+
+  describe("isFirebaseMcp", () => {
+    it("should reflect setFirebaseMcp value", () => {
+      env.setFirebaseMcp(true);
+      expect(env.isFirebaseMcp()).to.be.true;
+      env.setFirebaseMcp(false);
+      expect(env.isFirebaseMcp()).to.be.false;
+    });
+  });
+
+  describe("isFirebaseStudio", () => {
+    let dirExistsSyncStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      dirExistsSyncStub = sinon.stub(fsutils, "dirExistsSync");
+    });
+
+    afterEach(() => {
+      dirExistsSyncStub.restore();
+    });
+
+    it("should return true if MONOSPACE_ENV is set", () => {
+      const envStub = sinon.stub(process, "env").value({ MONOSPACE_ENV: "true" });
+      expect(env.isFirebaseStudio()).to.be.true;
+      envStub.restore();
+    });
+
+    it("should return true if /google/idx exists", () => {
+      dirExistsSyncStub.withArgs("/google/idx").returns(true);
+      expect(env.isFirebaseStudio()).to.be.true;
+    });
+  });
+});

src/env.ts

@@ -16,15 +16,56 @@ export function isFirebaseMcp() {
 export function setFirebaseMcp(value: boolean) {
   isFirebaseMcpFlag = value;
 }
+export const ANTIGRAVITY = "antigravity" as const;
+export const CLAUDE_CODE_COWORK = "claude_code_cowork" as const;
+export const CLAUDE_CODE = "claude_code" as const;
+export const CLINE = "cline" as const;
+export const CODEX_CLI = "codex_cli" as const;
+export const CURSOR = "cursor" as const;
+export const GEMINI_CLI = "gemini_cli" as const;
+export const OPEN_CODE = "open_code" as const;
+export const REPLIT = "replit" as const;
+export const COPILOT = "copilot" as const;
+export const GOOGLE_AI_STUDIO = "google_ai_studio" as const;
+export const UNKNOWN = "unknown" as const;
 
-// Detect if the CLI was invoked by a coding agent, based on well-known env vars.
-export function detectAIAgent(): string {
-  if (process.env.ANTIGRAVITY_CLI_ALIAS) return "antigravity";
-  if (process.env.CLAUDECODE) return "claude_code";
-  if (process.env.CLINE_ACTIVE) return "cline";
-  if (process.env.CODEX_SANDBOX) return "codex_cli";
-  if (process.env.CURSOR_AGENT) return "cursor";
-  if (process.env.GEMINI_CLI) return "gemini_cli";
-  if (process.env.OPENCODE) return "open_code";
-  return "unknown";
+/** All possible AI Agents */
+export type AiAgents =
+  | typeof ANTIGRAVITY
+  | typeof CLAUDE_CODE_COWORK
+  | typeof CLAUDE_CODE
+  | typeof CLINE
+  | typeof CODEX_CLI
+  | typeof CURSOR
+  | typeof GEMINI_CLI
+  | typeof GOOGLE_AI_STUDIO
+  | typeof OPEN_CODE
+  | typeof REPLIT
+  | typeof COPILOT
+  | typeof UNKNOWN;
+
+/**
+ * Detect if the CLI was invoked by a coding agent, based on well-known env vars.  Returns "unknown" if the coding agent is undefined, or if the environment is not running in a coding agent.
+ * @returns The AI agent that invoked the CLI, or UNKNOWN if none.
+ */
+export function detectAIAgent(): AiAgents {
+  if (process.env["ANTIGRAVITY_CLI_ALIAS"]) return ANTIGRAVITY;
+  if (process.env["CLAUDECODE"]) {
+    return process.env["CLAUDE_CODE_IS_COWORK"] ? CLAUDE_CODE_COWORK : CLAUDE_CODE;
+  }
+  if (process.env["CLINE_ACTIVE"]) return CLINE;
+  if (process.env["CODEX_SANDBOX"]) return CODEX_CLI;
+  if (
+    process.env["CURSOR_AGENT"] ||
+    process.env["CURSOR_TRACE_ID"] ||
+    process.env["CODEX_THREAD_ID"] ||
+    process.env["CODEX_SANDBOX_NETWORK_DISABLED"]
+  )
+    return CURSOR;
+  if (process.env["GEMINI_CLI"]) return GEMINI_CLI;
+  if (process.env["OPENCODE"] || process.env["OPENCODE_CLIENT"]) return OPEN_CODE;
+  if (process.env["REPLIT_USER"] || process.env["REPL_ID"]) return REPLIT;
+  if (process.env["COPILOT_MODEL"]) return COPILOT;
+  if (process.env["APPLET_DIR"]) return GOOGLE_AI_STUDIO;
+  return UNKNOWN;
 }