@umsai/ums-code 0.0.14-v2 → 0.3.0-v1

package/dist/src/config/extension.js

@@ -3,18 +3,22 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Storage } from '@umsai/ums-code-core';
+import { QWEN_DIR, Storage, Config, ExtensionInstallEvent, ExtensionUninstallEvent, ExtensionDisableEvent, ExtensionEnableEvent, logExtensionEnable, logExtensionInstallEvent, logExtensionUninstall, logExtensionDisable, } from '@umsai/ums-code-core';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import { simpleGit } from 'simple-git';
 import { SettingScope, loadSettings } from '../config/settings.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { recursivelyHydrateStrings } from './extensions/variables.js';
-export const EXTENSIONS_DIRECTORY_NAME = path.join('.ums', 'extensions');
-export const EXTENSIONS_CONFIG_FILENAME = 'ums-extension.json';
-export const EXTENSIONS_CONFIG_FILENAME_OLD = 'qwen-extension.json';
-export const INSTALL_METADATA_FILENAME = '.ums-extension-install.json';
+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';
+export const EXTENSIONS_DIRECTORY_NAME = path.join(QWEN_DIR, 'extensions');
+export const EXTENSIONS_CONFIG_FILENAME = 'gemini-extension.json';
+export const INSTALL_METADATA_FILENAME = '.gemini-extension-install.json';
 export class ExtensionStorage {
     extensionName;
     constructor(extensionName) {
@@ -31,16 +35,20 @@ export class ExtensionStorage {
         return storage.getExtensionsDir();
     }
     static async createTmpDir() {
-        return await fs.promises.mkdtemp(path.join(os.tmpdir(), 'qwen-extension'));
+        return await fs.promises.mkdtemp(path.join(os.tmpdir(), 'ums-extension'));
     }
 }
 export function getWorkspaceExtensions(workspaceDir) {
+    // If the workspace dir is the user extensions dir, there are no workspace extensions.
+    if (path.resolve(workspaceDir) === path.resolve(os.homedir())) {
+        return [];
+    }
     return loadExtensionsFromDir(workspaceDir);
 }
-async function copyExtension(source, destination) {
+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 {
@@ -48,7 +56,7 @@ export async function performWorkspaceExtensionMigration(extensions) {
                 source: extension.path,
                 type: 'local',
             };
-            await installExtension(installMetadata);
+            await installExtension(installMetadata, requestConsent);
         }
         catch (_) {
             failedInstallNames.push(extension.config.name);
@@ -56,17 +64,31 @@ export async function performWorkspaceExtensionMigration(extensions) {
     }
     return failedInstallNames;
 }
-export function loadExtensions(workspaceDir) {
+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,
+    });
+    return config;
+}
+export function loadExtensions(extensionEnablementManager, workspaceDir = process.cwd()) {
     const settings = loadSettings(workspaceDir).merged;
-    const disabledExtensions = settings.extensions?.disabled ?? [];
     const allExtensions = [...loadUserExtensions()];
-    if (!settings.experimental?.extensionManagement) {
+    if ((isWorkspaceTrusted(settings) ?? true) &&
+        // Default management setting to true
+        !(settings.experimental?.extensionManagement ?? true)) {
         allExtensions.push(...getWorkspaceExtensions(workspaceDir));
     }
     const uniqueExtensions = new Map();
     for (const extension of allExtensions) {
         if (!uniqueExtensions.has(extension.config.name) &&
-            !disabledExtensions.includes(extension.config.name)) {
+            extensionEnablementManager.isEnabled(extension.config.name, workspaceDir)) {
             uniqueExtensions.set(extension.config.name, extension);
         }
     }
@@ -91,54 +113,74 @@ export function loadExtensionsFromDir(dir) {
     const extensions = [];
     for (const subdir of fs.readdirSync(extensionsDir)) {
         const extensionDir = path.join(extensionsDir, subdir);
-        const extension = loadExtension(extensionDir);
+        const extension = loadExtension({ extensionDir, workspaceDir: dir });
         if (extension != null) {
             extensions.push(extension);
         }
     }
     return extensions;
 }
-export function loadExtension(extensionDir) {
+export function loadExtension(context) {
+    const { extensionDir, workspaceDir } = context;
     if (!fs.statSync(extensionDir).isDirectory()) {
-        console.error(`Warning: unexpected file ${extensionDir} in extensions directory.`);
         return null;
     }
-    let configFilePath = path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME);
-    if (!fs.existsSync(configFilePath)) {
-        const oldConfigFilePath = path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME_OLD);
-        if (!fs.existsSync(oldConfigFilePath)) {
-            console.error(`Warning: extension directory ${extensionDir} does not contain a config file ${configFilePath}.`);
-            return null;
-        }
-        configFilePath = oldConfigFilePath;
+    const installMetadata = loadInstallMetadata(extensionDir);
+    let effectiveExtensionPath = extensionDir;
+    if (installMetadata?.type === 'link') {
+        effectiveExtensionPath = installMetadata.source;
     }
     try {
-        const configContent = fs.readFileSync(configFilePath, 'utf-8');
-        const config = recursivelyHydrateStrings(JSON.parse(configContent), {
-            extensionPath: extensionDir,
-            '/': 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(extensionDir, contextFileName))
+            .map((contextFileName) => path.join(effectiveExtensionPath, contextFileName))
             .filter((contextFilePath) => fs.existsSync(contextFilePath));
         return {
-            path: extensionDir,
+            path: effectiveExtensionPath,
             config,
             contextFiles,
-            installMetadata: loadInstallMetadata(extensionDir),
+            installMetadata,
         };
     }
     catch (e) {
-        console.error(`Warning: error parsing extension config in ${configFilePath}: ${getErrorMessage(e)}`);
+        console.error(`Warning: Skipping extension in ${effectiveExtensionPath}: ${getErrorMessage(e)}`);
         return null;
     }
 }
-function loadInstallMetadata(extensionDir) {
+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.config.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 {
         const configContent = fs.readFileSync(metadataFilePath, 'utf-8');
@@ -160,130 +202,287 @@ function getContextFileNames(config) {
 }
 /**
  * Returns an annotated list of extensions. If an extension is listed in enabledExtensionNames, it will be active.
- * If enabledExtensionNames is empty, an extension is active unless it is in list of disabled extensions in settings.
+ * If enabledExtensionNames is empty, an extension is active unless it is disabled.
  * @param extensions The base list of extensions.
  * @param enabledExtensionNames The names of explicitly enabled extensions.
  * @param workspaceDir The current workspace directory.
  */
-export function annotateActiveExtensions(extensions, enabledExtensionNames, workspaceDir) {
-    const settings = loadSettings(workspaceDir).merged;
-    const disabledExtensions = settings.extensions?.disabled ?? [];
-    const annotatedExtensions = [];
-    if (enabledExtensionNames.length === 0) {
-        return extensions.map((extension) => ({
-            name: extension.config.name,
-            version: extension.config.version,
-            isActive: !disabledExtensions.includes(extension.config.name),
-            path: extension.path,
-        }));
-    }
-    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,
-        }));
-    }
-    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,
+export function annotateActiveExtensions(extensions, workspaceDir, manager) {
+    manager.validateExtensionOverrides(extensions);
+    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,
+    }));
+}
+/**
+ * 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 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). Defaults to 'yes' on enter.
+ */
+async function promptForConsentNonInteractive(prompt) {
+    const readline = await import('node:readline');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(['y', ''].includes(answer.trim().toLowerCase()));
         });
-    }
-    for (const requestedName of notFoundNames) {
-        console.error(`Extension not found: ${requestedName}`);
-    }
-    return annotatedExtensions;
+    });
 }
 /**
- * Clones a Git repository to a specified local path.
- * @param gitUrl The Git URL to clone.
- * @param destination The destination path to clone the repository to.
+ * 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 cloneFromGit(gitUrl, destination) {
+async function promptForConsentInteractive(prompt, addExtensionUpdateConfirmationRequest) {
+    return await new Promise((resolve) => {
+        addExtensionUpdateConfirmationRequest({
+            prompt,
+            onConfirm: (resolvedConfirmed) => {
+                resolve(resolvedConfirmed);
+            },
+        });
+    });
+}
+export async function installExtension(installMetadata, requestConsent, cwd = process.cwd(), previousExtensionConfig) {
+    const telemetryConfig = getTelemetryConfig(cwd);
+    let newExtensionConfig = null;
+    let localSourcePath;
     try {
-        // TODO(chrstnb): Download the archive instead to avoid unnecessary .git info.
-        await simpleGit().clone(gitUrl, destination, ['--depth', '1']);
+        const settings = loadSettings(cwd).merged;
+        if (!isWorkspaceTrusted(settings)) {
+            throw new Error(`Could not install extension from untrusted folder at ${installMetadata.source}`);
+        }
+        const extensionsDir = ExtensionStorage.getUserExtensionsDir();
+        await fs.promises.mkdir(extensionsDir, { recursive: true });
+        if (!path.isAbsolute(installMetadata.source) &&
+            (installMetadata.type === 'local' || installMetadata.type === 'link')) {
+            installMetadata.source = path.resolve(cwd, installMetadata.source);
+        }
+        let tempDir;
+        if (installMetadata.type === 'git' ||
+            installMetadata.type === 'github-release') {
+            tempDir = await ExtensionStorage.createTmpDir();
+            try {
+                const result = await downloadFromGitHubRelease(installMetadata, tempDir);
+                installMetadata.type = result.type;
+                installMetadata.releaseTag = result.tagName;
+            }
+            catch (_error) {
+                await cloneFromGit(installMetadata, tempDir);
+                installMetadata.type = 'git';
+            }
+            localSourcePath = tempDir;
+        }
+        else if (installMetadata.type === 'local' ||
+            installMetadata.type === 'link') {
+            localSourcePath = installMetadata.source;
+        }
+        else {
+            throw new Error(`Unsupported install type: ${installMetadata.type}`);
+        }
+        try {
+            newExtensionConfig = loadExtensionConfig({
+                extensionDir: localSourcePath,
+                workspaceDir: cwd,
+            });
+            const newExtensionName = newExtensionConfig.name;
+            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.`);
+            }
+            await maybeRequestConsentOrFail(newExtensionConfig, requestConsent, previousExtensionConfig);
+            await fs.promises.mkdir(destinationPath, { recursive: true });
+            if (installMetadata.type === 'local' ||
+                installMetadata.type === 'git' ||
+                installMetadata.type === 'github-release') {
+                await copyExtension(localSourcePath, destinationPath);
+            }
+            const metadataString = JSON.stringify(installMetadata, null, 2);
+            const metadataPath = path.join(destinationPath, INSTALL_METADATA_FILENAME);
+            await fs.promises.writeFile(metadataPath, metadataString);
+        }
+        finally {
+            if (tempDir) {
+                await fs.promises.rm(tempDir, { recursive: true, force: true });
+            }
+        }
+        logExtensionInstallEvent(telemetryConfig, new ExtensionInstallEvent(newExtensionConfig.name, newExtensionConfig.version, installMetadata.source, 'success'));
+        enableExtension(newExtensionConfig.name, SettingScope.User);
+        return newExtensionConfig.name;
     }
     catch (error) {
-        throw new Error(`Failed to clone Git repository from ${gitUrl}`, {
-            cause: error,
-        });
+        // Attempt to load config from the source path even if installation fails
+        // to get the name and version for logging.
+        if (!newExtensionConfig && localSourcePath) {
+            try {
+                newExtensionConfig = loadExtensionConfig({
+                    extensionDir: localSourcePath,
+                    workspaceDir: cwd,
+                });
+            }
+            catch {
+                // Ignore error, this is just for logging.
+            }
+        }
+        logExtensionInstallEvent(telemetryConfig, new ExtensionInstallEvent(newExtensionConfig?.name ?? '', newExtensionConfig?.version ?? '', installMetadata.source, 'error'));
+        throw error;
     }
 }
-export async function installExtension(installMetadata, cwd = process.cwd()) {
-    const extensionsDir = ExtensionStorage.getUserExtensionsDir();
-    await fs.promises.mkdir(extensionsDir, { recursive: true });
-    // Convert relative paths to absolute paths for the metadata file.
-    if (installMetadata.type === 'local' &&
-        !path.isAbsolute(installMetadata.source)) {
-        installMetadata.source = path.resolve(cwd, installMetadata.source);
+/**
+ * Builds a consent string for installing an extension based on it's
+ * extensionConfig.
+ */
+function extensionConsentString(extensionConfig) {
+    const output = [];
+    const mcpServerEntries = Object.entries(extensionConfig.mcpServers || {});
+    output.push(`Installing extension "${extensionConfig.name}".`);
+    output.push('**Extensions may introduce unexpected behavior. Ensure you have investigated the extension source and trust the author.**');
+    if (mcpServerEntries.length) {
+        output.push('This extension will run the following MCP servers:');
+        for (const [key, mcpServer] of mcpServerEntries) {
+            const isLocal = !!mcpServer.command;
+            const source = mcpServer.httpUrl ??
+                `${mcpServer.command || ''}${mcpServer.args ? ' ' + mcpServer.args.join(' ') : ''}`;
+            output.push(`  * ${key} (${isLocal ? 'local' : 'remote'}): ${source}`);
+        }
     }
-    let localSourcePath;
-    let tempDir;
-    if (installMetadata.type === 'git') {
-        tempDir = await ExtensionStorage.createTmpDir();
-        await cloneFromGit(installMetadata.source, tempDir);
-        localSourcePath = tempDir;
+    if (extensionConfig.contextFileName) {
+        output.push(`This extension will append info to your UMS.md context using ${extensionConfig.contextFileName}`);
     }
-    else {
-        localSourcePath = installMetadata.source;
+    if (extensionConfig.excludeTools) {
+        output.push(`This extension will exclude the following core tools: ${extensionConfig.excludeTools}`);
     }
-    let newExtensionName;
-    try {
-        const newExtension = loadExtension(localSourcePath);
-        if (!newExtension) {
-            throw new Error(`Invalid extension at ${installMetadata.source}. Please make sure it has a valid qwen-extension.json file.`);
-        }
-        // ~/.ums/extensions/{ExtensionConfig.name}.
-        newExtensionName = newExtension.config.name;
-        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.`);
+    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;
         }
-        await copyExtension(localSourcePath, destinationPath);
-        const metadataString = JSON.stringify(installMetadata, null, 2);
-        const metadataPath = path.join(destinationPath, INSTALL_METADATA_FILENAME);
-        await fs.promises.writeFile(metadataPath, metadataString);
-    }
-    finally {
-        if (tempDir) {
-            await fs.promises.rm(tempDir, { recursive: true, force: true });
+    }
+    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 function loadExtensionConfig(context) {
+    const { extensionDir, workspaceDir } = context;
+    const configFilePath = path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME);
+    if (!fs.existsSync(configFilePath)) {
+        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,
+            workspacePath: workspaceDir,
+            '/': path.sep,
+            pathSeparator: path.sep,
+        });
+        if (!config.name || !config.version) {
+            throw new Error(`Invalid configuration in ${configFilePath}: missing ${!config.name ? '"name"' : '"version"'}`);
         }
+        validateName(config.name);
+        return config;
+    }
+    catch (e) {
+        throw new Error(`Failed to load extension config from ${configFilePath}: ${getErrorMessage(e)}`);
     }
-    return newExtensionName;
 }
-export async function uninstallExtension(extensionName, cwd = process.cwd()) {
+export async function uninstallExtension(extensionIdentifier, cwd = process.cwd()) {
+    const telemetryConfig = getTelemetryConfig(cwd);
     const installedExtensions = loadUserExtensions();
-    if (!installedExtensions.some((installed) => installed.config.name === extensionName)) {
-        throw new Error(`Extension "${extensionName}" not found.`);
-    }
-    removeFromDisabledExtensions(extensionName, [SettingScope.User, SettingScope.Workspace], cwd);
+    const extensionName = installedExtensions.find((installed) => installed.config.name.toLowerCase() ===
+        extensionIdentifier.toLowerCase() ||
+        installed.installMetadata?.source.toLowerCase() ===
+            extensionIdentifier.toLowerCase())?.config.name;
+    if (!extensionName) {
+        throw new Error(`Extension not found.`);
+    }
+    const manager = new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir(), [extensionName]);
+    manager.remove(extensionName);
     const storage = new ExtensionStorage(extensionName);
-    return await fs.promises.rm(storage.getExtensionDir(), {
+    await fs.promises.rm(storage.getExtensionDir(), {
         recursive: true,
         force: true,
     });
+    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.config.name, os.homedir());
+    const workspaceEnabled = manager.isEnabled(extension.config.name, workspaceDir);
+    const status = workspaceEnabled ? chalk.green('✓') : chalk.red('✗');
+    let output = `${status} ${extension.config.name} (${extension.config.version})`;
     output += `\n Path: ${extension.path}`;
     if (extension.installMetadata) {
-        output += `\n Source: ${extension.installMetadata.source}`;
+        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) => {
@@ -304,74 +503,32 @@ export function toOutputString(extension) {
     }
     return output;
 }
-export async function updateExtension(extensionName, cwd = process.cwd()) {
-    const installedExtensions = loadUserExtensions();
-    const extension = installedExtensions.find((installed) => installed.config.name === extensionName);
-    if (!extension) {
-        throw new Error(`Extension "${extensionName}" not found. Run gemini extensions list to see available extensions.`);
-    }
-    if (!extension.installMetadata) {
-        throw new Error(`Extension cannot be updated because it is missing the .ums-extension.install.json file. To update manually, uninstall and then reinstall the updated version.`);
-    }
-    const originalVersion = extension.config.version;
-    const tempDir = await ExtensionStorage.createTmpDir();
-    try {
-        await copyExtension(extension.path, tempDir);
-        await uninstallExtension(extensionName, cwd);
-        await installExtension(extension.installMetadata, cwd);
-        const updatedExtension = loadExtension(extension.path);
-        if (!updatedExtension) {
-            throw new Error('Updated extension not found after installation.');
-        }
-        const updatedVersion = updatedExtension.config.version;
-        return {
-            originalVersion,
-            updatedVersion,
-        };
-    }
-    catch (e) {
-        console.error(`Error updating extension, rolling back. ${getErrorMessage(e)}`);
-        await copyExtension(tempDir, extension.path);
-        throw e;
-    }
-    finally {
-        await fs.promises.rm(tempDir, { recursive: true, force: true });
-    }
-}
 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 settings = loadSettings(cwd);
-    const settingsFile = settings.forScope(scope);
-    const extensionSettings = settingsFile.settings.extensions || {
-        disabled: [],
-    };
-    const disabledExtensions = extensionSettings.disabled || [];
-    if (!disabledExtensions.includes(name)) {
-        disabledExtensions.push(name);
-        extensionSettings.disabled = disabledExtensions;
-        settings.setValue(scope, 'extensions', extensionSettings);
+    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, scopes) {
-    removeFromDisabledExtensions(name, scopes);
-}
-/**
- * Removes an extension from the list of disabled extensions.
- * @param name The name of the extension to remove.
- * @param scope The scopes to remove the name from.
- */
-function removeFromDisabledExtensions(name, scopes, cwd = process.cwd()) {
-    const settings = loadSettings(cwd);
-    for (const scope of scopes) {
-        const settingsFile = settings.forScope(scope);
-        const extensionSettings = settingsFile.settings.extensions || {
-            disabled: [],
-        };
-        const disabledExtensions = extensionSettings.disabled || [];
-        extensionSettings.disabled = disabledExtensions.filter((extension) => extension !== name);
-        settings.setValue(scope, 'extensions', extensionSettings);
+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