vscode-mcp-comprehensive
Version:
Comprehensive MCP server exposing all VSCode features to AI agents with 101 tools including advanced debugging and console access
302 lines • 11.9 kB
JavaScript
import * as vscode from 'vscode';
export class CommandTools {
constructor(server) {
this.server = server;
this.registerTools();
}
registerTools() {
// Execute command
this.server.registerTool('command_execute', 'Execute VSCode command', {
type: 'object',
properties: {
command: { type: 'string', description: 'Command identifier' },
args: {
type: 'array',
description: 'Command arguments',
items: {}
},
},
required: ['command'],
}, this.executeCommand.bind(this));
// Get all commands
this.server.registerTool('command_get_all', 'List all available commands', {
type: 'object',
properties: {
filterText: { type: 'string', description: 'Filter commands by text' },
},
}, this.getAllCommands.bind(this));
// Register command
this.server.registerTool('command_register', 'Register custom command', {
type: 'object',
properties: {
command: { type: 'string', description: 'Command identifier' },
title: { type: 'string', description: 'Command title' },
category: { type: 'string', description: 'Command category' },
},
required: ['command', 'title'],
}, this.registerCommand.bind(this));
}
async executeCommand(args) {
try {
this.server.validateRequiredParams(args, ['command']);
const result = await vscode.commands.executeCommand(args.command, ...(args.args || []));
return this.server.createSuccessResponse({
command: args.command,
result: result,
success: true,
}, `Command '${args.command}' executed`);
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
async getAllCommands(args) {
try {
const commands = await vscode.commands.getCommands(true);
let filteredCommands = commands;
if (args.filterText) {
const filter = args.filterText.toLowerCase();
filteredCommands = commands.filter(cmd => cmd.toLowerCase().includes(filter));
}
return this.server.createSuccessResponse({
commands: filteredCommands,
total: filteredCommands.length,
});
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
async registerCommand(args) {
try {
this.server.validateRequiredParams(args, ['command', 'title']);
// Note: This is a simplified implementation
// In a real extension, you'd register the command with proper handlers
const disposable = vscode.commands.registerCommand(args.command, () => {
vscode.window.showInformationMessage(`Custom command '${args.title}' executed`);
});
return this.server.createSuccessResponse({
command: args.command,
title: args.title,
registered: true,
}, `Command '${args.command}' registered`);
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
}
export class TaskTools {
constructor(server) {
this.server = server;
this.registerTools();
}
registerTools() {
// Execute task
this.server.registerTool('task_execute', 'Run task', {
type: 'object',
properties: {
taskName: { type: 'string', description: 'Task name or identifier' },
scope: { type: 'string', description: 'Task scope (workspace/folder)' },
},
required: ['taskName'],
}, this.executeTask.bind(this));
// Get all tasks
this.server.registerTool('task_get_all', 'List all tasks', {
type: 'object',
properties: {},
}, this.getAllTasks.bind(this));
// Terminate task
this.server.registerTool('task_terminate', 'Stop running task', {
type: 'object',
properties: {
taskName: { type: 'string', description: 'Task name to terminate' },
},
required: ['taskName'],
}, this.terminateTask.bind(this));
// Get running tasks
this.server.registerTool('task_get_running', 'Get currently running tasks', {
type: 'object',
properties: {},
}, this.getRunningTasks.bind(this));
}
async executeTask(args) {
try {
this.server.validateRequiredParams(args, ['taskName']);
const tasks = await vscode.tasks.fetchTasks();
const task = tasks.find(t => t.name === args.taskName);
if (!task) {
return this.server.createErrorResponse(`Task '${args.taskName}' not found`);
}
const execution = await vscode.tasks.executeTask(task);
return this.server.createSuccessResponse({
taskName: args.taskName,
executionId: execution.task.name,
started: true,
}, `Task '${args.taskName}' started`);
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
async getAllTasks() {
try {
const tasks = await vscode.tasks.fetchTasks();
const taskInfo = tasks.map(task => ({
name: task.name,
source: task.source,
definition: task.definition,
scope: task.scope,
execution: task.execution,
}));
return this.server.createSuccessResponse({
tasks: taskInfo,
count: taskInfo.length,
});
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
async terminateTask(args) {
try {
this.server.validateRequiredParams(args, ['taskName']);
// Note: VSCode doesn't provide direct access to terminate specific tasks by name
// This would need to be implemented by tracking task executions
await vscode.commands.executeCommand('workbench.action.tasks.terminate');
return this.server.createSuccessResponse({
taskName: args.taskName,
terminated: true,
}, `Task termination requested`);
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
async getRunningTasks() {
try {
// Note: VSCode doesn't provide direct access to running tasks
// This would need custom tracking implementation
return this.server.createSuccessResponse({
runningTasks: [],
note: 'Running task tracking requires custom implementation',
});
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
}
export class ExtensionTools {
constructor(server) {
this.server = server;
this.registerTools();
}
registerTools() {
// Get all extensions
this.server.registerTool('extension_get_all', 'List all extensions', {
type: 'object',
properties: {
includeBuiltIn: { type: 'boolean', description: 'Include built-in extensions', default: false },
},
}, this.getAllExtensions.bind(this));
// Get extension by ID
this.server.registerTool('extension_get_by_id', 'Get specific extension', {
type: 'object',
properties: {
extensionId: { type: 'string', description: 'Extension identifier' },
},
required: ['extensionId'],
}, this.getExtensionById.bind(this));
// Check if extension is active
this.server.registerTool('extension_is_active', 'Check if extension is active', {
type: 'object',
properties: {
extensionId: { type: 'string', description: 'Extension identifier' },
},
required: ['extensionId'],
}, this.isExtensionActive.bind(this));
// Get extension configuration
this.server.registerTool('extension_get_configuration', 'Get extension configuration', {
type: 'object',
properties: {
extensionId: { type: 'string', description: 'Extension identifier' },
},
required: ['extensionId'],
}, this.getExtensionConfiguration.bind(this));
}
async getAllExtensions(args) {
try {
const extensions = vscode.extensions.all.filter(ext => args.includeBuiltIn || !ext.packageJSON.isBuiltin);
const extensionInfo = extensions.map(ext => ({
id: ext.id,
extensionPath: ext.extensionPath,
isActive: ext.isActive,
packageJSON: ext.packageJSON,
}));
return this.server.createSuccessResponse({
extensions: extensionInfo,
count: extensionInfo.length,
});
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
async getExtensionById(args) {
try {
this.server.validateRequiredParams(args, ['extensionId']);
const extension = vscode.extensions.getExtension(args.extensionId);
if (!extension) {
return this.server.createErrorResponse(`Extension '${args.extensionId}' not found`);
}
const extensionInfo = {
id: extension.id,
extensionPath: extension.extensionPath,
isActive: extension.isActive,
packageJSON: extension.packageJSON,
};
return this.server.createSuccessResponse(extensionInfo);
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
async isExtensionActive(args) {
try {
this.server.validateRequiredParams(args, ['extensionId']);
const extension = vscode.extensions.getExtension(args.extensionId);
if (!extension) {
return this.server.createErrorResponse(`Extension '${args.extensionId}' not found`);
}
return this.server.createSuccessResponse({
extensionId: args.extensionId,
isActive: extension.isActive,
});
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
async getExtensionConfiguration(args) {
try {
this.server.validateRequiredParams(args, ['extensionId']);
const extension = vscode.extensions.getExtension(args.extensionId);
if (!extension) {
return this.server.createErrorResponse(`Extension '${args.extensionId}' not found`);
}
// Get configuration section for the extension
const config = vscode.workspace.getConfiguration(extension.packageJSON.name);
const configData = JSON.parse(JSON.stringify(config));
return this.server.createSuccessResponse({
extensionId: args.extensionId,
configuration: configData,
contributes: extension.packageJSON.contributes,
});
}
catch (error) {
return this.server.createErrorResponse(error);
}
}
}
//# sourceMappingURL=otherTools.js.map