@google/gemini-cli 0.0.8999999 → 0.0.77777773

package/dist/src/config/extension.js

@@ -3,18 +3,20 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { GEMINI_DIR, Storage, ClearcutLogger, Config, ExtensionInstallEvent, ExtensionUninstallEvent, } from '@google/gemini-cli-core';
+import { GEMINI_DIR, Storage, Config, ExtensionInstallEvent, ExtensionUninstallEvent, ExtensionUpdateEvent, ExtensionDisableEvent, ExtensionEnableEvent, logExtensionEnable, logExtensionInstallEvent, logExtensionUninstall, logExtensionUpdateEvent, logExtensionDisable, } from '@google/gemini-cli-core';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import { SettingScope, loadSettings } from '../config/settings.js';
 import { getErrorMessage } from '../utils/errors.js';
-import { recursivelyHydrateStrings } from './extensions/variables.js';
+import { recursivelyHydrateStrings, } from './extensions/variables.js';
 import { isWorkspaceTrusted } from './trustedFolders.js';
 import { resolveEnvVarsInObject } from '../utils/envVarResolver.js';
 import { randomUUID } from 'node:crypto';
 import { cloneFromGit, downloadFromGitHubRelease, } from './extensions/github.js';
 import { ExtensionEnablementManager } from './extensions/extensionEnablement.js';
+import chalk from 'chalk';
+import { escapeAnsiCtrlCodes } from '../ui/utils/textUtils.js';
 export const EXTENSIONS_DIRECTORY_NAME = path.join(GEMINI_DIR, 'extensions');
 export const EXTENSIONS_CONFIG_FILENAME = 'gemini-extension.json';
 export const INSTALL_METADATA_FILENAME = '.gemini-extension-install.json';
@@ -47,7 +49,7 @@ export function getWorkspaceExtensions(workspaceDir) {
 export async function copyExtension(source, destination) {
     await fs.promises.cp(source, destination, { recursive: true });
 }
-export async function performWorkspaceExtensionMigration(extensions) {
+export async function performWorkspaceExtensionMigration(extensions, requestConsent) {
     const failedInstallNames = [];
     for (const extension of extensions) {
         try {
@@ -55,39 +57,40 @@ export async function performWorkspaceExtensionMigration(extensions) {
                 source: extension.path,
                 type: 'local',
             };
-            await installExtension(installMetadata);
+            await installOrUpdateExtension(installMetadata, requestConsent);
         }
         catch (_) {
-            failedInstallNames.push(extension.config.name);
+            failedInstallNames.push(extension.name);
         }
     }
     return failedInstallNames;
 }
-function getClearcutLogger(cwd) {
+function getTelemetryConfig(cwd) {
+    const settings = loadSettings(cwd);
     const config = new Config({
+        telemetry: settings.merged.telemetry,
+        interactive: false,
         sessionId: randomUUID(),
         targetDir: cwd,
         cwd,
         model: '',
         debugMode: false,
     });
-    const logger = ClearcutLogger.getInstance(config);
-    return logger;
+    return config;
 }
-export function loadExtensions(workspaceDir = process.cwd()) {
+export function loadExtensions(extensionEnablementManager, workspaceDir = process.cwd()) {
     const settings = loadSettings(workspaceDir).merged;
     const allExtensions = [...loadUserExtensions()];
-    if ((isWorkspaceTrusted(settings) ?? true) &&
+    if (isWorkspaceTrusted(settings).isTrusted &&
         // Default management setting to true
         !(settings.experimental?.extensionManagement ?? true)) {
         allExtensions.push(...getWorkspaceExtensions(workspaceDir));
     }
     const uniqueExtensions = new Map();
-    const manager = new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir());
     for (const extension of allExtensions) {
-        if (!uniqueExtensions.has(extension.config.name) &&
-            manager.isEnabled(extension.config.name, workspaceDir)) {
-            uniqueExtensions.set(extension.config.name, extension);
+        if (!uniqueExtensions.has(extension.name) &&
+            extensionEnablementManager.isEnabled(extension.name, workspaceDir)) {
+            uniqueExtensions.set(extension.name, extension);
         }
     }
     return Array.from(uniqueExtensions.values());
@@ -96,8 +99,8 @@ export function loadUserExtensions() {
     const userExtensions = loadExtensionsFromDir(os.homedir());
     const uniqueExtensions = new Map();
     for (const extension of userExtensions) {
-        if (!uniqueExtensions.has(extension.config.name)) {
-            uniqueExtensions.set(extension.config.name, extension);
+        if (!uniqueExtensions.has(extension.name)) {
+            uniqueExtensions.set(extension.name, extension);
         }
     }
     return Array.from(uniqueExtensions.values());
@@ -128,39 +131,59 @@ export function loadExtension(context) {
     if (installMetadata?.type === 'link') {
         effectiveExtensionPath = installMetadata.source;
     }
-    const configFilePath = path.join(effectiveExtensionPath, EXTENSIONS_CONFIG_FILENAME);
-    if (!fs.existsSync(configFilePath)) {
-        console.error(`Warning: extension directory ${effectiveExtensionPath} does not contain a config file ${configFilePath}.`);
-        return null;
-    }
     try {
-        const configContent = fs.readFileSync(configFilePath, 'utf-8');
-        let config = recursivelyHydrateStrings(JSON.parse(configContent), {
-            extensionPath: extensionDir,
-            workspacePath: workspaceDir,
-            '/': path.sep,
-            pathSeparator: path.sep,
+        let config = loadExtensionConfig({
+            extensionDir: effectiveExtensionPath,
+            workspaceDir,
         });
-        if (!config.name || !config.version) {
-            console.error(`Invalid extension config in ${configFilePath}: missing name or version.`);
-            return null;
-        }
         config = resolveEnvVarsInObject(config);
+        if (config.mcpServers) {
+            config.mcpServers = Object.fromEntries(Object.entries(config.mcpServers).map(([key, value]) => [
+                key,
+                filterMcpConfig(value),
+            ]));
+        }
         const contextFiles = getContextFileNames(config)
             .map((contextFileName) => path.join(effectiveExtensionPath, contextFileName))
             .filter((contextFilePath) => fs.existsSync(contextFilePath));
         return {
+            name: config.name,
+            version: config.version,
             path: effectiveExtensionPath,
-            config,
             contextFiles,
             installMetadata,
+            mcpServers: config.mcpServers,
+            excludeTools: config.excludeTools,
+            isActive: true, // Barring any other signals extensions should be considered Active.
         };
     }
     catch (e) {
-        console.error(`Warning: error parsing extension config in ${configFilePath}: ${getErrorMessage(e)}`);
+        console.error(`Warning: Skipping extension in ${effectiveExtensionPath}: ${getErrorMessage(e)}`);
         return null;
     }
 }
+export function loadExtensionByName(name, workspaceDir = process.cwd()) {
+    const userExtensionsDir = ExtensionStorage.getUserExtensionsDir();
+    if (!fs.existsSync(userExtensionsDir)) {
+        return null;
+    }
+    for (const subdir of fs.readdirSync(userExtensionsDir)) {
+        const extensionDir = path.join(userExtensionsDir, subdir);
+        if (!fs.statSync(extensionDir).isDirectory()) {
+            continue;
+        }
+        const extension = loadExtension({ extensionDir, workspaceDir });
+        if (extension && extension.name.toLowerCase() === name.toLowerCase()) {
+            return extension;
+        }
+    }
+    return null;
+}
+function filterMcpConfig(original) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { trust, ...rest } = original;
+    return Object.freeze(rest);
+}
 export function loadInstallMetadata(extensionDir) {
     const metadataFilePath = path.join(extensionDir, INSTALL_METADATA_FILENAME);
     try {
@@ -188,55 +211,48 @@ function getContextFileNames(config) {
  * @param enabledExtensionNames The names of explicitly enabled extensions.
  * @param workspaceDir The current workspace directory.
  */
-export function annotateActiveExtensions(extensions, enabledExtensionNames, workspaceDir) {
-    const manager = new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir());
-    const annotatedExtensions = [];
-    if (enabledExtensionNames.length === 0) {
-        return extensions.map((extension) => ({
-            name: extension.config.name,
-            version: extension.config.version,
-            isActive: manager.isEnabled(extension.config.name, workspaceDir),
-            path: extension.path,
-            installMetadata: extension.installMetadata,
-        }));
-    }
-    const lowerCaseEnabledExtensions = new Set(enabledExtensionNames.map((e) => e.trim().toLowerCase()));
-    if (lowerCaseEnabledExtensions.size === 1 &&
-        lowerCaseEnabledExtensions.has('none')) {
-        return extensions.map((extension) => ({
-            name: extension.config.name,
-            version: extension.config.version,
-            isActive: false,
-            path: extension.path,
-            installMetadata: extension.installMetadata,
-        }));
-    }
-    const notFoundNames = new Set(lowerCaseEnabledExtensions);
-    for (const extension of extensions) {
-        const lowerCaseName = extension.config.name.toLowerCase();
-        const isActive = lowerCaseEnabledExtensions.has(lowerCaseName);
-        if (isActive) {
-            notFoundNames.delete(lowerCaseName);
-        }
-        annotatedExtensions.push({
-            name: extension.config.name,
-            version: extension.config.version,
-            isActive,
-            path: extension.path,
-            installMetadata: extension.installMetadata,
-        });
-    }
-    for (const requestedName of notFoundNames) {
-        console.error(`Extension not found: ${requestedName}`);
-    }
-    return annotatedExtensions;
+export function annotateActiveExtensions(extensions, workspaceDir, manager) {
+    manager.validateExtensionOverrides(extensions);
+    return extensions.map((extension) => ({
+        ...extension,
+        isActive: manager.isEnabled(extension.name, workspaceDir),
+    }));
+}
+/**
+ * Requests consent from the user to perform an action, by reading a Y/n
+ * character from stdin.
+ *
+ * This should not be called from interactive mode as it will break the CLI.
+ *
+ * @param consentDescription The description of the thing they will be consenting to.
+ * @returns boolean, whether they consented or not.
+ */
+export async function requestConsentNonInteractive(consentDescription) {
+    console.info(consentDescription);
+    const result = await promptForConsentNonInteractive('Do you want to continue? [Y/n]: ');
+    return result;
+}
+/**
+ * Requests consent from the user to perform an action, in interactive mode.
+ *
+ * This should not be called from non-interactive mode as it will not work.
+ *
+ * @param consentDescription The description of the thing they will be consenting to.
+ * @param setExtensionUpdateConfirmationRequest A function to actually add a prompt to the UI.
+ * @returns boolean, whether they consented or not.
+ */
+export async function requestConsentInteractive(consentDescription, addExtensionUpdateConfirmationRequest) {
+    return await promptForConsentInteractive(consentDescription + '\n\nDo you want to continue?', addExtensionUpdateConfirmationRequest);
 }
 /**
- * Asks users a prompt and awaits for a y/n response
+ * Asks users a prompt and awaits for a y/n response on stdin.
+ *
+ * This should not be called from interactive mode as it will break the CLI.
+ *
  * @param prompt A yes/no prompt to ask the user
- * @returns Whether or not the user answers 'y' (yes)
+ * @returns Whether or not the user answers 'y' (yes). Defaults to 'yes' on enter.
  */
-async function promptForContinuation(prompt) {
+async function promptForConsentNonInteractive(prompt) {
     const readline = await import('node:readline');
     const rl = readline.createInterface({
         input: process.stdin,
@@ -245,17 +261,37 @@ async function promptForContinuation(prompt) {
     return new Promise((resolve) => {
         rl.question(prompt, (answer) => {
             rl.close();
-            resolve(answer.toLowerCase() === 'y');
+            resolve(['y', ''].includes(answer.trim().toLowerCase()));
         });
     });
 }
-export async function installExtension(installMetadata, askConsent = false, cwd = process.cwd()) {
-    const logger = getClearcutLogger(cwd);
+/**
+ * Asks users an interactive yes/no prompt.
+ *
+ * This should not be called from non-interactive mode as it will break the CLI.
+ *
+ * @param prompt A markdown prompt to ask the user
+ * @param setExtensionUpdateConfirmationRequest Function to update the UI state with the confirmation request.
+ * @returns Whether or not the user answers yes.
+ */
+async function promptForConsentInteractive(prompt, addExtensionUpdateConfirmationRequest) {
+    return await new Promise((resolve) => {
+        addExtensionUpdateConfirmationRequest({
+            prompt,
+            onConfirm: (resolvedConfirmed) => {
+                resolve(resolvedConfirmed);
+            },
+        });
+    });
+}
+export async function installOrUpdateExtension(installMetadata, requestConsent, cwd = process.cwd(), previousExtensionConfig) {
+    const isUpdate = !!previousExtensionConfig;
+    const telemetryConfig = getTelemetryConfig(cwd);
     let newExtensionConfig = null;
     let localSourcePath;
     try {
         const settings = loadSettings(cwd).merged;
-        if (!isWorkspaceTrusted(settings)) {
+        if (!isWorkspaceTrusted(settings).isTrusted) {
             throw new Error(`Could not install extension from untrusted folder at ${installMetadata.source}`);
         }
         const extensionsDir = ExtensionStorage.getUserExtensionsDir();
@@ -269,9 +305,9 @@ export async function installExtension(installMetadata, askConsent = false, cwd
             installMetadata.type === 'github-release') {
             tempDir = await ExtensionStorage.createTmpDir();
             try {
-                const tagName = await downloadFromGitHubRelease(installMetadata, tempDir);
-                updateExtensionVersion(tempDir, tagName);
-                installMetadata.type = 'github-release';
+                const result = await downloadFromGitHubRelease(installMetadata, tempDir);
+                installMetadata.type = result.type;
+                installMetadata.releaseTag = result.tagName;
             }
             catch (_error) {
                 await cloneFromGit(installMetadata, tempDir);
@@ -287,22 +323,22 @@ export async function installExtension(installMetadata, askConsent = false, cwd
             throw new Error(`Unsupported install type: ${installMetadata.type}`);
         }
         try {
-            newExtensionConfig = await loadExtensionConfig({
+            newExtensionConfig = loadExtensionConfig({
                 extensionDir: localSourcePath,
                 workspaceDir: cwd,
             });
-            if (!newExtensionConfig) {
-                throw new Error(`Invalid extension at ${installMetadata.source}. Please make sure it has a valid gemini-extension.json file.`);
-            }
             const newExtensionName = newExtensionConfig.name;
+            if (!isUpdate) {
+                const installedExtensions = loadUserExtensions();
+                if (installedExtensions.some((installed) => installed.name === newExtensionName)) {
+                    throw new Error(`Extension "${newExtensionName}" is already installed. Please uninstall it first.`);
+                }
+            }
+            await maybeRequestConsentOrFail(newExtensionConfig, requestConsent, previousExtensionConfig);
             const extensionStorage = new ExtensionStorage(newExtensionName);
             const destinationPath = extensionStorage.getExtensionDir();
-            const installedExtensions = loadUserExtensions();
-            if (installedExtensions.some((installed) => installed.config.name === newExtensionName)) {
-                throw new Error(`Extension "${newExtensionName}" is already installed. Please uninstall it first.`);
-            }
-            if (askConsent) {
-                await requestConsent(newExtensionConfig);
+            if (isUpdate) {
+                await uninstallExtension(newExtensionName, isUpdate, cwd);
             }
             await fs.promises.mkdir(destinationPath, { recursive: true });
             if (installMetadata.type === 'local' ||
@@ -319,132 +355,203 @@ export async function installExtension(installMetadata, askConsent = false, cwd
                 await fs.promises.rm(tempDir, { recursive: true, force: true });
             }
         }
-        logger?.logExtensionInstallEvent(new ExtensionInstallEvent(newExtensionConfig.name, newExtensionConfig.version, installMetadata.source, 'success'));
-        enableExtension(newExtensionConfig.name, SettingScope.User);
+        if (isUpdate) {
+            logExtensionUpdateEvent(telemetryConfig, new ExtensionUpdateEvent(newExtensionConfig.name, newExtensionConfig.version, previousExtensionConfig.version, installMetadata.source, 'success'));
+        }
+        else {
+            logExtensionInstallEvent(telemetryConfig, new ExtensionInstallEvent(newExtensionConfig.name, newExtensionConfig.version, installMetadata.source, 'success'));
+            enableExtension(newExtensionConfig.name, SettingScope.User);
+        }
         return newExtensionConfig.name;
     }
     catch (error) {
         // Attempt to load config from the source path even if installation fails
         // to get the name and version for logging.
         if (!newExtensionConfig && localSourcePath) {
-            newExtensionConfig = await loadExtensionConfig({
-                extensionDir: localSourcePath,
-                workspaceDir: cwd,
-            });
+            try {
+                newExtensionConfig = loadExtensionConfig({
+                    extensionDir: localSourcePath,
+                    workspaceDir: cwd,
+                });
+            }
+            catch {
+                // Ignore error, this is just for logging.
+            }
+        }
+        if (isUpdate) {
+            logExtensionUpdateEvent(telemetryConfig, new ExtensionUpdateEvent(newExtensionConfig?.name ?? previousExtensionConfig.name, newExtensionConfig?.version ?? '', previousExtensionConfig.version, installMetadata.source, 'error'));
+        }
+        else {
+            logExtensionInstallEvent(telemetryConfig, new ExtensionInstallEvent(newExtensionConfig?.name ?? '', newExtensionConfig?.version ?? '', installMetadata.source, 'error'));
         }
-        logger?.logExtensionInstallEvent(new ExtensionInstallEvent(newExtensionConfig?.name ?? '', newExtensionConfig?.version ?? '', installMetadata.source, 'error'));
         throw error;
     }
 }
-async function updateExtensionVersion(extensionDir, extensionVersion) {
-    const configFilePath = path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME);
-    if (fs.existsSync(configFilePath)) {
-        const configContent = await fs.promises.readFile(configFilePath, 'utf-8');
-        const config = JSON.parse(configContent);
-        config.version = extensionVersion;
-        await fs.promises.writeFile(configFilePath, JSON.stringify(config, null, 2));
-    }
-}
-async function requestConsent(extensionConfig) {
-    const mcpServerEntries = Object.entries(extensionConfig.mcpServers || {});
+/**
+ * Builds a consent string for installing an extension based on it's
+ * extensionConfig.
+ */
+function extensionConsentString(extensionConfig) {
+    const sanitizedConfig = escapeAnsiCtrlCodes(extensionConfig);
+    const output = [];
+    const mcpServerEntries = Object.entries(sanitizedConfig.mcpServers || {});
+    output.push(`Installing extension "${sanitizedConfig.name}".`);
+    output.push('**Extensions may introduce unexpected behavior. Ensure you have investigated the extension source and trust the author.**');
     if (mcpServerEntries.length) {
-        console.info('This extension will run the following MCP servers: ');
+        output.push('This extension will run the following MCP servers:');
         for (const [key, mcpServer] of mcpServerEntries) {
             const isLocal = !!mcpServer.command;
-            console.info(`  * ${key} (${isLocal ? 'local' : 'remote'}): ${mcpServer.description}`);
+            const source = mcpServer.httpUrl ??
+                `${mcpServer.command || ''}${mcpServer.args ? ' ' + mcpServer.args.join(' ') : ''}`;
+            output.push(`  * ${key} (${isLocal ? 'local' : 'remote'}): ${source}`);
         }
-        console.info('The extension will append info to your gemini.md context');
-        const shouldContinue = await promptForContinuation('Do you want to continue? (y/n): ');
-        if (!shouldContinue) {
-            throw new Error('Installation cancelled by user.');
+    }
+    if (sanitizedConfig.contextFileName) {
+        output.push(`This extension will append info to your gemini.md context using ${sanitizedConfig.contextFileName}`);
+    }
+    if (sanitizedConfig.excludeTools) {
+        output.push(`This extension will exclude the following core tools: ${sanitizedConfig.excludeTools}`);
+    }
+    return output.join('\n');
+}
+/**
+ * Requests consent from the user to install an extension (extensionConfig), if
+ * there is any difference between the consent string for `extensionConfig` and
+ * `previousExtensionConfig`.
+ *
+ * Always requests consent if previousExtensionConfig is null.
+ *
+ * Throws if the user does not consent.
+ */
+async function maybeRequestConsentOrFail(extensionConfig, requestConsent, previousExtensionConfig) {
+    const extensionConsent = extensionConsentString(extensionConfig);
+    if (previousExtensionConfig) {
+        const previousExtensionConsent = extensionConsentString(previousExtensionConfig);
+        if (previousExtensionConsent === extensionConsent) {
+            return;
         }
     }
+    if (!(await requestConsent(extensionConsent))) {
+        throw new Error(`Installation cancelled for "${extensionConfig.name}".`);
+    }
+}
+export function validateName(name) {
+    if (!/^[a-zA-Z0-9-]+$/.test(name)) {
+        throw new Error(`Invalid extension name: "${name}". Only letters (a-z, A-Z), numbers (0-9), and dashes (-) are allowed.`);
+    }
 }
-export async function loadExtensionConfig(context) {
+export function loadExtensionConfig(context) {
     const { extensionDir, workspaceDir } = context;
     const configFilePath = path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME);
     if (!fs.existsSync(configFilePath)) {
-        return null;
+        throw new Error(`Configuration file not found at ${configFilePath}`);
     }
     try {
         const configContent = fs.readFileSync(configFilePath, 'utf-8');
-        const config = recursivelyHydrateStrings(JSON.parse(configContent), {
-            extensionPath: extensionDir,
+        const rawConfig = JSON.parse(configContent);
+        if (!rawConfig.name || !rawConfig.version) {
+            throw new Error(`Invalid configuration in ${configFilePath}: missing ${!rawConfig.name ? '"name"' : '"version"'}`);
+        }
+        const installDir = new ExtensionStorage(rawConfig.name).getExtensionDir();
+        const config = recursivelyHydrateStrings(rawConfig, {
+            extensionPath: installDir,
             workspacePath: workspaceDir,
             '/': path.sep,
             pathSeparator: path.sep,
         });
-        if (!config.name || !config.version) {
-            return null;
-        }
+        validateName(config.name);
         return config;
     }
-    catch (_) {
-        return null;
+    catch (e) {
+        throw new Error(`Failed to load extension config from ${configFilePath}: ${getErrorMessage(e)}`);
     }
 }
-export async function uninstallExtension(extensionIdentifier, cwd = process.cwd()) {
-    const logger = getClearcutLogger(cwd);
+export async function uninstallExtension(extensionIdentifier, isUpdate, cwd = process.cwd()) {
     const installedExtensions = loadUserExtensions();
-    const extensionName = installedExtensions.find((installed) => installed.config.name.toLowerCase() ===
-        extensionIdentifier.toLowerCase() ||
+    const extensionName = installedExtensions.find((installed) => installed.name.toLowerCase() === extensionIdentifier.toLowerCase() ||
         installed.installMetadata?.source.toLowerCase() ===
-            extensionIdentifier.toLowerCase())?.config.name;
+            extensionIdentifier.toLowerCase())?.name;
     if (!extensionName) {
         throw new Error(`Extension not found.`);
     }
-    const manager = new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir());
-    manager.remove(extensionName);
     const storage = new ExtensionStorage(extensionName);
     await fs.promises.rm(storage.getExtensionDir(), {
         recursive: true,
         force: true,
     });
-    logger?.logExtensionUninstallEvent(new ExtensionUninstallEvent(extensionName, 'success'));
+    // The rest of the cleanup below here is only for true uninstalls, not
+    // uninstalls related to updates.
+    if (isUpdate)
+        return;
+    const manager = new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir(), [extensionName]);
+    manager.remove(extensionName);
+    const telemetryConfig = getTelemetryConfig(cwd);
+    logExtensionUninstall(telemetryConfig, new ExtensionUninstallEvent(extensionName, 'success'));
 }
-export function toOutputString(extension) {
-    let output = `${extension.config.name} (${extension.config.version})`;
+export function toOutputString(extension, workspaceDir) {
+    const manager = new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir());
+    const userEnabled = manager.isEnabled(extension.name, os.homedir());
+    const workspaceEnabled = manager.isEnabled(extension.name, workspaceDir);
+    const status = workspaceEnabled ? chalk.green('✓') : chalk.red('✗');
+    let output = `${status} ${extension.name} (${extension.version})`;
     output += `\n Path: ${extension.path}`;
     if (extension.installMetadata) {
         output += `\n Source: ${extension.installMetadata.source} (Type: ${extension.installMetadata.type})`;
         if (extension.installMetadata.ref) {
             output += `\n Ref: ${extension.installMetadata.ref}`;
         }
+        if (extension.installMetadata.releaseTag) {
+            output += `\n Release tag: ${extension.installMetadata.releaseTag}`;
+        }
     }
+    output += `\n Enabled (User): ${userEnabled}`;
+    output += `\n Enabled (Workspace): ${workspaceEnabled}`;
     if (extension.contextFiles.length > 0) {
         output += `\n Context files:`;
         extension.contextFiles.forEach((contextFile) => {
             output += `\n  ${contextFile}`;
         });
     }
-    if (extension.config.mcpServers) {
+    if (extension.mcpServers) {
         output += `\n MCP servers:`;
-        Object.keys(extension.config.mcpServers).forEach((key) => {
+        Object.keys(extension.mcpServers).forEach((key) => {
             output += `\n  ${key}`;
         });
     }
-    if (extension.config.excludeTools) {
+    if (extension.excludeTools) {
         output += `\n Excluded tools:`;
-        extension.config.excludeTools.forEach((tool) => {
+        extension.excludeTools.forEach((tool) => {
             output += `\n  ${tool}`;
         });
     }
     return output;
 }
 export function disableExtension(name, scope, cwd = process.cwd()) {
+    const config = getTelemetryConfig(cwd);
     if (scope === SettingScope.System || scope === SettingScope.SystemDefaults) {
         throw new Error('System and SystemDefaults scopes are not supported.');
     }
-    const manager = new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir());
+    const extension = loadExtensionByName(name, cwd);
+    if (!extension) {
+        throw new Error(`Extension with name ${name} does not exist.`);
+    }
+    const manager = new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir(), [name]);
     const scopePath = scope === SettingScope.Workspace ? cwd : os.homedir();
     manager.disable(name, true, scopePath);
+    logExtensionDisable(config, new ExtensionDisableEvent(name, scope));
 }
 export function enableExtension(name, scope, cwd = process.cwd()) {
     if (scope === SettingScope.System || scope === SettingScope.SystemDefaults) {
         throw new Error('System and SystemDefaults scopes are not supported.');
     }
+    const extension = loadExtensionByName(name, cwd);
+    if (!extension) {
+        throw new Error(`Extension with name ${name} does not exist.`);
+    }
     const manager = new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir());
     const scopePath = scope === SettingScope.Workspace ? cwd : os.homedir();
     manager.enable(name, true, scopePath);
+    const config = getTelemetryConfig(cwd);
+    logExtensionEnable(config, new ExtensionEnableEvent(name, scope));
 }
 //# sourceMappingURL=extension.js.map