snow-flow 3.5.17 → 3.6.1

package/dist/mcp/servicenow-automation-mcp.js

@@ -13,6 +13,7 @@ const servicenow_client_js_1 = require("../utils/servicenow-client.js");
 const mcp_auth_middleware_js_1 = require("../utils/mcp-auth-middleware.js");
 const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
 const mcp_logger_js_1 = require("./shared/mcp-logger.js");
+const servicenow_audit_logger_js_1 = require("../utils/servicenow-audit-logger.js");
 class ServiceNowAutomationMCP {
     constructor() {
         this.server = new index_js_1.Server({
@@ -25,6 +26,8 @@ class ServiceNowAutomationMCP {
         });
         this.client = new servicenow_client_js_1.ServiceNowClient();
         this.logger = new mcp_logger_js_1.MCPLogger('ServiceNowAutomationMCP');
+        this.auditLogger = (0, servicenow_audit_logger_js_1.getAuditLogger)(this.logger, 'servicenow-automation');
+        this.auditLogger.setServiceNowClient(this.client);
         this.config = mcp_config_manager_js_1.mcpConfig.getConfig();
         this.setupHandlers();
     }
@@ -1756,10 +1759,22 @@ ${groupedResults.suites.slice(0, 10).map(suite => `- ${suite.name} ${suite.activ
      * Execute script with output retrieval
      */
     async executeScriptWithOutput(args) {
+        const startTime = Date.now();
         try {
             this.logger.info('Executing script with output retrieval...');
             // Create a unique execution ID
             const executionId = `snow_flow_exec_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+            // Log script execution start
+            await this.getAuditLogger().logOperation('script_execution_start', 'INFO', {
+                message: 'Starting background script execution with output capture',
+                metadata: {
+                    execution_id: executionId,
+                    script_length: args.script.length,
+                    has_es5_validation: true,
+                    capture_logs: args.capture_logs,
+                    max_wait: args.max_wait || 5000
+                }
+            });
             // Wrap the script to capture output
             const wrappedScript = `
         var snowFlowOutput = [];
@@ -1864,6 +1879,27 @@ ${groupedResults.suites.slice(0, 10).map(suite => `- ${suite.name} ${suite.activ
                     this.logger.warn('Could not parse script output:', parseError);
                 }
             }
+            const duration = Date.now() - startTime;
+            const success = scriptOutput?.success !== false;
+            const outputLines = scriptOutput?.output?.length || 0;
+            const errorLines = scriptOutput?.errors?.length || 0;
+            // Log script execution completion with audit
+            await this.getAuditLogger().logScriptExecution('background', duration, success, scriptOutput?.errors || [], outputLines);
+            // Enhanced audit log with detailed execution info
+            await this.getAuditLogger().logOperation('script_execution_complete', success ? 'INFO' : 'ERROR', {
+                message: `Background script execution ${success ? 'completed successfully' : 'failed'}`,
+                duration_ms: duration,
+                metadata: {
+                    execution_id: executionId,
+                    output_lines: outputLines,
+                    error_lines: errorLines,
+                    script_success: success,
+                    execution_method: 'background_with_output',
+                    es5_validated: true,
+                    captured_output: !!scriptOutput
+                },
+                success
+            });
             return {
                 content: [{
                         type: 'text',
@@ -1872,6 +1908,10 @@ ${groupedResults.suites.slice(0, 10).map(suite => `- ${suite.name} ${suite.activ
             };
         }
         catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Log failed script execution
+            await this.getAuditLogger().logScriptExecution('background', duration, false, { message: errorMessage, type: 'exception' });
             this.logger.error('Failed to execute script with output:', error);
             throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to execute script: ${error}`);
         }
@@ -2412,6 +2452,12 @@ ${groupedResults.suites.slice(0, 10).map(suite => `- ${suite.name} ${suite.activ
             throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to trace execution: ${error}`);
         }
     }
+    /**
+     * Get audit logger for logging Snow-Flow activities
+     */
+    getAuditLogger() {
+        return this.auditLogger;
+    }
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);

package/dist/mcp/servicenow-local-development-mcp.js

@@ -261,6 +261,7 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
     }
     async pullArtifact(args) {
         const { sys_id, table } = args;
+        const startTime = Date.now();
         // Add timeout for pull operations
         const PULL_TIMEOUT = 15000; // 15 seconds for pull operations
         try {
@@ -280,6 +281,13 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
                 setTimeout(() => reject(new Error(`Pull operation timed out after ${PULL_TIMEOUT / 1000}s`)), PULL_TIMEOUT);
             });
             const artifact = await Promise.race([pullPromise, timeoutPromise]);
+            const duration = Date.now() - startTime;
+            // Log artifact sync operation
+            await this.getAuditLogger().logArtifactSync('pull', artifact.tableName, sys_id, artifact.name, artifact.files.length, duration, true);
+            // Special logging for widgets
+            if (artifact.tableName === 'sp_widget') {
+                await this.getAuditLogger().logWidgetOperation('pull', sys_id, artifact.name, duration, true);
+            }
             return {
                 content: [
                     {
@@ -290,7 +298,10 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
             };
         }
         catch (error) {
+            const duration = Date.now() - startTime;
             const errorMessage = error instanceof Error ? error.message : String(error);
+            // Log failed operation
+            await this.getAuditLogger().logArtifactSync('pull', table || 'unknown', sys_id, undefined, 0, duration, false);
             return {
                 content: [
                     {
@@ -303,8 +314,25 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
     }
     async pushArtifact(args) {
         const { sys_id, force = false } = args;
+        const startTime = Date.now();
         try {
             const success = await this.syncManager.pushArtifact(sys_id);
+            const duration = Date.now() - startTime;
+            // Get artifact info for logging
+            const localArtifacts = this.syncManager.listLocalArtifacts();
+            const artifact = localArtifacts.find(a => a.sys_id === sys_id);
+            if (success) {
+                // Log successful push
+                await this.getAuditLogger().logArtifactSync('push', artifact?.tableName || 'unknown', sys_id, artifact?.name, artifact?.files.length, duration, true);
+                // Special logging for widgets
+                if (artifact?.tableName === 'sp_widget') {
+                    await this.getAuditLogger().logWidgetOperation('push', sys_id, artifact.name, duration, true);
+                }
+            }
+            else {
+                // Log failed push
+                await this.getAuditLogger().logArtifactSync('push', artifact?.tableName || 'unknown', sys_id, artifact?.name, artifact?.files.length, duration, false);
+            }
             return {
                 content: [
                     {
@@ -317,7 +345,10 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
             };
         }
         catch (error) {
+            const duration = Date.now() - startTime;
             const errorMessage = error instanceof Error ? error.message : String(error);
+            // Log failed operation
+            await this.getAuditLogger().logArtifactSync('push', 'unknown', sys_id, undefined, 0, duration, false);
             return {
                 content: [
                     {

package/dist/mcp/shared/enhanced-base-mcp-server.d.ts

@@ -1,10 +1,11 @@
 /**
- * Enhanced Base MCP Server with Logging and Token Tracking
+ * Enhanced Base MCP Server with Logging, Token Tracking, and ServiceNow Audit Logging
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { ServiceNowClientWithTracking } from '../../utils/servicenow-client-with-tracking.js';
 import { MCPLogger } from './mcp-logger.js';
 import { ServiceNowOAuth } from '../../utils/snow-oauth.js';
+import { ServiceNowAuditLogger } from '../../utils/servicenow-audit-logger.js';
 export interface MCPToolResult {
     content: Array<{
         type: string;
@@ -16,13 +17,15 @@ export declare abstract class EnhancedBaseMCPServer {
     protected server: Server;
     protected client: ServiceNowClientWithTracking;
     protected logger: MCPLogger;
+    protected auditLogger: ServiceNowAuditLogger;
     protected oauth: ServiceNowOAuth;
     protected isAuthenticated: boolean;
+    protected serverName: string;
     constructor(name: string, version?: string);
     /**
-     * Execute tool with enhanced tracking
+     * Execute tool with enhanced tracking and audit logging
      */
-    protected executeTool(toolName: string, handler: () => Promise<MCPToolResult>): Promise<MCPToolResult>;
+    protected executeTool(toolName: string, handler: () => Promise<MCPToolResult>, params?: any): Promise<MCPToolResult>;
     /**
      * Validate ServiceNow connection with progress
      */
@@ -35,19 +38,19 @@ export declare abstract class EnhancedBaseMCPServer {
      */
     protected createResponse(message: string, data?: any): MCPToolResult;
     /**
-     * Query table with progress tracking
+     * Query table with progress tracking and audit logging
      */
     protected queryTable(table: string, query: string, limit?: number): Promise<any>;
     /**
-     * Create record with tracking
+     * Create record with tracking and audit logging
      */
     protected createRecord(table: string, data: any): Promise<any>;
     /**
-     * Update record with tracking
+     * Update record with tracking and audit logging
      */
     protected updateRecord(table: string, sysId: string, data: any): Promise<any>;
     /**
-     * Get record with tracking
+     * Get record with tracking and audit logging
      */
     protected getRecord(table: string, sysId: string): Promise<any>;
     /**
@@ -58,5 +61,13 @@ export declare abstract class EnhancedBaseMCPServer {
      * Get logger for direct use
      */
     getLogger(): MCPLogger;
+    /**
+     * Get audit logger for direct use
+     */
+    getAuditLogger(): ServiceNowAuditLogger;
+    /**
+     * Cleanup resources and flush audit logs
+     */
+    cleanup(): Promise<void>;
 }
 //# sourceMappingURL=enhanced-base-mcp-server.d.ts.map

package/dist/mcp/shared/enhanced-base-mcp-server.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Enhanced Base MCP Server with Logging and Token Tracking
+ * Enhanced Base MCP Server with Logging, Token Tracking, and ServiceNow Audit Logging
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnhancedBaseMCPServer = void 0;
@@ -9,15 +9,21 @@ const servicenow_client_with_tracking_js_1 = require("../../utils/servicenow-cli
 const mcp_logger_js_1 = require("./mcp-logger.js");
 const snow_oauth_js_1 = require("../../utils/snow-oauth.js");
 const mcp_auth_middleware_js_1 = require("../../utils/mcp-auth-middleware.js");
+const servicenow_audit_logger_js_1 = require("../../utils/servicenow-audit-logger.js");
 class EnhancedBaseMCPServer {
     constructor(name, version = '1.0.0') {
         this.isAuthenticated = false;
+        this.serverName = name;
         // Create enhanced logger
         this.logger = new mcp_logger_js_1.MCPLogger(name);
+        // Initialize ServiceNow audit logger
+        this.auditLogger = (0, servicenow_audit_logger_js_1.getAuditLogger)(this.logger, name);
         // Log startup
         this.logger.info(`🚀 Starting ${name} MCP Server v${version}`);
         // Create enhanced client with tracking
         this.client = new servicenow_client_with_tracking_js_1.ServiceNowClientWithTracking(this.logger);
+        // Connect audit logger to ServiceNow client
+        this.auditLogger.setServiceNowClient(this.client.getBaseClient());
         // Initialize OAuth
         this.oauth = new snow_oauth_js_1.ServiceNowOAuth();
         // Create server with capabilities
@@ -29,13 +35,19 @@ class EnhancedBaseMCPServer {
                 tools: {},
             },
         });
+        // Log server initialization
+        this.auditLogger.logOperation('server_initialization', 'INFO', {
+            message: `${name} MCP Server v${version} initialized`,
+            metadata: { version, capabilities: ['tools'] }
+        });
         // Report initialization
-        this.logger.info(`✅ ${name} initialized and ready`);
+        this.logger.info(`✅ ${name} initialized and ready with audit logging`);
     }
     /**
-     * Execute tool with enhanced tracking
+     * Execute tool with enhanced tracking and audit logging
      */
-    async executeTool(toolName, handler) {
+    async executeTool(toolName, handler, params) {
+        const startTime = Date.now();
         // Reset tokens at start of each operation to avoid accumulation
         this.logger.resetTokens();
         // Start operation tracking
@@ -44,30 +56,57 @@ class EnhancedBaseMCPServer {
             // Ensure authentication
             await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
             this.isAuthenticated = true;
+            // Log authentication success
+            await this.auditLogger.logAuthOperation('token_refresh', true);
             // Execute the tool handler
             const result = await handler();
+            const duration = Date.now() - startTime;
+            const tokenUsage = this.logger.getTokenUsage();
+            // Log successful tool execution
+            await this.auditLogger.logOperation('tool_execution', 'INFO', {
+                message: `Successfully executed ${toolName}`,
+                duration_ms: duration,
+                metadata: {
+                    tool_name: toolName,
+                    parameters: params ? JSON.stringify(params) : undefined,
+                    token_usage: tokenUsage
+                },
+                success: true
+            });
             // Log completion
             this.logger.operationComplete(toolName);
             // Send token usage summary if in Claude
             if (process.send) {
-                const usage = this.logger.getTokenUsage();
                 process.send({
                     type: 'token_usage',
                     data: {
                         tool: toolName,
-                        tokens: usage
+                        tokens: tokenUsage
                     }
                 });
             }
             return result;
         }
         catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Log failed tool execution
+            await this.auditLogger.logOperation('tool_execution', 'ERROR', {
+                message: `Failed to execute ${toolName}: ${errorMessage}`,
+                duration_ms: duration,
+                metadata: {
+                    tool_name: toolName,
+                    parameters: params ? JSON.stringify(params) : undefined,
+                    error_details: error instanceof Error ? { message: error.message, stack: error.stack } : error
+                },
+                success: false
+            });
             this.logger.error(`Tool execution failed: ${toolName}`, error);
             // Return error as tool result
             return {
                 content: [{
                         type: 'text',
-                        text: `❌ Error executing ${toolName}: ${error instanceof Error ? error.message : String(error)}`
+                        text: `❌ Error executing ${toolName}: ${errorMessage}`
                     }]
             };
         }
@@ -133,47 +172,95 @@ class EnhancedBaseMCPServer {
         return response;
     }
     /**
-     * Query table with progress tracking
+     * Query table with progress tracking and audit logging
      */
     async queryTable(table, query, limit = 10) {
+        const startTime = Date.now();
         this.logger.progress(`Querying ${table} table (limit: ${limit})...`);
-        const result = await this.client.searchRecords(table, query, limit);
-        const recordCount = result?.data?.result?.length || 0;
-        this.logger.info(`Query completed: ${recordCount} records found`);
-        return result;
+        try {
+            const result = await this.client.searchRecords(table, query, limit);
+            const recordCount = result?.data?.result?.length || 0;
+            const duration = Date.now() - startTime;
+            // Log API call
+            await this.auditLogger.logAPICall('searchRecords', table, 'query', recordCount, duration, true);
+            this.logger.info(`Query completed: ${recordCount} records found`);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            await this.auditLogger.logAPICall('searchRecords', table, 'query', 0, duration, false);
+            throw error;
+        }
     }
     /**
-     * Create record with tracking
+     * Create record with tracking and audit logging
      */
     async createRecord(table, data) {
+        const startTime = Date.now();
         this.logger.progress(`Creating ${table} record...`);
-        const result = await this.client.createRecord(table, data);
-        if (result?.success) {
-            this.logger.info(`✅ Created ${table} record: ${result.data?.result?.sys_id}`);
+        try {
+            const result = await this.client.createRecord(table, data);
+            const duration = Date.now() - startTime;
+            const success = !!result?.success;
+            const sysId = result?.data?.result?.sys_id;
+            // Log API call with audit
+            await this.auditLogger.logAPICall('createRecord', table, 'create', 1, duration, success);
+            if (success) {
+                this.logger.info(`✅ Created ${table} record: ${sysId}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            await this.auditLogger.logAPICall('createRecord', table, 'create', 0, duration, false);
+            throw error;
         }
-        return result;
     }
     /**
-     * Update record with tracking
+     * Update record with tracking and audit logging
      */
     async updateRecord(table, sysId, data) {
+        const startTime = Date.now();
         this.logger.progress(`Updating ${table} record ${sysId}...`);
-        const result = await this.client.updateRecord(table, sysId, data);
-        if (result?.success) {
-            this.logger.info(`✅ Updated ${table} record: ${sysId}`);
+        try {
+            const result = await this.client.updateRecord(table, sysId, data);
+            const duration = Date.now() - startTime;
+            const success = !!result?.success;
+            // Log API call with audit
+            await this.auditLogger.logAPICall('updateRecord', table, 'update', 1, duration, success);
+            if (success) {
+                this.logger.info(`✅ Updated ${table} record: ${sysId}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            await this.auditLogger.logAPICall('updateRecord', table, 'update', 0, duration, false);
+            throw error;
         }
-        return result;
     }
     /**
-     * Get record with tracking
+     * Get record with tracking and audit logging
      */
     async getRecord(table, sysId) {
+        const startTime = Date.now();
         this.logger.progress(`Getting ${table} record ${sysId}...`);
-        const result = await this.client.getRecord(table, sysId);
-        if (result?.success) {
-            this.logger.info(`✅ Retrieved ${table} record: ${sysId}`);
+        try {
+            const result = await this.client.getRecord(table, sysId);
+            const duration = Date.now() - startTime;
+            const success = !!result?.success;
+            // Log API call with audit
+            await this.auditLogger.logAPICall('getRecord', table, 'read', success ? 1 : 0, duration, success);
+            if (success) {
+                this.logger.info(`✅ Retrieved ${table} record: ${sysId}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            await this.auditLogger.logAPICall('getRecord', table, 'read', 0, duration, false);
+            throw error;
         }
-        return result;
     }
     /**
      * Get client for direct use
@@ -187,6 +274,36 @@ class EnhancedBaseMCPServer {
     getLogger() {
         return this.logger;
     }
+    /**
+     * Get audit logger for direct use
+     */
+    getAuditLogger() {
+        return this.auditLogger;
+    }
+    /**
+     * Cleanup resources and flush audit logs
+     */
+    async cleanup() {
+        this.logger.info(`🧹 Cleaning up ${this.serverName} MCP Server`);
+        try {
+            // Flush pending audit logs
+            await this.auditLogger.flush();
+            // Log server shutdown
+            await this.auditLogger.logOperation('server_shutdown', 'INFO', {
+                message: `${this.serverName} MCP Server shutting down`,
+                metadata: {
+                    uptime_ms: Date.now() - this.logger['startTime'],
+                    final_token_usage: this.logger.getTokenUsage()
+                }
+            });
+            // Stop progress indicators
+            this.logger.stopProgress();
+            this.logger.info(`✅ ${this.serverName} cleanup completed`);
+        }
+        catch (error) {
+            this.logger.error('Error during cleanup', error);
+        }
+    }
 }
 exports.EnhancedBaseMCPServer = EnhancedBaseMCPServer;
 //# sourceMappingURL=enhanced-base-mcp-server.js.map