@mxf-dev/core 2.0.5 → 3.0.0

package/src/protocols/mcp/tools/CodeAnalysisTools.ts

@@ -23,6 +23,7 @@ import { executeShellCommand } from './InfrastructureTools.js';
 import { paginationInputSchema, paginateArray, paginateMultipleArrays, checkResultSize } from '../../../utils/ToolPaginationUtils.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { resolveWorkspacePath } from '../security/McpToolPolicy.js';
 
 const logger = new Logger('info', 'CodeAnalysisTools', 'server');
 
@@ -234,7 +235,10 @@ export const analyzeCodebaseTool = {
     handler: async (args: any, context: any) => {
         
         try {
-            const workingDir = args.workingDirectory || process.cwd();
+            const workingDir = resolveWorkspacePath(
+                args.workingDirectory,
+                'analyze_codebase workingDirectory'
+            );
             const analysis: {
                 structure: any;
                 dependencies: any;
@@ -284,7 +288,11 @@ export const analyzeCodebaseTool = {
 
                 // Analyze dependencies using package.json
                 try {
-                    const packageJson = await fs.readFile(path.join(workingDir, 'package.json'), 'utf-8');
+                    const packageJsonPath = resolveWorkspacePath(
+                        path.join(workingDir, 'package.json'),
+                        'analyze_codebase package.json'
+                    );
+                    const packageJson = await fs.readFile(packageJsonPath, 'utf-8');
                     const pkg = JSON.parse(packageJson);
                     analysis.dependencies = {
                         production: Object.keys(pkg.dependencies || {}),
@@ -297,7 +305,10 @@ export const analyzeCodebaseTool = {
 
                 // Analyze TypeScript configuration
                 try {
-                    const tsconfigPath = path.join(workingDir, 'tsconfig.json');
+                    const tsconfigPath = resolveWorkspacePath(
+                        path.join(workingDir, 'tsconfig.json'),
+                        'analyze_codebase tsconfig.json'
+                    );
                     const tsconfig = await fs.readFile(tsconfigPath, 'utf-8');
                     const config = JSON.parse(tsconfig);
                     analysis.patterns = {
@@ -363,7 +374,10 @@ export const findFunctionsTool = {
     handler: async (args: any, context: any) => {
 
         try {
-            const workingDir = args.workingDirectory || process.cwd();
+            const workingDir = resolveWorkspacePath(
+                args.workingDirectory,
+                'find_functions workingDirectory'
+            );
             const limit = args.limit ?? 50;
             const offset = args.offset ?? 0;
             const allFunctions: any[] = [];
@@ -457,7 +471,10 @@ export const traceDependenciesTool = {
     handler: async (args: any, context: any) => {
 
         try {
-            const workingDir = args.workingDirectory || process.cwd();
+            const workingDir = resolveWorkspacePath(
+                args.workingDirectory,
+                'trace_dependencies workingDirectory'
+            );
             const limit = args.limit ?? 50;
             const offset = args.offset ?? 0;
             const allImports: any[] = [];
@@ -465,7 +482,10 @@ export const traceDependenciesTool = {
             const allDependents: any[] = [];
 
             // Read the target file
-            const fullPath = path.resolve(workingDir, args.filePath);
+            const fullPath = resolveWorkspacePath(
+                path.resolve(workingDir, args.filePath),
+                'trace_dependencies filePath'
+            );
             const content = await fs.readFile(fullPath, 'utf-8');
 
             // Extract imports
@@ -494,7 +514,7 @@ export const traceDependenciesTool = {
             }
 
             // Find files that import this file
-            const relativePath = path.relative(workingDir, args.filePath);
+            const relativePath = path.relative(workingDir, fullPath);
             const importPattern = relativePath.replace(/\\/g, '/').replace(/\.(ts|tsx|js|jsx)$/, '');
 
             const dependentsResult = await executeShellCommand('rg', [
@@ -580,13 +600,19 @@ export const suggestRefactoringTool = {
     handler: async (args: any, context: any) => {
 
         try {
-            const workingDir = args.workingDirectory || process.cwd();
+            const workingDir = resolveWorkspacePath(
+                args.workingDirectory,
+                'suggest_refactoring workingDirectory'
+            );
             const limit = args.limit ?? 50;
             const offset = args.offset ?? 0;
             const allSuggestions: any[] = [];
 
             // Read the file
-            const fullPath = path.resolve(workingDir, args.filePath);
+            const fullPath = resolveWorkspacePath(
+                path.resolve(workingDir, args.filePath),
+                'suggest_refactoring filePath'
+            );
             const content = await fs.readFile(fullPath, 'utf-8');
             const lines = content.split('\n');
 
@@ -673,23 +699,27 @@ export const validateArchitectureTool = {
             const allViolations: any[] = [];
 
             for (const filePath of args.filePaths) {
-                const content = await fs.readFile(filePath, 'utf-8');
+                const resolvedFilePath = resolveWorkspacePath(
+                    filePath,
+                    'validate_architecture filePath'
+                );
+                const content = await fs.readFile(resolvedFilePath, 'utf-8');
 
                 // Validate layering
                 if (args.rules.includes('layering')) {
-                    const layerViolations = validateLayering(filePath, content);
+                    const layerViolations = validateLayering(resolvedFilePath, content);
                     allViolations.push(...layerViolations);
                 }
 
                 // Validate dependencies
                 if (args.rules.includes('dependencies')) {
-                    const depViolations = validateDependencies(filePath, content);
+                    const depViolations = validateDependencies(resolvedFilePath, content);
                     allViolations.push(...depViolations);
                 }
 
                 // Validate naming
                 if (args.rules.includes('naming')) {
-                    const namingViolations = validateNaming(filePath, content);
+                    const namingViolations = validateNaming(resolvedFilePath, content);
                     allViolations.push(...namingViolations);
                 }
             }
@@ -727,4 +757,4 @@ export const codeAnalysisTools = [
     traceDependenciesTool,
     suggestRefactoringTool,
     validateArchitectureTool
-];
+];

package/src/protocols/mcp/tools/EffectivenessTools.ts

@@ -24,20 +24,97 @@
  * Enables agents to track and measure their own effectiveness
  */
 
-import { McpToolDefinition, McpToolHandlerResult } from '../McpServerTypes.js';
+import {
+    McpToolDefinition,
+    McpToolHandlerContext,
+    McpToolHandlerResult
+} from '../McpServerTypes.js';
 import { TaskEffectivenessService } from '../../../services/TaskEffectivenessService.js';
 import { AgentId } from '../../../types/Agent.js';
 import { ChannelId } from '../../../types/ChannelContext.js';
 import { 
     TaskDefinition,
     TaskExecutionEvent,
-    EffectivenessComparison,
-    EffectivenessAnalytics
+    TaskEffectivenessMetrics
 } from '../../../types/EffectivenessTypes.js';
 import { v4 as uuidv4 } from 'uuid';
 
+interface EffectivenessTenantIdentity {
+    agentId: AgentId;
+    channelId: ChannelId;
+}
+
+interface EffectivenessStartInput extends Record<string, unknown> {
+    taskType: string;
+    description: string;
+    successCriteria?: TaskDefinition['successCriteria'];
+    baselineMetrics?: {
+        completionTime?: number;
+        humanInterventions?: number;
+    };
+}
+
+interface EffectivenessEventInput extends Record<string, unknown> {
+    taskId: string;
+    eventType: TaskExecutionEvent['type'];
+    details?: Record<string, unknown>;
+}
+
+interface EffectivenessQualityInput extends Record<string, unknown> {
+    taskId: string;
+    completenessScore?: number;
+    iterationCount?: number;
+    customMetrics?: Record<string, number>;
+}
+
+interface EffectivenessCompleteInput extends Record<string, unknown> {
+    taskId: string;
+    success: boolean;
+    customMetrics?: Record<string, number>;
+}
+
+interface EffectivenessAnalyticsInput extends Record<string, unknown> {
+    timeRange: 'hour' | 'day' | 'week' | 'month';
+    taskType?: string;
+}
+
+interface EffectivenessCompareInput extends Record<string, unknown> {
+    taskId: string;
+}
+
+function requireTenantIdentity(context: McpToolHandlerContext): EffectivenessTenantIdentity {
+    if (!context.agentId?.trim() || !context.channelId?.trim() ||
+        context.agentId !== context.agentId.trim() ||
+        context.channelId !== context.channelId.trim()) {
+        throw new Error('Authenticated agent and channel context are required');
+    }
+
+    return {
+        agentId: context.agentId as AgentId,
+        channelId: context.channelId as ChannelId
+    };
+}
+
+function rejectCallerSelectedTenant(input: Record<string, unknown>): void {
+    if (Object.prototype.hasOwnProperty.call(input, 'agentId') ||
+        Object.prototype.hasOwnProperty.call(input, 'channelId')) {
+        throw new Error('Agent and channel identity are derived from authenticated tool context');
+    }
+}
+
+function errorMessage(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
+}
+
+function requireObjectInput<T extends Record<string, unknown>>(input: unknown): T {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('Tool input must be an object');
+    }
+    return input as T;
+}
+
 // Helper to create tool result
-function createToolResult(success: boolean, data: any): McpToolHandlerResult {
+function createToolResult(success: boolean, data: Record<string, unknown>): McpToolHandlerResult {
     return {
         content: {
             type: 'application/json',
@@ -94,15 +171,24 @@ export const task_effectiveness_start: McpToolDefinition = {
                 }
             }
         },
-        required: ['taskType', 'description']
+        required: ['taskType', 'description'],
+        additionalProperties: false
     },
     enabled: true,
-    handler: async ({ taskType, description, successCriteria, baselineMetrics }: any, { agentId, channelId }: any) => {
+    handler: async (
+        rawInput: unknown,
+        context: McpToolHandlerContext
+    ): Promise<McpToolHandlerResult> => {
         const effectivenessService = TaskEffectivenessService.getInstance();
         try {
+            const input = requireObjectInput<EffectivenessStartInput>(rawInput);
+            rejectCallerSelectedTenant(input);
+            const { taskType, description, successCriteria, baselineMetrics } = input;
+            const { agentId, channelId } = requireTenantIdentity(context);
             const definition: TaskDefinition = {
                 taskId: uuidv4(),
-                channelId: channelId as ChannelId,
+                agentId,
+                channelId,
                 taskType,
                 description,
                 successCriteria,
@@ -111,7 +197,7 @@ export const task_effectiveness_start: McpToolDefinition = {
                     metrics: {
                         performance: {
                             completionTime: baselineMetrics.completionTime,
-                            humanInterventions: baselineMetrics.humanInterventions,
+                            humanInterventions: baselineMetrics.humanInterventions ?? 0,
                             autonomyScore: 0, // Human baseline has 0 autonomy
                             stepCount: 0,
                             toolsUsed: 0,
@@ -129,9 +215,9 @@ export const task_effectiveness_start: McpToolDefinition = {
                 message: `Started tracking effectiveness for ${taskType} task`,
                 trackingStarted: Date.now()
             });
-        } catch (error) {
+        } catch (error: unknown) {
             return createToolResult(false, {
-                error: `Failed to start effectiveness tracking: ${error}`
+                error: `Failed to start effectiveness tracking: ${errorMessage(error)}`
             });
         }
     }
@@ -160,18 +246,27 @@ export const task_effectiveness_event: McpToolDefinition = {
                 description: 'Event-specific details (e.g., tool name, error message, milestone name)'
             }
         },
-        required: ['taskId', 'eventType']
+        required: ['taskId', 'eventType'],
+        additionalProperties: false
     },
     enabled: true,
-    handler: async ({ taskId, eventType, details = {} }: any, { agentId }: any) => {
+    handler: async (
+        rawInput: unknown,
+        context: McpToolHandlerContext
+    ): Promise<McpToolHandlerResult> => {
         const effectivenessService = TaskEffectivenessService.getInstance();
         try {
+            const input = requireObjectInput<EffectivenessEventInput>(rawInput);
+            rejectCallerSelectedTenant(input);
+            const { taskId, eventType, details = {} } = input;
+            const { agentId, channelId } = requireTenantIdentity(context);
             const event: TaskExecutionEvent = {
                 eventId: uuidv4(),
                 taskId,
                 timestamp: Date.now(),
-                type: eventType as any,
-                agentId: agentId as AgentId,
+                type: eventType,
+                agentId,
+                channelId,
                 details
             };
             
@@ -181,9 +276,9 @@ export const task_effectiveness_event: McpToolDefinition = {
                 message: `Recorded ${eventType} event for task`,
                 eventId: event.eventId
             });
-        } catch (error) {
+        } catch (error: unknown) {
             return createToolResult(false, {
-                error: `Failed to record event: ${error}`
+                error: `Failed to record event: ${errorMessage(error)}`
             });
         }
     }
@@ -218,26 +313,34 @@ export const task_effectiveness_quality: McpToolDefinition = {
                 additionalProperties: { type: 'number' }
             }
         },
-        required: ['taskId']
+        required: ['taskId'],
+        additionalProperties: false
     },
     enabled: true,
-    handler: async ({ taskId, completenessScore, iterationCount, customMetrics }: any, { agentId }: any) => {
+    handler: async (
+        rawInput: unknown,
+        context: McpToolHandlerContext
+    ): Promise<McpToolHandlerResult> => {
         const effectivenessService = TaskEffectivenessService.getInstance();
         try {
-            const updates: any = {};
+            const input = requireObjectInput<EffectivenessQualityInput>(rawInput);
+            rejectCallerSelectedTenant(input);
+            const { taskId, completenessScore, iterationCount, customMetrics } = input;
+            const { agentId, channelId } = requireTenantIdentity(context);
+            const updates: Partial<TaskEffectivenessMetrics['quality']> = {};
             if (completenessScore !== undefined) updates.completenessScore = completenessScore;
             if (iterationCount !== undefined) updates.iterationCount = iterationCount;
             if (customMetrics) updates.customMetrics = customMetrics;
             
-            effectivenessService.updateQuality(taskId, updates, agentId as AgentId);
+            effectivenessService.updateQuality(taskId, agentId, channelId, updates);
             
             return createToolResult(true, {
                 message: 'Updated quality metrics',
                 updates
             });
-        } catch (error) {
+        } catch (error: unknown) {
             return createToolResult(false, {
-                error: `Failed to update quality metrics: ${error}`
+                error: `Failed to update quality metrics: ${errorMessage(error)}`
             });
         }
     }
@@ -266,20 +369,39 @@ export const task_effectiveness_complete: McpToolDefinition = {
                 additionalProperties: { type: 'number' }
             }
         },
-        required: ['taskId', 'success']
+        required: ['taskId', 'success'],
+        additionalProperties: false
     },
     enabled: true,
-    handler: async ({ taskId, success, customMetrics }: any) => {
+    handler: async (
+        rawInput: unknown,
+        context: McpToolHandlerContext
+    ): Promise<McpToolHandlerResult> => {
         const effectivenessService = TaskEffectivenessService.getInstance();
         try {
-            const metrics = await effectivenessService.completeTask(taskId, success, customMetrics);
+            const input = requireObjectInput<EffectivenessCompleteInput>(rawInput);
+            rejectCallerSelectedTenant(input);
+            const { taskId, success, customMetrics } = input;
+            const { agentId, channelId } = requireTenantIdentity(context);
+            const metrics = await effectivenessService.completeTask(
+                taskId,
+                agentId,
+                channelId,
+                success,
+                customMetrics
+            );
             if (!metrics) {
                 return createToolResult(false, {
                     error: 'Task not found or already completed'
                 });
             }
             
-            const comparison = await effectivenessService.compareWithBaseline(taskId);
+            const comparison = await effectivenessService.compareWithBaseline(taskId, agentId, channelId);
+            if (!comparison) {
+                return createToolResult(false, {
+                    error: 'Task completed, but its persisted comparison could not be loaded'
+                });
+            }
             
             return createToolResult(true, {
                 message: 'Task completed and effectiveness measured',
@@ -288,17 +410,17 @@ export const task_effectiveness_complete: McpToolDefinition = {
                     autonomyScore: metrics.performance.autonomyScore,
                     toolsUsed: metrics.performance.toolsUsed,
                     errorCount: metrics.quality.errorCount,
-                    overallScore: comparison?.summary.overallScore || 0
+                    overallScore: comparison.summary.overallScore
                 },
-                comparison: comparison ? {
+                comparison: {
                     speedImprovement: `${comparison.improvements.speedImprovement.toFixed(1)}%`,
                     achievements: comparison.summary.achievements,
                     recommendations: comparison.summary.recommendations
-                } : undefined
+                }
             });
-        } catch (error) {
+        } catch (error: unknown) {
             return createToolResult(false, {
-                error: `Failed to complete task: ${error}`
+                error: `Failed to complete task: ${errorMessage(error)}`
             });
         }
     }
@@ -323,12 +445,20 @@ export const task_effectiveness_analytics: McpToolDefinition = {
                 description: 'Optional: Filter by specific task type'
             }
         },
-        required: ['timeRange']
+        required: ['timeRange'],
+        additionalProperties: false
     },
     enabled: true,
-    handler: async ({ timeRange, taskType }: any, { channelId }: any) => {
+    handler: async (
+        rawInput: unknown,
+        context: McpToolHandlerContext
+    ): Promise<McpToolHandlerResult> => {
         const effectivenessService = TaskEffectivenessService.getInstance();
         try {
+            const input = requireObjectInput<EffectivenessAnalyticsInput>(rawInput);
+            rejectCallerSelectedTenant(input);
+            const { timeRange, taskType } = input;
+            const { agentId, channelId } = requireTenantIdentity(context);
             const now = Date.now();
             const ranges = {
                 hour: 60 * 60 * 1000,
@@ -337,18 +467,20 @@ export const task_effectiveness_analytics: McpToolDefinition = {
                 month: 30 * 24 * 60 * 60 * 1000
             };
             
-            const startTime = now - ranges[timeRange as keyof typeof ranges];
+            const startTime = now - ranges[timeRange];
             const analytics = await effectivenessService.getAnalytics(
                 startTime, 
-                now, 
-                channelId as ChannelId,
+                now,
+                agentId,
+                channelId,
                 taskType
             );
             
             // Filter by task type if specified
             let relevantStats = analytics.byTaskType;
             if (taskType) {
-                relevantStats = { [taskType]: analytics.byTaskType[taskType] };
+                const taskStats = analytics.byTaskType[taskType];
+                relevantStats = taskStats ? { [taskType]: taskStats } : {};
             }
             
             return createToolResult(true, {
@@ -367,9 +499,9 @@ export const task_effectiveness_analytics: McpToolDefinition = {
                     }
                 }
             });
-        } catch (error) {
+        } catch (error: unknown) {
             return createToolResult(false, {
-                error: `Failed to get analytics: ${error}`
+                error: `Failed to get analytics: ${errorMessage(error)}`
             });
         }
     }
@@ -389,13 +521,21 @@ export const task_effectiveness_compare: McpToolDefinition = {
                 description: 'Current task ID to compare'
             }
         },
-        required: ['taskId']
+        required: ['taskId'],
+        additionalProperties: false
     },
     enabled: true,
-    handler: async ({ taskId }: any) => {
+    handler: async (
+        rawInput: unknown,
+        context: McpToolHandlerContext
+    ): Promise<McpToolHandlerResult> => {
         const effectivenessService = TaskEffectivenessService.getInstance();
         try {
-            const comparison = await effectivenessService.compareWithBaseline(taskId);
+            const input = requireObjectInput<EffectivenessCompareInput>(rawInput);
+            rejectCallerSelectedTenant(input);
+            const { taskId } = input;
+            const { agentId, channelId } = requireTenantIdentity(context);
+            const comparison = await effectivenessService.compareWithBaseline(taskId, agentId, channelId);
             if (!comparison) {
                 return createToolResult(false, {
                     error: 'Task not found or no comparison available'
@@ -415,9 +555,9 @@ export const task_effectiveness_compare: McpToolDefinition = {
                     recommendations: comparison.summary.recommendations
                 }
             });
-        } catch (error) {
+        } catch (error: unknown) {
             return createToolResult(false, {
-                error: `Failed to compare task: ${error}`
+                error: `Failed to compare task: ${errorMessage(error)}`
             });
         }
     }
@@ -431,4 +571,4 @@ export const effectivenessTools: McpToolDefinition[] = [
     task_effectiveness_complete,
     task_effectiveness_analytics,
     task_effectiveness_compare
-];
+];

package/src/protocols/mcp/tools/GitTools.ts

@@ -34,11 +34,13 @@ import { TOOL_CATEGORIES } from '../../../constants/ToolNames.js';
 import { defineTool, ToolRunContext } from '../defineTool.js';
 import { ToolError } from '../ToolError.js';
 import { executeShellCommand, ShellCommandResult } from './InfrastructureTools.js';
+import * as path from 'path';
+import { resolveWorkspacePath } from '../security/McpToolPolicy.js';
 
 /** Working-directory property shared by every git tool's schema. */
 const workingDirectoryProperty = {
     type: 'string',
-    description: 'Working directory path (defaults to the server working directory)'
+    description: 'Working directory under MXF_WORKSPACE_ROOT (defaults to MXF_WORKSPACE_ROOT)'
 };
 
 /**
@@ -58,7 +60,7 @@ async function runGit(
             channelId: context.channelId,
             requestId: context.requestId
         },
-        workingDirectory: workingDirectory || process.cwd(),
+        workingDirectory,
         captureOutput: true
     });
 
@@ -164,11 +166,19 @@ export const gitAddTool = defineTool<
         required: ['files']
     },
     run: async (input, context) => {
-        await runGit(['add', ...input.files], input.workingDirectory, context);
+        const workingDirectory = resolveWorkspacePath(
+            input.workingDirectory,
+            'git_add workingDirectory'
+        );
+        const files = input.files.map(file => resolveWorkspacePath(
+            path.resolve(workingDirectory, file),
+            'git_add file'
+        ));
+        await runGit(['add', ...files], workingDirectory, context);
 
         return {
-            stagedCount: input.files.length,
-            files: input.files
+            stagedCount: files.length,
+            files
         };
     }
 });