snow-flow 3.5.17 → 3.6.0

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

package/dist/utils/servicenow-audit-logger.d.ts

@@ -0,0 +1,109 @@
+/**
+ * ServiceNow Audit Logger - Snow-Flow Activity Tracking
+ *
+ * Extends the existing MCPLogger to send comprehensive audit logs
+ * to ServiceNow for all Snow-Flow activities with token usage tracking.
+ *
+ * Creates audit trail with source 'snow-flow' for compliance & debugging.
+ */
+import { MCPLogger } from '../mcp/shared/mcp-logger.js';
+import { ServiceNowClient } from './servicenow-client.js';
+export interface AuditLogEntry {
+    source: 'snow-flow';
+    level: 'INFO' | 'WARN' | 'ERROR' | 'DEBUG';
+    message: string;
+    operation: string;
+    table?: string;
+    sys_id?: string;
+    user_id?: string;
+    token_usage?: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    duration_ms?: number;
+    metadata?: any;
+    timestamp: string;
+    session_id?: string;
+    mcp_server: string;
+}
+export declare class ServiceNowAuditLogger {
+    private mcpLogger;
+    private serviceNowClient?;
+    private sessionId;
+    private mcpServerName;
+    private isEnabled;
+    private auditQueue;
+    private batchTimer?;
+    constructor(mcpLogger: MCPLogger, mcpServerName: string);
+    /**
+     * Initialize with ServiceNow client for audit log transmission
+     */
+    setServiceNowClient(client: ServiceNowClient): void;
+    /**
+     * Generate unique session ID for tracking related operations
+     */
+    private generateSessionId;
+    /**
+     * Log Snow-Flow operation with comprehensive audit trail
+     */
+    logOperation(operation: string, level?: 'INFO' | 'WARN' | 'ERROR' | 'DEBUG', details?: {
+        message?: string;
+        table?: string;
+        sys_id?: string;
+        duration_ms?: number;
+        metadata?: any;
+        success?: boolean;
+    }): Promise<void>;
+    /**
+     * Log API call with token tracking
+     */
+    logAPICall(apiMethod: string, table: string, operation: string, recordCount?: number, duration_ms?: number, success?: boolean): Promise<void>;
+    /**
+     * Log widget operations with specific tracking
+     */
+    logWidgetOperation(operation: 'pull' | 'push' | 'validate' | 'deploy', widgetSysId: string, widgetName?: string, duration_ms?: number, success?: boolean, errorDetails?: any): Promise<void>;
+    /**
+     * Log artifact sync operations
+     */
+    logArtifactSync(action: 'pull' | 'push' | 'cleanup', table: string, sys_id: string, artifactName?: string, fileCount?: number, duration_ms?: number, success?: boolean): Promise<void>;
+    /**
+     * Log script execution with ES5 validation
+     */
+    logScriptExecution(scriptType: 'background' | 'business_rule' | 'client_script', duration_ms?: number, success?: boolean, errorDetails?: any, outputLines?: number): Promise<void>;
+    /**
+     * Log authentication and token operations
+     */
+    logAuthOperation(operation: 'login' | 'token_refresh' | 'scope_elevation', success?: boolean, details?: any): Promise<void>;
+    /**
+     * Schedule batch sending to ServiceNow to avoid API flooding
+     */
+    private scheduleBatchSend;
+    /**
+     * Send audit log batch to ServiceNow
+     */
+    private sendAuditBatch;
+    /**
+     * Flush all pending audit logs immediately
+     */
+    flush(): Promise<void>;
+    /**
+     * Create audit logger wrapper for existing MCP server
+     */
+    static wrap(mcpLogger: MCPLogger, mcpServerName: string): ServiceNowAuditLogger;
+    /**
+     * Get audit statistics
+     */
+    getAuditStats(): {
+        session_id: string;
+        pending_logs: number;
+        is_enabled: boolean;
+        has_servicenow_client: boolean;
+    };
+}
+export declare function getAuditLogger(mcpLogger: MCPLogger, mcpServerName: string): ServiceNowAuditLogger;
+/**
+ * Initialize all audit loggers with ServiceNow client
+ */
+export declare function initializeAuditLogging(serviceNowClient: ServiceNowClient): void;
+//# sourceMappingURL=servicenow-audit-logger.d.ts.map

package/dist/utils/servicenow-audit-logger.js

@@ -0,0 +1,267 @@
+"use strict";
+/**
+ * ServiceNow Audit Logger - Snow-Flow Activity Tracking
+ *
+ * Extends the existing MCPLogger to send comprehensive audit logs
+ * to ServiceNow for all Snow-Flow activities with token usage tracking.
+ *
+ * Creates audit trail with source 'snow-flow' for compliance & debugging.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceNowAuditLogger = void 0;
+exports.getAuditLogger = getAuditLogger;
+exports.initializeAuditLogging = initializeAuditLogging;
+class ServiceNowAuditLogger {
+    constructor(mcpLogger, mcpServerName) {
+        this.isEnabled = true;
+        this.auditQueue = [];
+        this.mcpLogger = mcpLogger;
+        this.mcpServerName = mcpServerName;
+        this.sessionId = this.generateSessionId();
+        // Enable audit logging if not explicitly disabled
+        this.isEnabled = process.env.SNOW_FLOW_AUDIT_LOGGING !== 'false';
+        if (this.isEnabled) {
+            this.mcpLogger.info('🔍 ServiceNow Audit Logger initialized', {
+                source: 'snow-flow',
+                session_id: this.sessionId,
+                mcp_server: this.mcpServerName
+            });
+        }
+    }
+    /**
+     * Initialize with ServiceNow client for audit log transmission
+     */
+    setServiceNowClient(client) {
+        this.serviceNowClient = client;
+        if (this.isEnabled) {
+            this.mcpLogger.info('🔗 ServiceNow client connected for audit logging');
+        }
+    }
+    /**
+     * Generate unique session ID for tracking related operations
+     */
+    generateSessionId() {
+        return `snow-flow-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Log Snow-Flow operation with comprehensive audit trail
+     */
+    async logOperation(operation, level = 'INFO', details = {}) {
+        if (!this.isEnabled)
+            return;
+        const tokenUsage = this.mcpLogger.getTokenUsage();
+        const timestamp = new Date().toISOString();
+        const auditEntry = {
+            source: 'snow-flow',
+            level,
+            message: details.message || `Snow-Flow ${operation}`,
+            operation,
+            table: details.table,
+            sys_id: details.sys_id,
+            token_usage: tokenUsage.total > 0 ? tokenUsage : undefined,
+            duration_ms: details.duration_ms,
+            metadata: {
+                ...details.metadata,
+                success: details.success,
+                mcp_server: this.mcpServerName,
+                session_id: this.sessionId
+            },
+            timestamp,
+            session_id: this.sessionId,
+            mcp_server: this.mcpServerName
+        };
+        // Log to console immediately via MCPLogger
+        this.mcpLogger.info(`🔍 [AUDIT] ${operation}`, auditEntry);
+        // Queue for ServiceNow transmission
+        this.auditQueue.push(auditEntry);
+        // Batch send to avoid overwhelming ServiceNow
+        this.scheduleBatchSend();
+    }
+    /**
+     * Log API call with token tracking
+     */
+    async logAPICall(apiMethod, table, operation, recordCount, duration_ms, success = true) {
+        await this.logOperation('api_call', success ? 'INFO' : 'ERROR', {
+            message: `API ${apiMethod} on ${table} (${recordCount || 0} records)`,
+            table,
+            duration_ms,
+            metadata: {
+                api_method: apiMethod,
+                record_count: recordCount,
+                operation
+            },
+            success
+        });
+    }
+    /**
+     * Log widget operations with specific tracking
+     */
+    async logWidgetOperation(operation, widgetSysId, widgetName, duration_ms, success = true, errorDetails) {
+        await this.logOperation('widget_operation', success ? 'INFO' : 'ERROR', {
+            message: `Widget ${operation}: ${widgetName || widgetSysId}`,
+            table: 'sp_widget',
+            sys_id: widgetSysId,
+            duration_ms,
+            metadata: {
+                widget_name: widgetName,
+                operation_type: operation,
+                error_details: errorDetails
+            },
+            success
+        });
+    }
+    /**
+     * Log artifact sync operations
+     */
+    async logArtifactSync(action, table, sys_id, artifactName, fileCount, duration_ms, success = true) {
+        await this.logOperation('artifact_sync', success ? 'INFO' : 'ERROR', {
+            message: `Artifact ${action}: ${artifactName || sys_id} (${fileCount || 0} files)`,
+            table,
+            sys_id,
+            duration_ms,
+            metadata: {
+                action,
+                artifact_name: artifactName,
+                file_count: fileCount
+            },
+            success
+        });
+    }
+    /**
+     * Log script execution with ES5 validation
+     */
+    async logScriptExecution(scriptType, duration_ms, success = true, errorDetails, outputLines) {
+        await this.logOperation('script_execution', success ? 'INFO' : 'ERROR', {
+            message: `Script execution: ${scriptType}`,
+            duration_ms,
+            metadata: {
+                script_type: scriptType,
+                output_lines: outputLines,
+                error_details: errorDetails,
+                es5_validated: true // Snow-Flow always uses ES5
+            },
+            success
+        });
+    }
+    /**
+     * Log authentication and token operations
+     */
+    async logAuthOperation(operation, success = true, details) {
+        await this.logOperation('authentication', success ? 'INFO' : 'WARN', {
+            message: `Auth ${operation}`,
+            metadata: {
+                operation,
+                ...details
+            },
+            success
+        });
+    }
+    /**
+     * Schedule batch sending to ServiceNow to avoid API flooding
+     */
+    scheduleBatchSend() {
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+        }
+        // Send batches every 10 seconds or when queue reaches 20 entries
+        const shouldSendImmediately = this.auditQueue.length >= 20;
+        const delay = shouldSendImmediately ? 0 : 10000;
+        this.batchTimer = setTimeout(() => {
+            this.sendAuditBatch();
+        }, delay);
+    }
+    /**
+     * Send audit log batch to ServiceNow
+     */
+    async sendAuditBatch() {
+        if (this.auditQueue.length === 0 || !this.serviceNowClient) {
+            return;
+        }
+        const batch = [...this.auditQueue];
+        this.auditQueue = []; // Clear queue
+        try {
+            // Send to ServiceNow sys_log table with source 'snow-flow'
+            for (const entry of batch) {
+                await this.serviceNowClient.createRecord('sys_log', {
+                    source: 'snow-flow',
+                    level: entry.level,
+                    message: entry.message,
+                    sys_created_on: entry.timestamp,
+                    // Custom fields for Snow-Flow specific data
+                    u_operation: entry.operation,
+                    u_table: entry.table,
+                    u_sys_id: entry.sys_id,
+                    u_session_id: entry.session_id,
+                    u_mcp_server: entry.mcp_server,
+                    u_token_usage: entry.token_usage ? JSON.stringify(entry.token_usage) : null,
+                    u_duration_ms: entry.duration_ms,
+                    u_metadata: entry.metadata ? JSON.stringify(entry.metadata) : null
+                });
+            }
+            this.mcpLogger.info(`📨 Sent ${batch.length} audit log entries to ServiceNow`);
+        }
+        catch (error) {
+            // If ServiceNow logging fails, log locally but don't fail the operation
+            this.mcpLogger.warn('Failed to send audit logs to ServiceNow', {
+                error: error instanceof Error ? error.message : String(error),
+                batch_size: batch.length
+            });
+            // Re-queue failed entries (with max retry limit)
+            const retriedEntries = batch.map(entry => ({
+                ...entry,
+                metadata: {
+                    ...entry.metadata,
+                    retry_count: (entry.metadata?.retry_count || 0) + 1
+                }
+            })).filter(entry => (entry.metadata?.retry_count || 0) < 3);
+            this.auditQueue.unshift(...retriedEntries);
+        }
+    }
+    /**
+     * Flush all pending audit logs immediately
+     */
+    async flush() {
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = undefined;
+        }
+        await this.sendAuditBatch();
+    }
+    /**
+     * Create audit logger wrapper for existing MCP server
+     */
+    static wrap(mcpLogger, mcpServerName) {
+        return new ServiceNowAuditLogger(mcpLogger, mcpServerName);
+    }
+    /**
+     * Get audit statistics
+     */
+    getAuditStats() {
+        return {
+            session_id: this.sessionId,
+            pending_logs: this.auditQueue.length,
+            is_enabled: this.isEnabled,
+            has_servicenow_client: !!this.serviceNowClient
+        };
+    }
+}
+exports.ServiceNowAuditLogger = ServiceNowAuditLogger;
+/**
+ * Global audit logger factory for consistent usage across MCP servers
+ */
+const auditLoggers = new Map();
+function getAuditLogger(mcpLogger, mcpServerName) {
+    if (!auditLoggers.has(mcpServerName)) {
+        auditLoggers.set(mcpServerName, new ServiceNowAuditLogger(mcpLogger, mcpServerName));
+    }
+    return auditLoggers.get(mcpServerName);
+}
+/**
+ * Initialize all audit loggers with ServiceNow client
+ */
+function initializeAuditLogging(serviceNowClient) {
+    auditLoggers.forEach(logger => {
+        logger.setServiceNowClient(serviceNowClient);
+    });
+}
+//# sourceMappingURL=servicenow-audit-logger.js.map

package/dist/utils/servicenow-client-with-tracking.d.ts

@@ -6,6 +6,10 @@ import { MCPLogger } from '../mcp/shared/mcp-logger.js';
 export declare class ServiceNowClientWithTracking extends ServiceNowClient {
     private mcpLogger;
     constructor(logger?: MCPLogger);
+    /**
+     * Get the base ServiceNow client for audit logger integration
+     */
+    getBaseClient(): ServiceNowClient;
     /**
      * Override makeRequest to add tracking
      */

package/dist/utils/servicenow-client-with-tracking.js

@@ -11,6 +11,12 @@ class ServiceNowClientWithTracking extends servicenow_client_js_1.ServiceNowClie
         super();
         this.mcpLogger = logger || new mcp_logger_js_1.MCPLogger('ServiceNow-API');
     }
+    /**
+     * Get the base ServiceNow client for audit logger integration
+     */
+    getBaseClient() {
+        return this;
+    }
     /**
      * Override makeRequest to add tracking
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.5.17",
-  "description": "ServiceNow development framework with ROBUST artifact detection fix. v3.5.17 FIXES the intermittent 'Could not find artifact' errors in snow_pull_artifact. Enhanced pullArtifactBySysId with detailed error logging, longer timeouts (8s per table), smart table ordering, and comprehensive troubleshooting guidance. ULTRA-CONSERVATIVE wrapper system prevents duplicate HTML comments. Enhanced 'snow-flow init' creates optimized settings.json with 18 MCP servers, extensive development permissions, intelligent hooks, and ServiceNow-specific commands. Features intelligent timeout configuration and comprehensive ServiceNow development workflow.",
+  "version": "3.6.0",
+  "description": "ServiceNow development framework with COMPREHENSIVE AUDIT LOGGING. v3.6.0 introduces complete audit trail for all Snow-Flow activities in ServiceNow with source 'snow-flow'. Tracks API calls, widget operations, script execution, authentication, and tool usage with token consumption data. Enhanced compliance support for SOX/GDPR/HIPAA with detailed security monitoring. Includes robust artifact detection fix, ultra-conservative wrapper system, and optimized settings.json with 18 MCP servers. Features intelligent timeout configuration and comprehensive ServiceNow development workflow.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {