Fix mcp setting application

Signed-off-by: James Ostrander <jostrand@redhat.com>

Author: jlost

.vscode/launch.json

@@ -16,6 +16,17 @@
       "args": ["--extensionDevelopmentPath=${workspaceFolder}"],
       "outFiles": ["${workspaceFolder}/dist/**/*.js"],
       "preLaunchTask": "npm: build"
+    },
+    {
+      "name": "Run Extension (kserve workspace)",
+      "type": "extensionHost",
+      "request": "launch",
+      "args": [
+        "--extensionDevelopmentPath=${workspaceFolder}",
+        "/home/jostrand/projects/kserve"
+      ],
+      "outFiles": ["${workspaceFolder}/dist/**/*.js"],
+      "preLaunchTask": "npm: build"
     }
   ]
 }

README.md

@@ -98,20 +98,30 @@ Each launch configuration defined in your workspace becomes a tool named `launch
 
 ### ⚙️ MCP Options
 
-Tasks and launch configurations support an optional `mcp` block for MCP-specific settings. Hover over options in your editor for full documentation.
+Tasks support MCP options inside the `options` block. Launch configurations use them at the top level (you'll see a schema warning, but it works correctly). Hover over options in your editor for full documentation.
 
+**Task example:**
 ```json
 {
   "label": "Build",
   "type": "shell",
   "command": "npm run build",
-  "mcp": {
-    "returnOutput": "onFailure",
-    "interactive": true
+  "options": {
+    "mcp": { "returnOutput": "onFailure", "interactive": true }
   }
 }
 ```
 
+**Launch example:**
+```json
+{
+  "name": "Debug",
+  "type": "node",
+  "request": "launch",
+  "mcp": { "preserveConsole": true }
+}
+```
+
 | Option | Default | Description |
 |--------|---------|-------------|
 | `returnOutput` | `onFailure` | When to include output: `always`, `onFailure`, `never` |

esbuild.js

@@ -12,6 +12,9 @@ const buildOptions = {
   target: 'node18',
   sourcemap: true,
   minify: !isWatch,
+  // Prefer ESM modules over CommonJS/UMD to ensure static imports are used.
+  // This fixes bundling issues with jsonc-parser which has dynamic requires in its UMD build.
+  mainFields: ['module', 'main'],
 };
 
 async function build() {

package-lock.json

@@ -64,7 +64,10 @@
       "title": "Ignition MCP",
       "properties": {
         "ignition-mcp.outputLimit": {
-          "type": ["integer", "null"],
+          "type": [
+            "integer",
+            "null"
+          ],
           "default": 20480,
           "minimum": 1024,
           "description": "Default maximum characters to capture from task and debug output. Can be overridden per-task/launch via mcp.outputLimit in tasks.json/launch.json. Set to null for unlimited. Default is 20480 (20KB)."
@@ -98,6 +101,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "jsonc-parser": "^3.3.1",
     "zod": "^3.22.0"
   }
 }

package.json

@@ -9,7 +9,7 @@
         "properties": {
           "mcp": {
             "type": "object",
-            "description": "MCP-specific options for Ignition MCP extension. Controls how AI assistants interact with this debug configuration.",
+            "description": "MCP-specific options for Ignition MCP extension. Note: VS Code may show a schema warning for this property, but it works correctly.",
             "properties": {
               "returnOutput": {
                 "type": "string",

schemas/launch-mcp.schema.json

@@ -7,29 +7,34 @@
       "items": {
         "type": "object",
         "properties": {
-          "mcp": {
+          "options": {
             "type": "object",
-            "description": "MCP-specific options for Ignition MCP extension. Controls how AI assistants interact with this task.",
             "properties": {
-              "returnOutput": {
-                "type": "string",
-                "enum": ["always", "onFailure", "never"],
-                "default": "onFailure",
-                "markdownDescription": "Controls when terminal output is included in MCP tool responses.\n\n- `always` - Always include full terminal output\n- `onFailure` - Only include output when exit code != 0 (default)\n- `never` - Never include output; use `get_task_output` to retrieve separately\n\nHelps manage AI context size: successful builds don't need hundreds of lines of output, but failed builds should include error details."
-              },
-              "outputLimit": {
-                "type": ["integer", "null"],
-                "minimum": 1024,
-                "default": 20480,
-                "markdownDescription": "Maximum characters to capture from task output. Default is 20480 (20KB). Set to `null` for unlimited. Overrides the global `ignition-mcp.outputLimit` setting."
-              },
-              "interactive": {
-                "type": "boolean",
-                "default": false,
-                "markdownDescription": "Run task in VS Code's native terminal with full TTY support for interactive input.\n\n**Use when:**\n- Task runs `sudo` commands requiring password input\n- Task prompts for user confirmation (y/n)\n- Commands use `read` or similar interactive input\n- Any command requiring TTY support\n\n**Trade-off:** Output cannot be captured in this mode. The MCP response will show `[Interactive mode: output not captured]`. The terminal will open with focus so the user can interact."
+              "mcp": {
+                "type": "object",
+                "description": "MCP-specific options for Ignition MCP extension. Controls how AI assistants interact with this task.",
+                "properties": {
+                  "returnOutput": {
+                    "type": "string",
+                    "enum": ["always", "onFailure", "never"],
+                    "default": "onFailure",
+                    "markdownDescription": "Controls when terminal output is included in MCP tool responses.\n\n- `always` - Always include full terminal output\n- `onFailure` - Only include output when exit code != 0 (default)\n- `never` - Never include output; use `get_task_output` to retrieve separately\n\nHelps manage AI context size: successful builds don't need hundreds of lines of output, but failed builds should include error details."
+                  },
+                  "outputLimit": {
+                    "type": ["integer", "null"],
+                    "minimum": 1024,
+                    "default": 20480,
+                    "markdownDescription": "Maximum characters to capture from task output. Default is 20480 (20KB). Set to `null` for unlimited. Overrides the global `ignition-mcp.outputLimit` setting."
+                  },
+                  "interactive": {
+                    "type": "boolean",
+                    "default": false,
+                    "markdownDescription": "Run task in VS Code's native terminal with full TTY support for interactive input.\n\n**Use when:**\n- Task runs `sudo` commands requiring password input\n- Task prompts for user confirmation (y/n)\n- Commands use `read` or similar interactive input\n- Any command requiring TTY support\n\n**Trade-off:** Output cannot be captured in this mode. The MCP response will show `[Interactive mode: output not captured]`. The terminal will open with focus so the user can interact."
+                  }
+                },
+                "additionalProperties": false
               }
-            },
-            "additionalProperties": false
+            }
           }
         }
       }

schemas/tasks-mcp.schema.json

@@ -26,6 +26,7 @@ export async function activate(context: vscode.ExtensionContext) {
   context.subscriptions.push(outputChannel);
   log('Ignition MCP extension activating...');
   taskManager = new TaskManager();
+  taskManager.setOutputChannel(outputChannel);
   launchManager = new LaunchManager();
   context.subscriptions.push(taskManager);
   context.subscriptions.push(launchManager);
@@ -125,6 +126,9 @@ async function enableServer() {
   try {
     log(`Starting MCP server on port ${currentPort}...`);
     mcpServer = new MCPServer(taskManager, launchManager, currentPort, handleShutdownRequested);
+    if (outputChannel) {
+      mcpServer.setOutputChannel(outputChannel);
+    }
     await mcpServer.start();
     serverState = 'running';
     updateStatusBar();

src/extension.ts

@@ -1,4 +1,5 @@
 import * as http from 'http';
+import * as vscode from 'vscode';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { z } from 'zod';
@@ -17,6 +18,7 @@ export class MCPServer {
   private taskManager: TaskManager;
   private launchManager: LaunchManager;
   private onShutdownRequested?: ShutdownCallback;
+  private outputChannel: vscode.OutputChannel | null = null;
 
   constructor(
     taskManager: TaskManager,
@@ -34,6 +36,17 @@ export class MCPServer {
     });
   }
 
+  setOutputChannel(channel: vscode.OutputChannel) {
+    this.outputChannel = channel;
+  }
+
+  private log(message: string) {
+    const timestamp = new Date().toLocaleTimeString();
+    const fullMessage = `[${timestamp}] [MCPServer] ${message}`;
+    this.outputChannel?.appendLine(fullMessage);
+    console.log(fullMessage);
+  }
+
   private sanitizeToolName(name: string, prefix: string): string {
     return prefix + name
       .toLowerCase()
@@ -289,7 +302,7 @@ export class MCPServer {
     for (const task of tasks) {
       this.registerTaskTool(task);
     }
-    console.log(`Registered ${tasks.length} task tools`);
+    this.log(`Registered ${tasks.length} task tools`);
   }
 
   private buildInputSchema(inputs: InputDefinition[]): Record<string, z.ZodOptional<z.ZodString>> {
@@ -481,7 +494,7 @@ export class MCPServer {
     for (const config of configs) {
       this.registerLaunchTool(config);
     }
-    console.log(`Registered ${configs.length} launch tools`);
+    this.log(`Registered ${configs.length} launch tools`);
   }
 
   private registerLaunchTool(config: LaunchInfo) {
@@ -593,7 +606,7 @@ export class MCPServer {
       });
       // Explicitly listen on 0.0.0.0 to ensure both IPv4 and IPv6 work via loopback
       this.server.listen(this.port, '0.0.0.0', () => {
-        console.log(`MCP server listening on port ${this.port}`);
+        this.log(`MCP server listening on port ${this.port}`);
         resolve();
       });
     });
@@ -608,7 +621,7 @@ export class MCPServer {
     try {
       await this.transport.handleRequest(req, res);
     } catch (error) {
-      console.error('Error handling MCP request:', error);
+      this.log(`Error handling MCP request: ${error}`);
       if (!res.headersSent) {
         res.writeHead(500);
         res.end('Internal server error');

src/server/mcpServer.ts

@@ -2,6 +2,7 @@ import * as vscode from 'vscode';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as cp from 'child_process';
+import * as jsonc from 'jsonc-parser';
 
 export interface TaskInputDefinition {
   id: string;
@@ -137,6 +138,7 @@ export class TaskManager implements vscode.Disposable {
   private executionToId: Map<vscode.TaskExecution, string> = new Map();
   private interactiveExecutionIds: Set<string> = new Set();
   private disposables: vscode.Disposable[] = [];
+  private outputChannel: vscode.OutputChannel | null = null;
 
   constructor() {
     this.disposables.push(
@@ -146,6 +148,17 @@ export class TaskManager implements vscode.Disposable {
     );
   }
 
+  setOutputChannel(channel: vscode.OutputChannel) {
+    this.outputChannel = channel;
+  }
+
+  private log(message: string) {
+    const timestamp = new Date().toLocaleTimeString();
+    const fullMessage = `[${timestamp}] [TaskManager] ${message}`;
+    this.outputChannel?.appendLine(fullMessage);
+    console.log(fullMessage);
+  }
+
   private getDefaultOutputLimit(): number | null {
     const config = vscode.workspace.getConfiguration('ignition-mcp');
     return config.get<number | null>('outputLimit', 20480);
@@ -167,18 +180,32 @@ export class TaskManager implements vscode.Disposable {
   }
 
   async listTasks(): Promise<TaskInfo[]> {
+    this.log(`listTasks called`);
     const tasks = await vscode.tasks.fetchTasks();
+    this.log(`Found ${tasks.length} VS Code tasks`);
     const tasksJsonData = this.readTasksJson();
     const inputDefinitions = tasksJsonData?.inputs || [];
     const rawTasks = tasksJsonData?.tasks || [];
+    this.log(`Read ${rawTasks.length} tasks from tasks.json`);
     return tasks.map((task) => {
       const rawCommand = this.getRawCommand(task);
       const usedInputIds = this.findInputReferences(rawCommand);
       const inputs = usedInputIds.length > 0
         ? inputDefinitions.filter((inp: TaskInputDefinition) => usedInputIds.includes(inp.id))
         : undefined;
       const rawTaskEntry = rawTasks.find((t) => t.label === task.name);
-      const mcpOptions = rawTaskEntry?.mcp;
+      const mcpOptions = rawTaskEntry?.options?.mcp;
+      if (mcpOptions) {
+        this.log(`Task "${task.name}" has mcpOptions: ${JSON.stringify(mcpOptions)}`);
+      } else if (task.name === 'CRC Refresh') {
+        this.log(`Task "CRC Refresh" found but NO mcpOptions. rawTaskEntry: ${JSON.stringify(rawTaskEntry)}`);
+        this.log(`Task object keys: ${Object.keys(task)}`);
+        this.log(`Task definition: ${JSON.stringify(task.definition)}`);
+        const exec = task.execution;
+        if (exec && 'options' in exec) {
+          this.log(`Execution options: ${JSON.stringify((exec as { options?: unknown }).options)}`);
+        }
+      }
       return {
         name: task.name,
         source: task.source,
@@ -200,21 +227,33 @@ export class TaskManager implements vscode.Disposable {
 
   private readTasksJson(): { 
     inputs?: TaskInputDefinition[]; 
-    tasks?: Array<{ label?: string; mcp?: McpOptions }> 
+    tasks?: Array<{ label?: string; options?: { mcp?: McpOptions } }> 
   } | null {
     const workspaceFolders = vscode.workspace.workspaceFolders;
     if (!workspaceFolders || workspaceFolders.length === 0) {
+      this.log('readTasksJson: No workspace folders');
       return null;
     }
     const tasksJsonPath = path.join(workspaceFolders[0].uri.fsPath, '.vscode', 'tasks.json');
     if (!fs.existsSync(tasksJsonPath)) {
+      this.log(`readTasksJson: tasks.json not found at ${tasksJsonPath}`);
       return null;
     }
     try {
       const content = fs.readFileSync(tasksJsonPath, 'utf-8');
-      const cleanedContent = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
-      return JSON.parse(cleanedContent);
-    } catch {
+      const errors: jsonc.ParseError[] = [];
+      const parsed = jsonc.parse(content, errors, { allowTrailingComma: true });
+      if (errors.length > 0) {
+        this.log(`readTasksJson: JSONC parse warnings: ${errors.map(e => jsonc.printParseErrorCode(e.error)).join(', ')}`);
+      }
+      this.log(`readTasksJson: Successfully parsed tasks.json from ${tasksJsonPath}`);
+      const tasksWithMcp = parsed?.tasks?.filter((t: { options?: { mcp?: McpOptions } }) => t.options?.mcp);
+      if (tasksWithMcp?.length > 0) {
+        this.log(`Tasks with mcp options: ${tasksWithMcp.map((t: { label?: string }) => t.label).join(', ')}`);
+      }
+      return parsed;
+    } catch (err) {
+      this.log(`readTasksJson: Error parsing tasks.json: ${err}`);
       return null;
     }
   }
@@ -259,6 +298,7 @@ export class TaskManager implements vscode.Disposable {
   }
 
   async runTask(taskName: string, inputValues?: Record<string, string>, mcpOptions?: McpOptions): Promise<TaskRunResult> {
+    this.log(`runTask called for "${taskName}" with mcpOptions: ${JSON.stringify(mcpOptions)}`);
     const tasks = await vscode.tasks.fetchTasks();
     const task = tasks.find((t) => t.name === taskName);
     if (!task) {
@@ -278,8 +318,10 @@ export class TaskManager implements vscode.Disposable {
         this.outputLimits.set(executionId, mcpOptions.outputLimit);
       }
       if (mcpOptions?.interactive) {
+        this.log(`Running task "${taskName}" in INTERACTIVE mode`);
         return this.runTaskInteractive(task, executionId, inputValues);
       }
+      this.log(`Running task "${taskName}" in CAPTURE mode`);
       let rawCommand = this.getRawCommand(task);
       if (inputValues && Object.keys(inputValues).length > 0) {
         for (const [inputId, value] of Object.entries(inputValues)) {