Download packages/cli/src/ui/commands/extensionsCommand.ts from SaylorTwift/gemini-cli: direct link, hf CLI and curl.
- Browser
- Download file 25.7 kB
-
https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/cli/src/ui/commands/extensionsCommand.ts
- Command line
-
hf download hf://SaylorTwift/gemini-cli/packages/cli/src/ui/commands/extensionsCommand.ts
-
curl -L -o extensionsCommand.ts https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/cli/src/ui/commands/extensionsCommand.ts
25.7 kB
| /** | |
| * @license | |
| * Copyright 2025 Google LLC | |
| * SPDX-License-Identifier: Apache-2.0 | |
| */ | |
| import { | |
| debugLogger, | |
| listExtensions, | |
| getErrorMessage, | |
| type ExtensionInstallMetadata, | |
| } from '@google/gemini-cli-core'; | |
| import type { ExtensionUpdateInfo } from '../../config/extension.js'; | |
| import { | |
| emptyIcon, | |
| MessageType, | |
| type HistoryItemExtensionsList, | |
| type HistoryItemInfo, | |
| } from '../types.js'; | |
| import { | |
| type CommandContext, | |
| type SlashCommand, | |
| type SlashCommandActionReturn, | |
| CommandKind, | |
| } from './types.js'; | |
| import open from 'open'; | |
| import process from 'node:process'; | |
| import { | |
| ExtensionManager, | |
| inferInstallMetadata, | |
| } from '../../config/extension-manager.js'; | |
| import { SettingScope } from '../../config/settings.js'; | |
| import { McpServerEnablementManager } from '../../config/mcp/mcpServerEnablement.js'; | |
| import { theme } from '../semantic-colors.js'; | |
| import { stat } from 'node:fs/promises'; | |
| import { ExtensionSettingScope } from '../../config/extensions/extensionSettings.js'; | |
| import { type ConfigLogger } from '../../commands/extensions/utils.js'; | |
| import { ConfigExtensionDialog } from '../components/ConfigExtensionDialog.js'; | |
| import { ExtensionRegistryView } from '../components/views/ExtensionRegistryView.js'; | |
| import React from 'react'; | |
| function showMessageIfNoExtensions( | |
| context: CommandContext, | |
| extensions: unknown[], | |
| ): boolean { | |
| if (extensions.length === 0) { | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: 'No extensions installed. Run `/extensions explore` to check out the gallery.', | |
| }); | |
| return true; | |
| } | |
| return false; | |
| } | |
| async function listAction(context: CommandContext) { | |
| const extensions = context.services.agentContext?.config | |
| ? listExtensions(context.services.agentContext.config) | |
| : []; | |
| if (showMessageIfNoExtensions(context, extensions)) { | |
| return; | |
| } | |
| const historyItem: HistoryItemExtensionsList = { | |
| type: MessageType.EXTENSIONS_LIST, | |
| extensions, | |
| }; | |
| context.ui.addItem(historyItem); | |
| } | |
| function updateAction(context: CommandContext, args: string): Promise<void> { | |
| const updateArgs = args.split(' ').filter((value) => value.length > 0); | |
| const all = updateArgs.length === 1 && updateArgs[0] === '--all'; | |
| const names = all ? null : updateArgs; | |
| if (!all && names?.length === 0) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: 'Usage: /extensions update <extension-names>|--all', | |
| }); | |
| return Promise.resolve(); | |
| } | |
| let resolveUpdateComplete: (updateInfo: ExtensionUpdateInfo[]) => void; | |
| const updateComplete = new Promise<ExtensionUpdateInfo[]>( | |
| (resolve) => (resolveUpdateComplete = resolve), | |
| ); | |
| const extensions = context.services.agentContext?.config | |
| ? listExtensions(context.services.agentContext.config) | |
| : []; | |
| if (showMessageIfNoExtensions(context, extensions)) { | |
| return Promise.resolve(); | |
| } | |
| const historyItem: HistoryItemExtensionsList = { | |
| type: MessageType.EXTENSIONS_LIST, | |
| extensions, | |
| }; | |
| // eslint-disable-next-line @typescript-eslint/no-floating-promises | |
| updateComplete.then((updateInfos) => { | |
| if (updateInfos.length === 0) { | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: 'No extensions to update.', | |
| }); | |
| } | |
| context.ui.addItem(historyItem); | |
| context.ui.setPendingItem(null); | |
| }); | |
| try { | |
| context.ui.setPendingItem(historyItem); | |
| context.ui.dispatchExtensionStateUpdate({ | |
| type: 'SCHEDULE_UPDATE', | |
| payload: { | |
| all, | |
| names, | |
| onComplete: (updateInfos) => { | |
| resolveUpdateComplete(updateInfos); | |
| }, | |
| }, | |
| }); | |
| if (names?.length) { | |
| const extensions = listExtensions(context.services.agentContext!.config); | |
| for (const name of names) { | |
| const extension = extensions.find( | |
| (extension) => extension.name === name, | |
| ); | |
| if (!extension) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Extension ${name} not found.`, | |
| }); | |
| continue; | |
| } | |
| } | |
| } | |
| } catch (error) { | |
| resolveUpdateComplete!([]); | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: getErrorMessage(error), | |
| }); | |
| } | |
| return updateComplete.then((_) => {}); | |
| } | |
| async function restartAction( | |
| context: CommandContext, | |
| args: string, | |
| ): Promise<void> { | |
| const extensionLoader = | |
| context.services.agentContext?.config.getExtensionLoader(); | |
| if (!extensionLoader) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: "Extensions are not yet loaded, can't restart yet", | |
| }); | |
| return; | |
| } | |
| const extensions = extensionLoader.getExtensions(); | |
| if (showMessageIfNoExtensions(context, extensions)) { | |
| return; | |
| } | |
| const restartArgs = args.split(' ').filter((value) => value.length > 0); | |
| const all = restartArgs.length === 1 && restartArgs[0] === '--all'; | |
| const names = all ? null : restartArgs; | |
| if (!all && names?.length === 0) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: 'Usage: /extensions reload <extension-names>|--all', | |
| }); | |
| return Promise.resolve(); | |
| } | |
| let extensionsToRestart = extensionLoader | |
| .getExtensions() | |
| .filter((extension) => extension.isActive); | |
| if (names) { | |
| extensionsToRestart = extensionsToRestart.filter((extension) => | |
| names.includes(extension.name), | |
| ); | |
| if (names.length !== extensionsToRestart.length) { | |
| const notFound = names.filter( | |
| (name) => | |
| !extensionsToRestart.some((extension) => extension.name === name), | |
| ); | |
| if (notFound.length > 0) { | |
| context.ui.addItem({ | |
| type: MessageType.WARNING, | |
| text: `Extension(s) not found or not active: ${notFound.join(', ')}`, | |
| }); | |
| } | |
| } | |
| } | |
| if (extensionsToRestart.length === 0) { | |
| // We will have logged a different message above already. | |
| return; | |
| } | |
| const s = extensionsToRestart.length > 1 ? 's' : ''; | |
| const reloadingMessage = { | |
| type: MessageType.INFO, | |
| text: `Reloading ${extensionsToRestart.length} extension${s}...`, | |
| color: theme.text.primary, | |
| }; | |
| context.ui.addItem(reloadingMessage); | |
| const results = await Promise.allSettled( | |
| extensionsToRestart.map(async (extension) => { | |
| if (extension.isActive) { | |
| await extensionLoader.restartExtension(extension); | |
| context.ui.dispatchExtensionStateUpdate({ | |
| type: 'RESTARTED', | |
| payload: { | |
| name: extension.name, | |
| }, | |
| }); | |
| } | |
| }), | |
| ); | |
| const failures = results.filter( | |
| (result): result is PromiseRejectedResult => result.status === 'rejected', | |
| ); | |
| if (failures.length < extensionsToRestart.length) { | |
| try { | |
| await context.services.agentContext?.config.reloadSkills(); | |
| await context.services.agentContext?.config.getAgentRegistry()?.reload(); | |
| } catch (error) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Failed to reload skills or agents: ${getErrorMessage(error)}`, | |
| }); | |
| } | |
| } | |
| if (failures.length > 0) { | |
| const errorMessages = failures | |
| .map((failure, index) => { | |
| const extensionName = extensionsToRestart[index].name; | |
| return `${extensionName}: ${getErrorMessage(failure.reason)}`; | |
| }) | |
| .join('\n '); | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Failed to reload some extensions:\n ${errorMessages}`, | |
| }); | |
| } else { | |
| const infoItem: HistoryItemInfo = { | |
| type: MessageType.INFO, | |
| text: `${extensionsToRestart.length} extension${s} reloaded successfully`, | |
| icon: emptyIcon, | |
| color: theme.text.primary, | |
| }; | |
| context.ui.addItem(infoItem); | |
| } | |
| } | |
| async function exploreAction( | |
| context: CommandContext, | |
| ): Promise<SlashCommandActionReturn | void> { | |
| const settings = context.services.settings.merged; | |
| const useRegistryUI = settings.experimental?.extensionRegistry; | |
| if (useRegistryUI) { | |
| const extensionManager = | |
| context.services.agentContext?.config.getExtensionLoader(); | |
| if (extensionManager instanceof ExtensionManager) { | |
| return { | |
| type: 'custom_dialog' as const, | |
| component: React.createElement(ExtensionRegistryView, { | |
| onSelect: async (extension, requestConsentOverride) => { | |
| debugLogger.log(`Selected extension: ${extension.extensionName}`); | |
| await installAction(context, extension.url, requestConsentOverride); | |
| context.ui.removeComponent(); | |
| }, | |
| onLink: async (extension, requestConsentOverride) => { | |
| debugLogger.log(`Linking extension: ${extension.extensionName}`); | |
| await linkAction(context, extension.url, requestConsentOverride); | |
| context.ui.removeComponent(); | |
| }, | |
| onClose: () => context.ui.removeComponent(), | |
| extensionManager, | |
| }), | |
| }; | |
| } | |
| } | |
| const extensionsUrl = 'https://geminicli.com/extensions/'; | |
| // Only check for NODE_ENV for explicit test mode, not for unit test framework | |
| if (process.env['NODE_ENV'] === 'test') { | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Would open extensions page in your browser: ${extensionsUrl} (skipped in test environment)`, | |
| }); | |
| } else if ( | |
| process.env['SANDBOX'] && | |
| process.env['SANDBOX'] !== 'sandbox-exec' | |
| ) { | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `View available extensions at ${extensionsUrl}`, | |
| }); | |
| } else { | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Opening extensions page in your browser: ${extensionsUrl}`, | |
| }); | |
| try { | |
| await open(extensionsUrl); | |
| } catch { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Failed to open browser. Check out the extensions gallery at ${extensionsUrl}`, | |
| }); | |
| } | |
| } | |
| } | |
| function getEnableDisableContext( | |
| context: CommandContext, | |
| argumentsString: string, | |
| ): { | |
| extensionManager: ExtensionManager; | |
| names: string[]; | |
| scope: SettingScope; | |
| } | null { | |
| const extensionLoader = | |
| context.services.agentContext?.config.getExtensionLoader(); | |
| if (!(extensionLoader instanceof ExtensionManager)) { | |
| debugLogger.error( | |
| `Cannot ${context.invocation?.name} extensions in this environment`, | |
| ); | |
| return null; | |
| } | |
| const parts = argumentsString.split(' '); | |
| const name = parts[0]; | |
| if ( | |
| name === '' || | |
| !( | |
| (parts.length === 2 && parts[1].startsWith('--scope=')) || // --scope=<scope> | |
| (parts.length === 3 && parts[1] === '--scope') // --scope <scope> | |
| ) | |
| ) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Usage: /extensions ${context.invocation?.name} <extension> [--scope=<user|workspace|session>]`, | |
| }); | |
| return null; | |
| } | |
| let scope: SettingScope; | |
| // Transform `--scope=<scope>` to `--scope <scope>`. | |
| if (parts.length === 2) { | |
| parts.push(...parts[1].split('=')); | |
| parts.splice(1, 1); | |
| } | |
| switch (parts[2].toLowerCase()) { | |
| case 'workspace': | |
| scope = SettingScope.Workspace; | |
| break; | |
| case 'user': | |
| scope = SettingScope.User; | |
| break; | |
| case 'session': | |
| scope = SettingScope.Session; | |
| break; | |
| default: | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Unsupported scope ${parts[2]}, should be one of "user", "workspace", or "session"`, | |
| }); | |
| debugLogger.error(); | |
| return null; | |
| } | |
| let names: string[] = []; | |
| if (name === '--all') { | |
| let extensions = extensionLoader.getExtensions(); | |
| if (context.invocation?.name === 'enable') { | |
| extensions = extensions.filter((ext) => !ext.isActive); | |
| } | |
| if (context.invocation?.name === 'disable') { | |
| extensions = extensions.filter((ext) => ext.isActive); | |
| } | |
| names = extensions.map((ext) => ext.name); | |
| } else { | |
| names = [name]; | |
| } | |
| return { | |
| extensionManager: extensionLoader, | |
| names, | |
| scope, | |
| }; | |
| } | |
| async function disableAction(context: CommandContext, args: string) { | |
| const enableContext = getEnableDisableContext(context, args); | |
| if (!enableContext) return; | |
| const { names, scope, extensionManager } = enableContext; | |
| for (const name of names) { | |
| await extensionManager.disableExtension(name, scope); | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Extension "${name}" disabled for the scope "${scope}"`, | |
| }); | |
| } | |
| } | |
| async function enableAction(context: CommandContext, args: string) { | |
| const enableContext = getEnableDisableContext(context, args); | |
| if (!enableContext) return; | |
| const { names, scope, extensionManager } = enableContext; | |
| for (const name of names) { | |
| await extensionManager.enableExtension(name, scope); | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Extension "${name}" enabled for the scope "${scope}"`, | |
| }); | |
| // Auto-enable any disabled MCP servers for this extension | |
| const extension = extensionManager | |
| .getExtensions() | |
| .find((e) => e.name === name); | |
| if (extension?.mcpServers) { | |
| const mcpEnablementManager = McpServerEnablementManager.getInstance(); | |
| const mcpClientManager = | |
| context.services.agentContext?.config.getMcpClientManager(); | |
| const enabledServers = await mcpEnablementManager.autoEnableServers( | |
| Object.keys(extension.mcpServers ?? {}), | |
| ); | |
| if (mcpClientManager && enabledServers.length > 0) { | |
| const restartPromises = enabledServers.map((serverName) => | |
| mcpClientManager.restartServer(serverName).catch((error) => { | |
| context.ui.addItem({ | |
| type: MessageType.WARNING, | |
| text: `Failed to restart MCP server '${serverName}': ${getErrorMessage(error)}`, | |
| }); | |
| }), | |
| ); | |
| await Promise.all(restartPromises); | |
| } | |
| if (enabledServers.length > 0) { | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Re-enabled MCP servers: ${enabledServers.join(', ')}`, | |
| }); | |
| } | |
| } | |
| } | |
| } | |
| async function installAction( | |
| context: CommandContext, | |
| args: string, | |
| requestConsentOverride?: (consent: string) => Promise<boolean>, | |
| ) { | |
| const extensionLoader = | |
| context.services.agentContext?.config.getExtensionLoader(); | |
| if (!(extensionLoader instanceof ExtensionManager)) { | |
| debugLogger.error( | |
| `Cannot ${context.invocation?.name} extensions in this environment`, | |
| ); | |
| return; | |
| } | |
| const source = args.trim(); | |
| if (!source) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Usage: /extensions install <source>`, | |
| }); | |
| return; | |
| } | |
| // Validate that the source is either a valid URL or a valid file path. | |
| let isValid = false; | |
| try { | |
| // Check if it's a valid URL. | |
| new URL(source); | |
| isValid = true; | |
| } catch { | |
| // If not a URL, check for characters that are disallowed in file paths | |
| // and could be used for command injection. | |
| if (!/[;&|`'"]/.test(source)) { | |
| isValid = true; | |
| } | |
| } | |
| if (!isValid) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Invalid source: ${source}`, | |
| }); | |
| return; | |
| } | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Installing extension from "${source}"...`, | |
| }); | |
| try { | |
| const installMetadata = await inferInstallMetadata(source); | |
| const extension = await extensionLoader.installOrUpdateExtension( | |
| installMetadata, | |
| undefined, | |
| requestConsentOverride, | |
| ); | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Extension "${extension.name}" installed successfully.`, | |
| }); | |
| } catch (error) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Failed to install extension from "${source}": ${getErrorMessage( | |
| error, | |
| )}`, | |
| }); | |
| } | |
| } | |
| async function linkAction( | |
| context: CommandContext, | |
| args: string, | |
| requestConsentOverride?: (consent: string) => Promise<boolean>, | |
| ) { | |
| const extensionLoader = | |
| context.services.agentContext?.config.getExtensionLoader(); | |
| if (!(extensionLoader instanceof ExtensionManager)) { | |
| debugLogger.error( | |
| `Cannot ${context.invocation?.name} extensions in this environment`, | |
| ); | |
| return; | |
| } | |
| const sourceFilepath = args.trim(); | |
| if (!sourceFilepath) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Usage: /extensions link <source>`, | |
| }); | |
| return; | |
| } | |
| if (/[;&|`'"]/.test(sourceFilepath)) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Source file path contains disallowed characters: ${sourceFilepath}`, | |
| }); | |
| return; | |
| } | |
| try { | |
| await stat(sourceFilepath); | |
| } catch (error) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Invalid source: ${sourceFilepath}`, | |
| }); | |
| debugLogger.error( | |
| `Failed to stat path "${sourceFilepath}": ${getErrorMessage(error)}`, | |
| ); | |
| return; | |
| } | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Linking extension from "${sourceFilepath}"...`, | |
| }); | |
| try { | |
| const installMetadata: ExtensionInstallMetadata = { | |
| source: sourceFilepath, | |
| type: 'link', | |
| }; | |
| const extension = await extensionLoader.installOrUpdateExtension( | |
| installMetadata, | |
| undefined, | |
| requestConsentOverride, | |
| ); | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Extension "${extension.name}" linked successfully.`, | |
| }); | |
| } catch (error) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Failed to link extension from "${sourceFilepath}": ${getErrorMessage( | |
| error, | |
| )}`, | |
| }); | |
| } | |
| } | |
| async function uninstallAction(context: CommandContext, args: string) { | |
| const extensionLoader = | |
| context.services.agentContext?.config.getExtensionLoader(); | |
| if (!(extensionLoader instanceof ExtensionManager)) { | |
| debugLogger.error( | |
| `Cannot ${context.invocation?.name} extensions in this environment`, | |
| ); | |
| return; | |
| } | |
| const uninstallArgs = args.split(' ').filter((value) => value.length > 0); | |
| const all = uninstallArgs.includes('--all'); | |
| const names = uninstallArgs.filter((a) => !a.startsWith('--')); | |
| if (!all && names.length === 0) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Usage: /extensions uninstall <extension-names...>|--all`, | |
| }); | |
| return; | |
| } | |
| let namesToUninstall: string[] = []; | |
| if (all) { | |
| namesToUninstall = extensionLoader.getExtensions().map((ext) => ext.name); | |
| } else { | |
| namesToUninstall = names; | |
| } | |
| if (namesToUninstall.length === 0) { | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: all ? 'No extensions installed.' : 'No extension name provided.', | |
| }); | |
| return; | |
| } | |
| for (const extensionName of namesToUninstall) { | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Uninstalling extension "${extensionName}"...`, | |
| }); | |
| try { | |
| await extensionLoader.uninstallExtension(extensionName, false); | |
| context.ui.addItem({ | |
| type: MessageType.INFO, | |
| text: `Extension "${extensionName}" uninstalled successfully.`, | |
| }); | |
| } catch (error) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: `Failed to uninstall extension "${extensionName}": ${getErrorMessage( | |
| error, | |
| )}`, | |
| }); | |
| } | |
| } | |
| } | |
| async function configAction(context: CommandContext, args: string) { | |
| const parts = args.trim().split(/\s+/).filter(Boolean); | |
| let scope = ExtensionSettingScope.USER; | |
| const scopeEqIndex = parts.findIndex((p) => p.startsWith('--scope=')); | |
| if (scopeEqIndex > -1) { | |
| const scopeVal = parts[scopeEqIndex].split('=')[1]; | |
| if (scopeVal === 'workspace') { | |
| scope = ExtensionSettingScope.WORKSPACE; | |
| } else if (scopeVal === 'user') { | |
| scope = ExtensionSettingScope.USER; | |
| } | |
| parts.splice(scopeEqIndex, 1); | |
| } else { | |
| const scopeIndex = parts.indexOf('--scope'); | |
| if (scopeIndex > -1) { | |
| const scopeVal = parts[scopeIndex + 1]; | |
| if (scopeVal === 'workspace' || scopeVal === 'user') { | |
| scope = | |
| scopeVal === 'workspace' | |
| ? ExtensionSettingScope.WORKSPACE | |
| : ExtensionSettingScope.USER; | |
| parts.splice(scopeIndex, 2); | |
| } | |
| } | |
| } | |
| const otherArgs = parts; | |
| const name = otherArgs[0]; | |
| const setting = otherArgs[1]; | |
| if (name) { | |
| if (name.includes('/') || name.includes('\\') || name.includes('..')) { | |
| context.ui.addItem({ | |
| type: MessageType.ERROR, | |
| text: 'Invalid extension name. Names cannot contain path separators or "..".', | |
| }); | |
| return; | |
| } | |
| } | |
| const extensionManager = | |
| context.services.agentContext?.config.getExtensionLoader(); | |
| if (!(extensionManager instanceof ExtensionManager)) { | |
| debugLogger.error( | |
| `Cannot ${context.invocation?.name} extensions in this environment`, | |
| ); | |
| return; | |
| } | |
| const logger: ConfigLogger = { | |
| log: (message: string) => { | |
| context.ui.addItem({ type: MessageType.INFO, text: message.trim() }); | |
| }, | |
| error: (message: string) => | |
| context.ui.addItem({ type: MessageType.ERROR, text: message }), | |
| }; | |
| return { | |
| type: 'custom_dialog' as const, | |
| component: React.createElement(ConfigExtensionDialog, { | |
| extensionManager, | |
| onClose: () => context.ui.removeComponent(), | |
| extensionName: name, | |
| settingKey: setting, | |
| scope, | |
| configureAll: !name && !setting, | |
| loggerAdapter: logger, | |
| }), | |
| }; | |
| } | |
| /** | |
| * Exported for testing. | |
| */ | |
| export function completeExtensions( | |
| context: CommandContext, | |
| partialArg: string, | |
| ) { | |
| let extensions = context.services.agentContext?.config.getExtensions() ?? []; | |
| if (context.invocation?.name === 'enable') { | |
| extensions = extensions.filter((ext) => !ext.isActive); | |
| } | |
| if ( | |
| context.invocation?.name === 'disable' || | |
| context.invocation?.name === 'restart' || | |
| context.invocation?.name === 'reload' | |
| ) { | |
| extensions = extensions.filter((ext) => ext.isActive); | |
| } | |
| const extensionNames = extensions.map((ext) => ext.name); | |
| const suggestions = extensionNames.filter((name) => | |
| name.startsWith(partialArg), | |
| ); | |
| if ('--all'.startsWith(partialArg) || 'all'.startsWith(partialArg)) { | |
| suggestions.unshift('--all'); | |
| } | |
| return suggestions; | |
| } | |
| export function completeExtensionsAndScopes( | |
| context: CommandContext, | |
| partialArg: string, | |
| ) { | |
| return completeExtensions(context, partialArg).flatMap((s) => [ | |
| `${s} --scope user`, | |
| `${s} --scope workspace`, | |
| `${s} --scope session`, | |
| ]); | |
| } | |
| const listExtensionsCommand: SlashCommand = { | |
| name: 'list', | |
| description: 'List active extensions', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: true, | |
| takesArgs: false, | |
| action: listAction, | |
| }; | |
| const updateExtensionsCommand: SlashCommand = { | |
| name: 'update', | |
| description: 'Update extensions. Usage: update <extension-names>|--all', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: false, | |
| action: updateAction, | |
| completion: completeExtensions, | |
| }; | |
| const disableCommand: SlashCommand = { | |
| name: 'disable', | |
| description: 'Disable an extension', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: false, | |
| action: disableAction, | |
| completion: completeExtensionsAndScopes, | |
| }; | |
| const enableCommand: SlashCommand = { | |
| name: 'enable', | |
| description: 'Enable an extension', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: false, | |
| action: enableAction, | |
| completion: completeExtensionsAndScopes, | |
| }; | |
| const installCommand: SlashCommand = { | |
| name: 'install', | |
| description: 'Install an extension from a git repo or local path', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: false, | |
| action: installAction, | |
| }; | |
| const linkCommand: SlashCommand = { | |
| name: 'link', | |
| description: 'Link an extension from a local path', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: false, | |
| action: linkAction, | |
| }; | |
| const uninstallCommand: SlashCommand = { | |
| name: 'uninstall', | |
| altNames: ['delete'], | |
| description: 'Uninstall an extension', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: false, | |
| action: uninstallAction, | |
| completion: completeExtensions, | |
| }; | |
| const exploreExtensionsCommand: SlashCommand = { | |
| name: 'explore', | |
| description: 'Open extensions page in your browser', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: true, | |
| takesArgs: false, | |
| action: exploreAction, | |
| }; | |
| const reloadCommand: SlashCommand = { | |
| name: 'reload', | |
| altNames: ['restart'], | |
| description: 'Reload all extensions', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: false, | |
| action: restartAction, | |
| completion: completeExtensions, | |
| }; | |
| const configCommand: SlashCommand = { | |
| name: 'config', | |
| description: 'Configure extension settings', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: false, | |
| action: configAction, | |
| }; | |
| import { parseSlashCommand } from '../../utils/commands.js'; | |
| export function extensionsCommand( | |
| enableExtensionReloading?: boolean, | |
| ): SlashCommand { | |
| const conditionalCommands = enableExtensionReloading | |
| ? [ | |
| disableCommand, | |
| enableCommand, | |
| installCommand, | |
| uninstallCommand, | |
| linkCommand, | |
| configCommand, | |
| ] | |
| : []; | |
| const subCommands = [ | |
| listExtensionsCommand, | |
| updateExtensionsCommand, | |
| exploreExtensionsCommand, | |
| reloadCommand, | |
| ...conditionalCommands, | |
| ]; | |
| return { | |
| name: 'extensions', | |
| description: 'Manage extensions', | |
| kind: CommandKind.BUILT_IN, | |
| autoExecute: false, | |
| subCommands, | |
| action: async (context, args) => { | |
| if (args) { | |
| const parsed = parseSlashCommand(`/${args}`, subCommands); | |
| if (parsed.commandToExecute?.action) { | |
| return parsed.commandToExecute.action(context, parsed.args); | |
| } | |
| } | |
| // Default to list if no subcommand is provided | |
| return listExtensionsCommand.action!(context, args); | |
| }, | |
| }; | |
| } | |