@google/gemini-cli 0.44.0 → 0.45.0-nightly.20260527.g41c9260ca

package/bundle/chunk-UHMKT6SK.js

@@ -0,0 +1,154 @@
+const require = (await import('node:module')).createRequire(import.meta.url); const __chunk_filename = (await import('node:url')).fileURLToPath(import.meta.url); const __chunk_dirname = (await import('node:path')).dirname(__chunk_filename);
+import {
+  ExitCodes,
+  Storage,
+  isTelemetrySdkInitialized,
+  resetBrowserSession,
+  shutdownTelemetry
+} from "./chunk-PN5LGMOT.js";
+
+// packages/cli/src/utils/cleanup.ts
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+var cleanupFunctions = [];
+var syncCleanupFunctions = [];
+var configForTelemetry = null;
+var isShuttingDown = false;
+function registerCleanup(fn) {
+  cleanupFunctions.push(fn);
+}
+function removeCleanup(fn) {
+  const index = cleanupFunctions.indexOf(fn);
+  if (index !== -1) {
+    cleanupFunctions.splice(index, 1);
+  }
+}
+function registerSyncCleanup(fn) {
+  syncCleanupFunctions.push(fn);
+}
+function removeSyncCleanup(fn) {
+  const index = syncCleanupFunctions.indexOf(fn);
+  if (index !== -1) {
+    syncCleanupFunctions.splice(index, 1);
+  }
+}
+function resetCleanupForTesting() {
+  cleanupFunctions.length = 0;
+  syncCleanupFunctions.length = 0;
+  configForTelemetry = null;
+  isShuttingDown = false;
+}
+function runSyncCleanup() {
+  for (const fn of syncCleanupFunctions) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+  syncCleanupFunctions.length = 0;
+}
+function registerTelemetryConfig(config) {
+  configForTelemetry = config;
+}
+async function runExitCleanup() {
+  await drainStdin();
+  runSyncCleanup();
+  for (const fn of cleanupFunctions) {
+    try {
+      await fn();
+    } catch {
+    }
+  }
+  cleanupFunctions.length = 0;
+  try {
+    await resetBrowserSession();
+  } catch {
+  }
+  if (configForTelemetry) {
+    try {
+      await configForTelemetry.dispose();
+    } catch {
+    }
+  }
+  if (configForTelemetry && isTelemetrySdkInitialized()) {
+    try {
+      await shutdownTelemetry(configForTelemetry);
+    } catch {
+    }
+  }
+}
+async function drainStdin() {
+  if (!process.stdin?.isTTY) return;
+  process.stdin.resume().removeAllListeners("data").on("data", () => {
+  });
+  await new Promise((resolve) => setTimeout(resolve, 50));
+}
+async function gracefulShutdown(_reason) {
+  if (isShuttingDown) {
+    return;
+  }
+  isShuttingDown = true;
+  await runExitCleanup();
+  process.exit(ExitCodes.SUCCESS);
+}
+function setupSignalHandlers() {
+  process.on("SIGHUP", () => gracefulShutdown("SIGHUP"));
+  process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+  process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+}
+function setupTtyCheck() {
+  let intervalId = null;
+  let isCheckingTty = false;
+  intervalId = setInterval(async () => {
+    if (isCheckingTty || isShuttingDown) {
+      return;
+    }
+    if (process.env["SANDBOX"]) {
+      return;
+    }
+    if (!process.stdin.isTTY && !process.stdout.isTTY) {
+      isCheckingTty = true;
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      await gracefulShutdown("TTY loss");
+    }
+  }, 5e3);
+  intervalId.unref();
+  return () => {
+    if (intervalId) {
+      clearInterval(intervalId);
+      intervalId = null;
+    }
+  };
+}
+async function cleanupCheckpoints() {
+  const storage = new Storage(process.cwd());
+  await storage.initialize();
+  const tempDir = storage.getProjectTempDir();
+  const checkpointsDir = join(tempDir, "checkpoints");
+  try {
+    await fs.rm(checkpointsDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+export {
+  registerCleanup,
+  removeCleanup,
+  registerSyncCleanup,
+  removeSyncCleanup,
+  resetCleanupForTesting,
+  runSyncCleanup,
+  registerTelemetryConfig,
+  runExitCleanup,
+  setupSignalHandlers,
+  setupTtyCheck,
+  cleanupCheckpoints
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/bundle/chunk-UJJ75A5I.js

@@ -0,0 +1,398 @@
+const require = (await import('node:module')).createRequire(import.meta.url); const __chunk_filename = (await import('node:url')).fileURLToPath(import.meta.url); const __chunk_dirname = (await import('node:path')).dirname(__chunk_filename);
+import {
+  runExitCleanup
+} from "./chunk-UHMKT6SK.js";
+import {
+  RELEASE_CHANNEL_STABILITY,
+  debugLogger,
+  getChannelFromVersion,
+  isGitRepository
+} from "./chunk-PN5LGMOT.js";
+
+// packages/cli/src/utils/installationInfo.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as childProcess from "node:child_process";
+import process2 from "node:process";
+var isDevelopment = process2.env["NODE_ENV"] === "development";
+function getInstallationInfo(projectRoot, isAutoUpdateEnabled) {
+  const cliPath = process2.argv[1];
+  if (!cliPath) {
+    return { packageManager: "unknown" /* UNKNOWN */, isGlobal: false };
+  }
+  try {
+    if (process2.env["IS_BINARY"] === "true") {
+      return {
+        packageManager: "binary" /* BINARY */,
+        isGlobal: true,
+        updateMessage: "Running as a standalone binary. Please update by downloading the latest version from GitHub."
+      };
+    }
+    const realPath = fs.realpathSync(cliPath).replace(/\\/g, "/");
+    const normalizedProjectRoot = projectRoot?.replace(/\\/g, "/");
+    const isGit = isGitRepository(process2.cwd());
+    if (isGit && normalizedProjectRoot && realPath.startsWith(normalizedProjectRoot) && !realPath.includes("/node_modules/")) {
+      return {
+        packageManager: "unknown" /* UNKNOWN */,
+        // Not managed by a package manager in this sense
+        isGlobal: false,
+        updateMessage: 'Running from a local git clone. Please update with "git pull".'
+      };
+    }
+    if (realPath.includes("/.npm/_npx") || realPath.includes("/npm/_npx")) {
+      return {
+        packageManager: "npx" /* NPX */,
+        isGlobal: false,
+        updateMessage: "Running via npx, update not applicable."
+      };
+    }
+    if (realPath.includes("/.pnpm/_pnpx") || realPath.includes("/.cache/pnpm/dlx")) {
+      return {
+        packageManager: "pnpx" /* PNPX */,
+        isGlobal: false,
+        updateMessage: "Running via pnpx, update not applicable."
+      };
+    }
+    if (process2.platform === "darwin") {
+      try {
+        const brewPrefix = childProcess.execSync("brew --prefix gemini-cli", {
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        }).trim();
+        const brewRealPath = fs.realpathSync(brewPrefix);
+        if (realPath.startsWith(brewRealPath)) {
+          return {
+            packageManager: "homebrew" /* HOMEBREW */,
+            isGlobal: true,
+            updateMessage: 'Installed via Homebrew. Please update with "brew upgrade gemini-cli".'
+          };
+        }
+      } catch {
+      }
+    }
+    if (realPath.includes("/.volta/") || realPath.includes("/Volta/")) {
+      const updateCommand2 = "volta install @google/gemini-cli@latest";
+      return {
+        packageManager: "volta" /* VOLTA */,
+        isGlobal: true,
+        updateCommand: updateCommand2,
+        updateMessage: isAutoUpdateEnabled ? "Installed with Volta. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
+      };
+    }
+    if (realPath.includes("/.pnpm/global") || realPath.includes("/.local/share/pnpm") || realPath.includes("/Library/pnpm/global/") || realPath.includes("/AppData/Local/pnpm/global/")) {
+      const updateCommand2 = "pnpm add -g @google/gemini-cli@latest";
+      return {
+        packageManager: "pnpm" /* PNPM */,
+        isGlobal: true,
+        updateCommand: updateCommand2,
+        updateMessage: isAutoUpdateEnabled ? "Installed with pnpm. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
+      };
+    }
+    if (realPath.includes("/.yarn/global")) {
+      const updateCommand2 = "yarn global add @google/gemini-cli@latest";
+      return {
+        packageManager: "yarn" /* YARN */,
+        isGlobal: true,
+        updateCommand: updateCommand2,
+        updateMessage: isAutoUpdateEnabled ? "Installed with yarn. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
+      };
+    }
+    if (realPath.includes("/.bun/install/cache")) {
+      return {
+        packageManager: "bunx" /* BUNX */,
+        isGlobal: false,
+        updateMessage: "Running via bunx, update not applicable."
+      };
+    }
+    if (realPath.includes("/.bun/install/global")) {
+      const updateCommand2 = "bun add -g @google/gemini-cli@latest";
+      return {
+        packageManager: "bun" /* BUN */,
+        isGlobal: true,
+        updateCommand: updateCommand2,
+        updateMessage: isAutoUpdateEnabled ? "Installed with bun. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
+      };
+    }
+    if (normalizedProjectRoot && realPath.startsWith(`${normalizedProjectRoot}/node_modules`)) {
+      let pm = "npm" /* NPM */;
+      if (fs.existsSync(path.join(projectRoot, "yarn.lock"))) {
+        pm = "yarn" /* YARN */;
+      } else if (fs.existsSync(path.join(projectRoot, "pnpm-lock.yaml"))) {
+        pm = "pnpm" /* PNPM */;
+      } else if (fs.existsSync(path.join(projectRoot, "bun.lockb"))) {
+        pm = "bun" /* BUN */;
+      }
+      return {
+        packageManager: pm,
+        isGlobal: false,
+        updateMessage: "Locally installed. Please update via your project's package.json."
+      };
+    }
+    const updateCommand = "npm install -g @google/gemini-cli@latest";
+    return {
+      packageManager: "npm" /* NPM */,
+      isGlobal: true,
+      updateCommand,
+      updateMessage: isAutoUpdateEnabled ? "Installed with npm. Attempting to automatically update now..." : `Please run ${updateCommand} to update`
+    };
+  } catch (error) {
+    debugLogger.log(error);
+    return { packageManager: "unknown" /* UNKNOWN */, isGlobal: false };
+  }
+}
+
+// packages/cli/src/utils/updateEventEmitter.ts
+import { EventEmitter } from "node:events";
+var updateEventEmitter = new EventEmitter();
+
+// packages/cli/src/utils/spawnWrapper.ts
+import { spawn } from "node:child_process";
+var spawnWrapper = spawn;
+
+// packages/cli/src/utils/handleAutoUpdate.ts
+var _updateInProgress = false;
+async function waitForUpdateCompletion(timeoutMs = 3e4) {
+  if (!_updateInProgress) {
+    return;
+  }
+  debugLogger.log(
+    "\nGemini CLI is waiting for a background update to complete before restarting..."
+  );
+  return new Promise((resolve) => {
+    if (!_updateInProgress) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(cleanup, timeoutMs);
+    function cleanup() {
+      clearTimeout(timer);
+      updateEventEmitter.off("update-success", cleanup);
+      updateEventEmitter.off("update-failed", cleanup);
+      resolve();
+    }
+    updateEventEmitter.once("update-success", cleanup);
+    updateEventEmitter.once("update-failed", cleanup);
+  });
+}
+function handleAutoUpdate(info, settings, projectRoot, isSandboxEnabled, spawnFn = spawnWrapper) {
+  if (!info) {
+    return;
+  }
+  if (isSandboxEnabled) {
+    updateEventEmitter.emit("update-info", {
+      message: `${info.message}
+Automatic update is not available in sandbox mode.`
+    });
+    return;
+  }
+  if (!settings.merged.general.enableAutoUpdateNotification) {
+    return;
+  }
+  const installationInfo = getInstallationInfo(
+    projectRoot,
+    settings.merged.general.enableAutoUpdate
+  );
+  if ([
+    "npx" /* NPX */,
+    "pnpx" /* PNPX */,
+    "bunx" /* BUNX */,
+    "binary" /* BINARY */
+  ].includes(installationInfo.packageManager)) {
+    return;
+  }
+  let combinedMessage = info.message;
+  if (installationInfo.updateMessage) {
+    combinedMessage += `
+${installationInfo.updateMessage}`;
+  }
+  if (!installationInfo.updateCommand || !settings.merged.general.enableAutoUpdate) {
+    updateEventEmitter.emit("update-received", {
+      ...info,
+      message: combinedMessage,
+      isUpdating: false
+    });
+    return;
+  }
+  updateEventEmitter.emit("update-received", {
+    ...info,
+    message: combinedMessage,
+    isUpdating: true
+  });
+  if (_updateInProgress) {
+    return;
+  }
+  const currentVersion = info.update.current;
+  if (!currentVersion) {
+    debugLogger.warn(
+      "Update check: current version is missing. Skipping automatic update for safety."
+    );
+    return;
+  }
+  const currentChannel = getChannelFromVersion(currentVersion);
+  const targetChannel = getChannelFromVersion(info.update.latest);
+  if (RELEASE_CHANNEL_STABILITY[targetChannel] < RELEASE_CHANNEL_STABILITY[currentChannel]) {
+    return;
+  }
+  const isNightly = info.update.latest.includes("nightly");
+  const updateCommand = installationInfo.updateCommand.replace(
+    "@latest",
+    isNightly ? "@nightly" : `@${info.update.latest}`
+  );
+  const updateProcess = spawnFn(updateCommand, {
+    stdio: "ignore",
+    shell: true,
+    detached: true
+  });
+  _updateInProgress = true;
+  updateProcess.unref();
+  updateProcess.on("close", (code) => {
+    _updateInProgress = false;
+    if (code === 0) {
+      updateEventEmitter.emit("update-success", {
+        message: "Update successful! The new version will be used on your next run."
+      });
+    } else {
+      updateEventEmitter.emit("update-failed", {
+        message: `Automatic update failed. Please try updating manually:
+
+${updateCommand}`
+      });
+    }
+  });
+  updateProcess.on("error", (err) => {
+    _updateInProgress = false;
+    updateEventEmitter.emit("update-failed", {
+      message: `Automatic update failed. Please try updating manually. (error: ${err.message})
+
+${updateCommand}`
+    });
+  });
+  return updateProcess;
+}
+function setUpdateHandler(addItem, setUpdateInfo) {
+  let successfullyInstalled = false;
+  const handleUpdateReceived = (info) => {
+    setUpdateInfo(info);
+    const savedMessage = info.message;
+    setTimeout(() => {
+      if (!successfullyInstalled) {
+        addItem(
+          {
+            type: "info" /* INFO */,
+            text: savedMessage
+          },
+          Date.now()
+        );
+      }
+      setUpdateInfo(null);
+    }, 6e4);
+  };
+  const handleUpdateFailed = (data) => {
+    setUpdateInfo(null);
+    addItem(
+      {
+        type: "error" /* ERROR */,
+        text: data?.message || `Automatic update failed. Please try updating manually`
+      },
+      Date.now()
+    );
+  };
+  const handleUpdateSuccess = () => {
+    successfullyInstalled = true;
+    setUpdateInfo(null);
+    addItem(
+      {
+        type: "info" /* INFO */,
+        text: `Update successful! The new version will be used on your next run.`
+      },
+      Date.now()
+    );
+  };
+  const handleUpdateInfo = (data) => {
+    addItem(
+      {
+        type: "info" /* INFO */,
+        text: data.message
+      },
+      Date.now()
+    );
+  };
+  updateEventEmitter.on("update-received", handleUpdateReceived);
+  updateEventEmitter.on("update-failed", handleUpdateFailed);
+  updateEventEmitter.on("update-success", handleUpdateSuccess);
+  updateEventEmitter.on("update-info", handleUpdateInfo);
+  return () => {
+    updateEventEmitter.off("update-received", handleUpdateReceived);
+    updateEventEmitter.off("update-failed", handleUpdateFailed);
+    updateEventEmitter.off("update-success", handleUpdateSuccess);
+    updateEventEmitter.off("update-info", handleUpdateInfo);
+  };
+}
+
+// packages/cli/src/utils/processUtils.ts
+var RELAUNCH_EXIT_CODE = 199;
+var isRelaunching = false;
+async function relaunchApp() {
+  if (isRelaunching) return;
+  isRelaunching = true;
+  await waitForUpdateCompletion();
+  await runExitCleanup();
+  process.exit(RELAUNCH_EXIT_CODE);
+}
+function isStandardSea() {
+  return process.argv[0] !== process.argv[1] && (process.env["IS_BINARY"] === "true" || process.isSea?.() === true);
+}
+function getScriptArgs() {
+  return process.argv.slice(isStandardSea() ? 1 : 2);
+}
+function isSeaEnvironment() {
+  return process.env["IS_BINARY"] === "true" || process.isSea?.() === true || process.argv[0] === process.argv[1];
+}
+function getSpawnConfig(nodeArgs, scriptArgs) {
+  const isBinary = isSeaEnvironment();
+  const newEnv = {
+    ...process.env,
+    GEMINI_CLI_NO_RELAUNCH: "true"
+  };
+  const finalSpawnArgs = [];
+  if (isBinary) {
+    if (nodeArgs.length > 0) {
+      for (const arg of nodeArgs) {
+        if (/[\s"'\\]/.test(arg)) {
+          throw new Error(
+            `Unsupported node argument for SEA relaunch: ${arg}. Complex escaping is not supported.`
+          );
+        }
+      }
+      const existingNodeOptions = process.env["NODE_OPTIONS"] || "";
+      newEnv["NODE_OPTIONS"] = `${existingNodeOptions} ${nodeArgs.join(" ")}`.trim();
+    }
+    finalSpawnArgs.push(process.execPath, ...scriptArgs);
+  } else {
+    finalSpawnArgs.push(
+      ...process.execArgv,
+      ...nodeArgs,
+      process.argv[1],
+      ...scriptArgs
+    );
+  }
+  return {
+    spawnArgs: finalSpawnArgs,
+    env: newEnv
+  };
+}
+
+export {
+  isDevelopment,
+  handleAutoUpdate,
+  setUpdateHandler,
+  RELAUNCH_EXIT_CODE,
+  relaunchApp,
+  getScriptArgs,
+  getSpawnConfig
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/bundle/{chunk-7KIX5G5D.js → chunk-UMBPNYQU.js}

@@ -2,7 +2,7 @@ const require = (await import('node:module')).createRequire(import.meta.url); co
 import {
   exitCli,
   require_source
-} from "./chunk-M3EDSAPV.js";
+} from "./chunk-TREYQA4O.js";
 import {
   DEFAULT_PORT,
   SERVER_START_WAIT_MS,
@@ -14,10 +14,10 @@ import {
   isServerRunning,
   resolveGemmaConfig,
   writeServerProcessInfo
-} from "./chunk-7ZH745HC.js";
+} from "./chunk-VC3YLUFW.js";
 import {
   debugLogger
-} from "./chunk-TW47A6FW.js";
+} from "./chunk-EVYFBIGQ.js";
 import {
   __toESM
 } from "./chunk-34MYV7JD.js";

package/bundle/{chunk-7ZH745HC.js → chunk-VC3YLUFW.js}

@@ -1,6 +1,9 @@
 const require = (await import('node:module')).createRequire(import.meta.url); const __chunk_filename = (await import('node:url')).fileURLToPath(import.meta.url); const __chunk_dirname = (await import('node:path')).dirname(__chunk_filename);
 import {
   AuthProviderType,
+  AuthType,
+  CoreEvent,
+  CoreToolCallStatus,
   DEFAULT_MODEL_CONFIGS,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
   EDITOR_OPTIONS,
@@ -29,7 +32,7 @@ import {
   require_strip_json_comments,
   sanitizeFilenamePart,
   stripAnsi
-} from "./chunk-TW47A6FW.js";
+} from "./chunk-EVYFBIGQ.js";
 import {
   __commonJS,
   __require,
@@ -10176,7 +10179,11 @@ function convertSessionToHistoryFormats(messages) {
     const displayContentString = msg.displayContent ? partListUnionToString(msg.displayContent) : void 0;
     const contentString = partListUnionToString(msg.content);
     const uiText = displayContentString || contentString;
-    if (uiText.trim()) {
+    const trimmedText = uiText.trim();
+    if (trimmedText.startsWith("<session_context>") || trimmedText.startsWith("<hook_context>")) {
+      continue;
+    }
+    if (trimmedText) {
       let messageType;
       switch (msg.type) {
         case "user":
@@ -10213,7 +10220,7 @@ function convertSessionToHistoryFormats(messages) {
           args: tool.args,
           description: tool.description || "",
           renderOutputAsMarkdown: tool.renderOutputAsMarkdown ?? true,
-          status: tool.status === "success" ? "success" /* Success */ : "error" /* Error */,
+          status: tool.status === "success" ? CoreToolCallStatus.Success : CoreToolCallStatus.Error,
           resultDisplay: tool.resultDisplay,
           confirmationDetails: void 0
         }))
@@ -14551,6 +14558,15 @@ var SETTINGS_SCHEMA = {
         description: "Suitable for general coding and software development tasks.",
         showInDialog: true
       },
+      powerUserProfile: {
+        type: "boolean",
+        label: "Use the power user profile to manage agent contexts.",
+        category: "Experimental",
+        requiresRestart: true,
+        default: false,
+        description: "Less cache friendly version of the generalist profile.",
+        showInDialog: false
+      },
       contextManagement: {
         type: "boolean",
         label: "Enable Context Management",
@@ -16265,8 +16281,8 @@ var LoadedSettings = class {
   // React will pass a listener fn into this subscribe fn
   // that listener fn will perform an object identity check on the snapshot and trigger a React re render if the snapshot has changed
   subscribe(listener) {
-    coreEvents.on("settings-changed" /* SettingsChanged */, listener);
-    return () => coreEvents.off("settings-changed" /* SettingsChanged */, listener);
+    coreEvents.on(CoreEvent.SettingsChanged, listener);
+    return () => coreEvents.off(CoreEvent.SettingsChanged, listener);
   }
   getSnapshot() {
     return this._snapshot;
@@ -16327,6 +16343,47 @@ var LoadedSettings = class {
     this._remoteAdminSettings = { admin };
     this._merged = this.computeMergedSettings();
   }
+  /**
+   * Returns a consolidated list of excluded MCP servers across all settings files.
+   */
+  getConsolidatedExcludedMcpServers() {
+    const scopes = [
+      this.system,
+      this.systemDefaults,
+      this.user,
+      this.workspace
+    ];
+    return scopes.flatMap((scope) => {
+      const excluded = scope?.settings?.mcp?.excluded;
+      return Array.isArray(excluded) ? excluded : [];
+    });
+  }
+  /**
+   * Returns a consolidated list of allowed MCP servers (via intersection of all defined lists).
+   */
+  getConsolidatedAllowedMcpServers() {
+    const scopes = [
+      this.system,
+      this.systemDefaults,
+      this.user,
+      this.workspace
+    ];
+    const definedAllowlists = scopes.flatMap((scope) => {
+      const allowed = scope?.settings?.mcp?.allowed;
+      return Array.isArray(allowed) ? [allowed] : [];
+    });
+    if (definedAllowlists.length === 0) {
+      return void 0;
+    }
+    return definedAllowlists.reduce((acc, current) => {
+      const normalizedCurrent = new Set(
+        current.map((item) => item.toLowerCase().trim())
+      );
+      return acc.filter(
+        (item) => normalizedCurrent.has(item.toLowerCase().trim())
+      );
+    });
+  }
 };
 function findEnvFile(startDir, isTrusted, ignoreLocalEnv) {
   let currentDir = path3.resolve(startDir);
@@ -16369,7 +16426,7 @@ function setUpCloudShellEnvironment(envFilePath, isTrusted, isSandboxed, selecte
     }
   }
   let value = "cloudshell-gca";
-  if (selectedAuthType === "vertex-ai" /* USE_VERTEX_AI */) {
+  if (selectedAuthType === AuthType.USE_VERTEX_AI) {
     value = process2.env[USER_GCP_PROJECT];
   }
   if (envFilePath && fs4.existsSync(envFilePath)) {