@machina.ai/cell-cli 1.11.0-rc1 → 1.13.0-rc2

package/dist/src/config/extension.test.js

@@ -7,14 +7,16 @@ import { vi } from 'vitest';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { createHash } from 'node:crypto';
-import { EXTENSIONS_CONFIG_FILENAME, ExtensionStorage, INSTALL_METADATA_FILENAME, INSTALL_WARNING_MESSAGE, disableExtension, enableExtension, installOrUpdateExtension, loadExtension, loadExtensionConfig, loadExtensions, uninstallExtension, hashValue, } from './extension.js';
-import { CELL_DIR, ExtensionUninstallEvent, ExtensionDisableEvent, ExtensionEnableEvent, } from '@google/gemini-cli-core';
-import { SettingScope } from './settings.js';
-import { isWorkspaceTrusted } from './trustedFolders.js';
+import { ExtensionUninstallEvent, ExtensionDisableEvent, ExtensionEnableEvent, KeychainTokenStorage, } from '@google/gemini-cli-core';
+import { loadSettings, SettingScope } from './settings.js';
+import { isWorkspaceTrusted, resetTrustedFoldersForTesting, } from './trustedFolders.js';
 import { createExtension } from '../test-utils/createExtension.js';
 import { ExtensionEnablementManager } from './extensions/extensionEnablement.js';
 import { join } from 'node:path';
+import { EXTENSIONS_CONFIG_FILENAME, EXTENSIONS_DIRECTORY_NAME, INSTALL_METADATA_FILENAME, } from './extensions/variables.js';
+import { hashValue, ExtensionManager } from './extension-manager.js';
+import { ExtensionStorage } from './extensions/storage.js';
+import { INSTALL_WARNING_MESSAGE } from './extensions/consent.js';
 const mockGit = {
     clone: vi.fn(),
     getRemotes: vi.fn(),
@@ -40,11 +42,12 @@ vi.mock('simple-git', () => ({
         return mockGit;
     }),
 }));
+const mockHomedir = vi.hoisted(() => vi.fn(() => '/tmp/mock-home'));
 vi.mock('os', async (importOriginal) => {
     const mockedOs = await importOriginal();
     return {
         ...mockedOs,
-        homedir: vi.fn(),
+        homedir: mockHomedir,
     };
 });
 vi.mock('./trustedFolders.js', async (importOriginal) => {
@@ -72,6 +75,13 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
         ExtensionInstallEvent: vi.fn(),
         ExtensionUninstallEvent: vi.fn(),
         ExtensionDisableEvent: vi.fn(),
+        KeychainTokenStorage: vi.fn().mockImplementation(() => ({
+            getSecret: vi.fn(),
+            setSecret: vi.fn(),
+            deleteSecret: vi.fn(),
+            listSecrets: vi.fn(),
+            isAvailable: vi.fn().mockResolvedValue(true),
+        })),
     };
 });
 vi.mock('child_process', async (importOriginal) => {
@@ -81,15 +91,43 @@ vi.mock('child_process', async (importOriginal) => {
         execSync: vi.fn(),
     };
 });
-const EXTENSIONS_DIRECTORY_NAME = path.join(CELL_DIR, 'extensions');
 describe('extension tests', () => {
     let tempHomeDir;
     let tempWorkspaceDir;
     let userExtensionsDir;
+    let extensionManager;
+    let mockRequestConsent;
+    let mockPromptForSettings;
+    let mockKeychainStorage;
+    let keychainData;
     beforeEach(() => {
+        vi.clearAllMocks();
+        keychainData = {};
+        mockKeychainStorage = {
+            getSecret: vi
+                .fn()
+                .mockImplementation(async (key) => keychainData[key] || null),
+            setSecret: vi
+                .fn()
+                .mockImplementation(async (key, value) => {
+                keychainData[key] = value;
+            }),
+            deleteSecret: vi.fn().mockImplementation(async (key) => {
+                delete keychainData[key];
+            }),
+            listSecrets: vi
+                .fn()
+                .mockImplementation(async () => Object.keys(keychainData)),
+            isAvailable: vi.fn().mockResolvedValue(true),
+        };
+        KeychainTokenStorage.mockImplementation(() => mockKeychainStorage);
         tempHomeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cell-cli-test-home-'));
         tempWorkspaceDir = fs.mkdtempSync(path.join(tempHomeDir, 'gemini-cli-test-workspace-'));
         userExtensionsDir = path.join(tempHomeDir, EXTENSIONS_DIRECTORY_NAME);
+        mockRequestConsent = vi.fn();
+        mockRequestConsent.mockResolvedValue(true);
+        mockPromptForSettings = vi.fn();
+        mockPromptForSettings.mockResolvedValue('');
         fs.mkdirSync(userExtensionsDir, { recursive: true });
         vi.mocked(os.homedir).mockReturnValue(tempHomeDir);
         vi.mocked(isWorkspaceTrusted).mockReturnValue({
@@ -97,6 +135,13 @@ describe('extension tests', () => {
             source: undefined,
         });
         vi.spyOn(process, 'cwd').mockReturnValue(tempWorkspaceDir);
+        extensionManager = new ExtensionManager({
+            workspaceDir: tempWorkspaceDir,
+            requestConsent: mockRequestConsent,
+            requestSetting: mockPromptForSettings,
+            settings: loadSettings(tempWorkspaceDir).merged,
+        });
+        resetTrustedFoldersForTesting();
     });
     afterEach(() => {
         fs.rmSync(tempHomeDir, { recursive: true, force: true });
@@ -104,7 +149,7 @@ describe('extension tests', () => {
         vi.restoreAllMocks();
     });
     describe('loadExtensions', () => {
-        it('should include extension path in loaded extension', () => {
+        it('should include extension path in loaded extension', async () => {
             const extensionDir = path.join(userExtensionsDir, 'test-extension');
             fs.mkdirSync(extensionDir, { recursive: true });
             createExtension({
@@ -112,12 +157,12 @@ describe('extension tests', () => {
                 name: 'test-extension',
                 version: '1.0.0',
             });
-            const extensions = loadExtensions(new ExtensionEnablementManager());
+            const extensions = await extensionManager.loadExtensions();
             expect(extensions).toHaveLength(1);
             expect(extensions[0].path).toBe(extensionDir);
             expect(extensions[0].name).toBe('test-extension');
         });
-        it('should load context file path when GEMINI.md is present', () => {
+        it('should load context file path when GEMINI.md is present', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'ext1',
@@ -129,7 +174,7 @@ describe('extension tests', () => {
                 name: 'ext2',
                 version: '2.0.0',
             });
-            const extensions = loadExtensions(new ExtensionEnablementManager());
+            const extensions = await extensionManager.loadExtensions();
             expect(extensions).toHaveLength(2);
             const ext1 = extensions.find((e) => e.name === 'ext1');
             const ext2 = extensions.find((e) => e.name === 'ext2');
@@ -138,7 +183,7 @@ describe('extension tests', () => {
             ]);
             expect(ext2?.contextFiles).toEqual([]);
         });
-        it('should load context file path from the extension config', () => {
+        it('should load context file path from the extension config', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'ext1',
@@ -146,14 +191,14 @@ describe('extension tests', () => {
                 addContextFile: false,
                 contextFileName: 'my-context-file.md',
             });
-            const extensions = loadExtensions(new ExtensionEnablementManager());
+            const extensions = await extensionManager.loadExtensions();
             expect(extensions).toHaveLength(1);
             const ext1 = extensions.find((e) => e.name === 'ext1');
             expect(ext1?.contextFiles).toEqual([
                 path.join(userExtensionsDir, 'ext1', 'my-context-file.md'),
             ]);
         });
-        it('should annotate disabled extensions', () => {
+        it('should annotate disabled extensions', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'disabled-extension',
@@ -164,16 +209,16 @@ describe('extension tests', () => {
                 name: 'enabled-extension',
                 version: '2.0.0',
             });
-            const manager = new ExtensionEnablementManager();
-            disableExtension('disabled-extension', SettingScope.User, manager, tempWorkspaceDir);
-            const extensions = loadExtensions(manager);
+            await extensionManager.loadExtensions();
+            await extensionManager.disableExtension('disabled-extension', SettingScope.User);
+            const extensions = extensionManager.getExtensions();
             expect(extensions).toHaveLength(2);
             expect(extensions[0].name).toBe('disabled-extension');
             expect(extensions[0].isActive).toBe(false);
             expect(extensions[1].name).toBe('enabled-extension');
             expect(extensions[1].isActive).toBe(true);
         });
-        it('should hydrate variables', () => {
+        it('should hydrate variables', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'test-extension',
@@ -186,7 +231,7 @@ describe('extension tests', () => {
                     },
                 },
             });
-            const extensions = loadExtensions(new ExtensionEnablementManager());
+            const extensions = await extensionManager.loadExtensions();
             expect(extensions).toHaveLength(1);
             const expectedCwd = path.join(userExtensionsDir, 'test-extension', 'server');
             expect(extensions[0].mcpServers?.['test-server'].cwd).toBe(expectedCwd);
@@ -199,12 +244,13 @@ describe('extension tests', () => {
                 contextFileName: 'context.md',
             });
             fs.writeFileSync(path.join(sourceExtDir, 'context.md'), 'linked context');
-            const extensionName = await installOrUpdateExtension({
+            await extensionManager.loadExtensions();
+            const extension = await extensionManager.installOrUpdateExtension({
                 source: sourceExtDir,
                 type: 'link',
-            }, async (_) => true);
-            expect(extensionName).toEqual('my-linked-extension');
-            const extensions = loadExtensions(new ExtensionEnablementManager());
+            });
+            expect(extension.name).toEqual('my-linked-extension');
+            const extensions = extensionManager.getExtensions();
             expect(extensions).toHaveLength(1);
             const linkedExt = extensions[0];
             expect(linkedExt.name).toBe('my-linked-extension');
@@ -217,7 +263,32 @@ describe('extension tests', () => {
                 path.join(sourceExtDir, 'context.md'),
             ]);
         });
-        it('should resolve environment variables in extension configuration', () => {
+        it('should hydrate ${extensionPath} correctly for linked extensions', async () => {
+            const sourceExtDir = createExtension({
+                extensionsDir: tempWorkspaceDir,
+                name: 'my-linked-extension-with-path',
+                version: '1.0.0',
+                mcpServers: {
+                    'test-server': {
+                        command: 'node',
+                        args: ['${extensionPath}${/}server${/}index.js'],
+                        cwd: '${extensionPath}${/}server',
+                    },
+                },
+            });
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'link',
+            });
+            const extensions = extensionManager.getExtensions();
+            expect(extensions).toHaveLength(1);
+            expect(extensions[0].mcpServers?.['test-server'].cwd).toBe(path.join(sourceExtDir, 'server'));
+            expect(extensions[0].mcpServers?.['test-server'].args).toEqual([
+                path.join(sourceExtDir, 'server', 'index.js'),
+            ]);
+        });
+        it('should resolve environment variables in extension configuration', async () => {
             process.env['TEST_API_KEY'] = 'test-api-key-123';
             process.env['TEST_DB_URL'] = 'postgresql://localhost:5432/testdb';
             try {
@@ -243,7 +314,7 @@ describe('extension tests', () => {
                     },
                 };
                 fs.writeFileSync(configPath, JSON.stringify(extensionConfig));
-                const extensions = loadExtensions(new ExtensionEnablementManager());
+                const extensions = await extensionManager.loadExtensions();
                 expect(extensions).toHaveLength(1);
                 const extension = extensions[0];
                 expect(extension.name).toBe('test-extension');
@@ -260,7 +331,40 @@ describe('extension tests', () => {
                 delete process.env['TEST_DB_URL'];
             }
         });
-        it('should handle missing environment variables gracefully', () => {
+        it('should resolve environment variables from an extension .env file', async () => {
+            const extDir = createExtension({
+                extensionsDir: userExtensionsDir,
+                name: 'test-extension',
+                version: '1.0.0',
+                mcpServers: {
+                    'test-server': {
+                        command: 'node',
+                        args: ['server.js'],
+                        env: {
+                            API_KEY: '$MY_API_KEY',
+                            STATIC_VALUE: 'no-substitution',
+                        },
+                    },
+                },
+                settings: [
+                    {
+                        name: 'My API Key',
+                        description: 'API key for testing.',
+                        envVar: 'MY_API_KEY',
+                    },
+                ],
+            });
+            const envFilePath = path.join(extDir, '.env');
+            fs.writeFileSync(envFilePath, 'MY_API_KEY=test-key-from-file\n');
+            const extensions = await extensionManager.loadExtensions();
+            expect(extensions).toHaveLength(1);
+            const extension = extensions[0];
+            const serverConfig = extension.mcpServers['test-server'];
+            expect(serverConfig.env).toBeDefined();
+            expect(serverConfig.env['API_KEY']).toBe('test-key-from-file');
+            expect(serverConfig.env['STATIC_VALUE']).toBe('no-substitution');
+        });
+        it('should handle missing environment variables gracefully', async () => {
             const userExtensionsDir = path.join(tempHomeDir, EXTENSIONS_DIRECTORY_NAME);
             fs.mkdirSync(userExtensionsDir, { recursive: true });
             const extDir = path.join(userExtensionsDir, 'test-extension');
@@ -280,7 +384,7 @@ describe('extension tests', () => {
                 },
             };
             fs.writeFileSync(path.join(extDir, EXTENSIONS_CONFIG_FILENAME), JSON.stringify(extensionConfig));
-            const extensions = loadExtensions(new ExtensionEnablementManager());
+            const extensions = await extensionManager.loadExtensions();
             expect(extensions).toHaveLength(1);
             const extension = extensions[0];
             const serverConfig = extension.mcpServers['test-server'];
@@ -288,7 +392,7 @@ describe('extension tests', () => {
             expect(serverConfig.env['MISSING_VAR']).toBe('$UNDEFINED_ENV_VAR');
             expect(serverConfig.env['MISSING_VAR_BRACES']).toBe('${ALSO_UNDEFINED}');
         });
-        it('should skip extensions with invalid JSON and log a warning', () => {
+        it('should skip extensions with invalid JSON and log a warning', async () => {
             const consoleSpy = vi
                 .spyOn(console, 'error')
                 .mockImplementation(() => { });
@@ -303,14 +407,13 @@ describe('extension tests', () => {
             fs.mkdirSync(badExtDir);
             const badConfigPath = path.join(badExtDir, EXTENSIONS_CONFIG_FILENAME);
             fs.writeFileSync(badConfigPath, '{ "name": "bad-ext"'); // Malformed
-            const extensions = loadExtensions(new ExtensionEnablementManager());
+            const extensions = await extensionManager.loadExtensions();
             expect(extensions).toHaveLength(1);
             expect(extensions[0].name).toBe('good-ext');
-            expect(consoleSpy).toHaveBeenCalledOnce();
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining(`Warning: Skipping extension in ${badExtDir}: Failed to load extension config from ${badConfigPath}`));
+            expect(consoleSpy).toHaveBeenCalledExactlyOnceWith(expect.stringContaining(`Warning: Skipping extension in ${badExtDir}: Failed to load extension config from ${badConfigPath}`));
             consoleSpy.mockRestore();
         });
-        it('should skip extensions with missing name and log a warning', () => {
+        it('should skip extensions with missing name and log a warning', async () => {
             const consoleSpy = vi
                 .spyOn(console, 'error')
                 .mockImplementation(() => { });
@@ -325,14 +428,13 @@ describe('extension tests', () => {
             fs.mkdirSync(badExtDir);
             const badConfigPath = path.join(badExtDir, EXTENSIONS_CONFIG_FILENAME);
             fs.writeFileSync(badConfigPath, JSON.stringify({ version: '1.0.0' }));
-            const extensions = loadExtensions(new ExtensionEnablementManager());
+            const extensions = await extensionManager.loadExtensions();
             expect(extensions).toHaveLength(1);
             expect(extensions[0].name).toBe('good-ext');
-            expect(consoleSpy).toHaveBeenCalledOnce();
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining(`Warning: Skipping extension in ${badExtDir}: Failed to load extension config from ${badConfigPath}: Invalid configuration in ${badConfigPath}: missing "name"`));
+            expect(consoleSpy).toHaveBeenCalledExactlyOnceWith(expect.stringContaining(`Warning: Skipping extension in ${badExtDir}: Failed to load extension config from ${badConfigPath}: Invalid configuration in ${badConfigPath}: missing "name"`));
             consoleSpy.mockRestore();
         });
-        it('should filter trust out of mcp servers', () => {
+        it('should filter trust out of mcp servers', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'test-extension',
@@ -345,31 +447,28 @@ describe('extension tests', () => {
                     },
                 },
             });
-            const extensions = loadExtensions(new ExtensionEnablementManager());
+            const extensions = await extensionManager.loadExtensions();
             expect(extensions).toHaveLength(1);
             expect(extensions[0].mcpServers?.['test-server'].trust).toBeUndefined();
         });
-        it('should throw an error for invalid extension names', () => {
+        it('should throw an error for invalid extension names', async () => {
             const consoleSpy = vi
                 .spyOn(console, 'error')
                 .mockImplementation(() => { });
-            const badExtDir = createExtension({
+            createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'bad_name',
                 version: '1.0.0',
             });
-            const extension = loadExtension({
-                extensionDir: badExtDir,
-                workspaceDir: tempWorkspaceDir,
-                extensionEnablementManager: new ExtensionEnablementManager(),
-            });
-            expect(extension).toBeNull();
+            const extensions = await extensionManager.loadExtensions();
+            const extension = extensions.find((e) => e.name === 'bad_name');
+            expect(extension).toBeUndefined();
             expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid extension name: "bad_name"'));
             consoleSpy.mockRestore();
         });
         describe('id generation', () => {
-            it('should generate id from source for non-github git urls', () => {
-                const extensionDir = createExtension({
+            it('should generate id from source for non-github git urls', async () => {
+                createExtension({
                     extensionsDir: userExtensionsDir,
                     name: 'my-ext',
                     version: '1.0.0',
@@ -378,18 +477,12 @@ describe('extension tests', () => {
                         source: 'http://somehost.com/foo/bar',
                     },
                 });
-                const extension = loadExtension({
-                    extensionDir,
-                    workspaceDir: tempWorkspaceDir,
-                    extensionEnablementManager: new ExtensionEnablementManager(),
-                });
-                const expectedHash = createHash('sha256')
-                    .update('http://somehost.com/foo/bar')
-                    .digest('hex');
-                expect(extension?.id).toBe(expectedHash);
+                const extensions = await extensionManager.loadExtensions();
+                const extension = extensions.find((e) => e.name === 'my-ext');
+                expect(extension?.id).toBe(hashValue('http://somehost.com/foo/bar'));
             });
-            it('should generate id from owner/repo for github http urls', () => {
-                const extensionDir = createExtension({
+            it('should generate id from owner/repo for github http urls', async () => {
+                createExtension({
                     extensionsDir: userExtensionsDir,
                     name: 'my-ext',
                     version: '1.0.0',
@@ -398,18 +491,12 @@ describe('extension tests', () => {
                         source: 'http://github.com/foo/bar',
                     },
                 });
-                const extension = loadExtension({
-                    extensionDir,
-                    workspaceDir: tempWorkspaceDir,
-                    extensionEnablementManager: new ExtensionEnablementManager(),
-                });
-                const expectedHash = createHash('sha256')
-                    .update('https://github.com/foo/bar')
-                    .digest('hex');
-                expect(extension?.id).toBe(expectedHash);
+                const extensions = await extensionManager.loadExtensions();
+                const extension = extensions.find((e) => e.name === 'my-ext');
+                expect(extension?.id).toBe(hashValue('https://github.com/foo/bar'));
             });
-            it('should generate id from owner/repo for github ssh urls', () => {
-                const extensionDir = createExtension({
+            it('should generate id from owner/repo for github ssh urls', async () => {
+                createExtension({
                     extensionsDir: userExtensionsDir,
                     name: 'my-ext',
                     version: '1.0.0',
@@ -418,18 +505,12 @@ describe('extension tests', () => {
                         source: 'git@github.com:foo/bar',
                     },
                 });
-                const extension = loadExtension({
-                    extensionDir,
-                    workspaceDir: tempWorkspaceDir,
-                    extensionEnablementManager: new ExtensionEnablementManager(),
-                });
-                const expectedHash = createHash('sha256')
-                    .update('https://github.com/foo/bar')
-                    .digest('hex');
-                expect(extension?.id).toBe(expectedHash);
+                const extensions = await extensionManager.loadExtensions();
+                const extension = extensions.find((e) => e.name === 'my-ext');
+                expect(extension?.id).toBe(hashValue('https://github.com/foo/bar'));
             });
-            it('should generate id from source for github-release extension', () => {
-                const extensionDir = createExtension({
+            it('should generate id from source for github-release extension', async () => {
+                createExtension({
                     extensionsDir: userExtensionsDir,
                     name: 'my-ext',
                     version: '1.0.0',
@@ -438,18 +519,12 @@ describe('extension tests', () => {
                         source: 'https://github.com/foo/bar',
                     },
                 });
-                const extension = loadExtension({
-                    extensionDir,
-                    workspaceDir: tempWorkspaceDir,
-                    extensionEnablementManager: new ExtensionEnablementManager(),
-                });
-                const expectedHash = createHash('sha256')
-                    .update('https://github.com/foo/bar')
-                    .digest('hex');
-                expect(extension?.id).toBe(expectedHash);
+                const extensions = await extensionManager.loadExtensions();
+                const extension = extensions.find((e) => e.name === 'my-ext');
+                expect(extension?.id).toBe(hashValue('https://github.com/foo/bar'));
             });
-            it('should generate id from the original source for local extension', () => {
-                const extensionDir = createExtension({
+            it('should generate id from the original source for local extension', async () => {
+                createExtension({
                     extensionsDir: userExtensionsDir,
                     name: 'local-ext-name',
                     version: '1.0.0',
@@ -458,15 +533,9 @@ describe('extension tests', () => {
                         source: '/some/path',
                     },
                 });
-                const extension = loadExtension({
-                    extensionDir,
-                    workspaceDir: tempWorkspaceDir,
-                    extensionEnablementManager: new ExtensionEnablementManager(),
-                });
-                const expectedHash = createHash('sha256')
-                    .update('/some/path')
-                    .digest('hex');
-                expect(extension?.id).toBe(expectedHash);
+                const extensions = await extensionManager.loadExtensions();
+                const extension = extensions.find((e) => e.name === 'local-ext-name');
+                expect(extension?.id).toBe(hashValue('/some/path'));
             });
             it('should generate id from the original source for linked extensions', async () => {
                 const extDevelopmentDir = path.join(tempHomeDir, 'local_extensions');
@@ -475,35 +544,25 @@ describe('extension tests', () => {
                     name: 'link-ext-name',
                     version: '1.0.0',
                 });
-                const extensionName = await installOrUpdateExtension({
+                await extensionManager.loadExtensions();
+                await extensionManager.installOrUpdateExtension({
                     type: 'link',
                     source: actualExtensionDir,
-                }, async () => true, tempWorkspaceDir);
-                const extension = loadExtension({
-                    extensionDir: new ExtensionStorage(extensionName).getExtensionDir(),
-                    workspaceDir: tempWorkspaceDir,
-                    extensionEnablementManager: new ExtensionEnablementManager(),
                 });
-                const expectedHash = createHash('sha256')
-                    .update(actualExtensionDir)
-                    .digest('hex');
-                expect(extension?.id).toBe(expectedHash);
+                const extension = extensionManager
+                    .getExtensions()
+                    .find((e) => e.name === 'link-ext-name');
+                expect(extension?.id).toBe(hashValue(actualExtensionDir));
             });
-            it('should generate id from name for extension with no install metadata', () => {
-                const extensionDir = createExtension({
+            it('should generate id from name for extension with no install metadata', async () => {
+                createExtension({
                     extensionsDir: userExtensionsDir,
                     name: 'no-meta-name',
                     version: '1.0.0',
                 });
-                const extension = loadExtension({
-                    extensionDir,
-                    workspaceDir: tempWorkspaceDir,
-                    extensionEnablementManager: new ExtensionEnablementManager(),
-                });
-                const expectedHash = createHash('sha256')
-                    .update('no-meta-name')
-                    .digest('hex');
-                expect(extension?.id).toBe(expectedHash);
+                const extensions = await extensionManager.loadExtensions();
+                const extension = extensions.find((e) => e.name === 'no-meta-name');
+                expect(extension?.id).toBe(hashValue('no-meta-name'));
             });
         });
     });
@@ -516,7 +575,11 @@ describe('extension tests', () => {
             });
             const targetExtDir = path.join(userExtensionsDir, 'my-local-extension');
             const metadataPath = path.join(targetExtDir, INSTALL_METADATA_FILENAME);
-            await installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true);
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            });
             expect(fs.existsSync(targetExtDir)).toBe(true);
             expect(fs.existsSync(metadataPath)).toBe(true);
             const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
@@ -532,14 +595,24 @@ describe('extension tests', () => {
                 name: 'my-local-extension',
                 version: '1.0.0',
             });
-            await installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true);
-            await expect(installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true)).rejects.toThrow('Extension "my-local-extension" is already installed. Please uninstall it first.');
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            });
+            await expect(extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            })).rejects.toThrow('Extension "my-local-extension" is already installed. Please uninstall it first.');
         });
         it('should throw an error and cleanup if gemini-extension.json is missing', async () => {
             const sourceExtDir = path.join(tempHomeDir, 'bad-extension');
             fs.mkdirSync(sourceExtDir, { recursive: true });
             const configPath = path.join(sourceExtDir, EXTENSIONS_CONFIG_FILENAME);
-            await expect(installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true)).rejects.toThrow(`Configuration file not found at ${configPath}`);
+            await expect(extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            })).rejects.toThrow(`Configuration file not found at ${configPath}`);
             const targetExtDir = path.join(userExtensionsDir, 'bad-extension');
             expect(fs.existsSync(targetExtDir)).toBe(false);
         });
@@ -548,7 +621,10 @@ describe('extension tests', () => {
             fs.mkdirSync(sourceExtDir, { recursive: true });
             const configPath = path.join(sourceExtDir, EXTENSIONS_CONFIG_FILENAME);
             fs.writeFileSync(configPath, '{ "name": "bad-json", "version": "1.0.0"'); // Malformed JSON
-            await expect(installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true)).rejects.toThrow(new RegExp(`^Failed to load extension config from ${configPath.replace(/\\/g, '\\\\')}`));
+            await expect(extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            })).rejects.toThrow(new RegExp(`^Failed to load extension config from ${configPath.replace(/\\/g, '\\\\')}`));
         });
         it('should throw an error for missing name in gemini-extension.json', async () => {
             const sourceExtDir = createExtension({
@@ -559,7 +635,10 @@ describe('extension tests', () => {
             const configPath = path.join(sourceExtDir, EXTENSIONS_CONFIG_FILENAME);
             // Overwrite with invalid config
             fs.writeFileSync(configPath, JSON.stringify({ version: '1.0.0' }));
-            await expect(installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true)).rejects.toThrow(`Invalid configuration in ${configPath}: missing "name"`);
+            await expect(extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            })).rejects.toThrow(`Invalid configuration in ${configPath}: missing "name"`);
         });
         it('should install an extension from a git URL', async () => {
             const gitUrl = 'https://somehost.com/somerepo.git';
@@ -578,7 +657,11 @@ describe('extension tests', () => {
                 failureReason: 'no release data',
                 type: 'github-release',
             });
-            await installOrUpdateExtension({ source: gitUrl, type: 'git' }, async (_) => true);
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: gitUrl,
+                type: 'git',
+            });
             expect(fs.existsSync(targetExtDir)).toBe(true);
             expect(fs.existsSync(metadataPath)).toBe(true);
             const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
@@ -596,7 +679,11 @@ describe('extension tests', () => {
             const targetExtDir = path.join(userExtensionsDir, 'my-linked-extension');
             const metadataPath = path.join(targetExtDir, INSTALL_METADATA_FILENAME);
             const configPath = path.join(targetExtDir, EXTENSIONS_CONFIG_FILENAME);
-            await installOrUpdateExtension({ source: sourceExtDir, type: 'link' }, async (_) => true);
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'link',
+            });
             expect(fs.existsSync(targetExtDir)).toBe(true);
             expect(fs.existsSync(metadataPath)).toBe(true);
             expect(fs.existsSync(configPath)).toBe(false);
@@ -607,6 +694,65 @@ describe('extension tests', () => {
             });
             fs.rmSync(targetExtDir, { recursive: true, force: true });
         });
+        it('should prompt for trust if workspace is not trusted', async () => {
+            vi.mocked(isWorkspaceTrusted).mockReturnValue({
+                isTrusted: false,
+                source: undefined,
+            });
+            const sourceExtDir = createExtension({
+                extensionsDir: tempHomeDir,
+                name: 'my-local-extension',
+                version: '1.0.0',
+            });
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            });
+            expect(mockRequestConsent).toHaveBeenCalledWith(`The current workspace at "${tempWorkspaceDir}" is not trusted. Do you want to trust this workspace to install extensions?`);
+        });
+        it('should not install if user denies trust', async () => {
+            vi.mocked(isWorkspaceTrusted).mockReturnValue({
+                isTrusted: false,
+                source: undefined,
+            });
+            mockRequestConsent.mockImplementation(async (message) => {
+                if (message.includes('is not trusted. Do you want to trust this workspace to install extensions?')) {
+                    return false;
+                }
+                return true;
+            });
+            const sourceExtDir = createExtension({
+                extensionsDir: tempHomeDir,
+                name: 'my-local-extension',
+                version: '1.0.0',
+            });
+            await extensionManager.loadExtensions();
+            await expect(extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            })).rejects.toThrow(`Could not install extension because the current workspace at ${tempWorkspaceDir} is not trusted.`);
+        });
+        it('should add the workspace to trusted folders if user consents', async () => {
+            const trustedFoldersPath = path.join(tempHomeDir, '.cell-cli', 'trustedFolders.json');
+            vi.mocked(isWorkspaceTrusted).mockReturnValue({
+                isTrusted: false,
+                source: undefined,
+            });
+            const sourceExtDir = createExtension({
+                extensionsDir: tempHomeDir,
+                name: 'my-local-extension',
+                version: '1.0.0',
+            });
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            });
+            expect(fs.existsSync(trustedFoldersPath)).toBe(true);
+            const trustedFolders = JSON.parse(fs.readFileSync(trustedFoldersPath, 'utf-8'));
+            expect(trustedFolders[tempWorkspaceDir]).toBe('TRUST_FOLDER');
+        });
         describe.each([true, false])('with previous extension config: %s', (isUpdate) => {
             let sourceExtDir;
             beforeEach(async () => {
@@ -615,14 +761,18 @@ describe('extension tests', () => {
                     name: 'my-local-extension',
                     version: '1.1.0',
                 });
+                await extensionManager.loadExtensions();
                 if (isUpdate) {
-                    await installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true);
+                    await extensionManager.installOrUpdateExtension({
+                        source: sourceExtDir,
+                        type: 'local',
+                    });
                 }
                 // Clears out any calls to mocks from the above function calls.
                 vi.clearAllMocks();
             });
             it(`should log an ${isUpdate ? 'update' : 'install'} event to clearcut on success`, async () => {
-                await installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true, undefined, isUpdate
+                await extensionManager.installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, isUpdate
                     ? {
                         name: 'my-local-extension',
                         version: '1.0.0',
@@ -640,7 +790,7 @@ describe('extension tests', () => {
             it(`should ${isUpdate ? 'not ' : ''} alter the extension enablement configuration`, async () => {
                 const enablementManager = new ExtensionEnablementManager();
                 enablementManager.enable('my-local-extension', true, '/some/scope');
-                await installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true, undefined, isUpdate
+                await extensionManager.installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, isUpdate
                     ? {
                         name: 'my-local-extension',
                         version: '1.0.0',
@@ -673,9 +823,13 @@ describe('extension tests', () => {
                     },
                 },
             });
-            const mockRequestConsent = vi.fn();
-            mockRequestConsent.mockResolvedValue(true);
-            await expect(installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, mockRequestConsent)).resolves.toBe('my-local-extension');
+            await extensionManager.loadExtensions();
+            await expect(extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            })).resolves.toMatchObject({
+                name: 'my-local-extension',
+            });
             expect(mockRequestConsent).toHaveBeenCalledWith(`Installing extension "my-local-extension".
 ${INSTALL_WARNING_MESSAGE}
 This extension will run the following MCP servers:
@@ -694,7 +848,11 @@ This extension will run the following MCP servers:
                     },
                 },
             });
-            await expect(installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async () => true)).resolves.toBe('my-local-extension');
+            await extensionManager.loadExtensions();
+            await expect(extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            })).resolves.toMatchObject({ name: 'my-local-extension' });
         });
         it('should cancel installation if user declines prompt for local extension with mcp servers', async () => {
             const sourceExtDir = createExtension({
@@ -708,7 +866,12 @@ This extension will run the following MCP servers:
                     },
                 },
             });
-            await expect(installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async () => false)).rejects.toThrow('Installation cancelled for "my-local-extension".');
+            mockRequestConsent.mockResolvedValue(false);
+            await extensionManager.loadExtensions();
+            await expect(extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            })).rejects.toThrow('Installation cancelled for "my-local-extension".');
         });
         it('should save the autoUpdate flag to the install metadata', async () => {
             const sourceExtDir = createExtension({
@@ -718,11 +881,12 @@ This extension will run the following MCP servers:
             });
             const targetExtDir = path.join(userExtensionsDir, 'my-local-extension');
             const metadataPath = path.join(targetExtDir, INSTALL_METADATA_FILENAME);
-            await installOrUpdateExtension({
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
                 source: sourceExtDir,
                 type: 'local',
                 autoUpdate: true,
-            }, async (_) => true);
+            });
             expect(fs.existsSync(targetExtDir)).toBe(true);
             expect(fs.existsSync(metadataPath)).toBe(true);
             const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
@@ -745,18 +909,156 @@ This extension will run the following MCP servers:
                     },
                 },
             });
-            const mockRequestConsent = vi.fn();
-            // Install it and force consent first.
-            await installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async () => true);
+            await extensionManager.loadExtensions();
+            // Install it with hard coded consent first.
+            await extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            });
+            expect(mockRequestConsent).toHaveBeenCalledOnce();
             // Now update it without changing anything.
-            await expect(installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, mockRequestConsent, process.cwd(), 
+            await expect(extensionManager.installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, 
             // Provide its own existing config as the previous config.
-            await loadExtensionConfig({
-                extensionDir: sourceExtDir,
-                workspaceDir: process.cwd(),
-                extensionEnablementManager: new ExtensionEnablementManager(),
-            }))).resolves.toBe('my-local-extension');
-            expect(mockRequestConsent).not.toHaveBeenCalled();
+            await extensionManager.loadExtensionConfig(sourceExtDir))).resolves.toMatchObject({ name: 'my-local-extension' });
+            // Still only called once
+            expect(mockRequestConsent).toHaveBeenCalledOnce();
+        });
+        it('should prompt for settings if promptForSettings', async () => {
+            const sourceExtDir = createExtension({
+                extensionsDir: tempHomeDir,
+                name: 'my-local-extension',
+                version: '1.0.0',
+                settings: [
+                    {
+                        name: 'API Key',
+                        description: 'Your API key for the service.',
+                        envVar: 'MY_API_KEY',
+                    },
+                ],
+            });
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            });
+            expect(mockPromptForSettings).toHaveBeenCalled();
+        });
+        it('should not prompt for settings if promptForSettings is false', async () => {
+            const sourceExtDir = createExtension({
+                extensionsDir: tempHomeDir,
+                name: 'my-local-extension',
+                version: '1.0.0',
+                settings: [
+                    {
+                        name: 'API Key',
+                        description: 'Your API key for the service.',
+                        envVar: 'MY_API_KEY',
+                    },
+                ],
+            });
+            extensionManager = new ExtensionManager({
+                workspaceDir: tempWorkspaceDir,
+                requestConsent: mockRequestConsent,
+                requestSetting: null,
+                settings: loadSettings(tempWorkspaceDir).merged,
+            });
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            });
+        });
+        it('should only prompt for new settings on update, and preserve old settings', async () => {
+            // 1. Create and install the "old" version of the extension.
+            const oldSourceExtDir = createExtension({
+                extensionsDir: tempHomeDir, // Create it in a temp location first
+                name: 'my-local-extension',
+                version: '1.0.0',
+                settings: [
+                    {
+                        name: 'API Key',
+                        description: 'Your API key for the service.',
+                        envVar: 'MY_API_KEY',
+                    },
+                ],
+            });
+            mockPromptForSettings.mockResolvedValueOnce('old-api-key');
+            await extensionManager.loadExtensions();
+            // Install it so it exists in the userExtensionsDir
+            await extensionManager.installOrUpdateExtension({
+                source: oldSourceExtDir,
+                type: 'local',
+            });
+            const envPath = new ExtensionStorage('my-local-extension').getEnvFilePath();
+            expect(fs.existsSync(envPath)).toBe(true);
+            let envContent = fs.readFileSync(envPath, 'utf-8');
+            expect(envContent).toContain('MY_API_KEY=old-api-key');
+            expect(mockPromptForSettings).toHaveBeenCalledTimes(1);
+            // 2. Create the "new" version of the extension in a new source directory.
+            const newSourceExtDir = createExtension({
+                extensionsDir: path.join(tempHomeDir, 'new-source'), // Another temp location
+                name: 'my-local-extension', // Same name
+                version: '1.1.0', // New version
+                settings: [
+                    {
+                        name: 'API Key',
+                        description: 'Your API key for the service.',
+                        envVar: 'MY_API_KEY',
+                    },
+                    {
+                        name: 'New Setting',
+                        description: 'A new setting.',
+                        envVar: 'NEW_SETTING',
+                    },
+                ],
+            });
+            const previousExtensionConfig = extensionManager.loadExtensionConfig(path.join(userExtensionsDir, 'my-local-extension'));
+            mockPromptForSettings.mockResolvedValueOnce('new-setting-value');
+            // 3. Call installOrUpdateExtension to perform the update.
+            await extensionManager.installOrUpdateExtension({ source: newSourceExtDir, type: 'local' }, previousExtensionConfig);
+            expect(mockPromptForSettings).toHaveBeenCalledTimes(2);
+            expect(mockPromptForSettings).toHaveBeenCalledWith(expect.objectContaining({ name: 'New Setting' }));
+            expect(fs.existsSync(envPath)).toBe(true);
+            envContent = fs.readFileSync(envPath, 'utf-8');
+            expect(envContent).toContain('MY_API_KEY=old-api-key');
+            expect(envContent).toContain('NEW_SETTING=new-setting-value');
+        });
+        it('should fail auto-update if settings have changed', async () => {
+            // 1. Install initial version with autoUpdate: true
+            const oldSourceExtDir = createExtension({
+                extensionsDir: tempHomeDir,
+                name: 'my-auto-update-ext',
+                version: '1.0.0',
+                settings: [
+                    {
+                        name: 'OLD_SETTING',
+                        envVar: 'OLD_SETTING',
+                        description: 'An old setting',
+                    },
+                ],
+            });
+            await extensionManager.loadExtensions();
+            await extensionManager.installOrUpdateExtension({
+                source: oldSourceExtDir,
+                type: 'local',
+                autoUpdate: true,
+            });
+            // 2. Create new version with different settings
+            const newSourceExtDir = createExtension({
+                extensionsDir: tempHomeDir,
+                name: 'my-auto-update-ext',
+                version: '1.1.0',
+                settings: [
+                    {
+                        name: 'NEW_SETTING',
+                        envVar: 'NEW_SETTING',
+                        description: 'A new setting',
+                    },
+                ],
+            });
+            const previousExtensionConfig = extensionManager.loadExtensionConfig(path.join(userExtensionsDir, 'my-auto-update-ext'));
+            // 3. Attempt to update and assert it fails
+            await expect(extensionManager.installOrUpdateExtension({ source: newSourceExtDir, type: 'local', autoUpdate: true }, previousExtensionConfig)).rejects.toThrow('Extension "my-auto-update-ext" has settings changes and cannot be auto-updated. Please update manually.');
         });
         it('should throw an error for invalid extension names', async () => {
             const sourceExtDir = createExtension({
@@ -764,7 +1066,10 @@ This extension will run the following MCP servers:
                 name: 'bad_name',
                 version: '1.0.0',
             });
-            await expect(installOrUpdateExtension({ source: sourceExtDir, type: 'local' }, async (_) => true)).rejects.toThrow('Invalid extension name: "bad_name"');
+            await expect(extensionManager.installOrUpdateExtension({
+                source: sourceExtDir,
+                type: 'local',
+            })).rejects.toThrow('Invalid extension name: "bad_name"');
         });
         describe('installing from github', () => {
             const gitUrl = 'https://github.com/google/gemini-test-extension.git';
@@ -797,7 +1102,11 @@ This extension will run the following MCP servers:
                     version: '1.0.0',
                 });
                 vi.spyOn(ExtensionStorage, 'createTmpDir').mockResolvedValue(join(tempDir, extensionName));
-                await installOrUpdateExtension({ source: gitUrl, type: 'github-release' }, async () => true);
+                await extensionManager.loadExtensions();
+                await extensionManager.installOrUpdateExtension({
+                    source: gitUrl,
+                    type: 'github-release',
+                });
                 expect(fs.existsSync(targetExtDir)).toBe(true);
                 const metadataPath = path.join(targetExtDir, INSTALL_METADATA_FILENAME);
                 expect(fs.existsSync(metadataPath)).toBe(true);
@@ -815,13 +1124,12 @@ This extension will run the following MCP servers:
                     errorMessage: 'download failed',
                     type: 'github-release',
                 });
-                const requestConsent = vi.fn().mockResolvedValue(true);
-                await installOrUpdateExtension({ source: gitUrl, type: 'github-release' }, // Use github-release to force consent
-                requestConsent);
+                await extensionManager.loadExtensions();
+                await extensionManager.installOrUpdateExtension({ source: gitUrl, type: 'github-release' });
                 // It gets called once to ask for a git clone, and once to consent to
                 // the actual extension features.
-                expect(requestConsent).toHaveBeenCalledTimes(2);
-                expect(requestConsent).toHaveBeenCalledWith(expect.stringContaining('Would you like to attempt to install via "git clone" instead?'));
+                expect(mockRequestConsent).toHaveBeenCalledTimes(2);
+                expect(mockRequestConsent).toHaveBeenCalledWith(expect.stringContaining('Would you like to attempt to install via "git clone" instead?'));
                 expect(mockGit.clone).toHaveBeenCalled();
                 const metadataPath = path.join(userExtensionsDir, extensionName, INSTALL_METADATA_FILENAME);
                 const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
@@ -833,9 +1141,13 @@ This extension will run the following MCP servers:
                     errorMessage: 'download failed',
                     type: 'github-release',
                 });
-                const requestConsent = vi.fn().mockResolvedValue(false);
-                await expect(installOrUpdateExtension({ source: gitUrl, type: 'github-release' }, requestConsent)).rejects.toThrow(`Failed to install extension ${gitUrl}: download failed`);
-                expect(requestConsent).toHaveBeenCalledExactlyOnceWith(expect.stringContaining('Would you like to attempt to install via "git clone" instead?'));
+                mockRequestConsent.mockResolvedValue(false);
+                await extensionManager.loadExtensions();
+                await expect(extensionManager.installOrUpdateExtension({
+                    source: gitUrl,
+                    type: 'github-release',
+                })).rejects.toThrow(`Failed to install extension ${gitUrl}: download failed`);
+                expect(mockRequestConsent).toHaveBeenCalledExactlyOnceWith(expect.stringContaining('Would you like to attempt to install via "git clone" instead?'));
                 expect(mockGit.clone).not.toHaveBeenCalled();
             });
             it('should fallback to git clone without consent if no release data is found on first install', async () => {
@@ -844,11 +1156,14 @@ This extension will run the following MCP servers:
                     failureReason: 'no release data',
                     type: 'github-release',
                 });
-                const requestConsent = vi.fn().mockResolvedValue(true);
-                await installOrUpdateExtension({ source: gitUrl, type: 'git' }, requestConsent);
+                await extensionManager.loadExtensions();
+                await extensionManager.installOrUpdateExtension({
+                    source: gitUrl,
+                    type: 'git',
+                });
                 // We should not see the request to use git clone, this is a repo that
                 // has no github releases so it is the only install method.
-                expect(requestConsent).toHaveBeenCalledExactlyOnceWith(expect.stringContaining('Installing extension "gemini-test-extension"'));
+                expect(mockRequestConsent).toHaveBeenCalledExactlyOnceWith(expect.stringContaining('Installing extension "gemini-test-extension"'));
                 expect(mockGit.clone).toHaveBeenCalled();
                 const metadataPath = path.join(userExtensionsDir, extensionName, INSTALL_METADATA_FILENAME);
                 const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
@@ -861,10 +1176,9 @@ This extension will run the following MCP servers:
                     errorMessage: 'No release data found',
                     type: 'github-release',
                 });
-                const requestConsent = vi.fn().mockResolvedValue(true);
-                await installOrUpdateExtension({ source: gitUrl, type: 'github-release' }, // Note the type
-                requestConsent);
-                expect(requestConsent).toHaveBeenCalledWith(expect.stringContaining('Would you like to attempt to install via "git clone" instead?'));
+                await extensionManager.loadExtensions();
+                await extensionManager.installOrUpdateExtension({ source: gitUrl, type: 'github-release' });
+                expect(mockRequestConsent).toHaveBeenCalledWith(expect.stringContaining('Would you like to attempt to install via "git clone" instead?'));
                 expect(mockGit.clone).toHaveBeenCalled();
             });
         });
@@ -876,7 +1190,8 @@ This extension will run the following MCP servers:
                 name: 'my-local-extension',
                 version: '1.0.0',
             });
-            await uninstallExtension('my-local-extension', false);
+            await extensionManager.loadExtensions();
+            await extensionManager.uninstallExtension('my-local-extension', false);
             expect(fs.existsSync(sourceExtDir)).toBe(false);
         });
         it('should uninstall an extension by name and retain existing extensions', async () => {
@@ -890,13 +1205,15 @@ This extension will run the following MCP servers:
                 name: 'other-extension',
                 version: '1.0.0',
             });
-            await uninstallExtension('my-local-extension', false);
+            await extensionManager.loadExtensions();
+            await extensionManager.uninstallExtension('my-local-extension', false);
             expect(fs.existsSync(sourceExtDir)).toBe(false);
-            expect(loadExtensions(new ExtensionEnablementManager())).toHaveLength(1);
+            expect(extensionManager.getExtensions()).toHaveLength(1);
             expect(fs.existsSync(otherExtDir)).toBe(true);
         });
         it('should throw an error if the extension does not exist', async () => {
-            await expect(uninstallExtension('nonexistent-extension', false)).rejects.toThrow('Extension not found.');
+            await extensionManager.loadExtensions();
+            await expect(extensionManager.uninstallExtension('nonexistent-extension', false)).rejects.toThrow('Extension not found.');
         });
         describe.each([true, false])('with isUpdate: %s', (isUpdate) => {
             it(`should ${isUpdate ? 'not ' : ''}log uninstall event`, async () => {
@@ -909,7 +1226,8 @@ This extension will run the following MCP servers:
                         type: 'local',
                     },
                 });
-                await uninstallExtension('my-local-extension', isUpdate);
+                await extensionManager.loadExtensions();
+                await extensionManager.uninstallExtension('my-local-extension', isUpdate);
                 if (isUpdate) {
                     expect(mockLogExtensionUninstall).not.toHaveBeenCalled();
                     expect(ExtensionUninstallEvent).not.toHaveBeenCalled();
@@ -927,7 +1245,8 @@ This extension will run the following MCP servers:
                 });
                 const enablementManager = new ExtensionEnablementManager();
                 enablementManager.enable('test-extension', true, '/some/scope');
-                await uninstallExtension('test-extension', isUpdate);
+                await extensionManager.loadExtensions();
+                await extensionManager.uninstallExtension('test-extension', isUpdate);
                 const config = enablementManager.readConfig()['test-extension'];
                 if (isUpdate) {
                     expect(config).not.toBeUndefined();
@@ -949,7 +1268,8 @@ This extension will run the following MCP servers:
                     type: 'git',
                 },
             });
-            await uninstallExtension(gitUrl, false);
+            await extensionManager.loadExtensions();
+            await extensionManager.uninstallExtension(gitUrl, false);
             expect(fs.existsSync(sourceExtDir)).toBe(false);
             expect(mockLogExtensionUninstall).toHaveBeenCalled();
             expect(ExtensionUninstallEvent).toHaveBeenCalledWith(hashValue('gemini-sql-extension'), hashValue('https://github.com/google/gemini-sql-extension'), 'success');
@@ -961,29 +1281,32 @@ This extension will run the following MCP servers:
                 version: '1.0.0',
                 // No installMetadata provided
             });
-            await expect(uninstallExtension('https://github.com/google/no-metadata-extension', false)).rejects.toThrow('Extension not found.');
+            await extensionManager.loadExtensions();
+            await expect(extensionManager.uninstallExtension('https://github.com/google/no-metadata-extension', false)).rejects.toThrow('Extension not found.');
         });
     });
     describe('disableExtension', () => {
-        it('should disable an extension at the user scope', () => {
+        it('should disable an extension at the user scope', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'my-extension',
                 version: '1.0.0',
             });
-            disableExtension('my-extension', SettingScope.User, new ExtensionEnablementManager());
+            await extensionManager.loadExtensions();
+            await extensionManager.disableExtension('my-extension', SettingScope.User);
             expect(isEnabled({
                 name: 'my-extension',
                 enabledForPath: tempWorkspaceDir,
             })).toBe(false);
         });
-        it('should disable an extension at the workspace scope', () => {
+        it('should disable an extension at the workspace scope', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'my-extension',
                 version: '1.0.0',
             });
-            disableExtension('my-extension', SettingScope.Workspace, new ExtensionEnablementManager(), tempWorkspaceDir);
+            await extensionManager.loadExtensions();
+            await extensionManager.disableExtension('my-extension', SettingScope.Workspace);
             expect(isEnabled({
                 name: 'my-extension',
                 enabledForPath: tempHomeDir,
@@ -993,23 +1316,24 @@ This extension will run the following MCP servers:
                 enabledForPath: tempWorkspaceDir,
             })).toBe(false);
         });
-        it('should handle disabling the same extension twice', () => {
+        it('should handle disabling the same extension twice', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'my-extension',
                 version: '1.0.0',
             });
-            disableExtension('my-extension', SettingScope.User, new ExtensionEnablementManager());
-            disableExtension('my-extension', SettingScope.User, new ExtensionEnablementManager());
+            await extensionManager.loadExtensions();
+            await extensionManager.disableExtension('my-extension', SettingScope.User);
+            await extensionManager.disableExtension('my-extension', SettingScope.User);
             expect(isEnabled({
                 name: 'my-extension',
                 enabledForPath: tempWorkspaceDir,
             })).toBe(false);
         });
-        it('should throw an error if you request system scope', () => {
-            expect(() => disableExtension('my-extension', SettingScope.System, new ExtensionEnablementManager())).toThrow('System and SystemDefaults scopes are not supported.');
+        it('should throw an error if you request system scope', async () => {
+            await expect(async () => await extensionManager.disableExtension('my-extension', SettingScope.System)).rejects.toThrow('System and SystemDefaults scopes are not supported.');
         });
-        it('should log a disable event', () => {
+        it('should log a disable event', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'ext1',
@@ -1019,7 +1343,8 @@ This extension will run the following MCP servers:
                     type: 'local',
                 },
             });
-            disableExtension('ext1', SettingScope.Workspace, new ExtensionEnablementManager());
+            await extensionManager.loadExtensions();
+            await extensionManager.disableExtension('ext1', SettingScope.Workspace);
             expect(mockLogExtensionDisable).toHaveBeenCalled();
             expect(ExtensionDisableEvent).toHaveBeenCalledWith(hashValue('ext1'), hashValue(userExtensionsDir), SettingScope.Workspace);
         });
@@ -1029,41 +1354,40 @@ This extension will run the following MCP servers:
             vi.restoreAllMocks();
         });
         const getActiveExtensions = () => {
-            const manager = new ExtensionEnablementManager();
-            const extensions = loadExtensions(manager);
+            const extensions = extensionManager.getExtensions();
             return extensions.filter((e) => e.isActive);
         };
-        it('should enable an extension at the user scope', () => {
+        it('should enable an extension at the user scope', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'ext1',
                 version: '1.0.0',
             });
-            const extensionEnablementManager = new ExtensionEnablementManager();
-            disableExtension('ext1', SettingScope.User, extensionEnablementManager);
+            await extensionManager.loadExtensions();
+            await extensionManager.disableExtension('ext1', SettingScope.User);
             let activeExtensions = getActiveExtensions();
             expect(activeExtensions).toHaveLength(0);
-            enableExtension('ext1', SettingScope.User, extensionEnablementManager);
-            activeExtensions = getActiveExtensions();
+            await extensionManager.enableExtension('ext1', SettingScope.User);
+            activeExtensions = await getActiveExtensions();
             expect(activeExtensions).toHaveLength(1);
             expect(activeExtensions[0].name).toBe('ext1');
         });
-        it('should enable an extension at the workspace scope', () => {
+        it('should enable an extension at the workspace scope', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'ext1',
                 version: '1.0.0',
             });
-            const extensionEnablementManager = new ExtensionEnablementManager();
-            disableExtension('ext1', SettingScope.Workspace, extensionEnablementManager);
+            await extensionManager.loadExtensions();
+            await extensionManager.disableExtension('ext1', SettingScope.Workspace);
             let activeExtensions = getActiveExtensions();
             expect(activeExtensions).toHaveLength(0);
-            enableExtension('ext1', SettingScope.Workspace, extensionEnablementManager);
-            activeExtensions = getActiveExtensions();
+            await extensionManager.enableExtension('ext1', SettingScope.Workspace);
+            activeExtensions = await getActiveExtensions();
             expect(activeExtensions).toHaveLength(1);
             expect(activeExtensions[0].name).toBe('ext1');
         });
-        it('should log an enable event', () => {
+        it('should log an enable event', async () => {
             createExtension({
                 extensionsDir: userExtensionsDir,
                 name: 'ext1',
@@ -1073,9 +1397,9 @@ This extension will run the following MCP servers:
                     type: 'local',
                 },
             });
-            const extensionEnablementManager = new ExtensionEnablementManager();
-            disableExtension('ext1', SettingScope.Workspace, extensionEnablementManager);
-            enableExtension('ext1', SettingScope.Workspace, extensionEnablementManager);
+            await extensionManager.loadExtensions();
+            await extensionManager.disableExtension('ext1', SettingScope.Workspace);
+            await extensionManager.enableExtension('ext1', SettingScope.Workspace);
             expect(mockLogExtensionEnable).toHaveBeenCalled();
             expect(ExtensionEnableEvent).toHaveBeenCalledWith(hashValue('ext1'), hashValue(userExtensionsDir), SettingScope.Workspace);
         });