@google/gemini-cli 0.59.0-preview.0 → 0.60.0-nightly.20260905.g85aca163f

package/bundle/bundled/chrome-devtools-mcp.mjs

@@ -214893,7 +214893,7 @@ For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides
     };
     str_$n = registerUIStrings("models/crux-manager/CrUXManager.ts", UIStrings$o);
     i18nString$a = getLocalizedString.bind(void 0, str_$n);
-    CRUX_API_KEY = "AIzaSyCCSOx25vrb5z0tbedCB3_JRzzbVW6Uwgw";
+    CRUX_API_KEY = (process.env.CRUX_API_KEY || "");
     DEFAULT_ENDPOINT = `https://chromeuxreport.googleapis.com/v1/records:queryRecord?key=${CRUX_API_KEY}`;
     DEVICE_SCOPE_LIST = ["ALL", "DESKTOP", "PHONE"];
     pageScopeList = ["origin", "url"];

package/bundle/bundled/third_party/index.js

@@ -164530,7 +164530,7 @@ const UIStrings$o = {
 };
 const str_$n = registerUIStrings('models/crux-manager/CrUXManager.ts', UIStrings$o);
 const i18nString$a = getLocalizedString.bind(undefined, str_$n);
-const CRUX_API_KEY = 'AIzaSyCCSOx25vrb5z0tbedCB3_JRzzbVW6Uwgw';
+const CRUX_API_KEY = (process.env.CRUX_API_KEY || "");
 const DEFAULT_ENDPOINT = `https://chromeuxreport.googleapis.com/v1/records:queryRecord?key=${CRUX_API_KEY}`;
 let cruxManagerInstance;
 const DEVICE_SCOPE_LIST = ['ALL', 'DESKTOP', 'PHONE'];

package/bundle/{chunk-NQC3UDKG.js → chunk-3CDPEGVA.js}

@@ -5,7 +5,7 @@ import {
   isTelemetrySdkInitialized,
   resetBrowserSession,
   shutdownTelemetry
-} from "./chunk-YI5PKR5L.js";
+} from "./chunk-FIESYQDV.js";
 
 // packages/cli/src/utils/cleanup.ts
 import { promises as fs } from "node:fs";

package/bundle/{chunk-THPIH2AE.js → chunk-3MT62KJ7.js}

@@ -2,7 +2,7 @@ const require = (await import('node:module')).createRequire(import.meta.url); co
 import {
   CoreToolCallStatus,
   checkExhaustive
-} from "./chunk-52JU4ECF.js";
+} from "./chunk-M2YOG367.js";
 import {
   __commonJS,
   __toESM

package/bundle/{chunk-23C4TBLH.js → chunk-3SPYWTAG.js}

@@ -1,13 +1,13 @@
 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-7QCPYRGC.js";
+} from "./chunk-QCBXPS5K.js";
 import {
   RELEASE_CHANNEL_STABILITY,
   debugLogger,
   getChannelFromVersion,
   isGitRepository
-} from "./chunk-52JU4ECF.js";
+} from "./chunk-M2YOG367.js";
 
 // packages/cli/src/utils/installationInfo.ts
 import * as fs from "node:fs";

package/bundle/{chunk-UGT6DHAE.js → chunk-AL25HEEO.js}

@@ -2,7 +2,7 @@ const require = (await import('node:module')).createRequire(import.meta.url); co
 import {
   exitCli,
   require_source
-} from "./chunk-D6XI6WNG.js";
+} from "./chunk-FYCX7S2H.js";
 import {
   AppEvent,
   appEvents
@@ -59,14 +59,14 @@ import {
   stripUnsafeCharacters,
   toCodePoints,
   validateCustomTheme
-} from "./chunk-LXBSPQEH.js";
+} from "./chunk-JIXDRDKL.js";
 import {
   isDevelopment
-} from "./chunk-23C4TBLH.js";
+} from "./chunk-OI5WY42W.js";
 import {
   emptyIcon,
   require_react
-} from "./chunk-THPIH2AE.js";
+} from "./chunk-TVCSMCKT.js";
 import {
   ALL_EDITORS,
   ApprovalMode,
@@ -244,7 +244,7 @@ import {
   tokenLimit,
   uiTelemetryService,
   unescapePath
-} from "./chunk-52JU4ECF.js";
+} from "./chunk-AXAX7FSE.js";
 import {
   require_src
 } from "./chunk-TUDYL3X4.js";
@@ -25734,11 +25734,11 @@ var require_util4 = __commonJS({
     var { isUint8Array } = __require("node:util/types");
     var { webidl } = require_webidl();
     var supportedHashes = [];
-    var crypto2;
+    var crypto3;
     try {
-      crypto2 = __require("node:crypto");
+      crypto3 = __require("node:crypto");
       const possibleRelevantHashes = ["sha256", "sha384", "sha512"];
-      supportedHashes = crypto2.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
+      supportedHashes = crypto3.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
     } catch {
     }
     function responseURL(response) {
@@ -26041,7 +26041,7 @@ var require_util4 = __commonJS({
       return isOriginPotentiallyTrustworthy(url.origin);
     }
     function bytesMatch(bytes, metadataList) {
-      if (crypto2 === void 0) {
+      if (crypto3 === void 0) {
         return true;
       }
       const parsedMetadata = parseMetadata(metadataList);
@@ -26056,7 +26056,7 @@ var require_util4 = __commonJS({
       for (const item of metadata) {
         const algorithm = item.algo;
         const expectedValue = item.hash;
-        let actualValue = crypto2.createHash(algorithm).update(bytes).digest("base64");
+        let actualValue = crypto3.createHash(algorithm).update(bytes).digest("base64");
         if (actualValue[actualValue.length - 1] === "=") {
           if (actualValue[actualValue.length - 2] === "=") {
             actualValue = actualValue.slice(0, -2);
@@ -27074,8 +27074,8 @@ var require_body = __commonJS({
     var { multipartFormDataParser } = require_formdata_parser();
     var random;
     try {
-      const crypto2 = __require("node:crypto");
-      random = (max) => crypto2.randomInt(0, max);
+      const crypto3 = __require("node:crypto");
+      random = (max) => crypto3.randomInt(0, max);
     } catch {
       random = (max) => Math.floor(Math.random() * max);
     }
@@ -39992,13 +39992,13 @@ var require_frame = __commonJS({
     "use strict";
     var { maxUnsigned16Bit, opcodes } = require_constants7();
     var BUFFER_SIZE = 8 * 1024;
-    var crypto2;
+    var crypto3;
     var buffer = null;
     var bufIdx = BUFFER_SIZE;
     try {
-      crypto2 = __require("node:crypto");
+      crypto3 = __require("node:crypto");
     } catch {
-      crypto2 = {
+      crypto3 = {
         // not full compatibility, but minimum.
         randomFillSync: function randomFillSync(buffer2, _offset, _size) {
           for (let i = 0; i < buffer2.length; ++i) {
@@ -40011,7 +40011,7 @@ var require_frame = __commonJS({
     function generateMask() {
       if (bufIdx === BUFFER_SIZE) {
         bufIdx = 0;
-        crypto2.randomFillSync(buffer ??= Buffer.allocUnsafeSlow(BUFFER_SIZE), 0, BUFFER_SIZE);
+        crypto3.randomFillSync(buffer ??= Buffer.allocUnsafeSlow(BUFFER_SIZE), 0, BUFFER_SIZE);
       }
       return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]];
     }
@@ -40109,9 +40109,9 @@ var require_connection = __commonJS({
     var { getDecodeSplit } = require_util4();
     var { WebsocketFrameSend } = require_frame();
     var assert = __require("node:assert");
-    var crypto2;
+    var crypto3;
     try {
-      crypto2 = __require("node:crypto");
+      crypto3 = __require("node:crypto");
     } catch {
     }
     function establishWebSocketConnection(url, protocols, client, handler2, options) {
@@ -40131,7 +40131,7 @@ var require_connection = __commonJS({
         const headersList = getHeadersList(new Headers(options.headers));
         request.headersList = headersList;
       }
-      const keyValue = crypto2.randomBytes(16).toString("base64");
+      const keyValue = crypto3.randomBytes(16).toString("base64");
       request.headersList.append("sec-websocket-key", keyValue, true);
       request.headersList.append("sec-websocket-version", "13", true);
       for (const protocol of protocols) {
@@ -40164,7 +40164,7 @@ var require_connection = __commonJS({
             return;
           }
           const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
-          const digest = crypto2.createHash("sha1").update(keyValue + uid).digest("base64");
+          const digest = crypto3.createHash("sha1").update(keyValue + uid).digest("base64");
           if (secWSAccept !== digest) {
             failWebsocketConnection(handler2, 1002, "Incorrect hash received in Sec-WebSocket-Accept header.");
             return;
@@ -60865,6 +60865,7 @@ async function validateAuthMethod(authMethod) {
 }
 
 // packages/cli/src/config/extensions/consent.ts
+import * as crypto from "node:crypto";
 import * as fs9 from "node:fs/promises";
 import * as path3 from "node:path";
 var import_chalk4 = __toESM(require_source(), 1);
@@ -60934,6 +60935,27 @@ async function promptForConsentInteractive(prompt, addExtensionUpdateConfirmatio
     });
   });
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getMcpServerConfigHash(mcpServer) {
+  const plainMcpServer = isRecord(mcpServer) ? mcpServer : {};
+  const copy = { ...plainMcpServer };
+  delete copy["extension"];
+  const canonicalString = JSON.stringify(copy, (key, value) => {
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (isRecord(value)) {
+      return Object.keys(value).sort().reduce((result, k2) => {
+        result[k2] = value[k2];
+        return result;
+      }, {});
+    }
+    return value;
+  });
+  return crypto.createHash("sha256").update(canonicalString).digest("hex");
+}
 async function extensionConsentString(extensionConfig, hasHooks, skills = [], previousName, wasMigrated) {
   const sanitizedConfig = escapeAnsiCtrlCodes(extensionConfig);
   const output = [];
@@ -60961,6 +60983,83 @@ async function extensionConsentString(extensionConfig, hasHooks, skills = [], pr
       const isLocal = !!mcpServer.command;
       const source2 = mcpServer.httpUrl ?? `${mcpServer.command || ""}${mcpServer.args ? " " + mcpServer.args.join(" ") : ""}`;
       output.push(`  * ${key} (${isLocal ? "local" : "remote"}): ${source2}`);
+      if (mcpServer.cwd) {
+        output.push(`    Working directory: ${mcpServer.cwd}`);
+      }
+      if (mcpServer.env && Object.keys(mcpServer.env).length > 0) {
+        output.push("    Environment variables:");
+        const sortedEnv = Object.entries(mcpServer.env).sort(
+          ([a], [b2]) => a.localeCompare(b2)
+        );
+        for (const [envKey, envValue] of sortedEnv) {
+          const isSensitive = /token|secret|password|passwd|key|auth|credential|creds|private|cert/i.test(
+            envKey
+          );
+          const displayValue = isSensitive && envValue ? "********" : envValue ?? "";
+          output.push(`      - ${envKey}: ${displayValue}`);
+        }
+      }
+      if (mcpServer.headers && Object.keys(mcpServer.headers).length > 0) {
+        output.push("    Headers:");
+        const sortedHeaders = Object.entries(mcpServer.headers).sort(
+          ([a], [b2]) => a.localeCompare(b2)
+        );
+        for (const [headerKey, headerValue] of sortedHeaders) {
+          const isSensitive = /authorization|key|cookie|token|secret/i.test(
+            headerKey
+          );
+          const displayValue = isSensitive && headerValue ? "********" : headerValue ?? "";
+          output.push(`      - ${headerKey}: ${displayValue}`);
+        }
+      }
+      if (mcpServer.url) {
+        output.push(`    URL: ${mcpServer.url}`);
+      }
+      if (mcpServer.tcp) {
+        output.push(`    TCP: ${mcpServer.tcp}`);
+      }
+      if (mcpServer.type) {
+        output.push(`    Type: ${mcpServer.type}`);
+      }
+      if (mcpServer.timeout !== void 0) {
+        output.push(`    Timeout: ${mcpServer.timeout}`);
+      }
+      if (mcpServer.trust !== void 0) {
+        output.push(`    Trust: ${mcpServer.trust}`);
+      }
+      if (mcpServer.description) {
+        output.push(`    Description: ${mcpServer.description}`);
+      }
+      if (mcpServer.includeTools && mcpServer.includeTools.length > 0) {
+        output.push(`    Include tools: ${mcpServer.includeTools.join(", ")}`);
+      }
+      if (mcpServer.excludeTools && mcpServer.excludeTools.length > 0) {
+        output.push(`    Exclude tools: ${mcpServer.excludeTools.join(", ")}`);
+      }
+      if (mcpServer.authProviderType) {
+        output.push(`    Auth Provider Type: ${mcpServer.authProviderType}`);
+      }
+      if (mcpServer.targetAudience) {
+        output.push(`    Target Audience: ${mcpServer.targetAudience}`);
+      }
+      if (mcpServer.targetServiceAccount) {
+        output.push(
+          `    Target Service Account: ${mcpServer.targetServiceAccount}`
+        );
+      }
+      if (mcpServer.oauth) {
+        output.push("    OAuth Configuration:");
+        const sortedOauth = Object.entries(mcpServer.oauth).sort(
+          ([a], [b2]) => a.localeCompare(b2)
+        );
+        for (const [oKey, oValue] of sortedOauth) {
+          const isSensitive = /secret|token|password/i.test(oKey);
+          const valStr = Array.isArray(oValue) ? oValue.join(", ") : String(oValue ?? "");
+          const displayValue = isSensitive && valStr ? "********" : valStr;
+          output.push(`      - ${oKey}: ${displayValue}`);
+        }
+      }
+      output.push(`    Config signature: ${getMcpServerConfigHash(mcpServer)}`);
     }
   }
   if (sanitizedConfig.contextFileName) {
@@ -61576,7 +61675,7 @@ var ExtensionEnablementManager = class {
 };
 
 // packages/cli/src/config/extension-manager.ts
-import { createHash, randomUUID } from "node:crypto";
+import { createHash as createHash2, randomUUID } from "node:crypto";
 
 // packages/cli/src/config/extension.ts
 import * as fs13 from "node:fs";
@@ -65795,18 +65894,10 @@ Would you like to attempt to install via "git clone" instead?`
           }
         }
       }
-      const contextFiles = getContextFileNames(config).map((contextFileName) => {
-        const contextFilePath = path10.join(
-          effectiveExtensionPath,
-          contextFileName
-        );
-        if (!isSubpath(effectiveExtensionPath, contextFilePath)) {
-          throw new Error(
-            `Invalid context file path: "${contextFileName}". Context files must be within the extension directory.`
-          );
-        }
-        return contextFilePath;
-      }).filter((contextFilePath) => fs16.existsSync(contextFilePath));
+      const contextFiles = resolveContextFilePaths(
+        config,
+        effectiveExtensionPath
+      );
       const hydrationContext = {
         extensionPath: effectiveExtensionPath,
         workspacePath: this.workspaceDir,
@@ -65879,6 +65970,15 @@ Details: ${error.details}` : ""}`
           `[ExtensionManager] Error loading agent from ${config.name}: ${error.message}`
         );
       }
+      let plan = config.plan;
+      if (plan?.directory) {
+        if (typeof plan.directory !== "string" || path10.isAbsolute(plan.directory) || path10.win32.isAbsolute(plan.directory) || plan.directory.includes("..")) {
+          debugLogger.warn(
+            `[ExtensionManager] Invalid plan.directory in extension "${config.name}": "${plan.directory}". Relative parent navigation and absolute paths are not allowed.`
+          );
+          plan = void 0;
+        }
+      }
       return {
         name: config.name,
         version: config.version,
@@ -65901,7 +66001,7 @@ Details: ${error.details}` : ""}`
         themes: config.themes,
         rules,
         checkers,
-        plan: config.plan
+        plan
       };
     } catch (e) {
       debugLogger.error(
@@ -66156,6 +66256,69 @@ function getContextFileNames(config) {
   }
   return config.contextFileName;
 }
+function validateContextFilePath(contextFileName, effectiveExtensionPath) {
+  if (typeof contextFileName !== "string" || !contextFileName.trim()) {
+    return {
+      isValid: false,
+      errorMessage: "expected a non-empty string."
+    };
+  }
+  if (contextFileName.includes("\0")) {
+    return {
+      isValid: false,
+      errorMessage: "null bytes are not allowed."
+    };
+  }
+  if (path10.isAbsolute(contextFileName) || path10.win32.isAbsolute(contextFileName)) {
+    return {
+      isValid: false,
+      errorMessage: "Absolute paths are not allowed."
+    };
+  }
+  let decodedFileName = contextFileName;
+  try {
+    decodedFileName = decodeURIComponent(contextFileName);
+  } catch {
+    debugLogger.debug(
+      `[ExtensionManager] Could not decode URI component in contextFileName: "${contextFileName}". Proceeding with undecoded name.`
+    );
+  }
+  if (contextFileName.includes("..") || decodedFileName.includes("..")) {
+    return {
+      isValid: false,
+      errorMessage: 'Relative parent directory references ("..") are not allowed.'
+    };
+  }
+  const resolvedExtensionRoot = path10.resolve(effectiveExtensionPath);
+  const contextFilePath = path10.resolve(resolvedExtensionRoot, contextFileName);
+  if (!isSubpath(resolvedExtensionRoot, contextFilePath)) {
+    return {
+      isValid: false,
+      errorMessage: `escapes the extension directory boundary ("${resolvedExtensionRoot}").`
+    };
+  }
+  return {
+    isValid: true,
+    resolvedPath: contextFilePath
+  };
+}
+function resolveContextFilePaths(config, effectiveExtensionPath) {
+  return getContextFileNames(config).map((contextFileName) => {
+    const validation = validateContextFilePath(
+      contextFileName,
+      effectiveExtensionPath
+    );
+    if (!validation.isValid) {
+      debugLogger.warn(
+        `[ExtensionManager] Invalid contextFileName: "${contextFileName}" in extension "${config.name}". ${validation.errorMessage}`
+      );
+      return null;
+    }
+    return validation.resolvedPath;
+  }).filter(
+    (contextFilePath) => contextFilePath !== null && fs16.existsSync(contextFilePath)
+  );
+}
 function validateName(name) {
   if (!/^[a-zA-Z0-9-]+$/.test(name)) {
     throw new Error(
@@ -66200,7 +66363,7 @@ function getExtensionId(config, installMetadata) {
   return hashValue(idValue);
 }
 function hashValue(value) {
-  return createHash("sha256").update(value).digest("hex");
+  return createHash2("sha256").update(value).digest("hex");
 }
 
 // packages/cli/src/config/mcp/mcpServerEnablement.ts
@@ -66477,7 +66640,7 @@ function getDialogRestartRequiredSettings() {
     (definition) => definition.requiresRestart && definition.showInDialog !== false
   ).map((definition) => definition.key);
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function isSettingsValue(value) {
@@ -66489,7 +66652,7 @@ function isSettingsValue(value) {
 function getNestedValue(obj, path38) {
   let current = obj;
   for (const key of path38) {
-    if (!isRecord(current) || !(key in current)) {
+    if (!isRecord2(current) || !(key in current)) {
       return void 0;
     }
     current = current[key];
@@ -66556,7 +66719,7 @@ function tryParseJsonStringArray(input) {
 function tryParseJsonObject(input) {
   try {
     const parsed = JSON.parse(input);
-    if (isRecord(parsed) && !Array.isArray(parsed)) {
+    if (isRecord2(parsed) && !Array.isArray(parsed)) {
       return parsed;
     }
     return null;
@@ -67157,8 +67320,8 @@ var import_execa = __toESM(require_execa(), 1);
 
 // node_modules/crypto-random-string/index.js
 import { promisify } from "util";
-import crypto from "crypto";
-var randomBytesAsync = promisify(crypto.randomBytes);
+import crypto2 from "crypto";
+var randomBytesAsync = promisify(crypto2.randomBytes);
 var urlSafeCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~".split("");
 var numericCharacters = "0123456789".split("");
 var distinguishableCharacters = "CDEHKMPRTUWXY012458".split("");
@@ -67171,7 +67334,7 @@ var generateForCustomCharacters = (length, characters) => {
   let string = "";
   let stringLength = 0;
   while (stringLength < length) {
-    const entropy = crypto.randomBytes(entropyLength);
+    const entropy = crypto2.randomBytes(entropyLength);
     let entropyPosition = 0;
     while (entropyPosition < entropyLength && stringLength < length) {
       const entropyValue = entropy.readUInt16LE(entropyPosition);
@@ -67206,7 +67369,7 @@ var generateForCustomCharactersAsync = async (length, characters) => {
   }
   return string;
 };
-var generateRandomBytes = (byteLength, type, length) => crypto.randomBytes(byteLength).toString(type).slice(0, length);
+var generateRandomBytes = (byteLength, type, length) => crypto2.randomBytes(byteLength).toString(type).slice(0, length);
 var generateRandomBytesAsync = async (byteLength, type, length) => {
   const buffer = await randomBytesAsync(byteLength);
   return buffer.toString(type).slice(0, length);
@@ -77177,7 +77340,7 @@ var authCommand = {
 import process29 from "node:process";
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "45e486b03";
+var GIT_COMMIT_INFO = "85aca163f";
 
 // packages/cli/src/ui/utils/historyExportUtils.ts
 import * as fsPromises from "node:fs/promises";
@@ -78990,7 +79153,7 @@ var ExtensionRegistryClient = class _ExtensionRegistryClient {
     _ExtensionRegistryClient.fetchPromise = (async () => {
       try {
         if (uri.startsWith("http")) {
-          if (isPrivateIp(uri)) {
+          if (await isPrivateIp(uri)) {
             throw new Error(
               "Private IP addresses are not allowed for the extension registry."
             );
@@ -82958,7 +83121,7 @@ Use /mcp auth <server-name> to authenticate.`
         type: "info",
         text: `Starting OAuth authentication for MCP server '${serverName}'...`
       });
-      const { MCPOAuthProvider } = await import("./dist-KC5GXNU5.js");
+      const { MCPOAuthProvider } = await import("./dist-CUTV6FXO.js");
       let oauthConfig = server.oauth;
       if (!oauthConfig) {
         oauthConfig = { enabled: false };
@@ -102142,6 +102305,7 @@ export {
   configureAllExtensions,
   getFormattedSettingValue,
   ExtensionManager,
+  validateContextFilePath,
   inferInstallMetadata,
   normalizeServerId,
   canLoadServer,
@@ -102159,7 +102323,7 @@ export {
   statusCommand,
   getSettingDefinition,
   getDialogRestartRequiredSettings,
-  isRecord,
+  isRecord2 as isRecord,
   getNestedValue,
   getEffectiveValue,
   getDialogSettingKeys,