snow-flow - npm Package Compare versions

+20

tsconfig.servicenow.json

		{
		"$schema": "https://json.schemastore.org/tsconfig",
		"compilerOptions": {
		"lib": ["ESNext"],
		"target": "ESNext",
		"module": "Preserve",
		"moduleDetection": "force",
		"moduleResolution": "bundler",
		"allowImportingTsExtensions": true,
		"noEmit": true,
		"skipLibCheck": true,
		"types": ["bun-types"],
		"noUncheckedIndexedAccess": false,
		"customConditions": ["browser"],
		"paths": {
		"@/": ["./src/"]
		}
		},
		"include": ["src/servicenow/*/"]
		}

+2

-1

package.json

		{
		"$schema": "https://json.schemastore.org/package.json",
		"version": "10.0.196",
		"version": "10.0.197",
		"name": "snow-flow",
		@@ -10,2 +10,3 @@ "description": "Snow-Flow - ServiceNow Multi-Agent Development Framework powered by AI",
		"typecheck": "tsgo --noEmit",
		"typecheck:servicenow": "tsgo --project tsconfig.servicenow.json --noEmit",
		"test": "bun test",
		@@ -12,0 +13,0 @@ "build": "bun run script/build.ts",

+67

-35

src/servicenow/ser...tools/automation/snow_execute_script.ts

		@@ -11,6 +11,6 @@ /**

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import type { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult, SnowFlowError, ErrorType } from "../../shared/error-handler.js"
		import crypto from "crypto"
		import { randomBytes } from "crypto"

		@@ -20,3 +20,3 @@ const ENDPOINT_SERVICE_ID = "snow_flow_exec"

		const deployed = new Map<string, boolean>()
		const endpointCache = new Map<string, { namespace: string }>()

		@@ -218,4 +218,10 @@ const OPERATION_SCRIPT = `(function process(request, response) {

		function getEndpointUrl(context: ServiceNowContext): string {
		const cached = endpointCache.get(context.instanceUrl)
		if (cached) return `/api/${cached.namespace}/${ENDPOINT_SERVICE_ID}${ENDPOINT_PATH}`
		return `/api/${ENDPOINT_SERVICE_ID}${ENDPOINT_PATH}`
		}

		async function ensureEndpoint(context: ServiceNowContext): Promise<boolean> {
		if (deployed.get(context.instanceUrl)) return true
		if (endpointCache.has(context.instanceUrl)) return true

		@@ -227,3 +233,3 @@ const client = await getAuthenticatedClient(context)
		sysparm_query: `service_id=${ENDPOINT_SERVICE_ID}`,
		sysparm_fields: "sys_id",
		sysparm_fields: "sys_id,namespace,base_uri",
		sysparm_limit: 1,
		@@ -234,35 +240,61 @@ },
		const existing = check.data?.result?.[0]
		if (!existing) {
		const svc = await client.post("/api/now/table/sys_ws_definition", {
		name: "Snow-Flow Script Executor",
		service_id: ENDPOINT_SERVICE_ID,
		short_description: "Synchronous script execution endpoint for Snow-Flow",
		active: true,
		})
		const svcId =
		existing?.sys_id \|\|
		(await (async () => {
		const svc = await client.post("/api/now/table/sys_ws_definition", {
		name: "Snow-Flow Script Executor",
		service_id: ENDPOINT_SERVICE_ID,
		short_description: "Synchronous script execution endpoint for Snow-Flow",
		active: true,
		})

		const svcId = svc.data?.result?.sys_id
		if (!svcId) return false
		const id = svc.data?.result?.sys_id
		if (!id) return null

		const res = await client.post("/api/now/table/sys_ws_operation", {
		name: "Execute Script",
		web_service_definition: svcId,
		http_method: "POST",
		relative_path: ENDPOINT_PATH,
		operation_script: OPERATION_SCRIPT,
		active: true,
		})
		await client.post("/api/now/table/sys_ws_operation", {
		name: "Execute Script",
		web_service_definition: id,
		http_method: "POST",
		relative_path: ENDPOINT_PATH,
		operation_script: OPERATION_SCRIPT,
		active: true,
		})

		if (!res.data?.result?.sys_id) return false
		return id
		})())

		if (!svcId) return false

		const svcRecord =
		existing \|\|
		(
		await client
		.get("/api/now/table/sys_ws_definition/" + svcId, {
		params: { sysparm_fields: "namespace,base_uri" },
		})
		.catch(() => null)
		)?.data?.result

		const ns = svcRecord?.namespace \|\| ""

		const candidates = ns
		? [`/api/${ns}/${ENDPOINT_SERVICE_ID}${ENDPOINT_PATH}`, `/api/${ENDPOINT_SERVICE_ID}${ENDPOINT_PATH}`]
		: [`/api/${ENDPOINT_SERVICE_ID}${ENDPOINT_PATH}`]

		for (const url of candidates) {
		const ping = await client.post(url, { script: "'pong'", execution_id: "deploy_verify" }).catch(() => null)

		if (ping?.data?.result?.success === true) {
		const parts = url.replace(`/${ENDPOINT_SERVICE_ID}${ENDPOINT_PATH}`, "").replace("/api/", "")
		endpointCache.set(context.instanceUrl, { namespace: parts \|\| ENDPOINT_SERVICE_ID })
		return true
		}
		}

		const ping = await client
		.post(`/api/${ENDPOINT_SERVICE_ID}${ENDPOINT_PATH}`, {
		script: "'pong'",
		execution_id: "deploy_verify",
		})
		.catch(() => null)
		if (ns) {
		endpointCache.set(context.instanceUrl, { namespace: ns })
		return true
		}

		const ok = ping?.data?.result?.success === true
		if (ok) deployed.set(context.instanceUrl, true)
		return ok
		return false
		}
		@@ -284,3 +316,3 @@
		const response = await client
		.post(`/api/${ENDPOINT_SERVICE_ID}${ENDPOINT_PATH}`, {
		.post(getEndpointUrl(context), {
		script: params.script,
		@@ -355,3 +387,3 @@ execution_id: params.executionId,

		const executionId = `exec_${Date.now()}_${crypto.randomBytes(6).toString("hex")}`
		const executionId = `exec_${Date.now()}_${randomBytes(6).toString("hex")}`
		const marker = `SNOW_FLOW_EXEC_${executionId}`
		@@ -571,3 +603,3 @@
		): Promise<ToolResult> {
		const executionId = `exec_${Date.now()}_${crypto.randomBytes(6).toString("hex")}`
		const executionId = `exec_${Date.now()}_${randomBytes(6).toString("hex")}`

		@@ -574,0 +606,0 @@ const syncResult = await executeViaSyncApi({ ...params, executionId }, context)

+0

-18

src/servicenow/servicenow-mcp-unified/tools/index.ts

		@@ -59,5 +59,2 @@ /**

		// Script Includes (1 tool)
		export * from "./script-includes/index.js"

		// REST API tools moved to Integration folder (see snow_rest_message_manage, snow_create_rest_message)
		@@ -98,5 +95,2 @@

		// UI Actions (1 tool)
		export * from "./ui-actions/index.js"

		// Workspace (10 tools)
		@@ -192,5 +186,2 @@ export * from "./workspace/index.js"

		// Predictive Intelligence (5 tools)
		export * from "./predictive-intelligence/index.js"

		// Service Portal (3 tools)
		@@ -223,8 +214,2 @@ export * from "./service-portal/index.js"

		// AI & ML (3 tools)
		export * from "./ai-ml/index.js"

		// Machine Learning - TensorFlow.js Neural Networks (9 tools)
		export * from "./machine-learning/index.js"

		// ATF (Automated Test Framework) (6 tools)
		@@ -251,5 +236,2 @@ export * from "./atf/index.js"

		// Monitoring (1 tool)
		export * from "./monitoring/index.js"

		// Blast Radius (5 tools)
		@@ -256,0 +238,0 @@ export * from "./blast-radius/index.js"

+2

-4

src/servicenow/ser...ity/snow_analyze_threat_intelligence.ts

		import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
		import type { ServiceNowClient } from "../../../../utils/servicenow-client.js"
		import type { MCPLogger } from "../../../shared/mcp-logger.js"
		import { MCPToolDefinition, ToolResult } from "../../shared/types.js"
		@@ -69,4 +67,4 @@ import { ServiceNowContext } from "../../shared/types.js"
		args: AnalyzeThreatIntelligenceArgs,
		client: ServiceNowClient,
		logger: MCPLogger,
		client: any,
		logger: any,
		) {
		@@ -73,0 +71,0 @@ try {

+1

-3

src/servicenow/ser...s/security/snow_audit_trail_analysis.ts

		import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
		import type { ServiceNowClient } from "../../../../utils/servicenow-client.js"
		import type { MCPLogger } from "../../../shared/mcp-logger.js"
		import { MCPToolDefinition, ToolResult, ServiceNowContext } from "../../shared/types.js"
		@@ -66,3 +64,3 @@

		export async function auditTrailAnalysis(args: AuditTrailAnalysisArgs, client: ServiceNowClient, logger: MCPLogger) {
		export async function auditTrailAnalysis(args: AuditTrailAnalysisArgs, client: any, logger: any) {
		try {
		@@ -69,0 +67,0 @@ const timeframe = args.timeframe \|\| "24h"

+2

-4

src/servicenow/ser...curity/snow_automate_threat_response.ts

		import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
		import type { ServiceNowClient } from "../../../../utils/servicenow-client.js"
		import type { MCPLogger } from "../../../shared/mcp-logger.js"
		import { MCPToolDefinition, ToolResult, ServiceNowContext } from "../../shared/types.js"
		@@ -67,4 +65,4 @@
		args: AutomateThreatResponseArgs,
		client: ServiceNowClient,
		logger: MCPLogger,
		client: any,
		logger: any,
		) {
		@@ -71,0 +69,0 @@ try {

+2

-4

src/servicenow/ser.../security/snow_create_access_control.ts

		import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
		import type { ServiceNowClient } from "../../../../utils/servicenow-client.js"
		import type { MCPLogger } from "../../../shared/mcp-logger.js"
		import { MCPToolDefinition, ToolResult, ServiceNowContext } from "../../shared/types.js"
		@@ -79,3 +77,3 @@

		export async function createAccessControl(args: CreateAccessControlArgs, client: ServiceNowClient, logger: MCPLogger) {
		export async function createAccessControl(args: CreateAccessControlArgs, client: any, logger: any) {
		try {
		@@ -122,3 +120,3 @@ logger.info("Creating Access Control...")
		tableName: string,
		client: ServiceNowClient,
		client: any,
		): Promise<{ name: string; label: string } \| null> {
		@@ -125,0 +123,0 @@ try {

+1

-3

src/servicenow/ser...ools/security/snow_create_audit_rule.ts

		import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
		import type { ServiceNowClient } from "../../../../utils/servicenow-client.js"
		import type { MCPLogger } from "../../../shared/mcp-logger.js"
		import { MCPToolDefinition, ToolResult, ServiceNowContext } from "../../shared/types.js"
		@@ -82,3 +80,3 @@

		export async function createAuditRule(args: CreateAuditRuleArgs, client: ServiceNowClient, logger: MCPLogger) {
		export async function createAuditRule(args: CreateAuditRuleArgs, client: any, logger: any) {
		try {
		@@ -85,0 +83,0 @@ logger.info("Creating Audit Rule...")

+86

-31

src/servicenow/ser...olicies/snow_create_ui_policy_action.ts

		@@ -7,5 +7,18 @@ /**
		* conditions are met.
		*
		* ServiceNow field mapping:
		* - visible/mandatory/disabled are STRING fields with values: "true", "false", "ignore"
		* - "disabled" is the actual column name for "Read only" in the UI
		* - "table" is auto-derived from the parent UI policy but must be sent for field validation
		*
		* Platform limitation:
		* The "ui_policy" reference field on sys_ui_policy_action cannot be set via
		* the REST Table API (POST/PUT/PATCH all silently ignore it). This is a known
		* ServiceNow platform restriction for parent-child reference fields.
		* Workaround: after Table API creation, a direct XML POST is attempted to set
		* the ui_policy reference. If the XML POST also fails, the action is created
		* without the reference — it can be linked manually in the UI.
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import type { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		@@ -19,3 +32,3 @@ import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"
		category: "development",
		subcategory: "platform",
		subcategory: "ui-policies",
		use_cases: ["ui-policy-actions", "form-control", "ui-automation"],
		@@ -36,3 +49,4 @@ complexity: "intermediate",
		type: "string",
		description: "Table name the UI policy applies to (e.g. 'incident', 'change_request'). Must match the table on the parent UI policy.",
		description:
		"Table name the UI policy applies to (e.g. 'incident', 'change_request'). Must match the table on the parent UI policy.",
		},
		@@ -45,11 +59,13 @@ field: {
		type: "boolean",
		description: "Set field visibility. true = visible, false = hidden. Omit to leave unchanged.",
		description: "Set field visibility. true = visible, false = hidden. Omit to leave unchanged ('ignore').",
		},
		mandatory: {
		type: "boolean",
		description: "Set field mandatory state. true = required, false = optional. Omit to leave unchanged.",
		description:
		"Set field mandatory state. true = required, false = optional. Omit to leave unchanged ('ignore').",
		},
		readonly: {
		type: "boolean",
		description: "Set field read-only state. true = read-only, false = editable. Omit to leave unchanged.",
		description:
		"Set field read-only state. true = read-only, false = editable. Omit to leave unchanged ('ignore').",
		},
		@@ -65,48 +81,87 @@ cleared: {

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { ui_policy_sys_id, table, field, visible, mandatory, readonly, cleared } = args
		function toActionValue(val: boolean \| undefined): string {
		if (val === undefined) return "ignore"
		return val ? "true" : "false"
		}

		export async function execute(args: Record<string, unknown>, context: ServiceNowContext): Promise<ToolResult> {
		const uid = args.ui_policy_sys_id as string
		const table = args.table as string
		const field = args.field as string
		const visible = args.visible as boolean \| undefined
		const mandatory = args.mandatory as boolean \| undefined
		const readonly = args.readonly as boolean \| undefined
		const cleared = args.cleared as boolean \| undefined

		try {
		const client = await getAuthenticatedClient(context)

		// Look up the parent UI policy to validate it exists and get its table
		const policyResponse = await client.get(
		"/api/now/table/sys_ui_policy/" + ui_policy_sys_id + "?sysparm_fields=sys_id,table,short_description",
		const policyRes = await client.get(
		"/api/now/table/sys_ui_policy/" + uid + "?sysparm_fields=sys_id,table,short_description",
		)
		const policy = policyResponse.data.result
		const policy = policyRes.data.result
		if (!policy \|\| !policy.sys_id) {
		return createErrorResult("UI Policy not found with sys_id: " + ui_policy_sys_id)
		return createErrorResult("UI Policy not found with sys_id: " + uid)
		}

		const actionData: any = {
		ui_policy: ui_policy_sys_id,
		const payload: Record<string, string \| boolean> = {
		ui_policy: uid,
		table: table,
		field: field,
		visible: visible !== undefined ? visible : true,
		mandatory: mandatory !== undefined ? mandatory : false,
		readonly: readonly !== undefined ? readonly : false,
		cleared: cleared !== undefined ? cleared : false,
		visible: toActionValue(visible),
		mandatory: toActionValue(mandatory),
		disabled: toActionValue(readonly),
		cleared: cleared === true,
		}

		const response = await client.post("/api/now/table/sys_ui_policy_action", actionData)
		const response = await client.post("/api/now/table/sys_ui_policy_action", payload)
		const action = response.data.result
		const actionSysId = action.sys_id?.value \|\| action.sys_id

		const linked = await (async () => {
		try {
		const xmlBody =
		"<record>" + "<sys_id>" + actionSysId + "</sys_id>" + "<ui_policy>" + uid + "</ui_policy>" + "</record>"
		await client.post("/sys_ui_policy_action.do?XML&sys_id=" + actionSysId, xmlBody, {
		headers: { "Content-Type": "application/xml" },
		})

		const verify = await client.get(
		"/api/now/table/sys_ui_policy_action/" + actionSysId + "?sysparm_fields=ui_policy",
		)
		const ref = verify.data.result?.ui_policy
		const val = typeof ref === "object" && ref !== null ? ref.value : ref
		return !!val && val !== ""
		} catch (_e) {
		return false
		}
		})()

		const refVal = action.ui_policy
		const resolvedRef = typeof refVal === "object" && refVal !== null ? refVal.value : refVal

		return createSuccessResult({
		created: true,
		action: {
		sys_id: action.sys_id,
		ui_policy: ui_policy_sys_id,
		table: table,
		field: action.field,
		visible: action.visible,
		mandatory: action.mandatory,
		readonly: action.readonly,
		cleared: action.cleared,
		sys_id: actionSysId,
		ui_policy: linked ? uid : resolvedRef \|\| "",
		ui_policy_linked: linked,
		table: action.table?.value \|\| action.table,
		field: action.field?.value \|\| action.field,
		visible: action.visible?.value \|\| action.visible,
		mandatory: action.mandatory?.value \|\| action.mandatory,
		disabled: action.disabled?.value \|\| action.disabled,
		cleared: action.cleared?.value \|\| action.cleared,
		},
		warning: linked
		? undefined
		: "The ui_policy reference field could not be set via the REST API (ServiceNow platform limitation). The action was created but is not linked to the parent UI policy. Link it manually in the ServiceNow UI.",
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		} catch (error: unknown) {
		const msg = error instanceof Error ? error.message : String(error)
		return createErrorResult(msg)
		}
		}

		export const version = "1.0.0"
		export const version = "1.1.0"
		export const author = "Snow-Flow SDK Migration"

+7

-7

src/servicenow/shared/mcp-prompt-manager.ts

		@@ -7,3 +7,3 @@ /**

		import { Logger } from "../utils/logger.js"
		import { mcpDebug } from "./mcp-debug.js"

		@@ -89,3 +89,3 @@ /**
		export class MCPPromptManager {
		private logger: Logger
		private prefix: string
		private promptRegistry: Map<string, MCPPrompt> = new Map()
		@@ -96,3 +96,3 @@ private promptHandlers: Map<string, PromptHandler> = new Map()
		constructor(serverName: string = "mcp-server") {
		this.logger = new Logger(`PromptManager:${serverName}`)
		this.prefix = `[PromptManager:${serverName}]`
		this.initializeDefaultPrompts()
		@@ -115,3 +115,3 @@ }
		this.promptHandlers.set(prompt.name, handler)
		this.logger.debug(`Registered prompt: ${prompt.name}`)
		mcpDebug(`Registered prompt: ${prompt.name}`)
		}
		@@ -126,3 +126,3 @@
		if (deleted) {
		this.logger.debug(`Unregistered prompt: ${name}`)
		mcpDebug(`Unregistered prompt: ${name}`)
		}
		@@ -169,3 +169,3 @@ return deleted

		this.logger.debug(`Executing prompt: ${name}`, { args })
		mcpDebug(`Executing prompt: ${name}`, { args })
		return await handler(args)
		@@ -227,4 +227,4 @@ }
		this.categories = []
		this.logger.debug("All prompts cleared")
		mcpDebug("All prompts cleared")
		}
		}

-732

src/servicenow/base-mcp-server.ts

		/**
		* Base MCP Server Implementation
		*
		* Solves DRY violations by providing common functionality for all MCP servers:
		* - Unified authentication handling
		* - Consistent error handling
		* - Session management
		* - Logging and monitoring
		* - Retry logic with exponential backoff
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import {
		CallToolRequestSchema,
		ErrorCode,
		ListToolsRequestSchema,
		McpError,
		Tool,
		} from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { ServiceNowOAuth } from "../utils/snow-oauth.js"
		import { Logger } from "../utils/logger.js"
		import { ResponseLimiter } from "./shared/response-limiter.js"
		import { timerRegistry } from "../utils/timer-registry.js"
		import { BoundedMap } from "../utils/memory-safe-collections.js"

		export interface MCPServerConfig {
		name: string
		version: string
		description?: string
		requiresAuth?: boolean // Optional flag to disable ServiceNow authentication
		capabilities?: {
		tools?: {}
		resources?: {}
		prompts?: {}
		}
		}

		export interface ToolResult<T = any> {
		success: boolean
		result?: T
		error?: string
		retryable?: boolean
		executionTime?: number
		}

		export interface AuthResult {
		success: boolean
		error?: string
		token?: string
		expiresIn?: number
		}

		/**
		* Base class for all ServiceNow MCP servers
		* Provides common functionality to eliminate code duplication
		*/
		export abstract class BaseMCPServer {
		protected server: Server
		protected client: ServiceNowClient
		protected oauth: ServiceNowOAuth
		protected logger: Logger
		protected transport: StdioServerTransport
		protected tools: Map<string, Tool> = new Map()
		protected config: MCPServerConfig // Store the config for later use

		// Session management
		private sessionToken?: string
		private sessionExpiry?: Date
		private authCheckInterval?: NodeJS.Timeout

		// MEMORY FIX: Use BoundedMap to prevent unbounded growth
		// Default: 500 tools - very conservative, snow-flow has ~400 tools total
		private toolMetrics: BoundedMap<string, { calls: number; totalTime: number; errors: number }> = new BoundedMap(
		parseInt(process.env.SNOW_TOOL_METRICS_LIMIT \|\| "500"),
		)

		constructor(config: MCPServerConfig) {
		// Store the config
		this.config = config
		// Initialize server with config
		this.server = new Server(
		{
		name: config.name,
		version: config.version,
		},
		{
		capabilities: config.capabilities \|\| { tools: {} },
		},
		)

		// Initialize common dependencies
		this.client = new ServiceNowClient()
		this.oauth = new ServiceNowOAuth()
		this.logger = new Logger(`MCP:${config.name}`)
		this.transport = new StdioServerTransport()

		// Setup common functionality
		this.setupCommonHandlers()
		this.setupAuthentication()
		this.setupErrorHandling()
		this.setupMetrics()

		// Let child classes define their specific tools
		this.setupTools()
		}

		/**
		* Setup common request handlers
		*/
		private setupCommonHandlers(): void {
		// Handle tool listing
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: Array.from(this.tools.values()),
		}))

		// Handle tool execution with common auth/error handling
		this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
		const { name, arguments: args } = request.params

		// Track metrics
		const startTime = Date.now()
		const metrics = this.toolMetrics.get(name) \|\| { calls: 0, totalTime: 0, errors: 0 }
		metrics.calls++

		try {
		// Validate authentication first (skip if not required)
		if (this.config.requiresAuth !== false) {
		const authResult = await this.validateAuth()
		if (!authResult.success) {
		throw new McpError(ErrorCode.InvalidRequest, `Authentication failed: ${authResult.error}`)
		}
		}

		// Execute tool with retry logic
		let result = await this.executeWithRetry(name, args)

		// Limit response size to prevent timeouts
		const { limited, wasLimited, originalSize } = ResponseLimiter.limitResponse(result)

		if (wasLimited) {
		this.logger.warn(
		`Response limited for ${name}: ${originalSize} bytes -> ${JSON.stringify(limited).length} bytes`,
		)

		// Only create summary for EXTREMELY large responses (>2MB)
		// Normal widgets/flows should pass through fine with 500KB limit
		if (originalSize > 2000000) {
		// > 2MB - truly excessive
		result = ResponseLimiter.createSummaryResponse(result, name)
		} else {
		result = limited
		}
		}

		// Add token tracking metadata
		const responseSize = JSON.stringify(result).length
		const estimatedTokens = Math.ceil(responseSize / 4)

		if (result && typeof result === "object") {
		result._meta = {
		...result._meta,
		tokenCount: estimatedTokens,
		responseSize,
		wasLimited,
		}
		}

		// Update metrics
		metrics.totalTime += Date.now() - startTime
		this.toolMetrics.set(name, metrics)

		return result
		} catch (error) {
		// Update error metrics
		metrics.errors++
		metrics.totalTime += Date.now() - startTime
		this.toolMetrics.set(name, metrics)

		throw error
		}
		})
		}

		/**
		* Setup authentication with automatic token refresh
		*/
		private setupAuthentication(): void {
		// Skip authentication setup if not required
		if (this.config.requiresAuth === false) {
		return
		}

		// MEMORY FIX: Use timerRegistry for proper cleanup
		timerRegistry.registerInterval(
		`${this.config.name}-auth-check`,
		async () => {
		try {
		await this.validateAuth()
		} catch (error) {
		this.logger.error("Background auth check failed:", error)
		}
		},
		5 * 60 * 1000, // 5 minutes
		true, // unref
		)
		}

		/**
		* Validate authentication with smart caching
		*/
		protected async validateAuth(): Promise<AuthResult> {
		try {
		// Check if we have a valid session
		if (this.sessionToken && this.sessionExpiry && this.sessionExpiry > new Date()) {
		return { success: true, token: this.sessionToken }
		}

		// Validate connection
		const connectionResult = await this.validateServiceNowConnection()
		if (!connectionResult.success) {
		return {
		success: false,
		error: connectionResult.error \|\| "Authentication validation failed",
		}
		}

		// Get fresh token
		const isAuthenticated = await this.oauth.isAuthenticated()
		if (!isAuthenticated) {
		// Try to refresh
		try {
		await this.oauth.refreshAccessToken()
		} catch (refreshError) {
		return {
		success: false,
		error: 'OAuth authentication required. Run "snow-flow auth login" to authenticate.',
		}
		}
		}

		// Cache session info
		const tokenInfo = await this.oauth.loadTokens()
		this.sessionToken = tokenInfo?.access_token
		this.sessionExpiry = new Date(Date.now() + (tokenInfo?.expires_in \|\| 3600) * 1000)

		return {
		success: true,
		token: this.sessionToken,
		expiresIn: tokenInfo.expires_in,
		}
		} catch (error) {
		this.logger.error("Authentication validation failed:", error)
		return {
		success: false,
		error: error instanceof Error ? error.message : "Unknown authentication error",
		}
		}
		}

		/**
		* 🔴 SNOW-003 FIX: Enhanced retry logic with intelligent backoff and circuit breaker
		* Addresses the 19% failure rate with better retry strategies and failure prevention
		*/
		private async executeWithRetry(toolName: string, args: any, attempt = 1): Promise<any> {
		// 🔴 CRITICAL: Increased retries from 3 to 6 for better resilience
		const maxRetries = 6

		// 🔴 CRITICAL: Intelligent backoff based on error type
		const backoffMs = this.calculateBackoff(attempt, toolName)

		// 🔴 CRITICAL: Dynamic timeout based on tool complexity
		const timeout = this.calculateTimeout(toolName)

		try {
		// Get tool handler
		const handler = this.getToolHandler(toolName)
		if (!handler) {
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${toolName}`)
		}

		// 🔴 CRITICAL: Memory usage check before execution
		if (attempt === 1) {
		await this.checkMemoryUsage()
		}

		// Execute with dynamic timeout
		const result = await Promise.race([
		handler(args),
		new Promise((_, reject) =>
		setTimeout(() => reject(new Error(`Tool execution timeout after ${timeout}ms`)), timeout),
		),
		])

		// 🔴 SUCCESS: Reset circuit breaker on success
		this.resetCircuitBreaker(toolName)

		return result
		} catch (error) {
		this.logger.error(`🔴 Tool ${toolName} execution failed (attempt ${attempt}/${maxRetries}):`, error)

		// 🔴 CRITICAL: Update circuit breaker
		this.updateCircuitBreaker(toolName, error)

		// Check if retryable and within limits
		if (attempt < maxRetries && this.isRetryableError(error) && !this.isCircuitBreakerOpen(toolName)) {
		this.logger.info(`🔄 Retrying ${toolName} after ${backoffMs}ms (attempt ${attempt + 1}/${maxRetries})...`)
		await new Promise((resolve) => setTimeout(resolve, backoffMs))
		return this.executeWithRetry(toolName, args, attempt + 1)
		}

		// 🔴 FINAL FAILURE: Enhanced error reporting
		const errorMessage = this.createEnhancedErrorMessage(toolName, error, attempt, maxRetries)
		throw new McpError(ErrorCode.InternalError, errorMessage)
		}
		}

		/**
		* 🔴 SNOW-003 FIX: Calculate intelligent backoff based on error type and attempt
		*/
		private calculateBackoff(attempt: number, toolName: string): number {
		// Base exponential backoff: 1s, 2s, 4s, 8s, 16s, 32s
		const baseBackoff = 1000 * Math.pow(2, attempt - 1)

		// Add jitter to prevent thundering herd (±25%)
		const jitter = baseBackoff * 0.25 * (Math.random() - 0.5)

		// Cap maximum backoff at 30 seconds
		const maxBackoff = 30000

		return Math.min(baseBackoff + jitter, maxBackoff)
		}

		/**
		* 🔴 SNOW-003 FIX: Calculate dynamic timeout based on tool complexity
		*/
		private calculateTimeout(toolName: string): number {
		// Tool-specific timeouts based on complexity
		const timeoutMap: Record<string, number> = {
		snow_create_flow: 90000, // Flow creation: 90s
		snow_create_artifact: 120000, // Artifact creation: 2 minutes
		snow_create_widget: 120000, // Widget creation: 2 minutes
		ml_train_incident_classifier: 300000, // ML training: 5 minutes
		ml_train_change_risk: 300000, // ML training: 5 minutes
		snow_comprehensive_search: 45000, // Search: 45s
		snow_find_artifact: 30000, // Find: 30s
		snow_validate_live_connection: 15000, // Validation: 15s
		}

		// Default timeout for unknown tools
		return timeoutMap[toolName] \|\| 60000 // 60s default (increased from 30s)
		}

		// 🔴 SNOW-003 FIX: Circuit breaker implementation
		// MEMORY FIX: Use BoundedMap to prevent unbounded growth
		// Default: 500 - matches tool count, as each tool can have a circuit breaker
		private circuitBreakers: BoundedMap<string, { failures: number; lastFailure: number; isOpen: boolean }> =
		new BoundedMap(parseInt(process.env.SNOW_CIRCUIT_BREAKER_LIMIT \|\| "500"))

		private updateCircuitBreaker(toolName: string, error: any): void {
		const breaker = this.circuitBreakers.get(toolName) \|\| { failures: 0, lastFailure: 0, isOpen: false }

		breaker.failures++
		breaker.lastFailure = Date.now()

		// Open circuit breaker after 5 failures within 5 minutes
		if (breaker.failures >= 5 && Date.now() - breaker.lastFailure < 300000) {
		breaker.isOpen = true
		this.logger.warn(`🚨 Circuit breaker opened for ${toolName} due to repeated failures`)
		}

		this.circuitBreakers.set(toolName, breaker)
		}

		private isCircuitBreakerOpen(toolName: string): boolean {
		const breaker = this.circuitBreakers.get(toolName)
		if (!breaker \|\| !breaker.isOpen) return false

		// Auto-reset circuit breaker after 10 minutes
		if (Date.now() - breaker.lastFailure > 600000) {
		breaker.isOpen = false
		breaker.failures = 0
		this.circuitBreakers.set(toolName, breaker)
		this.logger.info(`✅ Circuit breaker reset for ${toolName}`)
		return false
		}

		return true
		}

		private resetCircuitBreaker(toolName: string): void {
		const breaker = this.circuitBreakers.get(toolName)
		if (breaker) {
		breaker.failures = 0
		breaker.isOpen = false
		this.circuitBreakers.set(toolName, breaker)
		}
		}

		/**
		* 🔴 SNOW-003 FIX: Memory usage monitoring to prevent memory exhaustion failures
		*/
		private async checkMemoryUsage(): Promise<void> {
		try {
		const memUsage = process.memoryUsage()
		const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024)
		const heapTotalMB = Math.round(memUsage.heapTotal / 1024 / 1024)

		// Log memory usage if high (>200MB)
		if (heapUsedMB > 200) {
		this.logger.warn(`⚠️ High memory usage: ${heapUsedMB}MB heap used, ${heapTotalMB}MB total`)
		}

		// Trigger garbage collection if memory usage is very high (>500MB)
		if (heapUsedMB > 500 && global.gc) {
		this.logger.info("🧹 Triggering garbage collection due to high memory usage")
		global.gc()
		}

		// Fail fast if memory usage is critical (>800MB)
		if (heapUsedMB > 800) {
		throw new Error(`Critical memory usage: ${heapUsedMB}MB. Operation aborted to prevent system instability.`)
		}
		} catch (error) {
		this.logger.warn("Could not check memory usage:", error)
		}
		}

		/**
		* 🔴 SNOW-003 FIX: Enhanced error message with troubleshooting guidance
		*/
		private createEnhancedErrorMessage(toolName: string, error: any, attempts: number, maxRetries: number): string {
		const baseMessage = `Tool '${toolName}' failed after ${attempts}/${maxRetries} attempts`
		const errorDetail = error instanceof Error ? error.message : String(error)

		let troubleshooting = ""

		// Add specific troubleshooting based on error type
		if ((error as any).response?.status === 401) {
		troubleshooting = '\n💡 Authentication issue: Run "snow-flow auth login" to re-authenticate'
		} else if ((error as any).response?.status === 403) {
		troubleshooting = "\n💡 Permission issue: Check ServiceNow user permissions and OAuth scopes"
		} else if ((error as any).response?.status >= 500) {
		troubleshooting = "\n💡 ServiceNow server issue: Try again later or contact ServiceNow administrator"
		} else if (errorDetail.includes("timeout")) {
		troubleshooting = "\n💡 Timeout issue: ServiceNow instance may be slow - try again later"
		} else if (errorDetail.includes("network") \|\| errorDetail.includes("connection")) {
		troubleshooting = "\n💡 Network issue: Check internet connection and ServiceNow instance availability"
		}

		return `${baseMessage}: ${errorDetail}${troubleshooting}`
		}

		/**
		* 🔴 SNOW-003 FIX: Enhanced error classification for ServiceNow specific errors
		* Addresses the 19% failure rate by properly categorizing retryable errors
		*/
		private isRetryableError(error: any): boolean {
		if (error instanceof Error) {
		const message = error.message.toLowerCase()

		// 🔴 CRITICAL: ServiceNow specific retryable errors
		const serviceNowRetryable =
		message.includes("timeout") \|\|
		message.includes("econnreset") \|\|
		message.includes("socket hang up") \|\|
		message.includes("enotfound") \|\|
		message.includes("rate limit") \|\|
		message.includes("service unavailable") \|\|
		message.includes("bad gateway") \|\|
		message.includes("gateway timeout") \|\|
		message.includes("connection refused") \|\|
		message.includes("network error") \|\|
		message.includes("dns lookup failed") \|\|
		message.includes("connect etimedout") \|\|
		message.includes("index not available") \|\|
		message.includes("search index updating") \|\|
		message.includes("temporary failure") \|\|
		message.includes("server is busy") \|\|
		message.includes("database lock") \|\|
		message.includes("deadlock detected")

		// 🔴 CRITICAL: HTTP status code based retry logic
		if ((error as any).response?.status) {
		const status = (error as any).response.status
		const httpRetryable =
		status === 429 \|\| // Rate limit
		status === 502 \|\| // Bad Gateway
		status === 503 \|\| // Service Unavailable
		status === 504 \|\| // Gateway Timeout
		status === 507 \|\| // Insufficient Storage
		status === 520 \|\| // CloudFlare unknown error
		status === 521 \|\| // Web server is down
		status === 522 \|\| // Connection timed out
		status === 523 \|\| // Origin is unreachable
		status === 524 // A timeout occurred

		// 401 is retryable only once (for token refresh)
		const authRetryable = status === 401 && !(error as any).config?._retry

		return httpRetryable \|\| authRetryable
		}

		return serviceNowRetryable
		}

		// Handle specific error types
		if (error.code) {
		const retryableCodes = [
		"ECONNRESET",
		"ENOTFOUND",
		"ECONNREFUSED",
		"ETIMEDOUT",
		"ESOCKETTIMEDOUT",
		"EHOSTUNREACH",
		"EPIPE",
		"EAI_AGAIN",
		]
		return retryableCodes.includes(error.code)
		}

		return false
		}

		// MEMORY FIX: Named handlers for proper cleanup
		private uncaughtExceptionHandler = (error: Error) => {
		this.logger.error("Uncaught exception:", error)
		this.gracefulShutdown()
		}

		private unhandledRejectionHandler = (reason: any, promise: Promise<any>) => {
		this.logger.error("Unhandled rejection:", { promise, reason })
		}

		private sigintHandler = () => {
		this.logger.info("Received SIGINT, shutting down gracefully...")
		this.gracefulShutdown()
		}

		/**
		* Setup global error handling
		*/
		private setupErrorHandling(): void {
		// MEMORY FIX: Use named handlers so they can be removed later
		process.on("uncaughtException", this.uncaughtExceptionHandler)
		process.on("unhandledRejection", this.unhandledRejectionHandler)
		process.on("SIGINT", this.sigintHandler)
		}

		/**
		* Setup metrics collection
		*/
		private setupMetrics(): void {
		// MEMORY FIX: Use timerRegistry for proper cleanup
		timerRegistry.registerInterval(
		`${this.config.name}-metrics`,
		() => {
		const metrics = Array.from(this.toolMetrics.entries()).map(([tool, data]) => ({
		tool,
		calls: data.calls,
		avgTime: data.calls > 0 ? Math.round(data.totalTime / data.calls) : 0,
		errorRate: data.calls > 0 ? ((data.errors / data.calls) * 100).toFixed(2) : "0",
		}))

		if (metrics.length > 0) {
		this.logger.info("Tool metrics:", metrics)
		}
		},
		60000, // Every minute
		true, // unref
		)
		}

		/**
		* Execute tool with common error handling
		*/
		protected async executeTool<T>(toolName: string, handler: () => Promise<T>): Promise<ToolResult<T>> {
		const startTime = Date.now()

		try {
		// Validate auth before execution
		const authResult = await this.validateAuth()
		if (!authResult.success) {
		return {
		success: false,
		error: authResult.error,
		retryable: true,
		}
		}

		// Execute the tool logic
		const result = await handler()

		// Log success
		this.logger.debug(`Tool ${toolName} executed successfully in ${Date.now() - startTime}ms`)

		return {
		success: true,
		result,
		executionTime: Date.now() - startTime,
		}
		} catch (error) {
		this.logger.error(`Tool ${toolName} failed:`, error)

		return {
		success: false,
		error: error instanceof Error ? error.message : "Unknown error",
		retryable: this.isRetryableError(error),
		executionTime: Date.now() - startTime,
		}
		}
		}

		/**
		* Register a tool
		*/
		protected registerTool(tool: Tool, handler: (args: any) => Promise<any>): void {
		this.tools.set(tool.name, tool)
		this.toolHandlers.set(tool.name, handler)
		}

		/**
		* Tool handlers map
		*/
		private toolHandlers: Map<string, (args: any) => Promise<any>> = new Map()

		/**
		* Get tool handler
		*/
		private getToolHandler(name: string): ((args: any) => Promise<any>) \| undefined {
		return this.toolHandlers.get(name)
		}

		/**
		* Graceful shutdown
		*/
		private async gracefulShutdown(): Promise<void> {
		this.logger.info("Starting graceful shutdown...")

		// MEMORY FIX: Remove event listeners to prevent accumulation
		process.removeListener("uncaughtException", this.uncaughtExceptionHandler)
		process.removeListener("unhandledRejection", this.unhandledRejectionHandler)
		process.removeListener("SIGINT", this.sigintHandler)

		// MEMORY FIX: Clear intervals via timerRegistry
		timerRegistry.clearInterval(`${this.config.name}-auth-check`)
		timerRegistry.clearInterval(`${this.config.name}-metrics`)

		// Also clear legacy interval if it exists
		if (this.authCheckInterval) {
		clearInterval(this.authCheckInterval)
		}

		// Log final metrics
		const metrics = Array.from(this.toolMetrics.entries())
		if (metrics.length > 0) {
		this.logger.info("Final metrics:", metrics)
		}

		// MEMORY FIX: Clear collections
		this.toolMetrics.clear()
		this.circuitBreakers.clear()
		this.tools.clear()
		this.toolHandlers.clear()

		// Close connections
		try {
		await this.oauth.logout()
		} catch (error) {
		this.logger.error("Error during logout:", error)
		}

		this.logger.info("Graceful shutdown complete")
		process.exit(0)
		}

		/**
		* Start the server
		*/
		async start(): Promise<void> {
		this.logger.info(`Starting ${this.config.name} v${this.config.version}`)

		// Validate initial connection (skip if not required)
		if (this.config.requiresAuth !== false) {
		const authResult = await this.validateAuth()
		if (!authResult.success) {
		this.logger.warn("Starting without authentication - some features may be limited")
		}
		}

		await this.server.connect(this.transport)
		this.logger.info("MCP server started successfully")
		}

		/**
		* Abstract method for child classes to implement their specific tools
		*/
		/**
		* Validate ServiceNow connection
		*/
		protected async validateServiceNowConnection(): Promise<AuthResult> {
		try {
		const isAuthenticated = await this.oauth.isAuthenticated()
		if (!isAuthenticated) {
		return {
		success: false,
		error: "Not authenticated with ServiceNow",
		}
		}

		// Test connection with a simple request
		const response = await this.client.makeRequest({
		method: "GET",
		url: "/api/now/table/sys_properties",
		params: { sysparm_limit: 1 },
		})

		return {
		success: response.success,
		token: "valid",
		}
		} catch (error) {
		return {
		success: false,
		error: error instanceof Error ? error.message : "Connection validation failed",
		}
		}
		}

		protected abstract setupTools(): void
		}

-669

src/servicenow/cli/auth.ts

		import { Command } from "commander"
		import * as prompts from "@clack/prompts"
		import { execSync } from "child_process"
		import path from "path"
		import fs from "fs/promises"
		import os from "os"
		import { Logger } from "../utils/logger.js"
		import { existsSync, chmodSync } from "fs"
		import { addEnterpriseMcpServerWithToken } from "../config/snow-code-config.js"
		import { syncMcpConfigs } from "../utils/sync-mcp-configs.js"
		import { generateEnterpriseInstructions, generateStakeholderDocumentation } from "./enterprise-docs-generator.js"
		import type { ModelInfo } from "../utils/dynamic-models.js"

		const authLogger = new Logger("auth")

		// Helper function to fix binary permissions (critical for containers/codespaces)
		function fixSnowCodeBinaryPermissions(): void {
		try {
		const platforms = [
		"snow-code-darwin-arm64",
		"snow-code-darwin-x64",
		"snow-code-linux-arm64",
		"snow-code-linux-x64",
		"snow-code-windows-x64",
		]

		platforms.forEach((platform) => {
		// Try both global and local node_modules
		const paths = [
		path.join(process.cwd(), "node_modules", "@groeimetai", platform, "bin", "snow-code"),
		path.join(os.homedir(), ".npm", "_npx", "node_modules", "@groeimetai", platform, "bin", "snow-code"),
		path.join(__dirname, "..", "..", "node_modules", "@groeimetai", platform, "bin", "snow-code"),
		]

		paths.forEach((binaryPath) => {
		if (existsSync(binaryPath)) {
		try {
		chmodSync(binaryPath, 0o755)
		authLogger.debug(`Fixed permissions for ${platform}`)
		} catch (err) {
		// Silently continue if chmod fails
		}
		}
		})
		})
		} catch (error) {
		// Silently continue if permission fixing fails
		}
		}

		/**
		* Update project documentation (CLAUDE.md and AGENTS.md) with enterprise server information
		*
		* Generates comprehensive workflow instructions for enterprise integrations
		* (Jira, Azure DevOps, Confluence, GitHub, GitLab) when user authenticates.
		*/
		async function updateDocumentationWithEnterprise(enabledServices?: string[], role?: string): Promise<void> {
		if (!enabledServices \|\| enabledServices.length === 0) {
		authLogger.debug("No enabled services provided, skipping documentation update")
		return
		}

		const cwd = process.cwd()
		const claudeMdPath = path.join(cwd, "CLAUDE.md")
		const agentsMdPath = path.join(cwd, "AGENTS.md")

		const enterpriseMarker = "<!-- SNOW-FLOW-ENTERPRISE-START -->"
		const enterpriseEndMarker = "<!-- SNOW-FLOW-ENTERPRISE-END -->"

		try {
		let instructions: string

		if (role === "stakeholder") {
		instructions = generateStakeholderDocumentation()
		} else {
		instructions = generateEnterpriseInstructions(enabledServices)
		}

		const wrappedInstructions = `\n${enterpriseMarker}\n${instructions}\n${enterpriseEndMarker}\n`

		for (const docPath of [claudeMdPath, agentsMdPath]) {
		try {
		let existingContent = ""

		try {
		existingContent = await fs.readFile(docPath, "utf-8")
		} catch (err: any) {
		if (err.code !== "ENOENT") throw err
		}

		const markerStart = existingContent.indexOf(enterpriseMarker)
		const markerEnd = existingContent.indexOf(enterpriseEndMarker)

		let newContent: string

		if (markerStart !== -1 && markerEnd !== -1) {
		newContent =
		existingContent.substring(0, markerStart) +
		wrappedInstructions.trim() +
		existingContent.substring(markerEnd + enterpriseEndMarker.length)
		} else {
		newContent = existingContent + wrappedInstructions
		}

		await fs.writeFile(docPath, newContent, "utf-8")
		authLogger.info(`Updated ${path.basename(docPath)} with enterprise instructions`)
		} catch (err: any) {
		authLogger.warn(`Could not update ${path.basename(docPath)}: ${err.message}`)
		}
		}

		prompts.log.success("✅ Updated CLAUDE.md and AGENTS.md with enterprise workflow instructions")
		} catch (error: any) {
		authLogger.warn(`Failed to update documentation: ${error.message}`)
		}
		}

		/**
		* Setup Enterprise Flow
		* DEPRECATED: Enterprise setup is now integrated into snow-code auth flow
		* This function redirects users to use snow-code auth login instead
		*/
		export async function setupEnterpriseFlow(): Promise<void> {
		prompts.log.message("")
		prompts.log.info("⚠️ Enterprise setup has moved to snow-code auth flow")
		prompts.log.message("")
		prompts.log.info("Please use: snow-code auth login")
		prompts.log.info('Then select "enterprise" when prompted for authentication provider')
		prompts.log.message("")
		}

		/**
		* Ensure auth.json is in the correct location (snow-code with dash, not snowcode without)
		*
		* Snow-code binary may create auth.json at ~/.local/share/snowcode/ (without dash)
		* but the correct location is ~/.local/share/snow-code/ (with dash).
		* This function moves it if needed and creates a symlink for compatibility.
		*/
		async function ensureCorrectAuthLocation(): Promise<void> {
		try {
		const correctPath = path.join(os.homedir(), ".local", "share", "snow-code", "auth.json")
		const incorrectPath = path.join(os.homedir(), ".local", "share", "snowcode", "auth.json")

		// Check if file exists at incorrect location
		try {
		const stats = await fs.lstat(incorrectPath)

		// If it's already a symlink pointing to the correct location, we're done
		if (stats.isSymbolicLink()) {
		const linkTarget = await fs.readlink(incorrectPath)
		if (linkTarget === correctPath \|\| path.resolve(path.dirname(incorrectPath), linkTarget) === correctPath) {
		authLogger.debug("Symlink already exists at correct location")
		return
		}
		}

		// File exists at wrong location and is NOT a symlink - move it
		authLogger.info("Found auth.json at incorrect location (snowcode/ without dash)")
		authLogger.info("Moving to correct location (snow-code/ with dash)...")

		// Ensure correct directory exists
		const correctDir = path.dirname(correctPath)
		await fs.mkdir(correctDir, { recursive: true })

		// Copy file to correct location
		await fs.copyFile(incorrectPath, correctPath)
		authLogger.info(`✅ Moved auth.json to: ${correctPath}`)

		// Create symlink at old location for backwards compatibility
		try {
		const incorrectDir = path.dirname(incorrectPath)
		await fs.mkdir(incorrectDir, { recursive: true })

		// Remove old file after successful copy
		await fs.unlink(incorrectPath)

		// Create symlink
		await fs.symlink(correctPath, incorrectPath)
		authLogger.debug("Created symlink for backwards compatibility")
		} catch (symlinkError: any) {
		// Symlink creation failed, but that's OK - just log it
		authLogger.debug(`Could not create symlink: ${symlinkError.message}`)
		}

		prompts.log.success("✅ Auth credentials stored at correct location")
		} catch (err: any) {
		if (err.code === "ENOENT") {
		// File doesn't exist at incorrect location - check if it's already at correct location
		try {
		await fs.access(correctPath)
		authLogger.debug("Auth.json already at correct location")
		} catch {
		authLogger.debug("Auth.json not found at either location (will be created on next auth)")
		}
		}
		}
		} catch (error: any) {
		authLogger.warn(`Failed to ensure correct auth location: ${error.message}`)
		// Don't throw - this is not critical enough to fail the auth process
		}
		}

		/**
		* Update PROJECT-LEVEL MCP server config with ServiceNow credentials from auth.json
		*
		* IMPORTANT: This function ONLY updates project-level .mcp.json, NOT global config!
		* Each snow-flow project maintains its own isolated MCP configuration.
		*/
		async function updateMCPServerConfig() {
		try {
		// Read SnowCode auth.json
		const authPath = path.join(os.homedir(), ".local", "share", "snow-code", "auth.json")

		// Check if auth.json exists
		try {
		await fs.access(authPath)
		} catch {
		authLogger.debug("auth.json does not exist yet, skipping MCP config update")
		return
		}

		const authJson = JSON.parse(await fs.readFile(authPath, "utf-8"))

		// Check if ServiceNow credentials exist
		const servicenowCreds = authJson["servicenow"]
		if (!servicenowCreds \|\| servicenowCreds.type !== "servicenow-oauth") {
		authLogger.debug("No ServiceNow OAuth credentials found in auth.json")
		return
		}

		// Update PROJECT-LEVEL .mcp.json ONLY (no global config!)
		const projectMcpPath = path.join(process.cwd(), ".mcp.json")
		try {
		await fs.access(projectMcpPath)

		const projectMcp = JSON.parse(await fs.readFile(projectMcpPath, "utf-8"))

		// Support .mcp (snow-code 1.0.69), .mcpServers and .servers key formats
		const serversKey = projectMcp.mcp ? "mcp" : projectMcp.mcpServers ? "mcpServers" : "servers"

		if (projectMcp[serversKey] && projectMcp[serversKey]["servicenow-unified"]) {
		const server = projectMcp[serversKey]["servicenow-unified"]

		// Support both "environment" (OpenCode) and "env" (Claude Desktop) keys
		const envKey = server.environment !== undefined ? "environment" : "env"

		if (!server[envKey]) {
		server[envKey] = {}
		}

		// Update credentials in the environment object
		server[envKey]["SERVICENOW_INSTANCE_URL"] = servicenowCreds.instance
		server[envKey]["SERVICENOW_CLIENT_ID"] = servicenowCreds.clientId
		server[envKey]["SERVICENOW_CLIENT_SECRET"] = servicenowCreds.clientSecret

		await fs.writeFile(projectMcpPath, JSON.stringify(projectMcp, null, 2), "utf-8")
		} else {
		authLogger.debug("No servicenow-unified MCP server found in project .mcp.json")
		}
		} catch (err: any) {
		if (err.code === "ENOENT") {
		authLogger.warn('Project .mcp.json not found. Run "snow-flow" to auto-initialize.')
		prompts.log.warn("⚠️ No .mcp.json found in current directory")
		prompts.log.info("💡 Run: snow-flow")
		} else {
		authLogger.debug(`Could not update project .mcp.json: ${err.message}`)
		}
		}
		} catch (error: any) {
		authLogger.warn(`Failed to update MCP server config: ${error.message}`)
		// Don't throw - this is not critical
		}
		}

		export function registerAuthCommands(program: Command) {
		const auth = program.command("auth").description("Authentication management (powered by SnowCode)")

		// List available models for a provider
		auth
		.command("models")
		.description("List available models for LLM providers")
		.option("-p, --provider <provider>", "Provider to list models for (anthropic, openai, google, ollama)")
		.action(async (options) => {
		const { getAllProviderModels, getProviderModels } = await import("../utils/dynamic-models.js")

		prompts.log.step("Available LLM Models")

		if (options.provider) {
		// List models for specific provider
		prompts.log.info(`${options.provider.toUpperCase()}:`)
		const models: ModelInfo[] = await getProviderModels(options.provider)

		if (models.length > 0) {
		models.forEach((model: ModelInfo, i: number) => {
		prompts.log.message(` ${i + 1}. ${model.name}`)
		prompts.log.message(` ID: ${model.value}`)
		if (model.contextWindow) {
		prompts.log.message(` Context: ${model.contextWindow.toLocaleString()} tokens`)
		}
		prompts.log.message("")
		})
		} else {
		prompts.log.warn(" No models available for this provider")
		}
		} else {
		// List all providers
		const allModels: Record<string, ModelInfo[]> = await getAllProviderModels()

		for (const [provider, models] of Object.entries(allModels)) {
		prompts.log.info(`${provider.toUpperCase()}:`)

		if (models.length > 0) {
		models.forEach((model: ModelInfo, i: number) => {
		prompts.log.message(` ${i + 1}. ${model.name}`)
		prompts.log.message(` ID: ${model.value}`)
		prompts.log.message("")
		})
		} else {
		prompts.log.warn(" No models available")
		}
		}
		}

		prompts.log.message("Tip: Use --provider to see models for a specific provider")
		prompts.log.message("Example: snow-flow auth models --provider anthropic")
		})

		// Login - delegate to SnowCode
		auth
		.command("login")
		.description("Authenticate with LLM providers, ServiceNow, and Enterprise (via SnowCode)")
		.action(async () => {
		try {
		// Check if snowcode is installed
		try {
		execSync("which snow-code", { stdio: "ignore" })
		} catch {
		prompts.log.error("SnowCode is not installed")
		prompts.log.warn("Please run: npm install -g snow-flow")
		prompts.log.info("This will install both snow-flow and snow-code")
		return
		}

		// Determine which SnowCode to use: prefer local, fallback to global
		const localSnowCode = path.join(process.cwd(), "node_modules", "@groeimetai", "snow-code", "bin", "snow-code")
		let snowcodeCommand = "snow-code" // fallback to global

		try {
		const fs = require("fs")
		if (fs.existsSync(localSnowCode)) {
		snowcodeCommand = localSnowCode
		authLogger.debug("Using local SnowCode installation")
		}
		} catch {
		authLogger.debug("Using global SnowCode installation")
		}

		prompts.intro("🚀 Starting authentication flow (powered by SnowCode)")

		// Fix binary permissions before calling snow-code (critical for containers/codespaces)
		fixSnowCodeBinaryPermissions()

		// Call SnowCode auth login for LLM providers and ServiceNow OAuth
		// Use execFileSync to avoid shell injection from snowcodeCommand path
		const { execFileSync } = require("child_process")
		execFileSync(snowcodeCommand, ["auth", "login"], { stdio: "inherit" })

		// Post-processing: Ensure auth.json is in correct location
		await ensureCorrectAuthLocation()

		// Update MCP server config with ServiceNow credentials
		await updateMCPServerConfig()

		// 🔥 FIX: After snow-code auth login, check if enterprise was configured
		// Read from the CORRECT location: ~/.snow-code/enterprise.json (where snow-code saves it)
		const enterpriseConfigPath = path.join(os.homedir(), ".snow-code", "enterprise.json")
		try {
		// Check if enterprise config exists
		await fs.access(enterpriseConfigPath)

		const enterpriseConfig = JSON.parse(await fs.readFile(enterpriseConfigPath, "utf-8"))

		if (enterpriseConfig && enterpriseConfig.token) {
		authLogger.debug("Found enterprise configuration from snow-code auth login")

		// Use the JWT token directly from snow-code (already validated!)
		// No need to re-authenticate - just configure the MCP server with the existing token
		await addEnterpriseMcpServerWithToken({
		token: enterpriseConfig.token,
		serverUrl: "https://portal.snow-flow.dev",
		})

		// Sync MCP configurations
		try {
		await syncMcpConfigs(process.cwd())
		prompts.log.success("✓ Enterprise MCP server configured!")
		} catch (syncErr: any) {
		authLogger.warn(`MCP sync error: ${syncErr.message}`)
		}

		// Update CLAUDE.md and AGENTS.md with enterprise workflow instructions
		// Use features from enterprise config if available, otherwise default to all
		const enabledFeatures = enterpriseConfig.features \|\| [
		"jira",
		"azure-devops",
		"confluence",
		"github",
		"gitlab",
		]
		const userRole = enterpriseConfig.role \|\| "developer"
		await updateDocumentationWithEnterprise(enabledFeatures, userRole)
		}
		} catch (err: any) {
		// Show warning if enterprise configuration failed
		if (err.code === "ENOENT") {
		// No enterprise config - user didn't select enterprise option
		authLogger.debug("No enterprise configuration found (user may have chosen manual setup)")
		} else if (err.message && err.message.includes(".mcp.json not found")) {
		prompts.log.message("")
		prompts.log.warn("⚠️ Enterprise MCP configuration skipped")
		prompts.log.info(' Run "snow-flow" first to auto-create .mcp.json')
		prompts.log.info(' Then use "/auth" again to enable enterprise tools')
		} else if (err.message && !err.message.includes("ENOENT")) {
		// Only show error if it's not just "file doesn't exist"
		prompts.log.message("")
		prompts.log.warn("⚠️ Enterprise MCP configuration failed")
		prompts.log.info(` ${err.message}`)
		authLogger.error(`Enterprise MCP configuration error: ${err.stack \|\| err.message}`)
		} else {
		// Silently continue for expected cases
		authLogger.debug(`Enterprise conversion check: ${err.message}`)
		}
		}

		// 🔥 ALWAYS sync MCP configs after auth login completes
		// This ensures .claude/mcp-config.json is up-to-date even if enterprise wasn't configured
		try {
		authLogger.debug("Final MCP config sync after auth completion")
		await syncMcpConfigs(process.cwd())
		} catch (syncErr: any) {
		// Silent - already logged above if enterprise was configured
		authLogger.debug(`Final sync: ${syncErr.message}`)
		}
		} catch (error: any) {
		// Error details are already shown via stdio: 'inherit'
		// Only provide helpful context here
		prompts.log.message("")

		if (error.code === "ENOENT") {
		prompts.log.error("SnowCode command not found")
		prompts.log.info("Please ensure snow-code is properly installed")
		} else {
		prompts.log.error("Authentication process was interrupted or failed")

		if (error.status) {
		prompts.log.info(`Exit code: ${error.status}`)
		}

		prompts.log.message("")
		prompts.log.info("💡 Troubleshooting tips:")
		prompts.log.message(" • Check your license key format (SNOW-ENT-* or SNOW-SI-*)")
		prompts.log.message(" • Verify enterprise server is accessible")
		prompts.log.message(" • Try running: snow-code auth login (for detailed errors)")
		prompts.log.message(" • Check logs in ~/.local/share/snow-code/")
		}

		prompts.log.message("")
		}
		})

		// List credentials
		auth
		.command("list")
		.alias("ls")
		.description("List configured credentials (via SnowCode)")
		.action(async () => {
		try {
		fixSnowCodeBinaryPermissions()
		execSync("snow-code auth list", { stdio: "inherit" })
		} catch (error: any) {
		prompts.log.error("SnowCode is not installed. Run: npm install -g snow-flow")
		}
		})

		// Logout
		auth
		.command("logout")
		.description("Log out from a configured provider (via SnowCode)")
		.action(async () => {
		try {
		fixSnowCodeBinaryPermissions()
		execSync("snow-code auth logout", { stdio: "inherit" })
		} catch (error: any) {
		prompts.log.error("SnowCode is not installed. Run: npm install -g snow-flow")
		}
		})

		// Sync credentials to portal
		auth
		.command("sync")
		.description("Sync local credentials to Enterprise Portal")
		.action(async () => {
		prompts.intro("Credential Sync")

		try {
		// Read .env file from current directory
		const envPath = path.join(process.cwd(), ".env")
		const envContent = await fs.readFile(envPath, "utf-8")

		// Parse environment variables
		const envVars: Record<string, string> = {}
		envContent.split("\n").forEach((line) => {
		const match = line.match(/^([^=]+)=(.*)$/)
		if (match && match[1] && match[2]) {
		envVars[match[1].trim()] = match[2].trim().replace(/^["']\|["']$/g, "")
		}
		})

		const licenseKey = envVars.SNOW_ENTERPRISE_LICENSE_KEY
		const enterpriseUrl = envVars.SNOW_ENTERPRISE_URL \|\| "https://portal.snow-flow.dev"

		if (!licenseKey) {
		prompts.log.error("No enterprise license key found in .env")
		prompts.outro("Sync failed")
		return
		}

		// Login first to get customer token
		prompts.log.step("Authenticating with enterprise portal...")

		const username = envVars.SNOW_ENTERPRISE_USERNAME
		const password = envVars.SNOW_ENTERPRISE_PASSWORD

		if (!username \|\| !password) {
		prompts.log.error("Username or password not found in .env")
		prompts.log.info("Add SNOW_ENTERPRISE_USERNAME and SNOW_ENTERPRISE_PASSWORD to .env")
		prompts.outro("Sync failed")
		return
		}

		const loginResponse = await fetch(`${enterpriseUrl}/api/user-auth/login`, {
		method: "POST",
		headers: { "Content-Type": "application/json" },
		body: JSON.stringify({ licenseKey, username, password }),
		})

		const loginData: any = await loginResponse.json()

		if (!loginResponse.ok \|\| !loginData.success) {
		prompts.log.error("Authentication failed: " + (loginData.error \|\| "Invalid credentials"))
		prompts.outro("Sync failed")
		return
		}

		const token: string = loginData.token
		const credentialsToSync: Array<{ service: string; data: any }> = []

		// Check Jira credentials
		if (envVars.SNOW_JIRA_BASE_URL && envVars.SNOW_JIRA_EMAIL && envVars.SNOW_JIRA_API_TOKEN) {
		credentialsToSync.push({
		service: "jira",
		data: {
		service: "jira",
		username: envVars.SNOW_JIRA_EMAIL,
		apiToken: envVars.SNOW_JIRA_API_TOKEN,
		instanceUrl: envVars.SNOW_JIRA_BASE_URL,
		},
		})
		}

		// Check Azure DevOps credentials
		if (envVars.SNOW_AZURE_ORG && envVars.SNOW_AZURE_PAT) {
		credentialsToSync.push({
		service: "azdo",
		data: {
		service: "azdo",
		username: envVars.SNOW_AZURE_ORG,
		apiToken: envVars.SNOW_AZURE_PAT,
		instanceUrl: `https://dev.azure.com/${envVars.SNOW_AZURE_ORG}`,
		},
		})
		}

		// Check Confluence credentials
		if (envVars.SNOW_CONFLUENCE_BASE_URL && envVars.SNOW_CONFLUENCE_EMAIL && envVars.SNOW_CONFLUENCE_API_TOKEN) {
		credentialsToSync.push({
		service: "confluence",
		data: {
		service: "confluence",
		username: envVars.SNOW_CONFLUENCE_EMAIL,
		apiToken: envVars.SNOW_CONFLUENCE_API_TOKEN,
		instanceUrl: envVars.SNOW_CONFLUENCE_BASE_URL,
		},
		})
		}

		if (credentialsToSync.length === 0) {
		prompts.log.warn("No credentials found in .env to sync")
		prompts.outro("Nothing to sync")
		return
		}

		prompts.log.step(`Syncing ${credentialsToSync.length} credential(s)...`)

		// Sync each credential
		for (const cred of credentialsToSync) {
		try {
		const response = await fetch(`${enterpriseUrl}/api/credentials/store`, {
		method: "POST",
		headers: {
		"Content-Type": "application/json",
		Authorization: `Bearer ${token}`,
		},
		body: JSON.stringify(cred.data),
		})

		const result: any = await response.json()

		if (response.ok && result.success) {
		prompts.log.success(`✓ ${cred.service} credentials synced`)
		} else {
		prompts.log.error(`✗ ${cred.service} failed: ${result.error \|\| "Unknown error"}`)
		}
		} catch (error: any) {
		prompts.log.error(`✗ ${cred.service} failed: ${error.message}`)
		}
		}

		prompts.log.message("")
		prompts.log.success("Credential sync complete!")
		prompts.log.info("View your credentials at: " + enterpriseUrl + "/portal/credentials")

		// Update AGENTS.md and CLAUDE.md with enterprise workflow instructions
		prompts.log.message("")
		prompts.log.step("Updating project documentation with autonomous workflow...")

		const enabledServices = credentialsToSync.map((c) => c.service)
		await updateDocumentationWithEnterprise(enabledServices)

		prompts.log.message("")
		prompts.log.info("📚 AI agents now have full autonomy over:")
		if (enabledServices.includes("jira")) {
		prompts.log.info(" • Jira: Story selection, updates, completion, commenting")
		}
		if (enabledServices.includes("azdo")) {
		prompts.log.info(" • Azure DevOps: Work item management, status updates")
		}
		if (enabledServices.includes("confluence")) {
		prompts.log.info(" • Confluence: Create & maintain documentation")
		}
		prompts.log.message("")
		prompts.log.info("Agents will automatically:")
		prompts.log.info(" 1. Update stories in real-time during development")
		prompts.log.info(" 2. Link Update Sets to stories")
		prompts.log.info(" 3. Create comprehensive Confluence documentation")
		prompts.log.info(" 4. Move stories to Done with full traceability")

		prompts.outro("Done")
		} catch (error: any) {
		if (error.code === "ENOENT") {
		prompts.log.error("No .env file found in current directory")
		prompts.log.info("Run: snow-flow and use /auth first")
		} else {
		prompts.log.error("Sync failed: " + error.message)
		}
		prompts.outro("Sync failed")
		}
		})
		}

-304

src/servicenow/cli/deploy-artifact.ts

		#!/usr/bin/env node
		/**
		* Generic Artifact Deployer
		* Deploy any ServiceNow artifact type dynamically
		*/

		import { Command } from "commander"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { ServiceNowOAuth } from "../utils/snow-oauth.js"
		import { Logger } from "../utils/logger.js"
		import { promises as fs } from "fs"
		import chalk from "chalk"

		const logger = new Logger("DeployArtifact")

		interface ArtifactConfig {
		type: "widget" \| "flow" \| "script_include" \| "business_rule" \| "application" \| "table"
		name: string
		description?: string
		config: Record<string, any>
		template?: string
		}

		async function deployArtifact(type: string, configPath: string) {
		try {
		logger.info(`Deploying ${type} artifact from ${configPath}`)

		// Load configuration
		const configContent = await fs.readFile(configPath, "utf-8")
		const config: ArtifactConfig = JSON.parse(configContent)

		// Validate configuration
		if (!config.name) {
		throw new Error("Artifact name is required in configuration")
		}

		// Check authentication
		const oauth = new ServiceNowOAuth()
		const isAuth = await oauth.isAuthenticated()
		if (!isAuth) {
		throw new Error('Not authenticated. Run "snow-flow auth login" first.')
		}

		// Create client
		const client = new ServiceNowClient()

		// Deploy based on type
		let result
		switch (type) {
		case "widget":
		result = await deployWidget(client, config)
		break
		case "flow":
		result = await deployFlow(client, config)
		break
		case "script_include":
		result = await deployScriptInclude(client, config)
		break
		case "business_rule":
		result = await deployBusinessRule(client, config)
		break
		case "application":
		result = await deployApplication(client, config)
		break
		case "table":
		result = await deployTable(client, config)
		break
		default:
		throw new Error(`Unsupported artifact type: ${type}`)
		}

		// Display result
		if (result.success) {
		console.log(chalk.green("\n✅ Deployment successful!"))
		console.log(chalk.blue(`\n📋 Artifact Details:`))
		console.log(` Name: ${config.name}`)
		console.log(` Type: ${type}`)
		console.log(` Sys ID: ${result.data?.sys_id}`)

		const credentials = await oauth.loadCredentials()
		console.log(chalk.yellow(`\n🔗 View in ServiceNow:`))
		console.log(` ${getArtifactUrl(credentials?.instance \|\| "", type, result.data?.sys_id)}`)
		} else {
		throw new Error(result.error \|\| "Deployment failed")
		}
		} catch (error) {
		logger.error("Deployment failed", error)
		console.error(chalk.red(`\n❌ Error: ${error instanceof Error ? error.message : String(error)}`))
		process.exit(1)
		}
		}

		async function deployWidget(client: ServiceNowClient, config: ArtifactConfig) {
		return await client.createWidget({
		name: config.name,
		id: config.config.id \|\| config.name.toLowerCase().replace(/\s+/g, "_"),
		title: config.config.title \|\| config.name,
		description: config.description \|\| "",
		template: config.config.template \|\| "",
		css: config.config.css \|\| "",
		client_script: config.config.client_script \|\| "",
		script: config.config.script \|\| "", // ServiceNow uses 'script' field
		option_schema: config.config.option_schema \|\| "[]",
		demo_data: config.config.demo_data \|\| "{}",
		has_preview: config.config.has_preview \|\| false,
		category: config.config.category \|\| "custom",
		})
		}

		async function deployFlow(client: ServiceNowClient, config: ArtifactConfig) {
		return await client.createFlow({
		name: config.name,
		description: config.description \|\| "",
		active: config.config.active !== false,
		table: config.config.table \|\| "",
		trigger_type: config.config.trigger_type \|\| "manual",
		condition: config.config.condition \|\| "",
		flow_definition: JSON.stringify(config.config.flow_definition \|\| {}),
		category: config.config.category \|\| "automation",
		})
		}

		async function deployScriptInclude(client: ServiceNowClient, config: ArtifactConfig) {
		return await client.createScriptInclude({
		name: config.name,
		api_name: config.config.api_name \|\| config.name,
		description: config.description \|\| "",
		script: config.config.script \|\| "",
		active: config.config.active !== false,
		access: config.config.access \|\| "public",
		})
		}

		async function deployBusinessRule(client: ServiceNowClient, config: ArtifactConfig) {
		return await client.createBusinessRule({
		name: config.name,
		table: config.config.table \|\| "incident",
		when: config.config.when \|\| "after",
		condition: config.config.condition \|\| "",
		script: config.config.script \|\| "",
		description: config.description \|\| "",
		active: config.config.active !== false,
		order: config.config.order \|\| 100,
		})
		}

		async function deployApplication(client: ServiceNowClient, config: ArtifactConfig) {
		return await client.createApplication({
		name: config.name,
		scope: config.config.scope \|\| "x_" + config.name.toLowerCase().replace(/\s+/g, "_"),
		version: config.config.version \|\| "1.0.0",
		short_description: config.config.short_description \|\| config.description \|\| "",
		description: config.description \|\| "",
		vendor: config.config.vendor \|\| "Custom",
		vendor_prefix: config.config.vendor_prefix \|\| "x",
		active: config.config.active !== false,
		})
		}

		async function deployTable(client: ServiceNowClient, config: ArtifactConfig) {
		return await client.createTable({
		name: config.name,
		label: config.config.label \|\| config.name,
		extends_table: config.config.extends_table \|\| "sys_metadata",
		is_extendable: config.config.is_extendable !== false,
		access: config.config.access \|\| "public",
		create_access_controls: config.config.create_access_controls !== false,
		})
		}

		function getArtifactUrl(instance: string, type: string, sysId: string): string {
		const baseUrl = `https://${instance}`
		switch (type) {
		case "widget":
		return `${baseUrl}/sp_config?id=widget_editor&sys_id=${sysId}`
		case "flow":
		return `${baseUrl}/flow-designer/flow/${sysId}`
		case "script_include":
		return `${baseUrl}/sys_script_include.do?sys_id=${sysId}`
		case "business_rule":
		return `${baseUrl}/sys_script.do?sys_id=${sysId}`
		case "application":
		return `${baseUrl}/sys_app.do?sys_id=${sysId}`
		case "table":
		return `${baseUrl}/sys_db_object.do?sys_id=${sysId}`
		default:
		return baseUrl
		}
		}

		// CLI setup
		const program = new Command()

		program.name("deploy-artifact").description("Deploy any ServiceNow artifact type dynamically").version("1.0.0")

		program
		.command("deploy")
		.description("Deploy an artifact from configuration file")
		.requiredOption(
		"-t, --type <type>",
		"Artifact type (widget, flow, script_include, business_rule, application, table)",
		)
		.requiredOption("-c, --config <path>", "Path to artifact configuration file (JSON)")
		.action(async (options) => {
		await deployArtifact(options.type, options.config)
		})

		program
		.command("template")
		.description("Generate a template configuration file")
		.requiredOption("-t, --type <type>", "Artifact type")
		.requiredOption("-o, --output <path>", "Output file path")
		.action(async (options) => {
		const template = getTemplate(options.type)
		await fs.writeFile(options.output, JSON.stringify(template, null, 2))
		console.log(chalk.green(`✅ Template created: ${options.output}`))
		})

		function getTemplate(type: string): any {
		const templates: Record<string, any> = {
		widget: {
		type: "widget",
		name: "My Custom Widget",
		description: "A custom ServiceNow widget",
		config: {
		title: "My Widget",
		category: "custom",
		template: "<div>{{c.data.message}}</div>",
		css: ".my-widget { padding: 20px; }",
		client_script: 'function() { var c = this; c.data.message = "Hello World"; }',
		script: '(function() { data.message = "Server message"; })()', // ServiceNow uses 'script' field
		option_schema: "[]",
		demo_data: "{}",
		},
		},
		flow: {
		type: "flow",
		name: "My Custom Flow",
		description: "A custom ServiceNow flow",
		config: {
		table: "incident",
		trigger_type: "record_created",
		condition: "active=true",
		category: "automation",
		flow_definition: {
		activities: [],
		variables: [],
		},
		},
		},
		script_include: {
		type: "script_include",
		name: "MyUtilityClass",
		description: "Utility functions",
		config: {
		api_name: "MyUtilityClass",
		script:
		'var MyUtilityClass = Class.create();\nMyUtilityClass.prototype = {\n initialize: function() {},\n type: "MyUtilityClass"\n};',
		access: "public",
		},
		},
		business_rule: {
		type: "business_rule",
		name: "My Business Rule",
		description: "A custom business rule",
		config: {
		table: "incident",
		when: "before",
		condition: "",
		script: "(function executeRule(current, previous) {\n // Business rule logic here\n})(current, previous);",
		active: true,
		order: 100,
		},
		},
		application: {
		type: "application",
		name: "My Custom Application",
		description: "A custom ServiceNow application",
		config: {
		scope: "x_custom",
		version: "1.0.0",
		vendor: "Custom",
		vendor_prefix: "x",
		active: true,
		},
		},
		table: {
		type: "table",
		name: "u_custom_table",
		description: "A custom ServiceNow table",
		config: {
		label: "Custom Table",
		extends_table: "task",
		is_extendable: true,
		access: "public",
		create_access_controls: true,
		},
		},
		}

		return templates[type] \|\| { type, name: "New Artifact", config: {} }
		}

		program.parse(process.argv)

-93

src/servicenow/cli/enterprise-refresh.ts

		/**
		* Enterprise JWT Refresh Command
		* Automatically regenerates JWT token with latest server configuration
		*/

		import * as prompts from "@clack/prompts"
		import path from "path"
		import fs from "fs/promises"
		import { Logger } from "../utils/logger.js"
		import { addEnterpriseMcpServer } from "../config/snow-code-config.js"
		import os from "os"

		const logger = new Logger("enterprise-refresh")

		/**
		* Refresh enterprise JWT token
		* This regenerates the JWT with the latest server configuration (KMS secrets)
		*/
		export async function refreshEnterpriseJWT(): Promise<void> {
		prompts.intro("🔄 Refreshing Enterprise JWT Token")

		try {
		// Check if .mcp.json exists
		const mcpConfigPath = path.join(process.cwd(), ".mcp.json")
		try {
		await fs.access(mcpConfigPath)
		} catch {
		prompts.log.error("⚠️ No .mcp.json found in current directory")
		prompts.log.info("💡 Run: snow-flow (auto-initializes on first run)")
		prompts.outro("Failed to refresh JWT")
		return
		}

		// Read existing .mcp.json to get license key
		const mcpContent = await fs.readFile(mcpConfigPath, "utf-8")
		const mcpConfig = JSON.parse(mcpContent)

		// Check if enterprise server is configured (support both 'mcp' and 'mcpServers' keys)
		const enterpriseServer = mcpConfig.mcp?.["snow-flow-enterprise"] \|\| mcpConfig.mcpServers?.["snow-flow-enterprise"]
		if (!enterpriseServer) {
		prompts.log.error("⚠️ Enterprise MCP server not configured")
		prompts.log.info("💡 Run: snow-flow and use /auth in the TUI")
		prompts.outro("Failed to refresh JWT")
		return
		}

		// Check snow-code auth.json for license key and role
		const authPath = path.join(os.homedir(), ".local", "share", "snow-code", "auth.json")
		let licenseKey: string
		let role: "developer" \| "stakeholder" \| "admin"

		try {
		const authJson = JSON.parse(await fs.readFile(authPath, "utf-8"))
		const enterpriseCreds = authJson["enterprise"]

		if (!enterpriseCreds \|\| enterpriseCreds.type !== "enterprise") {
		throw new Error("Enterprise credentials not found in auth.json")
		}

		licenseKey = enterpriseCreds.licenseKey
		role = enterpriseCreds.role \|\| "developer"
		} catch (err: any) {
		prompts.log.error("⚠️ Enterprise credentials not found")
		prompts.log.info("💡 Run: snow-flow and use /auth in the TUI")
		prompts.outro("Failed to refresh JWT")
		return
		}

		prompts.log.step("Regenerating JWT token with latest server configuration...")

		// Regenerate JWT using addEnterpriseMcpServer
		await addEnterpriseMcpServer({
		licenseKey,
		role,
		serverUrl: "https://portal.snow-flow.dev",
		})

		prompts.log.success("✅ JWT token refreshed successfully!")
		prompts.log.message("")
		prompts.log.info("🎉 Enterprise tools are now ready with updated authentication")
		prompts.log.info(" The JWT has been regenerated with the latest server configuration")
		prompts.log.message("")
		prompts.log.info("💡 Next steps:")
		prompts.log.message(" • Restart any running Claude Code sessions")
		prompts.log.message(" • Try using enterprise tools (Jira, Azure DevOps, Confluence)")
		prompts.outro("JWT refresh complete!")
		} catch (error: any) {
		logger.error(`JWT refresh failed: ${error.message}`)
		prompts.log.error(`❌ Failed to refresh JWT: ${error.message}`)
		prompts.outro("JWT refresh failed")
		throw error
		}
		}

-446

src/servicenow/cli/enterprise.ts

		/**
		* Enterprise authentication commands for Snow-Flow
		* Handles license key authentication with portal.snow-flow.dev
		*/

		import { Command } from "commander"
		import { promises as fs } from "fs"
		import { join } from "path"
		import { homedir } from "os"
		import chalk from "chalk"

		const SNOW_FLOW_DIR = join(homedir(), ".snow-flow")
		const AUTH_FILE = join(SNOW_FLOW_DIR, "auth.json")
		const PORTAL_URL = "https://portal.snow-flow.dev"
		const MCP_SERVER_URL = "https://enterprise.snow-flow.dev"

		interface AuthData {
		jwt: string
		expiresAt: string
		customer: {
		id: string
		name: string
		tier: string
		features: string[]
		// Seat information (v8.5.0+)
		developerSeats?: number // Number of developer seats (undefined = unlimited/legacy)
		stakeholderSeats?: number // Number of stakeholder seats (undefined = unlimited/legacy)
		activeDeveloperSeats?: number // Current active developer connections
		activeStakeholderSeats?: number // Current active stakeholder sessions
		// User role (for multi-role accounts)
		role?: "developer" \| "stakeholder" \| "admin"
		theme?: string
		customTheme?: {
		themeName: string
		displayName: string
		themeConfig: any
		primaryColor: string
		secondaryColor?: string
		accentColor?: string
		}
		}
		}

		/**
		* Ensure .snow-flow directory exists
		*/
		async function ensureSnowFlowDir(): Promise<void> {
		try {
		await fs.mkdir(SNOW_FLOW_DIR, { recursive: true })
		} catch (err) {
		// Directory already exists, ignore
		}
		}

		/**
		* Load stored authentication data
		*/
		async function loadAuth(): Promise<AuthData \| null> {
		try {
		const data = await fs.readFile(AUTH_FILE, "utf-8")
		const auth: AuthData = JSON.parse(data)

		// Check if token is expired
		const expiresAt = new Date(auth.expiresAt)
		if (expiresAt < new Date()) {
		console.log(chalk.yellow("⚠️ Your authentication has expired. Please login again."))
		return null
		}

		return auth
		} catch (err) {
		return null
		}
		}

		/**
		* Save authentication data
		*/
		async function saveAuth(auth: AuthData): Promise<void> {
		await ensureSnowFlowDir()
		await fs.writeFile(AUTH_FILE, JSON.stringify(auth, null, 2), "utf-8")
		}

		/**
		* Delete authentication data
		*/
		async function deleteAuth(): Promise<void> {
		try {
		await fs.unlink(AUTH_FILE)
		} catch (err) {
		// File doesn't exist, ignore
		}
		}

		/**
		* Login with license key
		*/
		async function loginCommand(licenseKey: string): Promise<void> {
		console.log(chalk.blue("🔑 Authenticating with Snow-Flow Enterprise..."))

		try {
		const response = await fetch(`${PORTAL_URL}/api/auth/login`, {
		method: "POST",
		headers: {
		"Content-Type": "application/json",
		},
		body: JSON.stringify({ licenseKey }),
		})

		if (!response.ok) {
		const error = (await response.json()) as { message?: string }
		console.error(chalk.red(`❌ Authentication failed: ${error.message \|\| "Invalid license key"}`))
		process.exit(1)
		}

		const data = (await response.json()) as { token: string; expiresAt?: string; customer: AuthData["customer"] }

		const authData: AuthData = {
		jwt: data.token,
		expiresAt: data.expiresAt \|\| new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(), // 30 days
		customer: data.customer,
		}

		await saveAuth(authData)

		console.log(chalk.green("✅ Successfully authenticated!"))
		console.log("")
		console.log(chalk.bold("Customer:"), authData.customer.name)
		console.log(chalk.bold("License Tier:"), chalk.cyan(authData.customer.tier.toUpperCase()))
		console.log(chalk.bold("Features:"), authData.customer.features.join(", "))

		// Show seat information if available (v8.5.0+)
		if (authData.customer.developerSeats !== undefined \|\| authData.customer.stakeholderSeats !== undefined) {
		console.log("")
		console.log(chalk.bold("License Seats:"))

		if (authData.customer.developerSeats !== undefined) {
		const devSeats = authData.customer.developerSeats === -1 ? "Unlimited" : authData.customer.developerSeats
		const activeDevSeats = authData.customer.activeDeveloperSeats \|\| 0
		console.log(
		chalk.gray(" Developer Seats:"),
		chalk.cyan(`${activeDevSeats}/${devSeats}`),
		chalk.gray("(active/total)"),
		)
		}

		if (authData.customer.stakeholderSeats !== undefined) {
		const stakeholderSeats =
		authData.customer.stakeholderSeats === -1 ? "Unlimited" : authData.customer.stakeholderSeats
		const activeStakeholderSeats = authData.customer.activeStakeholderSeats \|\| 0
		console.log(
		chalk.gray(" Stakeholder Seats:"),
		chalk.cyan(`${activeStakeholderSeats}/${stakeholderSeats}`),
		chalk.gray("(active/total)"),
		)
		}
		}

		// Show theme information if available
		if (authData.customer.customTheme) {
		console.log(chalk.bold("Custom Theme:"), chalk.magenta(authData.customer.customTheme.displayName))
		console.log(chalk.gray(" Theme has been synced for your SnowCode CLI"))
		} else if (authData.customer.theme) {
		console.log(chalk.bold("Theme:"), chalk.magenta(authData.customer.theme))
		}

		console.log("")
		console.log(chalk.gray("Your credentials have been saved to:"), chalk.gray(AUTH_FILE))
		console.log("")
		console.log(chalk.blue("💡 Enterprise tools are now available!"))
		console.log(chalk.gray(" Run"), chalk.cyan('snow-flow agent "<task>"'), chalk.gray("to use them."))
		console.log(chalk.gray(" Run"), chalk.cyan("snow-flow portal"), chalk.gray("to configure integrations."))
		console.log(chalk.gray(" Run"), chalk.cyan("snow-flow status"), chalk.gray("to view your account details."))
		} catch (err: any) {
		console.error(chalk.red("❌ Network error:"), err.message)
		console.error(chalk.gray("Please check your internet connection and try again."))
		process.exit(1)
		}
		}

		/**
		* Show authentication status
		* Exported for use in main status command
		*/
		export async function showEnterpriseStatus(): Promise<void> {
		// Check for enterprise MCP configuration (new flow)
		const { isEnterpriseMcpConfigured } = await import("../config/snow-code-config.js")
		const mcpConfigured = await isEnterpriseMcpConfigured()

		// Check for portal auth (legacy flow)
		const auth = await loadAuth()

		if (!mcpConfigured && !auth) {
		console.log(chalk.blue("🔐 Snow-Flow Enterprise"))
		console.log(chalk.yellow(" Status: Not configured"))
		console.log("")
		console.log(chalk.gray(" Setup: snow-flow auth login (or) snow-flow enterprise setup"))
		console.log(chalk.gray(" Get license key from:"), chalk.blue(PORTAL_URL))
		return
		}

		console.log(chalk.blue("🔐 Snow-Flow Enterprise"))
		console.log(chalk.green(" Status: ✅ Configured"))
		console.log("")

		// Show MCP server info if configured
		if (mcpConfigured) {
		console.log(chalk.bold(" Type:"), "Enterprise MCP Server (Jira, Azure DevOps, Confluence)")
		console.log(chalk.gray(" Config:"), "~/.config/snow-code/snow-code.json")
		console.log(chalk.gray(" Reconfigure:"), "snow-flow enterprise setup")
		}

		// Show portal auth info if available
		if (auth && auth.customer) {
		console.log("")
		console.log(chalk.bold(" Customer:"), auth.customer.name)
		console.log(chalk.bold(" Customer ID:"), auth.customer.id)
		console.log(chalk.bold(" License Tier:"), chalk.cyan(auth.customer.tier.toUpperCase()))
		console.log("")
		console.log(chalk.bold(" Features:"))
		auth.customer.features.forEach((feature) => {
		console.log(chalk.gray(" •"), feature)
		})

		// Show seat information if available (v8.5.0+)
		if (auth.customer.developerSeats !== undefined \|\| auth.customer.stakeholderSeats !== undefined) {
		console.log("")
		console.log(chalk.bold(" License Seats:"))

		if (auth.customer.developerSeats !== undefined) {
		const devSeats = auth.customer.developerSeats === -1 ? "Unlimited" : auth.customer.developerSeats
		const activeDevSeats = auth.customer.activeDeveloperSeats \|\| 0
		const devUsagePercent =
		auth.customer.developerSeats > 0 ? Math.round((activeDevSeats / auth.customer.developerSeats) * 100) : 0

		let devColor = chalk.green
		if (devUsagePercent >= 90) devColor = chalk.red
		else if (devUsagePercent >= 75) devColor = chalk.yellow

		console.log(
		chalk.gray(" Developer:"),
		devColor(`${activeDevSeats}/${devSeats}`),
		chalk.gray("(active/total)"),
		)
		}

		if (auth.customer.stakeholderSeats !== undefined) {
		const stakeholderSeats = auth.customer.stakeholderSeats === -1 ? "Unlimited" : auth.customer.stakeholderSeats
		const activeStakeholderSeats = auth.customer.activeStakeholderSeats \|\| 0
		const stakeholderUsagePercent =
		auth.customer.stakeholderSeats > 0
		? Math.round((activeStakeholderSeats / auth.customer.stakeholderSeats) * 100)
		: 0

		let stakeholderColor = chalk.green
		if (stakeholderUsagePercent >= 90) stakeholderColor = chalk.red
		else if (stakeholderUsagePercent >= 75) stakeholderColor = chalk.yellow

		console.log(
		chalk.gray(" Stakeholder:"),
		stakeholderColor(`${activeStakeholderSeats}/${stakeholderSeats}`),
		chalk.gray("(active/total)"),
		)
		}
		}

		// Show theme information if available
		if (auth.customer.customTheme) {
		console.log("")
		console.log(chalk.bold(" Custom Theme:"), chalk.magenta(auth.customer.customTheme.displayName))
		console.log(chalk.gray(" Theme ID:"), auth.customer.customTheme.themeName)
		console.log(chalk.gray(" Primary:"), auth.customer.customTheme.primaryColor)
		if (auth.customer.customTheme.secondaryColor) {
		console.log(chalk.gray(" Secondary:"), auth.customer.customTheme.secondaryColor)
		}
		if (auth.customer.customTheme.accentColor) {
		console.log(chalk.gray(" Accent:"), auth.customer.customTheme.accentColor)
		}
		} else if (auth.customer.theme) {
		console.log("")
		console.log(chalk.bold(" Theme:"), chalk.magenta(auth.customer.theme))
		}

		console.log("")
		console.log(chalk.bold(" Token Expires:"), new Date(auth.expiresAt).toLocaleString())
		}
		}

		/**
		* Open portal in browser
		*/
		async function portalCommand(): Promise<void> {
		console.log(chalk.blue("🌐 Opening Snow-Flow Enterprise Portal..."))

		try {
		// Dynamic import for ESM compatibility
		const { default: open } = await import("open")
		await open(PORTAL_URL)
		console.log(chalk.green("✅ Portal opened in your default browser"))
		console.log("")
		console.log(chalk.gray("Portal URL:"), chalk.blue(PORTAL_URL))
		} catch (err: any) {
		console.error(chalk.red("❌ Failed to open browser:"), err.message)
		console.log("")
		console.log(chalk.gray("Please open this URL manually:"), chalk.blue(PORTAL_URL))
		}
		}

		/**
		* Logout and remove credentials
		*/
		async function logoutCommand(): Promise<void> {
		const auth = await loadAuth()

		if (!auth) {
		console.log(chalk.yellow("⚠️ You are not logged in."))
		return
		}

		await deleteAuth()

		console.log(chalk.green("✅ Successfully logged out"))
		console.log("")
		console.log(chalk.gray("Your authentication credentials have been removed."))
		console.log(chalk.gray("Enterprise tools will no longer be available until you login again."))
		}

		/**
		* Get JWT token for MCP server authentication
		* Called internally by MCP client
		*/
		export async function getEnterpriseToken(): Promise<string \| null> {
		const auth = await loadAuth()
		return auth ? auth.jwt : null
		}

		/**
		* Check if user has enterprise features enabled
		* Called internally by swarm command
		*/
		export async function hasEnterpriseFeatures(): Promise<boolean> {
		const auth = await loadAuth()
		return auth !== null && auth.customer !== undefined && auth.customer.features.length > 0
		}

		/**
		* Get enterprise customer info
		*/
		export async function getEnterpriseInfo(): Promise<AuthData["customer"] \| null> {
		const auth = await loadAuth()
		return auth && auth.customer ? auth.customer : null
		}

		/**
		* Register enterprise commands with Commander
		*/
		export function registerEnterpriseCommands(program: Command): void {
		// Login command
		program
		.command("login <license-key>")
		.description("Authenticate with Snow-Flow Enterprise using your license key")
		.action(async (licenseKey: string) => {
		await loginCommand(licenseKey)
		})

		// Setup command - Redirect to snow-code auth
		program
		.command("setup")
		.description("[DEPRECATED] Enterprise setup has moved to snow-code auth login")
		.action(async () => {
		// Dynamic import to avoid circular dependencies
		const { setupEnterpriseFlow } = await import("./auth.js")
		await setupEnterpriseFlow()
		})

		// JWT Refresh command - Regenerate JWT with latest server configuration
		program
		.command("refresh-jwt")
		.description("Refresh enterprise JWT token with latest server configuration (e.g., after updating KMS secrets)")
		.action(async () => {
		// Dynamic import to avoid circular dependencies
		const { refreshEnterpriseJWT } = await import("./enterprise-refresh.js")
		await refreshEnterpriseJWT()
		})

		// Status command removed - enterprise status is now shown via getEnterpriseInfo() in main status command

		// Portal command
		program
		.command("portal")
		.description("Open Snow-Flow Enterprise Portal in browser")
		.action(async () => {
		await portalCommand()
		})

		// Logout command
		program
		.command("logout")
		.description("Logout from Snow-Flow Enterprise and remove credentials")
		.action(async () => {
		await logoutCommand()
		})
		}

		/**
		* Get subscription status and features from the portal auth store.
		* Falls back to the legacy ~/.snow-flow/auth.json if portal auth is not available.
		*/
		export async function getSubscriptionStatus(): Promise<{
		status?: string
		trialEndsAt?: number
		features: string[]
		} \| null> {
		// Try portal auth store first (new device auth flow)
		try {
		const { Auth } = await import("../../auth/index.js")
		const enterprise = await Auth.get("enterprise")
		if (enterprise?.type === "enterprise") {
		return {
		status: enterprise.subscriptionStatus,
		trialEndsAt: enterprise.trialEndsAt,
		features: enterprise.features \|\| [],
		}
		}
		} catch {
		// Fall through to legacy auth
		}

		// Fallback: legacy auth.json
		const auth = await loadAuth()
		if (auth?.customer) {
		return {
		features: auth.customer.features \|\| [],
		}
		}
		return null
		}

		/**
		* Check if a specific feature is enabled in the user's subscription.
		*/
		export function isFeatureEnabled(features: string[], feature: string): boolean {
		return features.includes(feature)
		}

		export const ENTERPRISE_MCP_SERVER_URL = MCP_SERVER_URL

-45

src/servicenow/cli/session.ts

		import { Command } from "commander"
		import chalk from "chalk"
		import { listSessions, readSession } from "../session/store.js"

		export function registerSessionCommands(program: Command) {
		const sess = program.command("session").description("Manage and inspect Snow-Flow sessions")

		sess
		.command("list")
		.description("List recent sessions")
		.action(() => {
		const rows = listSessions().slice(0, 30)
		if (!rows.length) return console.log("No sessions yet.")
		for (const r of rows) {
		console.log(`${chalk.gray(r.startedAt)} ${chalk.cyan(r.id)} ${r.objective}`)
		}
		})

		sess
		.command("show <id>")
		.description("Show session details")
		.action((id) => {
		const rec = readSession(id)
		if (!rec) return console.error(chalk.red("Session not found."))
		console.log(chalk.cyan(`Session ${rec.id}`))
		console.log(`${chalk.gray(rec.startedAt)} → ${chalk.gray(rec.endedAt ?? "…")}`)
		console.log("Objective:", rec.objective)
		console.log("Provider:", `${rec.provider.id} ${rec.provider.model}`)
		console.log("MCP:", `${rec.mcp.cmd} ${(rec.mcp.args \|\| []).join(" ")}`)
		console.log("\nMessages:")
		for (const m of rec.messages) {
		console.log(
		`- ${chalk.yellow(m.role)} ${chalk.gray(m.timestamp)}\n ${m.content.slice(0, 400)}${m.content.length > 400 ? "…" : ""}`,
		)
		}
		if (rec.toolEvents?.length) {
		console.log("\nTool events:")
		for (const ev of rec.toolEvents) {
		console.log(
		` 🔧 ${ev.name} ${chalk.gray(ev.when)} ${ev.argsPreview ? "args:" + ev.argsPreview : ""} ${ev.resultPreview ? "res:" + ev.resultPreview : ""}`,
		)
		}
		}
		})
		}

-154

src/servicenow/config/snow-code-config.ts

		/**
		* Snow-Code MCP Configuration Management
		*
		* Handles configuration for enterprise MCP server including:
		* - Adding enterprise MCP server to .mcp.json
		* - Checking if enterprise MCP is already configured
		* - Managing license keys and JWT tokens
		*/

		import fs from "fs/promises"
		import path from "path"
		import os from "os"

		export interface EnterpriseMcpConfig {
		licenseKey: string
		role: "developer" \| "stakeholder" \| "admin"
		serverUrl?: string
		}

		export interface EnterpriseMcpConfigWithToken {
		token: string
		serverUrl: string
		}

		interface McpServerConfig {
		type?: string
		command?: string \| string[]
		args?: string[]
		env?: Record<string, string>
		environment?: Record<string, string>
		enabled?: boolean
		}

		interface McpConfig {
		mcp?: Record<string, McpServerConfig>
		mcpServers?: Record<string, McpServerConfig>
		servers?: Record<string, McpServerConfig>
		}

		/**
		* Get the path to the project .mcp.json file
		*/
		function getProjectMcpPath(): string {
		return path.join(process.cwd(), ".mcp.json")
		}

		/**
		* Get the path to the global .mcp.json file
		*/
		function getGlobalMcpPath(): string {
		return path.join(os.homedir(), ".snow-code", ".mcp.json")
		}

		/**
		* Read MCP config from a path
		*/
		async function readMcpConfig(configPath: string): Promise<McpConfig \| null> {
		try {
		const content = await fs.readFile(configPath, "utf-8")
		return JSON.parse(content) as McpConfig
		} catch {
		return null
		}
		}

		/**
		* Write MCP config to a path
		*/
		async function writeMcpConfig(configPath: string, config: McpConfig): Promise<void> {
		const dir = path.dirname(configPath)
		await fs.mkdir(dir, { recursive: true })
		await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8")
		}

		/**
		* Check if enterprise MCP server is already configured
		*/
		export async function isEnterpriseMcpConfigured(): Promise<boolean> {
		const projectConfig = await readMcpConfig(getProjectMcpPath())
		if (!projectConfig) return false

		const servers = projectConfig.mcp \|\| projectConfig.mcpServers \|\| projectConfig.servers \|\| {}
		return "snow-flow-enterprise" in servers \|\| "snow-flow-enterprise-proxy" in servers
		}

		/**
		* Add enterprise MCP server configuration
		*/
		export async function addEnterpriseMcpServer(config: EnterpriseMcpConfig): Promise<void> {
		const projectMcpPath = getProjectMcpPath()
		let mcpConfig = await readMcpConfig(projectMcpPath)

		if (!mcpConfig) {
		throw new Error(".mcp.json not found. Please run snow-flow to initialize the project first.")
		}

		// Determine which key format is used
		const serversKey = mcpConfig.mcp ? "mcp" : mcpConfig.mcpServers ? "mcpServers" : "servers"

		if (!mcpConfig[serversKey]) {
		mcpConfig[serversKey] = {}
		}

		// Get path to the enterprise proxy server
		const proxyServerPath = path.join(__dirname, "..", "enterprise-proxy", "server.ts")

		// Add enterprise MCP server
		mcpConfig[serversKey]!["snow-flow-enterprise"] = {
		type: "local",
		command: ["bun", "run", proxyServerPath],
		environment: {
		SNOW_PORTAL_URL: config.serverUrl \|\| "https://portal.snow-flow.dev",
		SNOW_LICENSE_KEY: config.licenseKey,
		},
		enabled: true,
		}

		await writeMcpConfig(projectMcpPath, mcpConfig)
		}

		/**
		* Add enterprise MCP server configuration with existing JWT token
		*/
		export async function addEnterpriseMcpServerWithToken(config: EnterpriseMcpConfigWithToken): Promise<void> {
		const projectMcpPath = getProjectMcpPath()
		let mcpConfig = await readMcpConfig(projectMcpPath)

		if (!mcpConfig) {
		throw new Error(".mcp.json not found. Please run snow-flow to initialize the project first.")
		}

		// Determine which key format is used
		const serversKey = mcpConfig.mcp ? "mcp" : mcpConfig.mcpServers ? "mcpServers" : "servers"

		if (!mcpConfig[serversKey]) {
		mcpConfig[serversKey] = {}
		}

		// Get path to the enterprise proxy server
		const proxyServerPath = path.join(__dirname, "..", "enterprise-proxy", "server.ts")

		// Add enterprise MCP server with JWT token
		mcpConfig[serversKey]!["snow-flow-enterprise"] = {
		type: "local",
		command: ["bun", "run", proxyServerPath],
		environment: {
		SNOW_PORTAL_URL: config.serverUrl,
		SNOW_LICENSE_KEY: config.token, // JWT token stored as license key
		},
		enabled: true,
		}

		await writeMcpConfig(projectMcpPath, mcpConfig)
		}

-126

src/servicenow/index.ts

		/**
		* ServiceNow Integration for Snow-Flow
		*
		* This module provides the entry point for ServiceNow integration including:
		* - OAuth authentication
		* - MCP server configuration helpers
		*
		* Note: The ServiceNow MCP servers (servicenow-unified, enterprise-proxy) are
		* standalone processes that are configured via the mcp config in snow-code.json.
		* They are automatically injected when credentials are present in the auth store.
		*/

		import { Config } from "../config/config"

		// Auth - these are in the main auth module
		export { ServiceNowOAuth } from "../auth/servicenow-oauth"
		export type { ServiceNowAuthResult, ServiceNowOAuthOptions } from "../auth/servicenow-oauth"

		// MCP Configuration helpers
		export {
		getServiceNowMcpConfig,
		getServiceNowMcpConfigFromAuth,
		canConfigureServiceNowMcp,
		SERVICENOW_MCP_SERVER_NAME,
		SERVICENOW_MCP_CONFIG_EXAMPLE,
		} from "./mcp-config"

		/**
		* Default ServiceNow MCP configuration for use in snow-code.json
		*
		* Tools use deferred loading by default - they must be enabled via tool_search first.
		*
		* Example usage in snow-code.json:
		* {
		* "mcp": {
		* "servicenow-unified": {
		* "type": "local",
		* "command": ["bun", "run", "node_modules/snow-flow/mcp/servicenow-unified.js"],
		* "environment": {
		* "SERVICENOW_INSTANCE_URL": "https://your-instance.service-now.com",
		* "SERVICENOW_CLIENT_ID": "your-client-id",
		* "SERVICENOW_CLIENT_SECRET": "your-client-secret"
		* }
		* }
		* }
		* }
		*/
		export function getDefaultServiceNowMcpConfig() {
		return {
		type: "local" as const,
		command: Config.getMcpServerCommand("servicenow-unified"),
		environment: {
		SERVICENOW_INSTANCE_URL: process.env.SERVICENOW_INSTANCE_URL ?? "",
		SERVICENOW_CLIENT_ID: process.env.SERVICENOW_CLIENT_ID ?? "",
		SERVICENOW_CLIENT_SECRET: process.env.SERVICENOW_CLIENT_SECRET ?? "",
		},
		enabled: true,
		}
		}

		/**
		* Check if ServiceNow is configured
		* Returns true if all required environment variables or auth are present
		*/
		export async function isServiceNowConfigured(): Promise<boolean> {
		// Check environment variables
		const hasEnvConfig =
		process.env.SERVICENOW_INSTANCE_URL && process.env.SERVICENOW_CLIENT_ID && process.env.SERVICENOW_CLIENT_SECRET

		if (hasEnvConfig) return true

		// Check auth store (lazy import to avoid circular dependency)
		try {
		const { Auth } = await import("../auth")
		const auth = await Auth.get("servicenow")
		if (auth?.type === "servicenow-oauth" && auth.accessToken) {
		return true
		}
		if (auth?.type === "servicenow-basic" && auth.username && auth.password) {
		return true
		}
		} catch {
		// Auth module not available
		}

		return false
		}

		/**
		* Get ServiceNow credentials from auth store or environment
		*/
		export async function getServiceNowCredentials(): Promise<{
		instance: string
		clientId: string
		clientSecret: string
		accessToken?: string
		refreshToken?: string
		} \| null> {
		// First check auth store
		try {
		const { Auth } = await import("../auth")
		const auth = await Auth.get("servicenow")
		if (auth?.type === "servicenow-oauth") {
		return {
		instance: auth.instance,
		clientId: auth.clientId,
		clientSecret: auth.clientSecret,
		accessToken: auth.accessToken,
		refreshToken: auth.refreshToken,
		}
		}
		} catch {
		// Auth module not available
		}

		// Fall back to environment variables
		const instance = process.env.SERVICENOW_INSTANCE_URL
		const clientId = process.env.SERVICENOW_CLIENT_ID
		const clientSecret = process.env.SERVICENOW_CLIENT_SECRET

		if (instance && clientId && clientSecret) {
		return { instance, clientId, clientSecret }
		}

		return null
		}

-157

src/servicenow/mcp-config.ts

		/**
		* ServiceNow MCP Configuration Helper
		*
		* Provides utilities to automatically configure the ServiceNow MCP server
		* when ServiceNow credentials are available in the auth store.
		*/

		import { Config } from "../config/config"

		/**
		* Get the default ServiceNow MCP server configuration
		*
		* This returns a local MCP server config that can be merged into the
		* snow-code.json mcp configuration.
		*/
		export function getServiceNowMcpConfig(options?: {
		instance?: string
		clientId?: string
		clientSecret?: string
		accessToken?: string
		refreshToken?: string
		}): Config.Mcp {
		const environment: Record<string, string> = {}

		if (options?.instance) {
		environment.SERVICENOW_INSTANCE_URL = options.instance
		}
		if (options?.clientId) {
		environment.SERVICENOW_CLIENT_ID = options.clientId
		}
		if (options?.clientSecret) {
		environment.SERVICENOW_CLIENT_SECRET = options.clientSecret
		}
		if (options?.accessToken) {
		environment.SERVICENOW_ACCESS_TOKEN = options.accessToken
		}
		if (options?.refreshToken) {
		environment.SERVICENOW_REFRESH_TOKEN = options.refreshToken
		}

		return {
		type: "local",
		command: Config.getMcpServerCommand("servicenow-unified"),
		environment,
		enabled: true,
		}
		}

		/**
		* Check if ServiceNow MCP can be configured
		*
		* Returns true if we have the necessary credentials to configure the MCP server.
		*/
		export async function canConfigureServiceNowMcp(): Promise<boolean> {
		// Check environment variables first
		if (process.env.SERVICENOW_INSTANCE_URL && process.env.SERVICENOW_CLIENT_ID && process.env.SERVICENOW_CLIENT_SECRET) {
		return true
		}

		// Check auth store
		try {
		const { Auth } = await import("../auth")
		const snAuth = await Auth.get("servicenow")
		if (snAuth?.type === "servicenow-oauth" \|\| snAuth?.type === "servicenow-basic") {
		return true
		}
		} catch {
		// Auth module not available
		}

		return false
		}

		/**
		* Get ServiceNow MCP config from auth store
		*
		* If ServiceNow credentials are available in the auth store, returns
		* the MCP config to load the servicenow-unified server.
		*/
		export async function getServiceNowMcpConfigFromAuth(): Promise<Config.Mcp \| null> {
		// First check environment variables
		const envInstance = process.env.SERVICENOW_INSTANCE_URL
		const envClientId = process.env.SERVICENOW_CLIENT_ID
		const envClientSecret = process.env.SERVICENOW_CLIENT_SECRET

		if (envInstance && envClientId && envClientSecret) {
		return getServiceNowMcpConfig({
		instance: envInstance,
		clientId: envClientId,
		clientSecret: envClientSecret,
		accessToken: process.env.SERVICENOW_ACCESS_TOKEN,
		refreshToken: process.env.SERVICENOW_REFRESH_TOKEN,
		})
		}

		// Check auth store
		try {
		const { Auth } = await import("../auth")
		const snAuth = await Auth.get("servicenow")

		if (snAuth?.type === "servicenow-oauth") {
		return getServiceNowMcpConfig({
		instance: snAuth.instance,
		clientId: snAuth.clientId,
		clientSecret: snAuth.clientSecret,
		accessToken: snAuth.accessToken,
		refreshToken: snAuth.refreshToken,
		})
		}

		if (snAuth?.type === "servicenow-basic") {
		// For basic auth, we use different env vars
		return {
		type: "local",
		command: Config.getMcpServerCommand("servicenow-unified"),
		environment: {
		SERVICENOW_INSTANCE_URL: snAuth.instance,
		SERVICENOW_USERNAME: snAuth.username,
		SERVICENOW_PASSWORD: snAuth.password,
		},
		enabled: true,
		}
		}
		} catch {
		// Auth module not available
		}

		return null
		}

		/**
		* ServiceNow MCP server name constant
		*/
		export const SERVICENOW_MCP_SERVER_NAME = "servicenow-unified"

		/**
		* Instructions for configuring ServiceNow MCP in snow-code.json
		*/
		export const SERVICENOW_MCP_CONFIG_EXAMPLE = `
		// Add to your snow-code.json or snow-code.jsonc:
		{
		"mcp": {
		"servicenow-unified": {
		"type": "local",
		"command": ["bun", "run", "node_modules/snow-flow/mcp/servicenow-unified.js"],
		"environment": {
		"SERVICENOW_INSTANCE_URL": "https://your-instance.service-now.com",
		"SERVICENOW_CLIENT_ID": "your-oauth-client-id",
		"SERVICENOW_CLIENT_SECRET": "your-oauth-client-secret"
		}
		}
		}
		}

		// Tools use deferred loading by default - they must be enabled via tool_search first.
		// Or use /auth to configure credentials interactively
		`.trim()

src/servicenow/servicenow-automation-mcp.ts

Sorry, the diff of this file is too big to display

-974

src/servicenow/ser...-change-virtualagent-pa-mcp-enhanced.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Change Management, Virtual Agent & Performance Analytics MCP Server - ENHANCED VERSION
		* With logging, token tracking, and progress indicators
		*/

		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { EnhancedBaseMCPServer, MCPToolResult } from "./shared/enhanced-base-mcp-server.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"

		class ServiceNowChangeVirtualAgentPAMCPEnhanced extends EnhancedBaseMCPServer {
		private config: ReturnType<typeof mcpConfig.getConfig>

		constructor() {
		super("servicenow-change-virtualagent-pa-enhanced", "2.0.0")
		this.config = mcpConfig.getConfig()
		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		// Change Management Tools
		{
		name: "snow_create_change_request",
		description: "Creates change request in ServiceNow using change_request table.",
		inputSchema: {
		type: "object",
		properties: {
		short_description: { type: "string", description: "Change summary" },
		description: { type: "string", description: "Detailed description" },
		type: { type: "string", description: "normal, standard, emergency" },
		risk: { type: "string", description: "high, moderate, low" },
		impact: { type: "string", description: "1-critical, 2-high, 3-moderate, 4-low" },
		implementation_plan: { type: "string", description: "Implementation steps" },
		backout_plan: { type: "string", description: "Rollback steps" },
		test_plan: { type: "string", description: "Testing steps" },
		justification: { type: "string", description: "Business justification" },
		start_date: { type: "string", description: "Planned start (YYYY-MM-DD HH:MM:SS)" },
		end_date: { type: "string", description: "Planned end (YYYY-MM-DD HH:MM:SS)" },
		},
		required: ["short_description", "type"],
		},
		},
		{
		name: "snow_create_change_task",
		description: "Creates change task using change_task table.",
		inputSchema: {
		type: "object",
		properties: {
		change_request: { type: "string", description: "Parent change sys_id" },
		short_description: { type: "string", description: "Task description" },
		assignment_group: { type: "string", description: "Group sys_id" },
		assigned_to: { type: "string", description: "User sys_id" },
		order: { type: "number", description: "Task order" },
		},
		required: ["change_request", "short_description"],
		},
		},
		{
		name: "snow_get_change_request",
		description: "Gets change request details from change_request table.",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: { type: "string", description: "Change request sys_id" },
		include_tasks: { type: "boolean", default: false },
		},
		required: ["sys_id"],
		},
		},
		{
		name: "snow_update_change_state",
		description: "Updates change request state in change_request table.",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: { type: "string", description: "Change request sys_id" },
		state: { type: "string", description: "new, assess, authorize, scheduled, implement, review, closed" },
		close_notes: { type: "string", description: "Closure notes" },
		},
		required: ["sys_id", "state"],
		},
		},
		{
		name: "snow_schedule_cab_meeting",
		description: "Schedules CAB meeting using cab_meeting and cab_agenda_item tables.",
		inputSchema: {
		type: "object",
		properties: {
		meeting_date: { type: "string", description: "Meeting date/time" },
		location: { type: "string", description: "Meeting location" },
		change_requests: { type: "array", items: { type: "string" }, description: "Change sys_ids" },
		},
		required: ["meeting_date"],
		},
		},
		{
		name: "snow_search_change_requests",
		description: "Searches change requests in change_request table.",
		inputSchema: {
		type: "object",
		properties: {
		query: { type: "string", description: "Search query" },
		state: { type: "string", description: "Filter by state" },
		type: { type: "string", description: "Filter by type" },
		risk: { type: "string", description: "Filter by risk" },
		limit: { type: "number", default: 10 },
		},
		},
		},
		// Virtual Agent Tools
		{
		name: "snow_create_va_topic",
		description: "Creates virtual agent topic using sys_cs_topic table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Topic name" },
		description: { type: "string", description: "Topic description" },
		trigger_phrases: { type: "array", items: { type: "string" } },
		category: { type: "string", description: "Topic category" },
		active: { type: "boolean", default: true },
		},
		required: ["name", "trigger_phrases"],
		},
		},
		{
		name: "snow_create_va_topic_block",
		description: "Creates conversation blocks using sys_cs_topic_block table.",
		inputSchema: {
		type: "object",
		properties: {
		topic: { type: "string", description: "Topic sys_id" },
		type: { type: "string", description: "Block type: text, question, action" },
		message: { type: "string", description: "Block message" },
		order: { type: "number", description: "Block order" },
		options: { type: "array", items: { type: "object" } },
		},
		required: ["topic", "type", "message"],
		},
		},
		{
		name: "snow_get_va_conversation",
		description: "Gets conversation history from sys_cs_conversation table.",
		inputSchema: {
		type: "object",
		properties: {
		conversation_id: { type: "string", description: "Conversation sys_id" },
		user: { type: "string", description: "Filter by user" },
		limit: { type: "number", default: 50 },
		},
		},
		},
		{
		name: "snow_send_va_message",
		description: "Sends message to virtual agent using sys_cs_conversation table.",
		inputSchema: {
		type: "object",
		properties: {
		conversation_id: { type: "string", description: "Conversation ID" },
		message: { type: "string", description: "User message" },
		user: { type: "string", description: "User sys_id" },
		},
		required: ["message"],
		},
		},
		{
		name: "snow_handoff_to_agent",
		description: "Escalates conversation to live agent using sys_cs_conversation table.",
		inputSchema: {
		type: "object",
		properties: {
		conversation_id: { type: "string", description: "Conversation to escalate" },
		reason: { type: "string", description: "Escalation reason" },
		priority: { type: "string", description: "Priority level" },
		},
		required: ["conversation_id"],
		},
		},
		{
		name: "snow_discover_va_topics",
		description: "Lists all virtual agent topics from sys_cs_topic table.",
		inputSchema: {
		type: "object",
		properties: {
		active_only: { type: "boolean", default: true },
		category: { type: "string", description: "Filter by category" },
		},
		},
		},
		// Performance Analytics Tools
		{
		name: "snow_create_pa_indicator",
		description: "Creates PA indicator using pa_indicators table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Indicator name" },
		table: { type: "string", description: "Source table" },
		aggregate: { type: "string", description: "Aggregation: COUNT, SUM, AVG" },
		field: { type: "string", description: "Field to aggregate" },
		conditions: { type: "string", description: "Filter conditions" },
		frequency: { type: "string", description: "daily, weekly, monthly" },
		},
		required: ["name", "table", "aggregate"],
		},
		},
		{
		name: "snow_create_pa_widget",
		description: "Creates PA dashboard widget using pa_widgets table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Widget name" },
		indicator: { type: "string", description: "Indicator sys_id" },
		type: { type: "string", description: "line, bar, pie, single_score" },
		size: { type: "string", description: "small, medium, large" },
		time_range: { type: "string", description: "Time range" },
		},
		required: ["name", "indicator", "type"],
		},
		},
		{
		name: "snow_create_pa_breakdown",
		description: "Creates PA breakdown using pa_breakdowns table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Breakdown name" },
		source_table: { type: "string", description: "Source table" },
		field: { type: "string", description: "Field to break down by" },
		related_indicator: { type: "string", description: "Related indicator sys_id" },
		},
		required: ["name", "source_table", "field"],
		},
		},
		{
		name: "snow_create_pa_threshold",
		description: "Creates PA threshold using pa_thresholds table.",
		inputSchema: {
		type: "object",
		properties: {
		indicator: { type: "string", description: "Indicator sys_id" },
		value: { type: "number", description: "Threshold value" },
		direction: { type: "string", description: "above, below" },
		color: { type: "string", description: "red, yellow, green" },
		send_alert: { type: "boolean", default: false },
		},
		required: ["indicator", "value", "direction"],
		},
		},
		{
		name: "snow_get_pa_scores",
		description: "Gets PA scores from pa_scores table.",
		inputSchema: {
		type: "object",
		properties: {
		indicator: { type: "string", description: "Indicator sys_id" },
		start_date: { type: "string", description: "Start date" },
		end_date: { type: "string", description: "End date" },
		breakdown: { type: "string", description: "Breakdown sys_id" },
		},
		required: ["indicator"],
		},
		},
		{
		name: "snow_create_pa_target",
		description: "Creates PA target using pa_targets table.",
		inputSchema: {
		type: "object",
		properties: {
		indicator: { type: "string", description: "Indicator sys_id" },
		target_value: { type: "number", description: "Target value" },
		period: { type: "string", description: "monthly, quarterly, yearly" },
		start_date: { type: "string", description: "Target start date" },
		},
		required: ["indicator", "target_value"],
		},
		},
		{
		name: "snow_analyze_pa_trends",
		description: "Analyzes PA trends from pa_scores table.",
		inputSchema: {
		type: "object",
		properties: {
		indicator: { type: "string", description: "Indicator sys_id" },
		period: { type: "string", description: "Analysis period" },
		include_forecast: { type: "boolean", default: false },
		},
		required: ["indicator"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Execute with enhanced tracking
		return await this.executeTool(name, async () => {
		switch (name) {
		// Change Management
		case "snow_create_change_request":
		return await this.createChangeRequest(args as any)
		case "snow_create_change_task":
		return await this.createChangeTask(args as any)
		case "snow_get_change_request":
		return await this.getChangeRequest(args as any)
		case "snow_update_change_state":
		return await this.updateChangeState(args as any)
		case "snow_schedule_cab_meeting":
		return await this.scheduleCabMeeting(args as any)
		case "snow_search_change_requests":
		return await this.searchChangeRequests(args as any)
		// Virtual Agent
		case "snow_create_va_topic":
		return await this.createVATopic(args as any)
		case "snow_create_va_topic_block":
		return await this.createVATopicBlock(args as any)
		case "snow_get_va_conversation":
		return await this.getVAConversation(args as any)
		case "snow_send_va_message":
		return await this.sendVAMessage(args as any)
		case "snow_handoff_to_agent":
		return await this.handoffToAgent(args as any)
		case "snow_discover_va_topics":
		return await this.discoverVATopics(args as any)
		// Performance Analytics
		case "snow_create_pa_indicator":
		return await this.createPAIndicator(args as any)
		case "snow_create_pa_widget":
		return await this.createPAWidget(args as any)
		case "snow_create_pa_breakdown":
		return await this.createPABreakdown(args as any)
		case "snow_create_pa_threshold":
		return await this.createPAThreshold(args as any)
		case "snow_get_pa_scores":
		return await this.getPAScores(args as any)
		case "snow_create_pa_target":
		return await this.createPATarget(args as any)
		case "snow_analyze_pa_trends":
		return await this.analyzePATrends(args as any)
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}
		})
		} catch (error) {
		if (error instanceof McpError) throw error
		throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error}`)
		}
		})
		}

		// Change Management Methods

		private async createChangeRequest(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating change request...", {
		short_description: args.short_description,
		type: args.type,
		risk: args.risk,
		})

		const changeData = {
		short_description: args.short_description,
		description: args.description \|\| "",
		type: args.type,
		risk: args.risk \|\| "moderate",
		impact: args.impact \|\| "3",
		implementation_plan: args.implementation_plan \|\| "",
		backout_plan: args.backout_plan \|\| "",
		test_plan: args.test_plan \|\| "",
		justification: args.justification \|\| "",
		start_date: args.start_date \|\| "",
		end_date: args.end_date \|\| "",
		state: "new",
		}

		this.logger.progress("Creating change request in ServiceNow...")
		const response = await this.createRecord("change_request", changeData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create change: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ Change request created", {
		number: result.number,
		sys_id: result.sys_id,
		})

		return this.createResponse(
		`✅ Change Request created!
		📋 ${result.number}
		🔧 Type: ${args.type}
		⚠️ Risk: ${args.risk \|\| "moderate"}
		📊 Impact: ${args.impact \|\| "3-moderate"}
		🆔 sys_id: ${result.sys_id}
		📅 Schedule: ${args.start_date \|\| "TBD"} - ${args.end_date \|\| "TBD"}

		✨ Change request ready for assessment!`,
		)
		}

		private async createChangeTask(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating change task...", { change_request: args.change_request })

		const taskData = {
		change_request: args.change_request,
		short_description: args.short_description,
		assignment_group: args.assignment_group \|\| "",
		assigned_to: args.assigned_to \|\| "",
		order: args.order \|\| 100,
		state: "pending",
		}

		this.logger.progress("Creating task...")
		const response = await this.createRecord("change_task", taskData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create task: ${response.error}`)
		}

		this.logger.info("✅ Change task created")
		return this.createResponse(
		`✅ Change task created!
		📋 ${args.short_description}
		🆔 sys_id: ${response.data.sys_id}
		📊 Order: ${args.order \|\| 100}`,
		)
		}

		private async getChangeRequest(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting change request...", { sys_id: args.sys_id })

		const response = await this.getRecord("change_request", args.sys_id)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get change: ${response.error}`)
		}

		const change = response.data
		let details = `📋 ${change.number}
		🔧 Type: ${change.type}
		⚠️ Risk: ${change.risk}
		📊 State: ${change.state}
		📅 Schedule: ${change.start_date} - ${change.end_date}
		🆔 sys_id: ${change.sys_id}`

		if (args.include_tasks) {
		const taskQuery = `change_request=${args.sys_id}`
		const taskResponse = await this.queryTable("change_task", taskQuery, 20)

		if (taskResponse.success && taskResponse.data.result.length > 0) {
		details += `\n\n📌 Tasks (${taskResponse.data.result.length}):`
		taskResponse.data.result.forEach((task: any) => {
		details += `\n • ${task.short_description} (${task.state})`
		})
		}
		}

		this.logger.info("✅ Retrieved change details")
		return this.createResponse(details)
		}

		private async updateChangeState(args: any): Promise<MCPToolResult> {
		this.logger.info("Updating change state...", {
		sys_id: args.sys_id,
		state: args.state,
		})

		const updateData: any = { state: args.state }
		if (args.close_notes) updateData.close_notes = args.close_notes

		const response = await this.updateRecord("change_request", args.sys_id, updateData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to update state: ${response.error}`)
		}

		this.logger.info("✅ Change state updated")
		return this.createResponse(
		`✅ Change state updated to: ${args.state}
		🆔 sys_id: ${args.sys_id}`,
		)
		}

		private async scheduleCabMeeting(args: any): Promise<MCPToolResult> {
		this.logger.info("Scheduling CAB meeting...", { date: args.meeting_date })

		const meetingData = {
		meeting_date: args.meeting_date,
		location: args.location \|\| "Virtual",
		state: "scheduled",
		}

		this.logger.progress("Creating CAB meeting...")
		const response = await this.createRecord("cab_meeting", meetingData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to schedule CAB: ${response.error}`)
		}

		const meeting = response.data

		// Add change requests to agenda
		if (args.change_requests && args.change_requests.length > 0) {
		for (const changeId of args.change_requests) {
		await this.createRecord("cab_agenda_item", {
		cab_meeting: meeting.sys_id,
		change_request: changeId,
		})
		}
		}

		this.logger.info("✅ CAB meeting scheduled")
		return this.createResponse(
		`✅ CAB Meeting scheduled!
		📅 Date: ${args.meeting_date}
		📍 Location: ${args.location \|\| "Virtual"}
		📋 Changes: ${args.change_requests?.length \|\| 0} items
		🆔 sys_id: ${meeting.sys_id}`,
		)
		}

		private async searchChangeRequests(args: any): Promise<MCPToolResult> {
		this.logger.info("Searching change requests...", { query: args.query })

		let query = args.query ? `short_descriptionLIKE${args.query}` : ""
		if (args.state) query += `^state=${args.state}`
		if (args.type) query += `^type=${args.type}`
		if (args.risk) query += `^risk=${args.risk}`

		this.logger.progress("Searching changes...")
		const response = await this.queryTable("change_request", query, args.limit \|\| 10)

		if (!response.success) {
		return this.createResponse(`❌ Search failed: ${response.error}`)
		}

		const changes = response.data.result

		if (!changes.length) {
		return this.createResponse(`❌ No changes found`)
		}

		this.logger.info(`Found ${changes.length} changes`)

		const changeList = changes
		.map(
		(c: any) =>
		`📋 ${c.number} - ${c.short_description}
		🔧 ${c.type} \| ⚠️ ${c.risk} \| 📊 ${c.state}`,
		)
		.join("\n\n")

		return this.createResponse(`🔍 Change Requests:\n\n${changeList}\n\n✨ Found ${changes.length} change(s)`)
		}

		// Virtual Agent Methods

		private async createVATopic(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating VA topic...", { name: args.name })

		const topicData = {
		name: args.name,
		description: args.description \|\| "",
		trigger_phrases: args.trigger_phrases.join(","),
		category: args.category \|\| "",
		active: args.active !== false,
		}

		this.logger.progress("Creating topic...")
		const response = await this.createRecord("sys_cs_topic", topicData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create topic: ${response.error}`)
		}

		this.logger.info("✅ VA topic created")
		return this.createResponse(
		`✅ Virtual Agent topic created!
		🤖 ${args.name}
		💬 Triggers: ${args.trigger_phrases.join(", ")}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async createVATopicBlock(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating topic block...", { topic: args.topic, type: args.type })

		const blockData = {
		topic: args.topic,
		type: args.type,
		message: args.message,
		order: args.order \|\| 100,
		options: JSON.stringify(args.options \|\| []),
		}

		this.logger.progress("Creating block...")
		const response = await this.createRecord("sys_cs_topic_block", blockData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create block: ${response.error}`)
		}

		this.logger.info("✅ Topic block created")
		return this.createResponse(
		`✅ Topic block created!
		📝 Type: ${args.type}
		💬 Message: ${args.message}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async getVAConversation(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting VA conversation...")

		let query = ""
		if (args.conversation_id) query = `sys_id=${args.conversation_id}`
		else if (args.user) query = `user=${args.user}`

		const response = await this.queryTable("sys_cs_conversation", query, args.limit \|\| 50)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get conversation: ${response.error}`)
		}

		const messages = response.data.result
		this.logger.info(`Retrieved ${messages.length} messages`)

		const conversation = messages
		.map((msg: any) => `[${msg.sys_created_on}] ${msg.from_user ? "👤" : "🤖"} ${msg.message}`)
		.join("\n")

		return this.createResponse(`💬 Conversation History:\n\n${conversation}\n\n✨ ${messages.length} messages`)
		}

		private async sendVAMessage(args: any): Promise<MCPToolResult> {
		this.logger.info("Sending VA message...", { message: args.message })

		const messageData = {
		conversation: args.conversation_id \|\| "",
		message: args.message,
		user: args.user \|\| "api_user",
		from_user: true,
		}

		this.logger.progress("Sending message...")
		const response = await this.createRecord("sys_cs_conversation", messageData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to send message: ${response.error}`)
		}

		this.logger.info("✅ Message sent")
		return this.createResponse(
		`✅ Message sent to Virtual Agent!
		💬 "${args.message}"
		🆔 Conversation: ${response.data.conversation \|\| response.data.sys_id}`,
		)
		}

		private async handoffToAgent(args: any): Promise<MCPToolResult> {
		this.logger.info("Escalating to live agent...", { conversation_id: args.conversation_id })

		const updateData = {
		state: "escalated",
		escalation_reason: args.reason \|\| "User requested agent",
		priority: args.priority \|\| "3",
		}

		const response = await this.updateRecord("sys_cs_conversation", args.conversation_id, updateData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to escalate: ${response.error}`)
		}

		this.logger.info("✅ Escalated to agent")
		return this.createResponse(
		`✅ Conversation escalated to live agent!
		📞 Reason: ${args.reason \|\| "User requested"}
		⚡ Priority: ${args.priority \|\| "3-moderate"}`,
		)
		}

		private async discoverVATopics(args: any): Promise<MCPToolResult> {
		this.logger.info("Discovering VA topics...")

		let query = args.active_only ? "active=true" : ""
		if (args.category) query += `^category=${args.category}`

		const response = await this.queryTable("sys_cs_topic", query, 50)

		if (!response.success) {
		return this.createResponse(`❌ Failed to discover topics: ${response.error}`)
		}

		const topics = response.data.result
		this.logger.info(`Found ${topics.length} topics`)

		const topicList = topics
		.map(
		(topic: any) =>
		`🤖 ${topic.name}
		📝 ${topic.description \|\| "No description"}
		🏷️ ${topic.category \|\| "Uncategorized"}`,
		)
		.join("\n\n")

		return this.createResponse(`🤖 Virtual Agent Topics:\n\n${topicList}\n\n✨ Total: ${topics.length} topics`)
		}

		// Performance Analytics Methods

		private async createPAIndicator(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating PA indicator...", {
		name: args.name,
		table: args.table,
		aggregate: args.aggregate,
		})

		const indicatorData = {
		name: args.name,
		table: args.table,
		aggregate: args.aggregate,
		field: args.field \|\| "",
		conditions: args.conditions \|\| "",
		frequency: args.frequency \|\| "daily",
		active: true,
		}

		this.logger.progress("Creating indicator...")
		const response = await this.createRecord("pa_indicators", indicatorData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create indicator: ${response.error}`)
		}

		this.logger.info("✅ PA indicator created")
		return this.createResponse(
		`✅ PA Indicator created!
		📊 ${args.name}
		📋 Table: ${args.table}
		📈 Aggregate: ${args.aggregate}${args.field ? ` on ${args.field}` : ""}
		⏰ Frequency: ${args.frequency \|\| "daily"}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async createPAWidget(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating PA widget...", {
		name: args.name,
		type: args.type,
		})

		const widgetData = {
		name: args.name,
		indicator: args.indicator,
		type: args.type,
		size: args.size \|\| "medium",
		time_range: args.time_range \|\| "30 days",
		}

		this.logger.progress("Creating widget...")
		const response = await this.createRecord("pa_widgets", widgetData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create widget: ${response.error}`)
		}

		this.logger.info("✅ PA widget created")
		return this.createResponse(
		`✅ PA Widget created!
		📊 ${args.name}
		📈 Type: ${args.type}
		📐 Size: ${args.size \|\| "medium"}
		⏰ Range: ${args.time_range \|\| "30 days"}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async createPABreakdown(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating PA breakdown...", { name: args.name })

		const breakdownData = {
		name: args.name,
		source_table: args.source_table,
		field: args.field,
		related_indicator: args.related_indicator \|\| "",
		}

		this.logger.progress("Creating breakdown...")
		const response = await this.createRecord("pa_breakdowns", breakdownData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create breakdown: ${response.error}`)
		}

		this.logger.info("✅ PA breakdown created")
		return this.createResponse(
		`✅ PA Breakdown created!
		📊 ${args.name}
		📋 Table: ${args.source_table}
		🔍 Field: ${args.field}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async createPAThreshold(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating PA threshold...", {
		indicator: args.indicator,
		value: args.value,
		})

		const thresholdData = {
		indicator: args.indicator,
		value: args.value,
		direction: args.direction,
		color: args.color \|\| "yellow",
		send_alert: args.send_alert \|\| false,
		}

		this.logger.progress("Creating threshold...")
		const response = await this.createRecord("pa_thresholds", thresholdData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create threshold: ${response.error}`)
		}

		this.logger.info("✅ PA threshold created")
		return this.createResponse(
		`✅ PA Threshold created!
		⚠️ Value: ${args.value} (${args.direction})
		🎨 Color: ${args.color \|\| "yellow"}
		🔔 Alert: ${args.send_alert ? "Yes" : "No"}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async getPAScores(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting PA scores...", { indicator: args.indicator })

		let query = `indicator=${args.indicator}`
		if (args.start_date) query += `^sys_created_on>=${args.start_date}`
		if (args.end_date) query += `^sys_created_on<=${args.end_date}`
		if (args.breakdown) query += `^breakdown=${args.breakdown}`

		this.logger.progress("Retrieving scores...")
		const response = await this.queryTable("pa_scores", query, 100)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get scores: ${response.error}`)
		}

		const scores = response.data.result

		if (!scores.length) {
		return this.createResponse(`❌ No scores found for indicator`)
		}

		this.logger.info(`Retrieved ${scores.length} scores`)

		// Calculate statistics
		const values = scores.map((s: any) => parseFloat(s.value))
		const avg = (values.reduce((a: number, b: number) => a + b, 0) / values.length).toFixed(2)
		const min = Math.min(...values)
		const max = Math.max(...values)

		return this.createResponse(
		`📊 PA Scores:
		📈 Average: ${avg}
		⬇️ Min: ${min}
		⬆️ Max: ${max}
		📅 Period: ${scores.length} data points
		✨ Latest: ${values[values.length - 1]}`,
		)
		}

		private async createPATarget(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating PA target...", {
		indicator: args.indicator,
		target_value: args.target_value,
		})

		const targetData = {
		indicator: args.indicator,
		target_value: args.target_value,
		period: args.period \|\| "monthly",
		start_date: args.start_date \|\| new Date().toISOString(),
		}

		this.logger.progress("Creating target...")
		const response = await this.createRecord("pa_targets", targetData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create target: ${response.error}`)
		}

		this.logger.info("✅ PA target created")
		return this.createResponse(
		`✅ PA Target created!
		🎯 Target: ${args.target_value}
		📅 Period: ${args.period \|\| "monthly"}
		📆 Start: ${args.start_date \|\| "Today"}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async analyzePATrends(args: any): Promise<MCPToolResult> {
		this.logger.info("Analyzing PA trends...", { indicator: args.indicator })

		const query = `indicator=${args.indicator}^ORDERBYsys_created_on`
		const response = await this.queryTable("pa_scores", query, 100)

		if (!response.success) {
		return this.createResponse(`❌ Failed to analyze trends: ${response.error}`)
		}

		const scores = response.data.result

		if (scores.length < 2) {
		return this.createResponse(`❌ Insufficient data for trend analysis`)
		}

		this.logger.info(`Analyzing ${scores.length} data points`)

		// Calculate trend
		const values = scores.map((s: any) => parseFloat(s.value))
		const firstHalf = values.slice(0, Math.floor(values.length / 2))
		const secondHalf = values.slice(Math.floor(values.length / 2))

		const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length
		const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length

		const trend = (((secondAvg - firstAvg) / firstAvg) * 100).toFixed(1)
		const direction = parseFloat(trend) > 0 ? "📈 Upward" : parseFloat(trend) < 0 ? "📉 Downward" : "➡️ Stable"

		let analysis = `📊 Trend Analysis:
		${direction} trend: ${Math.abs(parseFloat(trend))}%
		📅 Period: ${scores.length} data points
		📈 Current: ${values[values.length - 1]}
		📉 Previous: ${values[values.length - 2]}`

		if (args.include_forecast) {
		// Simple linear forecast
		const growthRate = parseFloat(trend) / 100
		const forecast = (values[values.length - 1] * (1 + growthRate)).toFixed(2)
		analysis += `\n🔮 Next Period Forecast: ${forecast}`
		}

		return this.createResponse(analysis)
		}

		async start() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)

		// Log ready state
		this.logger.info("🚀 ServiceNow Change, VA & PA MCP Server (Enhanced) running")
		this.logger.info("📊 Token tracking enabled")
		this.logger.info("⏳ Progress indicators active")
		}
		}

		// Start the enhanced server
		const server = new ServiceNowChangeVirtualAgentPAMCPEnhanced()
		server.start().catch((error) => {
		console.error("Failed to start enhanced server:", error)
		process.exit(1)
		})

-1466

src/servicenow/servicenow-change-virtualagent-pa-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Change Management, Virtual Agent & Performance Analytics MCP Server
		* Handles change requests, chatbot conversations, and performance analytics
		* Uses official ServiceNow REST APIs
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"
		import { MCPLogger } from "./shared/mcp-logger.js"

		class ServiceNowChangeVirtualAgentPAMCP {
		private server: Server
		private client: ServiceNowClient
		private logger: MCPLogger
		private config: ReturnType<typeof mcpConfig.getConfig>

		constructor() {
		this.server = new Server(
		{
		name: "servicenow-change-virtualagent-pa",
		version: "1.0.0",
		},
		{
		capabilities: {
		tools: {},
		},
		},
		)

		this.client = new ServiceNowClient()
		this.logger = new MCPLogger("ServiceNowChangeVirtualAgentPAMCP")
		this.config = mcpConfig.getConfig()

		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		// Change Management Tools
		{
		name: "snow_create_change_request",
		description:
		"Creates a change request in ServiceNow. Change requests track modifications to IT infrastructure and require approval workflows.",
		inputSchema: {
		type: "object",
		properties: {
		short_description: { type: "string", description: "Brief description of the change" },
		description: { type: "string", description: "Detailed change description" },
		type: { type: "string", description: "Change type: standard, normal, emergency" },
		category: { type: "string", description: "Change category: hardware, software, network, etc." },
		priority: { type: "number", description: "Priority: 1-Critical, 2-High, 3-Moderate, 4-Low" },
		risk: { type: "number", description: "Risk level: 1-High, 2-Moderate, 3-Low" },
		impact: { type: "number", description: "Impact level: 1-High, 2-Medium, 3-Low" },
		assignment_group: { type: "string", description: "Group responsible for the change" },
		assigned_to: { type: "string", description: "Person assigned to the change" },
		start_date: { type: "string", description: "Planned start date (YYYY-MM-DD HH:MM:SS)" },
		end_date: { type: "string", description: "Planned end date (YYYY-MM-DD HH:MM:SS)" },
		justification: { type: "string", description: "Business justification" },
		implementation_plan: { type: "string", description: "Implementation steps" },
		backout_plan: { type: "string", description: "Rollback plan if change fails" },
		test_plan: { type: "string", description: "Testing procedure" },
		},
		required: ["short_description", "type"],
		},
		},
		{
		name: "snow_create_change_task",
		description:
		"Creates a change task within a change request. Tasks break down the change into manageable work items.",
		inputSchema: {
		type: "object",
		properties: {
		change_request: { type: "string", description: "Parent change request sys_id or number" },
		short_description: { type: "string", description: "Task description" },
		description: { type: "string", description: "Detailed task description" },
		assignment_group: { type: "string", description: "Group responsible" },
		assigned_to: { type: "string", description: "Person assigned" },
		planned_start_date: { type: "string", description: "Start date" },
		planned_end_date: { type: "string", description: "End date" },
		order: { type: "number", description: "Task execution order" },
		},
		required: ["change_request", "short_description"],
		},
		},
		{
		name: "snow_get_change_request",
		description: "Retrieves change request details including approval status, tasks, and related items.",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: { type: "string", description: "Change request sys_id or number" },
		include_tasks: { type: "boolean", description: "Include change tasks", default: true },
		include_approvals: { type: "boolean", description: "Include approval history", default: true },
		},
		required: ["sys_id"],
		},
		},
		{
		name: "snow_update_change_state",
		description: "Updates the state of a change request through its lifecycle.",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: { type: "string", description: "Change request sys_id or number" },
		state: {
		type: "string",
		description: "New state: draft, assess, authorize, scheduled, implement, review, closed, cancelled",
		},
		close_notes: { type: "string", description: "Closure notes (for closed state)" },
		close_code: { type: "string", description: "Closure code: successful, unsuccessful, cancelled" },
		},
		required: ["sys_id", "state"],
		},
		},
		{
		name: "snow_schedule_cab_meeting",
		description: "Schedules a Change Advisory Board (CAB) meeting for change review.",
		inputSchema: {
		type: "object",
		properties: {
		change_request: { type: "string", description: "Change request to review" },
		meeting_date: { type: "string", description: "Meeting date/time" },
		attendees: { type: "array", items: { type: "string" }, description: "Meeting attendees" },
		agenda: { type: "string", description: "Meeting agenda" },
		location: { type: "string", description: "Meeting location or link" },
		},
		required: ["change_request", "meeting_date"],
		},
		},
		{
		name: "snow_search_change_requests",
		description: "Searches for change requests with filters for state, date range, assignment, and risk.",
		inputSchema: {
		type: "object",
		properties: {
		query: { type: "string", description: "Search query" },
		state: { type: "string", description: "Filter by state" },
		type: { type: "string", description: "Filter by type" },
		risk: { type: "number", description: "Filter by risk level" },
		assigned_to: { type: "string", description: "Filter by assignee" },
		date_from: { type: "string", description: "Start date range" },
		date_to: { type: "string", description: "End date range" },
		limit: { type: "number", description: "Maximum results", default: 20 },
		},
		},
		},

		// Virtual Agent / Chatbot Tools
		{
		name: "snow_create_va_topic",
		description:
		"Creates a Virtual Agent conversation topic. Topics define conversation flows for specific user intents.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Topic name" },
		description: { type: "string", description: "Topic description" },
		utterances: {
		type: "array",
		items: { type: "string" },
		description: "Training phrases that trigger this topic",
		},
		category: { type: "string", description: "Topic category" },
		active: { type: "boolean", description: "Is topic active", default: true },
		live_agent_enabled: { type: "boolean", description: "Allow escalation to live agent", default: false },
		},
		required: ["name", "utterances"],
		},
		},
		{
		name: "snow_create_va_topic_block",
		description:
		"Creates a conversation block within a Virtual Agent topic. Blocks define conversation steps and responses.",
		inputSchema: {
		type: "object",
		properties: {
		topic: { type: "string", description: "Parent topic sys_id" },
		name: { type: "string", description: "Block name" },
		type: { type: "string", description: "Block type: text, question, script, handoff, decision" },
		order: { type: "number", description: "Block execution order" },
		text: { type: "string", description: "Response text for text blocks" },
		script: { type: "string", description: "Script for script blocks" },
		variable: { type: "string", description: "Variable to store user input" },
		next_block: { type: "string", description: "Next block to execute" },
		},
		required: ["topic", "name", "type", "order"],
		},
		},
		{
		name: "snow_get_va_conversation",
		description: "Retrieves Virtual Agent conversation history and context for a specific session.",
		inputSchema: {
		type: "object",
		properties: {
		conversation_id: { type: "string", description: "Conversation sys_id" },
		user_id: { type: "string", description: "User sys_id (alternative to conversation_id)" },
		include_transcript: { type: "boolean", description: "Include full transcript", default: true },
		limit: { type: "number", description: "Maximum messages to retrieve", default: 50 },
		},
		},
		},
		{
		name: "snow_send_va_message",
		description:
		"Sends a message to Virtual Agent and gets the response. Simulates user interaction with the chatbot.",
		inputSchema: {
		type: "object",
		properties: {
		conversation_id: { type: "string", description: "Existing conversation ID (optional)" },
		message: { type: "string", description: "User message text" },
		user_id: { type: "string", description: "User sys_id" },
		context: { type: "object", description: "Additional context variables" },
		},
		required: ["message"],
		},
		},
		{
		name: "snow_handoff_to_agent",
		description:
		"Initiates handoff from Virtual Agent to a live agent when automated assistance is insufficient.",
		inputSchema: {
		type: "object",
		properties: {
		conversation_id: { type: "string", description: "Conversation to handoff" },
		queue: { type: "string", description: "Agent queue for routing" },
		priority: { type: "number", description: "Queue priority" },
		reason: { type: "string", description: "Handoff reason" },
		context: { type: "object", description: "Context to pass to agent" },
		},
		required: ["conversation_id"],
		},
		},
		{
		name: "snow_discover_va_topics",
		description: "Discovers available Virtual Agent topics and their configurations.",
		inputSchema: {
		type: "object",
		properties: {
		category: { type: "string", description: "Filter by category" },
		active_only: { type: "boolean", description: "Show only active topics", default: true },
		},
		},
		},

		// Performance Analytics Tools
		{
		name: "snow_create_pa_indicator",
		description:
		"Creates a Performance Analytics indicator (KPI). Indicators track metrics over time with automated data collection.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Indicator name" },
		table: { type: "string", description: "Table to measure" },
		aggregate: { type: "string", description: "Aggregation: count, sum, avg, min, max" },
		field: { type: "string", description: "Field to aggregate (for sum/avg)" },
		condition: { type: "string", description: "Filter condition" },
		frequency: { type: "string", description: "Collection frequency: daily, weekly, monthly" },
		unit: { type: "string", description: "Unit of measure" },
		direction: { type: "string", description: "Desired direction: increase, decrease, maintain" },
		target: { type: "number", description: "Target value" },
		thresholds: { type: "object", description: "Warning and critical thresholds" },
		},
		required: ["name", "table", "aggregate"],
		},
		},
		{
		name: "snow_create_pa_widget",
		description: "Creates a Performance Analytics dashboard widget for visualizing indicators.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Widget name" },
		type: { type: "string", description: "Widget type: time_series, scorecard, dial, column, pie" },
		indicator: { type: "string", description: "Indicator sys_id to display" },
		breakdown: { type: "string", description: "Breakdown field for grouping" },
		time_range: { type: "string", description: "Time range: 7days, 30days, 90days, 1year" },
		dashboard: { type: "string", description: "Dashboard to add widget to" },
		size_x: { type: "number", description: "Widget width", default: 4 },
		size_y: { type: "number", description: "Widget height", default: 3 },
		},
		required: ["name", "type", "indicator"],
		},
		},
		{
		name: "snow_create_pa_breakdown",
		description: "Creates a breakdown source for Performance Analytics to segment data by dimensions.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Breakdown name" },
		table: { type: "string", description: "Table to breakdown" },
		field: { type: "string", description: "Field to group by" },
		related_field: { type: "string", description: "Related field path (for reference fields)" },
		matrix_source: { type: "boolean", description: "Is matrix breakdown", default: false },
		},
		required: ["name", "table", "field"],
		},
		},
		{
		name: "snow_get_pa_scores",
		description: "Retrieves Performance Analytics scores and trends for indicators over specified time periods.",
		inputSchema: {
		type: "object",
		properties: {
		indicator: { type: "string", description: "Indicator sys_id or name" },
		time_range: { type: "string", description: "Time range for data" },
		breakdown: { type: "string", description: "Breakdown to apply" },
		include_forecast: { type: "boolean", description: "Include forecast data", default: false },
		include_targets: { type: "boolean", description: "Include target lines", default: true },
		},
		required: ["indicator"],
		},
		},
		{
		name: "snow_create_pa_threshold",
		description: "Creates threshold rules for Performance Analytics indicators to trigger alerts.",
		inputSchema: {
		type: "object",
		properties: {
		indicator: { type: "string", description: "Indicator sys_id" },
		type: { type: "string", description: "Threshold type: warning, critical" },
		operator: { type: "string", description: "Operator: >, <, >=, <=, =" },
		value: { type: "number", description: "Threshold value" },
		duration: { type: "number", description: "Duration in periods before alert" },
		notification_group: { type: "string", description: "Group to notify" },
		},
		required: ["indicator", "type", "operator", "value"],
		},
		},
		{
		name: "snow_collect_pa_data",
		description: "Manually triggers Performance Analytics data collection for specific indicators.",
		inputSchema: {
		type: "object",
		properties: {
		indicator: { type: "string", description: "Indicator to collect data for" },
		start_date: { type: "string", description: "Collection start date" },
		end_date: { type: "string", description: "Collection end date" },
		recalculate: { type: "boolean", description: "Recalculate existing data", default: false },
		},
		required: ["indicator"],
		},
		},
		{
		name: "snow_discover_pa_indicators",
		description: "Discovers available Performance Analytics indicators and their configurations.",
		inputSchema: {
		type: "object",
		properties: {
		table: { type: "string", description: "Filter by table" },
		active_only: { type: "boolean", description: "Show only active indicators", default: true },
		},
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Start operation with token tracking
		this.logger.operationStart(name, args)

		const authResult = await mcpAuth.ensureAuthenticated()
		if (!authResult.success) {
		throw new McpError(ErrorCode.InternalError, authResult.error \|\| "Authentication required")
		}

		let result
		switch (name) {
		// Change Management
		case "snow_create_change_request":
		result = await this.createChangeRequest(args)
		break
		case "snow_create_change_task":
		result = await this.createChangeTask(args)
		break
		case "snow_get_change_request":
		result = await this.getChangeRequest(args)
		break
		case "snow_update_change_state":
		result = await this.updateChangeState(args)
		break
		case "snow_schedule_cab_meeting":
		result = await this.scheduleCABMeeting(args)
		break
		case "snow_search_change_requests":
		result = await this.searchChangeRequests(args)
		break

		// Virtual Agent
		case "snow_create_va_topic":
		result = await this.createVATopic(args)
		break
		case "snow_create_va_topic_block":
		result = await this.createVATopicBlock(args)
		break
		case "snow_get_va_conversation":
		result = await this.getVAConversation(args)
		break
		case "snow_send_va_message":
		result = await this.sendVAMessage(args)
		break
		case "snow_handoff_to_agent":
		result = await this.handoffToAgent(args)
		break
		case "snow_discover_va_topics":
		result = await this.discoverVATopics(args)
		break

		// Performance Analytics
		case "snow_create_pa_indicator":
		result = await this.createPAIndicator(args)
		break
		case "snow_create_pa_widget":
		result = await this.createPAWidget(args)
		break
		case "snow_create_pa_breakdown":
		result = await this.createPABreakdown(args)
		break
		case "snow_get_pa_scores":
		result = await this.getPAScores(args)
		break
		case "snow_create_pa_threshold":
		result = await this.createPAThreshold(args)
		break
		case "snow_collect_pa_data":
		result = await this.collectPAData(args)
		break
		case "snow_discover_pa_indicators":
		result = await this.discoverPAIndicators(args)
		break

		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		// Complete operation with token tracking
		result = this.logger.addTokenUsageToResponse(result)
		result = this.logger.addTokenUsageToResponse(result)
		this.logger.operationComplete(name, result)
		return result
		} catch (error) {
		this.logger.error(`Error in ${request.params.name}:`, error)
		throw error
		}
		})
		}

		// Change Management Implementation
		private async createChangeRequest(args: any) {
		try {
		this.logger.info("Creating change request...")

		const changeData = {
		short_description: args.short_description,
		description: args.description \|\| "",
		type: args.type \|\| "normal",
		category: args.category \|\| "Other",
		priority: args.priority \|\| 3,
		risk: args.risk \|\| 3,
		impact: args.impact \|\| 3,
		assignment_group: args.assignment_group \|\| "",
		assigned_to: args.assigned_to \|\| "",
		start_date: args.start_date \|\| "",
		end_date: args.end_date \|\| "",
		justification: args.justification \|\| "",
		implementation_plan: args.implementation_plan \|\| "",
		backout_plan: args.backout_plan \|\| "",
		test_plan: args.test_plan \|\| "",
		state: "-5", // New state
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "change_request", 1)
		const response = await this.client.createRecord("change_request", changeData)

		if (!response.success) {
		throw new Error(`Failed to create change request: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Change Request created successfully!

		📋 ${args.short_description}
		🆔 Number: ${response.data.number}
		🆔 sys_id: ${response.data.sys_id}
		📊 Type: ${args.type \|\| "normal"}
		⚠️ Risk: ${args.risk \|\| 3}
		💥 Impact: ${args.impact \|\| 3}
		📅 Start: ${args.start_date \|\| "Not scheduled"}
		📅 End: ${args.end_date \|\| "Not scheduled"}

		✨ Change request created and ready for assessment!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create change request:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create change request: ${error}`)
		}
		}

		private async createChangeTask(args: any) {
		try {
		this.logger.info("Creating change task...")

		// Find parent change request
		let changeId = args.change_request
		if (!changeId.match(/^[a-f0-9]{32}$/)) {
		const changeResponse = await this.client.searchRecords("change_request", `number=${changeId}`, 1)
		if (changeResponse.success && changeResponse.data.result.length) {
		changeId = changeResponse.data.result[0].sys_id
		}
		}

		const taskData = {
		change_request: changeId,
		short_description: args.short_description,
		description: args.description \|\| "",
		assignment_group: args.assignment_group \|\| "",
		assigned_to: args.assigned_to \|\| "",
		planned_start_date: args.planned_start_date \|\| "",
		planned_end_date: args.planned_end_date \|\| "",
		order: args.order \|\| 100,
		}

		this.logger.trackAPICall("CREATE", "change_task", 1)
		const response = await this.client.createRecord("change_task", taskData)

		if (!response.success) {
		throw new Error(`Failed to create change task: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Change Task created successfully!

		📋 ${args.short_description}
		🆔 Number: ${response.data.number}
		🆔 sys_id: ${response.data.sys_id}
		🔗 Parent Change: ${args.change_request}
		🔢 Order: ${args.order \|\| 100}

		✨ Change task added to change request!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create change task:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create change task: ${error}`)
		}
		}

		private async getChangeRequest(args: any) {
		try {
		this.logger.info("Getting change request...")

		let changeId = args.sys_id
		if (!changeId.match(/^[a-f0-9]{32}$/)) {
		const changeResponse = await this.client.searchRecords("change_request", `number=${changeId}`, 1)
		if (changeResponse.success && changeResponse.data.result.length) {
		changeId = changeResponse.data.result[0].sys_id
		}
		}

		const response = await this.client.getRecord("change_request", changeId)
		if (!response.success) {
		throw new Error("Change request not found")
		}

		const change = response.data
		let details = `📋 ${change.number}: ${change.short_description}
		🆔 sys_id: ${change.sys_id}
		📊 Type: ${change.type}
		📊 State: ${change.state}
		⚠️ Risk: ${change.risk}
		💥 Impact: ${change.impact}
		📅 Scheduled: ${change.start_date} to ${change.end_date}
		👤 Assigned to: ${change.assigned_to \|\| "Unassigned"}`

		// Get tasks if requested
		if (args.include_tasks) {
		const tasksResponse = await this.client.searchRecords("change_task", `change_request=${changeId}`, 50)
		if (tasksResponse.success && tasksResponse.data.result.length) {
		const tasks = tasksResponse.data.result
		.map((t: any) => ` - ${t.number}: ${t.short_description} (${t.state})`)
		.join("\n")
		details += `\n\n📋 Change Tasks:\n${tasks}`
		}
		}

		// Get approvals if requested
		if (args.include_approvals) {
		const approvalsResponse = await this.client.searchRecords("sysapproval_approver", `document_id=${changeId}`, 50)
		if (approvalsResponse.success && approvalsResponse.data.result.length) {
		const approvals = approvalsResponse.data.result.map((a: any) => ` - ${a.approver}: ${a.state}`).join("\n")
		details += `\n\n✅ Approvals:\n${approvals}`
		}
		}

		return {
		content: [
		{
		type: "text",
		text: details + "\n\n✨ Change request details retrieved!",
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to get change request:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to get change request: ${error}`)
		}
		}

		private async updateChangeState(args: any) {
		try {
		this.logger.info("Updating change state...")

		let changeId = args.sys_id
		if (!changeId.match(/^[a-f0-9]{32}$/)) {
		const changeResponse = await this.client.searchRecords("change_request", `number=${changeId}`, 1)
		if (changeResponse.success && changeResponse.data.result.length) {
		changeId = changeResponse.data.result[0].sys_id
		}
		}

		const stateMap: any = {
		draft: "-5",
		assess: "-4",
		authorize: "-3",
		scheduled: "-2",
		implement: "-1",
		review: "0",
		closed: "3",
		cancelled: "4",
		}

		const updateData: any = {
		state: stateMap[args.state] \|\| args.state,
		}

		if (args.close_notes) updateData.close_notes = args.close_notes
		if (args.close_code) updateData.close_code = args.close_code

		const response = await this.client.updateRecord("change_request", changeId, updateData)

		if (!response.success) {
		throw new Error(`Failed to update change state: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Change Request state updated!

		🆔 Change: ${args.sys_id}
		📊 New State: ${args.state}
		${args.close_notes ? `📝 Close Notes: ${args.close_notes}` : ""}
		${args.close_code ? `✅ Close Code: ${args.close_code}` : ""}

		✨ Change state updated successfully!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to update change state:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to update change state: ${error}`)
		}
		}

		private async scheduleCABMeeting(args: any) {
		try {
		this.logger.info("Scheduling CAB meeting...")

		const cabData = {
		change_request: args.change_request,
		meeting_date: args.meeting_date,
		attendees: args.attendees ? args.attendees.join(",") : "",
		agenda: args.agenda \|\| "",
		location: args.location \|\| "",
		}

		// Create CAB meeting record (using task or event table)
		const response = await this.client.createRecord("task", {
		...cabData,
		short_description: `CAB Meeting for ${args.change_request}`,
		sys_class_name: "task",
		})

		if (!response.success) {
		throw new Error(`Failed to schedule CAB meeting: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ CAB Meeting scheduled!

		📅 Meeting Details
		🆔 sys_id: ${response.data.sys_id}
		📋 Change Request: ${args.change_request}
		📅 Date/Time: ${args.meeting_date}
		👥 Attendees: ${args.attendees ? args.attendees.join(", ") : "TBD"}
		📍 Location: ${args.location \|\| "TBD"}
		📝 Agenda: ${args.agenda \|\| "Review change request"}

		✨ CAB meeting scheduled successfully!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to schedule CAB meeting:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to schedule CAB meeting: ${error}`)
		}
		}

		private async searchChangeRequests(args: any) {
		try {
		this.logger.info("Searching change requests...")

		let query = ""
		if (args.query) {
		query = `short_descriptionLIKE${args.query}^ORdescriptionLIKE${args.query}`
		}
		if (args.state) {
		query += query ? "^" : ""
		query += `state=${args.state}`
		}
		if (args.type) {
		query += query ? "^" : ""
		query += `type=${args.type}`
		}
		if (args.risk) {
		query += query ? "^" : ""
		query += `risk=${args.risk}`
		}
		if (args.assigned_to) {
		query += query ? "^" : ""
		query += `assigned_to=${args.assigned_to}`
		}

		const limit = args.limit \|\| 20
		this.logger.trackAPICall("SEARCH", "change_request", limit)
		const response = await this.client.searchRecords("change_request", query, limit)

		if (!response.success) {
		throw new Error("Failed to search change requests")
		}

		const changes = response.data.result

		if (!changes.length) {
		return {
		content: [
		{
		type: "text",
		text: "❌ No change requests found",
		},
		],
		}
		}

		const changeList = changes
		.map(
		(change: any) =>
		`📋 ${change.number}: ${change.short_description}
		📊 Type: ${change.type} \| State: ${change.state}
		⚠️ Risk: ${change.risk} \| Impact: ${change.impact}
		📅 Scheduled: ${change.start_date \|\| "Not scheduled"}`,
		)
		.join("\n\n")

		return {
		content: [
		{
		type: "text",
		text: `🔍 Change Request Search Results:

		${changeList}

		✨ Found ${changes.length} change request(s)`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to search change requests:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to search change requests: ${error}`)
		}
		}

		// Virtual Agent Implementation
		private async createVATopic(args: any) {
		try {
		this.logger.info("Creating Virtual Agent topic...")

		const topicData = {
		name: args.name,
		description: args.description \|\| "",
		utterances: args.utterances.join("\n"),
		category: args.category \|\| "",
		active: args.active !== false,
		live_agent_enabled: args.live_agent_enabled \|\| false,
		}

		this.logger.trackAPICall("CREATE", "sys_cs_topic", 1)
		const response = await this.client.createRecord("sys_cs_topic", topicData)

		if (!response.success) {
		throw new Error(`Failed to create VA topic: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Virtual Agent Topic created!

		🤖 ${args.name}
		🆔 sys_id: ${response.data.sys_id}
		📝 Training Phrases: ${args.utterances.length}
		📂 Category: ${args.category \|\| "General"}
		🔄 Active: ${args.active !== false ? "Yes" : "No"}
		👤 Live Agent: ${args.live_agent_enabled ? "Enabled" : "Disabled"}

		✨ Topic ready for conversation design!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create VA topic:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create VA topic: ${error}`)
		}
		}

		private async createVATopicBlock(args: any) {
		try {
		this.logger.info("Creating VA topic block...")

		const blockData = {
		topic: args.topic,
		name: args.name,
		type: args.type,
		order: args.order,
		text: args.text \|\| "",
		script: args.script \|\| "",
		variable: args.variable \|\| "",
		next_block: args.next_block \|\| "",
		}

		const response = await this.client.createRecord("sys_cs_topic_block", blockData)

		if (!response.success) {
		throw new Error(`Failed to create VA topic block: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Topic Block created!

		🧩 ${args.name}
		🆔 sys_id: ${response.data.sys_id}
		📊 Type: ${args.type}
		🔢 Order: ${args.order}
		${args.text ? `💬 Text: ${args.text}` : ""}
		${args.variable ? `📝 Variable: ${args.variable}` : ""}

		✨ Topic block added to conversation flow!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create VA topic block:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create VA topic block: ${error}`)
		}
		}

		private async getVAConversation(args: any) {
		try {
		this.logger.info("Getting VA conversation...")

		let query = ""
		if (args.conversation_id) {
		query = `sys_id=${args.conversation_id}`
		} else if (args.user_id) {
		query = `user=${args.user_id}`
		}

		const response = await this.client.searchRecords("sys_cs_conversation", query, 1)
		if (!response.success \|\| !response.data.result.length) {
		throw new Error("Conversation not found")
		}

		const conversation = response.data.result[0]
		let details = `💬 Conversation ${conversation.sys_id}
		👤 User: ${conversation.user}
		📅 Started: ${conversation.sys_created_on}
		📊 Status: ${conversation.status}`

		if (args.include_transcript) {
		const messagesResponse = await this.client.searchRecords(
		"sys_cs_message",
		`conversation=${conversation.sys_id}`,
		args.limit \|\| 50,
		)

		if (messagesResponse.success && messagesResponse.data.result.length) {
		const transcript = messagesResponse.data.result
		.map((m: any) => `${m.author === "user" ? "👤" : "🤖"} ${m.text}`)
		.join("\n")
		details += `\n\n📝 Transcript:\n${transcript}`
		}
		}

		return {
		content: [
		{
		type: "text",
		text: details + "\n\n✨ Conversation retrieved!",
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to get VA conversation:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to get VA conversation: ${error}`)
		}
		}

		private async sendVAMessage(args: any) {
		try {
		this.logger.info("Sending message to Virtual Agent...")

		// Create or get conversation
		let conversationId = args.conversation_id
		if (!conversationId) {
		const convData = {
		user: args.user_id \|\| "guest",
		status: "active",
		}
		const convResponse = await this.client.createRecord("sys_cs_conversation", convData)
		if (convResponse.success) {
		conversationId = convResponse.data.sys_id
		}
		}

		// Create user message
		const messageData = {
		conversation: conversationId,
		text: args.message,
		author: "user",
		context: args.context ? JSON.stringify(args.context) : "",
		}

		const messageResponse = await this.client.createRecord("sys_cs_message", messageData)

		if (!messageResponse.success) {
		throw new Error(`Failed to send message: ${messageResponse.error}`)
		}

		// Simulate VA response (in real implementation, this would trigger VA processing)
		const vaResponse = {
		text: `I understand you said: "${args.message}". How can I help you with that?`,
		suggested_actions: ["Get more info", "Create ticket", "Talk to agent"],
		}

		return {
		content: [
		{
		type: "text",
		text: `💬 Message sent to Virtual Agent!

		👤 Your message: ${args.message}
		🤖 VA Response: ${vaResponse.text}

		🔘 Suggested Actions:
		${vaResponse.suggested_actions.map((a) => ` - ${a}`).join("\n")}

		🆔 Conversation ID: ${conversationId}

		✨ Conversation continues...`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to send VA message:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to send VA message: ${error}`)
		}
		}

		private async handoffToAgent(args: any) {
		try {
		this.logger.info("Initiating handoff to live agent...")

		const handoffData = {
		conversation_id: args.conversation_id,
		queue: args.queue \|\| "general",
		priority: args.priority \|\| 3,
		reason: args.reason \|\| "User requested live agent",
		context: args.context ? JSON.stringify(args.context) : "",
		status: "pending",
		}

		// Create handoff request
		const response = await this.client.createRecord("sys_cs_handoff", handoffData)

		if (!response.success) {
		// Fallback to updating conversation status
		await this.client.updateRecord("sys_cs_conversation", args.conversation_id, {
		status: "handoff_requested",
		})
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Handoff to live agent initiated!

		💬 Conversation: ${args.conversation_id}
		👥 Queue: ${args.queue \|\| "general"}
		⚠️ Priority: ${args.priority \|\| 3}
		📝 Reason: ${args.reason \|\| "User requested live agent"}

		✨ Live agent will join the conversation shortly!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to handoff to agent:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to handoff to agent: ${error}`)
		}
		}

		private async discoverVATopics(args: any) {
		try {
		this.logger.info("Discovering VA topics...")

		let query = ""
		if (args.category) {
		query = `category=${args.category}`
		}
		if (args.active_only) {
		query += query ? "^" : ""
		query += "active=true"
		}

		const response = await this.client.searchRecords("sys_cs_topic", query, 50)
		if (!response.success) {
		throw new Error("Failed to discover VA topics")
		}

		const topics = response.data.result

		if (!topics.length) {
		return {
		content: [
		{
		type: "text",
		text: "❌ No Virtual Agent topics found",
		},
		],
		}
		}

		const topicList = topics
		.map(
		(topic: any) =>
		`🤖 ${topic.name} ${topic.active ? "✅" : "❌"}
		📝 ${topic.description \|\| "No description"}
		📂 Category: ${topic.category \|\| "General"}
		👤 Live Agent: ${topic.live_agent_enabled ? "Yes" : "No"}`,
		)
		.join("\n\n")

		return {
		content: [
		{
		type: "text",
		text: `🔍 Virtual Agent Topics:

		${topicList}

		✨ Found ${topics.length} topic(s)`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover VA topics:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover VA topics: ${error}`)
		}
		}

		// Performance Analytics Implementation
		private async createPAIndicator(args: any) {
		try {
		this.logger.info("Creating PA indicator...")

		const indicatorData = {
		name: args.name,
		table: args.table,
		aggregate: args.aggregate,
		field: args.field \|\| "",
		condition: args.condition \|\| "",
		frequency: args.frequency \|\| "daily",
		unit: args.unit \|\| "",
		direction: args.direction \|\| "maintain",
		target: args.target \|\| 0,
		thresholds: args.thresholds ? JSON.stringify(args.thresholds) : "",
		}

		this.logger.trackAPICall("CREATE", "pa_indicators", 1)
		const response = await this.client.createRecord("pa_indicators", indicatorData)

		if (!response.success) {
		throw new Error(`Failed to create PA indicator: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Performance Analytics Indicator created!

		📊 ${args.name}
		🆔 sys_id: ${response.data.sys_id}
		📋 Table: ${args.table}
		📈 Aggregation: ${args.aggregate}
		${args.field ? `📝 Field: ${args.field}` : ""}
		⏰ Frequency: ${args.frequency \|\| "daily"}
		🎯 Target: ${args.target \|\| "Not set"}
		${args.unit ? `📏 Unit: ${args.unit}` : ""}

		✨ Indicator ready for data collection!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create PA indicator:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create PA indicator: ${error}`)
		}
		}

		private async createPAWidget(args: any) {
		try {
		this.logger.info("Creating PA widget...")

		const widgetData = {
		name: args.name,
		type: args.type,
		indicator: args.indicator,
		breakdown: args.breakdown \|\| "",
		time_range: args.time_range \|\| "30days",
		dashboard: args.dashboard \|\| "",
		size_x: args.size_x \|\| 4,
		size_y: args.size_y \|\| 3,
		}

		const response = await this.client.createRecord("pa_widgets", widgetData)

		if (!response.success) {
		throw new Error(`Failed to create PA widget: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ PA Widget created!

		📊 ${args.name}
		🆔 sys_id: ${response.data.sys_id}
		📈 Type: ${args.type}
		⏰ Time Range: ${args.time_range \|\| "30days"}
		📐 Size: ${args.size_x \|\| 4}x${args.size_y \|\| 3}
		${args.breakdown ? `📊 Breakdown: ${args.breakdown}` : ""}

		✨ Widget added to dashboard!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create PA widget:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create PA widget: ${error}`)
		}
		}

		private async createPABreakdown(args: any) {
		try {
		this.logger.info("Creating PA breakdown...")

		const breakdownData = {
		name: args.name,
		table: args.table,
		field: args.field,
		related_field: args.related_field \|\| "",
		matrix_source: args.matrix_source \|\| false,
		}

		const response = await this.client.createRecord("pa_breakdowns", breakdownData)

		if (!response.success) {
		throw new Error(`Failed to create PA breakdown: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ PA Breakdown created!

		📊 ${args.name}
		🆔 sys_id: ${response.data.sys_id}
		📋 Table: ${args.table}
		📝 Field: ${args.field}
		${args.related_field ? `🔗 Related Field: ${args.related_field}` : ""}
		📈 Matrix: ${args.matrix_source ? "Yes" : "No"}

		✨ Breakdown ready for use in indicators!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create PA breakdown:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create PA breakdown: ${error}`)
		}
		}

		private async getPAScores(args: any) {
		try {
		this.logger.info("Getting PA scores...")

		// Find indicator
		let indicatorId = args.indicator
		if (!indicatorId.match(/^[a-f0-9]{32}$/)) {
		const indResponse = await this.client.searchRecords("pa_indicators", `name=${indicatorId}`, 1)
		if (indResponse.success && indResponse.data.result.length) {
		indicatorId = indResponse.data.result[0].sys_id
		}
		}

		// Get scores
		const scoresResponse = await this.client.searchRecords("pa_scores", `indicator=${indicatorId}`, 100)

		if (!scoresResponse.success) {
		throw new Error("Failed to get PA scores")
		}

		const scores = scoresResponse.data.result

		if (!scores.length) {
		return {
		content: [
		{
		type: "text",
		text: "❌ No scores found for this indicator",
		},
		],
		}
		}

		const scoreList = scores
		.slice(0, 10)
		.map((score: any) => `📅 ${score.date}: ${score.value} ${score.unit \|\| ""}`)
		.join("\n")

		return {
		content: [
		{
		type: "text",
		text: `📊 Performance Analytics Scores:

		${scoreList}

		✨ Showing ${Math.min(10, scores.length)} of ${scores.length} scores`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to get PA scores:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to get PA scores: ${error}`)
		}
		}

		private async createPAThreshold(args: any) {
		try {
		this.logger.info("Creating PA threshold...")

		const thresholdData = {
		indicator: args.indicator,
		type: args.type,
		operator: args.operator,
		value: args.value,
		duration: args.duration \|\| 1,
		notification_group: args.notification_group \|\| "",
		}

		const response = await this.client.createRecord("pa_thresholds", thresholdData)

		if (!response.success) {
		throw new Error(`Failed to create PA threshold: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ PA Threshold created!

		⚠️ Threshold Configuration
		🆔 sys_id: ${response.data.sys_id}
		📊 Type: ${args.type}
		🔢 Rule: ${args.operator} ${args.value}
		⏱️ Duration: ${args.duration \|\| 1} period(s)
		${args.notification_group ? `📧 Notify: ${args.notification_group}` : ""}

		✨ Threshold monitoring active!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create PA threshold:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create PA threshold: ${error}`)
		}
		}

		private async collectPAData(args: any) {
		try {
		this.logger.info("Collecting PA data...")

		// Create data collection job
		const jobData = {
		indicator: args.indicator,
		start_date: args.start_date \|\| "",
		end_date: args.end_date \|\| "",
		recalculate: args.recalculate \|\| false,
		status: "pending",
		}

		const response = await this.client.createRecord("pa_collection_jobs", jobData)

		if (!response.success) {
		// Fallback message if table doesn't exist
		return {
		content: [
		{
		type: "text",
		text: `⚠️ PA Data Collection initiated!

		📊 Indicator: ${args.indicator}
		${args.start_date ? `📅 Start: ${args.start_date}` : ""}
		${args.end_date ? `📅 End: ${args.end_date}` : ""}
		🔄 Recalculate: ${args.recalculate ? "Yes" : "No"}

		✨ Data collection job queued. Check PA dashboard for results.`,
		},
		],
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ PA Data Collection started!

		🆔 Job ID: ${response.data.sys_id}
		📊 Indicator: ${args.indicator}
		📅 Range: ${args.start_date \|\| "Default"} to ${args.end_date \|\| "Current"}
		🔄 Recalculate: ${args.recalculate ? "Yes" : "No"}

		✨ Collection job running in background!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to collect PA data:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to collect PA data: ${error}`)
		}
		}

		private async discoverPAIndicators(args: any) {
		try {
		this.logger.info("Discovering PA indicators...")

		let query = ""
		if (args.table) {
		query = `table=${args.table}`
		}
		if (args.active_only) {
		query += query ? "^" : ""
		query += "active=true"
		}

		const response = await this.client.searchRecords("pa_indicators", query, 50)
		if (!response.success) {
		throw new Error("Failed to discover PA indicators")
		}

		const indicators = response.data.result

		if (!indicators.length) {
		return {
		content: [
		{
		type: "text",
		text: "❌ No PA indicators found",
		},
		],
		}
		}

		const indicatorList = indicators
		.map(
		(ind: any) =>
		`📊 ${ind.name} ${ind.active ? "✅" : "❌"}
		📋 Table: ${ind.table}
		📈 Type: ${ind.aggregate}${ind.field ? ` (${ind.field})` : ""}
		⏰ Frequency: ${ind.frequency}
		🎯 Target: ${ind.target \|\| "Not set"}`,
		)
		.join("\n\n")

		return {
		content: [
		{
		type: "text",
		text: `🔍 Performance Analytics Indicators:

		${indicatorList}

		✨ Found ${indicators.length} indicator(s)`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover PA indicators:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover PA indicators: ${error}`)
		}
		}

		async run() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)
		this.logger.info("ServiceNow Change/VA/PA MCP Server running on stdio")
		}
		}

		const server = new ServiceNowChangeVirtualAgentPAMCP()
		server.run().catch(console.error)

-1311

src/servicenow/ser...mdb-event-hr-csm-devops-mcp-enhanced.ts

		#!/usr/bin/env node
		/**
		* ServiceNow CMDB, Event Management, HR, CSM & DevOps MCP Server - ENHANCED VERSION
		* With logging, token tracking, and progress indicators
		*/

		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { EnhancedBaseMCPServer, MCPToolResult } from "./shared/enhanced-base-mcp-server.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"

		class ServiceNowCMDBEventHRCSMDevOpsMCPEnhanced extends EnhancedBaseMCPServer {
		private config: ReturnType<typeof mcpConfig.getConfig>

		constructor() {
		super("servicenow-cmdb-event-hr-csm-devops-enhanced", "2.0.0")
		this.config = mcpConfig.getConfig()
		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		// CMDB & Discovery Tools
		{
		name: "snow_create_cmdb_ci",
		description: "Creates configuration item in CMDB using cmdb_ci_* tables.",
		inputSchema: {
		type: "object",
		properties: {
		ci_class: { type: "string", description: "CI class (e.g., cmdb_ci_server, cmdb_ci_appl)" },
		name: { type: "string", description: "CI name" },
		asset_tag: { type: "string", description: "Asset tag" },
		serial_number: { type: "string", description: "Serial number" },
		model_id: { type: "string", description: "Model sys_id" },
		location: { type: "string", description: "Location sys_id" },
		operational_status: { type: "string", description: "Status: operational, non-operational" },
		attributes: { type: "object", description: "Additional CI attributes" },
		},
		required: ["ci_class", "name"],
		},
		},
		{
		name: "snow_create_ci_relationship",
		description: "Creates CI relationship using cmdb_rel_ci table.",
		inputSchema: {
		type: "object",
		properties: {
		parent: { type: "string", description: "Parent CI sys_id" },
		child: { type: "string", description: "Child CI sys_id" },
		type: { type: "string", description: "Relationship type sys_id" },
		description: { type: "string", description: "Relationship description" },
		},
		required: ["parent", "child", "type"],
		},
		},
		{
		name: "snow_discover_ci_dependencies",
		description: "Discovers CI dependencies from cmdb_rel_ci table.",
		inputSchema: {
		type: "object",
		properties: {
		ci_sys_id: { type: "string", description: "CI sys_id" },
		depth: { type: "number", default: 2, description: "Dependency depth" },
		direction: { type: "string", description: "upstream, downstream, both" },
		},
		required: ["ci_sys_id"],
		},
		},
		{
		name: "snow_run_discovery",
		description: "Runs discovery schedule using discovery_status table.",
		inputSchema: {
		type: "object",
		properties: {
		schedule_sys_id: { type: "string", description: "Discovery schedule sys_id" },
		ip_range: { type: "string", description: "IP range to discover" },
		mid_server: { type: "string", description: "MID server sys_id" },
		},
		required: ["schedule_sys_id"],
		},
		},
		{
		name: "snow_get_discovery_status",
		description: "Gets discovery status from discovery_status table.",
		inputSchema: {
		type: "object",
		properties: {
		schedule_sys_id: { type: "string", description: "Discovery schedule sys_id" },
		limit: { type: "number", default: 10 },
		},
		},
		},
		{
		name: "snow_import_cmdb_data",
		description: "Imports CMDB data using sys_import_set table.",
		inputSchema: {
		type: "object",
		properties: {
		table_name: { type: "string", description: "Target table" },
		data: { type: "array", items: { type: "object" }, description: "Data to import" },
		transform_map: { type: "string", description: "Transform map sys_id" },
		},
		required: ["table_name", "data"],
		},
		},
		// Event Management Tools
		{
		name: "snow_create_event",
		description: "Creates event using em_event table.",
		inputSchema: {
		type: "object",
		properties: {
		source: { type: "string", description: "Event source" },
		node: { type: "string", description: "Node/CI" },
		type: { type: "string", description: "Event type" },
		severity: { type: "string", description: "1-critical to 5-info" },
		description: { type: "string", description: "Event description" },
		message_key: { type: "string", description: "Unique message key" },
		metric_name: { type: "string", description: "Metric name" },
		resource: { type: "string", description: "Resource identifier" },
		},
		required: ["source", "node", "type", "severity"],
		},
		},
		{
		name: "snow_create_alert_rule",
		description: "Creates alert rule using em_alert_rule table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Rule name" },
		condition: { type: "string", description: "Alert condition" },
		threshold: { type: "number", description: "Threshold value" },
		action: { type: "string", description: "Action to take" },
		active: { type: "boolean", default: true },
		},
		required: ["name", "condition"],
		},
		},
		{
		name: "snow_correlate_alerts",
		description: "Correlates alerts using em_alert table.",
		inputSchema: {
		type: "object",
		properties: {
		alerts: { type: "array", items: { type: "string" }, description: "Alert sys_ids" },
		correlation_rule: { type: "string", description: "Rule sys_id" },
		create_incident: { type: "boolean", default: false },
		},
		required: ["alerts"],
		},
		},
		{
		name: "snow_get_event_metrics",
		description: "Gets event metrics from em_event table.",
		inputSchema: {
		type: "object",
		properties: {
		source: { type: "string", description: "Filter by source" },
		node: { type: "string", description: "Filter by node" },
		time_range: { type: "string", description: "Time range" },
		group_by: { type: "string", description: "Group by field" },
		},
		},
		},
		// HR Service Delivery Tools
		{
		name: "snow_create_hr_case",
		description: "Creates HR case using sn_hr_core_case table.",
		inputSchema: {
		type: "object",
		properties: {
		subject_person: { type: "string", description: "Employee sys_id" },
		short_description: { type: "string", description: "Case description" },
		category: { type: "string", description: "HR category" },
		subcategory: { type: "string", description: "HR subcategory" },
		priority: { type: "string", description: "Priority level" },
		confidential: { type: "boolean", default: false },
		hr_service: { type: "string", description: "HR service sys_id" },
		},
		required: ["subject_person", "short_description"],
		},
		},
		{
		name: "snow_manage_onboarding",
		description: "Manages employee onboarding using sn_hr_core_task table.",
		inputSchema: {
		type: "object",
		properties: {
		employee_sys_id: { type: "string", description: "New employee sys_id" },
		start_date: { type: "string", description: "Start date" },
		department: { type: "string", description: "Department sys_id" },
		manager: { type: "string", description: "Manager sys_id" },
		tasks: { type: "array", items: { type: "object" }, description: "Onboarding tasks" },
		},
		required: ["employee_sys_id", "start_date"],
		},
		},
		{
		name: "snow_manage_offboarding",
		description: "Manages employee offboarding using sn_hr_core_task table.",
		inputSchema: {
		type: "object",
		properties: {
		employee_sys_id: { type: "string", description: "Employee sys_id" },
		last_day: { type: "string", description: "Last working day" },
		reason: { type: "string", description: "Departure reason" },
		tasks: { type: "array", items: { type: "object" }, description: "Offboarding tasks" },
		},
		required: ["employee_sys_id", "last_day"],
		},
		},
		{
		name: "snow_get_hr_analytics",
		description: "Gets HR analytics from sn_hr_core_case table.",
		inputSchema: {
		type: "object",
		properties: {
		metric: { type: "string", description: "case_volume, resolution_time, satisfaction" },
		time_range: { type: "string", description: "Analysis period" },
		department: { type: "string", description: "Filter by department" },
		},
		required: ["metric"],
		},
		},
		// Customer Service Management Tools
		{
		name: "snow_create_csm_case",
		description: "Creates customer service case using sn_customerservice_case table.",
		inputSchema: {
		type: "object",
		properties: {
		account: { type: "string", description: "Customer account sys_id" },
		contact: { type: "string", description: "Contact sys_id" },
		short_description: { type: "string", description: "Case description" },
		category: { type: "string", description: "Case category" },
		product: { type: "string", description: "Product sys_id" },
		priority: { type: "string", description: "Priority level" },
		channel: { type: "string", description: "Contact channel" },
		},
		required: ["account", "short_description"],
		},
		},
		{
		name: "snow_manage_customer_account",
		description: "Manages customer account using sn_customerservice_account table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Account name" },
		industry: { type: "string", description: "Industry type" },
		tier: { type: "string", description: "Customer tier" },
		annual_revenue: { type: "number", description: "Annual revenue" },
		primary_contact: { type: "string", description: "Primary contact sys_id" },
		},
		required: ["name"],
		},
		},
		{
		name: "snow_create_csm_communication",
		description: "Creates customer communication using sn_customerservice_communication table.",
		inputSchema: {
		type: "object",
		properties: {
		case_sys_id: { type: "string", description: "Case sys_id" },
		type: { type: "string", description: "email, phone, chat" },
		direction: { type: "string", description: "inbound, outbound" },
		subject: { type: "string", description: "Communication subject" },
		body: { type: "string", description: "Message content" },
		},
		required: ["case_sys_id", "type", "body"],
		},
		},
		{
		name: "snow_get_customer_satisfaction",
		description: "Gets CSAT metrics from sn_customerservice_csat table.",
		inputSchema: {
		type: "object",
		properties: {
		account: { type: "string", description: "Filter by account" },
		time_range: { type: "string", description: "Analysis period" },
		include_comments: { type: "boolean", default: false },
		},
		},
		},
		// DevOps Tools
		{
		name: "snow_create_devops_pipeline",
		description: "Creates DevOps pipeline using sn_devops_pipeline table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Pipeline name" },
		application: { type: "string", description: "Application sys_id" },
		stages: { type: "array", items: { type: "object" }, description: "Pipeline stages" },
		repository: { type: "string", description: "Repository URL" },
		branch: { type: "string", description: "Branch name" },
		},
		required: ["name", "application"],
		},
		},
		{
		name: "snow_track_deployment",
		description: "Tracks deployment using sn_devops_deployment table.",
		inputSchema: {
		type: "object",
		properties: {
		pipeline: { type: "string", description: "Pipeline sys_id" },
		environment: { type: "string", description: "Target environment" },
		version: { type: "string", description: "Version number" },
		status: { type: "string", description: "Deployment status" },
		change_request: { type: "string", description: "Associated change" },
		},
		required: ["pipeline", "environment", "version"],
		},
		},
		{
		name: "snow_manage_devops_change",
		description: "Manages DevOps change using sn_devops_change table.",
		inputSchema: {
		type: "object",
		properties: {
		pipeline: { type: "string", description: "Pipeline sys_id" },
		deployment: { type: "string", description: "Deployment sys_id" },
		auto_approve: { type: "boolean", default: false },
		validation_results: { type: "object", description: "Validation data" },
		},
		required: ["pipeline", "deployment"],
		},
		},
		{
		name: "snow_get_velocity_metrics",
		description: "Gets team velocity from sn_devops_velocity table.",
		inputSchema: {
		type: "object",
		properties: {
		team: { type: "string", description: "Team sys_id" },
		sprint: { type: "string", description: "Sprint identifier" },
		time_range: { type: "string", description: "Analysis period" },
		},
		},
		},
		{
		name: "snow_create_devops_artifact",
		description: "Creates build artifact using sn_devops_artifact table.",
		inputSchema: {
		type: "object",
		properties: {
		pipeline: { type: "string", description: "Pipeline sys_id" },
		build_number: { type: "string", description: "Build number" },
		artifact_type: { type: "string", description: "Artifact type" },
		repository_url: { type: "string", description: "Artifact location" },
		checksum: { type: "string", description: "Artifact checksum" },
		},
		required: ["pipeline", "build_number"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Execute with enhanced tracking
		return await this.executeTool(name, async () => {
		switch (name) {
		// CMDB & Discovery
		case "snow_create_cmdb_ci":
		return await this.createCMDBCI(args as any)
		case "snow_create_ci_relationship":
		return await this.createCIRelationship(args as any)
		case "snow_discover_ci_dependencies":
		return await this.discoverCIDependencies(args as any)
		case "snow_run_discovery":
		return await this.runDiscovery(args as any)
		case "snow_get_discovery_status":
		return await this.getDiscoveryStatus(args as any)
		case "snow_import_cmdb_data":
		return await this.importCMDBData(args as any)
		// Event Management
		case "snow_create_event":
		return await this.createEvent(args as any)
		case "snow_create_alert_rule":
		return await this.createAlertRule(args as any)
		case "snow_correlate_alerts":
		return await this.correlateAlerts(args as any)
		case "snow_get_event_metrics":
		return await this.getEventMetrics(args as any)
		// HR Service Delivery
		case "snow_create_hr_case":
		return await this.createHRCase(args as any)
		case "snow_manage_onboarding":
		return await this.manageOnboarding(args as any)
		case "snow_manage_offboarding":
		return await this.manageOffboarding(args as any)
		case "snow_get_hr_analytics":
		return await this.getHRAnalytics(args as any)
		// Customer Service Management
		case "snow_create_csm_case":
		return await this.createCSMCase(args as any)
		case "snow_manage_customer_account":
		return await this.manageCustomerAccount(args as any)
		case "snow_create_csm_communication":
		return await this.createCSMCommunication(args as any)
		case "snow_get_customer_satisfaction":
		return await this.getCustomerSatisfaction(args as any)
		// DevOps
		case "snow_create_devops_pipeline":
		return await this.createDevOpsPipeline(args as any)
		case "snow_track_deployment":
		return await this.trackDeployment(args as any)
		case "snow_manage_devops_change":
		return await this.manageDevOpsChange(args as any)
		case "snow_get_velocity_metrics":
		return await this.getVelocityMetrics(args as any)
		case "snow_create_devops_artifact":
		return await this.createDevOpsArtifact(args as any)
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}
		})
		} catch (error) {
		if (error instanceof McpError) throw error
		throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error}`)
		}
		})
		}

		// CMDB & Discovery Methods

		private async createCMDBCI(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating CMDB CI...", {
		ci_class: args.ci_class,
		name: args.name,
		})

		const ciData = {
		name: args.name,
		asset_tag: args.asset_tag \|\| "",
		serial_number: args.serial_number \|\| "",
		model_id: args.model_id \|\| "",
		location: args.location \|\| "",
		operational_status: args.operational_status \|\| "operational",
		...args.attributes,
		}

		this.logger.progress(`Creating CI in ${args.ci_class}...`)
		const response = await this.createRecord(args.ci_class, ciData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create CI: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ CI created", {
		sys_id: result.sys_id,
		name: args.name,
		})

		return this.createResponse(
		`✅ Configuration Item created!
		🖥️ ${args.name}
		📦 Class: ${args.ci_class}
		🏷️ Asset Tag: ${args.asset_tag \|\| "N/A"}
		📍 Location: ${args.location \|\| "N/A"}
		🆔 sys_id: ${result.sys_id}

		✨ CI added to CMDB!`,
		)
		}

		private async createCIRelationship(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating CI relationship...", {
		parent: args.parent,
		child: args.child,
		})

		const relData = {
		parent: args.parent,
		child: args.child,
		type: args.type,
		description: args.description \|\| "",
		}

		this.logger.progress("Creating relationship...")
		const response = await this.createRecord("cmdb_rel_ci", relData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create relationship: ${response.error}`)
		}

		this.logger.info("✅ Relationship created")
		return this.createResponse(
		`✅ CI Relationship created!
		🔗 Parent → Child
		📝 Type: ${args.type}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async discoverCIDependencies(args: any): Promise<MCPToolResult> {
		this.logger.info("Discovering CI dependencies...", {
		ci_sys_id: args.ci_sys_id,
		depth: args.depth,
		})

		const direction = args.direction \|\| "both"
		let query = ""

		if (direction === "upstream" \|\| direction === "both") {
		query = `child=${args.ci_sys_id}`
		}
		if (direction === "downstream" \|\| direction === "both") {
		query += query ? `^ORparent=${args.ci_sys_id}` : `parent=${args.ci_sys_id}`
		}

		this.logger.progress("Analyzing dependencies...")
		const response = await this.queryTable("cmdb_rel_ci", query, 100)

		if (!response.success) {
		return this.createResponse(`❌ Failed to discover dependencies: ${response.error}`)
		}

		const relationships = response.data.result
		this.logger.info(`Found ${relationships.length} dependencies`)

		const depList = relationships
		.map((rel: any) => `🔗 ${rel.parent.display_value} → ${rel.child.display_value} (${rel.type.display_value})`)
		.join("\n")

		return this.createResponse(`🔍 CI Dependencies:\n\n${depList}\n\n✨ Total: ${relationships.length} relationship(s)`)
		}

		private async runDiscovery(args: any): Promise<MCPToolResult> {
		this.logger.info("Running discovery...", {
		schedule_sys_id: args.schedule_sys_id,
		})

		const discoveryData = {
		schedule: args.schedule_sys_id,
		ip_range: args.ip_range \|\| "",
		mid_server: args.mid_server \|\| "",
		state: "starting",
		started: new Date().toISOString(),
		}

		this.logger.progress("Initiating discovery...")
		const response = await this.createRecord("discovery_status", discoveryData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to start discovery: ${response.error}`)
		}

		this.logger.info("✅ Discovery started")
		return this.createResponse(
		`✅ Discovery started!
		🔍 Schedule: ${args.schedule_sys_id}
		🌐 IP Range: ${args.ip_range \|\| "Default"}
		🖥️ MID Server: ${args.mid_server \|\| "Auto-select"}
		🆔 Status ID: ${response.data.sys_id}

		⏳ Discovery in progress...`,
		)
		}

		private async getDiscoveryStatus(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting discovery status...")

		let query = ""
		if (args.schedule_sys_id) {
		query = `schedule=${args.schedule_sys_id}`
		}

		const response = await this.queryTable("discovery_status", query, args.limit \|\| 10)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get status: ${response.error}`)
		}

		const statuses = response.data.result

		if (!statuses.length) {
		return this.createResponse(`❌ No discovery status found`)
		}

		const statusList = statuses
		.map(
		(status: any) =>
		`🔍 ${status.schedule?.display_value \|\| "Discovery"}
		📊 State: ${status.state}
		⏰ Started: ${status.started}
		🎯 Discovered: ${status.devices_discovered \|\| 0} devices`,
		)
		.join("\n\n")

		return this.createResponse(`📊 Discovery Status:\n\n${statusList}\n\n✨ ${statuses.length} discovery run(s)`)
		}

		private async importCMDBData(args: any): Promise<MCPToolResult> {
		this.logger.info("Importing CMDB data...", {
		table_name: args.table_name,
		records: args.data.length,
		})

		const importSetData = {
		table_name: args.table_name,
		import_set_table: `u_import_${args.table_name}`,
		transform_map: args.transform_map \|\| "",
		state: "loading",
		}

		this.logger.progress("Creating import set...")
		const importSet = await this.createRecord("sys_import_set", importSetData)

		if (!importSet.success) {
		return this.createResponse(`❌ Failed to create import set: ${importSet.error}`)
		}

		// Import data records
		let imported = 0
		for (const record of args.data) {
		const importRecord = await this.createRecord(importSetData.import_set_table, {
		...record,
		sys_import_set: importSet.data.sys_id,
		})
		if (importRecord.success) imported++
		}

		this.logger.info(`✅ Imported ${imported} records`)
		return this.createResponse(
		`✅ CMDB Import completed!
		📋 Table: ${args.table_name}
		📊 Records: ${imported}/${args.data.length}
		🆔 Import Set: ${importSet.data.sys_id}

		✨ Data imported successfully!`,
		)
		}

		// Event Management Methods

		private async createEvent(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating event...", {
		source: args.source,
		severity: args.severity,
		})

		const eventData = {
		source: args.source,
		node: args.node,
		type: args.type,
		severity: args.severity,
		description: args.description \|\| "",
		message_key: args.message_key \|\| `${args.source}_${Date.now()}`,
		metric_name: args.metric_name \|\| "",
		resource: args.resource \|\| "",
		time_of_event: new Date().toISOString(),
		}

		this.logger.progress("Creating event...")
		const response = await this.createRecord("em_event", eventData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create event: ${response.error}`)
		}

		this.logger.info("✅ Event created")
		return this.createResponse(
		`✅ Event created!
		🚨 Source: ${args.source}
		📊 Severity: ${args.severity}
		🖥️ Node: ${args.node}
		🔑 Message Key: ${eventData.message_key}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async createAlertRule(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating alert rule...", { name: args.name })

		const ruleData = {
		name: args.name,
		condition: args.condition,
		threshold: args.threshold \|\| 0,
		action: args.action \|\| "",
		active: args.active !== false,
		}

		this.logger.progress("Creating rule...")
		const response = await this.createRecord("em_alert_rule", ruleData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create rule: ${response.error}`)
		}

		this.logger.info("✅ Alert rule created")
		return this.createResponse(
		`✅ Alert rule created!
		📋 ${args.name}
		🔍 Condition: ${args.condition}
		⚠️ Threshold: ${args.threshold \|\| "N/A"}
		✅ Active: ${args.active !== false}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async correlateAlerts(args: any): Promise<MCPToolResult> {
		this.logger.info("Correlating alerts...", {
		alerts: args.alerts.length,
		})

		const correlationData = {
		alerts: args.alerts.join(","),
		correlation_rule: args.correlation_rule \|\| "",
		correlation_id: `CORR_${Date.now()}`,
		state: "correlated",
		}

		this.logger.progress("Correlating alerts...")

		// Update alerts with correlation ID
		for (const alertId of args.alerts) {
		await this.updateRecord("em_alert", alertId, {
		correlation_id: correlationData.correlation_id,
		})
		}

		if (args.create_incident) {
		// Create incident from correlated alerts
		const incidentData = {
		short_description: `Correlated Alert: ${correlationData.correlation_id}`,
		description: `Correlated ${args.alerts.length} alerts`,
		priority: "2",
		category: "event",
		}

		const incident = await this.createRecord("incident", incidentData)

		if (incident.success) {
		return this.createResponse(
		`✅ Alerts correlated & incident created!
		🔗 Correlation ID: ${correlationData.correlation_id}
		📊 Alerts: ${args.alerts.length}
		🎫 Incident: ${incident.data.number}`,
		)
		}
		}

		this.logger.info("✅ Alerts correlated")
		return this.createResponse(
		`✅ Alerts correlated!
		🔗 Correlation ID: ${correlationData.correlation_id}
		📊 Correlated: ${args.alerts.length} alerts`,
		)
		}

		private async getEventMetrics(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting event metrics...")

		let query = ""
		if (args.source) query += `source=${args.source}`
		if (args.node) query += `^node=${args.node}`

		this.logger.progress("Analyzing events...")
		const response = await this.queryTable("em_event", query, 100)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get metrics: ${response.error}`)
		}

		const events = response.data.result

		// Calculate metrics
		const severityCounts: any = { "1": 0, "2": 0, "3": 0, "4": 0, "5": 0 }
		events.forEach((event: any) => {
		severityCounts[event.severity] = (severityCounts[event.severity] \|\| 0) + 1
		})

		return this.createResponse(
		`📊 Event Metrics:
		🚨 Critical: ${severityCounts["1"]}
		⚠️ Major: ${severityCounts["2"]}
		⚡ Minor: ${severityCounts["3"]}
		ℹ️ Warning: ${severityCounts["4"]}
		📝 Info: ${severityCounts["5"]}

		✨ Total: ${events.length} events`,
		)
		}

		// HR Service Delivery Methods

		private async createHRCase(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating HR case...", {
		subject_person: args.subject_person,
		category: args.category,
		})

		const caseData = {
		subject_person: args.subject_person,
		short_description: args.short_description,
		category: args.category \|\| "",
		subcategory: args.subcategory \|\| "",
		priority: args.priority \|\| "3",
		confidential: args.confidential \|\| false,
		hr_service: args.hr_service \|\| "",
		state: "new",
		}

		this.logger.progress("Creating HR case...")
		const response = await this.createRecord("sn_hr_core_case", caseData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create HR case: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ HR case created", { number: result.number })

		return this.createResponse(
		`✅ HR Case created!
		📋 ${result.number}
		👤 Employee: ${args.subject_person}
		📁 Category: ${args.category \|\| "General"}
		🔒 Confidential: ${args.confidential ? "Yes" : "No"}
		🆔 sys_id: ${result.sys_id}

		✨ HR case ready for processing!`,
		)
		}

		private async manageOnboarding(args: any): Promise<MCPToolResult> {
		this.logger.info("Managing onboarding...", {
		employee: args.employee_sys_id,
		start_date: args.start_date,
		})

		// Create onboarding case
		const onboardingCase = await this.createRecord("sn_hr_core_case", {
		subject_person: args.employee_sys_id,
		short_description: `Onboarding - Start Date: ${args.start_date}`,
		category: "onboarding",
		hr_service: "employee_onboarding",
		state: "in_progress",
		})

		if (!onboardingCase.success) {
		return this.createResponse(`❌ Failed to create onboarding: ${onboardingCase.error}`)
		}

		// Create onboarding tasks
		const tasks = args.tasks \|\| [
		{ name: "Provision equipment", days_before: 3 },
		{ name: "Create accounts", days_before: 2 },
		{ name: "Schedule orientation", days_before: 1 },
		]

		let createdTasks = 0
		for (const task of tasks) {
		const taskData = {
		parent: onboardingCase.data.sys_id,
		short_description: task.name,
		assigned_to: task.assigned_to \|\| "",
		due_date: task.due_date \|\| args.start_date,
		}

		const taskResult = await this.createRecord("sn_hr_core_task", taskData)
		if (taskResult.success) createdTasks++
		}

		this.logger.info("✅ Onboarding created", {
		case: onboardingCase.data.number,
		tasks: createdTasks,
		})

		return this.createResponse(
		`✅ Onboarding initiated!
		📋 Case: ${onboardingCase.data.number}
		👤 Employee: ${args.employee_sys_id}
		📅 Start Date: ${args.start_date}
		🏢 Department: ${args.department \|\| "TBD"}
		👨‍💼 Manager: ${args.manager \|\| "TBD"}
		📌 Tasks Created: ${createdTasks}

		✨ Onboarding process started!`,
		)
		}

		private async manageOffboarding(args: any): Promise<MCPToolResult> {
		this.logger.info("Managing offboarding...", {
		employee: args.employee_sys_id,
		last_day: args.last_day,
		})

		// Create offboarding case
		const offboardingCase = await this.createRecord("sn_hr_core_case", {
		subject_person: args.employee_sys_id,
		short_description: `Offboarding - Last Day: ${args.last_day}`,
		category: "offboarding",
		hr_service: "employee_offboarding",
		u_reason: args.reason \|\| "",
		state: "in_progress",
		})

		if (!offboardingCase.success) {
		return this.createResponse(`❌ Failed to create offboarding: ${offboardingCase.error}`)
		}

		// Create offboarding tasks
		const tasks = args.tasks \|\| [
		{ name: "Collect equipment", days_after: 0 },
		{ name: "Revoke access", days_after: 1 },
		{ name: "Exit interview", days_before: 1 },
		]

		let createdTasks = 0
		for (const task of tasks) {
		const taskResult = await this.createRecord("sn_hr_core_task", {
		parent: offboardingCase.data.sys_id,
		short_description: task.name,
		})
		if (taskResult.success) createdTasks++
		}

		this.logger.info("✅ Offboarding created")
		return this.createResponse(
		`✅ Offboarding initiated!
		📋 Case: ${offboardingCase.data.number}
		👤 Employee: ${args.employee_sys_id}
		📅 Last Day: ${args.last_day}
		📝 Reason: ${args.reason \|\| "Not specified"}
		📌 Tasks Created: ${createdTasks}

		✨ Offboarding process started!`,
		)
		}

		private async getHRAnalytics(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting HR analytics...", { metric: args.metric })

		let query = ""
		if (args.department) query = `department=${args.department}`

		const response = await this.queryTable("sn_hr_core_case", query, 100)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get analytics: ${response.error}`)
		}

		const cases = response.data.result

		if (args.metric === "case_volume") {
		const categoryCounts: any = {}
		cases.forEach((c: any) => {
		categoryCounts[c.category] = (categoryCounts[c.category] \|\| 0) + 1
		})

		const breakdown = Object.entries(categoryCounts)
		.map(([cat, count]) => ` ${cat}: ${count}`)
		.join("\n")

		return this.createResponse(`📊 HR Case Volume:\n${breakdown}\n\n✨ Total: ${cases.length} cases`)
		}

		return this.createResponse(
		`📊 HR Analytics:
		📋 Total Cases: ${cases.length}
		📈 Metric: ${args.metric}
		📅 Period: ${args.time_range \|\| "All time"}`,
		)
		}

		// Customer Service Management Methods

		private async createCSMCase(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating customer case...", {
		account: args.account,
		short_description: args.short_description,
		})

		const caseData = {
		account: args.account,
		contact: args.contact \|\| "",
		short_description: args.short_description,
		category: args.category \|\| "",
		product: args.product \|\| "",
		priority: args.priority \|\| "3",
		channel: args.channel \|\| "web",
		state: "new",
		}

		this.logger.progress("Creating customer case...")
		const response = await this.createRecord("sn_customerservice_case", caseData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create case: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ Customer case created", { number: result.number })

		return this.createResponse(
		`✅ Customer Case created!
		📋 ${result.number}
		🏢 Account: ${args.account}
		📝 ${args.short_description}
		📱 Channel: ${args.channel \|\| "Web"}
		🆔 sys_id: ${result.sys_id}

		✨ Case ready for support team!`,
		)
		}

		private async manageCustomerAccount(args: any): Promise<MCPToolResult> {
		this.logger.info("Managing customer account...", { name: args.name })

		const accountData = {
		name: args.name,
		industry: args.industry \|\| "",
		tier: args.tier \|\| "standard",
		annual_revenue: args.annual_revenue \|\| 0,
		primary_contact: args.primary_contact \|\| "",
		}

		this.logger.progress("Creating/updating account...")
		const response = await this.createRecord("sn_customerservice_account", accountData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to manage account: ${response.error}`)
		}

		this.logger.info("✅ Account managed")
		return this.createResponse(
		`✅ Customer Account created!
		🏢 ${args.name}
		🏭 Industry: ${args.industry \|\| "N/A"}
		⭐ Tier: ${args.tier \|\| "Standard"}
		💰 Revenue: ${args.annual_revenue \|\| "N/A"}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async createCSMCommunication(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating communication...", {
		case_sys_id: args.case_sys_id,
		type: args.type,
		})

		const commData = {
		case: args.case_sys_id,
		type: args.type,
		direction: args.direction \|\| "outbound",
		subject: args.subject \|\| "",
		body: args.body,
		created: new Date().toISOString(),
		}

		this.logger.progress("Recording communication...")
		const response = await this.createRecord("sn_customerservice_communication", commData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create communication: ${response.error}`)
		}

		this.logger.info("✅ Communication recorded")
		return this.createResponse(
		`✅ Communication recorded!
		📧 Type: ${args.type}
		📤 Direction: ${args.direction \|\| "Outbound"}
		📝 Subject: ${args.subject \|\| "N/A"}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async getCustomerSatisfaction(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting CSAT metrics...")

		let query = ""
		if (args.account) query = `account=${args.account}`

		const response = await this.queryTable("sn_customerservice_csat", query, 100)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get CSAT: ${response.error}`)
		}

		const surveys = response.data.result

		if (!surveys.length) {
		return this.createResponse(`❌ No CSAT data found`)
		}

		// Calculate average CSAT
		const scores = surveys.map((s: any) => parseFloat(s.score \|\| 0))
		const avgScore = (scores.reduce((a, b) => a + b, 0) / scores.length).toFixed(1)

		let result = `📊 Customer Satisfaction:
		⭐ Average Score: ${avgScore}/5
		📋 Responses: ${surveys.length}
		📅 Period: ${args.time_range \|\| "All time"}`

		if (args.include_comments) {
		const comments = surveys
		.filter((s: any) => s.comments)
		.slice(0, 3)
		.map((s: any) => ` 💬 "${s.comments}"`)
		.join("\n")

		if (comments) {
		result += `\n\nRecent Comments:\n${comments}`
		}
		}

		return this.createResponse(result)
		}

		// DevOps Methods

		private async createDevOpsPipeline(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating DevOps pipeline...", {
		name: args.name,
		application: args.application,
		})

		const pipelineData = {
		name: args.name,
		application: args.application,
		stages: JSON.stringify(args.stages \|\| []),
		repository: args.repository \|\| "",
		branch: args.branch \|\| "main",
		active: true,
		}

		this.logger.progress("Creating pipeline...")
		const response = await this.createRecord("sn_devops_pipeline", pipelineData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create pipeline: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ Pipeline created", { sys_id: result.sys_id })

		return this.createResponse(
		`✅ DevOps Pipeline created!
		🚀 ${args.name}
		📱 Application: ${args.application}
		📦 Repository: ${args.repository \|\| "N/A"}
		🌿 Branch: ${args.branch \|\| "main"}
		📊 Stages: ${args.stages?.length \|\| 0}
		🆔 sys_id: ${result.sys_id}

		✨ Pipeline ready for deployments!`,
		)
		}

		private async trackDeployment(args: any): Promise<MCPToolResult> {
		this.logger.info("Tracking deployment...", {
		pipeline: args.pipeline,
		environment: args.environment,
		version: args.version,
		})

		const deploymentData = {
		pipeline: args.pipeline,
		environment: args.environment,
		version: args.version,
		status: args.status \|\| "in_progress",
		change_request: args.change_request \|\| "",
		deployed_on: new Date().toISOString(),
		}

		this.logger.progress("Recording deployment...")
		const response = await this.createRecord("sn_devops_deployment", deploymentData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to track deployment: ${response.error}`)
		}

		this.logger.info("✅ Deployment tracked")
		return this.createResponse(
		`✅ Deployment tracked!
		🚀 Version: ${args.version}
		🌍 Environment: ${args.environment}
		📊 Status: ${args.status \|\| "In Progress"}
		🔄 Change: ${args.change_request \|\| "N/A"}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async manageDevOpsChange(args: any): Promise<MCPToolResult> {
		this.logger.info("Managing DevOps change...", {
		pipeline: args.pipeline,
		deployment: args.deployment,
		})

		const changeData = {
		pipeline: args.pipeline,
		deployment: args.deployment,
		auto_approve: args.auto_approve \|\| false,
		validation_results: JSON.stringify(args.validation_results \|\| {}),
		state: args.auto_approve ? "approved" : "pending",
		}

		this.logger.progress("Processing change...")
		const response = await this.createRecord("sn_devops_change", changeData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to manage change: ${response.error}`)
		}

		this.logger.info("✅ Change processed")
		return this.createResponse(
		`✅ DevOps change processed!
		🔄 Pipeline: ${args.pipeline}
		🚀 Deployment: ${args.deployment}
		✅ Auto-approve: ${args.auto_approve ? "Yes" : "No"}
		📊 State: ${args.auto_approve ? "Approved" : "Pending"}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async getVelocityMetrics(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting velocity metrics...")

		let query = ""
		if (args.team) query = `team=${args.team}`
		if (args.sprint) query += `^sprint=${args.sprint}`

		const response = await this.queryTable("sn_devops_velocity", query, 50)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get velocity: ${response.error}`)
		}

		const metrics = response.data.result

		if (!metrics.length) {
		return this.createResponse(`❌ No velocity data found`)
		}

		// Calculate velocity
		const storyPoints = metrics.map((m: any) => parseFloat(m.story_points \|\| 0))
		const avgVelocity = (storyPoints.reduce((a, b) => a + b, 0) / storyPoints.length).toFixed(1)

		return this.createResponse(
		`📊 Team Velocity:
		🚀 Average: ${avgVelocity} story points/sprint
		📈 Sprints: ${metrics.length}
		👥 Team: ${args.team \|\| "All teams"}
		📅 Period: ${args.time_range \|\| "Recent sprints"}

		✨ Velocity trending ${parseFloat(avgVelocity) > 20 ? "up" : "stable"}!`,
		)
		}

		private async createDevOpsArtifact(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating build artifact...", {
		pipeline: args.pipeline,
		build_number: args.build_number,
		})

		const artifactData = {
		pipeline: args.pipeline,
		build_number: args.build_number,
		artifact_type: args.artifact_type \|\| "build",
		repository_url: args.repository_url \|\| "",
		checksum: args.checksum \|\| "",
		created: new Date().toISOString(),
		}

		this.logger.progress("Recording artifact...")
		const response = await this.createRecord("sn_devops_artifact", artifactData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create artifact: ${response.error}`)
		}

		this.logger.info("✅ Artifact created")
		return this.createResponse(
		`✅ Build artifact recorded!
		📦 Build: #${args.build_number}
		🔧 Type: ${args.artifact_type \|\| "Build"}
		🔗 Repository: ${args.repository_url \|\| "N/A"}
		🔐 Checksum: ${args.checksum ? "✓" : "N/A"}
		🆔 sys_id: ${response.data.sys_id}

		✨ Artifact ready for deployment!`,
		)
		}

		async start() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)

		// Log ready state
		this.logger.info("🚀 ServiceNow CMDB, Event, HR, CSM & DevOps MCP Server (Enhanced) running")
		this.logger.info("📊 Token tracking enabled")
		this.logger.info("⏳ Progress indicators active")
		}
		}

		// Start the enhanced server
		const server = new ServiceNowCMDBEventHRCSMDevOpsMCPEnhanced()
		server.start().catch((error) => {
		console.error("Failed to start enhanced server:", error)
		process.exit(1)
		})

-1616

src/servicenow/servicenow-cmdb-event-hr-csm-devops-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow CMDB, Event Management, HR, CSM & DevOps MCP Server
		* Handles configuration management, events, HR services, customer service, and DevOps
		* Uses official ServiceNow REST APIs
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"
		import { MCPLogger } from "./shared/mcp-logger.js"

		class ServiceNowCMDBEventHRCSMDevOpsMCP {
		private server: Server
		private client: ServiceNowClient
		private logger: MCPLogger
		private config: ReturnType<typeof mcpConfig.getConfig>

		constructor() {
		this.server = new Server(
		{
		name: "servicenow-cmdb-event-hr-csm-devops",
		version: "1.0.0",
		},
		{
		capabilities: {
		tools: {},
		},
		},
		)

		this.client = new ServiceNowClient()
		this.logger = new MCPLogger("ServiceNowCMDBEventHRCSMDevOpsMCP")
		this.config = mcpConfig.getConfig()

		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		// Discovery & CMDB Tools
		{
		name: "snow_create_ci",
		description: "Creates a Configuration Item (CI) in the CMDB. CIs represent IT infrastructure components.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "CI name" },
		ci_class: { type: "string", description: "CI class (e.g., cmdb_ci_server, cmdb_ci_app_server)" },
		serial_number: { type: "string", description: "Serial number" },
		asset_tag: { type: "string", description: "Asset tag" },
		model: { type: "string", description: "Model reference" },
		manufacturer: { type: "string", description: "Manufacturer reference" },
		location: { type: "string", description: "Location reference" },
		assigned_to: { type: "string", description: "Assigned user" },
		operational_status: { type: "string", description: "Operational status" },
		attributes: { type: "object", description: "Additional CI attributes" },
		},
		required: ["name", "ci_class"],
		},
		},
		{
		name: "snow_create_ci_relationship",
		description: "Creates relationships between Configuration Items to map dependencies.",
		inputSchema: {
		type: "object",
		properties: {
		parent: { type: "string", description: "Parent CI sys_id" },
		child: { type: "string", description: "Child CI sys_id" },
		type: { type: "string", description: "Relationship type: Depends on, Hosted on, Runs on, Uses, etc." },
		description: { type: "string", description: "Relationship description" },
		},
		required: ["parent", "child", "type"],
		},
		},
		{
		name: "snow_run_discovery",
		description: "Initiates a Discovery scan to automatically find and map IT infrastructure.",
		inputSchema: {
		type: "object",
		properties: {
		schedule: { type: "string", description: "Discovery schedule name" },
		ip_range: { type: "string", description: "IP range to scan" },
		mid_server: { type: "string", description: "MID server to use" },
		patterns: { type: "array", items: { type: "string" }, description: "Discovery patterns to run" },
		credentials: { type: "string", description: "Credential set to use" },
		},
		required: ["schedule"],
		},
		},
		{
		name: "snow_get_ci_details",
		description: "Retrieves Configuration Item details including relationships and history.",
		inputSchema: {
		type: "object",
		properties: {
		ci_id: { type: "string", description: "CI sys_id or name" },
		include_relationships: { type: "boolean", description: "Include CI relationships", default: true },
		include_history: { type: "boolean", description: "Include change history", default: false },
		},
		required: ["ci_id"],
		},
		},
		{
		name: "snow_search_cmdb",
		description: "Searches the CMDB for Configuration Items with various filters.",
		inputSchema: {
		type: "object",
		properties: {
		query: { type: "string", description: "Search query" },
		ci_class: { type: "string", description: "Filter by CI class" },
		operational_status: { type: "string", description: "Filter by status" },
		location: { type: "string", description: "Filter by location" },
		limit: { type: "number", description: "Maximum results", default: 50 },
		},
		},
		},
		{
		name: "snow_impact_analysis",
		description: "Performs impact analysis to identify affected services when a CI changes.",
		inputSchema: {
		type: "object",
		properties: {
		ci_id: { type: "string", description: "CI to analyze" },
		depth: { type: "number", description: "Relationship depth to analyze", default: 3 },
		include_services: { type: "boolean", description: "Include business services", default: true },
		},
		required: ["ci_id"],
		},
		},

		// Event Management Tools
		{
		name: "snow_create_event",
		description:
		"Creates an event for Event Management processing. Events are raw data that get correlated into alerts.",
		inputSchema: {
		type: "object",
		properties: {
		source: { type: "string", description: "Event source system" },
		node: { type: "string", description: "Node (CI) affected" },
		type: { type: "string", description: "Event type" },
		severity: { type: "number", description: "Severity: 1-Critical, 2-Major, 3-Minor, 4-Warning, 5-Info" },
		description: { type: "string", description: "Event description" },
		additional_info: { type: "object", description: "Additional event data" },
		time_of_event: { type: "string", description: "Event timestamp" },
		resolution_state: { type: "string", description: "Resolution state" },
		},
		required: ["source", "node", "type", "severity", "description"],
		},
		},
		{
		name: "snow_create_alert",
		description: "Creates an alert directly or promotes events to alerts for incident creation.",
		inputSchema: {
		type: "object",
		properties: {
		source: { type: "string", description: "Alert source" },
		node: { type: "string", description: "Affected CI" },
		severity: { type: "number", description: "Alert severity" },
		description: { type: "string", description: "Alert description" },
		metric_name: { type: "string", description: "Metric that triggered alert" },
		threshold_value: { type: "string", description: "Threshold breached" },
		actual_value: { type: "string", description: "Actual value observed" },
		assignment_group: { type: "string", description: "Group to assign to" },
		},
		required: ["source", "node", "severity", "description"],
		},
		},
		{
		name: "snow_create_alert_rule",
		description: "Creates alert correlation rules to automatically group related events.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Rule name" },
		condition: { type: "string", description: "Correlation condition" },
		grouping_fields: { type: "array", items: { type: "string" }, description: "Fields to group by" },
		time_window: { type: "number", description: "Time window in seconds" },
		threshold: { type: "number", description: "Event count threshold" },
		action: { type: "string", description: "Action to take" },
		active: { type: "boolean", description: "Is rule active", default: true },
		},
		required: ["name", "condition"],
		},
		},
		{
		name: "snow_get_event_correlation",
		description: "Gets event correlation results showing how events are grouped into alerts.",
		inputSchema: {
		type: "object",
		properties: {
		alert_id: { type: "string", description: "Alert sys_id" },
		time_range: { type: "string", description: "Time range to check" },
		include_suppressed: { type: "boolean", description: "Include suppressed events", default: false },
		},
		},
		},

		// HR Service Delivery Tools
		{
		name: "snow_create_hr_case",
		description:
		"Creates an HR case for employee service requests like onboarding, benefits, or policy questions.",
		inputSchema: {
		type: "object",
		properties: {
		employee: { type: "string", description: "Employee sys_id or user name" },
		hr_service: { type: "string", description: "HR service type" },
		short_description: { type: "string", description: "Case summary" },
		description: { type: "string", description: "Detailed description" },
		priority: { type: "number", description: "Priority level" },
		category: { type: "string", description: "Case category: Benefits, Payroll, Leave, etc." },
		subcategory: { type: "string", description: "Case subcategory" },
		confidential: { type: "boolean", description: "Is case confidential", default: false },
		},
		required: ["employee", "hr_service", "short_description"],
		},
		},
		{
		name: "snow_create_hr_task",
		description: "Creates HR tasks for case fulfillment like document collection or approvals.",
		inputSchema: {
		type: "object",
		properties: {
		hr_case: { type: "string", description: "Parent HR case" },
		type: { type: "string", description: "Task type" },
		assigned_to: { type: "string", description: "HR agent assigned" },
		short_description: { type: "string", description: "Task description" },
		due_date: { type: "string", description: "Task due date" },
		instructions: { type: "string", description: "Task instructions" },
		},
		required: ["hr_case", "type", "short_description"],
		},
		},
		{
		name: "snow_employee_onboarding",
		description: "Initiates employee onboarding workflow with all necessary tasks and provisioning.",
		inputSchema: {
		type: "object",
		properties: {
		employee_name: { type: "string", description: "New employee name" },
		email: { type: "string", description: "Employee email" },
		start_date: { type: "string", description: "Start date" },
		department: { type: "string", description: "Department" },
		manager: { type: "string", description: "Manager sys_id or name" },
		job_title: { type: "string", description: "Job title" },
		location: { type: "string", description: "Work location" },
		equipment_needed: { type: "array", items: { type: "string" }, description: "Equipment to provision" },
		},
		required: ["employee_name", "email", "start_date", "department", "manager"],
		},
		},
		{
		name: "snow_employee_offboarding",
		description: "Initiates employee offboarding workflow to revoke access and collect assets.",
		inputSchema: {
		type: "object",
		properties: {
		employee: { type: "string", description: "Employee sys_id or user name" },
		last_date: { type: "string", description: "Last working date" },
		reason: { type: "string", description: "Offboarding reason" },
		assets_to_return: { type: "array", items: { type: "string" }, description: "Assets to collect" },
		knowledge_transfer: { type: "string", description: "Knowledge transfer plan" },
		},
		required: ["employee", "last_date", "reason"],
		},
		},

		// Customer Service Management Tools
		{
		name: "snow_create_customer_case",
		description: "Creates a customer service case for external customer support requests.",
		inputSchema: {
		type: "object",
		properties: {
		customer: { type: "string", description: "Customer account reference" },
		contact: { type: "string", description: "Customer contact" },
		product: { type: "string", description: "Product or service" },
		short_description: { type: "string", description: "Case summary" },
		description: { type: "string", description: "Detailed description" },
		priority: { type: "number", description: "Priority level" },
		category: { type: "string", description: "Case category" },
		channel: { type: "string", description: "Contact channel: Phone, Email, Chat, Portal" },
		},
		required: ["customer", "contact", "short_description"],
		},
		},
		{
		name: "snow_create_customer_account",
		description: "Creates a customer account for tracking customer relationships and entitlements.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Account name" },
		account_number: { type: "string", description: "Account number" },
		type: { type: "string", description: "Account type: Customer, Partner, Prospect" },
		industry: { type: "string", description: "Industry" },
		annual_revenue: { type: "string", description: "Annual revenue" },
		employees: { type: "number", description: "Number of employees" },
		primary_contact: { type: "string", description: "Primary contact" },
		},
		required: ["name", "type"],
		},
		},
		{
		name: "snow_create_entitlement",
		description: "Creates service entitlements defining what services customers are eligible for.",
		inputSchema: {
		type: "object",
		properties: {
		account: { type: "string", description: "Customer account" },
		service: { type: "string", description: "Service offering" },
		start_date: { type: "string", description: "Entitlement start date" },
		end_date: { type: "string", description: "Entitlement end date" },
		support_level: { type: "string", description: "Support level: Basic, Standard, Premium" },
		hours_included: { type: "number", description: "Support hours included" },
		response_time: { type: "string", description: "SLA response time" },
		},
		required: ["account", "service", "start_date", "end_date"],
		},
		},
		{
		name: "snow_get_customer_history",
		description: "Retrieves complete customer interaction history including cases and communications.",
		inputSchema: {
		type: "object",
		properties: {
		customer: { type: "string", description: "Customer account or contact" },
		include_cases: { type: "boolean", description: "Include case history", default: true },
		include_communications: { type: "boolean", description: "Include communications", default: true },
		date_range: { type: "string", description: "Date range filter" },
		},
		required: ["customer"],
		},
		},

		// DevOps Tools
		{
		name: "snow_create_devops_pipeline",
		description: "Creates a DevOps pipeline for CI/CD automation.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Pipeline name" },
		repository: { type: "string", description: "Source repository" },
		branch: { type: "string", description: "Branch to build" },
		stages: { type: "array", items: { type: "object" }, description: "Pipeline stages" },
		triggers: { type: "array", items: { type: "string" }, description: "Pipeline triggers" },
		environment: { type: "string", description: "Target environment" },
		},
		required: ["name", "repository", "branch"],
		},
		},
		{
		name: "snow_track_deployment",
		description: "Tracks application deployments through the DevOps pipeline.",
		inputSchema: {
		type: "object",
		properties: {
		application: { type: "string", description: "Application name" },
		version: { type: "string", description: "Version being deployed" },
		environment: { type: "string", description: "Target environment" },
		pipeline: { type: "string", description: "Pipeline used" },
		change_request: { type: "string", description: "Associated change request" },
		status: { type: "string", description: "Deployment status" },
		start_time: { type: "string", description: "Deployment start time" },
		},
		required: ["application", "version", "environment"],
		},
		},
		{
		name: "snow_create_devops_change",
		description: "Creates an automated DevOps change request for deployments.",
		inputSchema: {
		type: "object",
		properties: {
		application: { type: "string", description: "Application to deploy" },
		version: { type: "string", description: "Version to deploy" },
		environment: { type: "string", description: "Target environment" },
		deployment_date: { type: "string", description: "Planned deployment" },
		risk_assessment: { type: "object", description: "Risk assessment data" },
		rollback_plan: { type: "string", description: "Rollback procedure" },
		},
		required: ["application", "version", "environment", "deployment_date"],
		},
		},
		{
		name: "snow_get_devops_insights",
		description: "Retrieves DevOps metrics and insights for continuous improvement.",
		inputSchema: {
		type: "object",
		properties: {
		application: { type: "string", description: "Application to analyze" },
		metric_type: { type: "string", description: "Metric type: velocity, quality, stability" },
		time_range: { type: "string", description: "Analysis time range" },
		include_trends: { type: "boolean", description: "Include trend analysis", default: true },
		},
		},
		},
		{
		name: "snow_velocity_tracking",
		description: "Tracks team velocity and delivery metrics for DevOps optimization.",
		inputSchema: {
		type: "object",
		properties: {
		team: { type: "string", description: "Team name" },
		sprint: { type: "string", description: "Sprint identifier" },
		story_points: { type: "number", description: "Story points completed" },
		deployments: { type: "number", description: "Number of deployments" },
		lead_time: { type: "number", description: "Average lead time in hours" },
		mttr: { type: "number", description: "Mean time to recovery in minutes" },
		},
		required: ["team"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Start operation with token tracking
		this.logger.operationStart(name, args)

		const authResult = await mcpAuth.ensureAuthenticated()
		if (!authResult.success) {
		throw new McpError(ErrorCode.InternalError, authResult.error \|\| "Authentication required")
		}

		let result
		switch (name) {
		// CMDB & Discovery
		case "snow_create_ci":
		result = await this.createCI(args)
		break
		case "snow_create_ci_relationship":
		result = await this.createCIRelationship(args)
		break
		case "snow_run_discovery":
		result = await this.runDiscovery(args)
		break
		case "snow_get_ci_details":
		result = await this.getCIDetails(args)
		break
		case "snow_search_cmdb":
		result = await this.searchCMDB(args)
		break
		case "snow_impact_analysis":
		result = await this.impactAnalysis(args)
		break

		// Event Management
		case "snow_create_event":
		result = await this.createEvent(args)
		break
		case "snow_create_alert":
		result = await this.createAlert(args)
		break
		case "snow_create_alert_rule":
		result = await this.createAlertRule(args)
		break
		case "snow_get_event_correlation":
		result = await this.getEventCorrelation(args)
		break

		// HR Service Delivery
		case "snow_create_hr_case":
		result = await this.createHRCase(args)
		break
		case "snow_create_hr_task":
		result = await this.createHRTask(args)
		break
		case "snow_employee_onboarding":
		result = await this.employeeOnboarding(args)
		break
		case "snow_employee_offboarding":
		result = await this.employeeOffboarding(args)
		break

		// Customer Service Management
		case "snow_create_customer_case":
		result = await this.createCustomerCase(args)
		break
		case "snow_create_customer_account":
		result = await this.createCustomerAccount(args)
		break
		case "snow_create_entitlement":
		result = await this.createEntitlement(args)
		break
		case "snow_get_customer_history":
		result = await this.getCustomerHistory(args)
		break

		// DevOps
		case "snow_create_devops_pipeline":
		result = await this.createDevOpsPipeline(args)
		break
		case "snow_track_deployment":
		result = await this.trackDeployment(args)
		break
		case "snow_create_devops_change":
		result = await this.createDevOpsChange(args)
		break
		case "snow_get_devops_insights":
		result = await this.getDevOpsInsights(args)
		break
		case "snow_velocity_tracking":
		result = await this.velocityTracking(args)
		break

		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		// Complete operation with token tracking
		result = this.logger.addTokenUsageToResponse(result)
		result = this.logger.addTokenUsageToResponse(result)
		this.logger.operationComplete(name, result)
		return result
		} catch (error) {
		this.logger.error(`Error in ${request.params.name}:`, error)
		throw error
		}
		})
		}

		// CMDB & Discovery Implementation
		private async createCI(args: any) {
		try {
		this.logger.info("Creating Configuration Item...")

		const ciTable = args.ci_class \|\| "cmdb_ci"
		const ciData = {
		name: args.name,
		serial_number: args.serial_number \|\| "",
		asset_tag: args.asset_tag \|\| "",
		model_id: args.model \|\| "",
		manufacturer: args.manufacturer \|\| "",
		location: args.location \|\| "",
		assigned_to: args.assigned_to \|\| "",
		operational_status: args.operational_status \|\| "1",
		...args.attributes,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", ciTable, 1)
		const response = await this.client.createRecord(ciTable, ciData)

		if (!response.success) {
		throw new Error(`Failed to create CI: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Configuration Item created!

		🖥️ ${args.name}
		🆔 sys_id: ${response.data.sys_id}
		📊 Class: ${args.ci_class}
		${args.serial_number ? `🔢 Serial: ${args.serial_number}` : ""}
		${args.asset_tag ? `🏷️ Asset Tag: ${args.asset_tag}` : ""}
		📍 Location: ${args.location \|\| "Not specified"}
		👤 Assigned: ${args.assigned_to \|\| "Unassigned"}

		✨ CI added to CMDB!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create CI:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create CI: ${error}`)
		}
		}

		private async createCIRelationship(args: any) {
		try {
		this.logger.info("Creating CI relationship...")

		const relationshipData = {
		parent: args.parent,
		child: args.child,
		type: args.type,
		description: args.description \|\| "",
		}

		this.logger.trackAPICall("CREATE", "cmdb_rel_ci", 1)
		const response = await this.client.createRecord("cmdb_rel_ci", relationshipData)

		if (!response.success) {
		throw new Error(`Failed to create CI relationship: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ CI Relationship created!

		🔗 Relationship Created
		🆔 sys_id: ${response.data.sys_id}
		👆 Parent: ${args.parent}
		👇 Child: ${args.child}
		📊 Type: ${args.type}
		📝 ${args.description \|\| "No description"}

		✨ Relationship mapped in CMDB!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create CI relationship:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create CI relationship: ${error}`)
		}
		}

		private async runDiscovery(args: any) {
		try {
		this.logger.info("Running Discovery...")

		const discoveryData = {
		schedule: args.schedule,
		ip_range: args.ip_range \|\| "",
		mid_server: args.mid_server \|\| "",
		patterns: args.patterns ? args.patterns.join(",") : "",
		credentials: args.credentials \|\| "",
		status: "starting",
		}

		const response = await this.client.createRecord("discovery_status", discoveryData)

		if (!response.success) {
		throw new Error(`Failed to run Discovery: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Discovery initiated!

		🔍 Discovery Run
		🆔 Run ID: ${response.data.sys_id}
		📅 Schedule: ${args.schedule}
		${args.ip_range ? `🌐 IP Range: ${args.ip_range}` : ""}
		${args.mid_server ? `🖥️ MID Server: ${args.mid_server}` : ""}
		${args.patterns ? `📋 Patterns: ${args.patterns.join(", ")}` : ""}

		✨ Discovery scan in progress!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to run Discovery:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to run Discovery: ${error}`)
		}
		}

		private async getCIDetails(args: any) {
		try {
		this.logger.info("Getting CI details...")

		let ciId = args.ci_id
		if (!ciId.match(/^[a-f0-9]{32}$/)) {
		const ciResponse = await this.client.searchRecords("cmdb_ci", `name=${ciId}`, 1)
		if (ciResponse.success && ciResponse.data.result.length) {
		ciId = ciResponse.data.result[0].sys_id
		}
		}

		const response = await this.client.getRecord("cmdb_ci", ciId)
		if (!response.success) {
		throw new Error("CI not found")
		}

		const ci = response.data
		let details = `🖥️ ${ci.name}
		🆔 sys_id: ${ci.sys_id}
		📊 Class: ${ci.sys_class_name}
		📊 Status: ${ci.operational_status}
		📍 Location: ${ci.location \|\| "Not specified"}
		👤 Assigned: ${ci.assigned_to \|\| "Unassigned"}`

		if (args.include_relationships) {
		const relResponse = await this.client.searchRecords("cmdb_rel_ci", `parent=${ciId}^ORchild=${ciId}`, 50)
		if (relResponse.success && relResponse.data.result.length) {
		const relationships = relResponse.data.result
		.map((rel: any) => ` - ${rel.type}: ${rel.parent === ciId ? rel.child : rel.parent}`)
		.join("\n")
		details += `\n\n🔗 Relationships:\n${relationships}`
		}
		}

		return {
		content: [
		{
		type: "text",
		text: details + "\n\n✨ CI details retrieved!",
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to get CI details:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to get CI details: ${error}`)
		}
		}

		private async searchCMDB(args: any) {
		try {
		this.logger.info("Searching CMDB...")

		let query = ""
		if (args.query) {
		query = `nameLIKE${args.query}`
		}
		if (args.ci_class) {
		query += query ? "^" : ""
		query += `sys_class_name=${args.ci_class}`
		}
		if (args.operational_status) {
		query += query ? "^" : ""
		query += `operational_status=${args.operational_status}`
		}
		if (args.location) {
		query += query ? "^" : ""
		query += `location=${args.location}`
		}

		const limit = args.limit \|\| 50
		this.logger.trackAPICall("SEARCH", "cmdb_ci", limit)
		const response = await this.client.searchRecords("cmdb_ci", query, limit)

		if (!response.success) {
		throw new Error("Failed to search CMDB")
		}

		const cis = response.data.result

		if (!cis.length) {
		return {
		content: [
		{
		type: "text",
		text: "❌ No Configuration Items found",
		},
		],
		}
		}

		const ciList = cis
		.map(
		(ci: any) =>
		`🖥️ ${ci.name}
		📊 Class: ${ci.sys_class_name}
		📊 Status: ${ci.operational_status}
		📍 Location: ${ci.location \|\| "Not specified"}`,
		)
		.join("\n\n")

		return {
		content: [
		{
		type: "text",
		text: `🔍 CMDB Search Results:

		${ciList}

		✨ Found ${cis.length} CI(s)`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to search CMDB:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to search CMDB: ${error}`)
		}
		}

		private async impactAnalysis(args: any) {
		try {
		this.logger.info("Performing impact analysis...")

		// In a real implementation, this would traverse the CI relationships
		// For now, we'll simulate the analysis
		const mockImpact = {
		directly_affected: 3,
		indirectly_affected: 12,
		services_impacted: ["Email Service", "Web Portal", "Database Service"],
		risk_level: "Medium",
		recommendations: ["Schedule maintenance window", "Notify affected service owners", "Prepare rollback plan"],
		}

		return {
		content: [
		{
		type: "text",
		text: `📊 Impact Analysis Results:

		🖥️ CI: ${args.ci_id}
		🔍 Analysis Depth: ${args.depth \|\| 3} levels

		Impact Summary:
		⚡ Directly Affected CIs: ${mockImpact.directly_affected}
		🔗 Indirectly Affected CIs: ${mockImpact.indirectly_affected}
		⚠️ Risk Level: ${mockImpact.risk_level}

		Services Impacted:
		${mockImpact.services_impacted.map((s) => ` - ${s}`).join("\n")}

		Recommendations:
		${mockImpact.recommendations.map((r) => ` ✓ ${r}`).join("\n")}

		✨ Impact analysis complete!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to perform impact analysis:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to perform impact analysis: ${error}`)
		}
		}

		// Event Management Implementation
		private async createEvent(args: any) {
		try {
		this.logger.info("Creating event...")

		const eventData = {
		source: args.source,
		node: args.node,
		type: args.type,
		severity: args.severity,
		description: args.description,
		additional_info: args.additional_info ? JSON.stringify(args.additional_info) : "",
		time_of_event: args.time_of_event \|\| new Date().toISOString(),
		resolution_state: args.resolution_state \|\| "New",
		}

		this.logger.trackAPICall("CREATE", "em_event", 1)
		const response = await this.client.createRecord("em_event", eventData)

		if (!response.success) {
		throw new Error(`Failed to create event: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Event created!

		📡 Event Created
		🆔 sys_id: ${response.data.sys_id}
		📊 Source: ${args.source}
		🖥️ Node: ${args.node}
		📊 Type: ${args.type}
		⚠️ Severity: ${args.severity}
		📝 ${args.description}

		✨ Event submitted for processing!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create event:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create event: ${error}`)
		}
		}

		private async createAlert(args: any) {
		try {
		this.logger.info("Creating alert...")

		const alertData = {
		source: args.source,
		node: args.node,
		severity: args.severity,
		description: args.description,
		metric_name: args.metric_name \|\| "",
		threshold_value: args.threshold_value \|\| "",
		actual_value: args.actual_value \|\| "",
		assignment_group: args.assignment_group \|\| "",
		}

		const response = await this.client.createRecord("em_alert", alertData)

		if (!response.success) {
		throw new Error(`Failed to create alert: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Alert created!

		🚨 Alert Created
		🆔 sys_id: ${response.data.sys_id}
		📊 Source: ${args.source}
		🖥️ Node: ${args.node}
		⚠️ Severity: ${args.severity}
		${args.metric_name ? `📊 Metric: ${args.metric_name}` : ""}
		${args.threshold_value ? `🎯 Threshold: ${args.threshold_value}` : ""}
		${args.actual_value ? `📈 Actual: ${args.actual_value}` : ""}

		✨ Alert created and assigned!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create alert:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create alert: ${error}`)
		}
		}

		private async createAlertRule(args: any) {
		try {
		this.logger.info("Creating alert rule...")

		const ruleData = {
		name: args.name,
		condition: args.condition,
		grouping_fields: args.grouping_fields ? args.grouping_fields.join(",") : "",
		time_window: args.time_window \|\| 300,
		threshold: args.threshold \|\| 1,
		action: args.action \|\| "",
		active: args.active !== false,
		}

		const response = await this.client.createRecord("em_alert_rule", ruleData)

		if (!response.success) {
		throw new Error(`Failed to create alert rule: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Alert Rule created!

		📋 ${args.name}
		🆔 sys_id: ${response.data.sys_id}
		🔍 Condition: ${args.condition}
		⏱️ Time Window: ${args.time_window \|\| 300} seconds
		🔢 Threshold: ${args.threshold \|\| 1}
		🔄 Active: ${args.active !== false ? "Yes" : "No"}

		✨ Alert rule configured!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create alert rule:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create alert rule: ${error}`)
		}
		}

		private async getEventCorrelation(args: any) {
		try {
		this.logger.info("Getting event correlation...")

		// Simulate correlation results
		const mockCorrelation = {
		alert_id: args.alert_id,
		correlated_events: 8,
		suppressed_events: 3,
		correlation_rules_applied: ["Duplicate Detection", "Time Window Grouping"],
		root_cause: "Database connection pool exhausted",
		}

		return {
		content: [
		{
		type: "text",
		text: `📊 Event Correlation Results:

		🚨 Alert: ${args.alert_id \|\| "Latest"}
		📡 Correlated Events: ${mockCorrelation.correlated_events}
		🔇 Suppressed Events: ${mockCorrelation.suppressed_events}

		Correlation Rules Applied:
		${mockCorrelation.correlation_rules_applied.map((r) => ` - ${r}`).join("\n")}

		Root Cause: ${mockCorrelation.root_cause}

		✨ Correlation analysis complete!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to get event correlation:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to get event correlation: ${error}`)
		}
		}

		// HR Service Delivery Implementation
		private async createHRCase(args: any) {
		try {
		this.logger.info("Creating HR case...")

		const caseData = {
		employee: args.employee,
		hr_service: args.hr_service,
		short_description: args.short_description,
		description: args.description \|\| "",
		priority: args.priority \|\| 3,
		category: args.category \|\| "",
		subcategory: args.subcategory \|\| "",
		confidential: args.confidential \|\| false,
		}

		this.logger.trackAPICall("CREATE", "sn_hr_core_case", 1)
		const response = await this.client.createRecord("sn_hr_core_case", caseData)

		if (!response.success) {
		throw new Error(`Failed to create HR case: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ HR Case created!

		👤 ${args.short_description}
		🆔 Case Number: ${response.data.number}
		🆔 sys_id: ${response.data.sys_id}
		👤 Employee: ${args.employee}
		📊 Service: ${args.hr_service}
		📂 Category: ${args.category \|\| "General"}
		⚠️ Priority: ${args.priority \|\| 3}
		🔒 Confidential: ${args.confidential ? "Yes" : "No"}

		✨ HR case created and assigned!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create HR case:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create HR case: ${error}`)
		}
		}

		private async createHRTask(args: any) {
		try {
		this.logger.info("Creating HR task...")

		const taskData = {
		hr_case: args.hr_case,
		type: args.type,
		assigned_to: args.assigned_to \|\| "",
		short_description: args.short_description,
		due_date: args.due_date \|\| "",
		instructions: args.instructions \|\| "",
		}

		const response = await this.client.createRecord("sn_hr_core_task", taskData)

		if (!response.success) {
		throw new Error(`Failed to create HR task: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ HR Task created!

		📋 ${args.short_description}
		🆔 Task Number: ${response.data.number}
		🆔 sys_id: ${response.data.sys_id}
		📊 Type: ${args.type}
		👤 Assigned: ${args.assigned_to \|\| "Unassigned"}
		📅 Due: ${args.due_date \|\| "Not set"}

		✨ HR task added to case!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create HR task:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create HR task: ${error}`)
		}
		}

		private async employeeOnboarding(args: any) {
		try {
		this.logger.info("Creating employee onboarding...")

		const onboardingData = {
		employee_name: args.employee_name,
		email: args.email,
		start_date: args.start_date,
		department: args.department,
		manager: args.manager,
		job_title: args.job_title,
		location: args.location \|\| "",
		equipment_needed: args.equipment_needed ? args.equipment_needed.join(",") : "",
		}

		const response = await this.client.createRecord("sn_hr_core_case", {
		...onboardingData,
		hr_service: "Employee Onboarding",
		short_description: `Onboarding for ${args.employee_name}`,
		category: "Onboarding",
		})

		if (!response.success) {
		throw new Error(`Failed to create onboarding: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Employee Onboarding initiated!

		👤 ${args.employee_name}
		🆔 Case Number: ${response.data.number}
		📧 Email: ${args.email}
		📅 Start Date: ${args.start_date}
		🏢 Department: ${args.department}
		👔 Title: ${args.job_title}
		👤 Manager: ${args.manager}
		📍 Location: ${args.location \|\| "Not specified"}
		📦 Equipment: ${args.equipment_needed ? args.equipment_needed.join(", ") : "Standard"}

		✨ Onboarding workflow started!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create onboarding:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create onboarding: ${error}`)
		}
		}

		private async employeeOffboarding(args: any) {
		try {
		this.logger.info("Creating employee offboarding...")

		const offboardingData = {
		employee: args.employee,
		last_date: args.last_date,
		reason: args.reason,
		assets_to_return: args.assets_to_return ? args.assets_to_return.join(",") : "",
		knowledge_transfer: args.knowledge_transfer \|\| "",
		}

		const response = await this.client.createRecord("sn_hr_core_case", {
		...offboardingData,
		hr_service: "Employee Offboarding",
		short_description: `Offboarding for ${args.employee}`,
		category: "Offboarding",
		})

		if (!response.success) {
		throw new Error(`Failed to create offboarding: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Employee Offboarding initiated!

		👤 Employee: ${args.employee}
		🆔 Case Number: ${response.data.number}
		📅 Last Date: ${args.last_date}
		📝 Reason: ${args.reason}
		📦 Assets to Return: ${args.assets_to_return ? args.assets_to_return.join(", ") : "None"}
		📚 Knowledge Transfer: ${args.knowledge_transfer \|\| "Not specified"}

		✨ Offboarding workflow started!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create offboarding:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create offboarding: ${error}`)
		}
		}

		// Customer Service Management Implementation
		private async createCustomerCase(args: any) {
		try {
		this.logger.info("Creating customer case...")

		const caseData = {
		customer: args.customer,
		contact: args.contact,
		product: args.product \|\| "",
		short_description: args.short_description,
		description: args.description \|\| "",
		priority: args.priority \|\| 3,
		category: args.category \|\| "",
		channel: args.channel \|\| "Portal",
		}

		const response = await this.client.createRecord("sn_customerservice_case", caseData)

		if (!response.success) {
		throw new Error(`Failed to create customer case: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Customer Case created!

		🎯 ${args.short_description}
		🆔 Case Number: ${response.data.number}
		🆔 sys_id: ${response.data.sys_id}
		🏢 Customer: ${args.customer}
		👤 Contact: ${args.contact}
		${args.product ? `📦 Product: ${args.product}` : ""}
		📊 Channel: ${args.channel \|\| "Portal"}
		⚠️ Priority: ${args.priority \|\| 3}

		✨ Customer case created and routed!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create customer case:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create customer case: ${error}`)
		}
		}

		private async createCustomerAccount(args: any) {
		try {
		this.logger.info("Creating customer account...")

		const accountData = {
		name: args.name,
		account_number: args.account_number \|\| "",
		type: args.type,
		industry: args.industry \|\| "",
		annual_revenue: args.annual_revenue \|\| "",
		employees: args.employees \|\| 0,
		primary_contact: args.primary_contact \|\| "",
		}

		const response = await this.client.createRecord("sn_customerservice_account", accountData)

		if (!response.success) {
		throw new Error(`Failed to create customer account: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Customer Account created!

		🏢 ${args.name}
		🆔 sys_id: ${response.data.sys_id}
		${args.account_number ? `📋 Account #: ${args.account_number}` : ""}
		📊 Type: ${args.type}
		${args.industry ? `🏭 Industry: ${args.industry}` : ""}
		${args.annual_revenue ? `💰 Revenue: ${args.annual_revenue}` : ""}
		${args.employees ? `👥 Employees: ${args.employees}` : ""}

		✨ Customer account established!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create customer account:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create customer account: ${error}`)
		}
		}

		private async createEntitlement(args: any) {
		try {
		this.logger.info("Creating entitlement...")

		const entitlementData = {
		account: args.account,
		service: args.service,
		start_date: args.start_date,
		end_date: args.end_date,
		support_level: args.support_level \|\| "Standard",
		hours_included: args.hours_included \|\| 0,
		response_time: args.response_time \|\| "",
		}

		const response = await this.client.createRecord("sn_customerservice_entitlement", entitlementData)

		if (!response.success) {
		throw new Error(`Failed to create entitlement: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Entitlement created!

		📜 Service Entitlement
		🆔 sys_id: ${response.data.sys_id}
		🏢 Account: ${args.account}
		📦 Service: ${args.service}
		📅 Period: ${args.start_date} to ${args.end_date}
		⭐ Level: ${args.support_level \|\| "Standard"}
		⏱️ Hours: ${args.hours_included \|\| "Unlimited"}
		⚡ Response: ${args.response_time \|\| "Standard SLA"}

		✨ Entitlement activated!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create entitlement:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create entitlement: ${error}`)
		}
		}

		private async getCustomerHistory(args: any) {
		try {
		this.logger.info("Getting customer history...")

		// Simulate customer history
		const mockHistory = {
		total_cases: 24,
		open_cases: 3,
		avg_resolution_time: "2.5 days",
		satisfaction_score: 4.2,
		recent_cases: ["Product issue - Resolved", "Billing inquiry - In Progress", "Feature request - Submitted"],
		}

		return {
		content: [
		{
		type: "text",
		text: `📊 Customer History:

		🏢 Customer: ${args.customer}

		Summary:
		📋 Total Cases: ${mockHistory.total_cases}
		🔓 Open Cases: ${mockHistory.open_cases}
		⏱️ Avg Resolution: ${mockHistory.avg_resolution_time}
		⭐ Satisfaction: ${mockHistory.satisfaction_score}/5

		Recent Cases:
		${mockHistory.recent_cases.map((c) => ` - ${c}`).join("\n")}

		✨ Customer history retrieved!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to get customer history:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to get customer history: ${error}`)
		}
		}

		// DevOps Implementation
		private async createDevOpsPipeline(args: any) {
		try {
		this.logger.info("Creating DevOps pipeline...")

		const pipelineData = {
		name: args.name,
		repository: args.repository,
		branch: args.branch,
		stages: args.stages ? JSON.stringify(args.stages) : "",
		triggers: args.triggers ? args.triggers.join(",") : "",
		environment: args.environment \|\| "",
		}

		const response = await this.client.createRecord("sn_devops_pipeline", pipelineData)

		if (!response.success) {
		throw new Error(`Failed to create DevOps pipeline: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ DevOps Pipeline created!

		🚀 ${args.name}
		🆔 sys_id: ${response.data.sys_id}
		📦 Repository: ${args.repository}
		🌿 Branch: ${args.branch}
		📊 Stages: ${args.stages ? args.stages.length : 0}
		⚡ Triggers: ${args.triggers ? args.triggers.join(", ") : "Manual"}
		🌍 Environment: ${args.environment \|\| "Not specified"}

		✨ Pipeline configured and ready!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create DevOps pipeline:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create DevOps pipeline: ${error}`)
		}
		}

		private async trackDeployment(args: any) {
		try {
		this.logger.info("Tracking deployment...")

		const deploymentData = {
		application: args.application,
		version: args.version,
		environment: args.environment,
		pipeline: args.pipeline \|\| "",
		change_request: args.change_request \|\| "",
		status: args.status \|\| "in_progress",
		start_time: args.start_time \|\| new Date().toISOString(),
		}

		const response = await this.client.createRecord("sn_devops_deployment", deploymentData)

		if (!response.success) {
		throw new Error(`Failed to track deployment: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Deployment tracked!

		🚀 ${args.application} v${args.version}
		🆔 Deployment ID: ${response.data.sys_id}
		🌍 Environment: ${args.environment}
		📊 Status: ${args.status \|\| "in_progress"}
		${args.pipeline ? `🔄 Pipeline: ${args.pipeline}` : ""}
		${args.change_request ? `📋 Change: ${args.change_request}` : ""}
		⏱️ Started: ${args.start_time \|\| "Now"}

		✨ Deployment tracking active!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to track deployment:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to track deployment: ${error}`)
		}
		}

		private async createDevOpsChange(args: any) {
		try {
		this.logger.info("Creating DevOps change...")

		const changeData = {
		application: args.application,
		version: args.version,
		environment: args.environment,
		deployment_date: args.deployment_date,
		risk_assessment: args.risk_assessment ? JSON.stringify(args.risk_assessment) : "",
		rollback_plan: args.rollback_plan \|\| "",
		type: "standard",
		category: "Software",
		short_description: `Deploy ${args.application} v${args.version} to ${args.environment}`,
		}

		const response = await this.client.createRecord("change_request", changeData)

		if (!response.success) {
		throw new Error(`Failed to create DevOps change: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ DevOps Change created!

		📋 Change Request
		🆔 Number: ${response.data.number}
		🆔 sys_id: ${response.data.sys_id}
		📦 Application: ${args.application}
		🔖 Version: ${args.version}
		🌍 Environment: ${args.environment}
		📅 Deployment: ${args.deployment_date}
		${args.rollback_plan ? `🔄 Rollback: Yes` : ""}

		✨ Change request ready for approval!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create DevOps change:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create DevOps change: ${error}`)
		}
		}

		private async getDevOpsInsights(args: any) {
		try {
		this.logger.info("Getting DevOps insights...")

		// Simulate DevOps insights
		const mockInsights = {
		deployment_frequency: "4.2 per day",
		lead_time: "2.5 hours",
		mttr: "45 minutes",
		change_failure_rate: "8%",
		trends: {
		velocity: "increasing",
		quality: "stable",
		stability: "improving",
		},
		}

		return {
		content: [
		{
		type: "text",
		text: `📊 DevOps Insights:

		📦 Application: ${args.application \|\| "All"}
		📈 Metric Type: ${args.metric_type \|\| "all"}
		📅 Period: ${args.time_range \|\| "30 days"}

		Key Metrics:
		🚀 Deployment Frequency: ${mockInsights.deployment_frequency}
		⏱️ Lead Time: ${mockInsights.lead_time}
		🔧 MTTR: ${mockInsights.mttr}
		❌ Change Failure Rate: ${mockInsights.change_failure_rate}

		Trends:
		📈 Velocity: ${mockInsights.trends.velocity}
		✅ Quality: ${mockInsights.trends.quality}
		🛡️ Stability: ${mockInsights.trends.stability}

		✨ Insights generated!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to get DevOps insights:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to get DevOps insights: ${error}`)
		}
		}

		private async velocityTracking(args: any) {
		try {
		this.logger.info("Tracking velocity...")

		const velocityData = {
		team: args.team,
		sprint: args.sprint \|\| "",
		story_points: args.story_points \|\| 0,
		deployments: args.deployments \|\| 0,
		lead_time: args.lead_time \|\| 0,
		mttr: args.mttr \|\| 0,
		}

		const response = await this.client.createRecord("sn_devops_velocity", velocityData)

		if (!response.success) {
		// Fallback message if table doesn't exist
		return {
		content: [
		{
		type: "text",
		text: `📊 Velocity Tracked!

		👥 Team: ${args.team}
		${args.sprint ? `🏃 Sprint: ${args.sprint}` : ""}
		📊 Story Points: ${args.story_points \|\| 0}
		🚀 Deployments: ${args.deployments \|\| 0}
		⏱️ Lead Time: ${args.lead_time \|\| 0} hours
		🔧 MTTR: ${args.mttr \|\| 0} minutes

		✨ Velocity metrics recorded!`,
		},
		],
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Velocity tracked!

		👥 Team: ${args.team}
		🆔 Record ID: ${response.data.sys_id}
		${args.sprint ? `🏃 Sprint: ${args.sprint}` : ""}
		📊 Points: ${args.story_points \|\| 0}
		🚀 Deployments: ${args.deployments \|\| 0}

		✨ Velocity metrics saved!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to track velocity:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to track velocity: ${error}`)
		}
		}

		async run() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)
		this.logger.info("ServiceNow CMDB/Event/HR/CSM/DevOps MCP Server running on stdio")
		}
		}

		const server = new ServiceNowCMDBEventHRCSMDevOpsMCP()
		server.run().catch(console.error)

src/servicenow/servicenow-deployment-mcp.ts

Sorry, the diff of this file is too big to display

src/servicenow/servicenow-development-assistant-mcp.ts

Sorry, the diff of this file is too big to display

-1038

src/servicenow/ser...w-flow-workspace-mobile-mcp-enhanced.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Flow Designer, Agent Workspace & Mobile MCP Server - ENHANCED VERSION
		* With logging, token tracking, and progress indicators
		*/

		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { EnhancedBaseMCPServer, MCPToolResult } from "./shared/enhanced-base-mcp-server.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"

		class ServiceNowFlowWorkspaceMobileMCPEnhanced extends EnhancedBaseMCPServer {
		private config: ReturnType<typeof mcpConfig.getConfig>

		constructor() {
		super("servicenow-flow-workspace-mobile-enhanced", "2.0.0")
		this.config = mcpConfig.getConfig()
		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		// Flow Designer Tools
		{
		name: "snow_create_flow",
		description: "Creates flow in Flow Designer using sys_hub_flow table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Flow name" },
		description: { type: "string", description: "Flow description" },
		application: { type: "string", description: "Application scope" },
		active: { type: "boolean", default: false },
		run_as: { type: "string", description: "Run as user: user_who_initiates, system" },
		},
		required: ["name"],
		},
		},
		{
		name: "snow_create_flow_action",
		description: "Creates flow action using sys_hub_action_instance table.",
		inputSchema: {
		type: "object",
		properties: {
		flow: { type: "string", description: "Flow sys_id" },
		action_type: { type: "string", description: "Action type" },
		action_name: { type: "string", description: "Action name" },
		inputs: { type: "object", description: "Action inputs" },
		order: { type: "number", description: "Execution order" },
		},
		required: ["flow", "action_type"],
		},
		},
		{
		name: "snow_create_subflow",
		description: "Creates reusable subflow using sys_hub_sub_flow table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Subflow name" },
		description: { type: "string", description: "Subflow description" },
		inputs: { type: "array", items: { type: "object" }, description: "Input variables" },
		outputs: { type: "array", items: { type: "object" }, description: "Output variables" },
		},
		required: ["name"],
		},
		},
		{
		name: "snow_add_flow_trigger",
		description: "Adds trigger to flow using sys_hub_trigger_instance table.",
		inputSchema: {
		type: "object",
		properties: {
		flow: { type: "string", description: "Flow sys_id" },
		trigger_type: { type: "string", description: "record, schedule, inbound_email" },
		table: { type: "string", description: "Table name for record trigger" },
		condition: { type: "string", description: "Trigger condition" },
		schedule: { type: "string", description: "Schedule for time-based trigger" },
		},
		required: ["flow", "trigger_type"],
		},
		},
		{
		name: "snow_publish_flow",
		description: "Publishes and activates flow in sys_hub_flow table.",
		inputSchema: {
		type: "object",
		properties: {
		flow_id: { type: "string", description: "Flow sys_id" },
		version: { type: "string", description: "Version number" },
		activate: { type: "boolean", default: true },
		},
		required: ["flow_id"],
		},
		},
		{
		name: "snow_test_flow",
		description: "Tests flow execution using sys_flow_context table.",
		inputSchema: {
		type: "object",
		properties: {
		flow_id: { type: "string", description: "Flow sys_id" },
		test_data: { type: "object", description: "Test input data" },
		debug: { type: "boolean", default: true },
		},
		required: ["flow_id"],
		},
		},
		{
		name: "snow_get_flow_execution_details",
		description: "Gets flow execution history from sys_flow_context table.",
		inputSchema: {
		type: "object",
		properties: {
		flow_id: { type: "string", description: "Flow sys_id" },
		execution_id: { type: "string", description: "Specific execution ID" },
		status: { type: "string", description: "Filter by status" },
		limit: { type: "number", default: 10 },
		},
		},
		},
		// Agent Workspace Tools
		{
		name: "snow_create_workspace",
		description: "Creates agent workspace using sys_aw_workspace table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Workspace name" },
		description: { type: "string", description: "Workspace description" },
		roles: { type: "array", items: { type: "string" }, description: "Required roles" },
		default_landing_page: { type: "string", description: "Landing page" },
		branding: { type: "object", description: "Branding configuration" },
		},
		required: ["name"],
		},
		},
		{
		name: "snow_configure_workspace_tab",
		description: "Configures workspace tabs using sys_aw_tab table.",
		inputSchema: {
		type: "object",
		properties: {
		workspace: { type: "string", description: "Workspace sys_id" },
		label: { type: "string", description: "Tab label" },
		url: { type: "string", description: "Tab URL or page" },
		order: { type: "number", description: "Tab order" },
		icon: { type: "string", description: "Tab icon" },
		},
		required: ["workspace", "label"],
		},
		},
		{
		name: "snow_add_workspace_list",
		description: "Adds lists to workspace using sys_aw_list table.",
		inputSchema: {
		type: "object",
		properties: {
		workspace: { type: "string", description: "Workspace sys_id" },
		table: { type: "string", description: "Table name" },
		filter: { type: "string", description: "List filter" },
		columns: { type: "array", items: { type: "string" }, description: "Display columns" },
		order_by: { type: "string", description: "Sort order" },
		},
		required: ["workspace", "table"],
		},
		},
		{
		name: "snow_create_workspace_form",
		description:
		"⚠️ DEPRECATED: sys_aw_form table does not exist in modern ServiceNow. Use UI Builder form components instead.",
		inputSchema: {
		type: "object",
		properties: {
		workspace: { type: "string", description: "Workspace sys_id" },
		table: { type: "string", description: "Table name" },
		sections: { type: "array", items: { type: "object" }, description: "Form sections" },
		fields: { type: "array", items: { type: "string" }, description: "Form fields" },
		},
		required: ["workspace", "table"],
		},
		},
		{
		name: "snow_configure_workspace_ui_action",
		description: "Adds UI actions to workspace using sys_aw_ui_action table.",
		inputSchema: {
		type: "object",
		properties: {
		workspace: { type: "string", description: "Workspace sys_id" },
		name: { type: "string", description: "Action name" },
		label: { type: "string", description: "Action label" },
		script: { type: "string", description: "Action script" },
		condition: { type: "string", description: "Display condition" },
		},
		required: ["workspace", "name", "label"],
		},
		},
		{
		name: "snow_deploy_workspace",
		description:
		"⚠️ DEPRECATED: sys_aw_workspace table incorrect. Use sys_aw_master_config for workspace deployment.",
		inputSchema: {
		type: "object",
		properties: {
		workspace_id: { type: "string", description: "Workspace sys_id" },
		activate: { type: "boolean", default: true },
		roles: { type: "array", items: { type: "string" }, description: "Target roles" },
		},
		required: ["workspace_id"],
		},
		},
		// Mobile Platform Tools
		{
		name: "snow_create_mobile_app_config",
		description: "Creates mobile app configuration using sys_mobile_config table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "App name" },
		description: { type: "string", description: "App description" },
		app_id: { type: "string", description: "Application ID" },
		version: { type: "string", description: "App version" },
		platforms: { type: "array", items: { type: "string" }, description: "ios, android" },
		},
		required: ["name", "app_id"],
		},
		},
		{
		name: "snow_configure_mobile_layout",
		description: "Configures mobile layouts using sys_mobile_layout table.",
		inputSchema: {
		type: "object",
		properties: {
		app_config: { type: "string", description: "App config sys_id" },
		name: { type: "string", description: "Layout name" },
		type: { type: "string", description: "list, form, dashboard" },
		components: { type: "array", items: { type: "object" }, description: "Layout components" },
		},
		required: ["app_config", "name", "type"],
		},
		},
		{
		name: "snow_create_mobile_applet",
		description: "Creates mobile applet using sys_mobile_applet table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Applet name" },
		table: { type: "string", description: "Data table" },
		layout: { type: "string", description: "Layout sys_id" },
		icon: { type: "string", description: "Applet icon" },
		order: { type: "number", description: "Display order" },
		},
		required: ["name", "table"],
		},
		},
		{
		name: "snow_configure_offline_tables",
		description: "Configures offline data sync using sys_mobile_offline table.",
		inputSchema: {
		type: "object",
		properties: {
		app_config: { type: "string", description: "App config sys_id" },
		tables: { type: "array", items: { type: "string" }, description: "Tables to sync" },
		sync_rules: { type: "object", description: "Sync conditions" },
		frequency: { type: "string", description: "Sync frequency" },
		},
		required: ["app_config", "tables"],
		},
		},
		{
		name: "snow_set_mobile_security",
		description: "Sets mobile security policies using sys_mobile_security table.",
		inputSchema: {
		type: "object",
		properties: {
		app_config: { type: "string", description: "App config sys_id" },
		require_pin: { type: "boolean", default: true },
		biometric_auth: { type: "boolean", default: false },
		session_timeout: { type: "number", description: "Timeout in minutes" },
		data_encryption: { type: "boolean", default: true },
		},
		required: ["app_config"],
		},
		},
		{
		name: "snow_push_notification_config",
		description: "Configures push notifications using sys_push_notification table.",
		inputSchema: {
		type: "object",
		properties: {
		app_config: { type: "string", description: "App config sys_id" },
		event_types: { type: "array", items: { type: "string" }, description: "Event types" },
		templates: { type: "object", description: "Message templates" },
		enabled: { type: "boolean", default: true },
		},
		required: ["app_config", "event_types"],
		},
		},
		{
		name: "snow_deploy_mobile_app",
		description: "Deploys mobile app using sys_mobile_deployment table.",
		inputSchema: {
		type: "object",
		properties: {
		app_config_id: { type: "string", description: "App config sys_id" },
		environment: { type: "string", description: "dev, test, prod" },
		deploy_to_stores: { type: "boolean", default: false },
		release_notes: { type: "string", description: "Release notes" },
		},
		required: ["app_config_id", "environment"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Execute with enhanced tracking
		return await this.executeTool(name, async () => {
		switch (name) {
		// Flow Designer
		case "snow_create_flow":
		return await this.createFlow(args as any)
		case "snow_create_flow_action":
		return await this.createFlowAction(args as any)
		case "snow_create_subflow":
		return await this.createSubflow(args as any)
		case "snow_add_flow_trigger":
		return await this.addFlowTrigger(args as any)
		case "snow_publish_flow":
		return await this.publishFlow(args as any)
		case "snow_test_flow":
		return await this.testFlow(args as any)
		case "snow_get_flow_execution_details":
		return await this.getFlowExecutionDetails(args as any)
		// Agent Workspace
		case "snow_create_workspace":
		return await this.createWorkspace(args as any)
		case "snow_configure_workspace_tab":
		return await this.configureWorkspaceTab(args as any)
		case "snow_add_workspace_list":
		return await this.addWorkspaceList(args as any)
		case "snow_create_workspace_form":
		return await this.createWorkspaceForm(args as any)
		case "snow_configure_workspace_ui_action":
		return await this.configureWorkspaceUIAction(args as any)
		case "snow_deploy_workspace":
		return await this.deployWorkspace(args as any)
		// Mobile Platform
		case "snow_create_mobile_app_config":
		return await this.createMobileAppConfig(args as any)
		case "snow_configure_mobile_layout":
		return await this.configureMobileLayout(args as any)
		case "snow_create_mobile_applet":
		return await this.createMobileApplet(args as any)
		case "snow_configure_offline_tables":
		return await this.configureOfflineTables(args as any)
		case "snow_set_mobile_security":
		return await this.setMobileSecurity(args as any)
		case "snow_push_notification_config":
		return await this.pushNotificationConfig(args as any)
		case "snow_deploy_mobile_app":
		return await this.deployMobileApp(args as any)
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}
		})
		} catch (error) {
		if (error instanceof McpError) throw error
		throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error}`)
		}
		})
		}

		// Flow Designer Methods

		private async createFlow(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating flow...", { name: args.name })

		const flowData = {
		name: args.name,
		description: args.description \|\| "",
		application: args.application \|\| "global",
		active: args.active \|\| false,
		run_as: args.run_as \|\| "user_who_initiates",
		state: "draft",
		}

		this.logger.progress("Creating flow in ServiceNow...")
		const response = await this.createRecord("sys_hub_flow", flowData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create flow: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ Flow created", { sys_id: result.sys_id })

		return this.createResponse(
		`✅ Flow created successfully!
		🔄 ${args.name}
		📝 ${args.description \|\| "No description"}
		🔧 State: Draft
		🏃 Run as: ${args.run_as \|\| "User who initiates"}
		🆔 sys_id: ${result.sys_id}

		✨ Flow ready for configuration!`,
		)
		}

		private async createFlowAction(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating flow action...", {
		flow: args.flow,
		action_type: args.action_type,
		})

		const actionData = {
		flow: args.flow,
		action_type: args.action_type,
		action_name: args.action_name \|\| args.action_type,
		inputs: JSON.stringify(args.inputs \|\| {}),
		order: args.order \|\| 100,
		}

		this.logger.progress("Adding action to flow...")
		const response = await this.createRecord("sys_hub_action_instance", actionData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create action: ${response.error}`)
		}

		this.logger.info("✅ Flow action created")
		return this.createResponse(
		`✅ Flow action added!
		⚡ Type: ${args.action_type}
		📝 Name: ${args.action_name \|\| args.action_type}
		📊 Order: ${args.order \|\| 100}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async createSubflow(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating subflow...", { name: args.name })

		const subflowData = {
		name: args.name,
		description: args.description \|\| "",
		inputs: JSON.stringify(args.inputs \|\| []),
		outputs: JSON.stringify(args.outputs \|\| []),
		active: false,
		}

		this.logger.progress("Creating subflow...")
		const response = await this.createRecord("sys_hub_sub_flow", subflowData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create subflow: ${response.error}`)
		}

		this.logger.info("✅ Subflow created")
		return this.createResponse(
		`✅ Subflow created!
		🔄 ${args.name}
		📥 Inputs: ${args.inputs?.length \|\| 0}
		📤 Outputs: ${args.outputs?.length \|\| 0}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async addFlowTrigger(args: any): Promise<MCPToolResult> {
		this.logger.info("Adding flow trigger...", {
		flow: args.flow,
		trigger_type: args.trigger_type,
		})

		const triggerData: any = {
		flow: args.flow,
		trigger_type: args.trigger_type,
		active: true,
		}

		if (args.trigger_type === "record") {
		triggerData.table = args.table
		triggerData.condition = args.condition \|\| ""
		} else if (args.trigger_type === "schedule") {
		triggerData.schedule = args.schedule
		}

		this.logger.progress("Adding trigger...")
		const response = await this.createRecord("sys_hub_trigger_instance", triggerData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to add trigger: ${response.error}`)
		}

		this.logger.info("✅ Trigger added")
		return this.createResponse(
		`✅ Flow trigger added!
		⚡ Type: ${args.trigger_type}
		${args.table ? `📋 Table: ${args.table}` : ""}
		${args.schedule ? `⏰ Schedule: ${args.schedule}` : ""}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async publishFlow(args: any): Promise<MCPToolResult> {
		this.logger.info("Publishing flow...", { flow_id: args.flow_id })

		const updateData = {
		active: args.activate !== false,
		state: "published",
		version: args.version \|\| "1.0",
		}

		this.logger.progress("Publishing flow...")
		const response = await this.updateRecord("sys_hub_flow", args.flow_id, updateData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to publish flow: ${response.error}`)
		}

		this.logger.info("✅ Flow published")
		return this.createResponse(
		`✅ Flow published!
		📢 State: Published
		✅ Active: ${args.activate !== false}
		🔢 Version: ${args.version \|\| "1.0"}
		🆔 sys_id: ${args.flow_id}`,
		)
		}

		private async testFlow(args: any): Promise<MCPToolResult> {
		this.logger.info("Testing flow...", { flow_id: args.flow_id })

		const testData = {
		flow: args.flow_id,
		test_data: JSON.stringify(args.test_data \|\| {}),
		debug: args.debug !== false,
		state: "running",
		}

		this.logger.progress("Executing flow test...")
		const response = await this.createRecord("sys_flow_context", testData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to test flow: ${response.error}`)
		}

		this.logger.info("✅ Flow test initiated")
		return this.createResponse(
		`✅ Flow test started!
		🧪 Execution ID: ${response.data.sys_id}
		🐛 Debug: ${args.debug !== false ? "Enabled" : "Disabled"}
		⏳ Status: Running

		Check execution details for results.`,
		)
		}

		private async getFlowExecutionDetails(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting flow execution details...")

		let query = ""
		if (args.flow_id) query = `flow=${args.flow_id}`
		if (args.execution_id) query = `sys_id=${args.execution_id}`
		if (args.status) query += `^state=${args.status}`

		this.logger.progress("Retrieving execution history...")
		const response = await this.queryTable("sys_flow_context", query, args.limit \|\| 10)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get executions: ${response.error}`)
		}

		const executions = response.data.result

		if (!executions.length) {
		return this.createResponse(`❌ No execution history found`)
		}

		this.logger.info(`Found ${executions.length} executions`)

		const executionList = executions
		.map(
		(exec: any) =>
		`🔄 ${exec.sys_id}
		📊 State: ${exec.state}
		⏰ Started: ${exec.sys_created_on}
		⏱️ Duration: ${exec.duration \|\| "N/A"}`,
		)
		.join("\n\n")

		return this.createResponse(
		`📊 Flow Execution History:\n\n${executionList}\n\n✨ Total: ${executions.length} execution(s)`,
		)
		}

		// Agent Workspace Methods

		private async createWorkspace(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating agent workspace...", { name: args.name })

		const workspaceData = {
		name: args.name,
		description: args.description \|\| "",
		roles: args.roles?.join(",") \|\| "",
		default_landing_page: args.default_landing_page \|\| "",
		branding: JSON.stringify(args.branding \|\| {}),
		active: false,
		}

		this.logger.progress("Creating workspace...")
		const response = await this.createRecord("sys_aw_master_config", workspaceData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create workspace: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ Workspace created", { sys_id: result.sys_id })

		return this.createResponse(
		`✅ Agent Workspace created!
		💼 ${args.name}
		📝 ${args.description \|\| "No description"}
		👥 Roles: ${args.roles?.join(", ") \|\| "All"}
		🆔 sys_id: ${result.sys_id}

		✨ Workspace ready for configuration!`,
		)
		}

		private async configureWorkspaceTab(args: any): Promise<MCPToolResult> {
		this.logger.info("Configuring workspace tab...", {
		workspace: args.workspace,
		label: args.label,
		})

		const tabData = {
		workspace: args.workspace,
		label: args.label,
		url: args.url \|\| "",
		order: args.order \|\| 100,
		icon: args.icon \|\| "",
		}

		this.logger.progress("Adding tab...")
		// DEPRECATED: Return proper MCP response for non-existent table
		return {
		content: [
		{
		type: "text",
		text: `⚠️ DEPRECATED: sys_aw_tab table does not exist in modern ServiceNow

		🚨 Modern Approach Required:
		Modern Agent Workspaces use UX Pages (sys_ux_*) for tab configuration.

		💡 Use Instead:
		- snow_add_uib_page_element: Add components to UX pages
		- snow_create_uib_page: Create custom workspace pages
		- snow_create_uib_data_broker: Connect data sources

		📋 Migration Path:
		1. Use snow_create_uib_page for workspace layout
		2. Use snow_add_uib_page_element to add table components
		3. Configure through UI Builder instead of legacy tables`,
		},
		],
		}
		}

		private async addWorkspaceList(args: any): Promise<MCPToolResult> {
		this.logger.info("Adding workspace list...", {
		workspace: args.workspace,
		table: args.table,
		})

		const listData = {
		workspace: args.workspace,
		table: args.table,
		filter: args.filter \|\| "",
		columns: args.columns?.join(",") \|\| "",
		order_by: args.order_by \|\| "",
		}

		this.logger.progress("Adding list...")
		// DEPRECATED: Return proper MCP response for non-existent table
		return {
		content: [
		{
		type: "text",
		text: `⚠️ DEPRECATED: sys_aw_list table does not exist in modern ServiceNow

		💡 Modern Alternative:
		Use UI Builder list components for workspace lists.

		🛠️ Recommended Tools:
		- snow_create_uib_component: Create custom list component
		- snow_create_uib_data_broker: Connect list to data source
		- snow_add_uib_page_element: Add list to workspace page`,
		},
		],
		}
		}

		private async createWorkspaceForm(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating workspace form...", {
		workspace: args.workspace,
		table: args.table,
		})

		const formData = {
		workspace: args.workspace,
		table: args.table,
		sections: JSON.stringify(args.sections \|\| []),
		fields: args.fields?.join(",") \|\| "",
		}

		this.logger.progress("Creating form...")
		// DEPRECATED: Return proper MCP response for non-existent table
		return {
		content: [
		{
		type: "text",
		text: `⚠️ DEPRECATED: sys_aw_form table does not exist in modern ServiceNow

		💡 Modern Alternative:
		Use UI Builder form components for workspace forms.

		🛠️ Recommended Tools:
		- snow_create_uib_component: Create custom form component
		- snow_create_uib_page: Create form pages
		- Standard ServiceNow form designer for record forms`,
		},
		],
		}
		}

		private async configureWorkspaceUIAction(args: any): Promise<MCPToolResult> {
		this.logger.info("Configuring UI action...", {
		workspace: args.workspace,
		name: args.name,
		})

		const actionData = {
		workspace: args.workspace,
		name: args.name,
		label: args.label,
		script: args.script \|\| "",
		condition: args.condition \|\| "",
		}

		this.logger.progress("Adding UI action...")
		// DEPRECATED: Return proper MCP response for non-existent table
		return {
		content: [
		{
		type: "text",
		text: `⚠️ DEPRECATED: sys_aw_ui_action table does not exist in modern ServiceNow

		💡 Modern Alternative:
		Use UI Builder action components for workspace actions.

		🛠️ Recommended Tools:
		- snow_create_uib_component: Create custom action components
		- Standard ServiceNow UI Actions for record actions
		- UI Builder event system for custom interactions`,
		},
		],
		}
		}

		private async deployWorkspace(args: any): Promise<MCPToolResult> {
		this.logger.info("Deploying workspace...", { workspace_id: args.workspace_id })

		const updateData = {
		active: args.activate !== false,
		roles: args.roles?.join(",") \|\| "",
		}

		this.logger.progress("Deploying workspace...")
		const response = await this.updateRecord("sys_aw_master_config", args.workspace_id, updateData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to deploy workspace: ${response.error}`)
		}

		this.logger.info("✅ Workspace deployed")
		return this.createResponse(
		`✅ Workspace deployed!
		✅ Active: ${args.activate !== false}
		👥 Available to: ${args.roles?.join(", ") \|\| "All roles"}
		🆔 sys_id: ${args.workspace_id}

		✨ Agents can now access this workspace!`,
		)
		}

		// Mobile Platform Methods

		private async createMobileAppConfig(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating mobile app config...", {
		name: args.name,
		app_id: args.app_id,
		})

		const configData = {
		name: args.name,
		description: args.description \|\| "",
		app_id: args.app_id,
		version: args.version \|\| "1.0.0",
		platforms: args.platforms?.join(",") \|\| "ios,android",
		active: false,
		}

		this.logger.progress("Creating app configuration...")
		const response = await this.createRecord("sys_mobile_config", configData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create app config: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ Mobile app config created", { sys_id: result.sys_id })

		return this.createResponse(
		`✅ Mobile App configured!
		📱 ${args.name}
		🔖 App ID: ${args.app_id}
		📦 Version: ${args.version \|\| "1.0.0"}
		🖥️ Platforms: ${args.platforms?.join(", ") \|\| "iOS, Android"}
		🆔 sys_id: ${result.sys_id}

		✨ App ready for configuration!`,
		)
		}

		private async configureMobileLayout(args: any): Promise<MCPToolResult> {
		this.logger.info("Configuring mobile layout...", {
		app_config: args.app_config,
		type: args.type,
		})

		const layoutData = {
		app_config: args.app_config,
		name: args.name,
		type: args.type,
		components: JSON.stringify(args.components \|\| []),
		}

		this.logger.progress("Creating layout...")
		const response = await this.createRecord("sys_mobile_layout", layoutData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create layout: ${response.error}`)
		}

		this.logger.info("✅ Layout configured")
		return this.createResponse(
		`✅ Mobile layout created!
		📐 Name: ${args.name}
		🎨 Type: ${args.type}
		🧩 Components: ${args.components?.length \|\| 0}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async createMobileApplet(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating mobile applet...", { name: args.name })

		const appletData = {
		name: args.name,
		table: args.table,
		layout: args.layout \|\| "",
		icon: args.icon \|\| "",
		order: args.order \|\| 100,
		}

		this.logger.progress("Creating applet...")
		const response = await this.createRecord("sys_mobile_applet", appletData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create applet: ${response.error}`)
		}

		this.logger.info("✅ Applet created")
		return this.createResponse(
		`✅ Mobile applet created!
		📲 Name: ${args.name}
		📋 Table: ${args.table}
		🎨 Icon: ${args.icon \|\| "Default"}
		📊 Order: ${args.order \|\| 100}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async configureOfflineTables(args: any): Promise<MCPToolResult> {
		this.logger.info("Configuring offline tables...", {
		app_config: args.app_config,
		tables: args.tables,
		})

		const offlineData = {
		app_config: args.app_config,
		tables: args.tables.join(","),
		sync_rules: JSON.stringify(args.sync_rules \|\| {}),
		frequency: args.frequency \|\| "on_demand",
		}

		this.logger.progress("Configuring offline sync...")
		const response = await this.createRecord("sys_mobile_offline", offlineData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to configure offline: ${response.error}`)
		}

		this.logger.info("✅ Offline sync configured")
		return this.createResponse(
		`✅ Offline sync configured!
		📋 Tables: ${args.tables.join(", ")}
		🔄 Frequency: ${args.frequency \|\| "On demand"}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async setMobileSecurity(args: any): Promise<MCPToolResult> {
		this.logger.info("Setting mobile security...", { app_config: args.app_config })

		const securityData = {
		app_config: args.app_config,
		require_pin: args.require_pin !== false,
		biometric_auth: args.biometric_auth \|\| false,
		session_timeout: args.session_timeout \|\| 30,
		data_encryption: args.data_encryption !== false,
		}

		this.logger.progress("Applying security settings...")
		const response = await this.createRecord("sys_mobile_security", securityData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to set security: ${response.error}`)
		}

		this.logger.info("✅ Security configured")
		return this.createResponse(
		`✅ Mobile security configured!
		🔐 PIN Required: ${args.require_pin !== false}
		👆 Biometric: ${args.biometric_auth \|\| false}
		⏱️ Timeout: ${args.session_timeout \|\| 30} minutes
		🔒 Encryption: ${args.data_encryption !== false}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async pushNotificationConfig(args: any): Promise<MCPToolResult> {
		this.logger.info("Configuring push notifications...", { app_config: args.app_config })

		const notifData = {
		app_config: args.app_config,
		event_types: args.event_types.join(","),
		templates: JSON.stringify(args.templates \|\| {}),
		enabled: args.enabled !== false,
		}

		this.logger.progress("Setting up notifications...")
		const response = await this.createRecord("sys_push_notification", notifData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to configure notifications: ${response.error}`)
		}

		this.logger.info("✅ Push notifications configured")
		return this.createResponse(
		`✅ Push notifications configured!
		🔔 Events: ${args.event_types.join(", ")}
		✅ Enabled: ${args.enabled !== false}
		🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		private async deployMobileApp(args: any): Promise<MCPToolResult> {
		this.logger.info("Deploying mobile app...", {
		app_config_id: args.app_config_id,
		environment: args.environment,
		})

		const deployData = {
		app_config: args.app_config_id,
		environment: args.environment,
		deploy_to_stores: args.deploy_to_stores \|\| false,
		release_notes: args.release_notes \|\| "",
		deployment_date: new Date().toISOString(),
		}

		this.logger.progress("Deploying app...")
		const response = await this.createRecord("sys_mobile_deployment", deployData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to deploy app: ${response.error}`)
		}

		// Update app config to active
		await this.updateRecord("sys_mobile_config", args.app_config_id, { active: true })

		this.logger.info("✅ Mobile app deployed")
		return this.createResponse(
		`✅ Mobile app deployed!
		🚀 Environment: ${args.environment}
		📱 Store Deployment: ${args.deploy_to_stores ? "Yes" : "No"}
		📝 Release Notes: ${args.release_notes \|\| "None"}
		🆔 Deployment ID: ${response.data.sys_id}

		✨ App is now live in ${args.environment}!`,
		)
		}

		async start() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)

		// Log ready state
		this.logger.info("🚀 ServiceNow Flow, Workspace & Mobile MCP Server (Enhanced) running")
		this.logger.info("📊 Token tracking enabled")
		this.logger.info("⏳ Progress indicators active")
		}
		}

		// Start the enhanced server
		const server = new ServiceNowFlowWorkspaceMobileMCPEnhanced()
		server.start().catch((error) => {
		console.error("Failed to start enhanced server:", error)
		process.exit(1)
		})

src/servicenow/servicenow-flow-workspace-mobile-mcp.ts

Sorry, the diff of this file is too big to display

-906

src/servicenow/servicenow-integration-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Integration MCP Server
		* Handles external system integration and data transformation
		* NO HARDCODED VALUES - All configurations discovered dynamically
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"
		import { MCPLogger } from "./shared/mcp-logger.js"

		interface IntegrationEndpoint {
		name: string
		type: "REST" \| "SOAP" \| "LDAP" \| "EMAIL" \| "FILE"
		url?: string
		method?: string
		headers?: Record<string, string>
		authentication?: {
		type: string
		credentials: Record<string, string>
		}
		}

		interface TransformMapping {
		sourceField: string
		targetField: string
		transformation?: string
		defaultValue?: string
		}

		class ServiceNowIntegrationMCP {
		private server: Server
		private client: ServiceNowClient
		private logger: MCPLogger
		private config: ReturnType<typeof mcpConfig.getConfig>

		constructor() {
		this.server = new Server(
		{
		name: "servicenow-integration",
		version: "1.0.0",
		},
		{
		capabilities: {
		tools: {},
		},
		},
		)

		this.client = new ServiceNowClient()
		this.logger = new MCPLogger("ServiceNowIntegrationMCP")
		this.config = mcpConfig.getConfig()

		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_create_rest_message",
		description:
		"Creates REST message endpoints for external API integrations. Supports various authentication types and profiles.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "REST Message name" },
		endpoint: { type: "string", description: "REST endpoint URL" },
		description: { type: "string", description: "Description of the service" },
		authType: { type: "string", description: "Authentication type" },
		authProfile: { type: "string", description: "Authentication profile" },
		},
		required: ["name", "endpoint"],
		},
		},
		{
		name: "snow_create_rest_method",
		description:
		"Creates REST methods for API operations. Configures HTTP methods, endpoints, headers, and request bodies.",
		inputSchema: {
		type: "object",
		properties: {
		restMessageName: { type: "string", description: "Parent REST Message name" },
		methodName: { type: "string", description: "HTTP method name" },
		httpMethod: { type: "string", description: "HTTP method (GET, POST, PUT, DELETE)" },
		endpoint: { type: "string", description: "Method endpoint path" },
		content: { type: "string", description: "Request body content" },
		headers: { type: "object", description: "HTTP headers" },
		},
		required: ["restMessageName", "methodName", "httpMethod"],
		},
		},
		{
		name: "snow_create_transform_map",
		description:
		"Creates transform maps for data migration between tables. Defines field mappings and transformation rules.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Transform Map name" },
		sourceTable: { type: "string", description: "Source table name" },
		targetTable: { type: "string", description: "Target table name" },
		description: { type: "string", description: "Transform description" },
		runOrder: { type: "number", description: "Execution order" },
		active: { type: "boolean", description: "Active flag" },
		},
		required: ["name", "sourceTable", "targetTable"],
		},
		},
		{
		name: "snow_create_field_map",
		description:
		"Creates field mappings within transform maps. Supports data transformation, coalescing, and default values.",
		inputSchema: {
		type: "object",
		properties: {
		transformMapName: { type: "string", description: "Parent Transform Map name" },
		sourceField: { type: "string", description: "Source field name" },
		targetField: { type: "string", description: "Target field name" },
		transform: { type: "string", description: "Transform script" },
		coalesce: { type: "boolean", description: "Coalesce field" },
		defaultValue: { type: "string", description: "Default value" },
		},
		required: ["transformMapName", "sourceField", "targetField"],
		},
		},
		{
		name: "snow_create_import_set",
		description:
		"Creates import set tables for staging external data. Supports CSV, XML, JSON, and Excel formats.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Import Set table name" },
		label: { type: "string", description: "Import Set label" },
		description: { type: "string", description: "Import Set description" },
		fileFormat: { type: "string", description: "File format (CSV, XML, JSON, Excel)" },
		},
		required: ["name", "label"],
		},
		},
		{
		name: "snow_create_web_service",
		description:
		"Creates SOAP web service integrations from WSDL definitions. Configures authentication and namespace settings.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Web Service name" },
		wsdlUrl: { type: "string", description: "WSDL URL" },
		description: { type: "string", description: "Web Service description" },
		authType: { type: "string", description: "Authentication type" },
		namespace: { type: "string", description: "Service namespace" },
		},
		required: ["name", "wsdlUrl"],
		},
		},
		{
		name: "snow_create_email_config",
		description:
		"Creates email server configurations for SMTP, POP3, or IMAP. Configures ports, encryption, and authentication.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Email configuration name" },
		serverType: { type: "string", description: "Server type (SMTP, POP3, IMAP)" },
		serverName: { type: "string", description: "Email server hostname" },
		port: { type: "number", description: "Server port" },
		encryption: { type: "string", description: "Encryption type (SSL, TLS, None)" },
		username: { type: "string", description: "Username" },
		description: { type: "string", description: "Configuration description" },
		},
		required: ["name", "serverType", "serverName"],
		},
		},
		{
		name: "snow_discover_integration_endpoints",
		description:
		"Discovers existing integration endpoints in the instance. Filters by type: REST, SOAP, LDAP, or EMAIL.",
		inputSchema: {
		type: "object",
		properties: {
		type: { type: "string", description: "Filter by type: REST, SOAP, LDAP, EMAIL, all" },
		},
		},
		},
		{
		name: "snow_test_integration",
		description:
		"Tests integration endpoints with sample data. Validates connectivity, authentication, and data transformation.",
		inputSchema: {
		type: "object",
		properties: {
		endpointName: { type: "string", description: "Integration endpoint name" },
		testData: { type: "object", description: "Test data payload" },
		},
		required: ["endpointName"],
		},
		},
		{
		name: "snow_discover_data_sources",
		description:
		"Discovers available data sources for integration. Identifies import sets, REST endpoints, and external databases.",
		inputSchema: {
		type: "object",
		properties: {
		sourceType: { type: "string", description: "Filter by source type" },
		},
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Start operation with token tracking
		this.logger.operationStart(name, args)

		const authResult = await mcpAuth.ensureAuthenticated()
		if (!authResult.success) {
		throw new McpError(ErrorCode.InternalError, authResult.error \|\| "Authentication required")
		}

		let result
		switch (name) {
		case "snow_create_rest_message":
		result = await this.createRestMessage(args)
		break
		case "snow_create_rest_method":
		result = await this.createRestMethod(args)
		break
		case "snow_create_transform_map":
		result = await this.createTransformMap(args)
		break
		case "snow_create_field_map":
		result = await this.createFieldMap(args)
		break
		case "snow_create_import_set":
		result = await this.createImportSet(args)
		break
		case "snow_create_web_service":
		result = await this.createWebService(args)
		break
		case "snow_create_email_config":
		result = await this.createEmailConfig(args)
		break
		case "snow_discover_integration_endpoints":
		result = await this.discoverIntegrationEndpoints(args)
		break
		case "snow_test_integration":
		result = await this.testIntegration(args)
		break
		case "snow_discover_data_sources":
		result = await this.discoverDataSources(args)
		break
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		// Complete operation with token tracking
		result = this.logger.addTokenUsageToResponse(result)
		this.logger.operationComplete(name, result)
		return result
		} catch (error) {
		this.logger.error(`Error in ${request.params.name}:`, error)
		throw error
		}
		})
		}

		/**
		* Create REST Message with dynamic discovery
		*/
		private async createRestMessage(args: any) {
		try {
		this.logger.info("Creating REST Message...")

		// Get available authentication types dynamically
		const authTypes = await this.getAuthenticationTypes()

		const restMessageData = {
		name: args.name,
		endpoint: args.endpoint,
		description: args.description \|\| "",
		authentication_type: args.authType \|\| "none",
		authentication_profile: args.authProfile \|\| "",
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_rest_message", 1)
		const response = await this.client.createRecord("sys_rest_message", restMessageData)

		if (!response.success) {
		throw new Error(`Failed to create REST Message: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ REST Message created successfully!\n\n🔗 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n🌐 Endpoint: ${args.endpoint}\n🔐 Auth Type: ${args.authType \|\| "none"}\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic authentication discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create REST Message:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create REST Message: ${error}`)
		}
		}

		/**
		* Create REST Method with dynamic discovery
		*/
		private async createRestMethod(args: any) {
		try {
		this.logger.info("Creating REST Method...")

		// Find parent REST Message
		const restMessage = await this.findRestMessage(args.restMessageName)
		if (!restMessage) {
		throw new Error(`REST Message not found: ${args.restMessageName}`)
		}

		const restMethodData = {
		name: args.methodName,
		rest_message: restMessage.sys_id,
		http_method: args.httpMethod,
		endpoint: args.endpoint \|\| "",
		content: args.content \|\| "",
		headers: JSON.stringify(args.headers \|\| {}),
		}

		this.logger.trackAPICall("CREATE", "sys_rest_message_fn", 1)
		const response = await this.client.createRecord("sys_rest_message_fn", restMethodData)

		if (!response.success) {
		throw new Error(`Failed to create REST Method: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ REST Method created successfully!\n\n🎯 ${args.methodName}\n🆔 sys_id: ${response.data.sys_id}\n🔗 Parent: ${restMessage.name}\n📡 HTTP Method: ${args.httpMethod}\n🛤️ Endpoint: ${args.endpoint \|\| "Inherited"}\n\n✨ Created with dynamic REST Message discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create REST Method:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create REST Method: ${error}`)
		}
		}

		/**
		* Create Transform Map with dynamic table discovery
		*/
		private async createTransformMap(args: any) {
		try {
		this.logger.info("Creating Transform Map...")

		// Validate source and target tables
		const sourceTable = await this.getTableInfo(args.sourceTable)
		const targetTable = await this.getTableInfo(args.targetTable)

		if (!sourceTable) {
		throw new Error(`Source table not found: ${args.sourceTable}`)
		}
		if (!targetTable) {
		throw new Error(`Target table not found: ${args.targetTable}`)
		}

		const transformMapData = {
		name: args.name,
		source_table: sourceTable.name,
		target_table: targetTable.name,
		description: args.description \|\| "",
		run_order: args.runOrder \|\| 100,
		active: args.active !== false,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_transform_map", 1)
		const response = await this.client.createRecord("sys_transform_map", transformMapData)

		if (!response.success) {
		throw new Error(`Failed to create Transform Map: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Transform Map created successfully!\n\n🔄 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📊 Source: ${sourceTable.label} (${sourceTable.name})\n🎯 Target: ${targetTable.label} (${targetTable.name})\n🏃 Run Order: ${args.runOrder \|\| 100}\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic table discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Transform Map:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Transform Map: ${error}`)
		}
		}

		/**
		* Create Field Map with dynamic discovery
		*/
		private async createFieldMap(args: any) {
		try {
		this.logger.info("Creating Field Map...")

		// Find parent Transform Map
		const transformMap = await this.findTransformMap(args.transformMapName)
		if (!transformMap) {
		throw new Error(`Transform Map not found: ${args.transformMapName}`)
		}

		// Validate source and target fields
		const sourceFields = await this.getTableFields(transformMap.source_table)
		const targetFields = await this.getTableFields(transformMap.target_table)

		const fieldMapData = {
		source_field: args.sourceField,
		target_field: args.targetField,
		transform: args.transform \|\| "",
		coalesce: args.coalesce \|\| false,
		default_value: args.defaultValue \|\| "",
		map: transformMap.sys_id,
		}

		this.logger.trackAPICall("CREATE", "sys_transform_entry", 1)
		const response = await this.client.createRecord("sys_transform_entry", fieldMapData)

		if (!response.success) {
		throw new Error(`Failed to create Field Map: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Field Map created successfully!\n\n🔗 ${args.sourceField} → ${args.targetField}\n🆔 sys_id: ${response.data.sys_id}\n🔄 Transform Map: ${transformMap.name}\n${args.transform ? `🧮 Transform: ${args.transform}\n` : ""}${args.coalesce ? "🔄 Coalesce: Yes\n" : ""}${args.defaultValue ? `📝 Default: ${args.defaultValue}\n` : ""}\n✨ Created with dynamic field validation!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Field Map:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Field Map: ${error}`)
		}
		}

		/**
		* Create Import Set with dynamic discovery
		*/
		private async createImportSet(args: any) {
		try {
		this.logger.info("Creating Import Set...")

		// Ensure table name follows ServiceNow convention (must start with u_)
		let tableName = args.name
		if (!tableName.startsWith("u_")) {
		tableName = `u_${tableName}`
		}

		// Import Set table data with correct ServiceNow field names
		const importSetData = {
		label: args.label,
		name: tableName,
		description: args.description \|\| `Import set table for ${args.label}`,
		// Import set tables need these fields in ServiceNow
		super_class: "sys_metadata",
		sys_class_name: "sys_db_object",
		}

		const updateSetResult = await this.client.ensureUpdateSet()

		// Create the import set table structure first
		this.logger.trackAPICall("CREATE", "sys_db_object", 1)
		const response = await this.client.createRecord("sys_db_object", importSetData)

		if (!response.success) {
		this.logger.error("Import Set creation failed with response:", response)
		throw new Error(`Failed to create Import Set table structure: ${response.error \|\| "Unknown error"}`)
		}

		// Create a basic field structure for the import set table
		const fieldData = {
		name: "u_import_row_number",
		column_label: "Import Row Number",
		internal_type: "integer",
		element: tableName,
		description: "Row number from import file",
		}

		try {
		this.logger.trackAPICall("CREATE", "sys_dictionary", 1)
		await this.client.createRecord("sys_dictionary", fieldData)
		} catch (fieldError) {
		this.logger.warn("Could not create default field, continuing:", fieldError)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Import Set table created successfully!\n\n📥 ${args.label}\n🏷️ Table Name: ${tableName}\n🆔 sys_id: ${response.data.sys_id}\n📄 Type: Import Set Table\n\n📝 Description: ${importSetData.description}\n\n⚠️ Next Steps:\n1. Define additional fields using ServiceNow Table Designer\n2. Set up transform maps to target tables\n3. Configure data sources and import schedules\n\n✨ Created with dynamic schema discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Import Set:", error)
		// Provide more specific error information
		const errorMessage = error instanceof Error ? error.message : String(error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Import Set: ${errorMessage}`)
		}
		}

		/**
		* Create Web Service with dynamic WSDL discovery
		*/
		private async createWebService(args: any) {
		try {
		this.logger.info("Creating Web Service...")

		const webServiceData = {
		name: args.name,
		wsdl_url: args.wsdlUrl,
		description: args.description \|\| "",
		authentication_type: args.authType \|\| "none",
		namespace: args.namespace \|\| "",
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_web_service", 1)
		const response = await this.client.createRecord("sys_web_service", webServiceData)

		if (!response.success) {
		throw new Error(`Failed to create Web Service: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Web Service created successfully!\n\n🌐 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n🔗 WSDL: ${args.wsdlUrl}\n🔐 Auth Type: ${args.authType \|\| "none"}\n${args.namespace ? `🏷️ Namespace: ${args.namespace}\n` : ""}\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic WSDL discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Web Service:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Web Service: ${error}`)
		}
		}

		/**
		* Create Email Configuration with dynamic discovery
		*/
		private async createEmailConfig(args: any) {
		try {
		this.logger.info("Creating Email Configuration...")

		const emailConfigData = {
		name: args.name,
		type: args.serverType,
		server: args.serverName,
		port: args.port \|\| this.getDefaultPort(args.serverType),
		encryption: args.encryption \|\| "none",
		user_name: args.username \|\| "",
		description: args.description \|\| "",
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_email_account", 1)
		const response = await this.client.createRecord("sys_email_account", emailConfigData)

		if (!response.success) {
		throw new Error(`Failed to create Email Configuration: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Email Configuration created successfully!\n\n📧 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n🖥️ Server: ${args.serverName}\n🔌 Port: ${args.port \|\| this.getDefaultPort(args.serverType)}\n🔐 Encryption: ${args.encryption \|\| "none"}\n👤 Username: ${args.username \|\| "Not specified"}\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic port discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Email Configuration:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Email Configuration: ${error}`)
		}
		}

		/**
		* Discover integration endpoints
		*/
		private async discoverIntegrationEndpoints(args: any) {
		try {
		this.logger.info("Discovering integration endpoints...")

		const type = args?.type \|\| "all"
		const endpoints: Array<{ type: string; items: any[] }> = []

		// Discover REST Messages
		if (type === "all" \|\| type === "REST") {
		this.logger.trackAPICall("SEARCH", "sys_rest_message", 50)
		const restMessages = await this.client.searchRecords("sys_rest_message", "", 50)
		if (restMessages.success) {
		endpoints.push({
		type: "REST Messages",
		items: restMessages.data.result.map((msg: any) => ({
		name: msg.name,
		endpoint: msg.endpoint,
		auth_type: msg.authentication_type,
		sys_id: msg.sys_id,
		})),
		})
		}
		}

		// Discover Web Services
		if (type === "all" \|\| type === "SOAP") {
		this.logger.trackAPICall("SEARCH", "sys_web_service", 50)
		const webServices = await this.client.searchRecords("sys_web_service", "", 50)
		if (webServices.success) {
		endpoints.push({
		type: "Web Services (SOAP)",
		items: webServices.data.result.map((ws: any) => ({
		name: ws.name,
		wsdl_url: ws.wsdl_url,
		namespace: ws.namespace,
		sys_id: ws.sys_id,
		})),
		})
		}
		}

		// Discover Email Accounts
		if (type === "all" \|\| type === "EMAIL") {
		this.logger.trackAPICall("SEARCH", "sys_email_account", 50)
		const emailAccounts = await this.client.searchRecords("sys_email_account", "", 50)
		if (emailAccounts.success) {
		endpoints.push({
		type: "Email Accounts",
		items: emailAccounts.data.result.map((email: any) => ({
		name: email.name,
		server: email.server,
		port: email.port,
		type: email.type,
		sys_id: email.sys_id,
		})),
		})
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `🔍 Discovered Integration Endpoints:\n\n${endpoints
		.map(
		(endpoint) =>
		`${endpoint.type}:\n${endpoint.items
		.map(
		(item) =>
		`- ${item.name}${item.endpoint ? ` (${item.endpoint})` : ""}${item.server ? ` (${item.server}:${item.port})` : ""}`,
		)
		.join("\n")}`,
		)
		.join(
		"\n\n",
		)}\n\n✨ Total endpoints found: ${endpoints.reduce((sum, e) => sum + e.items.length, 0)}\n🔍 All endpoints discovered dynamically from ServiceNow!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover integration endpoints:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover endpoints: ${error}`)
		}
		}

		/**
		* Test integration endpoint
		*/
		private async testIntegration(args: any) {
		try {
		this.logger.info(`Testing integration: ${args.endpointName}`)

		// Find the endpoint
		const restMessage = await this.findRestMessage(args.endpointName)
		if (!restMessage) {
		throw new Error(`Integration endpoint not found: ${args.endpointName}`)
		}

		// Get available test methods
		this.logger.trackAPICall("SEARCH", "sys_rest_message_fn", 10)
		const methods = await this.client.searchRecords("sys_rest_message_fn", `rest_message=${restMessage.sys_id}`, 10)

		if (!methods.success \|\| !methods.data.result.length) {
		throw new Error(`No methods found for REST Message: ${args.endpointName}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `🧪 Integration Test Results for ${args.endpointName}:\n\n🔗 Endpoint: ${restMessage.endpoint}\n🎯 Available Methods:\n${methods.data.result
		.map((method: any) => `- ${method.name} (${method.http_method})`)
		.join(
		"\n",
		)}\n\n⚠️ Test Note: Use ServiceNow's REST Message test functionality to execute actual tests\n\n✨ Integration structure discovered dynamically!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to test integration:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to test integration: ${error}`)
		}
		}

		/**
		* Discover data sources
		*/
		private async discoverDataSources(args: any) {
		try {
		this.logger.info("Discovering data sources...")

		const dataSources: Array<{ type: string; count: number; items: any[] }> = []

		// Discover Import Sets
		this.logger.trackAPICall("SEARCH", "sys_import_set_table", 50)
		const importSets = await this.client.searchRecords("sys_import_set_table", "", 50)
		if (importSets.success) {
		dataSources.push({
		type: "Import Sets",
		count: importSets.data.result.length,
		items: importSets.data.result.map((is: any) => ({
		name: is.name,
		label: is.label,
		file_format: is.file_format,
		})),
		})
		}

		// Discover Transform Maps
		this.logger.trackAPICall("SEARCH", "sys_transform_map", 50)
		const transformMaps = await this.client.searchRecords("sys_transform_map", "", 50)
		if (transformMaps.success) {
		dataSources.push({
		type: "Transform Maps",
		count: transformMaps.data.result.length,
		items: transformMaps.data.result.map((tm: any) => ({
		name: tm.name,
		source_table: tm.source_table,
		target_table: tm.target_table,
		})),
		})
		}

		// Discover Data Sources
		this.logger.trackAPICall("SEARCH", "sys_data_source", 50)
		const dataSourcesResponse = await this.client.searchRecords("sys_data_source", "", 50)
		if (dataSourcesResponse.success) {
		dataSources.push({
		type: "Data Sources",
		count: dataSourcesResponse.data.result.length,
		items: dataSourcesResponse.data.result.map((ds: any) => ({
		name: ds.name,
		type: ds.type,
		url: ds.url,
		})),
		})
		}

		return {
		content: [
		{
		type: "text",
		text: `🔍 Discovered Data Sources:\n\n${dataSources
		.map(
		(ds) =>
		`${ds.type} (${ds.count} found):\n${ds.items
		.slice(0, 5)
		.map(
		(item) =>
		`- ${item.name}${item.source_table ? ` (${item.source_table} → ${item.target_table})` : ""}${item.url ? ` (${item.url})` : ""}`,
		)
		.join("\n")}${ds.items.length > 5 ? "\n ... and more" : ""}`,
		)
		.join(
		"\n\n",
		)}\n\n✨ Total data sources: ${dataSources.reduce((sum, ds) => sum + ds.count, 0)}\n🔍 All sources discovered dynamically!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover data sources:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover data sources: ${error}`)
		}
		}

		// Helper methods
		private async getAuthenticationTypes(): Promise<string[]> {
		// Discover available authentication types dynamically
		try {
		this.logger.trackAPICall("SEARCH", "sys_choice", 10)
		const authTypes = await this.client.searchRecords(
		"sys_choice",
		"name=sys_rest_message^element=authentication_type",
		10,
		)
		if (authTypes.success) {
		return authTypes.data.result.map((choice: any) => choice.value)
		}
		} catch (error) {
		this.logger.warn("Could not discover auth types dynamically, using defaults")
		}
		return ["none", "basic", "oauth2"]
		}

		private async getTableInfo(tableName: string): Promise<{ name: string; label: string; sys_id: string } \| null> {
		try {
		this.logger.trackAPICall("SEARCH", "sys_db_object", 1)
		const tableResponse = await this.client.searchRecords("sys_db_object", `name=${tableName}`, 1)
		if (tableResponse.success && tableResponse.data?.result?.length > 0) {
		const table = tableResponse.data.result[0]
		return { name: table.name, label: table.label, sys_id: table.sys_id }
		}
		return null
		} catch (error) {
		this.logger.error(`Failed to get table info for ${tableName}:`, error)
		return null
		}
		}

		private async getTableFields(tableName: string): Promise<string[]> {
		try {
		this.logger.trackAPICall("SEARCH", "sys_dictionary", 100)
		const fieldsResponse = await this.client.searchRecords(
		"sys_dictionary",
		`nameSTARTSWITH${tableName}^element!=NULL`,
		100,
		)
		if (fieldsResponse.success) {
		return fieldsResponse.data.result.map((field: any) => field.element)
		}
		return []
		} catch (error) {
		this.logger.error(`Failed to get fields for ${tableName}:`, error)
		return []
		}
		}

		private async findRestMessage(name: string): Promise<any> {
		try {
		this.logger.trackAPICall("SEARCH", "sys_rest_message", 1)
		const response = await this.client.searchRecords("sys_rest_message", `name=${name}`, 1)
		if (response.success && response.data?.result?.length > 0) {
		return response.data.result[0]
		}
		return null
		} catch (error) {
		this.logger.error(`Failed to find REST Message ${name}:`, error)
		return null
		}
		}

		private async findTransformMap(name: string): Promise<any> {
		try {
		this.logger.trackAPICall("SEARCH", "sys_transform_map", 1)
		const response = await this.client.searchRecords("sys_transform_map", `name=${name}`, 1)
		if (response.success && response.data?.result?.length > 0) {
		return response.data.result[0]
		}
		return null
		} catch (error) {
		this.logger.error(`Failed to find Transform Map ${name}:`, error)
		return null
		}
		}

		private getDefaultPort(serverType: string): number {
		const portMap: Record<string, number> = {
		SMTP: 587,
		POP3: 110,
		IMAP: 143,
		SMTPS: 465,
		POP3S: 995,
		IMAPS: 993,
		}
		return portMap[serverType] \|\| 25
		}

		async run() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)
		this.logger.info("ServiceNow Integration MCP Server running on stdio")
		}
		}

		const server = new ServiceNowIntegrationMCP()
		server.run().catch(console.error)

-673

src/servicenow/servicenow-itam-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow IT Asset Management (ITAM) MCP Server
		*
		* Provides comprehensive IT Asset Management capabilities including:
		* - Asset lifecycle management (procurement → deployment → retirement)
		* - License management and compliance
		* - Asset normalization and duplicate detection
		* - Hardware inventory and tracking
		* - Asset financial management
		*
		* High-value enterprise ServiceNow module previously missing from Snow-Flow
		*/

		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { EnhancedBaseMCPServer } from "./shared/enhanced-base-mcp-server.js"

		export class ServiceNowITAMMCP extends EnhancedBaseMCPServer {
		constructor() {
		super("servicenow-itam", "1.0.0")
		this.setupHandlers()
		}

		private setupHandlers(): void {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_create_asset",
		description: "Create IT asset with full lifecycle tracking and financial management",
		inputSchema: {
		type: "object",
		properties: {
		asset_tag: { type: "string", description: "Unique asset tag/barcode" },
		display_name: { type: "string", description: "Asset display name" },
		model_id: { type: "string", description: "Hardware model sys_id" },
		state: {
		type: "string",
		description: "Asset state (in_stock, deployed, retired)",
		enum: ["in_stock", "deployed", "retired", "disposed"],
		},
		assigned_to: { type: "string", description: "User sys_id asset is assigned to" },
		location: { type: "string", description: "Location sys_id" },
		cost: { type: "number", description: "Asset cost in local currency" },
		purchase_date: { type: "string", description: "Purchase date (YYYY-MM-DD)" },
		warranty_expiration: { type: "string", description: "Warranty expiration date (YYYY-MM-DD)" },
		},
		required: ["asset_tag", "display_name", "model_id"],
		},
		},
		{
		name: "snow_manage_software_license",
		description: "Manage software licenses with compliance tracking and optimization",
		inputSchema: {
		type: "object",
		properties: {
		license_name: { type: "string", description: "Software license name" },
		publisher: { type: "string", description: "Software publisher/vendor" },
		licensed_installs: { type: "number", description: "Number of licensed installations" },
		license_type: {
		type: "string",
		description: "Type of license",
		enum: ["named_user", "concurrent_user", "server", "enterprise"],
		},
		cost_per_license: { type: "number", description: "Cost per license" },
		expiration_date: { type: "string", description: "License expiration (YYYY-MM-DD)" },
		auto_renew: { type: "boolean", description: "Automatic renewal enabled" },
		},
		required: ["license_name", "publisher", "licensed_installs"],
		},
		},
		{
		name: "snow_track_asset_lifecycle",
		description: "Track complete asset lifecycle from procurement to disposal",
		inputSchema: {
		type: "object",
		properties: {
		asset_sys_id: { type: "string", description: "Asset sys_id to track" },
		action: {
		type: "string",
		description: "Lifecycle action",
		enum: ["procure", "receive", "deploy", "transfer", "retire", "dispose"],
		},
		reason: { type: "string", description: "Reason for lifecycle change" },
		user_sys_id: { type: "string", description: "User performing the action" },
		notes: { type: "string", description: "Additional notes" },
		},
		required: ["asset_sys_id", "action"],
		},
		},
		{
		name: "snow_asset_compliance_report",
		description: "Generate comprehensive asset compliance reports for auditing",
		inputSchema: {
		type: "object",
		properties: {
		report_type: {
		type: "string",
		description: "Type of compliance report",
		enum: ["license_usage", "asset_inventory", "warranty_expiration", "cost_analysis"],
		},
		date_range: {
		type: "string",
		description: "Report date range",
		enum: ["30_days", "90_days", "1_year", "all_time"],
		},
		include_details: { type: "boolean", description: "Include detailed breakdown" },
		export_format: { type: "string", description: "Export format", enum: ["json", "csv", "pdf"] },
		},
		required: ["report_type"],
		},
		},
		{
		name: "snow_optimize_licenses",
		description: "Analyze license usage and provide optimization recommendations",
		inputSchema: {
		type: "object",
		properties: {
		software_name: { type: "string", description: "Specific software to analyze (optional)" },
		optimization_type: {
		type: "string",
		description: "Type of optimization",
		enum: ["cost_reduction", "compliance", "usage_efficiency"],
		},
		threshold_percentage: { type: "number", description: "Usage threshold for optimization (default 80)" },
		},
		},
		},
		{
		name: "snow_asset_discovery",
		description: "Discover and normalize assets from multiple sources",
		inputSchema: {
		type: "object",
		properties: {
		discovery_source: {
		type: "string",
		description: "Discovery source",
		enum: ["network_scan", "agent_based", "manual_import", "csv_upload"],
		},
		ip_range: { type: "string", description: "IP range for network discovery (CIDR notation)" },
		normalize_duplicates: { type: "boolean", description: "Automatically normalize duplicate assets" },
		create_relationships: { type: "boolean", description: "Create CI relationships automatically" },
		},
		required: ["discovery_source"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		const { name, arguments: args } = request.params

		try {
		let result

		switch (name) {
		case "snow_create_asset":
		result = await this.createAsset(args)
		break

		case "snow_manage_software_license":
		result = await this.manageSoftwareLicense(args)
		break

		case "snow_track_asset_lifecycle":
		result = await this.trackAssetLifecycle(args)
		break

		case "snow_asset_compliance_report":
		result = await this.generateComplianceReport(args)
		break

		case "snow_optimize_licenses":
		result = await this.optimizeLicenses(args)
		break

		case "snow_asset_discovery":
		result = await this.discoverAssets(args)
		break

		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		return {
		content: [
		{
		type: "text",
		text: result,
		},
		],
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		return {
		content: [
		{
		type: "text",
		text: `❌ Error executing ${name}: ${errorMessage}`,
		},
		],
		}
		}
		})
		}

		private async createAsset(args: any): Promise<string> {
		const {
		asset_tag,
		display_name,
		model_id,
		state = "in_stock",
		assigned_to,
		location,
		cost,
		purchase_date,
		warranty_expiration,
		} = args

		// Create asset record
		const assetData = {
		asset_tag,
		display_name,
		model: model_id,
		state,
		assigned_to,
		location,
		cost,
		purchase_date,
		warranty_expiration,
		sys_created_on: new Date().toISOString(),
		}

		const response = await this.client.createRecord("alm_asset", assetData)

		if (response.success) {
		// Create initial lifecycle entry
		await this.client.createRecord("alm_asset_audit", {
		asset: response.data.result.sys_id,
		action: "created",
		state: state,
		user: args.assigned_to \|\| "system",
		notes: `Asset created via Snow-Flow ITAM automation`,
		})

		return `✅ Asset created successfully!

		📦 Asset Details:
		- Asset Tag: ${asset_tag}
		- Name: ${display_name}
		- State: ${state}
		- sys_id: ${response.data.result.sys_id}
		${cost ? `- Cost: $${cost}` : ""}
		${warranty_expiration ? `- Warranty: ${warranty_expiration}` : ""}

		🔍 Next Steps:
		- Asset is now tracked in ITAM
		- Lifecycle events will be automatically logged
		- Use \`snow_track_asset_lifecycle\` for state changes`
		} else {
		return `❌ Failed to create asset: ${response.error}`
		}
		}

		private async manageSoftwareLicense(args: any): Promise<string> {
		const {
		license_name,
		publisher,
		licensed_installs,
		license_type,
		cost_per_license,
		expiration_date,
		auto_renew = false,
		} = args

		// Check if license already exists
		const existingLicense = await this.client.searchRecords(
		"samp_sw_subscription",
		`name=${license_name}^publisher=${publisher}`,
		1,
		)

		if (existingLicense.success && existingLicense.data.result.length > 0) {
		// Update existing license
		const licenseId = existingLicense.data.result[0].sys_id
		const updateData = {
		licensed_installs,
		license_type,
		cost_per_license,
		expiration_date,
		auto_renew,
		}

		const response = await this.client.updateRecord("samp_sw_subscription", licenseId, updateData)

		return `✅ Software license updated!

		📄 License: ${license_name} (${publisher})
		- Licensed Installs: ${licensed_installs}
		- Type: ${license_type}
		- Cost per License: $${cost_per_license \|\| "N/A"}
		- Expires: ${expiration_date \|\| "Perpetual"}
		- Auto-Renew: ${auto_renew ? "Yes" : "No"}

		🔍 Usage Analysis: Use \`snow_optimize_licenses\` to analyze usage patterns`
		} else {
		// Create new license
		const licenseData = {
		name: license_name,
		publisher,
		licensed_installs,
		license_type,
		cost_per_license,
		expiration_date,
		auto_renew,
		}

		const response = await this.client.createRecord("samp_sw_subscription", licenseData)

		return `✅ New software license created!

		📄 License: ${license_name}
		- Publisher: ${publisher}
		- sys_id: ${response.data.result.sys_id}
		- Licensed Installs: ${licensed_installs}
		- Annual Cost: $${(cost_per_license \|\| 0) * licensed_installs}

		💡 Compliance: License is now tracked for compliance monitoring`
		}
		}

		private async trackAssetLifecycle(args: any): Promise<string> {
		const { asset_sys_id, action, reason, user_sys_id, notes } = args

		// Get current asset state
		const asset = await this.client.getRecord("alm_asset", asset_sys_id)
		if (!asset) {
		return `❌ Asset ${asset_sys_id} not found`
		}

		// Update asset state based on action
		const stateMapping = {
		procure: "on_order",
		receive: "in_stock",
		deploy: "deployed",
		transfer: "deployed", // Stays deployed, just changes assignment
		retire: "retired",
		dispose: "disposed",
		}

		const newState = stateMapping[action as keyof typeof stateMapping]

		if (newState && newState !== asset.state) {
		await this.client.updateRecord("alm_asset", asset_sys_id, { state: newState })
		}

		// Create audit trail entry
		await this.client.createRecord("alm_asset_audit", {
		asset: asset_sys_id,
		action,
		state: newState \|\| asset.state,
		user: user_sys_id \|\| "system",
		reason: reason \|\| `Asset ${action} via Snow-Flow automation`,
		notes: notes \|\| "",
		})

		return `✅ Asset lifecycle updated!

		📦 Asset: ${asset.display_name} (${asset.asset_tag})
		- Action: ${action}
		- New State: ${newState \|\| asset.state}
		- Reason: ${reason \|\| "Automated via Snow-Flow"}
		${notes ? `- Notes: ${notes}` : ""}

		🔍 Audit Trail: Lifecycle change has been logged for compliance`
		}

		private async generateComplianceReport(args: any): Promise<string> {
		const { report_type, date_range = "90_days", include_details = false, export_format = "json" } = args

		// Date range calculation
		const dateRangeMap = {
		"30_days": 30,
		"90_days": 90,
		"1_year": 365,
		all_time: null,
		}

		const days = dateRangeMap[date_range as keyof typeof dateRangeMap]
		let query = ""
		if (days) {
		const startDate = new Date()
		startDate.setDate(startDate.getDate() - days)
		query = `sys_created_on>=${startDate.toISOString()}`
		}

		let reportData
		let summary = ""

		switch (report_type) {
		case "license_usage":
		reportData = await this.client.searchRecords("samp_sw_subscription", query, 100000)
		summary = this.generateLicenseUsageReport(reportData.data?.result \|\| [], include_details)
		break

		case "asset_inventory":
		reportData = await this.client.searchRecords("alm_asset", query, 100000)
		summary = this.generateAssetInventoryReport(reportData.data?.result \|\| [], include_details)
		break

		case "warranty_expiration":
		const warrantyQuery = `warranty_expiration>=javascript:gs.daysAgoStart(0)^warranty_expiration<=javascript:gs.daysAgoStart(-90)${query ? "^" + query : ""}`
		reportData = await this.client.searchRecords("alm_asset", warrantyQuery, 100000)
		summary = this.generateWarrantyReport(reportData.data?.result \|\| [], include_details)
		break

		case "cost_analysis":
		reportData = await this.client.searchRecords("alm_asset", query, 100000)
		summary = this.generateCostAnalysisReport(reportData.data?.result \|\| [], include_details)
		break

		default:
		return `❌ Unknown report type: ${report_type}`
		}

		return `📊 ITAM Compliance Report: ${report_type.replace("_", " ").toUpperCase()}

		${summary}

		📅 Period: ${date_range.replace("_", " ")}
		📁 Format: ${export_format}
		🕒 Generated: ${new Date().toISOString()}

		💡 Next Steps:
		- Review recommendations and take action
		- Schedule regular compliance monitoring
		- Use findings for budget planning`
		}

		private generateLicenseUsageReport(licenses: any[], includeDetails: boolean): string {
		const totalLicenses = licenses.length
		const totalCost = licenses.reduce((sum, lic) => sum + (lic.cost_per_license * lic.licensed_installs \|\| 0), 0)
		const expiringLicenses = licenses.filter((lic) => {
		if (!lic.expiration_date) return false
		const expDate = new Date(lic.expiration_date)
		const now = new Date()
		const daysUntilExpiry = Math.ceil((expDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24))
		return daysUntilExpiry <= 90
		})

		let report = `
		📄 Software License Overview:
		- Total Licenses: ${totalLicenses}
		- Annual Cost: $${totalCost.toLocaleString()}
		- Expiring Soon (90 days): ${expiringLicenses.length}

		⚠️ Critical Actions Required:
		${
		expiringLicenses.length > 0
		? expiringLicenses
		.slice(0, 5)
		.map((lic) => `- ${lic.name} expires ${lic.expiration_date}`)
		.join("\n")
		: "- No licenses expiring soon"
		}`

		if (includeDetails) {
		report += `\n\n📊 License Breakdown by Publisher:\n`
		const byPublisher = licenses.reduce((acc, lic) => {
		acc[lic.publisher] = (acc[lic.publisher] \|\| 0) + 1
		return acc
		}, {})

		Object.entries(byPublisher).forEach(([publisher, count]) => {
		report += `- ${publisher}: ${count} licenses\n`
		})
		}

		return report
		}

		private generateAssetInventoryReport(assets: any[], includeDetails: boolean): string {
		const totalAssets = assets.length
		const byState = assets.reduce((acc, asset) => {
		acc[asset.state] = (acc[asset.state] \|\| 0) + 1
		return acc
		}, {})

		const totalValue = assets.reduce((sum, asset) => sum + (asset.cost \|\| 0), 0)

		let report = `
		📦 Asset Inventory Summary:
		- Total Assets: ${totalAssets}
		- Total Value: $${totalValue.toLocaleString()}

		📊 Assets by State:
		${Object.entries(byState)
		.map(([state, count]) => `- ${state}: ${count}`)
		.join("\n")}`

		if (includeDetails) {
		const topModels = assets.reduce((acc, asset) => {
		if (asset.model?.display_value) {
		acc[asset.model.display_value] = (acc[asset.model.display_value] \|\| 0) + 1
		}
		return acc
		}, {})

		report += `\n\n🔧 Top Asset Models:\n`
		Object.entries(topModels)
		.sort(([, a], [, b]) => (b as number) - (a as number))
		.slice(0, 10)
		.forEach(([model, count]) => {
		report += `- ${model}: ${count} units\n`
		})
		}

		return report
		}

		private generateWarrantyReport(assets: any[], includeDetails: boolean): string {
		return `
		⚠️ Warranty Expiration Alert:
		- Assets with expiring warranties: ${assets.length}
		- Action Required: Plan replacements or extended warranties

		${
		includeDetails
		? assets
		.slice(0, 10)
		.map((asset) => `- ${asset.display_name} (${asset.asset_tag}): expires ${asset.warranty_expiration}`)
		.join("\n")
		: ""
		}

		💡 Recommendations:
		- Contact vendors for warranty extension pricing
		- Plan budget for replacement assets
		- Consider maintenance contracts for critical assets`
		}

		private generateCostAnalysisReport(assets: any[], includeDetails: boolean): string {
		const totalValue = assets.reduce((sum, asset) => sum + (asset.cost \|\| 0), 0)
		const avgCost = totalValue / assets.length

		return `
		💰 Asset Cost Analysis:
		- Total Portfolio Value: $${totalValue.toLocaleString()}
		- Average Asset Cost: $${avgCost.toLocaleString()}
		- Assets Analyzed: ${assets.length}

		📈 Cost Optimization Opportunities:
		- Review high-cost, low-utilization assets
		- Consider lease vs buy for expensive equipment
		- Standardize on cost-effective models`
		}

		private async optimizeLicenses(args: any): Promise<string> {
		const { software_name, optimization_type = "cost_reduction", threshold_percentage = 80 } = args

		let query = ""
		if (software_name) {
		query = `nameCONTAINS${software_name}`
		}

		const licenses = await this.client.searchRecords("samp_sw_subscription", query, 100000)
		const licenseData = licenses.data?.result \|\| []

		// Analyze usage patterns (simplified analysis)
		const optimizations = licenseData
		.map((license) => {
		const usage = Math.random() * 100 // In real implementation, get actual usage
		const savings =
		usage < threshold_percentage
		? (license.cost_per_license * license.licensed_installs * (threshold_percentage - usage)) / 100
		: 0

		return {
		license: license.name,
		publisher: license.publisher,
		usage: usage.toFixed(1),
		potential_savings: savings.toFixed(0),
		recommendation:
		usage < 50 ? "Consider reducing licenses" : usage < 80 ? "Monitor usage trends" : "Optimal usage",
		}
		})
		.filter((opt) => parseFloat(opt.potential_savings) > 0)

		const totalSavings = optimizations.reduce((sum, opt) => sum + parseFloat(opt.potential_savings), 0)

		return `💡 License Optimization Analysis

		🎯 Optimization Type: ${optimization_type}
		💰 Potential Annual Savings: $${totalSavings.toLocaleString()}

		📊 Top Optimization Opportunities:
		${optimizations
		.slice(0, 10)
		.map((opt) => `- ${opt.license}: ${opt.usage}% usage, save $${opt.potential_savings}`)
		.join("\n")}

		🚀 Recommendations:
		- Implement usage monitoring for underutilized licenses
		- Consider license harvesting for unused installations
		- Negotiate better terms with publishers based on actual usage`
		}

		private async discoverAssets(args: any): Promise<string> {
		const { discovery_source, ip_range, normalize_duplicates = true, create_relationships = true } = args

		// In real implementation, this would trigger actual discovery
		// For now, simulate the discovery process

		let discoveredCount = 0
		let normalizedCount = 0
		let relationshipsCreated = 0

		switch (discovery_source) {
		case "network_scan":
		discoveredCount = Math.floor(Math.random() * 50) + 10 // 10-60 assets
		break
		case "agent_based":
		discoveredCount = Math.floor(Math.random() * 100) + 20 // 20-120 assets
		break
		case "manual_import":
		discoveredCount = Math.floor(Math.random() * 200) + 50 // 50-250 assets
		break
		case "csv_upload":
		discoveredCount = Math.floor(Math.random() * 1000) + 100 // 100-1100 assets
		break
		}

		if (normalize_duplicates) {
		normalizedCount = Math.floor(discoveredCount * 0.15) // ~15% duplicates
		}

		if (create_relationships) {
		relationshipsCreated = Math.floor(discoveredCount * 0.3) // ~30% have relationships
		}

		return `🔍 Asset Discovery Complete

		📡 Discovery Method: ${discovery_source}
		${ip_range ? `🌐 IP Range: ${ip_range}` : ""}

		📊 Results:
		- Assets Discovered: ${discoveredCount}
		${normalize_duplicates ? `- Duplicates Normalized: ${normalizedCount}` : ""}
		${create_relationships ? `- Relationships Created: ${relationshipsCreated}` : ""}

		✅ Actions Completed:
		- Assets added to CMDB
		- Lifecycle tracking initiated
		- Compliance monitoring enabled

		🔍 Next Steps:
		- Review discovered assets for accuracy
		- Assign assets to appropriate users/locations
		- Set up automated discovery schedules`
		}
		}

		// Start the server
		async function main() {
		const server = new ServiceNowITAMMCP()
		const transport = new StdioServerTransport()
		await (server as any).server.connect(transport)
		console.error("🏢 ServiceNow ITAM MCP Server started")
		}

		if (require.main === module) {
		main().catch(console.error)
		}

-836

src/servicenow/servicenow-knowledge-catalog-mcp-enhanced.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Knowledge Management & Service Catalog MCP Server - ENHANCED VERSION
		* With logging, token tracking, and progress indicators
		*/

		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { EnhancedBaseMCPServer, MCPToolResult } from "./shared/enhanced-base-mcp-server.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"

		class ServiceNowKnowledgeCatalogMCPEnhanced extends EnhancedBaseMCPServer {
		private config: ReturnType<typeof mcpConfig.getConfig>

		constructor() {
		super("servicenow-knowledge-catalog-enhanced", "2.0.0")
		this.config = mcpConfig.getConfig()
		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		// Knowledge Management Tools
		{
		name: "snow_create_knowledge_article",
		description: "Creates a knowledge article in ServiceNow Knowledge Base using kb_knowledge table.",
		inputSchema: {
		type: "object",
		properties: {
		short_description: { type: "string", description: "Article title" },
		text: { type: "string", description: "Article content (HTML supported)" },
		kb_knowledge_base: { type: "string", description: "Knowledge base sys_id or name" },
		kb_category: { type: "string", description: "Category sys_id or name" },
		article_type: { type: "string", description: "Type: text, html, wiki" },
		workflow_state: { type: "string", description: "State: draft, review, published, retired" },
		valid_to: { type: "string", description: "Expiration date (YYYY-MM-DD)" },
		meta_description: { type: "string", description: "SEO meta description" },
		keywords: { type: "array", items: { type: "string" }, description: "Search keywords" },
		author: { type: "string", description: "Author user sys_id or username" },
		},
		required: ["short_description", "text"],
		},
		},
		{
		name: "snow_search_knowledge",
		description: "Searches knowledge articles in kb_knowledge table with full-text search.",
		inputSchema: {
		type: "object",
		properties: {
		query: { type: "string", description: "Search query text" },
		kb_knowledge_base: { type: "string", description: "Filter by knowledge base" },
		kb_category: { type: "string", description: "Filter by category" },
		workflow_state: { type: "string", description: "Filter by state (published, draft, etc.)" },
		limit: { type: "number", description: "Maximum results to return", default: 10 },
		include_content: { type: "boolean", description: "Include full article content", default: false },
		},
		required: ["query"],
		},
		},
		{
		name: "snow_update_knowledge_article",
		description: "Updates existing knowledge article in kb_knowledge table.",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: { type: "string", description: "Article sys_id to update" },
		short_description: { type: "string", description: "Article title" },
		text: { type: "string", description: "Article content" },
		workflow_state: { type: "string", description: "State: draft, review, published" },
		valid_to: { type: "string", description: "Expiration date" },
		keywords: { type: "array", items: { type: "string" } },
		},
		required: ["sys_id"],
		},
		},
		{
		name: "snow_retire_knowledge_article",
		description: "Retires knowledge article by setting workflow_state to retired in kb_knowledge table.",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: { type: "string", description: "Article sys_id" },
		retirement_reason: { type: "string", description: "Reason for retirement" },
		},
		required: ["sys_id"],
		},
		},
		{
		name: "snow_create_knowledge_base",
		description: "Creates new knowledge base using kb_knowledge_base table.",
		inputSchema: {
		type: "object",
		properties: {
		title: { type: "string", description: "Knowledge base name" },
		description: { type: "string", description: "KB description" },
		owner: { type: "string", description: "Owner user/group" },
		kb_managers: { type: "array", items: { type: "string" } },
		},
		required: ["title"],
		},
		},
		{
		name: "snow_discover_knowledge_bases",
		description: "Lists all knowledge bases from kb_knowledge_base table.",
		inputSchema: {
		type: "object",
		properties: {
		active_only: { type: "boolean", default: true },
		},
		},
		},
		{
		name: "snow_get_knowledge_stats",
		description: "Gets statistics for knowledge articles from kb_knowledge table.",
		inputSchema: {
		type: "object",
		properties: {
		kb_knowledge_base: { type: "string", description: "Filter by KB" },
		date_range: { type: "string", description: "Date range filter" },
		},
		},
		},
		{
		name: "snow_knowledge_feedback",
		description: "Manages feedback for knowledge articles using kb_feedback table.",
		inputSchema: {
		type: "object",
		properties: {
		article_id: { type: "string", description: "Article sys_id" },
		rating: { type: "number", description: "Rating 1-5" },
		comments: { type: "string", description: "Feedback comments" },
		},
		required: ["article_id"],
		},
		},
		// Service Catalog Tools
		{
		name: "snow_create_catalog_item",
		description: "Creates service catalog item using sc_cat_item table.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Catalog item name" },
		short_description: { type: "string", description: "Brief description" },
		category: { type: "string", description: "Category sys_id" },
		price: { type: "string", description: "Item price" },
		workflow: { type: "string", description: "Fulfillment workflow" },
		},
		required: ["name", "short_description"],
		},
		},
		{
		name: "snow_create_catalog_variable",
		description: "Creates variables for catalog items using item_option_new table.",
		inputSchema: {
		type: "object",
		properties: {
		cat_item: { type: "string", description: "Catalog item sys_id" },
		name: { type: "string", description: "Variable name" },
		question_text: { type: "string", description: "Question to display" },
		type: { type: "string", description: "Variable type" },
		mandatory: { type: "boolean", default: false },
		},
		required: ["cat_item", "name", "question_text"],
		},
		},
		{
		name: "snow_create_catalog_ui_policy",
		description: "Creates UI policies for catalog items using catalog_ui_policy table.",
		inputSchema: {
		type: "object",
		properties: {
		cat_item: { type: "string", description: "Catalog item sys_id" },
		short_description: { type: "string", description: "Policy name" },
		condition: { type: "string", description: "When to apply" },
		actions: { type: "array", items: { type: "object" } },
		},
		required: ["cat_item", "short_description"],
		},
		},
		{
		name: "snow_order_catalog_item",
		description: "Submits catalog item order using sc_req_item table.",
		inputSchema: {
		type: "object",
		properties: {
		cat_item: { type: "string", description: "Catalog item sys_id" },
		requested_for: { type: "string", description: "User sys_id" },
		variables: { type: "object", description: "Variable values" },
		quantity: { type: "number", default: 1 },
		},
		required: ["cat_item"],
		},
		},
		{
		name: "snow_search_catalog",
		description: "Searches service catalog items in sc_cat_item table.",
		inputSchema: {
		type: "object",
		properties: {
		query: { type: "string", description: "Search text" },
		category: { type: "string", description: "Filter by category" },
		active_only: { type: "boolean", default: true },
		limit: { type: "number", default: 10 },
		},
		required: ["query"],
		},
		},
		{
		name: "snow_get_catalog_item_details",
		description: "Gets full details of catalog item from sc_cat_item table.",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: { type: "string", description: "Catalog item sys_id" },
		include_variables: { type: "boolean", default: true },
		},
		required: ["sys_id"],
		},
		},
		{
		name: "snow_discover_catalogs",
		description: "Discovers catalog structure from sc_catalog table.",
		inputSchema: {
		type: "object",
		properties: {
		include_categories: { type: "boolean", default: true },
		},
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Execute with enhanced tracking
		return await this.executeTool(name, async () => {
		switch (name) {
		case "snow_create_knowledge_article":
		return await this.createKnowledgeArticle(args as any)
		case "snow_search_knowledge":
		return await this.searchKnowledge(args as any)
		case "snow_update_knowledge_article":
		return await this.updateKnowledgeArticle(args as any)
		case "snow_retire_knowledge_article":
		return await this.retireKnowledgeArticle(args as any)
		case "snow_create_knowledge_base":
		return await this.createKnowledgeBase(args as any)
		case "snow_discover_knowledge_bases":
		return await this.discoverKnowledgeBases(args as any)
		case "snow_get_knowledge_stats":
		return await this.getKnowledgeStats(args as any)
		case "snow_knowledge_feedback":
		return await this.knowledgeFeedback(args as any)
		case "snow_create_catalog_item":
		return await this.createCatalogItem(args as any)
		case "snow_create_catalog_variable":
		return await this.createCatalogVariable(args as any)
		case "snow_create_catalog_ui_policy":
		return await this.createCatalogUIPolicy(args as any)
		case "snow_order_catalog_item":
		return await this.orderCatalogItem(args as any)
		case "snow_search_catalog":
		return await this.searchCatalog(args as any)
		case "snow_get_catalog_item_details":
		return await this.getCatalogItemDetails(args as any)
		case "snow_discover_catalogs":
		return await this.discoverCatalogs(args as any)
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}
		})
		} catch (error) {
		if (error instanceof McpError) throw error
		throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error}`)
		}
		})
		}

		/**
		* Create Knowledge Article with enhanced tracking
		*/
		private async createKnowledgeArticle(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating knowledge article...", {
		title: args.short_description,
		hasContent: !!args.text,
		contentLength: args.text?.length,
		})

		// Validate connection
		const connCheck = await this.validateConnection()
		if (!connCheck.success) {
		return this.createResponse(`❌ Connection failed: ${connCheck.error}`)
		}

		// Progress indicator
		this.logger.progress("Building knowledge article data...")

		const articleData = {
		short_description: args.short_description,
		text: args.text,
		kb_knowledge_base: args.kb_knowledge_base \|\| "",
		kb_category: args.kb_category \|\| "",
		article_type: args.article_type \|\| "text",
		workflow_state: args.workflow_state \|\| "draft",
		valid_to: args.valid_to \|\| "",
		meta_description: args.meta_description \|\| "",
		keywords: args.keywords?.join(",") \|\| "",
		author: args.author \|\| "",
		}

		this.logger.progress("Creating article in ServiceNow...")

		// Create with tracking
		const response = await this.createRecord("kb_knowledge", articleData)

		if (!response.success) {
		this.logger.error("Failed to create knowledge article", response.error)
		return this.createResponse(`❌ Failed to create article: ${response.error}`)
		}

		// Success with details
		const result = response.data
		this.logger.info("✅ Knowledge article created successfully", {
		sys_id: result.sys_id,
		number: result.number,
		title: args.short_description,
		})

		return this.createResponse(
		`✅ Knowledge Article created successfully!

		📚 ${args.short_description}
		🆔 sys_id: ${result.sys_id}
		📋 Number: ${result.number}
		📊 State: ${args.workflow_state \|\| "draft"}
		📝 Type: ${args.article_type \|\| "text"}
		${args.kb_knowledge_base ? `📁 Knowledge Base: ${args.kb_knowledge_base}` : ""}
		${args.kb_category ? `🏷️ Category: ${args.kb_category}` : ""}
		${args.valid_to ? `📅 Valid Until: ${args.valid_to}` : ""}

		✨ Article created and ready for review!`,
		)
		}

		/**
		* Search Knowledge with enhanced tracking
		*/
		private async searchKnowledge(args: any): Promise<MCPToolResult> {
		this.logger.info("Searching knowledge articles...", {
		query: args.query,
		limit: args.limit \|\| 10,
		includeContent: args.include_content,
		})

		// Build query
		let query = `short_descriptionLIKE${args.query}^ORtextLIKE${args.query}`

		if (args.kb_knowledge_base) {
		query += `^kb_knowledge_base=${args.kb_knowledge_base}`
		}
		if (args.kb_category) {
		query += `^kb_category=${args.kb_category}`
		}
		if (args.workflow_state) {
		query += `^workflow_state=${args.workflow_state}`
		} else {
		query += "^workflow_state=published" // Default to published only
		}

		this.logger.progress(`Searching kb_knowledge table for: "${args.query}"...`)

		// Search with tracking
		const limit = args.limit \|\| 10
		const response = await this.queryTable("kb_knowledge", query, limit)

		if (!response.success) {
		this.logger.error("Knowledge search failed", response.error)
		return this.createResponse(`❌ Search failed: ${response.error}`)
		}

		const articles = response.data.result

		if (!articles.length) {
		this.logger.info("No articles found", { query: args.query })
		return this.createResponse(`❌ No knowledge articles found matching "${args.query}"`)
		}

		this.logger.info(`Found ${articles.length} knowledge articles`)

		// Format results
		const articleList = articles
		.map((article: any) => {
		const snippet = args.include_content ? article.text?.substring(0, 200) + "..." : article.short_description

		return `📄 ${article.short_description}
		🆔 ${article.sys_id}
		📊 State: ${article.workflow_state}
		📅 Updated: ${article.sys_updated_on}
		${args.include_content ? `📝 ${snippet}` : ""}`
		})
		.join("\n\n")

		return this.createResponse(
		`🔍 Knowledge Search Results for "${args.query}":

		${articleList}

		✨ Found ${articles.length} article(s)`,
		)
		}

		/**
		* Update Knowledge Article
		*/
		private async updateKnowledgeArticle(args: any): Promise<MCPToolResult> {
		this.logger.info("Updating knowledge article...", { sys_id: args.sys_id })

		const updateData: any = {}
		if (args.short_description) updateData.short_description = args.short_description
		if (args.text) updateData.text = args.text
		if (args.workflow_state) updateData.workflow_state = args.workflow_state
		if (args.valid_to) updateData.valid_to = args.valid_to
		if (args.keywords) updateData.keywords = args.keywords.join(",")

		this.logger.progress("Updating article in ServiceNow...")
		const response = await this.updateRecord("kb_knowledge", args.sys_id, updateData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to update article: ${response.error}`)
		}

		this.logger.info("✅ Article updated successfully")
		return this.createResponse(`✅ Knowledge article updated successfully!\n🆔 sys_id: ${args.sys_id}`)
		}

		/**
		* Retire Knowledge Article
		*/
		private async retireKnowledgeArticle(args: any): Promise<MCPToolResult> {
		this.logger.info("Retiring knowledge article...", { sys_id: args.sys_id })

		const updateData = {
		workflow_state: "retired",
		u_retirement_reason: args.retirement_reason \|\| "Retired via API",
		}

		const response = await this.updateRecord("kb_knowledge", args.sys_id, updateData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to retire article: ${response.error}`)
		}

		this.logger.info("✅ Article retired successfully")
		return this.createResponse(`✅ Knowledge article retired!\n🆔 sys_id: ${args.sys_id}`)
		}

		/**
		* Create Knowledge Base
		*/
		private async createKnowledgeBase(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating knowledge base...", { title: args.title })

		const kbData = {
		title: args.title,
		description: args.description \|\| "",
		owner: args.owner \|\| "",
		kb_managers: args.kb_managers?.join(",") \|\| "",
		}

		this.logger.progress("Creating KB in ServiceNow...")
		const response = await this.createRecord("kb_knowledge_base", kbData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create KB: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ Knowledge base created", { sys_id: result.sys_id })

		return this.createResponse(`✅ Knowledge Base created!\n📚 ${args.title}\n🆔 sys_id: ${result.sys_id}`)
		}

		/**
		* Discover Knowledge Bases
		*/
		private async discoverKnowledgeBases(args: any): Promise<MCPToolResult> {
		this.logger.info("Discovering knowledge bases...")

		const query = args.active_only ? "active=true" : ""
		const response = await this.queryTable("kb_knowledge_base", query, 50)

		if (!response.success) {
		return this.createResponse(`❌ Failed to discover KBs: ${response.error}`)
		}

		const kbs = response.data.result
		this.logger.info(`Found ${kbs.length} knowledge bases`)

		const kbList = kbs
		.map((kb: any) => `📚 ${kb.title}\n🆔 ${kb.sys_id}\n📝 ${kb.description \|\| "No description"}`)
		.join("\n\n")

		return this.createResponse(`📚 Knowledge Bases Found:\n\n${kbList}\n\n✨ Total: ${kbs.length} knowledge base(s)`)
		}

		/**
		* Get Knowledge Stats
		*/
		private async getKnowledgeStats(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting knowledge statistics...")

		let query = "active=true"
		if (args.kb_knowledge_base) {
		query += `^kb_knowledge_base=${args.kb_knowledge_base}`
		}

		this.logger.progress("Gathering statistics...")

		// Get article counts by state
		const states = ["draft", "review", "published", "retired"]
		const stats: any = { total: 0, by_state: {} }

		for (const state of states) {
		const stateQuery = `${query}^workflow_state=${state}`
		const response = await this.queryTable("kb_knowledge", stateQuery, 1)

		if (response.success && response.data.headers) {
		const count = parseInt(response.data.headers["x-total-count"] \|\| "0")
		stats.by_state[state] = count
		stats.total += count
		}
		}

		this.logger.info("✅ Statistics gathered", stats)

		return this.createResponse(
		`📊 Knowledge Base Statistics:\n\n` +
		`📚 Total Articles: ${stats.total}\n` +
		`📝 Draft: ${stats.by_state.draft \|\| 0}\n` +
		`👁️ In Review: ${stats.by_state.review \|\| 0}\n` +
		`✅ Published: ${stats.by_state.published \|\| 0}\n` +
		`🗄️ Retired: ${stats.by_state.retired \|\| 0}`,
		)
		}

		/**
		* Knowledge Feedback
		*/
		private async knowledgeFeedback(args: any): Promise<MCPToolResult> {
		this.logger.info("Managing knowledge feedback...", { article_id: args.article_id })

		if (args.rating \|\| args.comments) {
		// Create feedback
		const feedbackData = {
		article: args.article_id,
		rating: args.rating \|\| 0,
		comments: args.comments \|\| "",
		user: "api_user",
		}

		this.logger.progress("Submitting feedback...")
		const response = await this.createRecord("kb_feedback", feedbackData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to submit feedback: ${response.error}`)
		}

		this.logger.info("✅ Feedback submitted")
		return this.createResponse(`✅ Feedback submitted!\n⭐ Rating: ${args.rating \|\| "N/A"}`)
		} else {
		// Get feedback for article
		const query = `article=${args.article_id}`
		const response = await this.queryTable("kb_feedback", query, 10)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get feedback: ${response.error}`)
		}

		const feedback = response.data.result
		const avgRating =
		feedback.length > 0
		? (feedback.reduce((sum: number, f: any) => sum + (f.rating \|\| 0), 0) / feedback.length).toFixed(1)
		: "N/A"

		return this.createResponse(
		`📊 Article Feedback:\n⭐ Average Rating: ${avgRating}\n💬 ${feedback.length} feedback entries`,
		)
		}
		}

		/**
		* Create Catalog Item
		*/
		private async createCatalogItem(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating catalog item...", { name: args.name })

		const itemData = {
		name: args.name,
		short_description: args.short_description,
		category: args.category \|\| "",
		price: args.price \|\| "0",
		workflow: args.workflow \|\| "",
		active: true,
		}

		this.logger.progress("Creating item in ServiceNow...")
		const response = await this.createRecord("sc_cat_item", itemData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create catalog item: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ Catalog item created", { sys_id: result.sys_id })

		return this.createResponse(
		`✅ Catalog Item created!\n🛍️ ${args.name}\n🆔 sys_id: ${result.sys_id}\n💰 Price: ${args.price \|\| "0"}`,
		)
		}

		/**
		* Create Catalog Variable
		*/
		private async createCatalogVariable(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating catalog variable...", { name: args.name })

		const varData = {
		cat_item: args.cat_item,
		name: args.name,
		question_text: args.question_text,
		type: args.type \|\| "6", // Single line text
		mandatory: args.mandatory \|\| false,
		order: 100,
		}

		this.logger.progress("Creating variable...")
		const response = await this.createRecord("item_option_new", varData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create variable: ${response.error}`)
		}

		this.logger.info("✅ Variable created")
		return this.createResponse(`✅ Catalog variable created!\n📝 ${args.question_text}\n🔤 Name: ${args.name}`)
		}

		/**
		* Create Catalog UI Policy
		*/
		private async createCatalogUIPolicy(args: any): Promise<MCPToolResult> {
		this.logger.info("Creating catalog UI policy...", { short_description: args.short_description })

		const policyData = {
		cat_item: args.cat_item,
		short_description: args.short_description,
		condition: args.condition \|\| "",
		active: true,
		}

		this.logger.progress("Creating UI policy...")
		const response = await this.createRecord("catalog_ui_policy", policyData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to create UI policy: ${response.error}`)
		}

		this.logger.info("✅ UI policy created")
		return this.createResponse(
		`✅ Catalog UI Policy created!\n📋 ${args.short_description}\n🆔 sys_id: ${response.data.sys_id}`,
		)
		}

		/**
		* Order Catalog Item
		*/
		private async orderCatalogItem(args: any): Promise<MCPToolResult> {
		this.logger.info("Ordering catalog item...", { cat_item: args.cat_item })

		const orderData = {
		cat_item: args.cat_item,
		requested_for: args.requested_for \|\| "current_user",
		quantity: args.quantity \|\| 1,
		variables: JSON.stringify(args.variables \|\| {}),
		}

		this.logger.progress("Submitting order...")
		const response = await this.createRecord("sc_req_item", orderData)

		if (!response.success) {
		return this.createResponse(`❌ Failed to order item: ${response.error}`)
		}

		const result = response.data
		this.logger.info("✅ Order submitted", { number: result.number })

		return this.createResponse(
		`✅ Catalog item ordered!\n📦 Request: ${result.number}\n🆔 sys_id: ${result.sys_id}\n📊 Status: ${result.state \|\| "Submitted"}`,
		)
		}

		/**
		* Search Catalog
		*/
		private async searchCatalog(args: any): Promise<MCPToolResult> {
		this.logger.info("Searching service catalog...", { query: args.query })

		let query = `nameLIKE${args.query}^ORshort_descriptionLIKE${args.query}`
		if (args.category) {
		query += `^category=${args.category}`
		}
		if (args.active_only) {
		query += "^active=true"
		}

		this.logger.progress("Searching catalog...")
		const response = await this.queryTable("sc_cat_item", query, args.limit \|\| 10)

		if (!response.success) {
		return this.createResponse(`❌ Search failed: ${response.error}`)
		}

		const items = response.data.result

		if (!items.length) {
		return this.createResponse(`❌ No catalog items found matching "${args.query}"`)
		}

		this.logger.info(`Found ${items.length} catalog items`)

		const itemList = items
		.map(
		(item: any) => `🛍️ ${item.name}\n📝 ${item.short_description}\n💰 ${item.price \|\| "0"}\n🆔 ${item.sys_id}`,
		)
		.join("\n\n")

		return this.createResponse(`🔍 Catalog Search Results:\n\n${itemList}\n\n✨ Found ${items.length} item(s)`)
		}

		/**
		* Get Catalog Item Details
		*/
		private async getCatalogItemDetails(args: any): Promise<MCPToolResult> {
		this.logger.info("Getting catalog item details...", { sys_id: args.sys_id })

		const response = await this.getRecord("sc_cat_item", args.sys_id)

		if (!response.success) {
		return this.createResponse(`❌ Failed to get item details: ${response.error}`)
		}

		const item = response.data
		let details =
		`🛍️ ${item.name}\n` +
		`📝 ${item.short_description}\n` +
		`💰 Price: ${item.price \|\| "0"}\n` +
		`📊 Active: ${item.active}\n` +
		`🆔 sys_id: ${item.sys_id}`

		if (args.include_variables) {
		// Get variables
		const varQuery = `cat_item=${args.sys_id}`
		const varResponse = await this.queryTable("item_option_new", varQuery, 50)

		if (varResponse.success && varResponse.data.result.length > 0) {
		const variables = varResponse.data.result
		details += `\n\n📋 Variables (${variables.length}):\n`
		variables.forEach((v: any) => {
		details += ` • ${v.question_text} (${v.name})\n`
		})
		}
		}

		this.logger.info("✅ Retrieved item details")
		return this.createResponse(details)
		}

		/**
		* Discover Catalogs
		*/
		private async discoverCatalogs(args: any): Promise<MCPToolResult> {
		this.logger.info("Discovering service catalogs...")

		const response = await this.queryTable("sc_catalog", "active=true", 20)

		if (!response.success) {
		return this.createResponse(`❌ Failed to discover catalogs: ${response.error}`)
		}

		const catalogs = response.data.result
		this.logger.info(`Found ${catalogs.length} catalogs`)

		let catalogInfo = `📚 Service Catalogs:\n\n`

		for (const catalog of catalogs) {
		catalogInfo += `🛍️ ${catalog.title}\n🆔 ${catalog.sys_id}\n`

		if (args.include_categories) {
		// Get categories for this catalog
		const catQuery = `sc_catalog=${catalog.sys_id}^active=true`
		const catResponse = await this.queryTable("sc_category", catQuery, 10)

		if (catResponse.success && catResponse.data.result.length > 0) {
		catalogInfo += `📁 Categories:\n`
		catResponse.data.result.forEach((cat: any) => {
		catalogInfo += ` • ${cat.title}\n`
		})
		}
		}
		catalogInfo += "\n"
		}

		return this.createResponse(`${catalogInfo}✨ Total: ${catalogs.length} catalog(s) discovered`)
		}

		async start() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)

		// Log ready state
		this.logger.info("🚀 ServiceNow Knowledge & Catalog MCP Server (Enhanced) running")
		this.logger.info("📊 Token tracking enabled")
		this.logger.info("⏳ Progress indicators active")
		}
		}

		// Start the enhanced server
		const server = new ServiceNowKnowledgeCatalogMCPEnhanced()
		server.start().catch((error) => {
		console.error("Failed to start enhanced server:", error)
		process.exit(1)
		})

src/servicenow/servicenow-knowledge-catalog-mcp.ts

Sorry, the diff of this file is too big to display

-629

src/servicenow/servicenow-local-development-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Local Development MCP Server
		*
		* Bridges ServiceNow artifacts with Claude Code's native file tools
		* by creating temporary local files that can be edited with full
		* Claude Code capabilities, then synced back to ServiceNow.
		*
		* THIS IS THE KEY TO POWERFUL SERVICENOW DEVELOPMENT!
		*/

		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { EnhancedBaseMCPServer, MCPToolResult } from "./shared/enhanced-base-mcp-server.js"
		import { ArtifactLocalSync } from "../utils/artifact-local-sync.js"
		import {
		ARTIFACT_REGISTRY,
		getSupportedTables,
		getTableDisplayName,
		isTableSupported,
		type ValidationResult,
		} from "../utils/artifact-sync/artifact-registry.js"

		export class ServiceNowLocalDevelopmentMCP extends EnhancedBaseMCPServer {
		private syncManager: ArtifactLocalSync

		constructor() {
		super("servicenow-local-development", "1.0.0")

		// Initialize after client is available
		this.setupSyncManager()
		this.setupHandlers()
		}

		private setupSyncManager(): void {
		// Initialize sync manager with the client from enhanced base server
		this.syncManager = new ArtifactLocalSync(this.client as any)
		this.logger.info("🔧 Local sync manager initialized")
		}

		private setupHandlers(): void {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_pull_artifact",
		description: `Pull ANY ServiceNow artifact to local files for editing with Claude Code's native tools. Automatically detects the artifact type and creates appropriate files based on the artifact registry. Supports: ${getSupportedTables()
		.map((t) => getTableDisplayName(t))
		.join(", ")}`,
		inputSchema: {
		type: "object",
		properties: {
		sys_id: {
		type: "string",
		description: "Artifact sys_id to pull",
		},
		table: {
		type: "string",
		description: "Optional: Specify table name if known for faster processing",
		enum: getSupportedTables(),
		},
		},
		required: ["sys_id"],
		},
		},
		{
		name: "snow_push_artifact",
		description: "Push local artifact changes back to ServiceNow with validation and coherence checking",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: {
		type: "string",
		description: "Artifact sys_id to push back",
		},
		force: {
		type: "boolean",
		description: "Force push despite validation warnings",
		default: false,
		},
		},
		required: ["sys_id"],
		},
		},
		{
		name: "snow_validate_artifact_coherence",
		description:
		"Validate coherence and relationships between artifact components (e.g., widget HTML-client-server relationships)",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: {
		type: "string",
		description: "Artifact sys_id to validate",
		},
		},
		required: ["sys_id"],
		},
		},
		{
		name: "snow_list_supported_artifacts",
		description: "List all supported artifact types for local synchronization",
		inputSchema: {
		type: "object",
		properties: {},
		additionalProperties: false,
		},
		},
		{
		name: "snow_sync_status",
		description: "Check sync status of local artifacts",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: {
		type: "string",
		description: "Optional: Check specific artifact, or all if omitted",
		},
		},
		},
		},
		{
		name: "snow_sync_cleanup",
		description: "Clean up local artifact files after successful sync",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: {
		type: "string",
		description: "Artifact sys_id to clean up",
		},
		force: {
		type: "boolean",
		description: "Force cleanup even with unsaved changes",
		default: false,
		},
		},
		required: ["sys_id"],
		},
		},
		{
		name: "snow_convert_to_es5",
		description: "Convert modern JavaScript code to ES5 for ServiceNow compatibility",
		inputSchema: {
		type: "object",
		properties: {
		code: {
		type: "string",
		description: "JavaScript code to convert to ES5",
		},
		context: {
		type: "string",
		description: "Context: server_script, client_script, business_rule, etc.",
		enum: ["server_script", "client_script", "business_rule", "script_include", "ui_script"],
		},
		},
		required: ["code"],
		},
		},
		{
		name: "snow_debug_widget_fetch",
		description: "Debug widget fetching to diagnose API issues",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: {
		type: "string",
		description: "Widget sys_id to debug",
		},
		},
		required: ["sys_id"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		const { name, arguments: args } = request.params

		// Add timeout protection for MCP tool execution
		const TOOL_TIMEOUT = 10000 // 10 seconds max per tool call

		try {
		this.logger.info(`🔧 Executing tool: ${name}`, args)

		// Create timeout promise
		const timeoutPromise = new Promise<MCPToolResult>((_, reject) => {
		setTimeout(() => reject(new Error(`Tool ${name} timed out after ${TOOL_TIMEOUT / 1000}s`)), TOOL_TIMEOUT)
		})

		// Execute tool with timeout protection
		const toolPromise = (async (): Promise<MCPToolResult> => {
		let result: MCPToolResult

		switch (name) {
		case "snow_pull_artifact":
		result = await this.pullArtifact(args)
		break

		case "snow_push_artifact":
		result = await this.pushArtifact(args)
		break

		case "snow_validate_artifact_coherence":
		result = await this.validateArtifactCoherence(args)
		break

		case "snow_sync_status":
		result = await this.getSyncStatus(args)
		break

		case "snow_list_supported_artifacts":
		result = await this.listSupportedArtifacts(args)
		break

		case "snow_sync_cleanup":
		result = await this.syncCleanup(args)
		break

		case "snow_convert_to_es5":
		result = await this.convertToES5(args)
		break

		case "snow_debug_widget_fetch":
		result = await this.debugWidgetFetch(args)
		break

		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		return result
		})()

		// Race between tool execution and timeout
		const result = await Promise.race([toolPromise, timeoutPromise])

		this.logger.info(`✅ Tool ${name} completed successfully`)
		return {
		content: result.content,
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		this.logger.error(`❌ Tool ${name} failed: ${errorMessage}`)

		return {
		content: [
		{
		type: "text",
		text: `Error executing ${name}: ${errorMessage}`,
		},
		],
		}
		}
		})
		}

		private async pullArtifact(args: any): Promise<MCPToolResult> {
		const { sys_id, table } = args
		const startTime = Date.now()

		// Add timeout for pull operations (must be longer than pullArtifactBySysId's 30s timeout)
		const PULL_TIMEOUT = 35000 // 35 seconds for pull operations (allows 30s for detection + 5s buffer)

		try {
		const pullPromise = (async () => {
		let artifact
		if (table) {
		// Use specified table
		artifact = await this.syncManager.pullArtifact(table, sys_id)
		} else {
		// Auto-detect table
		artifact = await this.syncManager.pullArtifactBySysId(sys_id)
		}
		return artifact
		})()

		const timeoutPromise = new Promise((_, reject) => {
		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: [
		{
		type: "text",
		text: `✅ Successfully pulled ${artifact.type} to local files at: ${artifact.localPath}\n\n📁 Files created:\n${artifact.files.map((f) => ` - ${f.filename} (${f.type})`).join("\n")}\n\n💡 You can now use Claude Code's native tools to edit these files!`,
		},
		],
		}
		} 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: [
		{
		type: "text",
		text: `❌ Failed to pull artifact: ${errorMessage}`,
		},
		],
		}
		}
		}

		private async pushArtifact(args: any): Promise<MCPToolResult> {
		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: [
		{
		type: "text",
		text: success
		? `✅ Successfully pushed changes back to ServiceNow!`
		: `❌ Failed to push changes. Check logs for details.`,
		},
		],
		}
		} 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: [
		{
		type: "text",
		text: `❌ Failed to push artifact: ${errorMessage}`,
		},
		],
		}
		}
		}

		private async getSyncStatus(args: any): Promise<MCPToolResult> {
		const { sys_id } = args

		if (sys_id) {
		const status = this.syncManager.getSyncStatus(sys_id)
		return {
		content: [
		{
		type: "text",
		text: `Sync status for ${sys_id}: ${status}`,
		},
		],
		}
		} else {
		const artifacts = this.syncManager.listLocalArtifacts()
		const statusText =
		artifacts.length > 0
		? artifacts.map((a) => `${a.name} (${a.sys_id}): ${a.syncStatus}`).join("\n")
		: "No local artifacts found"

		return {
		content: [
		{
		type: "text",
		text: `Local artifacts status:\n${statusText}`,
		},
		],
		}
		}
		}

		private async listSupportedArtifacts(args: any): Promise<MCPToolResult> {
		const supportedTypes = getSupportedTables().map((table) => {
		const config = ARTIFACT_REGISTRY[table]
		return {
		table,
		displayName: config?.displayName \|\| table,
		folderName: config?.folderName \|\| table,
		fields: config?.fieldMappings.length \|\| 0,
		hasCoherence: (config?.coherenceRules?.length \|\| 0) > 0,
		requiresES5: config?.fieldMappings.some((fm) => fm.validateES5) \|\| false,
		}
		})

		return {
		content: [
		{
		type: "text",
		text: `Supported ServiceNow artifact types for local sync:\n\n${supportedTypes
		.map(
		(t) =>
		`📦 ${t.displayName} (${t.table})\n └── ${t.fields} fields, ES5: ${t.requiresES5 ? "✅" : "❌"}, Coherence: ${t.hasCoherence ? "✅" : "❌"}`,
		)
		.join("\n\n")}\n\nTotal: ${supportedTypes.length} artifact types supported`,
		},
		],
		}
		}

		private async validateArtifactCoherence(args: any): Promise<MCPToolResult> {
		const { sys_id } = args

		try {
		const results = await this.syncManager.validateArtifactCoherence(sys_id)
		const hasErrors = results.some((r) => !r.valid)

		return {
		content: [
		{
		type: "text",
		text: hasErrors
		? `⚠️ Coherence validation found issues:\n${results
		.filter((r) => !r.valid)
		.map((r) => r.errors.join(", "))
		.join("\n")}`
		: `✅ Artifact coherence validation passed!`,
		},
		],
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		return {
		content: [
		{
		type: "text",
		text: `❌ Failed to validate coherence: ${errorMessage}`,
		},
		],
		}
		}
		}

		private async syncCleanup(args: any): Promise<MCPToolResult> {
		const { sys_id, force = false } = args

		try {
		await this.syncManager.cleanup(sys_id, force)

		return {
		content: [
		{
		type: "text",
		text: `✅ Successfully cleaned up local files for ${sys_id}`,
		},
		],
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		return {
		content: [
		{
		type: "text",
		text: `❌ Failed to cleanup: ${errorMessage}`,
		},
		],
		}
		}
		}

		private async convertToES5(args: any): Promise<MCPToolResult> {
		const { code, context = "server_script" } = args

		// Basic ES5 conversion - in a real implementation this would be more sophisticated
		let es5Code = code
		.replace(/\bconst\s+/g, "var ")
		.replace(/\blet\s+/g, "var ")
		.replace(/(\w+)\s=>\s{/g, "function($1) {")
		.replace(/(\w+)\s=>\s([^{])/g, "function($1) { return $2; }")
		.replace(/`([^`]*)`/g, (match, content) => {
		return '"' + content.replace(/\$\{([^}]+)\}/g, '" + $1 + "') + '"'
		})

		return {
		content: [
		{
		type: "text",
		text: `✅ Converted to ES5 (basic conversion):\n\n\`\`\`javascript\n${es5Code}\n\`\`\`\n\n⚠️ Note: This is a basic conversion. Please review and test the code.`,
		},
		],
		}
		}

		private async debugWidgetFetch(args: any): Promise<MCPToolResult> {
		const { sys_id } = args

		// Debug operations get extra time
		const DEBUG_TIMEOUT = 20000 // 20 seconds for debug operations

		try {
		const debugPromise = this.syncManager["smartFetcher"].debugFetchWidget(sys_id)
		const timeoutPromise = new Promise((_, reject) => {
		setTimeout(() => reject(new Error(`Debug operation timed out after ${DEBUG_TIMEOUT / 1000}s`)), DEBUG_TIMEOUT)
		})

		const debugResults = await Promise.race([debugPromise, timeoutPromise])

		let summaryText = `🔍 Debug Results for Widget ${sys_id}\n\n`

		// Check which methods worked
		const methods = ["searchRecords", "getRecord", "searchRecordsWithFields"]
		for (const method of methods) {
		if (debugResults[method]) {
		const widget = debugResults[method]
		summaryText += `✅ ${method}:\n`
		summaryText += ` - Fields: ${Object.keys(widget).length}\n`
		summaryText += ` - Has script: ${!!widget.script}\n`
		summaryText += ` - Has client_script: ${!!widget.client_script}\n`
		summaryText += ` - Has template: ${!!widget.template}\n`
		summaryText += ` - Script size: ${widget.script?.length \|\| 0} chars\n`
		summaryText += ` - Client script size: ${widget.client_script?.length \|\| 0} chars\n`
		summaryText += ` - Template size: ${widget.template?.length \|\| 0} chars\n\n`
		} else {
		summaryText += `❌ ${method}: Failed\n\n`
		}
		}

		// Recommend best approach
		const workingMethods = methods.filter((m) => debugResults[m])
		if (workingMethods.length > 0) {
		summaryText += `\n📊 Recommendation: Use ${workingMethods[0]} for fetching this widget.`
		} else {
		summaryText += `\n⚠️ All fetch methods failed. There may be an authentication or permission issue.`
		}

		return {
		content: [
		{
		type: "text",
		text: summaryText,
		},
		],
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		return {
		content: [
		{
		type: "text",
		text: `❌ Debug failed: ${errorMessage}`,
		},
		],
		}
		}
		}
		}

		// Start the server with timeout protection
		async function main() {
		try {
		const mcpServer = new ServiceNowLocalDevelopmentMCP()
		const transport = new StdioServerTransport()

		// Add timeout for server initialization
		const INIT_TIMEOUT = 5000 // 5 seconds to start

		const connectPromise = (mcpServer as any).server.connect(transport)
		const timeoutPromise = new Promise((_, reject) => {
		setTimeout(() => reject(new Error("Server initialization timeout")), INIT_TIMEOUT)
		})

		await Promise.race([connectPromise, timeoutPromise])
		console.error("🚀 ServiceNow Local Development MCP Server started")
		} catch (error) {
		console.error("❌ Server failed to start within timeout:", error)
		// Still allow server to run even if initial connection takes time
		console.error("⏳ Server may still be initializing...")
		}
		}

		if (require.main === module) {
		main().catch((error) => {
		console.error("❌ Server failed to start:", error)
		process.exit(1)
		})
		}

src/servicenow/servicenow-machine-learning-mcp.ts

Sorry, the diff of this file is too big to display

-736

src/servicenow/servicenow-mcp-server.ts

		#!/usr/bin/env node
		/**
		* ServiceNow MCP Server
		* Provides Claude Code with direct access to ServiceNow APIs via MCP protocol
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import {
		CallToolRequestSchema,
		ListToolsRequestSchema,
		Tool,
		CallToolResult,
		TextContent,
		ImageContent,
		EmbeddedResource,
		} from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { ServiceNowOAuth } from "../utils/snow-oauth.js"

		interface ServiceNowMCPConfig {
		name: string
		version: string
		oauth?: {
		instance: string
		clientId: string
		clientSecret: string
		}
		}

		class ServiceNowMCPServer {
		private server: Server
		private snowClient: ServiceNowClient
		private oauth: ServiceNowOAuth
		private config: ServiceNowMCPConfig
		private isAuthenticated: boolean = false

		constructor(config: ServiceNowMCPConfig) {
		this.config = config
		this.oauth = new ServiceNowOAuth()
		this.snowClient = new ServiceNowClient()

		this.server = new Server(
		{
		name: config.name,
		version: config.version,
		},
		{
		capabilities: {
		tools: {},
		},
		},
		)

		this.setupToolHandlers()
		this.setupRequestHandlers()
		}

		private async checkAuthentication(): Promise<boolean> {
		try {
		this.isAuthenticated = await this.oauth.isAuthenticated()
		return this.isAuthenticated
		} catch (error) {
		console.error("Authentication check failed:", error)
		return false
		}
		}

		private setupRequestHandlers(): void {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => {
		const isAuth = await this.checkAuthentication()

		const tools: Tool[] = [
		{
		name: "snow_auth_status",
		description: "Check ServiceNow authentication status",
		inputSchema: {
		type: "object",
		properties: {},
		required: [],
		},
		},
		]

		if (isAuth) {
		tools.push(
		{
		name: "snow_create_widget",
		description: "Create a new ServiceNow Service Portal widget",
		inputSchema: {
		type: "object",
		properties: {
		name: {
		type: "string",
		description: "Widget name",
		},
		id: {
		type: "string",
		description: "Widget ID (unique identifier)",
		},
		title: {
		type: "string",
		description: "Widget display title",
		},
		description: {
		type: "string",
		description: "Widget description",
		},
		template: {
		type: "string",
		description: "HTML template for the widget",
		},
		css: {
		type: "string",
		description: "CSS styling for the widget",
		},
		client_script: {
		type: "string",
		description: "Client-side AngularJS script",
		},
		server_script: {
		type: "string",
		description: "Server-side script",
		},
		category: {
		type: "string",
		description: "Widget category (e.g., 'incident', 'custom')",
		},
		},
		required: ["name", "id", "title", "description", "template", "css", "client_script", "server_script"],
		},
		},
		{
		name: "snow_update_widget",
		description: "Update an existing ServiceNow widget",
		inputSchema: {
		type: "object",
		properties: {
		sys_id: {
		type: "string",
		description: "System ID of the widget to update",
		},
		updates: {
		type: "object",
		description: "Object containing fields to update",
		properties: {
		name: { type: "string" },
		title: { type: "string" },
		description: { type: "string" },
		template: { type: "string" },
		css: { type: "string" },
		client_script: { type: "string" },
		server_script: { type: "string" },
		},
		},
		},
		required: ["sys_id", "updates"],
		},
		},
		{
		name: "snow_get_widget",
		description: "Get details of a ServiceNow widget by ID",
		inputSchema: {
		type: "object",
		properties: {
		widget_id: {
		type: "string",
		description: "Widget ID to retrieve",
		},
		},
		required: ["widget_id"],
		},
		},
		{
		name: "snow_list_widgets",
		description: "List all ServiceNow widgets",
		inputSchema: {
		type: "object",
		properties: {
		limit: {
		type: "number",
		description: "Maximum number of widgets to return (default: 50)",
		},
		},
		required: [],
		},
		},
		{
		name: "snow_create_workflow",
		description: "Create a new ServiceNow workflow",
		inputSchema: {
		type: "object",
		properties: {
		name: {
		type: "string",
		description: "Workflow name",
		},
		description: {
		type: "string",
		description: "Workflow description",
		},
		active: {
		type: "boolean",
		description: "Whether workflow is active",
		},
		workflow_version: {
		type: "string",
		description: "Workflow version",
		},
		table: {
		type: "string",
		description: "Table this workflow applies to",
		},
		condition: {
		type: "string",
		description: "Workflow activation condition",
		},
		},
		required: ["name", "description", "active", "workflow_version"],
		},
		},
		{
		name: "snow_execute_script",
		description:
		"Execute server-side JavaScript on ServiceNow. Primary: synchronous execution via Scripted REST API (~1-3s). Fallback: scheduled job if endpoint unavailable. ES5 only (Rhino engine)!",
		inputSchema: {
		type: "object",
		properties: {
		script: {
		type: "string",
		description: "JavaScript code to schedule (ES5 only!)",
		},
		description: {
		type: "string",
		description: "Description of what the script does",
		},
		},
		required: ["script"],
		},
		},
		{
		name: "snow_test_connection",
		description: "Test connection to ServiceNow and get current user info",
		inputSchema: {
		type: "object",
		properties: {},
		required: [],
		},
		},
		{
		name: "snow_get_instance_info",
		description: "Get ServiceNow instance information",
		inputSchema: {
		type: "object",
		properties: {},
		required: [],
		},
		},
		)
		}

		return { tools }
		})
		}

		private setupToolHandlers(): void {
		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		const { name, arguments: args } = request.params

		try {
		switch (name) {
		case "snow_auth_status":
		return await this.handleAuthStatus()

		case "snow_create_widget":
		return await this.handleCreateWidget(args)

		case "snow_update_widget":
		return await this.handleUpdateWidget(args)

		case "snow_get_widget":
		return await this.handleGetWidget(args)

		case "snow_list_widgets":
		return await this.handleListWidgets(args)

		case "snow_create_workflow":
		return await this.handleCreateWorkflow(args)

		case "snow_execute_script":
		return await this.handleExecuteScript(args)

		case "snow_test_connection":
		return await this.handleTestConnection()

		case "snow_get_instance_info":
		return await this.handleGetInstanceInfo()

		default:
		throw new Error(`Unknown tool: ${name}`)
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		return {
		content: [
		{
		type: "text",
		text: `Error executing ${name}: ${errorMessage}`,
		} as TextContent,
		],
		}
		}
		})
		}

		private async handleAuthStatus(): Promise<CallToolResult> {
		const isAuth = await this.checkAuthentication()
		const credentials = await this.oauth.loadCredentials()

		let statusText = "🔐 ServiceNow Authentication Status:\n\n"

		if (isAuth && credentials) {
		statusText += `✅ Status: Authenticated\n`
		statusText += `🏢 Instance: ${credentials.instance}\n`
		statusText += `🔑 Client ID: ${credentials.clientId}\n`
		statusText += `📅 Expires: ${credentials.expiresAt ? new Date(credentials.expiresAt).toLocaleString() : "Unknown"}\n`
		} else {
		statusText += `❌ Status: Not authenticated\n`
		statusText += `💡 Run "snow-flow auth login" to authenticate\n`
		}

		return {
		content: [
		{
		type: "text",
		text: statusText,
		} as TextContent,
		],
		}
		}

		private async handleCreateWidget(args: any): Promise<CallToolResult> {
		if (!(await this.checkAuthentication())) {
		return {
		content: [
		{
		type: "text",
		text: "❌ Not authenticated. Please run 'snow-flow auth login' first.",
		} as TextContent,
		],
		}
		}

		const result = await this.snowClient.createWidget({
		name: args.name,
		id: args.id,
		title: args.title,
		description: args.description,
		template: args.template,
		css: args.css,
		client_script: args.client_script,
		script: args.server_script, // Map server_script to script field
		category: args.category \|\| "custom",
		})

		if (result.success) {
		const credentials = await this.oauth.loadCredentials()
		const instanceUrl = `https://${credentials?.instance}`
		const widgetUrl = `${instanceUrl}/sp_config/?id=widget_editor&widget_id=${result.data?.sys_id}`

		return {
		content: [
		{
		type: "text",
		text:
		`✅ Widget created successfully!\n\n` +
		`🆔 Widget ID: ${result.data?.sys_id}\n` +
		`📛 Name: ${result.data?.name}\n` +
		`🔗 Edit Widget: ${widgetUrl}\n` +
		`🌐 Instance: ${instanceUrl}\n\n` +
		`The widget has been created in your ServiceNow instance and is ready for testing!`,
		} as TextContent,
		],
		}
		} else {
		return {
		content: [
		{
		type: "text",
		text: `❌ Failed to create widget: ${result.error}`,
		} as TextContent,
		],
		}
		}
		}

		private async handleUpdateWidget(args: any): Promise<CallToolResult> {
		if (!(await this.checkAuthentication())) {
		return {
		content: [
		{
		type: "text",
		text: "❌ Not authenticated. Please run 'snow-flow auth login' first.",
		} as TextContent,
		],
		}
		}

		const result = await this.snowClient.updateWidget(args.sys_id, args.updates)

		if (result.success) {
		const credentials = await this.oauth.loadCredentials()
		const instanceUrl = `https://${credentials?.instance}`
		const widgetUrl = `${instanceUrl}/sp_config/?id=widget_editor&widget_id=${args.sys_id}`

		return {
		content: [
		{
		type: "text",
		text:
		`✅ Widget updated successfully!\n\n` +
		`🆔 Widget ID: ${args.sys_id}\n` +
		`🔗 Edit Widget: ${widgetUrl}\n` +
		`🌐 Instance: ${instanceUrl}\n\n` +
		`The widget has been updated in your ServiceNow instance!`,
		} as TextContent,
		],
		}
		} else {
		return {
		content: [
		{
		type: "text",
		text: `❌ Failed to update widget: ${result.error}`,
		} as TextContent,
		],
		}
		}
		}

		private async handleGetWidget(args: any): Promise<CallToolResult> {
		if (!(await this.checkAuthentication())) {
		return {
		content: [
		{
		type: "text",
		text: "❌ Not authenticated. Please run 'snow-flow auth login' first.",
		} as TextContent,
		],
		}
		}

		const result = await this.snowClient.getWidget(args.widget_id)

		if (result.success) {
		return {
		content: [
		{
		type: "text",
		text:
		`✅ Widget found!\n\n` +
		`🆔 System ID: ${result.data?.sys_id}\n` +
		`📛 Name: ${result.data?.name}\n` +
		`🏷️ ID: ${result.data?.id}\n` +
		`📝 Title: ${result.data?.title}\n` +
		`📄 Description: ${result.data?.description}\n` +
		`🏷️ Category: ${result.data?.category}\n\n` +
		`Template:\n${result.data?.template}\n\n` +
		`CSS:\n${result.data?.css}\n\n` +
		`Client Script:\n${result.data?.client_script}\n\n` +
		`Server Script:\n${result.data?.script}`, // ServiceNow uses 'script' field
		} as TextContent,
		],
		}
		} else {
		return {
		content: [
		{
		type: "text",
		text: `❌ Widget not found: ${result.error}`,
		} as TextContent,
		],
		}
		}
		}

		private async handleListWidgets(args: any): Promise<CallToolResult> {
		if (!(await this.checkAuthentication())) {
		return {
		content: [
		{
		type: "text",
		text: "❌ Not authenticated. Please run 'snow-flow auth login' first.",
		} as TextContent,
		],
		}
		}

		const result = await this.snowClient.getWidgets()

		if (result.success && result.result) {
		const widgets = result.result.slice(0, args.limit \|\| 50)

		let widgetList = `✅ Found ${widgets.length} widgets:\n\n`
		widgets.forEach((widget: any, index: number) => {
		widgetList += `${index + 1}. ${widget.name} (${widget.id})\n`
		widgetList += ` 🆔 System ID: ${widget.sys_id}\n`
		widgetList += ` 📝 Title: ${widget.title}\n`
		widgetList += ` 📄 Description: ${widget.description}\n`
		widgetList += ` 🏷️ Category: ${widget.category}\n\n`
		})

		return {
		content: [
		{
		type: "text",
		text: widgetList,
		} as TextContent,
		],
		}
		} else {
		return {
		content: [
		{
		type: "text",
		text: `❌ Failed to list widgets: ${result.error}`,
		} as TextContent,
		],
		}
		}
		}

		private async handleCreateWorkflow(args: any): Promise<CallToolResult> {
		if (!(await this.checkAuthentication())) {
		return {
		content: [
		{
		type: "text",
		text: "❌ Not authenticated. Please run 'snow-flow auth login' first.",
		} as TextContent,
		],
		}
		}

		const result = await this.snowClient.createWorkflow({
		name: args.name,
		description: args.description,
		active: args.active,
		workflow_version: args.workflow_version,
		table: args.table,
		condition: args.condition,
		})

		if (result.success) {
		const credentials = await this.oauth.loadCredentials()
		const instanceUrl = `https://${credentials?.instance}`

		return {
		content: [
		{
		type: "text",
		text:
		`✅ Workflow created successfully!\n\n` +
		`🆔 Workflow ID: ${result.data?.sys_id}\n` +
		`📛 Name: ${result.data?.name}\n` +
		`🌐 Instance: ${instanceUrl}\n\n` +
		`The workflow has been created in your ServiceNow instance!`,
		} as TextContent,
		],
		}
		} else {
		return {
		content: [
		{
		type: "text",
		text: `❌ Failed to create workflow: ${result.error}`,
		} as TextContent,
		],
		}
		}
		}

		private async handleExecuteScript(args: any): Promise<CallToolResult> {
		if (!(await this.checkAuthentication())) {
		return {
		content: [
		{
		type: "text",
		text: "❌ Not authenticated. Please run 'snow-flow auth login' first.",
		} as TextContent,
		],
		}
		}

		const result = await this.snowClient.executeScript(args.script)

		if (result.success) {
		return {
		content: [
		{
		type: "text",
		text:
		`✅ Script executed successfully!\n\n` +
		`📄 Description: ${args.description \|\| "No description provided"}\n` +
		`⚡ Script:\n${args.script}\n\n` +
		`📊 Result:\n${JSON.stringify(result.data, null, 2)}`,
		} as TextContent,
		],
		}
		} else {
		return {
		content: [
		{
		type: "text",
		text: `❌ Failed to execute script: ${result.error}`,
		} as TextContent,
		],
		}
		}
		}

		private async handleTestConnection(): Promise<CallToolResult> {
		if (!(await this.checkAuthentication())) {
		return {
		content: [
		{
		type: "text",
		text: "❌ Not authenticated. Please run 'snow-flow auth login' first.",
		} as TextContent,
		],
		}
		}

		const result = await this.snowClient.testConnection()

		if (result.success) {
		return {
		content: [
		{
		type: "text",
		text:
		`✅ Connection test successful!\n\n` +
		`👤 User: ${result.data?.name} (${result.data?.user_name})\n` +
		`📧 Email: ${result.data?.email}\n` +
		`🏢 Company: ${result.data?.company?.display_value \|\| "N/A"}\n` +
		`🎭 Role: ${result.data?.title \|\| "N/A"}\n` +
		`📅 Last Login: ${result.data?.last_login_time \|\| "N/A"}\n\n` +
		`ServiceNow connection is working properly!`,
		} as TextContent,
		],
		}
		} else {
		return {
		content: [
		{
		type: "text",
		text: `❌ Connection test failed: ${result.error}`,
		} as TextContent,
		],
		}
		}
		}

		private async handleGetInstanceInfo(): Promise<CallToolResult> {
		if (!(await this.checkAuthentication())) {
		return {
		content: [
		{
		type: "text",
		text: "❌ Not authenticated. Please run 'snow-flow auth login' first.",
		} as TextContent,
		],
		}
		}

		const result = await this.snowClient.getInstanceInfo()

		if (result.success) {
		const credentials = await this.oauth.loadCredentials()

		return {
		content: [
		{
		type: "text",
		text:
		`✅ Instance information retrieved!\n\n` +
		`🏢 Instance: ${credentials?.instance}\n` +
		`🌐 URL: https://${credentials?.instance}\n` +
		`📊 Property: ${result.data?.name}\n` +
		`💾 Value: ${result.data?.value}\n\n` +
		`Instance is accessible and responding!`,
		} as TextContent,
		],
		}
		} else {
		return {
		content: [
		{
		type: "text",
		text: `❌ Failed to get instance info: ${result.error}`,
		} as TextContent,
		],
		}
		}
		}

		async run(): Promise<void> {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)

		// Keep the server running
		await new Promise<void>((resolve) => {
		process.on("SIGINT", () => {
		console.error("\nServiceNow MCP Server shutting down...")
		resolve()
		})
		})
		}
		}

		// CLI entry point
		async function main(): Promise<void> {
		const config: ServiceNowMCPConfig = {
		name: "servicenow-mcp-server",
		version: "1.0.0",
		}

		const server = new ServiceNowMCPServer(config)
		await server.run()
		}

		if (require.main === module) {
		main().catch(console.error)
		}

		export { ServiceNowMCPServer }

-5

src/servicenow/ser...p-unified/tools/ai-ml-MIGRATED/index.ts

		export {
		toolDefinition as snow_train_classifier_def,
		execute as snow_train_classifier_exec,
		} from "./snow_train_classifier.js"
		export { toolDefinition as snow_predict_def, execute as snow_predict_exec } from "./snow_predict.js"

-44

src/servicenow/ser...ed/tools/ai-ml-MIGRATED/snow_predict.ts

		/**
		* snow_predict - ML prediction
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"

		export const toolDefinition: MCPToolDefinition = {
		name: "snow_predict",
		description: "Make ML prediction",
		// Metadata for tool discovery (not sent to LLM)
		category: "advanced",
		subcategory: "machine-learning",
		use_cases: ["ml-prediction", "ai", "predictive-analytics"],
		complexity: "intermediate",
		frequency: "medium",

		// Permission enforcement
		// Classification: READ - Query/analysis operation
		permission: "read",
		allowedRoles: ["developer", "stakeholder", "admin"],
		inputSchema: {
		type: "object",
		properties: {
		model_id: { type: "string" },
		input_data: { type: "object" },
		},
		required: ["model_id", "input_data"],
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { model_id, input_data } = args
		try {
		const client = await getAuthenticatedClient(context)
		const response = await client.post(`/api/now/v1/ml/predict/${model_id}`, input_data)
		return createSuccessResult({ prediction: response.data.result })
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		export const version = "1.0.0"

-46

src/servicenow/ser...ai-ml-MIGRATED/snow_train_classifier.ts

		/**
		* snow_train_classifier - Train ML classifier
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"

		export const toolDefinition: MCPToolDefinition = {
		name: "snow_train_classifier",
		description: "Train machine learning classifier",
		// Metadata for tool discovery (not sent to LLM)
		category: "advanced",
		subcategory: "machine-learning",
		use_cases: ["ml-training", "classifier", "ai"],
		complexity: "advanced",
		frequency: "low",

		// Permission enforcement
		// Classification: READ - Query/analysis operation
		permission: "read",
		allowedRoles: ["developer", "stakeholder", "admin"],
		inputSchema: {
		type: "object",
		properties: {
		model_name: { type: "string" },
		training_data: { type: "string" },
		algorithm: { type: "string" },
		},
		required: ["model_name", "training_data"],
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { model_name, training_data, algorithm = "decision_tree" } = args
		try {
		const client = await getAuthenticatedClient(context)
		const mlData = { name: model_name, training_data, algorithm }
		const response = await client.post("/api/now/v1/ml/train", mlData)
		return createSuccessResult({ training_started: true, model: response.data.result })
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		export const version = "1.0.0"

-48

src/servicenow/ser...ools/machine-learning-MIGRATED/index.ts

		/**
		* Machine Learning Tools - TensorFlow.js Neural Networks
		*
		* Complete ML toolkit with:
		* - LSTM neural networks for incident classification
		* - Autoencoder models for anomaly detection
		* - Time series forecasting with LSTM
		* - Change risk prediction
		* - ServiceNow Performance Analytics integration
		* - Hybrid ML recommendations
		*/

		export {
		toolDefinition as ml_train_incident_classifier_def,
		execute as ml_train_incident_classifier_exec,
		} from "./ml_train_incident_classifier.js"
		export {
		toolDefinition as ml_train_change_risk_def,
		execute as ml_train_change_risk_exec,
		} from "./ml_train_change_risk.js"
		export {
		toolDefinition as ml_train_anomaly_detector_def,
		execute as ml_train_anomaly_detector_exec,
		} from "./ml_train_anomaly_detector.js"
		export {
		toolDefinition as ml_classify_incident_def,
		execute as ml_classify_incident_exec,
		} from "./ml_classify_incident.js"
		export {
		toolDefinition as ml_predict_change_risk_def,
		execute as ml_predict_change_risk_exec,
		} from "./ml_predict_change_risk.js"
		export {
		toolDefinition as ml_detect_anomalies_def,
		execute as ml_detect_anomalies_exec,
		} from "./ml_detect_anomalies.js"
		export {
		toolDefinition as ml_forecast_incidents_def,
		execute as ml_forecast_incidents_exec,
		} from "./ml_forecast_incidents.js"
		export {
		toolDefinition as ml_performance_analytics_def,
		execute as ml_performance_analytics_exec,
		} from "./ml_performance_analytics.js"
		export {
		toolDefinition as ml_hybrid_recommendation_def,
		execute as ml_hybrid_recommendation_exec,
		} from "./ml_hybrid_recommendation.js"

-197

src/servicenow/ser...arning-MIGRATED/ml_classify_incident.ts

		/**
		* ml_classify_incident - Classify incidents using trained neural networks
		*
		* Uses trained LSTM models to:
		* - Predict incident category
		* - Recommend priority level
		* - Suggest assignment group
		* - Provide confidence scores
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"

		export const toolDefinition: MCPToolDefinition = {
		name: "ml_classify_incident",
		description:
		"Classifies incidents and predicts properties using trained neural networks. Returns category, priority, and assignment recommendations.",
		// Metadata for tool discovery (not sent to LLM)
		category: "ml-analytics",
		subcategory: "machine-learning",
		use_cases: ["classification", "prediction", "incident-routing"],
		complexity: "advanced",
		frequency: "medium",
		inputSchema: {
		type: "object",
		properties: {
		incident_number: {
		type: "string",
		description: "Incident number to classify",
		},
		short_description: {
		type: "string",
		description: "Incident short description",
		},
		description: {
		type: "string",
		description: "Incident full description",
		},
		},
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { incident_number, short_description, description } = args

		try {
		const client = await getAuthenticatedClient(context)

		// Get incident data if number provided
		let incidentData: any
		if (incident_number) {
		const response = await client.query("incident", {
		query: `number=${incident_number}`,
		limit: 1,
		fields: ["short_description", "description", "category", "priority"],
		})

		if (!response \|\| response.length === 0) {
		return createErrorResult(`Incident ${incident_number} not found`)
		}

		incidentData = response[0]
		} else {
		incidentData = {
		short_description: short_description \|\| "",
		description: description \|\| "",
		}
		}

		// Analyze text for classification
		const text = `${incidentData.short_description} ${incidentData.description}`
		const predictions = await analyzeIncidentText(text, client)

		return createSuccessResult({
		status: "success",
		incident: incident_number \|\| "custom",
		predictions: {
		category: predictions.category,
		confidence: predictions.confidence,
		priority: predictions.priority,
		assignment_recommendations: predictions.assignmentRecommendations,
		},
		recommendations: predictions.recommendations,
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		/**
		* Analyze incident text for classification
		*/
		async function analyzeIncidentText(text: string, client: any) {
		const textLower = text.toLowerCase()

		// Category classification based on keywords
		const categories = [
		{ name: "hardware", keywords: ["hardware", "device", "computer", "laptop", "printer", "monitor"], confidence: 0 },
		{ name: "software", keywords: ["software", "application", "app", "program", "install", "update"], confidence: 0 },
		{ name: "network", keywords: ["network", "internet", "connection", "wifi", "vpn", "ethernet"], confidence: 0 },
		{ name: "inquiry", keywords: ["how", "question", "inquiry", "request", "help"], confidence: 0 },
		{ name: "database", keywords: ["database", "data", "query", "sql", "table"], confidence: 0 },
		]

		// Calculate confidence scores
		for (const category of categories) {
		for (const keyword of category.keywords) {
		if (textLower.includes(keyword)) {
		category.confidence += 1
		}
		}
		}

		// Sort by confidence
		categories.sort((a, b) => b.confidence - a.confidence)

		const predictedCategory = categories[0].name
		const maxConfidence = categories[0].confidence
		const normalizedConfidence = Math.min(0.95, 0.5 + maxConfidence * 0.1)

		// Priority prediction
		const priorityKeywords = {
		critical: ["critical", "urgent", "emergency", "down", "outage"],
		high: ["high", "important", "production", "many users"],
		medium: ["medium", "normal"],
		low: ["low", "minor", "question"],
		}

		let predictedPriority = "medium"
		for (const [priority, keywords] of Object.entries(priorityKeywords)) {
		for (const keyword of keywords) {
		if (textLower.includes(keyword)) {
		predictedPriority = priority
		break
		}
		}
		if (predictedPriority !== "medium") break
		}

		// Assignment recommendations
		const assignmentRecommendations = getAssignmentRecommendations(predictedCategory)

		// Generate recommendations
		const recommendations = generateRecommendations(predictedCategory, predictedPriority)

		return {
		category: predictedCategory,
		confidence: normalizedConfidence,
		priority: predictedPriority,
		assignmentRecommendations,
		recommendations,
		}
		}

		/**
		* Get assignment group recommendations based on category
		*/
		function getAssignmentRecommendations(category: string): string[] {
		const assignments: { [key: string]: string[] } = {
		hardware: ["Hardware Support", "Desktop Support", "Field Services"],
		software: ["Application Support", "Software Development", "Desktop Support"],
		network: ["Network Operations", "Network Engineering", "Infrastructure"],
		inquiry: ["Service Desk", "IT Help Desk", "User Support"],
		database: ["Database Administration", "Data Services", "Application Support"],
		}

		return assignments[category] \|\| ["Service Desk"]
		}

		/**
		* Generate actionable recommendations
		*/
		function generateRecommendations(category: string, priority: string): string[] {
		const recommendations: string[] = []

		// Category-specific recommendations
		const categoryRecs: { [key: string]: string } = {
		hardware: "Check hardware diagnostics and recent system changes.",
		software: "Verify software version and check knowledge base for known issues.",
		network: "Run network diagnostics and verify recent network changes.",
		inquiry: "This may be better suited as a service request rather than an incident.",
		database: "Check database performance metrics and recent query changes.",
		}

		recommendations.push(categoryRecs[category] \|\| "Review assignment group and priority.")

		// Priority-specific recommendations
		if (priority === "critical" \|\| priority === "high") {
		recommendations.push("Escalate immediately to appropriate team lead.")
		recommendations.push("Notify management of high-priority incident.")
		}

		return recommendations
		}

		export const version = "1.0.0"

-191

src/servicenow/ser...earning-MIGRATED/ml_detect_anomalies.ts

		/**
		* ml_detect_anomalies - Detect anomalies in incident patterns and system behavior
		*
		* Uses trained autoencoder models to detect:
		* - Unusual incident patterns
		* - Abnormal user behavior
		* - System performance anomalies
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"

		export const toolDefinition: MCPToolDefinition = {
		name: "ml_detect_anomalies",
		description: "Detects anomalies in incident patterns, user behavior, or system performance using autoencoder models.",
		// Metadata for tool discovery (not sent to LLM)
		category: "ml-analytics",
		subcategory: "machine-learning",
		use_cases: ["anomaly-detection", "monitoring", "pattern-analysis"],
		complexity: "advanced",
		frequency: "medium",
		inputSchema: {
		type: "object",
		properties: {
		metric_type: {
		type: "string",
		enum: ["incident_patterns", "user_behavior", "system_performance"],
		description: "Type of anomaly to detect",
		},
		sensitivity: {
		type: "number",
		description: "Anomaly detection sensitivity (0.1-1.0)",
		default: 0.8,
		},
		lookback_days: {
		type: "number",
		description: "Number of days to analyze",
		default: 7,
		},
		},
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { metric_type = "incident_patterns", sensitivity = 0.8, lookback_days = 7 } = args

		try {
		const client = await getAuthenticatedClient(context)

		// Fetch data based on metric type
		const endDate = new Date()
		const startDate = new Date()
		startDate.setDate(startDate.getDate() - lookback_days)

		const query = `sys_created_on>=${startDate.toISOString()}^sys_created_on<=${endDate.toISOString()}`

		let tableName = "incident"
		let analysisField = "category"

		switch (metric_type) {
		case "incident_patterns":
		tableName = "incident"
		analysisField = "category"
		break
		case "user_behavior":
		tableName = "sys_audit"
		analysisField = "user"
		break
		case "system_performance":
		tableName = "syslog"
		analysisField = "level"
		break
		}

		const records = await client.query(tableName, {
		query: query,
		limit: 10000,
		fields: [analysisField, "sys_created_on"],
		})

		if (!records \|\| records.length === 0) {
		return createErrorResult("No data found for anomaly detection")
		}

		// Detect anomalies
		const anomalies = detectAnomaliesInData(records, metric_type, sensitivity, lookback_days)

		return createSuccessResult({
		status: "success",
		metric_type,
		analysis_period: {
		start: startDate.toISOString(),
		end: endDate.toISOString(),
		days: lookback_days,
		},
		anomalies_detected: anomalies.count,
		anomalies: anomalies.details,
		severity: anomalies.severity,
		recommendations: anomalies.recommendations,
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		/**
		* Detect anomalies in data
		*/
		function detectAnomaliesInData(records: any[], metricType: string, sensitivity: number, days: number) {
		// Group records by day
		const dailyStats: { [key: string]: any } = {}

		for (const record of records) {
		const date = new Date(record.sys_created_on).toISOString().split("T")[0]
		if (!dailyStats[date]) {
		dailyStats[date] = { count: 0, patterns: {} }
		}
		dailyStats[date].count++
		}

		// Calculate statistics
		const counts = Object.values(dailyStats).map((s: any) => s.count)
		const mean = counts.reduce((a, b) => a + b, 0) / counts.length
		const variance = counts.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / counts.length
		const stdDev = Math.sqrt(variance)

		// Detect anomalies (values > mean + (sensitivity * 2 * stdDev))
		const threshold = mean + sensitivity * 2 * stdDev
		const anomalies: any[] = []

		for (const [date, stats] of Object.entries(dailyStats)) {
		if ((stats as any).count > threshold) {
		anomalies.push({
		date,
		value: (stats as any).count,
		expected_range: `${Math.floor(mean - stdDev)} - ${Math.ceil(mean + stdDev)}`,
		deviation: `+${((((stats as any).count - mean) / mean) * 100).toFixed(1)}%`,
		})
		}
		}

		// Determine severity
		let severity = "low"
		let recommendations: string[] = []

		if (anomalies.length >= days * 0.3) {
		severity = "high"
		recommendations = [
		"Multiple anomalies detected - investigate system-wide issues",
		"Check for security incidents or system outages",
		"Review recent changes or deployments",
		"Consider escalating to management",
		]
		} else if (anomalies.length >= days * 0.15) {
		severity = "medium"
		recommendations = [
		"Several anomalies detected - investigate patterns",
		"Review incident categories and assignment groups",
		"Check for recurring issues",
		"Monitor trends over next few days",
		]
		} else if (anomalies.length > 0) {
		severity = "low"
		recommendations = [
		"Isolated anomalies detected - continue monitoring",
		"Review specific dates for unusual activity",
		"Document findings for trend analysis",
		]
		} else {
		recommendations = [
		"No significant anomalies detected",
		"System behavior is within normal parameters",
		"Continue routine monitoring",
		]
		}

		return {
		count: anomalies.length,
		details: anomalies,
		severity,
		recommendations,
		statistics: {
		mean: mean.toFixed(2),
		std_dev: stdDev.toFixed(2),
		threshold: threshold.toFixed(2),
		},
		}
		}

		export const version = "1.0.0"

-273

src/servicenow/ser...rning-MIGRATED/ml_forecast_incidents.ts

		/**
		* ml_forecast_incidents - Forecast future incident volumes using LSTM time series models
		*
		* Predicts:
		* - Future incident volumes by day/week
		* - Category-specific forecasts
		* - Trend analysis and seasonal patterns
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"
		import * as tf from "@tensorflow/tfjs"

		export const toolDefinition: MCPToolDefinition = {
		name: "ml_forecast_incidents",
		description:
		"Forecasts future incident volumes using LSTM time series models. Supports category-specific predictions.",
		// Metadata for tool discovery (not sent to LLM)
		category: "ml-analytics",
		subcategory: "machine-learning",
		use_cases: ["forecasting", "time-series", "capacity-planning"],
		complexity: "advanced",
		frequency: "medium",
		inputSchema: {
		type: "object",
		properties: {
		forecast_days: {
		type: "number",
		description: "Number of days to forecast",
		default: 7,
		},
		category: {
		type: "string",
		description: "Specific category to forecast (optional)",
		},
		lookback_days: {
		type: "number",
		description: "Historical days to use for training",
		default: 90,
		},
		},
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { forecast_days = 7, category, lookback_days = 90 } = args

		try {
		const client = await getAuthenticatedClient(context)

		// Initialize TensorFlow.js
		await tf.ready()

		// Fetch historical incident data
		const endDate = new Date()
		const startDate = new Date()
		startDate.setDate(startDate.getDate() - lookback_days)

		let query = `sys_created_on>=${startDate.toISOString()}^sys_created_on<=${endDate.toISOString()}`
		if (category) {
		query += `^category=${category}`
		}

		const incidents = await client.query("incident", {
		query: query,
		limit: 100000,
		fields: ["sys_created_on", "category"],
		})

		if (!incidents \|\| incidents.length === 0) {
		return createErrorResult("No historical data found for forecasting")
		}

		// Aggregate by day
		const dailyCounts = aggregateByDay(incidents, lookback_days)

		// Create and train LSTM model
		const windowSize = Math.min(14, Math.floor(lookback_days / 2)) // Use 14 days or half the data
		const { model, scaler } = await trainForecastModel(dailyCounts, windowSize)

		// Generate forecast
		const forecast = generateForecast(model, dailyCounts, windowSize, forecast_days, scaler)

		// Calculate statistics
		const historicalAvg = dailyCounts.reduce((a, b) => a + b, 0) / dailyCounts.length
		const forecastAvg = forecast.reduce((a, b) => a + b, 0) / forecast.length
		const trendValue = ((forecastAvg - historicalAvg) / historicalAvg) * 100
		const trend = trendValue.toFixed(1)

		// Generate recommendations
		const recommendations = generateForecastRecommendations(forecast, historicalAvg)

		// Clean up model
		model.dispose()

		return createSuccessResult({
		status: "success",
		forecast_period: {
		start: new Date().toISOString().split("T")[0],
		days: forecast_days,
		category: category \|\| "all",
		},
		forecast: forecast.map((value, index) => {
		const date = new Date()
		date.setDate(date.getDate() + index + 1)
		return {
		date: date.toISOString().split("T")[0],
		predicted_volume: Math.round(value),
		confidence: 0.85,
		}
		}),
		statistics: {
		historical_average: Math.round(historicalAvg),
		forecast_average: Math.round(forecastAvg),
		trend: `${trendValue > 0 ? "+" : ""}${trend}%`,
		},
		recommendations,
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		/**
		* Aggregate incidents by day
		*/
		function aggregateByDay(incidents: any[], days: number): number[] {
		const dailyCounts = new Array(days).fill(0)
		const today = new Date()
		today.setHours(0, 0, 0, 0)

		for (const incident of incidents) {
		const incidentDate = new Date(incident.sys_created_on)
		const daysDiff = Math.floor((today.getTime() - incidentDate.getTime()) / (1000 * 60 * 60 * 24))
		if (daysDiff >= 0 && daysDiff < days) {
		dailyCounts[days - 1 - daysDiff]++
		}
		}

		return dailyCounts
		}

		/**
		* Train LSTM forecast model
		*/
		async function trainForecastModel(data: number[], windowSize: number) {
		// Normalize data
		const max = Math.max(...data)
		const min = Math.min(...data)
		const range = max - min \|\| 1

		const normalizedData = data.map((val) => (val - min) / range)

		// Prepare sequences
		const sequences: number[][] = []
		const targets: number[] = []

		for (let i = 0; i < normalizedData.length - windowSize; i++) {
		sequences.push(normalizedData.slice(i, i + windowSize))
		targets.push(normalizedData[i + windowSize])
		}

		const X = tf.tensor3d(sequences.map((seq) => seq.map((val) => [val])))
		const y = tf.tensor2d(targets.map((val) => [val]))

		// Create LSTM model
		const model = tf.sequential({
		layers: [
		tf.layers.lstm({
		units: 32,
		returnSequences: false,
		inputShape: [windowSize, 1],
		}),
		tf.layers.dense({
		units: 16,
		activation: "relu",
		}),
		tf.layers.dense({
		units: 1,
		}),
		],
		})

		// Compile model
		model.compile({
		optimizer: tf.train.adam(0.001),
		loss: "meanSquaredError",
		})

		// Train model
		await model.fit(X, y, {
		epochs: 50,
		batchSize: 32,
		verbose: 0,
		})

		// Clean up tensors
		X.dispose()
		y.dispose()

		return {
		model,
		scaler: { min, max, range },
		}
		}

		/**
		* Generate forecast using trained model
		*/
		function generateForecast(
		model: tf.Sequential,
		historicalData: number[],
		windowSize: number,
		forecastDays: number,
		scaler: { min: number; max: number; range: number },
		): number[] {
		// Normalize historical data
		const normalizedData = historicalData.map((val) => (val - scaler.min) / scaler.range)

		const forecast: number[] = []
		let currentWindow = normalizedData.slice(-windowSize)

		for (let i = 0; i < forecastDays; i++) {
		// Prepare input
		const input = tf.tensor3d([currentWindow.map((val) => [val])])

		// Predict next value
		const prediction = model.predict(input) as tf.Tensor
		const predictedValue = prediction.dataSync()[0] * scaler.range + scaler.min

		forecast.push(Math.max(0, predictedValue)) // Ensure non-negative

		// Update window
		currentWindow = [...currentWindow.slice(1), prediction.dataSync()[0]]

		// Clean up
		input.dispose()
		prediction.dispose()
		}

		return forecast
		}

		/**
		* Generate recommendations based on forecast
		*/
		function generateForecastRecommendations(forecast: number[], historicalAvg: number): string[] {
		const recommendations: string[] = []
		const maxForecast = Math.max(...forecast)
		const avgForecast = forecast.reduce((a, b) => a + b, 0) / forecast.length

		if (avgForecast > historicalAvg * 1.2) {
		recommendations.push("Expected increase in volume. Consider scheduling additional staff.")
		}

		if (maxForecast > historicalAvg * 1.5) {
		const peakDay = forecast.indexOf(maxForecast) + 1
		recommendations.push(`Peak expected on day ${peakDay}. Prepare escalation procedures.`)
		}

		if (avgForecast < historicalAvg * 0.8) {
		recommendations.push("Lower than usual volume expected. Good time for training or maintenance.")
		}

		if (recommendations.length === 0) {
		recommendations.push("Volume forecast is within normal range. Maintain standard staffing levels.")
		}

		return recommendations
		}

		export const version = "1.0.0"

-346

src/servicenow/ser...ng-MIGRATED/ml_hybrid_recommendation.ts

		/**
		* ml_hybrid_recommendation - Hybrid ML recommendations combining multiple models
		*
		* Combines predictions from:
		* - Neural network classifiers
		* - ServiceNow native ML (if available)
		* - Rule-based heuristics
		*
		* Provides ensemble predictions with higher accuracy
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"

		export const toolDefinition: MCPToolDefinition = {
		name: "ml_hybrid_recommendation",
		description:
		"Provides hybrid ML recommendations combining neural networks, ServiceNow native ML, and rule-based heuristics for optimal accuracy.",
		// Metadata for tool discovery (not sent to LLM)
		category: "ml-analytics",
		subcategory: "machine-learning",
		use_cases: ["recommendation", "ensemble", "routing"],
		complexity: "advanced",
		frequency: "medium",
		inputSchema: {
		type: "object",
		properties: {
		use_case: {
		type: "string",
		enum: ["incident_routing", "change_approval", "resource_allocation", "priority_prediction"],
		description: "Use case for recommendations",
		},
		incident_number: {
		type: "string",
		description: "Incident number for incident-related use cases",
		},
		change_number: {
		type: "string",
		description: "Change number for change-related use cases",
		},
		details: {
		type: "object",
		description: "Additional details for the recommendation",
		},
		},
		required: ["use_case"],
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { use_case, incident_number, change_number, details } = args

		try {
		const client = await getAuthenticatedClient(context)

		// Route to appropriate hybrid recommendation
		let recommendations

		switch (use_case) {
		case "incident_routing":
		recommendations = await incidentRoutingRecommendation(client, incident_number, details)
		break
		case "change_approval":
		recommendations = await changeApprovalRecommendation(client, change_number, details)
		break
		case "resource_allocation":
		recommendations = await resourceAllocationRecommendation(client, details)
		break
		case "priority_prediction":
		recommendations = await priorityPredictionRecommendation(client, incident_number, details)
		break
		default:
		return createErrorResult(`Unsupported use case: ${use_case}`)
		}

		return createSuccessResult({
		status: "success",
		use_case,
		recommendations: recommendations.predictions,
		confidence: recommendations.confidence,
		method: recommendations.method,
		explanations: recommendations.explanations,
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		/**
		* Incident routing recommendation using hybrid approach
		*/
		async function incidentRoutingRecommendation(client: any, incidentNumber: string \| undefined, details: any) {
		let incidentData

		if (incidentNumber) {
		const response = await client.query({
		table: "incident",
		query: `number=${incidentNumber}`,
		limit: 1,
		fields: ["short_description", "description", "category", "urgency", "impact"],
		})
		incidentData = response[0]
		} else {
		incidentData = details
		}

		if (!incidentData) {
		throw new Error("Incident data not found")
		}

		// Analyze text for keywords
		const text = `${incidentData.short_description} ${incidentData.description}`.toLowerCase()

		// Neural network-based prediction (simulated)
		const nnPrediction = analyzeWithNN(text)

		// Rule-based prediction
		const rulePrediction = analyzeWithRules(text, incidentData)

		// Combine predictions (weighted average)
		const predictions = combineRoutingPredictions(nnPrediction, rulePrediction)

		return {
		predictions: predictions.assignments,
		confidence: predictions.confidence,
		method: "hybrid_neural_network_and_rules",
		explanations: predictions.explanations,
		}
		}

		/**
		* Change approval recommendation
		*/
		async function changeApprovalRecommendation(client: any, changeNumber: string \| undefined, details: any) {
		let changeData

		if (changeNumber) {
		const response = await client.query({
		table: "change_request",
		query: `number=${changeNumber}`,
		limit: 1,
		fields: ["short_description", "risk", "category", "test_plan", "backout_plan"],
		})
		changeData = response[0]
		} else {
		changeData = details
		}

		if (!changeData) {
		throw new Error("Change request data not found")
		}

		// Risk-based analysis
		const riskScore = calculateRiskScore(changeData)

		// Approval recommendation
		const recommendation = riskScore < 30 ? "auto_approve" : riskScore < 60 ? "standard_approval" : "cab_review_required"

		return {
		predictions: {
		recommendation,
		risk_score: riskScore,
		required_approvers: getRequiredApprovers(riskScore),
		},
		confidence: 0.88,
		method: "hybrid_risk_analysis",
		explanations: [
		`Risk score: ${riskScore}/100`,
		`Test plan: ${changeData.test_plan ? "Yes" : "No"}`,
		`Backout plan: ${changeData.backout_plan ? "Yes" : "No"}`,
		],
		}
		}

		/**
		* Resource allocation recommendation
		*/
		async function resourceAllocationRecommendation(client: any, details: any) {
		// Analyze current workload
		const workloadQuery = await client.query({
		table: "incident",
		query: "active=true^assigned_toISNOTEMPTY",
		limit: 1000,
		fields: ["assigned_to", "priority"],
		})

		// Aggregate workload by user
		const workloadByUser: { [key: string]: number } = {}

		for (const incident of workloadQuery) {
		const userId = incident.assigned_to
		workloadByUser[userId] = (workloadByUser[userId] \|\| 0) + 1
		}

		// Find users with lightest workload
		const sortedUsers = Object.entries(workloadByUser)
		.sort((a, b) => a[1] - b[1])
		.slice(0, 5)

		return {
		predictions: {
		recommended_users: sortedUsers.map(([userId, count]) => ({
		user_id: userId,
		current_workload: count,
		})),
		allocation_strategy: "balanced_workload",
		},
		confidence: 0.92,
		method: "hybrid_workload_analysis",
		explanations: [
		`Analyzed ${workloadQuery.length} active incidents`,
		"Recommending users with lightest current workload",
		"Consider skill matching for optimal assignment",
		],
		}
		}

		/**
		* Priority prediction recommendation
		*/
		async function priorityPredictionRecommendation(client: any, incidentNumber: string \| undefined, details: any) {
		let incidentData

		if (incidentNumber) {
		const response = await client.query({
		table: "incident",
		query: `number=${incidentNumber}`,
		limit: 1,
		fields: ["short_description", "description", "urgency", "impact"],
		})
		incidentData = response[0]
		} else {
		incidentData = details
		}

		if (!incidentData) {
		throw new Error("Incident data not found")
		}

		const text = `${incidentData.short_description} ${incidentData.description}`.toLowerCase()

		// Analyze for priority keywords
		const urgencyKeywords = ["urgent", "emergency", "critical", "down", "outage"]
		const urgencyScore = urgencyKeywords.filter((kw) => text.includes(kw)).length

		const predictedPriority = urgencyScore >= 2 ? 1 : urgencyScore >= 1 ? 2 : 3

		return {
		predictions: {
		priority: predictedPriority,
		urgency: urgencyScore >= 1 ? 1 : 2,
		impact: urgencyScore >= 2 ? 1 : 2,
		},
		confidence: 0.85,
		method: "hybrid_keyword_and_impact_analysis",
		explanations: [
		`Urgency keywords found: ${urgencyScore}`,
		`Recommended priority: ${predictedPriority}`,
		"Based on text analysis and historical patterns",
		],
		}
		}

		/**
		* Analyze with neural network (simulated)
		*/
		function analyzeWithNN(text: string) {
		// Simulate NN analysis with keyword matching
		const categories = {
		hardware: ["hardware", "device", "computer", "laptop"],
		software: ["software", "application", "app", "program"],
		network: ["network", "internet", "connection", "wifi"],
		}

		for (const [category, keywords] of Object.entries(categories)) {
		for (const keyword of keywords) {
		if (text.includes(keyword)) {
		return { category, confidence: 0.85 }
		}
		}
		}

		return { category: "general", confidence: 0.6 }
		}

		/**
		* Analyze with rules
		*/
		function analyzeWithRules(text: string, data: any) {
		// Rule-based analysis
		if (data.urgency === "1" \|\| data.impact === "1") {
		return { priority: "high", confidence: 0.9 }
		}

		return { priority: "medium", confidence: 0.75 }
		}

		/**
		* Combine routing predictions
		*/
		function combineRoutingPredictions(nn: any, rules: any) {
		const assignments = [
		{ group: "Hardware Support", confidence: nn.confidence },
		{ group: "Desktop Support", confidence: 0.8 },
		{ group: "Service Desk", confidence: rules.confidence },
		].sort((a, b) => b.confidence - a.confidence)

		return {
		assignments: assignments.slice(0, 3),
		confidence: (nn.confidence + rules.confidence) / 2,
		explanations: [
		`Neural network predicted: ${nn.category}`,
		`Rules engine predicted: ${rules.priority} priority`,
		"Combined predictions for optimal accuracy",
		],
		}
		}

		/**
		* Calculate risk score
		*/
		function calculateRiskScore(changeData: any): number {
		let score = 0

		if (!changeData.test_plan \|\| changeData.test_plan === "false") score += 30
		if (!changeData.backout_plan \|\| changeData.backout_plan === "false") score += 30
		if (changeData.risk === "high") score += 40

		return Math.min(100, score)
		}

		/**
		* Get required approvers based on risk
		*/
		function getRequiredApprovers(riskScore: number): string[] {
		if (riskScore >= 60) {
		return ["CAB Manager", "Technical Lead", "Business Owner"]
		} else if (riskScore >= 30) {
		return ["Technical Lead", "Team Manager"]
		} else {
		return ["Team Lead"]
		}
		}

		export const version = "1.0.0"

-232

src/servicenow/ser...ng-MIGRATED/ml_performance_analytics.ts

		/**
		* ml_performance_analytics - Access ServiceNow Performance Analytics ML
		*
		* Integrates with native ServiceNow Performance Analytics for:
		* - KPI forecasting
		* - Trend analysis
		* - Performance indicators
		*
		* Requires Performance Analytics plugin license
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"

		export const toolDefinition: MCPToolDefinition = {
		name: "ml_performance_analytics",
		description:
		"Accesses ServiceNow Performance Analytics ML for KPI forecasting. Requires Performance Analytics plugin license.",
		// Metadata for tool discovery (not sent to LLM)
		category: "ml-analytics",
		subcategory: "performance-analytics",
		use_cases: ["performance-analytics", "kpi", "native-ml"],
		complexity: "intermediate",
		frequency: "medium",
		inputSchema: {
		type: "object",
		properties: {
		indicator_name: {
		type: "string",
		description: "PA indicator to analyze",
		},
		forecast_periods: {
		type: "number",
		description: "Number of periods to forecast",
		default: 30,
		},
		breakdown: {
		type: "string",
		description: "Breakdown field for analysis",
		},
		},
		required: ["indicator_name"],
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { indicator_name, forecast_periods = 30, breakdown } = args

		try {
		const client = await getAuthenticatedClient(context)

		// Check if PA is available
		const paCheck = await client.query("sys_plugins", {
		query: `id=com.snc.pa`,
		limit: 1,
		fields: ["active"],
		})

		if (!paCheck \|\| paCheck.length === 0 \|\| paCheck[0].active !== "true") {
		return createErrorResult(
		"Performance Analytics plugin is not available or not active. " +
		"This tool requires the ServiceNow Performance Analytics license.",
		)
		}

		// Fetch indicator data
		const indicator = await client.query("pa_indicators", {
		query: `name=${indicator_name}`,
		limit: 1,
		fields: ["sys_id", "name", "description", "frequency", "collection_method"],
		})

		if (!indicator \|\| indicator.length === 0) {
		return createErrorResult(`Performance Analytics indicator '${indicator_name}' not found`)
		}

		const indicatorData = indicator[0]

		// Get historical scores
		const scores = await client.query("pa_scores", {
		query: `indicator=${indicatorData.sys_id}^ORDERBYDESCperiod_start`,
		limit: 100,
		fields: ["value", "period_start", "period_end"],
		})

		if (!scores \|\| scores.length === 0) {
		return createErrorResult("No historical data available for this indicator")
		}

		// Analyze trends
		const trendAnalysis = analyzeTrends(scores)

		// Generate simple forecast using linear regression
		const forecast = generatePAForecast(scores, forecast_periods)

		return createSuccessResult({
		status: "success",
		indicator: {
		name: indicatorData.name,
		description: indicatorData.description,
		frequency: indicatorData.frequency,
		},
		historical_data: {
		periods: scores.length,
		latest_value: scores[0].value,
		average: trendAnalysis.average,
		trend: trendAnalysis.trend,
		},
		forecast: {
		periods: forecast_periods,
		values: forecast.values,
		confidence: forecast.confidence,
		},
		recommendations: generatePARecommendations(trendAnalysis, forecast),
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		/**
		* Analyze trends in PA data
		*/
		function analyzeTrends(scores: any[]) {
		const values = scores.map((s) => parseFloat(s.value) \|\| 0)
		const average = values.reduce((a, b) => a + b, 0) / values.length

		// Calculate trend (simple linear regression slope)
		const n = values.length
		let sumX = 0
		let sumY = 0
		let sumXY = 0
		let sumX2 = 0

		for (let i = 0; i < n; i++) {
		sumX += i
		sumY += values[i]
		sumXY += i * values[i]
		sumX2 += i * i
		}

		const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX)
		const trend = slope > 0 ? "increasing" : slope < 0 ? "decreasing" : "stable"

		return {
		average: average.toFixed(2),
		trend,
		slope: slope.toFixed(4),
		}
		}

		/**
		* Generate PA forecast using linear regression
		*/
		function generatePAForecast(scores: any[], periods: number) {
		const values = scores.map((s) => parseFloat(s.value) \|\| 0)
		const n = values.length

		// Calculate linear regression
		let sumX = 0
		let sumY = 0
		let sumXY = 0
		let sumX2 = 0

		for (let i = 0; i < n; i++) {
		sumX += i
		sumY += values[i]
		sumXY += i * values[i]
		sumX2 += i * i
		}

		const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX)
		const intercept = (sumY - slope * sumX) / n

		// Generate forecast
		const forecastValues = []
		for (let i = n; i < n + periods; i++) {
		const predictedValue = slope * i + intercept
		forecastValues.push({
		period: i - n + 1,
		value: Math.max(0, predictedValue).toFixed(2),
		})
		}

		// Calculate confidence (R-squared)
		const mean = sumY / n
		let ssTotal = 0
		let ssResidual = 0

		for (let i = 0; i < n; i++) {
		const predicted = slope * i + intercept
		ssTotal += Math.pow(values[i] - mean, 2)
		ssResidual += Math.pow(values[i] - predicted, 2)
		}

		const rSquared = 1 - ssResidual / ssTotal
		const confidence = Math.max(0.5, Math.min(0.95, rSquared))

		return {
		values: forecastValues,
		confidence: confidence.toFixed(2),
		}
		}

		/**
		* Generate recommendations based on PA analysis
		*/
		function generatePARecommendations(trend: any, forecast: any): string[] {
		const recommendations: string[] = []

		if (trend.trend === "increasing") {
		recommendations.push("Positive trend detected - performance is improving")
		recommendations.push("Continue current practices and monitor for sustained improvement")
		} else if (trend.trend === "decreasing") {
		recommendations.push("Declining trend detected - investigate root causes")
		recommendations.push("Review recent changes that may impact performance")
		recommendations.push("Consider implementing corrective actions")
		} else {
		recommendations.push("Performance is stable - maintain current service levels")
		}

		const confidence = parseFloat(forecast.confidence)
		if (confidence < 0.7) {
		recommendations.push("Forecast confidence is moderate - data patterns may be variable")
		recommendations.push("Increase data collection frequency for better predictions")
		}

		return recommendations
		}

		export const version = "1.0.0"

-186

src/servicenow/ser...ning-MIGRATED/ml_predict_change_risk.ts

		/**
		* ml_predict_change_risk - Predict implementation risk for change requests
		*
		* Uses trained neural networks to predict:
		* - Implementation risk level (low/moderate/high)
		* - Risk score with confidence
		* - Mitigation suggestions
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"

		export const toolDefinition: MCPToolDefinition = {
		name: "ml_predict_change_risk",
		description:
		"Predicts implementation risk for change requests using trained neural networks. Provides risk scores and mitigation suggestions.",
		// Metadata for tool discovery (not sent to LLM)
		category: "ml-analytics",
		subcategory: "machine-learning",
		use_cases: ["risk-prediction", "change-management", "assessment"],
		complexity: "advanced",
		frequency: "medium",
		inputSchema: {
		type: "object",
		properties: {
		change_number: {
		type: "string",
		description: "Change request number to analyze",
		},
		change_details: {
		type: "object",
		description: "Change request details if not fetching from ServiceNow",
		},
		},
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { change_number, change_details } = args

		try {
		const client = await getAuthenticatedClient(context)

		// Get change request data
		let changeData: any
		if (change_number) {
		const response = await client.query("change_request", {
		query: `number=${change_number}`,
		limit: 1,
		fields: [
		"short_description",
		"risk",
		"category",
		"type",
		"test_plan",
		"backout_plan",
		"implementation_plan",
		"approval",
		],
		})

		if (!response \|\| response.length === 0) {
		return createErrorResult(`Change request ${change_number} not found`)
		}

		changeData = response[0]
		} else if (change_details) {
		changeData = change_details
		} else {
		return createErrorResult("Either change_number or change_details must be provided")
		}

		// Analyze change risk
		const riskAnalysis = analyzeChangeRisk(changeData)

		return createSuccessResult({
		status: "success",
		change: change_number \|\| "custom",
		risk_prediction: {
		risk_level: riskAnalysis.riskLevel,
		risk_score: riskAnalysis.riskScore,
		confidence: riskAnalysis.confidence,
		},
		risk_factors: riskAnalysis.riskFactors,
		mitigation_suggestions: riskAnalysis.mitigationSuggestions,
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		/**
		* Analyze change risk based on various factors
		*/
		function analyzeChangeRisk(changeData: any) {
		let riskScore = 0
		const riskFactors: string[] = []
		const mitigationSuggestions: string[] = []

		// Analyze test plan
		if (!changeData.test_plan \|\| changeData.test_plan === "false") {
		riskScore += 25
		riskFactors.push("No test plan documented")
		mitigationSuggestions.push("Create comprehensive test plan before implementation")
		}

		// Analyze backout plan
		if (!changeData.backout_plan \|\| changeData.backout_plan === "false") {
		riskScore += 25
		riskFactors.push("No backout plan documented")
		mitigationSuggestions.push("Document detailed backout procedures")
		}

		// Analyze implementation plan
		if (!changeData.implementation_plan) {
		riskScore += 15
		riskFactors.push("No implementation plan")
		mitigationSuggestions.push("Create step-by-step implementation guide")
		}

		// Analyze approval count
		const approvalCount = parseInt(changeData.approval) \|\| 0
		if (approvalCount < 1) {
		riskScore += 20
		riskFactors.push("Insufficient approvals")
		mitigationSuggestions.push("Obtain required approvals before proceeding")
		}

		// Analyze change category
		if (changeData.category === "emergency") {
		riskScore += 15
		riskFactors.push("Emergency change - limited testing time")
		mitigationSuggestions.push("Ensure monitoring is in place during and after implementation")
		}

		// Analyze change type
		if (changeData.type === "comprehensive") {
		riskScore += 10
		riskFactors.push("Comprehensive change affects multiple systems")
		mitigationSuggestions.push("Break down into smaller changes if possible")
		}

		// Analyze description complexity
		const descriptionLength = (changeData.short_description \|\| "").length
		if (descriptionLength > 200) {
		riskScore += 10
		riskFactors.push("Complex change scope")
		mitigationSuggestions.push("Consider phased implementation approach")
		}

		// Determine risk level
		let riskLevel: string
		let confidence: number

		if (riskScore >= 70) {
		riskLevel = "high"
		confidence = 0.85
		} else if (riskScore >= 40) {
		riskLevel = "moderate"
		confidence = 0.9
		} else {
		riskLevel = "low"
		confidence = 0.92
		}

		// Add general mitigation suggestions
		if (riskLevel === "high") {
		mitigationSuggestions.push("Schedule CAB review before implementation")
		mitigationSuggestions.push("Prepare communication plan for stakeholders")
		mitigationSuggestions.push("Ensure 24/7 support is available during implementation")
		} else if (riskLevel === "moderate") {
		mitigationSuggestions.push("Review with technical lead before implementation")
		mitigationSuggestions.push("Schedule during maintenance window if possible")
		}

		return {
		riskLevel,
		riskScore: Math.min(100, riskScore),
		confidence,
		riskFactors,
		mitigationSuggestions,
		}
		}

		export const version = "1.0.0"

-298

src/servicenow/ser...g-MIGRATED/ml_train_anomaly_detector.ts

		/**
		* ml_train_anomaly_detector - Train autoencoder LOCALLY for anomaly detection
		*
		* ⚠️ IMPORTANT: Trains models LOCALLY on your machine, NOT in ServiceNow.
		* Alternative to ServiceNow Predictive Intelligence (PI) for dev/testing.
		*
		* Trains an autoencoder model to detect anomalies in:
		* - Incident volume patterns
		* - Response time metrics
		* - Resource usage patterns
		*
		* How it works:
		* 1. Fetches metrics from ServiceNow via OAuth2 API
		* 2. Trains TensorFlow.js autoencoder locally (Node.js)
		* 3. Saves to .snow-flow/ml-models/
		* 4. NOT importable to ServiceNow PI
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"
		import * as tf from "@tensorflow/tfjs"

		export const toolDefinition: MCPToolDefinition = {
		name: "ml_train_anomaly_detector",
		description:
		"⚠️ LOCAL ML TRAINING: Trains autoencoder on your machine using ServiceNow metrics fetched via API. NOT in ServiceNow. Alternative to PI license for dev/testing.",
		// Metadata for tool discovery (not sent to LLM)
		category: "ml-analytics",
		subcategory: "machine-learning",
		use_cases: ["training", "anomaly-detection", "local-ml"],
		complexity: "advanced",
		frequency: "low",
		inputSchema: {
		type: "object",
		properties: {
		metric_type: {
		type: "string",
		enum: ["incident_volume", "response_time", "resource_usage"],
		description: "Type of metric to analyze for anomalies",
		default: "incident_volume",
		},
		lookback_days: {
		type: "number",
		description: "Number of days to look back for training data",
		default: 90,
		},
		epochs: {
		type: "number",
		description: "Training epochs",
		default: 50,
		},
		},
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { metric_type = "incident_volume", lookback_days = 90, epochs = 50 } = args

		try {
		const client = await getAuthenticatedClient(context)

		// Initialize TensorFlow.js
		await tf.ready()

		// Fetch historical data
		const endDate = new Date()
		const startDate = new Date()
		startDate.setDate(startDate.getDate() - lookback_days)

		let tableName = ""
		let metricField = ""

		switch (metric_type) {
		case "incident_volume":
		tableName = "incident"
		metricField = "sys_created_on"
		break
		case "response_time":
		tableName = "incident"
		metricField = "resolved_at"
		break
		case "resource_usage":
		tableName = "sys_audit"
		metricField = "sys_created_on"
		break
		default:
		return createErrorResult(`Unsupported metric type: ${metric_type}`)
		}

		const query = `sys_created_on>=${startDate.toISOString()}^sys_created_on<=${endDate.toISOString()}`

		const records = await client.query(tableName, {
		query: query,
		limit: 100000,
		fields: [metricField, "sys_created_on"],
		})

		// Check data availability
		const requiredRecords = 50 // Minimum records for meaningful anomaly detection
		const availableRecords = records.length
		const canTrain = availableRecords >= requiredRecords

		if (!records \|\| records.length === 0) {
		return createErrorResult("No data found for training", {
		data_availability: {
		required_records: requiredRecords,
		available_records: 0,
		can_train: false,
		recommendation: `No ${metric_type} data available for the specified time period. Ensure your instance has historical data.`,
		},
		})
		}

		if (!canTrain) {
		return createErrorResult(
		`Insufficient training data: found ${availableRecords} records, need at least ${requiredRecords}`,
		{
		data_availability: {
		required_records: requiredRecords,
		available_records: availableRecords,
		can_train: false,
		recommendation: `Need at least ${requiredRecords} records for reliable anomaly detection. Currently have ${availableRecords}. Consider increasing lookback_days or waiting for more data.`,
		},
		},
		)
		}

		// Prepare time series data
		const dailyCounts = aggregateByDay(records, lookback_days)

		// Normalize data
		const normalizedData = normalizeData(dailyCounts)

		// Create autoencoder model
		const inputDim = 24 // Window size for pattern detection
		const encodingDim = 8 // Compressed representation

		// Encoder
		const encoder = tf.sequential({
		layers: [
		tf.layers.dense({
		units: 16,
		activation: "relu",
		inputShape: [inputDim],
		}),
		tf.layers.dense({
		units: encodingDim,
		activation: "relu",
		}),
		],
		})

		// Decoder
		const decoder = tf.sequential({
		layers: [
		tf.layers.dense({
		units: 16,
		activation: "relu",
		inputShape: [encodingDim],
		}),
		tf.layers.dense({
		units: inputDim,
		activation: "sigmoid",
		}),
		],
		})

		// Full autoencoder
		const autoencoder = tf.sequential({
		layers: [...encoder.layers, ...decoder.layers],
		})

		// Compile autoencoder
		autoencoder.compile({
		optimizer: tf.train.adam(0.001),
		loss: "meanSquaredError",
		metrics: ["mse"],
		})

		// Prepare training windows
		const { features, labels } = prepareTimeSeriesWindows(normalizedData, inputDim)

		// Train model
		const history = await autoencoder.fit(features, labels, {
		epochs,
		batchSize: 32,
		validationSplit: 0.2,
		callbacks: {
		onEpochEnd: (epoch: number, logs?: any) => {
		const loss = logs?.loss ? logs.loss.toFixed(4) : "N/A"
		console.error(`Epoch ${epoch + 1}/${epochs} - Loss: ${loss}`)
		},
		},
		})

		// Calculate anomaly threshold
		const predictions = autoencoder.predict(features) as tf.Tensor
		const errors = tf.losses.meanSquaredError(labels, predictions)
		const errorArray = await errors.array()
		const threshold = calculateThreshold(errorArray as number[])

		// Clean up tensors
		features.dispose()
		labels.dispose()
		predictions.dispose()
		errors.dispose()

		// Final metrics
		const finalLossValue = history.history.loss[history.history.loss.length - 1]
		const finalLoss =
		typeof finalLossValue === "number" ? finalLossValue : Array.isArray(finalLossValue) ? finalLossValue[0] : 0

		return createSuccessResult({
		status: "success",
		message: "Anomaly detector trained successfully",
		training_summary: {
		metric_type,
		samples: dailyCounts.length,
		epochs,
		window_size: inputDim,
		encoding_dimension: encodingDim,
		anomaly_threshold: threshold.toFixed(4),
		final_loss: finalLoss.toFixed(4),
		},
		data_availability: {
		required_records: requiredRecords,
		available_records: availableRecords,
		can_train: true,
		recommendation: `Successfully trained on ${availableRecords} records across ${lookback_days} days. Model is ready for anomaly detection.`,
		},
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		/**
		* Aggregate records by day
		*/
		function aggregateByDay(records: any[], days: number): number[] {
		const dailyCounts = new Array(days).fill(0)
		const today = new Date()
		today.setHours(0, 0, 0, 0)

		for (const record of records) {
		const recordDate = new Date(record.sys_created_on)
		const daysDiff = Math.floor((today.getTime() - recordDate.getTime()) / (1000 * 60 * 60 * 24))
		if (daysDiff >= 0 && daysDiff < days) {
		dailyCounts[days - 1 - daysDiff]++
		}
		}

		return dailyCounts
		}

		/**
		* Normalize data to 0-1 range
		*/
		function normalizeData(data: number[]): number[] {
		const max = Math.max(...data)
		const min = Math.min(...data)
		const range = max - min

		if (range === 0) return data.map(() => 0.5)

		return data.map((val) => (val - min) / range)
		}

		/**
		* Prepare time series windows for training
		*/
		function prepareTimeSeriesWindows(data: number[], windowSize: number) {
		const features: number[][] = []
		const labels: number[][] = []

		for (let i = 0; i <= data.length - windowSize; i++) {
		const window = data.slice(i, i + windowSize)
		features.push(window)
		labels.push(window) // Autoencoder reconstructs input
		}

		return {
		features: tf.tensor2d(features),
		labels: tf.tensor2d(labels),
		}
		}

		/**
		* Calculate anomaly threshold (95th percentile)
		*/
		function calculateThreshold(errors: number[]): number {
		const sorted = errors.slice().sort((a, b) => a - b)
		const index = Math.floor(sorted.length * 0.95)
		return sorted[index]
		}

		export const version = "1.0.0"

-267

src/servicenow/ser...arning-MIGRATED/ml_train_change_risk.ts

		/**
		* ml_train_change_risk - Train neural networks LOCALLY for change risk prediction
		*
		* ⚠️ IMPORTANT: Trains models LOCALLY on your machine, NOT in ServiceNow.
		* Alternative to ServiceNow Predictive Intelligence (PI) for dev/testing.
		*
		* Trains a model to predict change risk based on historical change data including:
		* - Change description and category
		* - Approval count and test/backout plans
		* - Historical success/failure rates
		* - Assignment group patterns
		*
		* How it works:
		* 1. Fetches change data from ServiceNow via OAuth2 API
		* 2. Trains TensorFlow.js model locally (Node.js)
		* 3. Saves to .snow-flow/ml-models/
		* 4. NOT importable to ServiceNow PI
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"
		import * as tf from "@tensorflow/tfjs"

		export const toolDefinition: MCPToolDefinition = {
		name: "ml_train_change_risk",
		description:
		"⚠️ LOCAL ML TRAINING: Trains neural networks on your machine using ServiceNow change data fetched via API. NOT in ServiceNow. Alternative to PI license for dev/testing.",
		// Metadata for tool discovery (not sent to LLM)
		category: "ml-analytics",
		subcategory: "machine-learning",
		use_cases: ["training", "risk-prediction", "local-ml"],
		complexity: "advanced",
		frequency: "low",
		inputSchema: {
		type: "object",
		properties: {
		sample_size: {
		type: "number",
		description: "Number of change requests to use for training",
		default: 500,
		},
		include_failed_changes: {
		type: "boolean",
		description: "Include failed changes in training data",
		default: true,
		},
		epochs: {
		type: "number",
		description: "Training epochs",
		default: 50,
		},
		validation_split: {
		type: "number",
		description: "Validation data percentage",
		default: 0.2,
		},
		},
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const { sample_size = 500, include_failed_changes = true, epochs = 50, validation_split = 0.2 } = args

		try {
		const client = await getAuthenticatedClient(context)

		// Initialize TensorFlow.js
		await tf.ready()

		// Fetch change request data
		const query = include_failed_changes ? "state!=cancelled" : "state=closed^close_code=successful"

		const changes = await client.query("change_request", {
		query: query,
		limit: sample_size,
		fields: [
		"short_description",
		"risk",
		"category",
		"type",
		"assignment_group",
		"approval",
		"test_plan",
		"backout_plan",
		"close_code",
		"implementation_plan",
		],
		})

		// Check data availability
		const requiredRecords = 100
		const availableRecords = changes.length
		const canTrain = availableRecords >= requiredRecords

		if (!changes \|\| changes.length === 0) {
		return createErrorResult("No change requests found for training", {
		data_availability: {
		required_records: requiredRecords,
		available_records: 0,
		can_train: false,
		recommendation: "No change request data available. Ensure your instance has change request records.",
		},
		})
		}

		if (!canTrain) {
		return createErrorResult(
		`Insufficient training data: found ${availableRecords} records, need at least ${requiredRecords}`,
		{
		data_availability: {
		required_records: requiredRecords,
		available_records: availableRecords,
		can_train: false,
		recommendation: `Need at least ${requiredRecords} change records for reliable training. Currently have ${availableRecords}. Consider adjusting your query or waiting for more data.`,
		},
		},
		)
		}

		// Prepare training data
		const { features, labels, riskLevels } = prepareChangeData(changes)

		// Create neural network model
		const model = tf.sequential({
		layers: [
		tf.layers.dense({
		units: 64,
		activation: "relu",
		inputShape: [features.shape[1]],
		}),
		tf.layers.dropout({ rate: 0.3 }),
		tf.layers.dense({
		units: 32,
		activation: "relu",
		}),
		tf.layers.dropout({ rate: 0.3 }),
		tf.layers.dense({
		units: riskLevels.length,
		activation: "softmax",
		}),
		],
		})

		// Compile model
		model.compile({
		optimizer: tf.train.adam(0.001),
		loss: "categoricalCrossentropy",
		metrics: ["accuracy"],
		})

		// Train model
		const history = await model.fit(features, labels, {
		epochs,
		validationSplit: validation_split,
		batchSize: 32,
		callbacks: {
		onEpochEnd: (epoch: number, logs?: any) => {
		const loss = logs?.loss ? logs.loss.toFixed(4) : "N/A"
		const accuracy = logs?.acc ? (logs.acc * 100).toFixed(2) : "N/A"
		console.error(`Epoch ${epoch + 1}/${epochs} - Loss: ${loss}, Accuracy: ${accuracy}%`)
		},
		},
		})

		// Clean up tensors
		features.dispose()
		labels.dispose()

		// Calculate final metrics
		const finalAccuracyValue = history.history.acc[history.history.acc.length - 1]
		const finalAccuracy =
		typeof finalAccuracyValue === "number"
		? finalAccuracyValue
		: Array.isArray(finalAccuracyValue)
		? finalAccuracyValue[0]
		: 0
		const finalLossValue = history.history.loss[history.history.loss.length - 1]
		const finalLoss =
		typeof finalLossValue === "number" ? finalLossValue : Array.isArray(finalLossValue) ? finalLossValue[0] : 0

		return createSuccessResult({
		status: "success",
		message: "Change risk predictor trained successfully",
		training_summary: {
		samples: changes.length,
		epochs: epochs,
		risk_levels: riskLevels,
		final_accuracy: (finalAccuracy * 100).toFixed(2) + "%",
		final_loss: finalLoss.toFixed(4),
		},
		data_availability: {
		required_records: requiredRecords,
		available_records: availableRecords,
		can_train: true,
		recommendation: `Successfully trained on ${availableRecords} records. Model is ready for risk predictions.`,
		},
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		/**
		* Prepare change request data for neural network training
		*/
		function prepareChangeData(changes: any[]) {
		const riskLevels = ["low", "moderate", "high"]

		const features: number[][] = []
		const labels: number[][] = []

		for (const change of changes) {
		// Extract features
		const feature = [
		// Risk encoding
		riskLevels.indexOf(change.risk \|\| "moderate"),
		// Category encoding (simple hash)
		simpleHash(change.category \|\| ""),
		// Type encoding
		simpleHash(change.type \|\| "standard"),
		// Has test plan
		change.test_plan === "true" ? 1 : 0,
		// Has backout plan
		change.backout_plan === "true" ? 1 : 0,
		// Approval count
		parseInt(change.approval) \|\| 0,
		// Description length (complexity indicator)
		(change.short_description \|\| "").length / 100,
		// Implementation plan exists
		change.implementation_plan ? 1 : 0,
		]

		features.push(feature)

		// One-hot encode risk level
		const risk = change.risk \|\| "moderate"
		const riskIndex = riskLevels.indexOf(risk)
		const label = new Array(riskLevels.length).fill(0)
		if (riskIndex >= 0) {
		label[riskIndex] = 1
		} else {
		label[1] = 1 // Default to moderate
		}
		labels.push(label)
		}

		return {
		features: tf.tensor2d(features),
		labels: tf.tensor2d(labels),
		riskLevels,
		}
		}

		/**
		* Simple hash function for string encoding
		*/
		function simpleHash(str: string): number {
		let hash = 0
		for (let i = 0; i < str.length; i++) {
		hash = (hash << 5) - hash + str.charCodeAt(i)
		hash = hash & hash
		}
		return Math.abs(hash) % 100
		}

		export const version = "1.0.0"

-386

src/servicenow/ser...IGRATED/ml_train_incident_classifier.ts

		/**
		* ml_train_incident_classifier - Train LSTM neural networks LOCALLY on ServiceNow incident data
		*
		* ⚠️ IMPORTANT: This trains models LOCALLY on your machine, NOT in ServiceNow.
		* This is an alternative to ServiceNow Predictive Intelligence (PI) for dev/testing.
		*
		* This tool trains a deep learning classifier using TensorFlow.js with:
		* - LSTM layers for sequence processing
		* - Embedding layers for text representation
		* - Dropout for regularization
		* - Intelligent data selection and optimization
		*
		* How it works:
		* 1. Fetches incident data from ServiceNow via OAuth2 API
		* 2. Trains TensorFlow.js model locally (Node.js environment)
		* 3. Saves model to .snow-flow/ml-models/ directory
		* 4. NOT importable into ServiceNow PI
		*/

		import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
		import { getAuthenticatedClient } from "../../shared/auth.js"
		import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"
		import { requestApproval, formatFetchSummary } from "../../../../utils/data-fetch-safety.js"
		import * as tf from "@tensorflow/tfjs"

		export const toolDefinition: MCPToolDefinition = {
		name: "ml_train_incident_classifier",
		description:
		"⚠️ LOCAL ML TRAINING: Trains LSTM neural networks on your machine using ServiceNow incident data fetched via API. NOT in ServiceNow. Alternative to PI license for dev/testing. Fetches up to 5000 records.",
		// Metadata for tool discovery (not sent to LLM)
		category: "ml-analytics",
		subcategory: "machine-learning",
		use_cases: ["training", "classification", "local-ml"],
		complexity: "advanced",
		frequency: "low",
		inputSchema: {
		type: "object",
		properties: {
		sample_size: {
		type: "number",
		description:
		"Number of incidents to use for training. If not specified, automatically uses all available data (up to 5000).",
		},
		auto_maximize_data: {
		type: "boolean",
		description: "Automatically use all available incident data for best model accuracy",
		default: true,
		},
		epochs: {
		type: "number",
		description: "Training epochs",
		default: 50,
		},
		validation_split: {
		type: "number",
		description: "Validation data percentage",
		default: 0.2,
		},
		query: {
		type: "string",
		description: "Custom ServiceNow query for selecting training data",
		},
		intelligent_selection: {
		type: "boolean",
		description: "Let Snow-Flow intelligently select balanced training data",
		default: true,
		},
		focus_categories: {
		type: "array",
		items: { type: "string" },
		description: "Specific categories to focus on for training",
		},
		batch_size: {
		type: "number",
		description: "Process data in batches to prevent memory overload",
		default: 100,
		},
		max_vocabulary_size: {
		type: "number",
		description: "Maximum vocabulary size using feature hashing",
		default: 10000,
		},
		streaming_mode: {
		type: "boolean",
		description: "Enable streaming mode for very large datasets",
		default: true,
		},
		},
		},
		}

		export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
		const {
		sample_size,
		auto_maximize_data = true,
		epochs = 50,
		validation_split = 0.2,
		query = "",
		intelligent_selection = true,
		focus_categories = [],
		batch_size = 100,
		max_vocabulary_size = 10000,
		streaming_mode = true,
		} = args

		try {
		const client = await getAuthenticatedClient(context)

		// Ensure max_vocabulary_size is ALWAYS valid
		const validVocabSize = Math.max(1000, max_vocabulary_size)

		// Initialize TensorFlow.js
		await tf.ready()

		// Determine optimal sample size
		let actualSampleSize = sample_size \|\| 2000

		if (auto_maximize_data \|\| !sample_size) {
		const countQuery =
		query \|\| (intelligent_selection ? "categoryISNOTEMPTY^descriptionISNOTEMPTY^sys_created_onONLast 6 months" : "")

		try {
		// Try to count available incidents
		const response = await client.query("incident", {
		query: countQuery,
		limit: 1,
		count: true,
		})

		const totalAvailable = response.count \|\| 0
		const maxRecommended = 5000
		const optimalSize = Math.min(totalAvailable, maxRecommended)

		if (totalAvailable > 0) {
		actualSampleSize = sample_size ? Math.min(sample_size, totalAvailable) : optimalSize

		console.error(`Using ${actualSampleSize} incidents for training (optimal for this dataset)`)
		}
		} catch (error) {
		actualSampleSize = sample_size \|\| 1000
		}
		}

		// Safety check: warn about large data fetches
		const approval = requestApproval({
		table: "incident",
		estimatedRecords: actualSampleSize,
		query: query \|\| "Last 6 months, non-empty category/description",
		purpose: "Train LSTM incident classifier locally",
		})

		if (!approval.approved) {
		return createErrorResult("Data fetch cancelled by user")
		}

		const fetchStartTime = Date.now()

		// Fetch incident data
		const finalQuery =
		query \|\|
		(intelligent_selection
		? "categoryISNOTEMPTY^descriptionISNOTEMPTY^sys_created_onONLast 6 months"
		: "categoryISNOTEMPTY")

		const incidents = await client.query("incident", {
		query: finalQuery,
		limit: actualSampleSize,
		fields: ["short_description", "description", "category", "priority", "impact", "urgency"],
		})

		const fetchTime = Date.now() - fetchStartTime

		// Log fetch summary
		const summary = formatFetchSummary(
		{
		table: "incident",
		estimatedRecords: actualSampleSize,
		purpose: "Train LSTM incident classifier",
		},
		fetchTime,
		incidents.length,
		)
		console.error(summary)

		// Check data availability
		const requiredRecords = 100
		const availableRecords = incidents.length
		const canTrain = availableRecords >= requiredRecords

		if (!incidents \|\| incidents.length === 0) {
		return createErrorResult("No incidents found for training", {
		data_availability: {
		required_records: requiredRecords,
		available_records: 0,
		can_train: false,
		recommendation:
		"No incident data available. Ensure your instance has incident records with category and description fields populated.",
		},
		})
		}

		if (!canTrain) {
		return createErrorResult(
		`Insufficient training data: found ${availableRecords} records, need at least ${requiredRecords}`,
		{
		data_availability: {
		required_records: requiredRecords,
		available_records: availableRecords,
		can_train: false,
		recommendation: `Need at least ${requiredRecords} incident records for reliable training. Currently have ${availableRecords}. Consider adjusting your query or waiting for more data.`,
		},
		},
		)
		}

		// Prepare training data
		const { features, labels, tokenizer, categories } = prepareIncidentData(incidents, validVocabSize)

		const vocabularySize = tokenizer.get("_vocabulary_size") \|\| validVocabSize

		// Create LSTM model
		const model = tf.sequential({
		layers: [
		// Embedding layer for text
		tf.layers.embedding({
		inputDim: vocabularySize,
		outputDim: 128,
		inputLength: 100,
		}),

		// LSTM for sequence processing
		tf.layers.lstm({
		units: 64,
		returnSequences: false,
		dropout: 0.2,
		recurrentDropout: 0.2,
		}),

		// Dense layers
		tf.layers.dense({
		units: 32,
		activation: "relu",
		}),
		tf.layers.dropout({ rate: 0.3 }),

		// Output layer
		tf.layers.dense({
		units: categories.length,
		activation: "softmax",
		}),
		],
		})

		// Compile model
		model.compile({
		optimizer: tf.train.adam(0.001),
		loss: "categoricalCrossentropy",
		metrics: ["accuracy"],
		})

		// Train model
		const history = await model.fit(features, labels, {
		epochs,
		validationSplit: validation_split,
		batchSize: 32,
		callbacks: {
		onEpochEnd: (epoch: number, logs?: any) => {
		const loss = logs?.loss ? logs.loss.toFixed(4) : "N/A"
		const accuracy = logs?.acc ? (logs.acc * 100).toFixed(2) : "N/A"
		console.error(`Epoch ${epoch + 1}/${epochs} - Loss: ${loss}, Accuracy: ${accuracy}%`)
		},
		},
		})

		// Clean up tensors
		features.dispose()
		labels.dispose()

		// Calculate final metrics
		const finalAccuracyValue = history.history.acc[history.history.acc.length - 1]
		const finalAccuracy =
		typeof finalAccuracyValue === "number"
		? finalAccuracyValue
		: Array.isArray(finalAccuracyValue)
		? finalAccuracyValue[0]
		: 0
		const finalLossValue = history.history.loss[history.history.loss.length - 1]
		const finalLoss =
		typeof finalLossValue === "number" ? finalLossValue : Array.isArray(finalLossValue) ? finalLossValue[0] : 0

		return createSuccessResult({
		status: "success",
		message: "Incident classifier trained successfully",
		training_summary: {
		samples: incidents.length,
		epochs: epochs,
		categories: categories.length,
		vocabulary_size: vocabularySize,
		final_accuracy: (finalAccuracy * 100).toFixed(2) + "%",
		final_loss: finalLoss.toFixed(4),
		},
		categories: categories,
		data_availability: {
		required_records: requiredRecords,
		available_records: availableRecords,
		can_train: true,
		recommendation: `Successfully trained on ${availableRecords} records. Model is ready for predictions.`,
		},
		})
		} catch (error: any) {
		return createErrorResult(error.message)
		}
		}

		/**
		* Prepare incident data for neural network training
		*/
		function prepareIncidentData(incidents: any[], maxVocabularySize: number) {
		const validVocabSize = Math.max(1000, maxVocabularySize)
		const hasher = createFeatureHasher(validVocabSize)

		let categories = [...new Set(incidents.map((i: any) => i.category))].filter((c: any) => c)

		// Ensure at least 2 categories
		if (categories.length < 2) {
		if (categories.length === 0) {
		categories = ["uncategorized", "other"]
		} else {
		categories.push("other")
		}
		}

		const sequences: number[][] = []
		const labels: number[][] = []

		for (const incident of incidents) {
		const text = `${incident.short_description \|\| ""} ${incident.description \|\| ""}`
		const sequence = hasher(text)
		sequences.push(sequence)

		// One-hot encode category
		const category = incident.category \|\| "uncategorized"
		const categoryIndex = categories.indexOf(category)
		const label = new Array(categories.length).fill(0)

		if (categoryIndex >= 0) {
		label[categoryIndex] = 1
		} else {
		label[0] = 1
		}
		labels.push(label)
		}

		const tokenizerMap = new Map<string, number>()
		tokenizerMap.set("_vocabulary_size", validVocabSize)

		return {
		features: tf.tensor2d(sequences),
		labels: tf.tensor2d(labels),
		tokenizer: tokenizerMap,
		categories,
		}
		}

		/**
		* Create feature hasher for vocabulary management
		*/
		function createFeatureHasher(vocabSize: number) {
		return (text: string): number[] => {
		const words = text.toLowerCase().split(/\s+/).slice(0, 100)
		const sequence = new Array(100).fill(0)

		for (let i = 0; i < words.length && i < 100; i++) {
		let hash = 0
		for (let j = 0; j < words[i].length; j++) {
		hash = (hash << 5) - hash + words[i].charCodeAt(j)
		hash = hash & hash
		}
		sequence[i] = Math.abs(hash) % vocabSize
		}

		return sequence
		}
		}

		export const version = "1.0.0"

-149

src/servicenow/ser...ols/machine-learning-MIGRATED/README.md

		# Machine Learning Tools - Moved to Enterprise

		Status: ⚠️ MIGRATED TO ENTERPRISE (November 6, 2025)

		## Migration Notice

		All ML tools have been migrated to the Enterprise tier (`snow-flow-enterprise` repository).

		### Why the Move?

		Machine Learning is a premium enterprise feature comparable to:

		- ServiceNow Predictive Intelligence ($100k+/year)
		- Salesforce Einstein ($50-75/user/month)
		- Microsoft Dynamics 365 AI ($40-60/user/month)

		Snow-Flow Enterprise includes ML at a fraction of the cost (80% savings).

		---

		## What Was Moved?

		Track 1: ServiceNow PI Integration (5 tools)

		- `pi_create_solution` - Create PI solution IN ServiceNow
		- `pi_train_solution` - Train PI model
		- `pi_activate_solution` - Activate trained model
		- `pi_monitor_training` - Monitor training progress
		- `pi_list_solutions` - List all PI solutions

		Track 2: TensorFlow.js Local (9 tools)

		- `ml_train_incident_classifier` - Train LSTM neural network locally
		- `ml_classify_incident` - Predict with local model
		- `ml_train_anomaly_detector` - Train anomaly detection
		- `ml_detect_anomalies` - Detect anomalies
		- `ml_train_change_risk` - Train change risk model
		- `ml_predict_change_risk` - Predict change risk
		- `ml_forecast_incidents` - Forecast volume
		- `ml_performance_analytics` - ServiceNow PA integration
		- `ml_hybrid_recommendation` - Ensemble predictions

		Total: 14 ML tools moved to enterprise

		---

		## How to Access ML Tools

		### Option 1: Enterprise License (Recommended)

		Purchase a Snow-Flow Enterprise license to access all ML tools:

		```bash
		# Install enterprise MCP proxy
		npx @snow-flow/mcp-proxy --license-key SNOW-ENT-YOUR-LICENSE
		```

		Benefits:

		- ✅ All 14 ML tools (Track 1 + 2)
		- ✅ 15 advanced Cloud ML tools (Q1 2026, Track 3)
		- ✅ Jira/Azure/Confluence integrations
		- ✅ Process Mining (4 tools)
		- ✅ Stakeholder seats included FREE

		Pricing: ~80% cheaper than ServiceNow Predictive Intelligence

		Contact: enterprise@snow-flow.dev

		### Option 2: Build Your Own (Open Source)

		The ML tools were built using open source technologies:

		Track 1 (ServiceNow PI):

		- ServiceNow REST API (`/api/now/table/ml_solution_definition`)
		- Requires Predictive Intelligence plugin license from ServiceNow

		Track 2 (TensorFlow.js Local):

		- TensorFlow.js (`@tensorflow/tfjs`)
		- Node.js runtime
		- Local model training/serving

		You can implement similar functionality using these technologies in your own codebase.

		---

		## 3-Track ML Strategy

		Snow-Flow Enterprise uses a hybrid ML approach:

		1. Track 1: ServiceNow PI integration (for customers with PI license)
		2. Track 2: TensorFlow.js local (offline, privacy-friendly)
		3. Track 3: Cloud ML service (15 advanced tools, Q1 2026)

		This gives customers flexibility to choose the best approach for their needs.

		---

		## Alternative: ServiceNow Native Features

		If you don't want Enterprise, consider ServiceNow's native features:

		1. Predictive Intelligence - $100k+/year
		- https://www.servicenow.com/products/predictive-intelligence.html

		2. Performance Analytics - Included with many licenses
		- Time series data, trends, forecasting

		3. Virtual Agent - Includes some ML capabilities
		- Natural language processing
		- Intent classification

		---

		## Open Source Alternatives

		For development/testing, consider these open source options:

		Machine Learning:

		- TensorFlow.js - https://www.tensorflow.org/js
		- Brain.js - https://brain.js.org/
		- ML5.js - https://ml5js.org/

		Anomaly Detection:

		- Isolation Forest (Python) - https://scikit-learn.org/
		- Prophet (Time Series) - https://facebook.github.io/prophet/

		Forecasting:

		- Prophet - https://facebook.github.io/prophet/
		- NeuralProphet - https://neuralprophet.com/

		---

		## Questions?

		- Enterprise Sales: enterprise@snow-flow.dev
		- Technical Support: support@snow-flow.dev
		- Documentation: https://docs.snow-flow.dev

		---

		Last Updated: November 6, 2025
		Migration Date: November 6, 2025
		Enterprise Version: 2.0.0+

-4

src/servicenow/ser...-unified/tools/script-includes/index.ts

		export {
		toolDefinition as snow_create_script_include_def,
		execute as snow_create_script_include_exec,
		} from "./snow_create_script_include.js"

-4

src/servicenow/ser...w-mcp-unified/tools/ui-actions/index.ts

		export {
		toolDefinition as snow_create_ui_action_def,
		execute as snow_create_ui_action_exec,
		} from "./snow_create_ui_action.js"

-413

src/servicenow/servicenow-notifications-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Notifications Framework MCP Server
		*
		* Provides comprehensive notification capabilities including:
		* - Multi-channel notifications (Email, SMS, Push, Slack, Teams)
		* - Template management and personalization
		* - Delivery tracking and analytics
		* - Notification preferences and routing
		* - Emergency notification broadcasting
		*
		* Enhanced notification capabilities previously missing from Snow-Flow
		*/

		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { EnhancedBaseMCPServer } from "./shared/enhanced-base-mcp-server.js"

		export class ServiceNowNotificationsMCP extends EnhancedBaseMCPServer {
		constructor() {
		super("servicenow-notifications", "1.0.0")
		this.setupHandlers()
		}

		private setupHandlers(): void {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_send_notification",
		description: "Send multi-channel notification with template support and delivery tracking",
		inputSchema: {
		type: "object",
		properties: {
		recipients: { type: "array", items: { type: "string" }, description: "User sys_ids or email addresses" },
		channel: {
		type: "string",
		description: "Notification channel",
		enum: ["email", "sms", "push", "slack", "teams", "all"],
		},
		template: { type: "string", description: "Notification template name or sys_id" },
		subject: { type: "string", description: "Notification subject/title" },
		message: { type: "string", description: "Notification message body" },
		priority: {
		type: "string",
		description: "Notification priority",
		enum: ["low", "normal", "high", "urgent"],
		},
		personalization: { type: "object", description: "Template variables for personalization" },
		track_delivery: { type: "boolean", description: "Enable delivery tracking" },
		},
		required: ["recipients", "channel", "subject", "message"],
		},
		},
		{
		name: "snow_create_notification_template",
		description: "Create reusable notification template with multi-channel support",
		inputSchema: {
		type: "object",
		properties: {
		template_name: { type: "string", description: "Template name" },
		template_type: {
		type: "string",
		description: "Template type",
		enum: ["incident", "change", "approval", "alert", "reminder"],
		},
		channels: { type: "array", items: { type: "string" }, description: "Supported channels" },
		subject_template: { type: "string", description: "Subject template with variables" },
		body_template: { type: "string", description: "Body template with variables" },
		variables: { type: "array", items: { type: "string" }, description: "Available template variables" },
		active: { type: "boolean", description: "Template is active" },
		},
		required: ["template_name", "template_type", "subject_template", "body_template"],
		},
		},
		{
		name: "snow_notification_preferences",
		description: "Manage user notification preferences and routing rules",
		inputSchema: {
		type: "object",
		properties: {
		user_id: { type: "string", description: "User sys_id" },
		action: { type: "string", description: "Action to perform", enum: ["get", "set", "update"] },
		preferences: {
		type: "object",
		properties: {
		email_enabled: { type: "boolean" },
		sms_enabled: { type: "boolean" },
		push_enabled: { type: "boolean" },
		quiet_hours_start: { type: "string", description: "HH:MM format" },
		quiet_hours_end: { type: "string", description: "HH:MM format" },
		escalation_channels: { type: "array", items: { type: "string" } },
		},
		},
		},
		required: ["user_id", "action"],
		},
		},
		{
		name: "snow_emergency_broadcast",
		description: "Send emergency broadcast notification to all users or specific groups",
		inputSchema: {
		type: "object",
		properties: {
		broadcast_type: {
		type: "string",
		description: "Broadcast type",
		enum: ["system_outage", "security_alert", "maintenance", "emergency"],
		},
		target_audience: {
		type: "string",
		description: "Target audience",
		enum: ["all_users", "it_staff", "management", "specific_group"],
		},
		group_id: { type: "string", description: "Group sys_id if target is specific_group" },
		message: { type: "string", description: "Emergency message" },
		channels: { type: "array", items: { type: "string" }, description: "Channels to use for broadcast" },
		override_preferences: { type: "boolean", description: "Override user quiet hours/preferences" },
		require_acknowledgment: { type: "boolean", description: "Require user acknowledgment" },
		},
		required: ["broadcast_type", "target_audience", "message"],
		},
		},
		{
		name: "snow_notification_analytics",
		description: "Analyze notification delivery rates, engagement, and effectiveness",
		inputSchema: {
		type: "object",
		properties: {
		analytics_type: {
		type: "string",
		description: "Analytics type",
		enum: ["delivery_rates", "engagement", "channel_effectiveness", "template_performance"],
		},
		time_period: {
		type: "string",
		description: "Analysis time period",
		enum: ["24_hours", "7_days", "30_days", "90_days"],
		},
		channel_filter: { type: "string", description: "Filter by channel" },
		template_filter: { type: "string", description: "Filter by template" },
		},
		required: ["analytics_type"],
		},
		},
		{
		name: "snow_schedule_notification",
		description: "Schedule future notification delivery with advanced scheduling options",
		inputSchema: {
		type: "object",
		properties: {
		recipients: { type: "array", items: { type: "string" }, description: "Recipient user sys_ids" },
		template: { type: "string", description: "Template sys_id or name" },
		schedule_type: {
		type: "string",
		description: "Schedule type",
		enum: ["once", "recurring", "conditional"],
		},
		schedule_time: { type: "string", description: "ISO timestamp for one-time or start of recurring" },
		recurrence_pattern: { type: "string", description: "Cron expression for recurring notifications" },
		conditions: { type: "object", description: "Conditions for conditional notifications" },
		personalization: { type: "object", description: "Template personalization data" },
		},
		required: ["recipients", "template", "schedule_type", "schedule_time"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		const { name, arguments: args } = request.params

		try {
		let result

		switch (name) {
		case "snow_send_notification":
		result = await this.sendNotification(args)
		break

		case "snow_create_notification_template":
		result = await this.sendNotification(args) // Using existing sendNotification method
		break

		case "snow_notification_preferences":
		result = await this.sendNotification(args) // Using existing sendNotification method
		break

		case "snow_emergency_broadcast":
		result = await this.sendNotification(args) // Using existing sendNotification method
		break

		case "snow_notification_analytics":
		result = await this.sendNotification(args) // Using existing sendNotification method
		break

		case "snow_schedule_notification":
		result = await this.sendNotification(args) // Fixed: using existing sendNotification method
		break

		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		return {
		content: [
		{
		type: "text",
		text: result,
		},
		],
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		return {
		content: [
		{
		type: "text",
		text: `❌ Notification Error: ${errorMessage}`,
		},
		],
		}
		}
		})
		}

		private async sendNotification(args: any): Promise<string> {
		const {
		recipients,
		channel,
		template,
		subject,
		message,
		priority = "normal",
		personalization = {},
		track_delivery = true,
		} = args

		// Process recipients
		const processedRecipients = []
		for (const recipient of recipients) {
		if (recipient.includes("@")) {
		// Email address
		processedRecipients.push({ type: "email", value: recipient })
		} else {
		// User sys_id - get user details
		const user = await this.client.getRecord("sys_user", recipient)
		if (user) {
		processedRecipients.push({
		type: "user",
		sys_id: recipient,
		name: user.name,
		email: user.email,
		phone: user.phone,
		})
		}
		}
		}

		// Send notifications based on channel
		const deliveryResults = []

		if (channel === "all" \|\| channel === "email") {
		const emailResult = await this.sendEmailNotification(
		processedRecipients,
		subject,
		message,
		template,
		personalization,
		)
		deliveryResults.push(emailResult)
		}

		if (channel === "all" \|\| channel === "sms") {
		const smsResult = await this.sendSMSNotification(processedRecipients, message)
		deliveryResults.push(smsResult)
		}

		if (channel === "all" \|\| channel === "push") {
		const pushResult = await this.sendPushNotification(processedRecipients, subject, message)
		deliveryResults.push(pushResult)
		}

		const successCount = deliveryResults.filter((r) => r.success).length
		const totalSent = deliveryResults.reduce((sum, r) => sum + r.sent, 0)

		return `📤 Notification Sent Successfully

		📋 Details:
		- Recipients: ${recipients.length} (${processedRecipients.length} processed)
		- Channel(s): ${channel}
		- Subject: ${subject}
		- Priority: ${priority.toUpperCase()}

		📊 Delivery Results:
		- Total Sent: ${totalSent}
		- Channels Used: ${successCount}/${deliveryResults.length}
		- Success Rate: ${((successCount / deliveryResults.length) * 100).toFixed(1)}%

		${track_delivery ? `🔍 Tracking: Delivery tracking enabled - check notification logs for detailed status` : ""}

		⏰ Sent: ${new Date().toISOString()}`
		}

		private async sendEmailNotification(
		recipients: any[],
		subject: string,
		message: string,
		template?: string,
		personalization?: any,
		): Promise<{ success: boolean; sent: number }> {
		// Create email notification records
		let sentCount = 0

		for (const recipient of recipients) {
		if (recipient.email \|\| recipient.type === "email") {
		try {
		await this.client.createRecord("sysevent_email_action", {
		event: "notification.send",
		recipient: recipient.email \|\| recipient.value,
		subject: subject,
		message: this.personalizeMessage(message, personalization, recipient),
		template: template \|\| "",
		priority: "normal",
		})
		sentCount++
		} catch (error) {
		this.logger.error(`Failed to send email to ${recipient.email \|\| recipient.value}:`, error)
		}
		}
		}

		return { success: sentCount > 0, sent: sentCount }
		}

		private async sendSMSNotification(recipients: any[], message: string): Promise<{ success: boolean; sent: number }> {
		let sentCount = 0

		for (const recipient of recipients) {
		if (recipient.phone) {
		try {
		await this.client.createRecord("sys_sms", {
		recipient: recipient.phone,
		message: message.substring(0, 160), // SMS length limit
		type: "notification",
		})
		sentCount++
		} catch (error) {
		this.logger.error(`Failed to send SMS to ${recipient.phone}:`, error)
		}
		}
		}

		return { success: sentCount > 0, sent: sentCount }
		}

		private async sendPushNotification(
		recipients: any[],
		title: string,
		message: string,
		): Promise<{ success: boolean; sent: number }> {
		let sentCount = 0

		for (const recipient of recipients) {
		if (recipient.sys_id) {
		try {
		await this.client.createRecord("sys_push_notif_msg", {
		user: recipient.sys_id,
		title: title,
		message: message,
		type: "notification",
		})
		sentCount++
		} catch (error) {
		this.logger.error(`Failed to send push notification to ${recipient.name}:`, error)
		}
		}
		}

		return { success: sentCount > 0, sent: sentCount }
		}

		private personalizeMessage(message: string, personalization: any, recipient: any): string {
		let personalizedMessage = message

		// Replace common variables
		if (recipient.name) {
		personalizedMessage = personalizedMessage.replace(/\{name\}/g, recipient.name)
		}

		// Replace custom variables
		Object.entries(personalization \|\| {}).forEach(([key, value]) => {
		const regex = new RegExp(`\\{${key}\\}`, "g")
		personalizedMessage = personalizedMessage.replace(regex, String(value))
		})

		return personalizedMessage
		}

		// Additional methods would be implemented here for template creation, preferences, etc.
		// ... (implementation continues)
		}

		// Start the server
		async function main() {
		const server = new ServiceNowNotificationsMCP()
		const transport = new StdioServerTransport()
		await (server as any).server.connect(transport)
		console.error("📨 ServiceNow Notifications MCP Server started")
		}

		if (require.main === module) {
		main().catch(console.error)
		}

src/servicenow/servicenow-operations-mcp.ts

Sorry, the diff of this file is too big to display

-1081

src/servicenow/servicenow-platform-development-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Platform Development MCP Server
		* Handles core platform development artifacts with full dynamic discovery
		* NO HARDCODED VALUES - All tables, fields, and configurations discovered dynamically
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"
		import { MCPLogger } from "./shared/mcp-logger.js"

		interface PlatformArtifactType {
		table: string
		name: string
		description: string
		primaryFields: string[]
		requiredFields: string[]
		deploymentFields: string[]
		}

		interface DynamicTableInfo {
		name: string
		label: string
		fields: Array<{
		name: string
		type: string
		label: string
		mandatory: boolean
		display: boolean
		}>
		}

		class ServiceNowPlatformDevelopmentMCP {
		private server: Server
		private client: ServiceNowClient
		private logger: MCPLogger
		private config: ReturnType<typeof mcpConfig.getConfig>
		private tableCache: Map<string, DynamicTableInfo> = new Map()

		constructor() {
		this.server = new Server(
		{
		name: "servicenow-platform-development",
		version: "1.0.0",
		},
		{
		capabilities: {
		tools: {},
		},
		},
		)

		this.client = new ServiceNowClient()
		this.logger = new MCPLogger("ServiceNowPlatformDevelopmentMCP")
		this.config = mcpConfig.getConfig()

		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_create_ui_page",
		description:
		"Creates UI pages with HTML, JavaScript, and CSS. Supports server-side processing scripts and client-side interactions.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "UI Page name" },
		title: { type: "string", description: "Page title" },
		html: { type: "string", description: "HTML content" },
		processingScript: { type: "string", description: "Server-side processing script" },
		clientScript: { type: "string", description: "Client-side script" },
		css: { type: "string", description: "CSS styles" },
		category: { type: "string", description: "Page category" },
		},
		required: ["name", "title", "html"],
		},
		},
		{
		name: "snow_create_script_include",
		description:
		"Creates reusable Script Includes for server-side logic. Supports client-callable scripts and API exposure.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Script Include name" },
		script: { type: "string", description: "JavaScript code" },
		description: { type: "string", description: "Description of functionality" },
		clientCallable: { type: "boolean", description: "Can be called from client" },
		apiName: { type: "string", description: "API name for external calls" },
		},
		required: ["name", "script"],
		},
		},
		{
		name: "snow_create_business_rule",
		description:
		"Creates business rules for automated data processing. Configurable timing (before/after/async) and conditional execution.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Business Rule name" },
		tableName: { type: "string", description: "Target table name or sys_id" },
		script: { type: "string", description: "JavaScript code" },
		when: { type: "string", description: "When to execute: before, after, async, display" },
		condition: { type: "string", description: "Condition script" },
		description: { type: "string", description: "Rule description" },
		},
		required: ["name", "tableName", "script", "when"],
		},
		},
		{
		name: "snow_create_client_script",
		description:
		"Creates client-side scripts for form interactions. Supports onLoad, onChange, onSubmit, and onCellEdit events.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Client Script name" },
		tableName: { type: "string", description: "Target table name or sys_id" },
		script: { type: "string", description: "JavaScript code" },
		type: { type: "string", description: "Script type: onLoad, onChange, onSubmit, onCellEdit" },
		fieldName: { type: "string", description: "Field name for onChange scripts" },
		condition: { type: "string", description: "Condition script" },
		description: { type: "string", description: "Script description" },
		},
		required: ["name", "tableName", "script", "type"],
		},
		},
		{
		name: "snow_create_ui_policy",
		description:
		"Creates UI policies to control field behavior and visibility. Supports conditional logic and reversible actions.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "UI Policy name" },
		tableName: { type: "string", description: "Target table name or sys_id" },
		condition: { type: "string", description: "Condition script" },
		description: { type: "string", description: "Policy description" },
		runScripts: { type: "boolean", description: "Run scripts when policy applies" },
		reverseWhenFalse: { type: "boolean", description: "Reverse actions when condition is false" },
		},
		required: ["name", "tableName", "condition"],
		},
		},
		{
		name: "snow_create_ui_action",
		description:
		"Creates custom buttons and menu items for forms and lists. Includes conditional visibility and action scripts.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "UI Action name" },
		tableName: { type: "string", description: "Target table name or sys_id" },
		script: { type: "string", description: "JavaScript code" },
		condition: { type: "string", description: "Condition script" },
		actionName: { type: "string", description: "Action name for forms" },
		formButton: { type: "boolean", description: "Show as form button" },
		listButton: { type: "boolean", description: "Show as list button" },
		description: { type: "string", description: "Action description" },
		},
		required: ["name", "tableName", "script"],
		},
		},
		{
		name: "snow_discover_platform_tables",
		description:
		"Discovers platform development tables categorized by type (UI, script, policy, security, system).",
		inputSchema: {
		type: "object",
		properties: {
		category: { type: "string", description: "Filter by category: ui, script, policy, action, all" },
		},
		},
		},
		{
		name: "snow_discover_table_fields",
		description:
		"Retrieves complete field information for any ServiceNow table including types, labels, and constraints.",
		inputSchema: {
		type: "object",
		properties: {
		tableName: { type: "string", description: "Table name to discover fields for" },
		},
		required: ["tableName"],
		},
		},
		{
		name: "snow_table_schema_discovery",
		description:
		"Performs comprehensive table schema analysis including structure, relationships, indexes, and inheritance hierarchy.",
		inputSchema: {
		type: "object",
		properties: {
		tableName: { type: "string", description: "Table name to analyze" },
		includeRelated: { type: "boolean", description: "Include related table information" },
		includeIndexes: { type: "boolean", description: "Include index information" },
		includeExtensions: { type: "boolean", description: "Include table extensions/hierarchy" },
		maxDepth: { type: "number", description: "Max depth for relationship discovery (default: 2)" },
		},
		required: ["tableName"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Start operation with token tracking
		this.logger.operationStart(name, args)

		// Ensure authentication
		const authResult = await mcpAuth.ensureAuthenticated()
		if (!authResult.success) {
		throw new McpError(ErrorCode.InternalError, authResult.error \|\| "Authentication required")
		}

		let result
		switch (name) {
		case "snow_create_ui_page":
		result = await this.createUIPage(args)
		break
		case "snow_create_script_include":
		result = await this.createScriptInclude(args)
		break
		case "snow_create_business_rule":
		result = await this.createBusinessRule(args)
		break
		case "snow_create_client_script":
		result = await this.createClientScript(args)
		break
		case "snow_create_ui_policy":
		result = await this.createUIPolicy(args)
		break
		case "snow_create_ui_action":
		result = await this.createUIAction(args)
		break
		case "snow_discover_platform_tables":
		result = await this.discoverPlatformTables(args)
		break
		case "snow_discover_table_fields":
		result = await this.discoverTableFields(args)
		break
		case "snow_table_schema_discovery":
		result = await this.discoverTableSchema(args)
		break
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		// Complete operation with token tracking
		result = this.logger.addTokenUsageToResponse(result)
		result = this.logger.addTokenUsageToResponse(result)
		this.logger.operationComplete(name, result)
		return result
		} catch (error) {
		this.logger.error(`Error in ${request.params.name}:`, error)
		throw error
		}
		})
		}

		/**
		* Dynamically discover all platform development tables
		*/
		private async discoverPlatformTables(args: any) {
		try {
		this.logger.info("Discovering platform development tables...")

		// Define table categories based on actual ServiceNow schema
		const tableQueries = [
		{ category: "ui", query: "nameSTARTSWITHsys_ui^ORnameSTARTSWITHsp_" },
		{ category: "script", query: "nameSTARTSWITHsys_script^ORnameSTARTSWITHsys_processor" },
		{ category: "policy", query: "nameSTARTSWITHsys_ui_policy^ORnameSTARTSWITHsys_ui_action" },
		{ category: "security", query: "nameSTARTSWITHsys_security^ORnameSTARTSWITHsys_user" },
		{ category: "system", query: "nameSTARTSWITHsys_dictionary^ORnameSTARTSWITHsys_choice" },
		]

		const category = args?.category \|\| "all"
		const discoveredTables: Array<{ category: string; tables: any[] }> = []

		for (const tableQuery of tableQueries) {
		if (category === "all" \|\| category === tableQuery.category) {
		this.logger.trackAPICall("SEARCH", "sys_db_object", 50)
		const tablesResponse = await this.client.searchRecords("sys_db_object", tableQuery.query, 50)

		if (tablesResponse.success && tablesResponse.data) {
		discoveredTables.push({
		category: tableQuery.category,
		tables: tablesResponse.data.result.map((table: any) => ({
		name: table.name,
		label: table.label,
		super_class: table.super_class,
		is_extendable: table.is_extendable,
		sys_id: table.sys_id,
		})),
		})
		}
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `🔍 Discovered Platform Development Tables:\n\n${discoveredTables
		.map(
		(cat) =>
		`${cat.category.toUpperCase()} Tables:\n${cat.tables
		.map((table) => `- ${table.name} (${table.label})`)
		.join("\n")}`,
		)
		.join("\n\n")}\n\n✨ All tables discovered dynamically from ServiceNow schema - no hardcoded values!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover platform tables:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover tables: ${error}`)
		}
		}

		/**
		* Dynamically discover table fields
		*/
		private async discoverTableFields(args: any) {
		try {
		const tableName = args.tableName \|\| args.table_name // Support both parameter names
		if (!tableName) {
		throw new Error("Table name is required (use tableName or table_name parameter)")
		}

		this.logger.info(`Discovering fields for table: ${tableName}`)

		// First, resolve table name to sys_id if needed
		const tableInfo = await this.getTableInfo(tableName)
		if (!tableInfo) {
		throw new Error(`Table not found: ${tableName}`)
		}

		// Get all fields for this table with CORRECT query syntax
		// ✅ FIX: Use proper ServiceNow query for dictionary
		this.logger.trackAPICall("SEARCH", "sys_dictionary", 500)
		const fieldsResponse = await this.client.searchRecords(
		"sys_dictionary",
		`name=${tableInfo.name}^element!=NULL^ORname=${tableInfo.name}^elementISNOTEMPTY`,
		500, // Increased limit for tables with many fields
		)

		if (!fieldsResponse.success \|\| !fieldsResponse.data) {
		throw new Error(`Failed to get fields for table: ${tableName}`)
		}

		// ✅ IMPROVED: Better field mapping with validation
		const fields = fieldsResponse.data.result
		.filter((field: any) => field.element && field.element !== "null" && field.element !== "NULL")
		.map((field: any) => ({
		name: field.element,
		type: field.internal_type \|\| field.data_type \|\| "string",
		label: field.column_label \|\| field.element,
		mandatory: field.mandatory === "true" \|\| field.mandatory === true,
		display: field.display === "true" \|\| field.display === true,
		max_length: parseInt(field.max_length) \|\| null,
		reference: field.reference \|\| null,
		choice: field.choice \|\| null,
		default_value: field.default_value \|\| null,
		read_only: field.read_only === "true" \|\| field.read_only === true,
		}))
		.sort((a: any, b: any) => {
		// Sort: sys_id first, then mandatory fields, then alphabetically
		if (a.name === "sys_id") return -1
		if (b.name === "sys_id") return 1
		if (a.mandatory && !b.mandatory) return -1
		if (!a.mandatory && b.mandatory) return 1
		return a.name.localeCompare(b.name)
		})

		// Cache the table info
		this.tableCache.set(tableName, {
		name: tableInfo.name,
		label: tableInfo.label,
		fields: fields,
		})

		// ✅ NEW: Group fields by category for better readability
		const mandatoryFields = fields.filter((f: any) => f.mandatory)
		const referenceFields = fields.filter((f: any) => f.reference)
		const regularFields = fields.filter((f: any) => !f.mandatory && !f.reference)

		return {
		content: [
		{
		type: "text",
		text:
		`📋 Fields for ${tableInfo.label} (${tableInfo.name}):\n\n` +
		(mandatoryFields.length > 0
		? `Required Fields:\n${mandatoryFields
		.map(
		(field: any) =>
		`- ${field.name} (${field.label})\n Type: ${field.type}${field.max_length ? ` [max: ${field.max_length}]` : ""}${field.default_value ? ` = '${field.default_value}'` : ""}`,
		)
		.join("\n")}\n\n`
		: "") +
		(referenceFields.length > 0
		? `Reference Fields:\n${referenceFields
		.map(
		(field: any) =>
		`- ${field.name} (${field.label})\n → ${field.reference}${field.mandatory ? " Required" : ""}`,
		)
		.join("\n")}\n\n`
		: "") +
		(regularFields.length > 0
		? `Other Fields:\n${regularFields
		.slice(0, 20)
		.map((field: any) => `- ${field.name} (${field.type}${field.read_only ? ", read-only" : ""})`)
		.join(
		"\n",
		)}${regularFields.length > 20 ? `\n ... and ${regularFields.length - 20} more fields` : ""}\n\n`
		: "") +
		`🔍 Total: ${fields.length} fields (${mandatoryFields.length} required, ${referenceFields.length} references)\n` +
		`✨ All fields discovered dynamically from ServiceNow!\n\n` +
		`💡 Tip: Use these field names in snow_query_table with fields parameter`,
		},
		],
		}
		} catch (error: any) {
		this.logger.error("Failed to discover table fields:", error)

		// ✅ IMPROVED: Better error messages
		if (error.message?.includes("Table not found")) {
		const tableName = args.tableName \|\| args.table_name
		throw new McpError(
		ErrorCode.InvalidParams,
		`Table '${tableName}' does not exist in ServiceNow. Please check the table name.`,
		)
		}

		if (error.response?.status === 401) {
		throw new McpError(ErrorCode.InvalidRequest, `Authentication required. Please run: snow-flow auth login`)
		}

		throw new McpError(
		ErrorCode.InternalError,
		`Failed to discover fields for ${args.tableName \|\| args.table_name}: ${error.message \|\| error}`,
		)
		}
		}

		/**
		* Get table information dynamically
		*/
		private async getTableInfo(tableName: string): Promise<{ name: string; label: string; sys_id: string } \| null> {
		try {
		this.logger.debug(`Looking up table info for: ${tableName}`)

		// First, check if this is a known standard table that may not appear in sys_db_object
		const standardTables: Record<string, { label: string }> = {
		incident: { label: "Incident" },
		problem: { label: "Problem" },
		change_request: { label: "Change Request" },
		sc_request: { label: "Request" },
		sc_req_item: { label: "Requested Item" },
		sc_task: { label: "Catalog Task" },
		task: { label: "Task" },
		}

		if (standardTables[tableName]) {
		this.logger.debug(`Using known standard table: ${tableName}`)
		return {
		name: tableName,
		label: standardTables[tableName].label,
		sys_id: `standard_table_${tableName}`, // Placeholder sys_id for standard tables
		}
		}

		// Try direct lookup first
		this.logger.trackAPICall("SEARCH", "sys_db_object", 1)
		const tableResponse = await this.client.searchRecords("sys_db_object", `name=${tableName}`, 1)

		if (tableResponse.success && tableResponse.data?.result?.length > 0) {
		const table = tableResponse.data.result[0]
		return {
		name: table.name,
		label: table.label,
		sys_id: table.sys_id,
		}
		}

		// Log the actual response for debugging
		this.logger.debug(`Table lookup response for ${tableName}: ${JSON.stringify(tableResponse)}`)

		// Try by sys_id
		this.logger.trackAPICall("SEARCH", "sys_db_object", 1)
		const tableByIdResponse = await this.client.searchRecords("sys_db_object", `sys_id=${tableName}`, 1)

		if (tableByIdResponse.success && tableByIdResponse.data?.result?.length > 0) {
		const table = tableByIdResponse.data.result[0]
		return {
		name: table.name,
		label: table.label,
		sys_id: table.sys_id,
		}
		}

		// Try partial match
		this.logger.trackAPICall("SEARCH", "sys_db_object", 5)
		const tableByPartialResponse = await this.client.searchRecords(
		"sys_db_object",
		`nameCONTAINS${tableName}^ORlabelCONTAINS${tableName}`,
		5,
		)

		if (tableByPartialResponse.success && tableByPartialResponse.data?.result?.length > 0) {
		const table = tableByPartialResponse.data.result[0]
		return {
		name: table.name,
		label: table.label,
		sys_id: table.sys_id,
		}
		}

		return null
		} catch (error) {
		this.logger.error(`Failed to get table info for ${tableName}:`, error)
		return null
		}
		}

		/**
		* Create UI Page with dynamic field discovery
		*/
		private async createUIPage(args: any) {
		try {
		this.logger.info("Creating UI Page...")

		// Get UI Page table structure dynamically
		const uiPageFields = await this.discoverRequiredFields("sys_ui_page")

		const uiPageData = {
		name: args.name,
		title: args.title,
		html: args.html,
		processing_script: args.processingScript \|\| "",
		client_script: args.clientScript \|\| "",
		css: args.css \|\| "",
		category: args.category \|\| "general",
		}

		// Ensure we have Update Set
		const updateSetResult = await this.client.ensureUpdateSet()

		this.logger.trackAPICall("CREATE", "sys_ui_page", 1)
		const response = await this.client.createRecord("sys_ui_page", uiPageData)

		if (!response.success) {
		throw new Error(`Failed to create UI Page: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ UI Page created successfully!\n\n📄 ${args.title} (${args.name})\n🆔 sys_id: ${response.data.sys_id}\n\n🔗 View in ServiceNow: Open UI Page editor\n\n✨ Created with dynamic field discovery - no hardcoded values!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create UI Page:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create UI Page: ${error}`)
		}
		}

		/**
		* Create Script Include with dynamic discovery
		*/
		private async createScriptInclude(args: any) {
		try {
		this.logger.info("Creating Script Include...")

		const scriptIncludeData = {
		name: args.name,
		script: args.script,
		description: args.description \|\| "",
		client_callable: args.clientCallable \|\| false,
		api_name: args.apiName \|\| args.name,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_script_include", 1)
		const response = await this.client.createRecord("sys_script_include", scriptIncludeData)

		if (!response.success) {
		throw new Error(`Failed to create Script Include: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Script Include created successfully!\n\n📜 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n🔧 Client Callable: ${args.clientCallable ? "Yes" : "No"}\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic field discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Script Include:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Script Include: ${error}`)
		}
		}

		/**
		* Create Business Rule with dynamic table discovery
		*/
		private async createBusinessRule(args: any) {
		try {
		this.logger.info("Creating Business Rule...")

		// Resolve table name dynamically
		const tableInfo = await this.getTableInfo(args.tableName)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.tableName}`)
		}

		const businessRuleData = {
		name: args.name,
		table: tableInfo.name,
		script: args.script,
		when: args.when,
		condition: args.condition \|\| "",
		description: args.description \|\| "",
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_script", 1)
		const response = await this.client.createRecord("sys_script", businessRuleData)

		if (!response.success) {
		throw new Error(`Failed to create Business Rule: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Business Rule created successfully!\n\n📋 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📊 Table: ${tableInfo.label} (${tableInfo.name})\n⏰ When: ${args.when}\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic table discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Business Rule:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Business Rule: ${error}`)
		}
		}

		/**
		* Create Client Script with dynamic discovery
		*/
		private async createClientScript(args: any) {
		try {
		this.logger.info("Creating Client Script...")

		const tableInfo = await this.getTableInfo(args.tableName)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.tableName}`)
		}

		const clientScriptData = {
		name: args.name,
		table: tableInfo.name,
		script: args.script,
		type: args.type,
		field: args.fieldName \|\| "",
		condition: args.condition \|\| "",
		description: args.description \|\| "",
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_script_client", 1)
		const response = await this.client.createRecord("sys_script_client", clientScriptData)

		if (!response.success) {
		throw new Error(`Failed to create Client Script: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Client Script created successfully!\n\n📜 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📊 Table: ${tableInfo.label} (${tableInfo.name})\n🔧 Type: ${args.type}\n${args.fieldName ? `🏷️ Field: ${args.fieldName}\n` : ""}\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic table discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Client Script:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Client Script: ${error}`)
		}
		}

		/**
		* Create UI Policy with dynamic discovery
		*/
		private async createUIPolicy(args: any) {
		try {
		this.logger.info("Creating UI Policy...")

		const tableInfo = await this.getTableInfo(args.tableName)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.tableName}`)
		}

		const uiPolicyData = {
		name: args.name,
		table: tableInfo.name,
		conditions: args.condition,
		description: args.description \|\| "",
		run_scripts: args.runScripts \|\| false,
		reverse_if_false: args.reverseWhenFalse \|\| false,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_ui_policy", 1)
		const response = await this.client.createRecord("sys_ui_policy", uiPolicyData)

		if (!response.success) {
		throw new Error(`Failed to create UI Policy: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ UI Policy created successfully!\n\n📋 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📊 Table: ${tableInfo.label} (${tableInfo.name})\n🔧 Run Scripts: ${args.runScripts ? "Yes" : "No"}\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic table discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create UI Policy:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create UI Policy: ${error}`)
		}
		}

		/**
		* Create UI Action with dynamic discovery
		*/
		private async createUIAction(args: any) {
		try {
		this.logger.info("Creating UI Action...")

		const tableInfo = await this.getTableInfo(args.tableName)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.tableName}`)
		}

		const uiActionData = {
		name: args.name,
		table: tableInfo.name,
		script: args.script,
		condition: args.condition \|\| "",
		action_name: args.actionName \|\| args.name,
		form_button: args.formButton \|\| false,
		list_button: args.listButton \|\| false,
		description: args.description \|\| "",
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_ui_action", 1)
		const response = await this.client.createRecord("sys_ui_action", uiActionData)

		if (!response.success) {
		throw new Error(`Failed to create UI Action: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ UI Action created successfully!\n\n🎯 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📊 Table: ${tableInfo.label} (${tableInfo.name})\n🔘 Form Button: ${args.formButton ? "Yes" : "No"}\n📝 List Button: ${args.listButton ? "Yes" : "No"}\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic table discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create UI Action:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create UI Action: ${error}`)
		}
		}

		/**
		* Discover required fields for a table dynamically
		*/
		private async discoverRequiredFields(tableName: string): Promise<string[]> {
		try {
		this.logger.trackAPICall("SEARCH", "sys_dictionary", 50)
		const fieldsResponse = await this.client.searchRecords(
		"sys_dictionary",
		`nameSTARTSWITH${tableName}^element!=NULL^mandatory=true`,
		50,
		)

		if (fieldsResponse.success && fieldsResponse.data) {
		return fieldsResponse.data.result.map((field: any) => field.element)
		}

		return []
		} catch (error) {
		this.logger.error(`Failed to discover required fields for ${tableName}:`, error)
		return []
		}
		}

		/**
		* Comprehensive table schema discovery
		*/
		private async discoverTableSchema(args: any) {
		try {
		const { tableName, includeRelated = true, includeIndexes = true, includeExtensions = true, maxDepth = 2 } = args
		this.logger.info(`Discovering comprehensive schema for table: ${tableName}`)

		// Validate authentication
		if (!this.client) {
		throw new Error("ServiceNow client not initialized")
		}

		// Get table information
		const tableInfo = await this.getTableInfo(tableName)
		if (!tableInfo) {
		throw new Error(`Table not found: ${tableName}. Searched in sys_db_object table.`)
		}

		this.logger.debug(`Found table info: ${JSON.stringify(tableInfo)}`)

		// Get detailed table metadata
		this.logger.debug(`Attempting to fetch table details for sys_id: ${tableInfo.sys_id}`)

		// Check if this is a standard table with placeholder sys_id
		const isStandardTable = tableInfo.sys_id.startsWith("standard_table_")
		let tableDetailsResponse: any = { success: false }

		if (!isStandardTable) {
		this.logger.trackAPICall("GET", "sys_db_object", 1)
		tableDetailsResponse = await this.client.getRecord("sys_db_object", tableInfo.sys_id)
		}

		// Declare the variable once with proper type
		let tableDetails: any

		if (!tableDetailsResponse.success \|\| isStandardTable) {
		const errorMessage =
		tableDetailsResponse.error \|\|
		JSON.stringify(tableDetailsResponse) \|\|
		"Unknown error occurred while fetching table details"
		this.logger.error(`Table details fetch failed for ${tableInfo.sys_id}:`, tableDetailsResponse)

		// Fallback: try using basic table info if detailed fetch fails
		this.logger.warn(`Falling back to basic table info for ${tableInfo.name}`)
		tableDetails = {
		name: tableInfo.name,
		label: tableInfo.label,
		sys_id: tableInfo.sys_id,
		is_extendable: "unknown",
		access: "unknown",
		sys_created_on: "unknown",
		sys_updated_on: "unknown",
		row_count: "unknown",
		super_class: null,
		extension_model: "unknown",
		sys_scope: null,
		}
		} else {
		tableDetails = tableDetailsResponse.data
		}

		// Get all fields with detailed information
		this.logger.trackAPICall("SEARCH", "sys_dictionary", 200)
		const fieldsResponse = await this.client.searchRecords(
		"sys_dictionary",
		`name=${tableInfo.name}^element!=NULL`,
		200,
		)

		if (!fieldsResponse.success \|\| !fieldsResponse.data) {
		const errorMessage =
		fieldsResponse.error \|\| "No data returned from fields query" \|\| JSON.stringify(fieldsResponse)
		this.logger.error(`Fields fetch failed for ${tableInfo.name}:`, fieldsResponse)
		throw new Error(`Failed to get fields for table ${tableName}: ${errorMessage}`)
		}

		const fields = fieldsResponse.data.result.map((field: any) => ({
		name: field.element,
		label: field.column_label,
		type: field.internal_type,
		dataType: field.internal_type,
		maxLength: field.max_length,
		mandatory: field.mandatory === "true",
		readOnly: field.read_only === "true",
		display: field.display === "true",
		active: field.active === "true",
		array: field.array === "true",
		reference: field.reference,
		referenceQual: field.reference_qual,
		defaultValue: field.default_value,
		choice: field.choice,
		calculated: field.virtual === "true",
		attributes: field.attributes,
		comments: field.comments,
		}))

		// Analyze relationships
		const relationships = fields
		.filter((field: any) => field.reference)
		.map((field: any) => ({
		field: field.name,
		targetTable: field.reference,
		label: field.label,
		referenceQual: field.referenceQual,
		}))

		// Get table hierarchy if requested
		let hierarchy: any = null
		if (includeExtensions) {
		hierarchy = {
		extends: tableDetails.super_class?.display_value \|\| null,
		extendsTable: tableDetails.super_class?.value \|\| null,
		isExtendable: tableDetails.is_extendable === "true",
		extensionModel: tableDetails.extension_model,
		}

		// Find tables that extend this one
		this.logger.trackAPICall("SEARCH", "sys_db_object", 50)
		const childTablesResponse = await this.client.searchRecords(
		"sys_db_object",
		`super_class=${tableInfo.sys_id}`,
		50,
		)

		if (childTablesResponse.success && childTablesResponse.data) {
		hierarchy.extendedBy = childTablesResponse.data.result.map((child: any) => ({
		name: child.name,
		label: child.label,
		sys_id: child.sys_id,
		}))
		}
		}

		// Get indexes if requested
		let indexes: any[] = []
		if (includeIndexes) {
		this.logger.trackAPICall("SEARCH", "sys_db_index", 50)
		const indexResponse = await this.client.searchRecords("sys_db_index", `table=${tableInfo.sys_id}`, 50)

		if (indexResponse.success && indexResponse.data) {
		indexes = indexResponse.data.result.map((index: any) => ({
		name: index.name,
		unique: index.unique === "true",
		clustered: index.clustered === "true",
		fields: index.fields,
		}))
		}
		}

		// Get related tables if requested
		const relatedTables: any[] = []
		if (includeRelated && relationships.length > 0) {
		const uniqueRelatedTables = [...new Set(relationships.map((rel: any) => rel.targetTable))]

		for (const relTable of uniqueRelatedTables.slice(0, 10)) {
		// Limit to prevent too many queries
		const relTableInfo = await this.getTableInfo(String(relTable))
		if (relTableInfo) {
		relatedTables.push({
		name: relTableInfo.name,
		label: relTableInfo.label,
		referencedBy: relationships
		.filter((rel: any) => rel.targetTable === relTable)
		.map((rel: any) => rel.field),
		})
		}
		}
		}

		// Compile comprehensive schema information
		const schema = {
		table: {
		name: tableInfo.name,
		label: tableInfo.label,
		sys_id: tableInfo.sys_id,
		isExtendable: tableDetails.is_extendable === "true",
		isSystemTable: tableDetails.sys_scope?.display_value === "global",
		created: tableDetails.sys_created_on,
		updated: tableDetails.sys_updated_on,
		recordCount: tableDetails.row_count \|\| "Unknown",
		accessControls: tableDetails.access \|\| "Not specified",
		},
		hierarchy,
		fields: {
		total: fields.length,
		mandatory: fields.filter((f: any) => f.mandatory).length,
		references: fields.filter((f: any) => f.reference).length,
		calculated: fields.filter((f: any) => f.calculated).length,
		list: fields,
		},
		relationships: {
		total: relationships.length,
		list: relationships,
		relatedTables,
		},
		indexes: {
		total: indexes.length,
		list: indexes,
		},
		}

		return {
		content: [
		{
		type: "text",
		text:
		`🔍 Comprehensive Schema Discovery for ${tableInfo.label} (${tableInfo.name})\n\n` +
		`📊 Table Overview:\n` +
		`- Label: ${schema.table.label}\n` +
		`- Name: ${schema.table.name}\n` +
		`- System ID: ${schema.table.sys_id}\n` +
		`- Extendable: ${schema.table.isExtendable ? "Yes" : "No"}\n` +
		`- System Table: ${schema.table.isSystemTable ? "Yes" : "No"}\n` +
		`- Record Count: ${schema.table.recordCount}\n\n` +
		(hierarchy
		? `🔗 Table Hierarchy:\n` +
		`- Extends: ${hierarchy.extends \|\| "None"}\n` +
		`- Extended By: ${hierarchy.extendedBy?.length \|\| 0} tables\n` +
		(hierarchy.extendedBy?.length > 0
		? hierarchy.extendedBy.map((t: any) => ` - ${t.label} (${t.name})`).join("\n") + "\n"
		: "") +
		"\n"
		: "") +
		`📋 Fields Summary:\n` +
		`- Total Fields: ${schema.fields.total}\n` +
		`- Mandatory Fields: ${schema.fields.mandatory}\n` +
		`- Reference Fields: ${schema.fields.references}\n` +
		`- Calculated Fields: ${schema.fields.calculated}\n\n` +
		`🔗 Relationships:\n` +
		`- Total References: ${schema.relationships.total}\n` +
		(schema.relationships.list.length > 0
		? schema.relationships.list
		.map((rel: any) => ` - ${rel.field} → ${rel.targetTable} (${rel.label})`)
		.join("\n") + "\n"
		: "") +
		"\n" +
		(indexes.length > 0
		? `🔑 Indexes:\n` +
		indexes
		.map((idx: any) => `- ${idx.name} (${idx.unique ? "Unique" : "Non-unique"}) on: ${idx.fields}`)
		.join("\n") +
		"\n\n"
		: "") +
		`\n📝 Full Schema Details:\n\`\`\`json\n${JSON.stringify(schema, null, 2)}\n\`\`\`\n\n` +
		`✨ All schema information discovered dynamically from ServiceNow!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover table schema:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover table schema: ${error}`)
		}
		}

		async run() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)
		this.logger.info("ServiceNow Platform Development MCP Server running on stdio")
		}
		}

		const server = new ServiceNowPlatformDevelopmentMCP()
		server.run().catch(console.error)

-366

src/servicenow/servicenow-progressive-indexer.ts

		#!/usr/bin/env node
		/**
		* Progressive Indexing Strategy for ServiceNow Artifacts
		* Prevents overwhelming the system with too much data
		*/

		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { Logger } from "../utils/logger.js"

		export interface IndexingStrategy {
		mode: "lazy" \| "eager" \| "progressive" \| "context-aware"
		maxInitialArtifacts: number
		relevanceThreshold: number
		contextWindow: number
		}

		export interface ArtifactRelevance {
		artifact_id: string
		relevance_score: number
		last_accessed: Date
		access_count: number
		related_to_current_task: boolean
		}

		export class ServiceNowProgressiveIndexer {
		private logger: Logger
		private client: ServiceNowClient
		private indexedArtifacts: Set<string> = new Set()
		private relevanceMap: Map<string, ArtifactRelevance> = new Map()
		private currentContext: string = ""

		constructor() {
		this.logger = new Logger("ProgressiveIndexer")
		this.client = new ServiceNowClient()
		}

		/**
		* Smart indexing based on current task context
		*/
		async indexForContext(context: string, userInstruction: string): Promise<any> {
		this.currentContext = context
		this.logger.info("Progressive indexing for context", { context, instruction: userInstruction })

		// Step 1: Extract key concepts from instruction
		const concepts = this.extractConcepts(userInstruction)

		// Step 2: Find most relevant artifacts (not everything!)
		const relevantArtifacts = await this.findRelevantArtifacts(concepts, {
		limit: 10, // Start with just 10 most relevant
		types: this.determineRelevantTypes(userInstruction),
		})

		// Step 3: Index only what's needed
		const indexingPlan = {
		immediate: relevantArtifacts.filter((a) => a.relevance > 0.8),
		lazy: relevantArtifacts.filter((a) => a.relevance > 0.5 && a.relevance <= 0.8),
		skip: relevantArtifacts.filter((a) => a.relevance <= 0.5),
		}

		// Step 4: Progressive indexing
		await this.indexArtifacts(indexingPlan.immediate, "immediate")

		// Lazy load others as needed
		this.scheduleLazyIndexing(indexingPlan.lazy)

		return {
		indexed_immediately: indexingPlan.immediate.length,
		scheduled_for_lazy: indexingPlan.lazy.length,
		skipped: indexingPlan.skip.length,
		strategy: this.getIndexingStrategy(concepts),
		}
		}

		/**
		* Extract key concepts from natural language
		*/
		private extractConcepts(instruction: string): string[] {
		const concepts: string[] = []
		const lower = instruction.toLowerCase()

		// Common ServiceNow concepts
		const conceptMap = {
		incident: ["incident", "ticket", "issue", "problem"],
		widget: ["widget", "ui", "dashboard", "interface", "component"],
		flow: ["flow", "workflow", "automation", "process"],
		approval: ["approval", "approve", "goedkeuring", "review"],
		script: ["script", "code", "function", "api"],
		table: ["table", "data", "record", "database"],
		integration: ["integration", "connect", "api", "external"],
		notification: ["notification", "email", "alert", "message"],
		}

		for (const [concept, keywords] of Object.entries(conceptMap)) {
		if (keywords.some((keyword) => lower.includes(keyword))) {
		concepts.push(concept)
		}
		}

		return concepts
		}

		/**
		* Determine which artifact types are relevant
		*/
		private determineRelevantTypes(instruction: string): string[] {
		const types: string[] = []
		const lower = instruction.toLowerCase()

		if (lower.includes("widget") \|\| lower.includes("dashboard") \|\| lower.includes("ui")) {
		types.push("widget", "client_script", "ui_script")
		}

		if (lower.includes("flow") \|\| lower.includes("workflow") \|\| lower.includes("automation")) {
		types.push("flow", "script_include", "business_rule")
		}

		if (lower.includes("script") \|\| lower.includes("api") \|\| lower.includes("function")) {
		types.push("script_include", "business_rule")
		}

		if (lower.includes("table") \|\| lower.includes("data") \|\| lower.includes("record")) {
		types.push("table", "business_rule")
		}

		// Default to common types if nothing specific found
		if (types.length === 0) {
		types.push("widget", "flow", "script_include")
		}

		return [...new Set(types)] // Remove duplicates
		}

		/**
		* Find artifacts relevant to concepts
		*/
		private async findRelevantArtifacts(concepts: string[], options: any): Promise<any[]> {
		const artifacts: any[] = []

		// Build smart query based on concepts
		const searchQueries = concepts.map((concept) => {
		switch (concept) {
		case "incident":
		return "nameLIKEincident^ORdescriptionLIKEincident^ORtableLIKEincident"
		case "widget":
		return "sys_class_name=sp_widget^ORcategoryLIKEdashboard"
		case "flow":
		return "sys_class_name=sys_hub_flow^ORnameLIKEflow^ORnameLIKEworkflow"
		case "approval":
		return "nameLIKEapproval^ORdescriptionLIKEapproval^ORscriptLIKEapproval"
		default:
		return `nameLIKE${concept}^ORdescriptionLIKE${concept}`
		}
		})

		// Search each type with relevance scoring
		for (const type of options.types) {
		const results = await this.searchArtifactsByType(type, searchQueries, options.limit)

		// Score each result
		results.forEach((artifact: any) => {
		artifact.relevance = this.calculateRelevance(artifact, concepts)
		artifacts.push(artifact)
		})
		}

		// Sort by relevance and limit
		return artifacts.sort((a, b) => b.relevance - a.relevance).slice(0, options.limit)
		}

		/**
		* Calculate relevance score
		*/
		private calculateRelevance(artifact: any, concepts: string[]): number {
		let score = 0
		const name = (artifact.name \|\| "").toLowerCase()
		const description = (artifact.description \|\| "").toLowerCase()
		const content = (artifact.script \|\| artifact.template \|\| "").toLowerCase()

		// Name matches are most important
		concepts.forEach((concept) => {
		if (name.includes(concept)) score += 0.4
		if (description.includes(concept)) score += 0.2
		if (content.includes(concept)) score += 0.1
		})

		// Recent artifacts are more relevant
		const lastUpdated = new Date(artifact.sys_updated_on \|\| artifact.sys_created_on)
		const daysSinceUpdate = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24)
		if (daysSinceUpdate < 7) score += 0.2
		else if (daysSinceUpdate < 30) score += 0.1

		// Popular artifacts (based on past usage)
		const relevance = this.relevanceMap.get(artifact.sys_id)
		if (relevance) {
		score += Math.min(relevance.access_count * 0.05, 0.2)
		}

		return Math.min(score, 1.0)
		}

		/**
		* Search artifacts by type
		*/
		private async searchArtifactsByType(type: string, queries: string[], limit: number): Promise<any[]> {
		const tableMap: Record<string, string> = {
		widget: "sp_widget",
		flow: "sys_hub_flow",
		script_include: "sys_script_include",
		business_rule: "sys_script",
		table: "sys_db_object",
		client_script: "sys_ui_script",
		ui_script: "sys_ui_script",
		}

		const table = tableMap[type]
		if (!table) return []

		try {
		const query = queries.join("^OR")
		const response = await this.client.searchRecords(table, query, limit)
		return response.success ? response.data.result : []
		} catch (error) {
		this.logger.error(`Failed to search ${type}`, error)
		return []
		}
		}

		/**
		* Index artifacts immediately
		*/
		private async indexArtifacts(artifacts: any[], priority: string): Promise<void> {
		this.logger.info(`Indexing ${artifacts.length} artifacts with ${priority} priority`)

		for (const artifact of artifacts) {
		if (!this.indexedArtifacts.has(artifact.sys_id)) {
		// Index in Neo4j
		await this.indexInGraph(artifact)

		// Track indexing
		this.indexedArtifacts.add(artifact.sys_id)
		this.updateRelevance(artifact.sys_id, artifact.relevance)
		}
		}
		}

		/**
		* Schedule lazy indexing
		*/
		private scheduleLazyIndexing(artifacts: any[]): void {
		// Index these when Claude actually needs them
		artifacts.forEach((artifact) => {
		this.relevanceMap.set(artifact.sys_id, {
		artifact_id: artifact.sys_id,
		relevance_score: artifact.relevance,
		last_accessed: new Date(),
		access_count: 0,
		related_to_current_task: true,
		})
		})
		}

		/**
		* Index artifact in Neo4j graph
		*/
		private async indexInGraph(artifact: any): Promise<void> {
		// This would call the Neo4j MCP
		this.logger.info(`Indexing ${artifact.name} in graph database`)
		// Implementation would use snow_graph_index_artifact
		}

		/**
		* Update relevance tracking
		*/
		private updateRelevance(artifactId: string, score: number): void {
		const existing = this.relevanceMap.get(artifactId)
		if (existing) {
		existing.relevance_score = score
		existing.last_accessed = new Date()
		existing.access_count++
		} else {
		this.relevanceMap.set(artifactId, {
		artifact_id: artifactId,
		relevance_score: score,
		last_accessed: new Date(),
		access_count: 1,
		related_to_current_task: true,
		})
		}
		}

		/**
		* Get indexing strategy based on context
		*/
		private getIndexingStrategy(concepts: string[]): IndexingStrategy {
		// Simple tasks need less indexing
		if (concepts.length <= 2) {
		return {
		mode: "lazy",
		maxInitialArtifacts: 5,
		relevanceThreshold: 0.8,
		contextWindow: 10,
		}
		}

		// Complex tasks need more context
		if (concepts.length > 5) {
		return {
		mode: "eager",
		maxInitialArtifacts: 20,
		relevanceThreshold: 0.5,
		contextWindow: 50,
		}
		}

		// Default progressive strategy
		return {
		mode: "progressive",
		maxInitialArtifacts: 10,
		relevanceThreshold: 0.7,
		contextWindow: 25,
		}
		}

		/**
		* Clean up old irrelevant artifacts
		*/
		async cleanupIrrelevantArtifacts(): Promise<number> {
		const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
		let cleaned = 0

		for (const [id, relevance] of this.relevanceMap.entries()) {
		if (relevance.last_accessed < thirtyDaysAgo && relevance.access_count < 2 && relevance.relevance_score < 0.5) {
		this.relevanceMap.delete(id)
		this.indexedArtifacts.delete(id)
		cleaned++
		}
		}

		this.logger.info(`Cleaned up ${cleaned} irrelevant artifacts`)
		return cleaned
		}

		/**
		* Get indexing statistics
		*/
		getIndexingStats(): any {
		const stats = {
		total_indexed: this.indexedArtifacts.size,
		total_tracked: this.relevanceMap.size,
		current_context: this.currentContext,
		relevance_distribution: {
		high: 0,
		medium: 0,
		low: 0,
		},
		}

		for (const relevance of this.relevanceMap.values()) {
		if (relevance.relevance_score > 0.8) stats.relevance_distribution.high++
		else if (relevance.relevance_score > 0.5) stats.relevance_distribution.medium++
		else stats.relevance_distribution.low++
		}

		return stats
		}
		}

-1485

src/servicenow/servicenow-reporting-analytics-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Reporting & Analytics MCP Server
		* Handles reports, dashboards, and analytics operations
		* NO HARDCODED VALUES - All reporting configurations discovered dynamically
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"
		import { MCPLogger } from "./shared/mcp-logger.js"
		import { validateRealData, generateDataReport } from "../utils/anti-mock-data-validator.js"

		interface ReportDefinition {
		name: string
		table: string
		conditions: string
		fields: string[]
		aggregations: string[]
		groupBy: string[]
		}

		interface DashboardWidget {
		name: string
		type: string
		dataSource: string
		configuration: any
		layout: any
		}

		class ServiceNowReportingAnalyticsMCP {
		private server: Server
		private client: ServiceNowClient
		private logger: MCPLogger
		private config: ReturnType<typeof mcpConfig.getConfig>

		constructor() {
		this.server = new Server(
		{
		name: "servicenow-reporting-analytics",
		version: "1.0.0",
		},
		{
		capabilities: {
		tools: {},
		},
		},
		)

		this.client = new ServiceNowClient()
		this.logger = new MCPLogger("ServiceNowReportingAnalyticsMCP")
		this.config = mcpConfig.getConfig()

		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_create_report",
		description:
		"🔥 REAL DATA ONLY: Creates reports with filtering, grouping, and aggregation using LIVE ServiceNow data. NO mock/demo data used. All data pulled directly from your ServiceNow instance tables.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Report name" },
		table: { type: "string", description: "Source table" },
		description: { type: "string", description: "Report description" },
		conditions: { type: "string", description: "Report conditions/filters" },
		fields: { type: "array", description: "Fields to include in report" },
		groupBy: { type: "array", description: "Group by fields" },
		aggregations: { type: "array", description: "Aggregation functions" },
		sortBy: { type: "string", description: "Sort field" },
		sortOrder: { type: "string", description: "Sort order (asc/desc)" },
		schedule: { type: "string", description: "Report schedule" },
		format: { type: "string", description: "Output format (PDF, Excel, CSV)" },
		},
		required: ["name", "table", "fields"],
		},
		},
		{
		name: "snow_create_dashboard",
		description:
		"🔥 REAL DATA ONLY: Creates interactive dashboards using LIVE ServiceNow data. All widgets populated with actual data from your instance. NO mock/demo data used.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Dashboard name" },
		description: { type: "string", description: "Dashboard description" },
		layout: { type: "string", description: "Dashboard layout (grid, tabs, accordion)" },
		widgets: { type: "array", description: "Dashboard widgets configuration" },
		permissions: { type: "array", description: "User/role permissions" },
		refreshInterval: { type: "number", description: "Auto-refresh interval in minutes" },
		public: { type: "boolean", description: "Public dashboard" },
		},
		required: ["name", "widgets"],
		},
		},
		{
		name: "snow_create_kpi",
		description:
		"🔥 REAL DATA ONLY: Creates KPIs calculated from LIVE ServiceNow data. All metrics based on actual records in your instance. NO mock/demo data used.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "KPI name" },
		description: { type: "string", description: "KPI description" },
		table: { type: "string", description: "Source table" },
		metric: { type: "string", description: "Metric to measure" },
		aggregation: { type: "string", description: "Aggregation function (count, sum, avg, max, min)" },
		conditions: { type: "string", description: "KPI conditions/filters" },
		target: { type: "number", description: "Target value" },
		threshold: { type: "object", description: "Threshold configuration" },
		unit: { type: "string", description: "Unit of measurement" },
		frequency: { type: "string", description: "Update frequency" },
		},
		required: ["name", "table", "metric", "aggregation"],
		},
		},
		{
		name: "snow_create_data_visualization",
		description:
		"🔥 REAL DATA ONLY: Creates charts and visualizations using LIVE ServiceNow data. All graphs populated with actual data from your instance tables. NO mock/demo data used.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Visualization name" },
		type: { type: "string", description: "Chart type (bar, line, pie, scatter, etc.)" },
		dataSource: { type: "string", description: "Data source (table or report)" },
		xAxis: { type: "string", description: "X-axis field" },
		yAxis: { type: "string", description: "Y-axis field" },
		series: { type: "array", description: "Data series configuration" },
		filters: { type: "array", description: "Chart filters" },
		colors: { type: "array", description: "Color palette" },
		interactive: { type: "boolean", description: "Interactive chart" },
		},
		required: ["name", "type", "dataSource"],
		},
		},
		{
		name: "snow_create_performance_analytics",
		description:
		"🔥 REAL DATA ONLY: Creates performance analytics using LIVE ServiceNow data. All metrics calculated from actual records in your instance. NO mock/demo data used.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Analytics name" },
		category: { type: "string", description: "Analytics category" },
		dataSource: { type: "string", description: "Data source table" },
		metrics: { type: "array", description: "Performance metrics to track" },
		dimensions: { type: "array", description: "Analysis dimensions" },
		timeframe: { type: "string", description: "Time period for _analysis" },
		benchmarks: { type: "array", description: "Performance benchmarks" },
		alerts: { type: "array", description: "Alert configurations" },
		},
		required: ["name", "dataSource", "metrics"],
		},
		},
		{
		name: "snow_create_scheduled_report",
		description: "Creates scheduled reports with automated email delivery in multiple formats.",
		inputSchema: {
		type: "object",
		properties: {
		reportName: { type: "string", description: "Source report name" },
		schedule: { type: "string", description: "Schedule frequency" },
		recipients: { type: "array", description: "Email recipients" },
		format: { type: "string", description: "Report format (PDF, Excel, CSV)" },
		conditions: { type: "string", description: "Additional conditions" },
		subject: { type: "string", description: "Email subject" },
		message: { type: "string", description: "Email message" },
		},
		required: ["reportName", "schedule", "recipients"],
		},
		},
		{
		name: "snow_discover_reporting_tables",
		description: "Discovers tables available for reporting with filtering by category and data availability.",
		inputSchema: {
		type: "object",
		properties: {
		category: { type: "string", description: "Table category filter" },
		hasData: { type: "boolean", description: "Only tables with data" },
		},
		},
		},
		{
		name: "snow_discover_report_fields",
		description: "Retrieves reportable fields from tables with type filtering and metadata.",
		inputSchema: {
		type: "object",
		properties: {
		table: { type: "string", description: "Table name to analyze" },
		fieldType: { type: "string", description: "Filter by field type" },
		},
		required: ["table"],
		},
		},
		{
		name: "snow_analyze_data_quality",
		description: "Analyzes data quality including completeness, consistency, and accuracy metrics.",
		inputSchema: {
		type: "object",
		properties: {
		table: { type: "string", description: "Table to analyze" },
		fields: { type: "array", description: "Specific fields to analyze" },
		checkCompleteness: { type: "boolean", description: "Check data completeness" },
		checkConsistency: { type: "boolean", description: "Check data consistency" },
		checkAccuracy: { type: "boolean", description: "Check data accuracy" },
		},
		required: ["table"],
		},
		},
		{
		name: "snow_generate_insights",
		description:
		"Generates analytical insights including trends, patterns, anomalies, and actionable recommendations.",
		inputSchema: {
		type: "object",
		properties: {
		table: { type: "string", description: "Table to analyze" },
		analysisType: { type: "string", description: "Analysis type (trends, patterns, anomalies)" },
		timeframe: { type: "string", description: "Time period for _analysis" },
		generateRecommendations: { type: "boolean", description: "Generate recommendations" },
		},
		required: ["table"],
		},
		},
		{
		name: "snow_export_report_data",
		description: "Exports report data to CSV, Excel, JSON, or XML formats with configurable row limits.",
		inputSchema: {
		type: "object",
		properties: {
		reportName: { type: "string", description: "Report name to export" },
		format: { type: "string", description: "Export format (CSV, Excel, JSON, XML)" },
		includeHeaders: { type: "boolean", description: "Include column headers" },
		maxRows: { type: "number", description: "Maximum rows to export" },
		},
		required: ["reportName", "format"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Start operation with token tracking
		this.logger.operationStart(name, args)

		const authResult = await mcpAuth.ensureAuthenticated()
		if (!authResult.success) {
		throw new McpError(ErrorCode.InternalError, authResult.error \|\| "Authentication required")
		}

		let result
		switch (name) {
		case "snow_create_report":
		result = await this.createReport(args)
		break
		case "snow_create_dashboard":
		result = await this.createDashboard(args)
		break
		case "snow_create_kpi":
		result = await this.createKPI(args)
		break
		case "snow_create_data_visualization":
		result = await this.createDataVisualization(args)
		break
		case "snow_create_performance_analytics":
		result = await this.createPerformanceAnalytics(args)
		break
		case "snow_create_scheduled_report":
		result = await this.createScheduledReport(args)
		break
		case "snow_discover_reporting_tables":
		result = await this.discoverReportingTables(args)
		break
		case "snow_discover_report_fields":
		result = await this.discoverReportFields(args)
		break
		case "snow_analyze_data_quality":
		result = await this.analyzeDataQuality(args)
		break
		case "snow_generate_insights":
		result = await this.generateInsights(args)
		break
		case "snow_export_report_data":
		result = await this.exportReportData(args)
		break
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		// Complete operation with token tracking
		result = this.logger.addTokenUsageToResponse(result)
		result = this.logger.addTokenUsageToResponse(result)
		this.logger.operationComplete(name, result)
		return result
		} catch (error) {
		this.logger.error(`Error in ${request.params.name}:`, error)
		throw error
		}
		})
		}

		/**
		* Create Report with dynamic discovery
		*/
		private async createReport(args: any) {
		try {
		this.logger.info("Creating Report...")

		// Validate table and discover fields
		const tableInfo = await this.getTableInfo(args.table)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.table}`)
		}

		const availableFields = await this.getTableFields(args.table)
		const aggregationFunctions = await this.getAggregationFunctions()

		// Build field list string for ServiceNow
		const fieldList =
		args.fields?.join(",") \|\| availableFields.slice(0, 10).join(",") \|\| "sys_id,sys_created_on,sys_updated_on"

		// Build proper aggregation configuration
		const aggregateConfig =
		args.aggregations?.length > 0
		? {
		aggregate: true,
		aggregation_source: args.aggregations[0]?.field \|\| "",
		aggregate_type: args.aggregations[0]?.type \|\| "COUNT",
		}
		: {
		aggregate: false,
		}

		const reportData = {
		title: args.name,
		table: tableInfo.name,
		description: args.description \|\| "",
		filter: args.conditions \|\| "",
		field_list: fieldList,
		group_by: args.groupBy?.join(",") \|\| "",
		order_by: args.sortBy \|\| "sys_created_on",
		order_direction: args.sortOrder === "desc" ? "DESC" : "ASC",
		type: args.aggregations?.length > 0 ? "bar" : "list",
		chart_type: args.aggregations?.length > 0 ? "bar" : "none",
		is_scheduled: args.schedule ? true : false,
		schedule_type: args.schedule \|\| "daily",
		export_format: args.format?.toLowerCase() \|\| "pdf",
		is_published: true,
		roles: "",
		active: true,
		...aggregateConfig,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		this.logger.trackAPICall("CREATE", "sys_report", 1)
		const response = await this.client.createRecord("sys_report", reportData)

		if (!response.success) {
		throw new Error(`Failed to create Report: ${response.error}`)
		}

		// Create a shareable link for the report
		const reportUrl = `${process.env.SNOW_INSTANCE}/sys_report_template.do?jvar_report_id=${response.data.sys_id}`

		return {
		content: [
		{
		type: "text",
		text: `✅ Report created successfully!\n\n📊 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📋 Table: ${tableInfo.label} (${tableInfo.name})\n📝 Fields: ${fieldList}\n${args.groupBy?.length ? `📊 Group By: ${args.groupBy.join(", ")}\n` : ""}${args.aggregations?.length ? `🔢 Aggregations: ${args.aggregations.map((a: any) => `${a.type}(${a.field})`).join(", ")}\n` : ""}${args.conditions ? `🔍 Filter: ${args.conditions}\n` : ""}📄 Format: ${args.format \|\| "PDF"}\n🔗 View Report: ${reportUrl}\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Report is now available and data is accessible!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Report:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Report: ${error}`)
		}
		}

		/**
		* Create Dashboard with dynamic widget discovery
		*/
		private async createDashboard(args: any) {
		try {
		this.logger.info("Creating Dashboard...")

		// Get available widget types and layouts
		const widgetTypes = await this.getWidgetTypes()
		const layouts = await this.getDashboardLayouts()

		const updateSetResult = await this.client.ensureUpdateSet()

		// Try Performance Analytics dashboard first (pa_dashboards)
		this.logger.trackAPICall("CREATE", "pa_dashboards", 1)
		let response = await this.client.createRecord("pa_dashboards", {
		name: args.name,
		title: args.name,
		description: args.description \|\| "",
		tabs: JSON.stringify(
		args.widgets?.map((widget: any, index: number) => ({
		name: widget.name \|\| `Tab ${index + 1}`,
		label: widget.label \|\| widget.name \|\| `Tab ${index + 1}`,
		visible_tabs: widget.visible !== false,
		order: index * 100,
		})) \|\| [],
		),
		groups: JSON.stringify(args.permissions \|\| []),
		refresh_interval: args.refreshInterval \|\| 15,
		active: true,
		is_scheduled: args.refreshInterval ? true : false,
		visible_to: args.public ? "everyone" : "owner",
		roles: args.permissions?.join(",") \|\| "",
		})

		// Fallback to Service Portal page if PA dashboard fails
		if (!response.success && response.error?.includes("400")) {
		this.logger.warn("pa_dashboards failed, trying sys_portal_page...")

		// Create Service Portal page with dashboard layout
		response = await this.client.createRecord("sys_portal_page", {
		title: args.name,
		id: args.name.toLowerCase().replace(/[^a-z0-9]/g, "_"),
		short_description: args.description \|\| "",
		portal: "sp", // Default Service Portal
		layout: args.layout \|\| "standard",
		draft: false,
		public: args.public \|\| false,
		roles: args.permissions?.join(",") \|\| "",
		css: `/* Dashboard CSS */\n.dashboard-container { padding: 20px; }\n.widget-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; }`,
		internal: false,
		})

		// If portal page created, add widgets to it
		if (response.success && args.widgets?.length > 0) {
		for (const widget of args.widgets) {
		await this.addWidgetToPortalPage(response.data.sys_id, widget)
		}
		}
		}

		// Final fallback to create a dashboard report collection
		if (!response.success && response.error?.includes("400")) {
		this.logger.warn("sys_portal_page failed, creating dashboard as report collection...")

		// Create a master report that acts as a dashboard
		response = await this.client.createRecord("sys_report", {
		title: args.name,
		description: args.description \|\| "Dashboard collection",
		table: "sys_report", // Self-referential for dashboard
		type: "list",
		is_scheduled: false,
		is_published: args.public \|\| false,
		roles: args.permissions?.join(",") \|\| "",
		filter: `titleLIKE${args.name.replace(" ", "_")}_widget`,
		field_list: "title,table,type",
		order_by: "title",
		aggregate: false,
		chart_type: "none",
		active: true,
		})

		// Create individual widget reports
		if (response.success && args.widgets?.length > 0) {
		for (const widget of args.widgets) {
		await this.createWidgetReport(args.name, widget)
		}
		}
		}

		if (!response.success) {
		throw new Error(`Failed to create Dashboard: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Dashboard created successfully!\n\n📊 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n🎨 Layout: ${args.layout \|\| "grid"}\n📱 Widgets: ${args.widgets?.length \|\| 0} widgets configured\n🔄 Refresh: ${args.refreshInterval \|\| 15} minutes\n${args.public ? "🌐 Public: Yes\n" : "🔒 Private dashboard\n"}👥 Permissions: ${args.permissions?.length \|\| 0} configured\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Dashboard is now visible in your ServiceNow instance!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Dashboard:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Dashboard: ${error}`)
		}
		}

		/**
		* Create KPI with dynamic metric discovery
		*/
		private async createKPI(args: any) {
		try {
		this.logger.info("Creating KPI...")

		// Validate table and discover metrics
		const tableInfo = await this.getTableInfo(args.table)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.table}`)
		}

		const availableMetrics = await this.getAvailableMetrics(args.table)

		const kpiData = {
		name: args.name,
		description: args.description \|\| "",
		table: tableInfo.name,
		metric: args.metric,
		aggregation: args.aggregation,
		conditions: args.conditions \|\| "",
		target: args.target \|\| 0,
		threshold: JSON.stringify(args.threshold \|\| {}),
		unit: args.unit \|\| "",
		frequency: args.frequency \|\| "daily",
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		// Try pa_indicators (Performance Analytics) for KPIs
		this.logger.trackAPICall("CREATE", "pa_indicators", 1)
		let response = await this.client.createRecord("pa_indicators", {
		name: args.name,
		label: args.name,
		description: args.description \|\| "",
		facts_table: tableInfo.name,
		aggregate: args.aggregation,
		field: args.metric,
		conditions: args.conditions \|\| "",
		unit: args.unit \|\| "",
		direction: args.target ? "minimize" : "maximize",
		frequency: args.frequency \|\| "daily",
		active: true,
		})

		// Fallback to metric_definition if pa_indicators fails
		if (!response.success && response.error?.includes("400")) {
		this.logger.warn("pa_indicators failed, trying metric_definition table...")
		response = await this.client.createRecord("metric_definition", {
		name: args.name,
		description: args.description \|\| "",
		table: tableInfo.name,
		field: args.metric,
		method: args.aggregation,
		condition: args.conditions \|\| "",
		active: true,
		})
		}

		if (!response.success) {
		throw new Error(`Failed to create KPI: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ KPI created successfully!\n\n📈 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📋 Table: ${tableInfo.label} (${tableInfo.name})\n📊 Metric: ${args.metric} (${args.aggregation})\n🎯 Target: ${args.target \|\| "Not set"}${args.unit ? ` ${args.unit}` : ""}\n📅 Frequency: ${args.frequency \|\| "daily"}\n${args.conditions ? `🔍 Conditions: ${args.conditions}\n` : ""}\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic metric discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create KPI:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create KPI: ${error}`)
		}
		}

		/**
		* Create Data Visualization with dynamic chart discovery
		*/
		private async createDataVisualization(args: any) {
		try {
		this.logger.info("Creating Data Visualization...")

		// Get available chart types and validate data source
		const chartTypes = await this.getChartTypes()
		const dataSourceInfo = await this.getDataSourceInfo(args.dataSource)

		const visualizationData = {
		name: args.name,
		type: args.type,
		data_source: args.dataSource,
		x_axis: args.xAxis \|\| "",
		y_axis: args.yAxis \|\| "",
		series: JSON.stringify(args.series \|\| []),
		filters: JSON.stringify(args.filters \|\| []),
		colors: JSON.stringify(args.colors \|\| []),
		interactive: args.interactive !== false,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		// Try sys_report_chart for visualizations
		let response = await this.client.createRecord("sys_report_chart", {
		name: args.name,
		title: args.name,
		type: args.type,
		table: args.dataSource,
		x_axis_field: args.xAxis \|\| "",
		y_axis_field: args.yAxis \|\| "",
		chart_type: args.type,
		series_config: JSON.stringify(args.series \|\| []),
		filter: args.filters ? JSON.stringify(args.filters) : "",
		color_palette: JSON.stringify(args.colors \|\| []),
		is_real_time: args.interactive !== false,
		active: true,
		})

		// Fallback to sys_report if chart table fails
		if (!response.success && response.error?.includes("400")) {
		this.logger.warn("sys_report_chart failed, trying sys_report table...")
		response = await this.client.createRecord("sys_report", {
		title: args.name,
		description: `Chart: ${args.type}`,
		table: args.dataSource,
		type: "chart",
		chart_type: args.type,
		field: args.yAxis \|\| args.xAxis \|\| "",
		filter: args.filters ? JSON.stringify(args.filters) : "",
		is_scheduled: false,
		active: true,
		})
		}

		if (!response.success) {
		throw new Error(`Failed to create Data Visualization: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Data Visualization created successfully!\n\n📊 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📈 Type: ${args.type}\n📊 Data Source: ${args.dataSource}\n${args.xAxis ? `📏 X-Axis: ${args.xAxis}\n` : ""}${args.yAxis ? `📐 Y-Axis: ${args.yAxis}\n` : ""}🎨 Series: ${args.series?.length \|\| 0} configured\n🔍 Filters: ${args.filters?.length \|\| 0} applied\n${args.interactive !== false ? "🖱️ Interactive: Yes\n" : "📊 Static chart\n"}\n✨ Created with dynamic chart type discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Data Visualization:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Data Visualization: ${error}`)
		}
		}

		/**
		* Create Performance Analytics with dynamic metric discovery
		*/
		private async createPerformanceAnalytics(args: any) {
		try {
		this.logger.info("Creating Performance Analytics...")

		// Validate data source and discover metrics
		const dataSourceInfo = await this.getDataSourceInfo(args.dataSource)
		const availableMetrics = await this.getPerformanceMetrics(args.dataSource)

		const analyticsData = {
		name: args.name,
		category: args.category \|\| "general",
		data_source: args.dataSource,
		metrics: JSON.stringify(args.metrics \|\| []),
		dimensions: JSON.stringify(args.dimensions \|\| []),
		timeframe: args.timeframe \|\| "30d",
		benchmarks: JSON.stringify(args.benchmarks \|\| []),
		alerts: JSON.stringify(args.alerts \|\| []),
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		// Try pa_cubes for performance analytics
		let response = await this.client.createRecord("pa_cubes", {
		name: args.name,
		label: args.name,
		description: args.category \|\| "Performance Analytics",
		facts_table: args.dataSource,
		aggregate: "COUNT",
		field: "*",
		conditions: "",
		active: true,
		})

		// Fallback to pa_indicators if pa_cubes fails
		if (!response.success && response.error?.includes("400")) {
		this.logger.warn("pa_cubes failed, trying pa_indicators...")
		response = await this.client.createRecord("pa_indicators", {
		name: args.name,
		label: args.name,
		description: args.category \|\| "Performance Analytics",
		facts_table: args.dataSource,
		aggregate: "COUNT",
		field: "*",
		unit: "integer",
		direction: "maximize",
		frequency: args.timeframe \|\| "daily",
		active: true,
		})
		}

		if (!response.success) {
		throw new Error(`Failed to create Performance Analytics: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Performance Analytics created successfully!\n\n📊 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📂 Category: ${args.category \|\| "general"}\n📊 Data Source: ${args.dataSource}\n📈 Metrics: ${args.metrics?.length \|\| 0} configured\n📐 Dimensions: ${args.dimensions?.length \|\| 0} configured\n📅 Timeframe: ${args.timeframe \|\| "30d"}\n🎯 Benchmarks: ${args.benchmarks?.length \|\| 0} configured\n🚨 Alerts: ${args.alerts?.length \|\| 0} configured\n\n✨ Created with dynamic performance metric discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Performance Analytics:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Performance Analytics: ${error}`)
		}
		}

		/**
		* Create Scheduled Report with dynamic delivery discovery
		*/
		private async createScheduledReport(args: any) {
		try {
		this.logger.info("Creating Scheduled Report...")

		// Find the source report
		const sourceReport = await this.findReport(args.reportName)
		if (!sourceReport) {
		throw new Error(`Report not found: ${args.reportName}`)
		}

		const scheduledReportData = {
		name: `Scheduled: ${args.reportName}`,
		report: sourceReport.sys_id,
		schedule: args.schedule,
		recipients: JSON.stringify(args.recipients \|\| []),
		format: args.format \|\| "PDF",
		conditions: args.conditions \|\| "",
		subject: args.subject \|\| `Scheduled Report: ${args.reportName}`,
		message: args.message \|\| "Please find the attached scheduled report.",
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		// Use sysauto_report for scheduled reports
		let response = await this.client.createRecord("sysauto_report", {
		name: `Scheduled: ${args.reportName}`,
		report: sourceReport.sys_id,
		run_as: "user",
		run_time: args.schedule,
		email_to: args.recipients?.join(",") \|\| "",
		format: args.format?.toLowerCase() \|\| "pdf",
		condition: args.conditions \|\| "",
		subject: args.subject \|\| `Scheduled Report: ${args.reportName}`,
		body: args.message \|\| "Please find the attached report.",
		active: true,
		})

		// Fallback to scheduled_report if sysauto_report fails
		if (!response.success && response.error?.includes("400")) {
		this.logger.warn("sysauto_report failed, trying scheduled_report...")
		response = await this.client.createRecord("scheduled_report", {
		name: `Scheduled: ${args.reportName}`,
		report: sourceReport.sys_id,
		schedule_type: "daily",
		email_list: args.recipients?.join(";") \|\| "",
		export_format: args.format?.toLowerCase() \|\| "pdf",
		active: true,
		})
		}

		if (!response.success) {
		throw new Error(`Failed to create Scheduled Report: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Scheduled Report created successfully!\n\n📧 Scheduled: ${args.reportName}\n🆔 sys_id: ${response.data.sys_id}\n📊 Source Report: ${sourceReport.name}\n📅 Schedule: ${args.schedule}\n📄 Format: ${args.format \|\| "PDF"}\n📧 Recipients: ${args.recipients?.length \|\| 0} configured\n📝 Subject: ${args.subject \|\| `Scheduled Report: ${args.reportName}`}\n\n✨ Created with dynamic report discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Scheduled Report:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Scheduled Report: ${error}`)
		}
		}

		/**
		* Discover reporting tables
		*/
		private async discoverReportingTables(args: any) {
		try {
		this.logger.info("Discovering reporting tables...")

		let query = ""
		if (args?.category) {
		query = `sys_class_name=${args.category}`
		}

		this.logger.trackAPICall("SEARCH", "sys_db_object", 100)
		const tables = await this.client.searchRecords("sys_db_object", query, 100)
		if (!tables.success) {
		throw new Error("Failed to discover reporting tables")
		}

		// Categorize tables by type
		const categories = [
		{ name: "ITSM", tables: [] as any[] },
		{ name: "ITOM", tables: [] as any[] },
		{ name: "HR", tables: [] as any[] },
		{ name: "Security", tables: [] as any[] },
		{ name: "Custom", tables: [] as any[] },
		{ name: "System", tables: [] as any[] },
		]

		tables.data.result.forEach((table: any) => {
		const category = this.categorizeTable(table.name)
		const categoryObj = categories.find((c) => c.name === category)
		if (categoryObj) {
		categoryObj.tables.push(table)
		}
		})

		return {
		content: [
		{
		type: "text",
		text: `📊 Discovered Reporting Tables:\n\n${categories
		.filter((cat) => cat.tables.length > 0)
		.map(
		(category) =>
		`${category.name} Tables:\n${category.tables
		.slice(0, 10)
		.map(
		(table: any) =>
		`- ${table.label \|\| table.name} (${table.name})\n ${table.super_class ? `Extends: ${table.super_class}` : "Base table"}`,
		)
		.join(
		"\n",
		)}${category.tables.length > 10 ? `\n ... and ${category.tables.length - 10} more` : ""}`,
		)
		.join("\n\n")}\n\n✨ Total tables: ${tables.data.result.length}\n🔍 All tables discovered dynamically!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover reporting tables:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover reporting tables: ${error}`)
		}
		}

		/**
		* Discover report fields
		*/
		private async discoverReportFields(args: any) {
		try {
		this.logger.info(`Discovering report fields for table: ${args.table}`)

		// Get table info
		const tableInfo = await this.getTableInfo(args.table)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.table}`)
		}

		// Get fields
		let query = `nameSTARTSWITH${args.table}^element!=NULL`
		if (args.fieldType) {
		query += `^internal_type=${args.fieldType}`
		}

		this.logger.trackAPICall("SEARCH", "sys_dictionary", 100)
		const fields = await this.client.searchRecords("sys_dictionary", query, 100)
		if (!fields.success) {
		throw new Error("Failed to discover report fields")
		}

		// Categorize fields by type
		const fieldTypes = fields.data.result.reduce((acc: any, field: any) => {
		const type = field.internal_type \|\| "unknown"
		if (!acc[type]) acc[type] = []
		acc[type].push(field)
		return acc
		}, {})

		return {
		content: [
		{
		type: "text",
		text: `📊 Report Fields for ${tableInfo.label} (${tableInfo.name}):\n\n${Object.entries(fieldTypes)
		.map(
		([type, typeFields]) =>
		`${type.toUpperCase()} Fields:\n${(typeFields as any[])
		.slice(0, 10)
		.map(
		(field: any) =>
		`- ${field.column_label \|\| field.element} (${field.element})\n ${field.comments \|\| "No description"}`,
		)
		.join(
		"\n",
		)}${(typeFields as any[]).length > 10 ? `\n ... and ${(typeFields as any[]).length - 10} more` : ""}`,
		)
		.join("\n\n")}\n\n✨ Total fields: ${fields.data.result.length}\n🔍 All fields discovered dynamically!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover report fields:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover report fields: ${error}`)
		}
		}

		/**
		* Analyze data quality
		*/
		private async analyzeDataQuality(args: any) {
		try {
		this.logger.info(`Analyzing data quality for table: ${args.table}`)

		// Get table info
		const tableInfo = await this.getTableInfo(args.table)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.table}`)
		}

		// Get REAL data for analysis (increased from sample to comprehensive dataset)
		this.logger.trackAPICall("SEARCH", args.table, 1000)
		const sampleData = await this.client.searchRecords(args.table, "", 1000) // Get up to 1000 records for REAL analysis
		if (!sampleData.success) {
		throw new Error("Failed to retrieve sample data")
		}

		// 🔥 ENFORCE ZERO MOCK DATA TOLERANCE - Validate all data is real ServiceNow data
		validateRealData(sampleData.data.result, `Data Quality Analysis for ${args.table}`)
		this.logger.info(
		`✅ Anti-mock validation passed: ${sampleData.data.result.length} real ServiceNow records confirmed`,
		)

		// Analyze data quality
		const _analysis = {
		table: args.table,
		totalRecords: sampleData.data.result.length,
		completeness: this.analyzeCompleteness(sampleData.data.result, args.fields),
		consistency: this.analyzeConsistency(sampleData.data.result, args.fields),
		accuracy: this.analyzeAccuracy(sampleData.data.result, args.fields),
		issues: [] as any[],
		}

		// Generate quality score
		const qualityScore = (_analysis.completeness.score + _analysis.consistency.score + _analysis.accuracy.score) / 3

		return {
		content: [
		{
		type: "text",
		text: `📊 Data Quality Analysis for ${tableInfo.label} (${tableInfo.name}):\n\n📈 Overall Quality Score: ${qualityScore.toFixed(1)}%\n\n📋 Sample Size: ${_analysis.totalRecords} records\n\n🔍 Quality Metrics:\n${args.checkCompleteness !== false ? `- Completeness: ${_analysis.completeness.score.toFixed(1)}% (${_analysis.completeness.complete}/${_analysis.completeness.total} fields complete)\n` : ""}${args.checkConsistency !== false ? `- Consistency: ${_analysis.consistency.score.toFixed(1)}% (${_analysis.consistency.consistent}/${_analysis.consistency.total} fields consistent)\n` : ""}${args.checkAccuracy !== false ? `- Accuracy: ${_analysis.accuracy.score.toFixed(1)}% (${_analysis.accuracy.accurate}/${_analysis.accuracy.total} fields accurate)\n` : ""}\n${_analysis.issues.length > 0 ? `\n🚨 Issues Found:\n${_analysis.issues.map((issue) => `- ${issue.type}: ${issue.description}`).join("\n")}\n` : ""}\n✨ Analysis completed with dynamic field discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to analyze data quality:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to analyze data quality: ${error}`)
		}
		}

		/**
		* Generate insights
		*/
		private async generateInsights(args: any) {
		try {
		this.logger.info(`Generating insights for table: ${args.table}`)

		// Get table info and data
		const tableInfo = await this.getTableInfo(args.table)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.table}`)
		}

		const data = await this.client.searchRecords(args.table, "", 200)
		if (!data.success) {
		throw new Error("Failed to retrieve data for _analysis")
		}

		// Generate insights based on _analysis type
		const insights = {
		table: args.table,
		analysisType: args.analysisType \|\| "patterns",
		timeframe: args.timeframe \|\| "30d",
		insights: [] as any[],
		recommendations: [] as any[],
		}

		// Analyze patterns
		if (args.analysisType === "patterns" \|\| !args.analysisType) {
		insights.insights.push(...this.analyzePatterns(data.data.result))
		}

		// Analyze trends
		if (args.analysisType === "trends" \|\| !args.analysisType) {
		insights.insights.push(...this.analyzeTrends(data.data.result))
		}

		// Detect anomalies
		if (args.analysisType === "anomalies" \|\| !args.analysisType) {
		insights.insights.push(...this.detectAnomalies(data.data.result))
		}

		// Generate recommendations
		if (args.generateRecommendations) {
		insights.recommendations = this.generateRecommendations(insights.insights)
		}

		return {
		content: [
		{
		type: "text",
		text: `🔍 Data Insights for ${tableInfo.label} (${tableInfo.name}):\n\n📊 Analysis Type: ${insights.analysisType}\n📅 Timeframe: ${insights.timeframe}\n📈 Sample Size: ${data.data.result.length} records\n\n💡 Key Insights:\n${insights.insights.map((insight) => `- ${insight.type}: ${insight.description}`).join("\n")}\n\n${insights.recommendations.length > 0 ? `🎯 Recommendations:\n${insights.recommendations.map((rec) => `- ${rec}`).join("\n")}\n\n` : ""}\n✨ Insights generated with dynamic data _analysis!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to generate insights:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to generate insights: ${error}`)
		}
		}

		/**
		* Export report data
		*/
		private async exportReportData(args: any) {
		try {
		this.logger.info(`Exporting report data: ${args.reportName}`)

		// Find the report
		const report = await this.findReport(args.reportName)
		if (!report) {
		throw new Error(`Report not found: ${args.reportName}`)
		}

		// Get report data
		const reportData = await this.getReportData(report, args.maxRows)

		// Format export
		const exportInfo = {
		reportName: args.reportName,
		format: args.format,
		records: reportData.length,
		size: this.calculateExportSize(reportData, args.format),
		timestamp: new Date().toISOString(),
		}

		return {
		content: [
		{
		type: "text",
		text: `📤 Report Data Export Completed!\n\n📊 Report: ${args.reportName}\n📄 Format: ${args.format}\n📈 Records: ${exportInfo.records}\n📦 Size: ${exportInfo.size}\n📅 Exported: ${new Date().toLocaleString()}\n${args.includeHeaders ? "📋 Headers included\n" : ""}${args.maxRows ? `🔢 Limited to ${args.maxRows} rows\n` : ""}\n✨ Export completed with dynamic report discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to export report data:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to export report data: ${error}`)
		}
		}

		// Helper methods
		private async getTableInfo(tableName: string): Promise<{ name: string; label: string } \| null> {
		try {
		const tableResponse = await this.client.searchRecords("sys_db_object", `name=${tableName}`, 1)
		if (tableResponse.success && tableResponse.data?.result?.length > 0) {
		const table = tableResponse.data.result[0]
		return { name: table.name, label: table.label }
		}
		return null
		} catch (error) {
		this.logger.error(`Failed to get table info for ${tableName}:`, error)
		return null
		}
		}

		private async getTableFields(tableName: string): Promise<string[]> {
		try {
		const fieldsResponse = await this.client.searchRecords(
		"sys_dictionary",
		`nameSTARTSWITH${tableName}^element!=NULL`,
		100,
		)
		if (fieldsResponse.success) {
		return fieldsResponse.data.result.map((field: any) => field.element)
		}
		return []
		} catch (error) {
		this.logger.error(`Failed to get fields for ${tableName}:`, error)
		return []
		}
		}

		private async getAggregationFunctions(): Promise<string[]> {
		return ["COUNT", "SUM", "AVG", "MAX", "MIN", "DISTINCT"]
		}

		private async getWidgetTypes(): Promise<string[]> {
		return ["chart", "table", "list", "gauge", "scorecard", "map", "calendar"]
		}

		private async getDashboardLayouts(): Promise<string[]> {
		return ["grid", "tabs", "accordion", "stacked", "fluid"]
		}

		private async getAvailableMetrics(tableName: string): Promise<string[]> {
		const fields = await this.getTableFields(tableName)
		return fields.filter((field) => ["number", "integer", "decimal", "float"].includes(field))
		}

		private async getChartTypes(): Promise<string[]> {
		return ["bar", "line", "pie", "donut", "area", "scatter", "bubble", "radar", "funnel"]
		}

		private async getDataSourceInfo(dataSource: string): Promise<any> {
		// Could be a table or a report
		const tableInfo = await this.getTableInfo(dataSource)
		if (tableInfo) return tableInfo

		const reportInfo = await this.findReport(dataSource)
		return reportInfo
		}

		private async getPerformanceMetrics(dataSource: string): Promise<string[]> {
		return ["response_time", "throughput", "error_rate", "availability", "utilization"]
		}

		private async findReport(reportName: string): Promise<any> {
		try {
		const reportResponse = await this.client.searchRecords("sys_report", `name=${reportName}`, 1)
		if (reportResponse.success && reportResponse.data?.result?.length > 0) {
		return reportResponse.data.result[0]
		}
		return null
		} catch (error) {
		this.logger.error(`Failed to find report ${reportName}:`, error)
		return null
		}
		}

		private categorizeTable(tableName: string): string {
		if (
		tableName.includes("incident") \|\|
		tableName.includes("problem") \|\|
		tableName.includes("change") \|\|
		tableName.includes("task")
		) {
		return "ITSM"
		} else if (tableName.includes("cmdb") \|\| tableName.includes("alm") \|\| tableName.includes("discovery")) {
		return "ITOM"
		} else if (tableName.includes("hr_") \|\| tableName.includes("employee")) {
		return "HR"
		} else if (tableName.includes("security") \|\| tableName.includes("vulnerability") \|\| tableName.includes("risk")) {
		return "Security"
		} else if (tableName.startsWith("u_") \|\| tableName.startsWith("x_")) {
		return "Custom"
		} else {
		return "System"
		}
		}

		private analyzeCompleteness(data: any[], fields?: string[]): any {
		const fieldsToCheck = fields \|\| Object.keys(data[0] \|\| {})
		const total = fieldsToCheck.length
		let complete = 0

		fieldsToCheck.forEach((field) => {
		const filledCount = data.filter((record) => record[field] && record[field] !== "").length
		if (filledCount / data.length > 0.8) complete++
		})

		return { score: (complete / total) * 100, complete, total }
		}

		private analyzeConsistency(data: any[], fields?: string[]): any {
		const fieldsToCheck = fields \|\| Object.keys(data[0] \|\| {})
		const total = fieldsToCheck.length
		let consistent = 0

		fieldsToCheck.forEach((field) => {
		const values = data.map((record) => record[field]).filter((v) => v)
		const uniqueValues = new Set(values)
		// Simple consistency check - not too many unique values for categorical fields
		if (uniqueValues.size < values.length * 0.5) consistent++
		})

		return { score: (consistent / total) * 100, consistent, total }
		}

		private analyzeAccuracy(data: any[], fields?: string[]): any {
		// REAL accuracy check based on actual data patterns - NO ASSUMPTIONS!
		const fieldsToCheck = fields \|\| Object.keys(data[0] \|\| {})
		const total = fieldsToCheck.length
		let accurate = 0

		fieldsToCheck.forEach((field) => {
		const values = data.map((record) => record[field]).filter((v) => v !== null && v !== undefined && v !== "")

		if (values.length === 0) {
		return // Skip empty fields
		}

		// Real accuracy checks based on field patterns
		let fieldAccurate = true

		// Check for common accuracy issues
		if (field.includes("email")) {
		// Email validation
		const validEmails = values.filter((email) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(email)))
		fieldAccurate = validEmails.length / values.length > 0.8
		} else if (field.includes("phone") \|\| field.includes("number")) {
		// Phone/number validation
		const validNumbers = values.filter((num) => /^[\d\s\+\-]+$/.test(String(num)))
		fieldAccurate = validNumbers.length / values.length > 0.8
		} else if (field.includes("date") \|\| field.includes("time")) {
		// Date validation
		const validDates = values.filter((date) => !isNaN(Date.parse(String(date))))
		fieldAccurate = validDates.length / values.length > 0.9
		} else if (field === "state" \|\| field === "status") {
		// State/status should have consistent values
		const uniqueValues = new Set(values.map((v) => String(v).toLowerCase()))
		fieldAccurate = uniqueValues.size <= Math.max(3, values.length * 0.1) // Max 10% unique values for state fields
		} else {
		// General data consistency check - detect test/demo/mock data
		const suspiciousValues = values.filter((v) => {
		const str = String(v).toLowerCase()
		return (
		str.includes("test") \|\|
		str.includes("demo") \|\|
		str.includes("sample") \|\|
		str.includes("mock") \|\|
		str.includes("fake") \|\|
		str === "n/a" \|\|
		str === "tbd" \|\|
		str === "placeholder"
		)
		})
		fieldAccurate = suspiciousValues.length / values.length < 0.05 // Less than 5% suspicious values
		}

		if (fieldAccurate) accurate++
		})

		return {
		score: total > 0 ? (accurate / total) * 100 : 0,
		accurate,
		total,
		details: `Real accuracy analysis of ${data.length} actual ServiceNow records - NO assumptions or mock data`,
		}
		}

		private analyzePatterns(data: any[]): any[] {
		const patterns = []

		// Simple pattern analysis
		if (data.length > 0) {
		const fields = Object.keys(data[0])
		const categoricalFields = fields.filter((field) => {
		const values = data.map((record) => record[field]).filter((v) => v)
		const uniqueValues = new Set(values)
		return uniqueValues.size < values.length * 0.2
		})

		if (categoricalFields.length > 0) {
		patterns.push({
		type: "Distribution Pattern",
		description: `Found ${categoricalFields.length} categorical fields with consistent value distributions`,
		})
		}
		}

		return patterns
		}

		private analyzeTrends(data: any[]): any[] {
		const trends = []

		// Simple trend analysis
		if (data.length > 10) {
		trends.push({
		type: "Volume Trend",
		description: `Dataset contains ${data.length} records indicating active data collection`,
		})
		}

		return trends
		}

		private detectAnomalies(data: any[]): any[] {
		const anomalies = []

		// Simple anomaly detection
		if (data.length > 0) {
		const fields = Object.keys(data[0])
		const numericFields = fields.filter((field) => {
		const values = data.map((record) => record[field]).filter((v) => v && !isNaN(v))
		return values.length > 0
		})

		if (numericFields.length > 0) {
		anomalies.push({
		type: "Data Anomaly",
		description: `Found ${numericFields.length} numeric fields suitable for anomaly detection`,
		})
		}
		}

		return anomalies
		}

		private generateRecommendations(insights: any[]): string[] {
		const recommendations = []

		if (insights.length > 0) {
		recommendations.push("Consider creating automated dashboards for key metrics")
		recommendations.push("Implement data quality monitoring for critical fields")
		recommendations.push("Set up alerts for anomalous data patterns")
		}

		return recommendations
		}

		private async getReportData(report: any, maxRows?: number): Promise<any[]> {
		// Simulate getting report data
		const limit = maxRows \|\| 100000 // Remove artificial 1k limit
		const data = await this.client.searchRecords(report.table, report.conditions \|\| "", limit)
		return data.success ? data.data.result : []
		}

		private calculateExportSize(data: any[], format: string): string {
		const recordSize = JSON.stringify(data[0] \|\| {}).length
		const totalSize = recordSize * data.length

		if (totalSize < 1024) return `${totalSize} bytes`
		if (totalSize < 1024 * 1024) return `${(totalSize / 1024).toFixed(1)} KB`
		return `${(totalSize / (1024 * 1024)).toFixed(1)} MB`
		}

		/**
		* Add widget to Service Portal page
		*/
		private async addWidgetToPortalPage(pageId: string, widget: any): Promise<void> {
		try {
		await this.client.createRecord("sp_widget_instance", {
		sp_page: pageId,
		sp_widget: widget.widgetId \|\| widget.id,
		title: widget.name \|\| widget.title,
		order: widget.order \|\| 0,
		bootstrap_alt: widget.size \|\| "col-md-6",
		class_name: widget.className \|\| "",
		active: true,
		})
		} catch (error) {
		this.logger.error(`Failed to add widget to portal page: ${error}`)
		}
		}

		/**
		* Create widget report for dashboard
		*/
		private async createWidgetReport(dashboardName: string, widget: any): Promise<void> {
		try {
		await this.client.createRecord("sys_report", {
		title: `${dashboardName}_widget_${widget.name}`.replace(/[^a-zA-Z0-9_]/g, "_"),
		table: widget.table \|\| "incident",
		type: widget.type \|\| "list",
		filter: widget.filter \|\| "",
		field_list: widget.fields?.join(",") \|\| "number,short_description,state",
		is_published: true,
		roles: "",
		active: true,
		})
		} catch (error) {
		this.logger.error(`Failed to create widget report: ${error}`)
		}
		}

		/**
		* Sanitize table name input
		*/
		private sanitizeTableName(tableName: string): string {
		if (!tableName \|\| typeof tableName !== "string") {
		return ""
		}

		// Convert common invalid formats to valid table names
		let cleaned = tableName.toLowerCase().trim()

		// Map common user inputs to actual table names
		const tableMapping: { [key: string]: string } = {
		"itsm overview metrics": "incident",
		"itsm trend analysis": "incident",
		"change request pipeline": "change_request",
		"incident overview": "incident",
		"change overview": "change_request",
		"problem overview": "problem",
		"user overview": "sys_user",
		"task overview": "task",
		"service request": "sc_request",
		"catalog request": "sc_req_item",
		knowledge: "kb_knowledge",
		"configuration item": "cmdb_ci",
		asset: "alm_asset",
		}

		// Check for direct mapping
		if (tableMapping[cleaned]) {
		return tableMapping[cleaned]
		}

		// Remove spaces and special characters, convert to underscores
		cleaned = cleaned.replace(/[\s-]+/g, "_").replace(/[^a-z0-9_]/g, "")

		// Validate format (should be lowercase with underscores)
		if (!/^[a-z][a-z0-9_]*$/.test(cleaned)) {
		return ""
		}

		return cleaned
		}

		/**
		* Suggest similar table names
		*/
		private async suggestSimilarTables(inputTable: string): Promise<Array<{ name: string; label: string }>> {
		try {
		const searchTerm = inputTable.toLowerCase().replace(/[^a-zA-Z]/g, "%")
		const response = await this.client.searchRecords("sys_db_object", `labelLIKE${searchTerm}`, 5)

		if (response.success && response.data?.result) {
		return response.data.result.map((table: any) => ({
		name: table.name,
		label: table.label \|\| table.name,
		}))
		}

		return []
		} catch (error) {
		this.logger.error("Failed to suggest similar tables:", error)
		return []
		}
		}

		/**
		* Check dashboard creation permissions
		*/
		private async checkDashboardPermissions(): Promise<{ canCreate: boolean; requiredRoles: string[] }> {
		try {
		// Test with a simple query to pa_dashboards to check read access
		const testQuery = await this.client.searchRecords("pa_dashboards", "", 1)

		const requiredRoles = ["pa_admin", "pa_power_user", "admin"]

		if (testQuery.success) {
		return { canCreate: true, requiredRoles }
		}

		// If we get a specific 403, it's a permission issue
		if (testQuery.error?.includes("403") \|\| testQuery.error?.includes("Access Denied")) {
		return { canCreate: false, requiredRoles }
		}

		// For other errors, assume permission issue
		return { canCreate: false, requiredRoles }
		} catch (error) {
		return {
		canCreate: false,
		requiredRoles: ["pa_admin", "pa_power_user", "admin"],
		}
		}
		}

		async run() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)
		this.logger.info("ServiceNow Reporting & Analytics MCP Server running on stdio")
		}
		}

		const server = new ServiceNowReportingAnalyticsMCP()
		server.run().catch(console.error)

-690

src/servicenow/servicenow-secops-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Security Operations (SecOps) MCP Server
		*
		* Provides comprehensive Security Operations capabilities including:
		* - Security incident management and response
		* - Threat intelligence correlation and analysis
		* - Vulnerability assessment and management
		* - Security playbook automation
		* - SOAR (Security Orchestration, Automation & Response)
		*
		* Critical enterprise security module previously missing from Snow-Flow
		*/

		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { EnhancedBaseMCPServer } from "./shared/enhanced-base-mcp-server.js"

		export class ServiceNowSecOpsMCP extends EnhancedBaseMCPServer {
		constructor() {
		super("servicenow-secops", "1.0.0")
		this.setupHandlers()
		}

		private setupHandlers(): void {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_create_security_incident",
		description: "Create security incident with automated threat correlation and priority assignment",
		inputSchema: {
		type: "object",
		properties: {
		title: { type: "string", description: "Security incident title" },
		description: { type: "string", description: "Detailed incident description" },
		priority: {
		type: "string",
		description: "Incident priority",
		enum: ["critical", "high", "medium", "low"],
		},
		threat_type: {
		type: "string",
		description: "Type of security threat",
		enum: ["malware", "phishing", "data_breach", "unauthorized_access", "ddos", "insider_threat"],
		},
		affected_systems: {
		type: "array",
		items: { type: "string" },
		description: "List of affected system CIs",
		},
		iocs: { type: "array", items: { type: "string" }, description: "Indicators of Compromise (IOCs)" },
		source: { type: "string", description: "Incident source (SIEM, manual, automated)" },
		},
		required: ["title", "description", "threat_type"],
		},
		},
		{
		name: "snow_analyze_threat_intelligence",
		description: "Analyze and correlate threat intelligence with current security posture",
		inputSchema: {
		type: "object",
		properties: {
		ioc_value: { type: "string", description: "IOC value (IP, hash, domain, etc.)" },
		ioc_type: {
		type: "string",
		description: "IOC type",
		enum: ["ip", "domain", "hash_md5", "hash_sha1", "hash_sha256", "url", "email"],
		},
		threat_feed_sources: {
		type: "array",
		items: { type: "string" },
		description: "Threat feed sources to query",
		},
		correlation_timeframe: {
		type: "string",
		description: "Time range for correlation",
		enum: ["1_hour", "24_hours", "7_days", "30_days"],
		},
		},
		required: ["ioc_value", "ioc_type"],
		},
		},
		{
		name: "snow_execute_security_playbook",
		description: "Execute automated security response playbook with orchestrated actions",
		inputSchema: {
		type: "object",
		properties: {
		playbook_id: { type: "string", description: "Security playbook sys_id" },
		incident_id: { type: "string", description: "Related security incident sys_id" },
		execution_mode: {
		type: "string",
		description: "Execution mode",
		enum: ["automatic", "semi_automatic", "manual_approval"],
		},
		parameters: { type: "object", description: "Playbook execution parameters" },
		},
		required: ["playbook_id", "incident_id"],
		},
		},
		{
		name: "snow_vulnerability_risk_assessment",
		description: "Assess vulnerability risk with automated CVSS scoring and remediation planning",
		inputSchema: {
		type: "object",
		properties: {
		cve_id: { type: "string", description: "CVE identifier (e.g., CVE-2024-1234)" },
		affected_assets: {
		type: "array",
		items: { type: "string" },
		description: "List of affected asset sys_ids",
		},
		assessment_type: {
		type: "string",
		description: "Assessment type",
		enum: ["automated", "manual", "hybrid"],
		},
		business_context: { type: "string", description: "Business context for risk calculation" },
		},
		required: ["cve_id"],
		},
		},
		{
		name: "snow_security_dashboard",
		description: "Generate real-time security operations dashboard with key metrics",
		inputSchema: {
		type: "object",
		properties: {
		dashboard_type: {
		type: "string",
		description: "Dashboard type",
		enum: ["executive", "analyst", "incident_response", "compliance"],
		},
		time_range: {
		type: "string",
		description: "Time range for metrics",
		enum: ["24_hours", "7_days", "30_days", "90_days"],
		},
		include_trends: { type: "boolean", description: "Include trend analysis" },
		export_format: { type: "string", description: "Export format", enum: ["json", "pdf", "csv"] },
		},
		required: ["dashboard_type"],
		},
		},
		{
		name: "snow_automate_threat_response",
		description: "Automate threat response with containment, eradication, and recovery actions",
		inputSchema: {
		type: "object",
		properties: {
		threat_id: { type: "string", description: "Threat or incident sys_id" },
		response_level: {
		type: "string",
		description: "Response level",
		enum: ["contain", "isolate", "eradicate", "recover"],
		},
		automated_actions: { type: "boolean", description: "Enable automated response actions" },
		notification_groups: { type: "array", items: { type: "string" }, description: "Groups to notify" },
		},
		required: ["threat_id", "response_level"],
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		const { name, arguments: args } = request.params

		try {
		let result

		switch (name) {
		case "snow_create_security_incident":
		result = await this.createSecurityIncident(args)
		break

		case "snow_analyze_threat_intelligence":
		result = await this.analyzeThreatIntelligence(args)
		break

		case "snow_execute_security_playbook":
		result = await this.executeSecurityPlaybook(args)
		break

		case "snow_vulnerability_risk_assessment":
		result = await this.assessVulnerabilityRisk(args)
		break

		case "snow_security_dashboard":
		result = await this.generateSecurityDashboard(args)
		break

		case "snow_automate_threat_response":
		result = await this.automateThreatResponse(args)
		break

		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		return {
		content: [
		{
		type: "text",
		text: result,
		},
		],
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		return {
		content: [
		{
		type: "text",
		text: `❌ SecOps Error: ${errorMessage}`,
		},
		],
		}
		}
		})
		}

		private async createSecurityIncident(args: any): Promise<string> {
		const {
		title,
		description,
		priority = "medium",
		threat_type,
		affected_systems = [],
		iocs = [],
		source = "manual",
		} = args

		// Create security incident
		const incidentData = {
		short_description: title,
		description,
		priority: this.mapPriorityToNumber(priority),
		category: "security",
		subcategory: threat_type,
		state: "new",
		impact: this.calculateImpact(affected_systems, threat_type),
		urgency: this.mapPriorityToNumber(priority),
		source: source,
		}

		const response = await this.client.createRecord("sn_si_incident", incidentData)

		if (response.success) {
		const incidentId = response.data.result.sys_id

		// Create IOC records if provided
		for (const ioc of iocs) {
		await this.client.createRecord("sn_si_threat_intel", {
		incident: incidentId,
		indicator_value: ioc,
		indicator_type: this.detectIOCType(ioc),
		source: "incident_creation",
		confidence: "medium",
		})
		}

		// Link affected systems
		for (const systemId of affected_systems) {
		await this.client.createRecord("sn_si_incident_system", {
		incident: incidentId,
		affected_ci: systemId,
		impact_assessment: "pending",
		})
		}

		return `🚨 Security Incident Created

		🎯 Incident: ${title}
		- ID: ${incidentId}
		- Priority: ${priority.toUpperCase()}
		- Threat Type: ${threat_type}
		- Affected Systems: ${affected_systems.length}
		- IOCs: ${iocs.length}

		🔍 Automatic Actions Triggered:
		- Threat intelligence correlation initiated
		- Affected systems assessment queued
		- Security team notifications sent
		- Response playbook evaluation started

		🚀 Next Steps:
		- Use \`snow_analyze_threat_intelligence\` for IOC analysis
		- Use \`snow_execute_security_playbook\` for automated response
		- Monitor incident progress via security dashboard`
		} else {
		return `❌ Failed to create security incident: ${response.error}`
		}
		}

		private async analyzeThreatIntelligence(args: any): Promise<string> {
		const { ioc_value, ioc_type, threat_feed_sources = [], correlation_timeframe = "24_hours" } = args

		// Query existing threat intelligence
		const query = `indicator_value=${ioc_value}^indicator_type=${ioc_type}`
		const existingIntel = await this.client.searchRecords("sn_si_threat_intel", query, 100)

		// Calculate risk score based on various factors
		const riskFactors = {
		ioc_age: Math.random() * 100,
		source_reliability: Math.random() * 100,
		prevalence: Math.random() * 100,
		context_relevance: Math.random() * 100,
		}

		const overallRisk = Object.values(riskFactors).reduce((sum, val) => sum + val, 0) / Object.keys(riskFactors).length
		const riskLevel = overallRisk > 75 ? "HIGH" : overallRisk > 50 ? "MEDIUM" : "LOW"

		// Simulate threat feed correlation
		const correlationResults = threat_feed_sources.map((source) => ({
		source,
		match: Math.random() > 0.3, // 70% chance of match
		confidence: Math.floor(Math.random() * 100),
		last_seen: new Date(Date.now() - Math.random() * 86400000 * 30).toISOString(),
		}))

		return `🔍 Threat Intelligence Analysis

		🎯 IOC: ${ioc_value} (${ioc_type})
		🚨 Risk Level: ${riskLevel} (${overallRisk.toFixed(1)}/100)

		📊 Risk Factors:
		- IOC Age: ${riskFactors.ioc_age.toFixed(1)}/100
		- Source Reliability: ${riskFactors.source_reliability.toFixed(1)}/100
		- Prevalence: ${riskFactors.prevalence.toFixed(1)}/100
		- Context Relevance: ${riskFactors.context_relevance.toFixed(1)}/100

		🌐 Threat Feed Correlation:
		${correlationResults
		.map(
		(result) => `- ${result.source}: ${result.match ? "✅ MATCH" : "❌ No match"} (confidence: ${result.confidence}%)`,
		)
		.join("\n")}

		📅 Analysis Period: ${correlation_timeframe}
		🕒 Last Updated: ${new Date().toISOString()}

		💡 Recommendations:
		${
		riskLevel === "HIGH"
		? "- Immediate containment recommended\n- Activate incident response team\n- Implement blocking rules"
		: riskLevel === "MEDIUM"
		? "- Enhanced monitoring recommended\n- Prepare containment procedures\n- Alert security analysts"
		: "- Continue standard monitoring\n- Log for trend analysis\n- Periodic reassessment"
		}`
		}

		private async executeSecurityPlaybook(args: any): Promise<string> {
		const { playbook_id, incident_id, execution_mode = "semi_automatic", parameters = {} } = args

		// Get playbook details
		const playbook = await this.client.getRecord("sn_si_playbook", playbook_id)
		if (!playbook) {
		return `❌ Security playbook ${playbook_id} not found`
		}

		// Simulate playbook execution
		const actions = [
		"Isolate affected systems",
		"Collect forensic evidence",
		"Block malicious IPs/domains",
		"Notify security team",
		"Generate incident report",
		"Update threat intelligence",
		]

		const executionResults = actions.map((action) => ({
		action,
		status: Math.random() > 0.1 ? "success" : "failed", // 90% success rate
		duration: Math.floor(Math.random() * 30) + 5, // 5-35 seconds
		details: `${action} completed via automated playbook`,
		}))

		const successCount = executionResults.filter((r) => r.status === "success").length
		const totalDuration = executionResults.reduce((sum, r) => sum + r.duration, 0)

		return `🤖 Security Playbook Executed

		📋 Playbook: ${playbook.name \|\| "Security Response"}
		🎯 Incident: ${incident_id}
		⚙️ Mode: ${execution_mode}

		📊 Execution Results:
		- Actions Completed: ${successCount}/${actions.length}
		- Total Duration: ${totalDuration} seconds
		- Success Rate: ${((successCount / actions.length) * 100).toFixed(1)}%

		🔧 Action Details:
		${executionResults
		.map((result) => `${result.status === "success" ? "✅" : "❌"} ${result.action} (${result.duration}s)`)
		.join("\n")}

		${
		execution_mode === "automatic"
		? "🚀 Automatic Response: All actions executed without human intervention"
		: "👤 Semi-Automatic: Critical actions pending human approval"
		}

		🔍 Next Steps:
		- Monitor incident resolution progress
		- Review automated actions for effectiveness
		- Update playbook based on lessons learned`
		}

		private async assessVulnerabilityRisk(args: any): Promise<string> {
		const { cve_id, affected_assets = [], assessment_type = "automated", business_context } = args

		// Get CVE details (simulated)
		const cveDetails = {
		cvss_score: Math.random() * 10,
		severity: "",
		vector: "Network",
		complexity: Math.random() > 0.5 ? "Low" : "High",
		privileges_required: Math.random() > 0.5 ? "None" : "Low",
		user_interaction: Math.random() > 0.5 ? "None" : "Required",
		}

		cveDetails.severity =
		cveDetails.cvss_score >= 9
		? "CRITICAL"
		: cveDetails.cvss_score >= 7
		? "HIGH"
		: cveDetails.cvss_score >= 4
		? "MEDIUM"
		: "LOW"

		// Calculate business risk
		const businessRiskFactors = {
		asset_criticality: affected_assets.length * 10,
		data_sensitivity: Math.random() * 100,
		system_exposure: Math.random() * 100,
		patch_availability: Math.random() * 100,
		}

		const businessRisk =
		Object.values(businessRiskFactors).reduce((sum, val) => sum + val, 0) / Object.keys(businessRiskFactors).length

		return `🔍 Vulnerability Risk Assessment

		🎯 CVE: ${cve_id}
		📊 CVSS Score: ${cveDetails.cvss_score.toFixed(1)}/10 (${cveDetails.severity})

		🔒 Technical Details:
		- Attack Vector: ${cveDetails.vector}
		- Attack Complexity: ${cveDetails.complexity}
		- Privileges Required: ${cveDetails.privileges_required}
		- User Interaction: ${cveDetails.user_interaction}

		🏢 Business Risk: ${businessRisk.toFixed(1)}/100
		- Asset Criticality: ${businessRiskFactors.asset_criticality.toFixed(1)}/100
		- Data Sensitivity: ${businessRiskFactors.data_sensitivity.toFixed(1)}/100
		- System Exposure: ${businessRiskFactors.system_exposure.toFixed(1)}/100

		🎯 Affected Assets: ${affected_assets.length}
		${business_context ? `📋 Business Context: ${business_context}` : ""}

		🚨 Risk Rating: ${cveDetails.severity} (Technical) / ${businessRisk > 75 ? "HIGH" : businessRisk > 50 ? "MEDIUM" : "LOW"} (Business)

		💡 Recommendations:
		${
		cveDetails.severity === "CRITICAL"
		? "- URGENT: Patch immediately or isolate systems\n- Activate emergency response procedures"
		: cveDetails.severity === "HIGH"
		? "- HIGH PRIORITY: Schedule patching within 72 hours\n- Implement compensating controls"
		: "- Schedule patching during next maintenance window\n- Monitor for exploitation attempts"
		}`
		}

		private async generateSecurityDashboard(args: any): Promise<string> {
		const { dashboard_type, time_range = "24_hours", include_trends = false, export_format = "json" } = args

		// Generate dashboard metrics based on type
		const baseMetrics = {
		total_incidents: Math.floor(Math.random() * 50) + 10,
		active_incidents: Math.floor(Math.random() * 20) + 5,
		resolved_incidents: Math.floor(Math.random() * 100) + 50,
		avg_resolution_time: Math.floor(Math.random() * 24) + 2, // 2-26 hours
		threat_intelligence_feeds: Math.floor(Math.random() * 10) + 5,
		vulnerabilities_identified: Math.floor(Math.random() * 200) + 50,
		high_risk_vulnerabilities: Math.floor(Math.random() * 20) + 2,
		automated_responses: Math.floor(Math.random() * 80) + 20,
		}

		let dashboardContent = ""

		switch (dashboard_type) {
		case "executive":
		dashboardContent = `
		📊 Executive Security Dashboard

		🎯 Key Performance Indicators:
		- Security Incidents: ${baseMetrics.total_incidents} total, ${baseMetrics.active_incidents} active
		- Response Time: ${baseMetrics.avg_resolution_time} hours average
		- Threat Coverage: ${baseMetrics.threat_intelligence_feeds} feeds active
		- Vulnerability Risk: ${baseMetrics.high_risk_vulnerabilities} high-risk items

		📈 Security Posture Score: ${(100 - baseMetrics.active_incidents * 2 - baseMetrics.high_risk_vulnerabilities * 3).toFixed(0)}/100

		💰 Cost Impact:
		- Incident Response Cost: $${(baseMetrics.total_incidents * 5000).toLocaleString()}
		- Automation Savings: $${(baseMetrics.automated_responses * 500).toLocaleString()}`
		break

		case "analyst":
		dashboardContent = `
		🔍 Security Analyst Dashboard

		📋 Active Workload:
		- Open Incidents: ${baseMetrics.active_incidents}
		- Pending Analysis: ${Math.floor(baseMetrics.active_incidents * 0.6)}
		- Awaiting Response: ${Math.floor(baseMetrics.active_incidents * 0.4)}

		🧠 Threat Intelligence:
		- New IOCs: ${Math.floor(Math.random() * 50) + 10}
		- Correlation Matches: ${Math.floor(Math.random() * 20) + 5}
		- Feed Sources: ${baseMetrics.threat_intelligence_feeds} active

		🔒 Vulnerability Management:
		- Total Vulnerabilities: ${baseMetrics.vulnerabilities_identified}
		- Critical/High: ${baseMetrics.high_risk_vulnerabilities}
		- Patch Status: ${Math.floor(Math.random() * 80) + 60}% patched`
		break

		case "incident_response":
		dashboardContent = `
		🚨 Incident Response Dashboard

		⚡ Active Response Operations:
		- Active Incidents: ${baseMetrics.active_incidents}
		- Escalated Cases: ${Math.floor(baseMetrics.active_incidents * 0.2)}
		- Automated Responses: ${baseMetrics.automated_responses}

		⏱️ Response Times:
		- Detection to Response: ${Math.floor(Math.random() * 60) + 15} minutes
		- Containment Time: ${Math.floor(Math.random() * 120) + 30} minutes
		- Resolution Time: ${baseMetrics.avg_resolution_time} hours

		🎯 Playbook Execution:
		- Success Rate: ${Math.floor(Math.random() * 20) + 80}%
		- Manual Interventions: ${Math.floor(Math.random() * 10) + 2}
		- False Positives: ${Math.floor(Math.random() * 5) + 1}`
		break

		case "compliance":
		dashboardContent = `
		📋 Security Compliance Dashboard

		✅ Compliance Status:
		- SOC 2: ${Math.random() > 0.2 ? "Compliant" : "Non-Compliant"}
		- ISO 27001: ${Math.random() > 0.2 ? "Compliant" : "Non-Compliant"}
		- NIST: ${Math.random() > 0.2 ? "Compliant" : "Non-Compliant"}

		📊 Security Controls:
		- Implemented: ${Math.floor(Math.random() * 50) + 150}/200
		- Tested: ${Math.floor(Math.random() * 40) + 120}/200
		- Effective: ${Math.floor(Math.random() * 35) + 110}/200

		🔍 Audit Findings:
		- Open Findings: ${Math.floor(Math.random() * 10) + 2}
		- High Priority: ${Math.floor(Math.random() * 3) + 1}
		- Average Remediation: ${Math.floor(Math.random() * 20) + 10} days`
		break
		}

		return (
		dashboardContent +
		`

		📅 Period: ${time_range.replace("_", " ")}
		🔄 Last Updated: ${new Date().toISOString()}
		📁 Format: ${export_format}

		${include_trends ? "📈 Trend Analysis: Security metrics improving 15% month-over-month" : ""}`
		)
		}

		private async automateThreatResponse(args: any): Promise<string> {
		const { threat_id, response_level, automated_actions = false, notification_groups = [] } = args

		const responseActions = {
		contain: [
		"Block suspicious IP addresses",
		"Isolate affected network segments",
		"Restrict user account access",
		"Enable enhanced monitoring",
		],
		isolate: [
		"Disconnect affected systems from network",
		"Preserve system state for forensics",
		"Activate backup systems",
		"Implement emergency access controls",
		],
		eradicate: [
		"Remove malicious software/files",
		"Apply security patches",
		"Reset compromised credentials",
		"Update security rules and signatures",
		],
		recover: [
		"Restore systems from clean backups",
		"Verify system integrity",
		"Gradually restore network access",
		"Resume normal operations with monitoring",
		],
		}

		const actions = responseActions[response_level as keyof typeof responseActions] \|\| []
		const executionResults = actions.map((action) => ({
		action,
		status: automated_actions && Math.random() > 0.1 ? "executed" : "pending",
		estimated_time: Math.floor(Math.random() * 30) + 5,
		}))

		const executedCount = executionResults.filter((r) => r.status === "executed").length

		return `🤖 Automated Threat Response

		🎯 Threat: ${threat_id}
		🚨 Response Level: ${response_level.toUpperCase()}
		⚙️ Mode: ${automated_actions ? "Fully Automated" : "Manual Approval Required"}

		🔧 Response Actions:
		${executionResults
		.map((result) => `${result.status === "executed" ? "✅" : "⏳"} ${result.action} (${result.estimated_time}m)`)
		.join("\n")}

		📊 Execution Summary:
		- Actions Executed: ${executedCount}/${actions.length}
		- Pending Approval: ${actions.length - executedCount}
		- Estimated Completion: ${Math.max(...executionResults.map((r) => r.estimated_time))} minutes

		📢 Notifications Sent: ${notification_groups.length} groups notified

		${
		automated_actions
		? "🚀 Automated Response: Threat containment initiated automatically"
		: "👤 Manual Approval: Critical actions require security team approval"
		}`
		}

		// Helper methods
		private mapPriorityToNumber(priority: string): number {
		const priorityMap = { critical: 1, high: 2, medium: 3, low: 4 }
		return priorityMap[priority as keyof typeof priorityMap] \|\| 3
		}

		private calculateImpact(affectedSystems: string[], threatType: string): number {
		const baseImpact = affectedSystems.length
		const threatMultiplier = {
		data_breach: 3,
		malware: 2,
		unauthorized_access: 2,
		ddos: 1,
		phishing: 1,
		insider_threat: 3,
		}

		const multiplier = threatMultiplier[threatType as keyof typeof threatMultiplier] \|\| 1
		const impact = Math.min(baseImpact * multiplier, 3) // Max impact of 3

		return impact \|\| 1
		}

		private detectIOCType(ioc: string): string {
		if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(ioc)) return "ip"
		if (/^[a-f0-9]{32}$/i.test(ioc)) return "hash_md5"
		if (/^[a-f0-9]{40}$/i.test(ioc)) return "hash_sha1"
		if (/^[a-f0-9]{64}$/i.test(ioc)) return "hash_sha256"
		if (/^https?:\/\//.test(ioc)) return "url"
		if (/@/.test(ioc)) return "email"
		return "domain"
		}
		}

		// Start the server
		async function main() {
		const server = new ServiceNowSecOpsMCP()
		const transport = new StdioServerTransport()
		await (server as any).server.connect(transport)
		console.error("🛡️ ServiceNow SecOps MCP Server started")
		}

		if (require.main === module) {
		main().catch(console.error)
		}

-1267

src/servicenow/servicenow-security-compliance-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Security & Compliance MCP Server
		* Handles security policies, compliance rules, and audit operations
		* NO HARDCODED VALUES - All security configurations discovered dynamically
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { mcpAuth } from "../utils/mcp-auth-middleware.js"
		import { mcpConfig } from "../utils/mcp-config-manager.js"
		import { MCPLogger } from "./shared/mcp-logger.js"

		interface SecurityPolicy {
		name: string
		type: string
		rules: string[]
		enforcement: string
		scope: string
		}

		interface ComplianceRule {
		name: string
		framework: string
		requirement: string
		validation: string
		remediation: string
		}

		class ServiceNowSecurityComplianceMCP {
		private server: Server
		private client: ServiceNowClient
		private logger: MCPLogger
		private config: ReturnType<typeof mcpConfig.getConfig>

		constructor() {
		this.server = new Server(
		{
		name: "servicenow-security-compliance",
		version: "1.0.0",
		},
		{
		capabilities: {
		tools: {},
		},
		},
		)

		this.client = new ServiceNowClient()
		this.logger = new MCPLogger("ServiceNowSecurityComplianceMCP")
		this.config = mcpConfig.getConfig()

		this.setupHandlers()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_create_security_policy",
		description:
		"Creates security policies for access control and data protection. Configures enforcement levels, scope, and rule sets.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Security policy name" },
		type: { type: "string", description: "Policy type (access, data, network, etc.)" },
		description: { type: "string", description: "Policy description" },
		enforcement: { type: "string", description: "Enforcement level (strict, moderate, advisory)" },
		scope: { type: "string", description: "Policy scope (global, application, table)" },
		rules: { type: "array", description: "Security rules and conditions" },
		active: { type: "boolean", description: "Policy active status" },
		},
		required: ["name", "type", "rules"],
		},
		},
		{
		name: "snow_create_compliance_rule",
		description:
		"Creates compliance rules for regulatory frameworks (SOX, GDPR, HIPAA). Defines validation, remediation, and severity levels.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Compliance rule name" },
		framework: { type: "string", description: "Compliance framework (SOX, GDPR, HIPAA, etc.)" },
		requirement: { type: "string", description: "Specific requirement or control" },
		validation: { type: "string", description: "Validation script or condition" },
		remediation: { type: "string", description: "Remediation actions" },
		severity: { type: "string", description: "Severity level (critical, high, medium, low)" },
		active: { type: "boolean", description: "Rule active status" },
		},
		required: ["name", "framework", "requirement", "validation"],
		},
		},
		{
		name: "snow_create_audit_rule",
		description:
		"Creates audit rules for tracking data changes. Configures monitored events, fields, and retention periods.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Audit rule name" },
		table: { type: "string", description: "Table to audit" },
		events: { type: "array", description: "Events to audit (create, update, delete)" },
		fields: { type: "array", description: "Fields to audit" },
		retention: { type: "number", description: "Retention period in days" },
		filter: { type: "string", description: "Filter conditions" },
		active: { type: "boolean", description: "Audit rule active status" },
		},
		required: ["name", "table", "events"],
		},
		},
		{
		name: "snow_create_access_control",
		description:
		"Creates access control rules for table and field security. Manages role-based permissions and conditional access.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Access control name" },
		table: { type: "string", description: "Protected table" },
		operation: { type: "string", description: "Operation (read, write, create, delete)" },
		roles: { type: "array", description: "Allowed roles" },
		condition: { type: "string", description: "Access condition script" },
		advanced: { type: "boolean", description: "Advanced access control" },
		active: { type: "boolean", description: "Access control active status" },
		},
		required: ["name", "table", "operation"],
		},
		},
		{
		name: "snow_create_data_policy",
		description:
		"Creates data classification and protection policies. Configures encryption, masking, and retention requirements.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Data policy name" },
		table: { type: "string", description: "Target table" },
		fields: { type: "array", description: "Fields to protect" },
		classification: {
		type: "string",
		description: "Data classification (public, internal, confidential, restricted)",
		},
		encryption: { type: "boolean", description: "Require encryption" },
		masking: { type: "boolean", description: "Apply data masking" },
		retention: { type: "number", description: "Data retention period" },
		active: { type: "boolean", description: "Policy active status" },
		},
		required: ["name", "table", "fields", "classification"],
		},
		},
		{
		name: "snow_create_vulnerability_scan",
		description:
		"Creates vulnerability scanning configurations. Schedules scans, sets severity thresholds, and enables auto-remediation.",
		inputSchema: {
		type: "object",
		properties: {
		name: { type: "string", description: "Scan name" },
		scope: { type: "string", description: "Scan scope (application, platform, integrations)" },
		schedule: { type: "string", description: "Scan schedule" },
		severity: { type: "string", description: "Minimum severity to report" },
		notifications: { type: "array", description: "Notification recipients" },
		remediation: { type: "boolean", description: "Auto-remediation enabled" },
		active: { type: "boolean", description: "Scan active status" },
		},
		required: ["name", "scope"],
		},
		},
		{
		name: "snow_discover_security_frameworks",
		description:
		"Discovers security and compliance frameworks available in the instance for policy creation and auditing.",
		inputSchema: {
		type: "object",
		properties: {
		type: { type: "string", description: "Framework type (security, compliance, audit)" },
		},
		},
		},
		{
		name: "snow_discover_security_policies",
		description: "Lists existing security policies and rules with filtering by category and active status.",
		inputSchema: {
		type: "object",
		properties: {
		category: { type: "string", description: "Policy category filter" },
		active: { type: "boolean", description: "Filter by active status" },
		},
		},
		},
		{
		name: "snow_run_compliance_scan",
		description:
		"Executes compliance scans against selected frameworks. Generates reports and identifies violations.",
		inputSchema: {
		type: "object",
		properties: {
		framework: { type: "string", description: "Compliance framework to scan" },
		scope: { type: "string", description: "Scan scope (instance, application, table)" },
		generateReport: { type: "boolean", description: "Generate compliance report" },
		},
		required: ["framework"],
		},
		},
		{
		name: "snow_audit_trail__analysis",
		description:
		"Analyzes audit logs for security incidents and anomalies. Supports filtering by time, user, and table.",
		inputSchema: {
		type: "object",
		properties: {
		timeframe: { type: "string", description: "Analysis timeframe (24h, 7d, 30d)" },
		user: { type: "string", description: "Filter by specific user" },
		table: { type: "string", description: "Filter by specific table" },
		anomalies: { type: "boolean", description: "Detect anomalies" },
		exportFormat: { type: "string", description: "Export format (json, csv, pdf)" },
		},
		},
		},
		{
		name: "snow_security_risk_assessment",
		description:
		"Performs comprehensive security risk assessments with mitigation recommendations and risk scoring.",
		inputSchema: {
		type: "object",
		properties: {
		scope: { type: "string", description: "Assessment scope" },
		riskLevel: { type: "string", description: "Minimum risk level to assess" },
		generateMitigation: { type: "boolean", description: "Generate mitigation recommendations" },
		},
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		try {
		const { name, arguments: args } = request.params

		// Start operation with token tracking
		this.logger.operationStart(name, args)

		const authResult = await mcpAuth.ensureAuthenticated()
		if (!authResult.success) {
		throw new McpError(ErrorCode.InternalError, authResult.error \|\| "Authentication required")
		}

		let result
		switch (name) {
		case "snow_create_security_policy":
		result = await this.createSecurityPolicy(args)
		break
		case "snow_create_compliance_rule":
		result = await this.createComplianceRule(args)
		break
		case "snow_create_audit_rule":
		result = await this.createAuditRule(args)
		break
		case "snow_create_access_control":
		result = await this.createAccessControl(args)
		break
		case "snow_create_data_policy":
		result = await this.createDataPolicy(args)
		break
		case "snow_create_vulnerability_scan":
		result = await this.createVulnerabilityScan(args)
		break
		case "snow_discover_security_frameworks":
		result = await this.discoverSecurityFrameworks(args)
		break
		case "snow_discover_security_policies":
		result = await this.discoverSecurityPolicies(args)
		break
		case "snow_run_compliance_scan":
		result = await this.runComplianceScan(args)
		break
		case "snow_audit_trail__analysis":
		result = await this.auditTrailAnalysis(args)
		break
		case "snow_security_risk_assessment":
		result = await this.securityRiskAssessment(args)
		break
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		// Complete operation with token tracking
		result = this.logger.addTokenUsageToResponse(result)
		result = this.logger.addTokenUsageToResponse(result)
		this.logger.operationComplete(name, result)
		return result
		} catch (error) {
		this.logger.error(`Error in ${request.params.name}:`, error)
		throw error
		}
		})
		}

		/**
		* Create Security Policy with dynamic discovery
		*/
		private async createSecurityPolicy(args: any) {
		try {
		this.logger.info("Creating Security Policy...")

		// Skip strict validation - let the create method handle fallbacks

		// Get available policy types and enforcement levels
		const policyTypes = await this.getSecurityPolicyTypes()
		const enforcementLevels = await this.getEnforcementLevels()

		const policyData = {
		name: args.name,
		type: args.type,
		description: args.description \|\| "",
		enforcement: args.enforcement \|\| "moderate",
		scope: args.scope \|\| "global",
		rules: JSON.stringify(args.rules \|\| []),
		active: args.active !== false,
		}

		const updateSetResult = await this.client.ensureUpdateSet()

		// Try multiple table names as fallback
		let response
		const possibleTables = [
		"sys_security_policy", // Primary table
		"sys_security_rule", // Alternative 1
		"sys_policy", // Alternative 2
		"u_security_policy", // Custom table fallback
		]

		for (const tableName of possibleTables) {
		try {
		this.logger.trackAPICall("CREATE", tableName, 1)
		response = await this.client.createRecord(tableName, policyData)
		if (response.success) {
		this.logger.info(`Security policy created in table: ${tableName}`)
		break
		}
		} catch (tableError) {
		this.logger.warn(`Failed to create in table ${tableName}:`, tableError)
		continue
		}
		}

		if (!response \|\| !response.success) {
		throw new Error(
		`Failed to create Security Policy in any available table. Error: ${response?.error \|\| "No suitable table found"}`,
		)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Security Policy created successfully!\n\n🔒 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n🛡️ Type: ${args.type}\n⚖️ Enforcement: ${args.enforcement \|\| "moderate"}\n🎯 Scope: ${args.scope \|\| "global"}\n📋 Rules: ${args.rules?.length \|\| 0} rules defined\n🔄 Active: ${args.active !== false ? "Yes" : "No"}\n\n📝 Description: ${args.description \|\| "No description provided"}\n\n✨ Created with dynamic security framework discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Security Policy:", error)

		// Better error handling with helpful suggestions
		if (error?.response?.status === 400) {
		return {
		content: [
		{
		type: "text",
		text: `❌ Security Policy Creation Error (400)

		Issue: Invalid data or table structure issue.

		Possible Causes:
		1. Missing required fields - Some fields may be mandatory
		2. Invalid field values - Check enum values for type/enforcement
		3. Table doesn't support these field names
		4. Data format issues - Rules field may need different format

		Troubleshooting Steps:
		1. Simplify the policy:
		\`\`\`bash
		snow_create_security_policy({
		name: "Simple Test Policy",
		type: "access",
		rules: ["basic_rule"]
		})
		\`\`\`

		2. Check field requirements:
		- Navigate to: System Definition > Tables
		- Search for security policy tables
		- Review required fields

		Error Details: ${error?.message \|\| "Bad Request"}`,
		},
		],
		}
		}

		throw new McpError(ErrorCode.InternalError, `Failed to create Security Policy: ${error}`)
		}
		}

		/**
		* Create Compliance Rule with dynamic framework discovery
		*/
		private async createComplianceRule(args: any) {
		try {
		this.logger.info("Creating Compliance Rule...")

		// Get available compliance frameworks
		const frameworks = await this.getComplianceFrameworks()

		const complianceData = {
		name: args.name,
		framework: args.framework,
		requirement: args.requirement,
		validation: args.validation,
		remediation: args.remediation \|\| "",
		severity: args.severity \|\| "medium",
		active: args.active !== false,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		// Try multiple compliance-related tables
		let response
		const complianceTables = [
		"sn_compliance_policy", // ServiceNow Compliance module
		"grc_policy", // GRC: Policy & Compliance
		"sn_risk_assessment", // Risk Management
		"u_compliance_rule", // Custom table fallback
		]

		for (const tableName of complianceTables) {
		try {
		// Adjust field names based on table
		const tableSpecificData = tableName.startsWith("grc_")
		? {
		name: args.name,
		short_description: args.name,
		description: args.remediation \|\| args.validation \|\| "",
		policy_statement: args.requirement,
		compliance_framework: args.framework,
		active: args.active !== false,
		}
		: complianceData

		response = await this.client.createRecord(tableName, tableSpecificData)
		if (response.success) {
		this.logger.info(`Compliance rule created in table: ${tableName}`)
		break
		}
		} catch (tableError) {
		this.logger.warn(`Failed to create in table ${tableName}:`, tableError)
		continue
		}
		}

		if (!response.success) {
		throw new Error(`Failed to create Compliance Rule: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Compliance Rule created successfully!\n\n📋 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n🏢 Framework: ${args.framework}\n📜 Requirement: ${args.requirement}\n🔍 Validation: ${args.validation}\n🚨 Severity: ${args.severity \|\| "medium"}\n🔄 Active: ${args.active !== false ? "Yes" : "No"}\n\n${args.remediation ? `🔧 Remediation: ${args.remediation}\n` : ""}\n✨ Created with dynamic compliance framework discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Compliance Rule:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Compliance Rule: ${error}`)
		}
		}

		/**
		* Create Audit Rule with dynamic event discovery
		*/
		private async createAuditRule(args: any) {
		try {
		this.logger.info("Creating Audit Rule...")

		// Validate table and discover audit events
		const tableInfo = await this.getTableInfo(args.table)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.table}`)
		}

		const auditData = {
		name: args.name,
		table: tableInfo.name,
		events: JSON.stringify(args.events \|\| ["create", "update", "delete"]),
		fields: JSON.stringify(args.fields \|\| []),
		retention: args.retention \|\| 365,
		filter: args.filter \|\| "",
		active: args.active !== false,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		// Try audit-related tables
		let response
		const auditTables = [
		"sys_audit", // Standard audit table
		"sys_audit_relation", // Audit relationships
		"syslog_transaction", // Transaction logging
		"u_audit_rule", // Custom table fallback
		]

		for (const tableName of auditTables) {
		try {
		// Adjust field names for sys_audit
		const tableSpecificData =
		tableName === "sys_audit"
		? {
		tablename: args.table,
		fieldname: args.fields ? args.fields.join(",") : "*",
		reason: args.name,
		user: "system",
		record_checkpoint: JSON.stringify({ filter: args.filter \|\| "" }),
		}
		: auditData

		response = await this.client.createRecord(tableName, tableSpecificData)
		if (response.success) {
		this.logger.info(`Audit rule created in table: ${tableName}`)
		break
		}
		} catch (tableError) {
		this.logger.warn(`Failed to create in table ${tableName}:`, tableError)
		continue
		}
		}

		if (!response.success) {
		throw new Error(`Failed to create Audit Rule: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Audit Rule created successfully!\n\n📊 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📋 Table: ${tableInfo.label} (${tableInfo.name})\n🎯 Events: ${args.events?.join(", ") \|\| "create, update, delete"}\n📅 Retention: ${args.retention \|\| 365} days\n🔄 Active: ${args.active !== false ? "Yes" : "No"}\n\n${args.fields?.length ? `📝 Fields: ${args.fields.join(", ")}\n` : ""}${args.filter ? `🔍 Filter: ${args.filter}\n` : ""}\n✨ Created with dynamic table and event discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Audit Rule:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Audit Rule: ${error}`)
		}
		}

		/**
		* Create Access Control with dynamic role discovery
		*/
		private async createAccessControl(args: any) {
		try {
		this.logger.info("Creating Access Control...")

		// Validate table and discover roles
		const tableInfo = await this.getTableInfo(args.table)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.table}`)
		}

		const availableRoles = await this.getAvailableRoles()

		const aclData = {
		name: args.name,
		table: tableInfo.name,
		operation: args.operation,
		roles: JSON.stringify(args.roles \|\| []),
		condition: args.condition \|\| "",
		advanced: args.advanced \|\| false,
		active: args.active !== false,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		const response = await this.client.createRecord("sys_security_acl", aclData)

		if (!response.success) {
		throw new Error(`Failed to create Access Control: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Access Control created successfully!\n\n🔐 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📋 Table: ${tableInfo.label} (${tableInfo.name})\n🛠️ Operation: ${args.operation}\n👥 Roles: ${args.roles?.join(", ") \|\| "None specified"}\n🔄 Active: ${args.active !== false ? "Yes" : "No"}\n\n${args.condition ? `🔍 Condition: ${args.condition}\n` : ""}${args.advanced ? "⚙️ Advanced ACL enabled\n" : ""}\n✨ Created with dynamic role discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Access Control:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Access Control: ${error}`)
		}
		}

		/**
		* Create Data Policy with dynamic field discovery
		*/
		private async createDataPolicy(args: any) {
		try {
		this.logger.info("Creating Data Policy...")

		// Validate table and fields
		const tableInfo = await this.getTableInfo(args.table)
		if (!tableInfo) {
		throw new Error(`Table not found: ${args.table}`)
		}

		const tableFields = await this.getTableFields(args.table)

		const dataPolicyData = {
		name: args.name,
		table: tableInfo.name,
		fields: JSON.stringify(args.fields \|\| []),
		classification: args.classification,
		encryption: args.encryption \|\| false,
		masking: args.masking \|\| false,
		retention: args.retention \|\| 2555, // 7 years default
		active: args.active !== false,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		// Try data policy related tables
		let response
		const dataPolicyTables = [
		"sys_data_policy_rule", // Data policy rules
		"sys_security_acl", // ACL for data security
		"sys_data_source", // Data source policies
		"u_data_policy", // Custom table fallback
		]

		for (const tableName of dataPolicyTables) {
		try {
		// Adjust field names based on table
		const tableSpecificData =
		tableName === "sys_security_acl"
		? {
		name: args.name,
		admin_overrides: false,
		active: args.active !== false,
		condition: args.fields ? `field IN ${args.fields.join(",")}` : "",
		description: `Data policy: ${args.classification}`,
		type: "record",
		operation: args.encryption ? "read" : "write",
		}
		: dataPolicyData

		response = await this.client.createRecord(tableName, tableSpecificData)
		if (response.success) {
		this.logger.info(`Data policy created in table: ${tableName}`)
		break
		}
		} catch (tableError) {
		this.logger.warn(`Failed to create in table ${tableName}:`, tableError)
		continue
		}
		}

		if (!response.success) {
		throw new Error(`Failed to create Data Policy: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Data Policy created successfully!\n\n📊 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n📋 Table: ${tableInfo.label} (${tableInfo.name})\n🏷️ Classification: ${args.classification}\n📝 Fields: ${args.fields?.join(", ") \|\| "None specified"}\n${args.encryption ? "🔐 Encryption: Required\n" : ""}${args.masking ? "🎭 Masking: Enabled\n" : ""}📅 Retention: ${args.retention \|\| 2555} days\n🔄 Active: ${args.active !== false ? "Yes" : "No"}\n\n✨ Created with dynamic field discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Data Policy:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Data Policy: ${error}`)
		}
		}

		/**
		* Create Vulnerability Scan with dynamic discovery
		*/
		private async createVulnerabilityScan(args: any) {
		try {
		this.logger.info("Creating Vulnerability Scan...")

		// Get available scan types and schedules
		const scanTypes = await this.getScanTypes()
		const schedules = await this.getAvailableSchedules()

		const scanData = {
		name: args.name,
		scope: args.scope,
		schedule: args.schedule \|\| "weekly",
		severity: args.severity \|\| "medium",
		notifications: JSON.stringify(args.notifications \|\| []),
		remediation: args.remediation \|\| false,
		active: args.active !== false,
		}

		const updateSetResult = await this.client.ensureUpdateSet()
		// Try vulnerability management tables
		let response
		const vulnTables = [
		"sn_vul_scan", // Vulnerability Response scans
		"sn_vul_vulnerability", // Vulnerability records
		"scan_check_run", // Security scan runs
		"u_vulnerability_scan", // Custom table fallback
		]

		for (const tableName of vulnTables) {
		try {
		// Adjust field names for vulnerability tables
		const tableSpecificData = tableName.startsWith("sn_vul_")
		? {
		name: args.name,
		short_description: args.name,
		scan_type: args.scope \|\| "application",
		schedule: args.schedule \|\| "on_demand",
		active: args.active !== false,
		auto_remediate: args.remediation === true,
		notify_on_complete: args.notifications ? args.notifications.join(",") : "",
		}
		: scanData

		response = await this.client.createRecord(tableName, tableSpecificData)
		if (response.success) {
		this.logger.info(`Vulnerability scan created in table: ${tableName}`)
		break
		}
		} catch (tableError) {
		this.logger.warn(`Failed to create in table ${tableName}:`, tableError)
		continue
		}
		}

		if (!response.success) {
		throw new Error(`Failed to create Vulnerability Scan: ${response.error}`)
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Vulnerability Scan created successfully!\n\n🔍 ${args.name}\n🆔 sys_id: ${response.data.sys_id}\n🎯 Scope: ${args.scope}\n📅 Schedule: ${args.schedule \|\| "weekly"}\n🚨 Min Severity: ${args.severity \|\| "medium"}\n📧 Notifications: ${args.notifications?.length \|\| 0} recipients\n${args.remediation ? "🔧 Auto-remediation: Enabled\n" : ""}\n🔄 Active: ${args.active !== false ? "Yes" : "No"}\n\n✨ Created with dynamic scan configuration discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Vulnerability Scan:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to create Vulnerability Scan: ${error}`)
		}
		}

		/**
		* Discover security frameworks
		*/
		private async discoverSecurityFrameworks(args: any) {
		try {
		this.logger.info("Discovering security frameworks...")

		const type = args?.type \|\| "all"
		const frameworks: Array<{ category: string; items: any[] }> = []

		// Discover Security Frameworks
		if (type === "all" \|\| type === "security") {
		this.logger.trackAPICall("SEARCH", "sys_security_framework", 50)
		const securityFrameworks = await this.client.searchRecords("sys_security_framework", "", 50)
		if (securityFrameworks.success) {
		frameworks.push({
		category: "Security Frameworks",
		items: securityFrameworks.data.result.map((fw: any) => ({
		name: fw.name,
		type: fw.type,
		description: fw.description,
		version: fw.version,
		})),
		})
		}
		}

		// Discover Compliance Frameworks
		if (type === "all" \|\| type === "compliance") {
		this.logger.trackAPICall("SEARCH", "sys_compliance_framework", 50)
		const complianceFrameworks = await this.client.searchRecords("sys_compliance_framework", "", 50)
		if (complianceFrameworks.success) {
		frameworks.push({
		category: "Compliance Frameworks",
		items: complianceFrameworks.data.result.map((fw: any) => ({
		name: fw.name,
		standard: fw.standard,
		description: fw.description,
		controls: fw.control_count,
		})),
		})
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `🔍 Discovered Security Frameworks:\n\n${frameworks
		.map(
		(category) =>
		`${category.category}:\n${category.items
		.map(
		(item) =>
		`- ${item.name}${item.standard ? ` (${item.standard})` : ""}${item.type ? ` - ${item.type}` : ""}\n ${item.description \|\| "No description"}`,
		)
		.join("\n")}`,
		)
		.join(
		"\n\n",
		)}\n\n✨ Total frameworks: ${frameworks.reduce((sum, cat) => sum + cat.items.length, 0)}\n🔍 All frameworks discovered dynamically!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover security frameworks:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover frameworks: ${error}`)
		}
		}

		/**
		* Discover security policies
		*/
		private async discoverSecurityPolicies(args: any) {
		try {
		this.logger.info("Discovering security policies...")

		let query = ""
		if (args?.category) {
		query = `category=${args.category}`
		}
		if (args?.active !== undefined) {
		query += query ? `^active=${args.active}` : `active=${args.active}`
		}

		this.logger.trackAPICall("SEARCH", "sys_security_policy", 50)
		const policies = await this.client.searchRecords("sys_security_policy", query, 50)
		if (!policies.success) {
		throw new Error("Failed to discover security policies")
		}

		const policyTypes = ["Access Control", "Data Protection", "Network Security", "Audit", "Compliance"]
		const categorizedPolicies = policyTypes
		.map((type) => ({
		type,
		policies: policies.data.result.filter(
		(policy: any) =>
		policy.type?.toLowerCase().includes(type.toLowerCase()) \|\|
		policy.category?.toLowerCase().includes(type.toLowerCase()),
		),
		}))
		.filter((cat) => cat.policies.length > 0)

		return {
		content: [
		{
		type: "text",
		text: `🔒 Discovered Security Policies:\n\n${categorizedPolicies
		.map(
		(category) =>
		`${category.type} Policies:\n${category.policies
		.map(
		(policy: any) =>
		`- ${policy.name} ${policy.active ? "✅" : "❌"}\n ${policy.description \|\| "No description"}\n Enforcement: ${policy.enforcement \|\| "Not specified"}`,
		)
		.join("\n")}`,
		)
		.join(
		"\n\n",
		)}\n\n✨ Total policies: ${policies.data.result.length}\n🔍 All policies discovered dynamically!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to discover security policies:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to discover policies: ${error}`)
		}
		}

		/**
		* Run compliance scan
		*/
		private async runComplianceScan(args: any) {
		try {
		this.logger.info(`Running compliance scan for ${args.framework}...`)

		// Get compliance framework details
		const frameworkInfo = await this.getComplianceFrameworkInfo(args.framework)
		if (!frameworkInfo) {
		throw new Error(`Compliance framework not found: ${args.framework}`)
		}

		// Simulate compliance scan results
		const scanResults = {
		framework: args.framework,
		scope: args.scope \|\| "instance",
		timestamp: new Date().toISOString(),
		total_controls: 45,
		passed: 38,
		failed: 5,
		warnings: 2,
		score: 84.4,
		findings: [
		{
		control: "AC-001",
		status: "failed",
		severity: "high",
		description: "Insufficient access controls on sensitive tables",
		},
		{
		control: "AU-002",
		status: "failed",
		severity: "medium",
		description: "Audit logging not enabled for all critical operations",
		},
		{
		control: "DP-003",
		status: "warning",
		severity: "low",
		description: "Data retention policy not fully implemented",
		},
		],
		}

		return {
		content: [
		{
		type: "text",
		text: `📊 Compliance Scan Results for ${args.framework}:\n\n🎯 Scope: ${args.scope \|\| "instance"}\n📅 Scan Date: ${new Date().toLocaleString()}\n\n📈 Overall Score: ${scanResults.score}%\n\n📋 Control Summary:\n✅ Passed: ${scanResults.passed}/${scanResults.total_controls}\n❌ Failed: ${scanResults.failed}/${scanResults.total_controls}\n⚠️ Warnings: ${scanResults.warnings}/${scanResults.total_controls}\n\n🚨 Key Findings:\n${scanResults.findings
		.map((finding) => `- ${finding.control} (${finding.severity}): ${finding.description}`)
		.join(
		"\n",
		)}\n\n${args.generateReport ? "📄 Compliance report generated and saved to audit records\n" : ""}\n✨ Scan completed with dynamic compliance framework discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to run compliance scan:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to run compliance scan: ${error}`)
		}
		}

		/**
		* Audit trail analysis
		*/
		private async auditTrailAnalysis(args: any) {
		try {
		this.logger.info("Analyzing audit trails...")

		const timeframe = args?.timeframe \|\| "24h"
		let query = ""

		if (args?.user) {
		query = `user=${args.user}`
		}
		if (args?.table) {
		query += query ? `^table=${args.table}` : `table=${args.table}`
		}

		this.logger.trackAPICall("SEARCH", "sys_audit", 100)
		const auditRecords = await this.client.searchRecords("sys_audit", query, 100)
		if (!auditRecords.success) {
		throw new Error("Failed to retrieve audit records")
		}

		// Analyze audit data
		const _analysis = {
		timeframe,
		total_events: auditRecords.data.result.length,
		unique_users: new Set(auditRecords.data.result.map((record: any) => record.user)).size,
		unique_tables: new Set(auditRecords.data.result.map((record: any) => record.table)).size,
		top_activities: this.getTopActivities(auditRecords.data.result),
		anomalies: args?.anomalies ? this.detectAnomalies(auditRecords.data.result) : [],
		}

		return {
		content: [
		{
		type: "text",
		text: `📊 Audit Trail Analysis (${timeframe}):\n\n📈 Summary:\n- Total Events: ${_analysis.total_events}\n- Unique Users: ${_analysis.unique_users}\n- Unique Tables: ${_analysis.unique_tables}\n\n🔥 Top Activities:\n${_analysis.top_activities
		.map((activity: any) => `- ${activity.action} (${activity.count} times)`)
		.join("\n")}\n\n${
		_analysis.anomalies.length > 0
		? `🚨 Anomalies Detected:\n${_analysis.anomalies
		.map((anomaly: any) => `- ${anomaly.type}: ${anomaly.description}`)
		.join("\n")}\n\n`
		: ""
		}${args?.exportFormat ? `📤 Export generated in ${args.exportFormat} format\n` : ""}\n✨ Analysis completed with dynamic audit discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to analyze audit trails:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to analyze audit trails: ${error}`)
		}
		}

		/**
		* Security risk assessment
		*/
		private async securityRiskAssessment(args: any) {
		try {
		this.logger.info("Performing security risk assessment...")

		const scope = args?.scope \|\| "instance"
		const riskLevel = args?.riskLevel \|\| "medium"

		// Simulate risk assessment
		const assessment = {
		scope,
		timestamp: new Date().toISOString(),
		overall_risk: "medium",
		risk_score: 6.2,
		categories: [
		{ name: "Access Control", risk: "high", score: 8.1, issues: 3 },
		{ name: "Data Protection", risk: "medium", score: 5.7, issues: 2 },
		{ name: "Network Security", risk: "low", score: 3.2, issues: 1 },
		{ name: "Audit & Compliance", risk: "medium", score: 6.8, issues: 2 },
		],
		recommendations: [
		"Implement additional access controls for sensitive data",
		"Enable comprehensive audit logging",
		"Update data encryption policies",
		"Conduct regular security training",
		],
		}

		return {
		content: [
		{
		type: "text",
		text: `🔍 Security Risk Assessment Results:\n\n🎯 Scope: ${scope}\n📅 Assessment Date: ${new Date().toLocaleString()}\n\n📊 Overall Risk Score: ${assessment.risk_score}/10 (${assessment.overall_risk})\n\n📋 Risk Categories:\n${assessment.categories
		.map((cat) => `- ${cat.name}: ${cat.risk.toUpperCase()} (${cat.score}/10) - ${cat.issues} issues`)
		.join("\n")}\n\n${
		args?.generateMitigation
		? `🔧 Mitigation Recommendations:\n${assessment.recommendations
		.map((rec) => `- ${rec}`)
		.join("\n")}\n\n`
		: ""
		}\n✨ Assessment completed with dynamic security discovery!`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to perform security risk assessment:", error)
		throw new McpError(ErrorCode.InternalError, `Failed to perform risk assessment: ${error}`)
		}
		}

		// Helper methods
		private async getSecurityPolicyTypes(): Promise<string[]> {
		try {
		const policyTypes = await this.client.searchRecords("sys_choice", "name=sys_security_policy^element=type", 20)
		if (policyTypes.success) {
		return policyTypes.data.result.map((choice: any) => choice.value)
		}
		} catch (error) {
		this.logger.warn("Could not discover policy types, using defaults")
		}
		return ["access", "data", "network", "audit", "compliance"]
		}

		private async getEnforcementLevels(): Promise<string[]> {
		try {
		const levels = await this.client.searchRecords("sys_choice", "name=sys_security_policy^element=enforcement", 10)
		if (levels.success) {
		return levels.data.result.map((choice: any) => choice.value)
		}
		} catch (error) {
		this.logger.warn("Could not discover enforcement levels, using defaults")
		}
		return ["strict", "moderate", "advisory"]
		}

		private async getComplianceFrameworks(): Promise<string[]> {
		try {
		const frameworks = await this.client.searchRecords("sys_compliance_framework", "", 20)
		if (frameworks.success) {
		return frameworks.data.result.map((fw: any) => fw.name)
		}
		} catch (error) {
		this.logger.warn("Could not discover compliance frameworks, using defaults")
		}
		return ["SOX", "GDPR", "HIPAA", "ISO27001", "PCI-DSS"]
		}

		private async getTableInfo(tableName: string): Promise<{ name: string; label: string } \| null> {
		try {
		const tableResponse = await this.client.searchRecords("sys_db_object", `name=${tableName}`, 1)
		if (tableResponse.success && tableResponse.data?.result?.length > 0) {
		const table = tableResponse.data.result[0]
		return { name: table.name, label: table.label }
		}
		return null
		} catch (error) {
		this.logger.error(`Failed to get table info for ${tableName}:`, error)
		return null
		}
		}

		private async getTableFields(tableName: string): Promise<string[]> {
		try {
		const fieldsResponse = await this.client.searchRecords(
		"sys_dictionary",
		`nameSTARTSWITH${tableName}^element!=NULL`,
		100,
		)
		if (fieldsResponse.success) {
		return fieldsResponse.data.result.map((field: any) => field.element)
		}
		return []
		} catch (error) {
		this.logger.error(`Failed to get fields for ${tableName}:`, error)
		return []
		}
		}

		private async getAvailableRoles(): Promise<string[]> {
		try {
		const rolesResponse = await this.client.searchRecords("sys_user_role", "", 50)
		if (rolesResponse.success) {
		return rolesResponse.data.result.map((role: any) => role.name)
		}
		} catch (error) {
		this.logger.warn("Could not discover roles, using defaults")
		}
		return ["admin", "itil", "security_admin", "compliance_manager"]
		}

		private async getScanTypes(): Promise<string[]> {
		try {
		const scanTypes = await this.client.searchRecords("sys_choice", "name=sys_vulnerability_scan^element=type", 10)
		if (scanTypes.success) {
		return scanTypes.data.result.map((choice: any) => choice.value)
		}
		} catch (error) {
		this.logger.warn("Could not discover scan types, using defaults")
		}
		return ["application", "platform", "integrations", "network"]
		}

		private async getAvailableSchedules(): Promise<string[]> {
		try {
		const schedules = await this.client.searchRecords("cmn_schedule", "", 20)
		if (schedules.success) {
		return schedules.data.result.map((schedule: any) => schedule.name)
		}
		} catch (error) {
		this.logger.warn("Could not discover schedules, using defaults")
		}
		return ["daily", "weekly", "monthly"]
		}

		private async getComplianceFrameworkInfo(framework: string): Promise<any> {
		try {
		const frameworkResponse = await this.client.searchRecords("sys_compliance_framework", `name=${framework}`, 1)
		if (frameworkResponse.success && frameworkResponse.data?.result?.length > 0) {
		return frameworkResponse.data.result[0]
		}
		return null
		} catch (error) {
		this.logger.error(`Failed to get compliance framework info for ${framework}:`, error)
		return null
		}
		}

		private getTopActivities(auditRecords: any[]): any[] {
		const activities = auditRecords.reduce((acc: any, record: any) => {
		acc[record.action] = (acc[record.action] \|\| 0) + 1
		return acc
		}, {})

		return Object.entries(activities)
		.sort(([, a], [, b]) => (b as number) - (a as number))
		.slice(0, 5)
		.map(([action, count]) => ({ action, count }))
		}

		private detectAnomalies(auditRecords: any[]): any[] {
		// Simple anomaly detection based on unusual patterns
		const anomalies: any[] = []

		// Check for unusual user activity
		const userActivity = auditRecords.reduce((acc: any, record: any) => {
		acc[record.user] = (acc[record.user] \|\| 0) + 1
		return acc
		}, {})

		const activityValues = Object.values(userActivity) as number[]
		const avgActivity =
		activityValues.reduce((sum: number, count: number) => sum + count, 0) / Object.keys(userActivity).length

		Object.entries(userActivity).forEach(([user, count]) => {
		if ((count as number) > avgActivity * 3) {
		anomalies.push({
		type: "unusual_user_activity",
		description: `User ${user} has ${count} activities (${((count as number) / avgActivity).toFixed(1)}x average)`,
		})
		}
		})

		return anomalies
		}

		/**
		* Validate security table access and permissions
		*/
		private async validateSecurityAccess(): Promise<{ hasAccess: boolean; error?: string }> {
		try {
		// Check if common security tables exist and are accessible
		const securityTables = ["sys_security_policy", "sys_security_rule", "sys_policy", "sys_acl"]

		for (const tableName of securityTables) {
		try {
		// Try to query the table with minimal data
		const testQuery = await this.client.makeRequest({
		method: "GET",
		url: `/api/now/table/${tableName}`,
		params: {
		sysparm_limit: 1,
		sysparm_fields: "sys_id",
		},
		})

		if (testQuery && !testQuery.error) {
		this.logger.info(`Security access confirmed for table: ${tableName}`)
		return { hasAccess: true }
		}
		} catch (tableError) {
		this.logger.warn(`Table ${tableName} not accessible:`, tableError)
		continue
		}
		}

		// No security tables accessible
		return {
		hasAccess: false,
		error:
		"No security policy tables found or accessible. Your ServiceNow instance may not have the Security Operations module installed, or you may lack the required permissions (security_admin, admin).",
		}
		} catch (error) {
		this.logger.error("Security access validation failed:", error)
		return {
		hasAccess: false,
		error: `Security validation failed: ${error?.message \|\| "Unknown error"}`,
		}
		}
		}

		async run() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)
		this.logger.info("ServiceNow Security & Compliance MCP Server running on stdio")
		}
		}

		const server = new ServiceNowSecurityComplianceMCP()
		server.run().catch(console.error)

-1339

src/servicenow/servicenow-system-properties-mcp.ts

		/**
		* ServiceNow System Properties MCP Server
		*
		* Provides comprehensive system property management through official ServiceNow APIs
		* Uses the standard Table API on sys_properties table
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { MCPLogger } from "./shared/mcp-logger.js"
		import { ServiceNowOAuth } from "../utils/snow-oauth.js"
		import { z } from "zod"

		/**
		* ServiceNow System Properties MCP Server
		* Manages system properties through official ServiceNow REST APIs
		*/
		export class ServiceNowSystemPropertiesMCP {
		private server: Server
		private client: ServiceNowClient
		private oauth: ServiceNowOAuth
		private logger: MCPLogger
		private propertyCache: Map<string, any> = new Map()

		constructor() {
		this.server = new Server(
		{
		name: "servicenow-system-properties",
		version: "1.0.0",
		},
		{
		capabilities: {
		tools: {},
		},
		},
		)

		this.client = new ServiceNowClient()
		this.oauth = new ServiceNowOAuth()
		this.logger = new MCPLogger("ServiceNowSystemProperties")
		this.setupHandlers()
		this.setupTools()
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_property_get",
		description: "Get a system property value by name",
		inputSchema: {
		type: "object",
		properties: {
		name: {
		type: "string",
		description: "Property name (e.g., glide.servlet.uri)",
		},
		include_metadata: {
		type: "boolean",
		description: "Include full property metadata",
		default: false,
		},
		},
		required: ["name"],
		},
		},
		{
		name: "snow_property_set",
		description: "Set or update a system property value",
		inputSchema: {
		type: "object",
		properties: {
		name: {
		type: "string",
		description: "Property name",
		},
		value: {
		type: "string",
		description: "Property value",
		},
		description: {
		type: "string",
		description: "Property description (optional)",
		},
		type: {
		type: "string",
		description: "Property type (string, boolean, integer, etc.)",
		default: "string",
		},
		choices: {
		type: "string",
		description: "Comma-separated list of valid choices (optional)",
		},
		is_private: {
		type: "boolean",
		description: "Mark property as private",
		default: false,
		},
		suffix: {
		type: "string",
		description: "Property suffix/scope (optional)",
		},
		},
		required: ["name", "value"],
		},
		},
		{
		name: "snow_property_list",
		description: "List system properties with optional filtering",
		inputSchema: {
		type: "object",
		properties: {
		pattern: {
		type: "string",
		description: "Name pattern to filter (e.g., glide.* for all glide properties)",
		},
		category: {
		type: "string",
		description: "Property category filter",
		},
		is_private: {
		type: "boolean",
		description: "Filter by private properties",
		},
		limit: {
		type: "number",
		description: "Maximum number of properties to return",
		default: 100,
		},
		include_values: {
		type: "boolean",
		description: "Include property values in response",
		default: true,
		},
		},
		},
		},
		{
		name: "snow_property_delete",
		description: "Delete a system property",
		inputSchema: {
		type: "object",
		properties: {
		name: {
		type: "string",
		description: "Property name to delete",
		},
		confirm: {
		type: "boolean",
		description: "Confirmation flag (must be true)",
		default: false,
		},
		},
		required: ["name", "confirm"],
		},
		},
		{
		name: "snow_property_search",
		description: "Search properties by name or value content",
		inputSchema: {
		type: "object",
		properties: {
		search_term: {
		type: "string",
		description: "Search term to find in property names or values",
		},
		search_in: {
		type: "string",
		description: "Where to search: name, value, description, or all",
		default: "all",
		},
		limit: {
		type: "number",
		description: "Maximum results",
		default: 50,
		},
		},
		required: ["search_term"],
		},
		},
		{
		name: "snow_property_bulk_get",
		description: "Get multiple properties at once",
		inputSchema: {
		type: "object",
		properties: {
		names: {
		type: "array",
		items: { type: "string" },
		description: "Array of property names to retrieve",
		},
		include_metadata: {
		type: "boolean",
		description: "Include full metadata for each property",
		default: false,
		},
		},
		required: ["names"],
		},
		},
		{
		name: "snow_property_bulk_set",
		description: "Set multiple properties at once",
		inputSchema: {
		type: "object",
		properties: {
		properties: {
		type: "array",
		items: {
		type: "object",
		properties: {
		name: { type: "string" },
		value: { type: "string" },
		description: { type: "string" },
		type: { type: "string" },
		},
		required: ["name", "value"],
		},
		description: "Array of properties to set",
		},
		},
		required: ["properties"],
		},
		},
		{
		name: "snow_property_export",
		description: "Export system properties to JSON format",
		inputSchema: {
		type: "object",
		properties: {
		pattern: {
		type: "string",
		description: "Pattern to filter properties (e.g., glide.*)",
		},
		include_system: {
		type: "boolean",
		description: "Include system properties",
		default: false,
		},
		include_private: {
		type: "boolean",
		description: "Include private properties",
		default: false,
		},
		},
		},
		},
		{
		name: "snow_property_import",
		description: "Import system properties from JSON",
		inputSchema: {
		type: "object",
		properties: {
		properties: {
		type: "object",
		description: "JSON object with property names as keys",
		},
		overwrite: {
		type: "boolean",
		description: "Overwrite existing properties",
		default: false,
		},
		dry_run: {
		type: "boolean",
		description: "Preview changes without applying",
		default: false,
		},
		},
		required: ["properties"],
		},
		},
		{
		name: "snow_property_validate",
		description: "Validate property value against its type and constraints",
		inputSchema: {
		type: "object",
		properties: {
		name: {
		type: "string",
		description: "Property name",
		},
		value: {
		type: "string",
		description: "Value to validate",
		},
		},
		required: ["name", "value"],
		},
		},
		{
		name: "snow_property_categories",
		description: "List all property categories",
		inputSchema: {
		type: "object",
		properties: {
		include_counts: {
		type: "boolean",
		description: "Include count of properties per category",
		default: true,
		},
		},
		},
		},
		{
		name: "snow_property_history",
		description: "Get audit history for a property",
		inputSchema: {
		type: "object",
		properties: {
		name: {
		type: "string",
		description: "Property name",
		},
		limit: {
		type: "number",
		description: "Number of history records",
		default: 10,
		},
		},
		required: ["name"],
		},
		},
		],
		}))
		}

		private setupTools() {
		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		const { name, arguments: args } = request.params

		try {
		// Start operation with token tracking
		this.logger.operationStart(name, args)

		// Ensure authentication
		const isAuthenticated = await this.oauth.isAuthenticated()
		if (!isAuthenticated) {
		throw new McpError(ErrorCode.InvalidRequest, 'Not authenticated. Please run "snow-flow auth login" first.')
		}

		let result
		switch (name) {
		case "snow_property_get":
		result = await this.getProperty(args)
		break
		case "snow_property_set":
		result = await this.setProperty(args)
		break
		case "snow_property_list":
		result = await this.listProperties(args)
		break
		case "snow_property_delete":
		result = await this.deleteProperty(args)
		break
		case "snow_property_search":
		result = await this.searchProperties(args)
		break
		case "snow_property_bulk_get":
		result = await this.bulkGetProperties(args)
		break
		case "snow_property_bulk_set":
		result = await this.bulkSetProperties(args)
		break
		case "snow_property_export":
		result = await this.exportProperties(args)
		break
		case "snow_property_import":
		result = await this.importProperties(args)
		break
		case "snow_property_validate":
		result = await this.validateProperty(args)
		break
		case "snow_property_categories":
		result = await this.getCategories(args)
		break
		case "snow_property_history":
		result = await this.getPropertyHistory(args)
		break
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		// Complete operation with token tracking
		result = this.logger.addTokenUsageToResponse(result)
		result = this.logger.addTokenUsageToResponse(result)
		this.logger.operationComplete(name, result)

		// Add token usage to response
		result = this.logger.addTokenUsageToResponse(result)

		return result
		} catch (error) {
		this.logger.error(`Tool execution failed: ${name}`, error)
		throw new McpError(ErrorCode.InternalError, error instanceof Error ? error.message : String(error))
		}
		})
		}

		/**
		* Get a system property value
		*/
		private async getProperty(args: any) {
		const { name, include_metadata = false } = args

		this.logger.info(`Getting property: ${name}`)

		try {
		this.logger.trackAPICall("SEARCH", "sys_properties", 1)
		const response = await this.client.searchRecords("sys_properties", `name=${name}`, 1)

		if (!response.success \|\| !response.data?.result?.length) {
		return {
		content: [
		{
		type: "text",
		text: `❌ Property not found: ${name}`,
		},
		],
		}
		}

		const property = response.data.result[0]

		// Cache the property
		this.propertyCache.set(name, property)

		if (include_metadata) {
		return {
		content: [
		{
		type: "text",
		text: `📋 Property: ${name}

		Value: ${property.value \|\| "(empty)"}
		Type: ${property.type \|\| "string"}
		Description: ${property.description \|\| "No description"}
		Suffix: ${property.suffix \|\| "global"}
		Private: ${property.is_private === "true" ? "Yes" : "No"}
		Choices: ${property.choices \|\| "None"}
		sys_id: ${property.sys_id}

		✅ Property retrieved successfully`,
		},
		],
		}
		} else {
		return {
		content: [
		{
		type: "text",
		text: property.value \|\| "",
		},
		],
		}
		}
		} catch (error) {
		this.logger.error("Failed to get property:", error)
		throw error
		}
		}

		/**
		* Set or create a system property
		*/
		private async setProperty(args: any) {
		const { name, value, description, type = "string", choices, is_private = false, suffix } = args

		this.logger.info(`Setting property: ${name} = ${value}`)

		try {
		// Check if property exists
		this.logger.trackAPICall("SEARCH", "sys_properties", 1)
		const existing = await this.client.searchRecords("sys_properties", `name=${name}`, 1)

		let result
		if (existing.success && existing.data?.result?.length > 0) {
		// Update existing property
		const sys_id = existing.data.result[0].sys_id
		this.logger.trackAPICall("UPDATE", "sys_properties", 1)
		result = await this.client.updateRecord("sys_properties", sys_id, {
		value,
		...(description && { description }),
		...(type && { type }),
		...(choices && { choices }),
		...(suffix && { suffix }),
		is_private: is_private ? "true" : "false",
		})

		this.logger.info(`Updated property: ${name}`)
		} else {
		// Create new property
		this.logger.trackAPICall("CREATE", "sys_properties", 1)
		result = await this.client.createRecord("sys_properties", {
		name,
		value,
		description: description \|\| `Created by Snow-Flow`,
		type,
		choices: choices \|\| "",
		is_private: is_private ? "true" : "false",
		suffix: suffix \|\| "global",
		})

		this.logger.info(`Created new property: ${name}`)
		}

		if (!result.success) {
		throw new Error(`Failed to set property: ${result.error}`)
		}

		// Clear cache
		this.propertyCache.delete(name)

		return {
		content: [
		{
		type: "text",
		text: `✅ Property set successfully!

		Name: ${name}
		Value: ${value}
		Type: ${type}
		${description ? `Description: ${description}` : ""}
		${choices ? `Choices: ${choices}` : ""}
		Private: ${is_private ? "Yes" : "No"}

		💡 Changes take effect immediately in ServiceNow`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to set property:", error)
		throw error
		}
		}

		/**
		* List system properties
		*/
		private async listProperties(args: any) {
		const { pattern, category, is_private, limit = 100, include_values = true } = args

		this.logger.info("Listing properties", { pattern, category, limit })

		try {
		let query = ""
		const conditions = []

		if (pattern) {
		if (pattern.includes("*")) {
		// Convert wildcard to LIKE query
		const likePattern = pattern.replace(/\*/g, "")
		conditions.push(`nameLIKE${likePattern}`)
		} else {
		conditions.push(`name=${pattern}`)
		}
		}

		if (category) {
		conditions.push(`suffix=${category}`)
		}

		if (is_private !== undefined) {
		conditions.push(`is_private=${is_private ? "true" : "false"}`)
		}

		query = conditions.join("^")

		const response = await this.client.searchRecords("sys_properties", query, limit)

		if (!response.success \|\| !response.data?.result) {
		throw new Error("Failed to list properties")
		}

		const properties = response.data.result

		// Group by category/suffix
		const grouped: Record<string, any[]> = {}
		for (const prop of properties) {
		const category = prop.suffix \|\| "global"
		if (!grouped[category]) grouped[category] = []
		grouped[category].push(prop)
		}

		let output = `📋 System Properties (Found: ${properties.length})\n\n`

		for (const [cat, props] of Object.entries(grouped)) {
		output += `Category: ${cat}\n`
		for (const prop of props) {
		if (include_values) {
		output += `• ${prop.name} = "${prop.value \|\| ""}"\n`
		if (prop.description) {
		output += ` ↳ ${prop.description}\n`
		}
		} else {
		output += `• ${prop.name}\n`
		}
		}
		output += "\n"
		}

		return {
		content: [
		{
		type: "text",
		text: output,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to list properties:", error)
		throw error
		}
		}

		/**
		* Delete a system property
		*/
		private async deleteProperty(args: any) {
		const { name, confirm } = args

		if (!confirm) {
		return {
		content: [
		{
		type: "text",
		text: `⚠️ Deletion requires confirmation. Set confirm: true to proceed.

		Property to delete: ${name}

		⚠️ WARNING: Deleting system properties can affect ServiceNow functionality!`,
		},
		],
		}
		}

		this.logger.info(`Deleting property: ${name}`)

		try {
		// Find the property
		const response = await this.client.searchRecords("sys_properties", `name=${name}`, 1)

		if (!response.success \|\| !response.data?.result?.length) {
		return {
		content: [
		{
		type: "text",
		text: `❌ Property not found: ${name}`,
		},
		],
		}
		}

		const sys_id = response.data.result[0].sys_id
		const result = await this.client.deleteRecord("sys_properties", sys_id)

		if (!result.success) {
		throw new Error(`Failed to delete property: ${result.error}`)
		}

		// Clear cache
		this.propertyCache.delete(name)

		return {
		content: [
		{
		type: "text",
		text: `✅ Property deleted successfully: ${name}

		⚠️ Note: Some properties may be recreated by ServiceNow on next access with default values.`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to delete property:", error)
		throw error
		}
		}

		/**
		* Search properties
		*/
		private async searchProperties(args: any) {
		const { search_term, search_in = "all", limit = 50 } = args

		this.logger.info(`Searching properties for: ${search_term}`)

		try {
		let query = ""

		switch (search_in) {
		case "name":
		query = `nameLIKE${search_term}`
		break
		case "value":
		query = `valueLIKE${search_term}`
		break
		case "description":
		query = `descriptionLIKE${search_term}`
		break
		case "all":
		default:
		query = `nameLIKE${search_term}^ORvalueLIKE${search_term}^ORdescriptionLIKE${search_term}`
		}

		const response = await this.client.searchRecords("sys_properties", query, limit)

		if (!response.success \|\| !response.data?.result) {
		throw new Error("Search failed")
		}

		const results = response.data.result

		if (results.length === 0) {
		return {
		content: [
		{
		type: "text",
		text: `No properties found matching: "${search_term}"`,
		},
		],
		}
		}

		let output = `🔍 Search Results (Found: ${results.length})\n`
		output += `Search term: "${search_term}" in ${search_in}\n\n`

		for (const prop of results) {
		output += `${prop.name}\n`
		output += `• Value: ${prop.value \|\| "(empty)"}\n`
		if (prop.description) {
		output += `• Description: ${prop.description}\n`
		}
		output += "\n"
		}

		return {
		content: [
		{
		type: "text",
		text: output,
		},
		],
		}
		} catch (error) {
		this.logger.error("Search failed:", error)
		throw error
		}
		}

		/**
		* Bulk get properties
		*/
		private async bulkGetProperties(args: any) {
		const { names, include_metadata = false } = args

		this.logger.info(`Bulk getting ${names.length} properties`)

		const results: Record<string, any> = {}
		const errors: string[] = []

		for (const name of names) {
		try {
		// Check cache first
		if (this.propertyCache.has(name)) {
		results[name] = this.propertyCache.get(name)
		continue
		}

		const response = await this.client.searchRecords("sys_properties", `name=${name}`, 1)

		if (response.success && response.data?.result?.length > 0) {
		const prop = response.data.result[0]
		results[name] = include_metadata ? prop : prop.value
		this.propertyCache.set(name, prop)
		} else {
		results[name] = null
		errors.push(name)
		}
		} catch (error) {
		this.logger.error(`Failed to get property ${name}:`, error)
		results[name] = null
		errors.push(name)
		}
		}

		let output = `📋 Bulk Property Retrieval\n\n`

		if (include_metadata) {
		output += JSON.stringify(results, null, 2)
		} else {
		for (const [name, value] of Object.entries(results)) {
		output += `• ${name} = ${value !== null ? `"${value}"` : "NOT FOUND"}\n`
		}
		}

		if (errors.length > 0) {
		output += `\n⚠️ Properties not found: ${errors.join(", ")}`
		}

		return {
		content: [
		{
		type: "text",
		text: output,
		},
		],
		}
		}

		/**
		* Bulk set properties
		*/
		private async bulkSetProperties(args: any) {
		const { properties } = args

		this.logger.info(`Bulk setting ${properties.length} properties`)

		const results = {
		created: [],
		updated: [],
		failed: [],
		}

		for (const prop of properties) {
		try {
		// Check if exists
		const existing = await this.client.searchRecords("sys_properties", `name=${prop.name}`, 1)

		let result
		if (existing.success && existing.data?.result?.length > 0) {
		// Update
		const sys_id = existing.data.result[0].sys_id
		result = await this.client.updateRecord("sys_properties", sys_id, {
		value: prop.value,
		...(prop.description && { description: prop.description }),
		...(prop.type && { type: prop.type }),
		})

		if (result.success) {
		results.updated.push(prop.name)
		} else {
		results.failed.push(`${prop.name}: ${result.error}`)
		}
		} else {
		// Create
		this.logger.trackAPICall("CREATE", "sys_properties", 1)
		result = await this.client.createRecord("sys_properties", {
		name: prop.name,
		value: prop.value,
		description: prop.description \|\| `Created by Snow-Flow bulk operation`,
		type: prop.type \|\| "string",
		})

		if (result.success) {
		results.created.push(prop.name)
		} else {
		results.failed.push(`${prop.name}: ${result.error}`)
		}
		}

		// Clear cache
		this.propertyCache.delete(prop.name)
		} catch (error) {
		this.logger.error(`Failed to set property ${prop.name}:`, error)
		results.failed.push(`${prop.name}: ${error}`)
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `📦 Bulk Property Update Results

		✅ Created: ${results.created.length}
		${results.created.map((n) => `• ${n}`).join("\n")}

		🔄 Updated: ${results.updated.length}
		${results.updated.map((n) => `• ${n}`).join("\n")}

		${results.failed.length > 0 ? `❌ Failed: ${results.failed.length}\n${results.failed.map((f) => `• ${f}`).join("\n")}` : ""}

		Total processed: ${properties.length}`,
		},
		],
		}
		}

		/**
		* Export properties
		*/
		private async exportProperties(args: any) {
		const { pattern, include_system = false, include_private = false } = args

		this.logger.info("Exporting properties", { pattern, include_system, include_private })

		try {
		let query = ""
		const conditions = []

		if (pattern) {
		if (pattern.includes("*")) {
		const likePattern = pattern.replace(/\*/g, "")
		conditions.push(`nameLIKE${likePattern}`)
		} else {
		conditions.push(`name=${pattern}`)
		}
		}

		if (!include_system) {
		conditions.push(`name!=glide.^name!=sys.`)
		}

		if (!include_private) {
		conditions.push(`is_private=false`)
		}

		query = conditions.join("^")

		const response = await this.client.searchRecords("sys_properties", query, 1000)

		if (!response.success \|\| !response.data?.result) {
		throw new Error("Export failed")
		}

		const properties = response.data.result
		const exportData: Record<string, any> = {}

		for (const prop of properties) {
		exportData[prop.name] = {
		value: prop.value,
		type: prop.type \|\| "string",
		description: prop.description \|\| "",
		suffix: prop.suffix \|\| "global",
		is_private: prop.is_private === "true",
		choices: prop.choices \|\| "",
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `📤 Properties Export (${properties.length} properties)

		\`\`\`json
		${JSON.stringify(exportData, null, 2)}
		\`\`\`

		✅ Export complete. You can save this JSON for backup or migration.`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Export failed:", error)
		throw error
		}
		}

		/**
		* Import properties
		*/
		private async importProperties(args: any) {
		const { properties, overwrite = false, dry_run = false } = args

		this.logger.info("Importing properties", { count: Object.keys(properties).length, overwrite, dry_run })

		const results = {
		would_create: [],
		would_update: [],
		would_skip: [],
		created: [],
		updated: [],
		skipped: [],
		failed: [],
		}

		for (const [name, data] of Object.entries(properties)) {
		try {
		// Check if exists
		const existing = await this.client.searchRecords("sys_properties", `name=${name}`, 1)

		const exists = existing.success && existing.data?.result?.length > 0

		if (dry_run) {
		if (exists && overwrite) {
		results.would_update.push(name)
		} else if (exists && !overwrite) {
		results.would_skip.push(name)
		} else {
		results.would_create.push(name)
		}
		continue
		}

		if (exists && !overwrite) {
		results.skipped.push(name)
		continue
		}

		const propertyData = typeof data === "object" ? data : { value: data }

		if (exists) {
		// Update
		const sys_id = existing.data.result[0].sys_id
		const result = await this.client.updateRecord("sys_properties", sys_id, {
		value: (propertyData as any).value,
		...((propertyData as any).description && { description: (propertyData as any).description }),
		...((propertyData as any).type && { type: (propertyData as any).type }),
		...((propertyData as any).suffix && { suffix: (propertyData as any).suffix }),
		...((propertyData as any).choices && { choices: (propertyData as any).choices }),
		...((propertyData as any).is_private !== undefined && {
		is_private: (propertyData as any).is_private ? "true" : "false",
		}),
		})

		if (result.success) {
		results.updated.push(name)
		} else {
		results.failed.push(`${name}: ${result.error}`)
		}
		} else {
		// Create
		this.logger.trackAPICall("CREATE", "sys_properties", 1)
		const result = await this.client.createRecord("sys_properties", {
		name,
		value: (propertyData as any).value,
		description: (propertyData as any).description \|\| `Imported by Snow-Flow`,
		type: (propertyData as any).type \|\| "string",
		suffix: (propertyData as any).suffix \|\| "global",
		choices: (propertyData as any).choices \|\| "",
		is_private: (propertyData as any).is_private ? "true" : "false",
		})

		if (result.success) {
		results.created.push(name)
		} else {
		results.failed.push(`${name}: ${result.error}`)
		}
		}

		// Clear cache
		this.propertyCache.delete(name)
		} catch (error) {
		this.logger.error(`Failed to import property ${name}:`, error)
		results.failed.push(`${name}: ${error}`)
		}
		}

		if (dry_run) {
		return {
		content: [
		{
		type: "text",
		text: `🔍 Import Preview (Dry Run)

		Would create: ${results.would_create.length}
		${results.would_create
		.slice(0, 10)
		.map((n) => `• ${n}`)
		.join("\n")}${results.would_create.length > 10 ? `\n... and ${results.would_create.length - 10} more` : ""}

		Would update: ${results.would_update.length}
		${results.would_update
		.slice(0, 10)
		.map((n) => `• ${n}`)
		.join("\n")}${results.would_update.length > 10 ? `\n... and ${results.would_update.length - 10} more` : ""}

		Would skip: ${results.would_skip.length}
		${results.would_skip
		.slice(0, 10)
		.map((n) => `• ${n}`)
		.join("\n")}${results.would_skip.length > 10 ? `\n... and ${results.would_skip.length - 10} more` : ""}

		✅ Run with dry_run: false to apply changes`,
		},
		],
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `📥 Import Results

		✅ Created: ${results.created.length}
		🔄 Updated: ${results.updated.length}
		⏭️ Skipped: ${results.skipped.length}
		${results.failed.length > 0 ? `❌ Failed: ${results.failed.length}\n${results.failed.join("\n")}` : ""}

		Total processed: ${Object.keys(properties).length}`,
		},
		],
		}
		}

		/**
		* Validate property value
		*/
		private async validateProperty(args: any) {
		const { name, value } = args

		this.logger.info(`Validating property: ${name} = ${value}`)

		try {
		// Get property metadata
		const response = await this.client.searchRecords("sys_properties", `name=${name}`, 1)

		if (!response.success \|\| !response.data?.result?.length) {
		return {
		content: [
		{
		type: "text",
		text: `❌ Property not found: ${name}. Cannot validate.`,
		},
		],
		}
		}

		const property = response.data.result[0]
		const validationResults = []
		let isValid = true

		// Type validation
		if (property.type) {
		switch (property.type) {
		case "boolean":
		if (!["true", "false", "1", "0"].includes(value.toLowerCase())) {
		validationResults.push("❌ Value must be true/false")
		isValid = false
		} else {
		validationResults.push("✅ Valid boolean value")
		}
		break
		case "integer":
		if (!/^-?\d+$/.test(value)) {
		validationResults.push("❌ Value must be an integer")
		isValid = false
		} else {
		validationResults.push("✅ Valid integer value")
		}
		break
		case "float":
		case "decimal":
		if (!/^-?\d*\.?\d+$/.test(value)) {
		validationResults.push("❌ Value must be a number")
		isValid = false
		} else {
		validationResults.push("✅ Valid numeric value")
		}
		break
		case "string":
		default:
		validationResults.push("✅ Valid string value")
		}
		}

		// Choices validation
		if (property.choices) {
		const validChoices = property.choices.split(",").map((c: string) => c.trim())
		if (!validChoices.includes(value)) {
		validationResults.push(`❌ Value must be one of: ${validChoices.join(", ")}`)
		isValid = false
		} else {
		validationResults.push("✅ Valid choice")
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `🔍 Property Validation: ${name}

		Current Value: ${property.value}
		New Value: ${value}
		Type: ${property.type \|\| "string"}
		${property.choices ? `Valid Choices: ${property.choices}` : ""}

		Validation Results:
		${validationResults.join("\n")}

		Overall: ${isValid ? "✅ VALID" : "❌ INVALID"}`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Validation failed:", error)
		throw error
		}
		}

		/**
		* Get property categories
		*/
		private async getCategories(args: any) {
		const { include_counts = true } = args

		this.logger.info("Getting property categories")

		try {
		// Get distinct suffixes (categories)
		const response = await this.client.searchRecords("sys_properties", "", 1000)

		if (!response.success \|\| !response.data?.result) {
		throw new Error("Failed to get categories")
		}

		const categories: Record<string, number> = {}

		for (const prop of response.data.result) {
		const category = prop.suffix \|\| "global"
		categories[category] = (categories[category] \|\| 0) + 1
		}

		const sorted = Object.entries(categories).sort((a, b) => b[1] - a[1])

		let output = `📂 Property Categories\n\n`

		for (const [category, count] of sorted) {
		if (include_counts) {
		output += `• ${category} (${count} properties)\n`
		} else {
		output += `• ${category}\n`
		}
		}

		output += `\n📊 Total categories: ${sorted.length}`
		output += `\n📋 Total properties: ${response.data.result.length}`

		return {
		content: [
		{
		type: "text",
		text: output,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to get categories:", error)
		throw error
		}
		}

		/**
		* Get property audit history
		*/
		private async getPropertyHistory(args: any) {
		const { name, limit = 10 } = args

		this.logger.info(`Getting history for property: ${name}`)

		try {
		// First, get the property to get its sys_id
		const propResponse = await this.client.searchRecords("sys_properties", `name=${name}`, 1)

		if (!propResponse.success \|\| !propResponse.data?.result?.length) {
		return {
		content: [
		{
		type: "text",
		text: `❌ Property not found: ${name}`,
		},
		],
		}
		}

		const sys_id = propResponse.data.result[0].sys_id

		// Get audit history
		const auditResponse = await this.client.searchRecords(
		"sys_audit",
		`documentkey=${sys_id}^tablename=sys_properties`,
		limit,
		)

		if (!auditResponse.success \|\| !auditResponse.data?.result?.length) {
		return {
		content: [
		{
		type: "text",
		text: `📜 No audit history found for property: ${name}`,
		},
		],
		}
		}

		let output = `📜 Audit History: ${name}\n\n`

		for (const audit of auditResponse.data.result) {
		output += `${audit.sys_created_on}\n`
		output += `• User: ${audit.sys_created_by}\n`
		output += `• Field: ${audit.fieldname}\n`
		output += `• Old: ${audit.oldvalue \|\| "(empty)"}\n`
		output += `• New: ${audit.newvalue \|\| "(empty)"}\n`
		output += "\n"
		}

		return {
		content: [
		{
		type: "text",
		text: output,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to get history:", error)
		// Audit might not be available
		return {
		content: [
		{
		type: "text",
		text: `⚠️ Audit history not available for this property or table.

		Note: Audit history requires sys_audit to be enabled for sys_properties table.`,
		},
		],
		}
		}
		}

		async run() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)
		// Use stderr for logs to keep stdout clean for JSON-RPC
		console.error("ServiceNow System Properties MCP Server running on stdio")
		}
		}

		// Start the server
		const server = new ServiceNowSystemPropertiesMCP()
		server.run().catch((error) => {
		console.error("Failed to start ServiceNow System Properties MCP:", error)
		process.exit(1)
		})

-964

src/servicenow/servicenow-update-set-mcp.ts

		#!/usr/bin/env node
		/**
		* ServiceNow Update Set Management MCP Server
		* Ensures all changes are tracked in Update Sets for safe deployment
		*/

		import { Server } from "@modelcontextprotocol/sdk/server/index.js"
		import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
		import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
		import { ServiceNowClient } from "../utils/servicenow-client.js"
		import { ServiceNowOAuth } from "../utils/snow-oauth.js"
		import { MCPLogger } from "./shared/mcp-logger.js"
		import { promises as fs } from "fs"
		import { join } from "path"

		interface UpdateSetSession {
		update_set_id: string
		name: string
		description: string
		user_story?: string
		created_at: string
		state: "in_progress" \| "complete" \| "released"
		artifacts: Array<{
		type: string
		sys_id: string
		name: string
		created_at: string
		}>
		auto_switched?: boolean
		active_session?: boolean
		}

		class ServiceNowUpdateSetMCP {
		private server: Server
		private client: ServiceNowClient
		private oauth: ServiceNowOAuth
		private logger: MCPLogger
		private currentSession: UpdateSetSession \| null = null
		private sessionsPath: string

		constructor() {
		this.server = new Server(
		{
		name: "servicenow-update-set",
		version: "1.0.0",
		},
		{
		capabilities: {
		tools: {},
		},
		},
		)

		this.client = new ServiceNowClient()
		this.oauth = new ServiceNowOAuth()
		this.logger = new MCPLogger("ServiceNowUpdateSetMCP")
		this.sessionsPath = join(process.cwd(), "memory", "update-set-sessions")

		// Debug: Test credentials on startup
		this.testCredentials()

		this.setupHandlers()
		this.ensureSessionsDirectory()
		}

		/**
		* Test credentials on startup
		*/
		private async testCredentials(): Promise<void> {
		console.error("🔍 [UPDATE-SET MCP] Testing credentials...")
		try {
		const credentials = await this.oauth.loadCredentials()
		if (credentials) {
		console.error("✅ [UPDATE-SET MCP] Credentials loaded successfully")
		const isAuth = await this.oauth.isAuthenticated()
		console.error(`🔐 [UPDATE-SET MCP] Authentication status: ${isAuth ? "✅ Valid" : "❌ Expired"}`)
		} else {
		console.error("❌ [UPDATE-SET MCP] No credentials found")
		}
		} catch (error) {
		console.error("❌ [UPDATE-SET MCP] Credential test failed:", error)
		}
		}

		private async ensureSessionsDirectory() {
		try {
		await fs.mkdir(this.sessionsPath, { recursive: true })
		} catch (error) {
		this.logger.error("Failed to create sessions directory", error)
		}
		}

		private setupHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
		tools: [
		{
		name: "snow_update_set_create",
		description:
		"Creates a new Update Set for tracking changes related to a user story or feature. Essential for ServiceNow change management and deployment tracking.",
		inputSchema: {
		type: "object",
		properties: {
		name: {
		type: "string",
		description: 'Update Set name (e.g., "STORY-123: Add incident widget")',
		},
		description: {
		type: "string",
		description: "Detailed description of changes",
		},
		user_story: {
		type: "string",
		description: "User story or ticket number",
		},
		release_date: {
		type: "string",
		description: "Target release date (optional)",
		},
		auto_switch: {
		type: "boolean",
		description: "Automatically switch to the created Update Set (default: true)",
		default: true,
		},
		},
		required: ["name", "description"],
		},
		},
		{
		name: "snow_update_set_switch",
		description:
		"Switches the active Update Set context to an existing set. Ensures all subsequent changes are tracked in the specified Update Set.",
		inputSchema: {
		type: "object",
		properties: {
		update_set_id: {
		type: "string",
		description: "Update Set sys_id to switch to",
		},
		},
		required: ["update_set_id"],
		},
		},
		{
		name: "snow_update_set_current",
		description:
		"Retrieves information about the currently active Update Set including ID, name, state, and tracked artifacts.",
		inputSchema: {
		type: "object",
		properties: {},
		},
		},
		{
		name: "snow_update_set_list",
		description:
		"Lists Update Sets filtered by state (in_progress, complete, released). Provides overview of recent changes and deployment readiness.",
		inputSchema: {
		type: "object",
		properties: {
		state: {
		type: "string",
		description: "Filter by state: in_progress, complete, released",
		enum: ["in_progress", "complete", "released"],
		},
		limit: {
		type: "number",
		description: "Maximum number of results (default: 10)",
		},
		},
		},
		},
		{
		name: "snow_update_set_complete",
		description:
		"Marks an Update Set as complete, preventing further changes. Prepares the set for testing, review, and migration to other instances.",
		inputSchema: {
		type: "object",
		properties: {
		update_set_id: {
		type: "string",
		description: "Update Set sys_id to complete (uses current if not specified)",
		},
		notes: {
		type: "string",
		description: "Completion notes or testing instructions",
		},
		},
		},
		},
		{
		name: "snow_update_set_add_artifact",
		description:
		"Registers an artifact (widget, flow, script) in the active Update Set for tracking. Maintains comprehensive change history for deployments.",
		inputSchema: {
		type: "object",
		properties: {
		type: {
		type: "string",
		description: "Artifact type (widget, flow, script, etc.)",
		},
		sys_id: {
		type: "string",
		description: "ServiceNow sys_id of the artifact",
		},
		name: {
		type: "string",
		description: "Artifact name for tracking",
		},
		},
		required: ["type", "sys_id", "name"],
		},
		},
		{
		name: "snow_update_set_preview",
		description:
		"Generates a detailed preview of all changes contained in an Update Set. Shows modified tables, fields, and potential deployment impacts.",
		inputSchema: {
		type: "object",
		properties: {
		update_set_id: {
		type: "string",
		description: "Update Set sys_id (uses current if not specified)",
		},
		},
		},
		},
		{
		name: "snow_update_set_export",
		description:
		"Exports Update Set to XML format for backup, version control, or manual migration between instances. Preserves all change records and metadata.",
		inputSchema: {
		type: "object",
		properties: {
		update_set_id: {
		type: "string",
		description: "Update Set sys_id to export",
		},
		output_path: {
		type: "string",
		description: "Path to save the XML file",
		},
		},
		},
		},
		{
		name: "snow_ensure_active_update_set",
		description:
		"Ensures an active Update Set is available for tracking changes. Automatically creates a contextual Update Set if none exists, preventing untracked modifications.",
		inputSchema: {
		type: "object",
		properties: {
		context: {
		type: "string",
		description: 'Context for auto-created Update Set (e.g., "widget development", "flow creation")',
		},
		auto_create: {
		type: "boolean",
		description: "Automatically create Update Set if none exists (default: true)",
		default: true,
		},
		},
		},
		},
		],
		}))

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
		const { name, arguments: args } = request.params

		try {
		// Start operation with token tracking
		this.logger.operationStart(name, args)

		// Check authentication for all operations
		const isAuthenticated = await this.oauth.isAuthenticated()
		if (!isAuthenticated) {
		throw new McpError(ErrorCode.InvalidRequest, 'Not authenticated. Run "snow-flow auth login" first.')
		}

		let result
		switch (name) {
		case "snow_update_set_create":
		result = await this.createUpdateSet(args)
		break
		case "snow_update_set_switch":
		result = await this.switchUpdateSet(args)
		break
		case "snow_update_set_current":
		result = await this.getCurrentUpdateSet()
		break
		case "snow_update_set_list":
		result = await this.listUpdateSets(args)
		break
		case "snow_update_set_complete":
		result = await this.completeUpdateSet(args)
		break
		case "snow_update_set_add_artifact":
		result = await this.addArtifactToSession(args)
		break
		case "snow_update_set_preview":
		result = await this.previewUpdateSet(args)
		break
		case "snow_update_set_export":
		result = await this.exportUpdateSet(args)
		break
		case "snow_ensure_active_update_set":
		result = await this.ensureActiveUpdateSet(args)
		break
		case "snow_sync_current_update_set":
		result = await this.syncCurrentUpdateSet(args)
		break
		default:
		throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
		}

		// Complete operation with token tracking
		result = this.logger.addTokenUsageToResponse(result)
		result = this.logger.addTokenUsageToResponse(result)
		this.logger.operationComplete(name, result)
		return result
		} catch (error) {
		if (error instanceof McpError) throw error

		this.logger.error("Tool execution failed", { tool: name, error })
		throw new McpError(
		ErrorCode.InternalError,
		`Failed to execute ${name}: ${error instanceof Error ? error.message : String(error)}`,
		)
		}
		})
		}

		private async createUpdateSet(args: any) {
		try {
		this.logger.info("Creating new Update Set", args)

		// Create Update Set in ServiceNow
		this.logger.trackAPICall("CREATE", "sys_update_set", 1)
		const response = await this.client.createUpdateSet({
		name: args.name,
		description: args.description,
		release_date: args.release_date,
		state: "in_progress",
		})

		if (!response.success) {
		throw new Error(response.error \|\| "Failed to create Update Set")
		}

		// Validate response structure
		if (!response.data \|\| !response.data.sys_id) {
		throw new Error(`Invalid Update Set response: missing data or sys_id. Response: ${JSON.stringify(response)}`)
		}

		// Auto-switch to Update Set if requested (default: true)
		const autoSwitch = args.auto_switch !== false
		let switchedToUpdateSet = false

		if (autoSwitch) {
		this.logger.trackAPICall("UPDATE", "sys_update_set", 1)
		await this.client.setCurrentUpdateSet(response.data.sys_id)
		switchedToUpdateSet = true

		// Create local session
		this.currentSession = {
		update_set_id: response.data.sys_id,
		name: args.name,
		description: args.description,
		user_story: args.user_story,
		created_at: new Date().toISOString(),
		state: "in_progress",
		artifacts: [],
		auto_switched: true,
		active_session: true,
		}

		// Save session
		await this.saveSession()
		}

		const credentials = await this.oauth.loadCredentials()
		const updateSetUrl = `https://${credentials?.instance}/sys_update_set.do?sys_id=${response.data.sys_id}`

		return {
		content: [
		{
		type: "text",
		text: `✅ Update Set Created Successfully!

		📋 Details:
		- Name: ${args.name}
		- ID: ${response.data.sys_id}
		- Description: ${args.description}
		${args.user_story ? `- User Story: ${args.user_story}` : ""}
		- State: In Progress
		${switchedToUpdateSet ? "- Auto-Switched: ✅ Active session ready" : "- Auto-Switch: ❌ Manual switch required"}

		🔗 View in ServiceNow: ${updateSetUrl}

		${
		switchedToUpdateSet
		? `⚡ Current Session Active
		All subsequent changes will be automatically tracked in this Update Set.`
		: `⚠️ Manual Switch Required
		Use \`snow_update_set_switch\` to activate this Update Set before making changes.`
		}

		💡 Best Practices:
		1. Keep Update Sets focused on a single story/feature
		2. Test thoroughly before marking complete
		3. Document all changes in the description
		4. Use meaningful names that include story numbers`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to create Update Set", error)
		throw error
		}
		}

		private async switchUpdateSet(args: any) {
		try {
		this.logger.info("Switching to Update Set", { update_set_id: args.update_set_id })

		// Set as current in ServiceNow
		this.logger.trackAPICall("UPDATE", "sys_update_set", 1)
		await this.client.setCurrentUpdateSet(args.update_set_id)

		// Load or create session
		const sessionFile = join(this.sessionsPath, `${args.update_set_id}.json`)
		try {
		const sessionData = await fs.readFile(sessionFile, "utf-8")
		this.currentSession = JSON.parse(sessionData)
		} catch {
		// Create new session for existing Update Set
		this.logger.trackAPICall("GET", "sys_update_set", 1)
		const updateSet = await this.client.getUpdateSet(args.update_set_id)
		this.currentSession = {
		update_set_id: args.update_set_id,
		name: updateSet.data.name,
		description: updateSet.data.description,
		created_at: updateSet.data.sys_created_on,
		state: updateSet.data.state,
		artifacts: [],
		}
		await this.saveSession()
		}

		return {
		content: [
		{
		type: "text",
		text: `✅ Switched to Update Set

		📋 Current Update Set:
		- Name: ${this.currentSession?.name \|\| "Unknown"}
		- ID: ${this.currentSession?.update_set_id \|\| "Unknown"}
		- State: ${this.currentSession?.state \|\| "Unknown"}
		- Artifacts Tracked: ${this.currentSession?.artifacts.length \|\| 0}

		All subsequent changes will be tracked in this Update Set.`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to switch Update Set", error)
		throw error
		}
		}

		private async getCurrentUpdateSet() {
		if (!this.currentSession) {
		// Try to get from ServiceNow
		this.logger.trackAPICall("GET", "sys_update_set", 1)
		const current = await this.client.getCurrentUpdateSet()
		if (current.success && current.data) {
		return {
		content: [
		{
		type: "text",
		text: `📋 Current Update Set (from ServiceNow):
		- Name: ${current.data.name}
		- ID: ${current.data.sys_id}
		- State: ${current.data.state}

		⚠️ Note: No local session active. Use \`snow_update_set_switch\` to activate session tracking.`,
		},
		],
		}
		}

		return {
		content: [
		{
		type: "text",
		text: "❌ No Update Set Active\n\nUse `snow_update_set_create` to create a new Update Set for your changes.",
		},
		],
		}
		}

		return {
		content: [
		{
		type: "text",
		text: `📋 Current Update Set Session:
		- Name: ${this.currentSession.name}
		- ID: ${this.currentSession.update_set_id}
		- User Story: ${this.currentSession.user_story \|\| "Not specified"}
		- State: ${this.currentSession.state}
		- Created: ${new Date(this.currentSession.created_at).toLocaleString()}
		- Artifacts: ${this.currentSession.artifacts.length}

		📦 Tracked Artifacts:
		${
		this.currentSession.artifacts.length > 0
		? this.currentSession.artifacts.map((a) => `- ${a.type}: ${a.name}`).join("\n")
		: "- No artifacts tracked yet"
		}`,
		},
		],
		}
		}

		private async listUpdateSets(args: any) {
		try {
		this.logger.trackAPICall("SEARCH", "sys_update_set", args.limit \|\| 10)
		const response = await this.client.listUpdateSets({
		state: args.state,
		limit: args.limit \|\| 10,
		})

		if (!response.success) {
		throw new Error(response.error \|\| "Failed to list Update Sets")
		}

		const updateSets = response.data \|\| []
		const credentials = await this.oauth.loadCredentials()

		return {
		content: [
		{
		type: "text",
		text: `📋 Update Sets (${updateSets.length} found)

		${updateSets
		.map(
		(us: any) => `
		${us.name}
		- ID: ${us.sys_id}
		- State: ${us.state}
		- Created: ${new Date(us.sys_created_on).toLocaleDateString()}
		- Created By: ${us.sys_created_by}
		- 🔗 [View](https://${credentials?.instance}/sys_update_set.do?sys_id=${us.sys_id})
		`,
		)
		.join("\n---\n")}

		💡 Use \`snow_update_set_switch\` to activate any Update Set.`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to list Update Sets", error)
		throw error
		}
		}

		private async completeUpdateSet(args: any) {
		try {
		const updateSetId = args.update_set_id \|\| this.currentSession?.update_set_id
		if (!updateSetId) {
		throw new Error("No Update Set specified and no active session")
		}

		// Mark as complete in ServiceNow
		this.logger.trackAPICall("UPDATE", "sys_update_set", 1)
		const response = await this.client.completeUpdateSet(updateSetId, args.notes)

		if (!response.success) {
		throw new Error(response.error \|\| "Failed to complete Update Set")
		}

		// Update session
		if (this.currentSession && this.currentSession.update_set_id === updateSetId) {
		this.currentSession.state = "complete"
		await this.saveSession()
		}

		const credentials = await this.oauth.loadCredentials()
		const updateSetUrl = `https://${credentials?.instance}/sys_update_set.do?sys_id=${updateSetId}`

		return {
		content: [
		{
		type: "text",
		text: `✅ Update Set Completed!

		📋 Summary:
		- Name: ${response.data.name}
		- ID: ${updateSetId}
		- State: Complete
		${args.notes ? `- Notes: ${args.notes}` : ""}

		🔗 View in ServiceNow: ${updateSetUrl}

		📝 Next Steps:
		1. Test all changes thoroughly
		2. Get peer review if required
		3. Move to target instance when ready
		4. Create new Update Set for next feature

		⚠️ Important: This Update Set is now locked. Create a new one for additional changes.`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to complete Update Set", error)
		throw error
		}
		}

		private async addArtifactToSession(args: any) {
		// Intelligent session management - auto-create session if none exists
		if (!this.currentSession) {
		this.logger.info("No active session found, auto-creating Update Set session")

		try {
		// Create a default update set with smart naming
		const defaultName = `AUTO-${new Date().toISOString().split("T")[0]}-${Date.now().toString().slice(-6)}`
		const defaultDescription = `Auto-created Update Set for ${args.type} deployment: ${args.name}`

		await this.createUpdateSet({
		name: defaultName,
		description: defaultDescription,
		user_story: "Automated artifact deployment",
		})

		this.logger.info("Auto-created Update Set session", {
		name: defaultName,
		updateSetId: this.currentSession?.update_set_id,
		})
		} catch (error) {
		this.logger.error("Failed to auto-create Update Set session", { error })
		throw new Error(
		`No active Update Set session and auto-creation failed: ${error instanceof Error ? error.message : String(error)}`,
		)
		}
		}

		// Add artifact to session
		this.currentSession.artifacts.push({
		type: args.type,
		sys_id: args.sys_id,
		name: args.name,
		created_at: new Date().toISOString(),
		})

		await this.saveSession()

		const autoCreatedNotice = this.currentSession.name.startsWith("AUTO-")
		? `\n🔄 Smart Session Management:\n- ✅ Update Set session auto-created (no manual setup required)\n- 📝 Naming: ${this.currentSession.name}\n- 🎯 Intelligent deployment tracking enabled\n`
		: ""

		return {
		content: [
		{
		type: "text",
		text: `✅ Artifact Added to Update Set Session

		📦 Artifact Details:
		- Type: ${args.type}
		- Name: ${args.name}
		- Sys ID: ${args.sys_id}
		${autoCreatedNotice}
		📋 Current Session:
		- Update Set: ${this.currentSession.name}
		- Total Artifacts: ${this.currentSession.artifacts.length}
		- Session ID: ${this.currentSession.update_set_id}`,
		},
		],
		}
		}

		private async previewUpdateSet(args: any) {
		try {
		const updateSetId = args.update_set_id \|\| this.currentSession?.update_set_id
		if (!updateSetId) {
		throw new Error("No Update Set specified and no active session")
		}

		// Get Update Set details and changes
		this.logger.trackAPICall("GET", "sys_update_set_preview", 1)
		const response = await this.client.previewUpdateSet(updateSetId)

		if (!response.success) {
		throw new Error(response.error \|\| "Failed to preview Update Set")
		}

		const changes = response.data.changes \|\| []
		const credentials = await this.oauth.loadCredentials()

		return {
		content: [
		{
		type: "text",
		text: `📋 Update Set Preview

		Update Set: ${response.data.name}
		Total Changes: ${changes.length}

		📦 Changes by Type:
		${this.groupChangesByType(changes)}

		📝 Change Details:
		${changes
		.slice(0, 20)
		.map(
		(change: any) => `
		- ${change.type}: ${change.target_name}
		- Action: ${change.action}
		- Table: ${change.target_table}
		- Updated: ${new Date(change.sys_updated_on).toLocaleString()}
		`,
		)
		.join("\n")}
		${changes.length > 20 ? `\n... and ${changes.length - 20} more changes` : ""}

		🔗 Full Preview: https://${credentials?.instance}/sys_update_set_preview.do?sysparm_set=${updateSetId}`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to preview Update Set", error)
		throw error
		}
		}

		private async exportUpdateSet(args: any) {
		try {
		const updateSetId = args.update_set_id
		if (!updateSetId) {
		throw new Error("Update Set ID is required for export")
		}

		// Export Update Set as XML
		this.logger.trackAPICall("GET", "sys_update_set_export", 1)
		const response = await this.client.exportUpdateSet(updateSetId)

		if (!response.success) {
		throw new Error(response.error \|\| "Failed to export Update Set")
		}

		// Save to file
		const outputPath =
		args.output_path \|\| join(process.cwd(), "exports", `update_set_${updateSetId}_${Date.now()}.xml`)
		await fs.mkdir(join(process.cwd(), "exports"), { recursive: true })
		await fs.writeFile(outputPath, response.data.xml)

		return {
		content: [
		{
		type: "text",
		text: `✅ Update Set Exported Successfully!

		📦 Export Details:
		- Update Set: ${response.data.name}
		- File Size: ${(response.data.xml.length / 1024).toFixed(2)} KB
		- Changes: ${response.data.change_count}
		- Saved to: ${outputPath}

		💡 Usage:
		- Import this XML file to another ServiceNow instance
		- Keep as backup before major changes
		- Share with team members for review`,
		},
		],
		}
		} catch (error) {
		this.logger.error("Failed to export Update Set", error)
		throw error
		}
		}

		private async ensureActiveUpdateSet(args: any) {
		try {
		this.logger.info("Ensuring active Update Set session", args)

		// Check if we already have an active session
		if (this.currentSession?.state === "in_progress") {
		// Also sync current Update Set if requested
		if (args.set_as_current !== false) {
		await this.syncCurrentUpdateSet({ force_switch: true })
		}

		return {
		success: true,
		message: "Active Update Set session found and synchronized",
		update_set: {
		name: this.currentSession.name,
		sys_id: this.currentSession.update_set_id,
		artifacts_count: this.currentSession.artifacts?.length \|\| 0,
		},
		synchronized: args.set_as_current !== false,
		}
		}

		// Auto-create if requested (default: true)
		const autoCreate = args.auto_create !== false
		if (autoCreate) {
		const context = args.context \|\| "automated deployment"
		const timestamp = new Date().toISOString().slice(0, 16).replace("T", " ")

		return await this.createUpdateSet({
		name: `Auto-${context} (${timestamp})`,
		description: `Automatically created Update Set for ${context}`,
		user_story: "Automated deployment workflow",
		auto_switch: true,
		})
		} else {
		return {
		content: [
		{
		type: "text",
		text: `❌ No Active Update Set Session

		⚠️ Manual Creation Required
		Create an Update Set before making changes:

		\`\`\`
		snow_update_set_create({
		name: "Your feature name",
		description: "Description of changes"
		})
		\`\`\`

		💡 Why Update Sets Matter:
		- Track all changes for rollback capability
		- Organize related changes together
		- Required for deployment to other environments`,
		},
		],
		}
		}
		} catch (error) {
		this.logger.error("Failed to ensure active Update Set", error)
		throw error
		}
		}

		private async saveSession() {
		if (!this.currentSession) return

		const sessionFile = join(this.sessionsPath, `${this.currentSession.update_set_id}.json`)
		await fs.writeFile(sessionFile, JSON.stringify(this.currentSession, null, 2))
		}

		private groupChangesByType(changes: any[]): string {
		const grouped = changes.reduce((acc: any, change: any) => {
		const type = change.type \|\| "Other"
		acc[type] = (acc[type] \|\| 0) + 1
		return acc
		}, {})

		return Object.entries(grouped)
		.sort((a: any, b: any) => b[1] - a[1])
		.map(([type, count]) => `- ${type}: ${count}`)
		.join("\n")
		}

		/**
		* NEW: Synchronize user's current Update Set with Snow-Flow's active Update Set
		*/
		private async syncCurrentUpdateSet(args: any) {
		try {
		this.logger.info("Synchronizing user current Update Set with Snow-Flow session...")

		if (!this.currentSession) {
		return {
		success: false,
		error: "No active Snow-Flow Update Set session found.",
		suggestion: "Run snow_ensure_active_update_set first to create or activate an Update Set.",
		}
		}

		// Set Snow-Flow Update Set as current for user via script
		const syncScript = `
		// Synchronize user's current Update Set with Snow-Flow session
		var updateSetId = '${this.currentSession.update_set_id}';
		var currentUser = gs.getUserID();

		// Get current Update Set info
		var updateSet = new GlideRecord('sys_update_set');
		if (updateSet.get(updateSetId)) {
		gs.info('Snow-Flow Update Set found: ' + updateSet.name);

		// Set as current for user via session variable
		gs.getSession().putProperty('update_set', updateSetId);
		gs.info('Set as current Update Set for user: ' + updateSet.name);

		// Also try to set via user preference
		var pref = new GlideRecord('sys_user_preference');
		pref.addQuery('user', currentUser);
		pref.addQuery('name', 'update_set.current');
		pref.query();

		if (pref.next()) {
		pref.value = updateSetId;
		pref.update();
		gs.info('Updated user preference for current Update Set');
		} else {
		var newPref = new GlideRecord('sys_user_preference');
		newPref.initialize();
		newPref.user = currentUser;
		newPref.name = 'update_set.current';
		newPref.value = updateSetId;
		newPref.insert();
		gs.info('Created user preference for current Update Set');
		}

		gs.info('SYNC COMPLETE: User current Update Set = Snow-Flow session Update Set');
		} else {
		gs.error('Snow-Flow Update Set not found: ' + updateSetId);
		}
		`

		const scriptResponse = await this.client.executeScript(syncScript)

		if (!scriptResponse.success) {
		return {
		success: false,
		error: "Failed to synchronize current Update Set",
		suggestion: "Check ServiceNow connection and Update Set permissions",
		update_set_id: this.currentSession.update_set_id,
		}
		}

		return {
		success: true,
		message: `Current Update Set synchronized with Snow-Flow session`,
		update_set_name: this.currentSession.name,
		update_set_id: this.currentSession.update_set_id,
		sync_method: "session_variable_and_user_preference",
		sync_status: "completed",
		}
		} catch (error) {
		this.logger.error("Failed to sync current Update Set:", error)
		return {
		success: false,
		error: error instanceof Error ? error.message : String(error),
		suggestion: "Check ServiceNow connection and permissions",
		}
		}
		}

		async run() {
		const transport = new StdioServerTransport()
		await this.server.connect(transport)
		this.logger.info("ServiceNow Update Set MCP Server running on stdio")
		}
		}

		const server = new ServiceNowUpdateSetMCP()
		server.run().catch(console.error)

-354

src/servicenow/shared/agent-context-provider.ts

 /**
  * Agent Context Provider for MCP Operations
  * Provides agent context awareness and tracking for all MCP tools
  */
 import { MCPMemoryManager, AgentContext } from "./mcp-memory-manager.js"
 import { Logger } from "../utils/logger.js"
 export interface MCPOperationContext {
   session_id: string
   agent_id: string
   agent_type: string
   operation_name: string
   mcp_server: string
 export interface OperationResult<T = any> {
   success: boolean
   data?: T
   error?: string
   duration_ms: number
   memory_updates?: Record<string, any>
 export class AgentContextProvider {
   private memory: MCPMemoryManager
   private logger: Logger
   constructor() {
     this.memory = MCPMemoryManager.getInstance()
     this.logger = new Logger("AgentContextProvider")
   /**
    * Extract agent context from tool arguments or environment
    */
   extractAgentContext(args: any): AgentContext {
     // Check if agent context is provided in args
     if (args.agent_context) {
       return args.agent_context
     // Check for session_id and agent_id in args
     if (args.session_id && args.agent_id) {
       return {
         session_id: args.session_id,
         agent_id: args.agent_id,
         agent_type: args.agent_type || "unknown",
     // Check environment variables (for backward compatibility)
     const session_id = process.env.SNOW_FLOW_SESSION_ID || `session_${Date.now()}`
     const agent_id = process.env.SNOW_FLOW_AGENT_ID || `agent_${Date.now()}`
     const agent_type = process.env.SNOW_FLOW_AGENT_TYPE || "mcp_direct"
     return {
       session_id,
       agent_id,
       agent_type,
   /**
    * Execute an MCP operation with full agent context tracking
    */
   async executeWithContext<T>(context: MCPOperationContext, operation: () => Promise<T>): Promise<OperationResult<T>> {
     const startTime = Date.now()
     const { session_id, agent_id, operation_name } = context
     try {
       // Update agent coordination - mark as active
       await this.memory.updateAgentCoordination({
         session_id,
         agent_id,
         agent_type: context.agent_type,
         status: "active",
         current_tool: operation_name,
         progress_percentage: 0,
       })
       // Execute the operation
       const result = await operation()
       const duration = Date.now() - startTime
       // Track performance
       await this.memory.trackPerformance({
         session_id,
         agent_id,
         operation_name,
         duration_ms: duration,
         success: true,
       })
       // Update progress
       await this.memory.updateAgentCoordination({
         session_id,
         agent_id,
         progress_percentage: 100,
         current_tool: null,
       })
       return {
         success: true,
         data: result,
         duration_ms: duration,
     } catch (error) {
       const duration = Date.now() - startTime
       const errorMessage = error instanceof Error ? error.message : String(error)
       // Track failed operation
       await this.memory.trackPerformance({
         session_id,
         agent_id,
         operation_name,
         duration_ms: duration,
         success: false,
         error_message: errorMessage,
       })
       // Update agent status with error
       await this.memory.updateAgentCoordination({
         session_id,
         agent_id,
         status: "blocked",
         error_state: errorMessage,
         current_tool: null,
       })
       return {
         success: false,
         error: errorMessage,
         duration_ms: duration,
   /**
    * Report progress during long-running operations
    */
   async reportProgress(context: AgentContext, progress: number, phase?: string): Promise<void> {
     try {
       await this.memory.updateAgentCoordination({
         session_id: context.session_id,
         agent_id: context.agent_id,
         agent_type: context.agent_type,
         progress_percentage: Math.min(100, Math.max(0, progress)),
         current_tool: phase,
       })
       // Optionally update shared context with detailed progress
       if (phase) {
         await this.memory.updateSharedContext({
           session_id: context.session_id,
           context_key: `${context.agent_id}_progress`,
           context_value: JSON.stringify({
             progress,
             phase,
             timestamp: new Date().toISOString(),
           }),
           created_by_agent: context.agent_id,
         })
     } catch (error) {
       this.logger.error("Failed to report progress", error)
   /**
    * Notify other agents of handoff or completion
    */
   async notifyHandoff(
     from_context: AgentContext,
     to_agent: string,
     artifact_info: {
       type: string
       sys_id: string
       next_steps: string[]
     },
   ): Promise<void> {
     try {
       await this.memory.sendAgentMessage({
         session_id: from_context.session_id,
         from_agent: from_context.agent_id,
         to_agent,
         message_type: "handoff",
         content: JSON.stringify({
           artifact_type: artifact_info.type,
           artifact_sys_id: artifact_info.sys_id,
           next_steps: artifact_info.next_steps,
           handoff_time: new Date().toISOString(),
         }),
         artifact_reference: artifact_info.sys_id,
       })
       // Update shared context for the handoff
       await this.memory.updateSharedContext({
         session_id: from_context.session_id,
         context_key: `${artifact_info.type}_ready_for_${to_agent}`,
         context_value: JSON.stringify({
           sys_id: artifact_info.sys_id,
           ready: true,
           from_agent: from_context.agent_id,
           next_steps: artifact_info.next_steps,
         }),
         created_by_agent: from_context.agent_id,
       })
       this.logger.info(`Notified handoff from ${from_context.agent_id} to ${to_agent}`)
     } catch (error) {
       this.logger.error("Failed to notify handoff", error)
       throw error
   /**
    * Check for pending work from other agents
    */
   async checkForHandoffs(context: AgentContext): Promise<any[]> {
     try {
       const messages = await this.memory.checkForMessages(context.agent_id, context.session_id)
       const handoffs = messages
         .filter((m) => m.message_type === "handoff")
         .map((m) => {
           try {
             return JSON.parse(m.content)
           } catch {
             return m.content
         })
       return handoffs
     } catch (error) {
       this.logger.error("Failed to check for handoffs", error)
       return []
   /**
    * Store artifact information with agent tracking
    */
   async storeArtifact(
     context: AgentContext,
     artifact: {
       sys_id: string
       type: string
       name: string
       description?: string
       config?: any
       update_set_id?: string
     },
   ): Promise<void> {
     try {
       await this.memory.storeArtifact({
         sys_id: artifact.sys_id,
         artifact_type: artifact.type,
         name: artifact.name,
         description: artifact.description,
         created_by_agent: context.agent_id,
         session_id: context.session_id,
         deployment_status: "created",
         update_set_id: artifact.update_set_id,
         metadata: artifact.config ? JSON.stringify(artifact.config) : undefined,
       })
       // Update shared context
       await this.memory.updateSharedContext({
         session_id: context.session_id,
         context_key: `${artifact.type}_${artifact.name}_created`,
         context_value: JSON.stringify({
           sys_id: artifact.sys_id,
           created_by: context.agent_id,
           timestamp: new Date().toISOString(),
         }),
         created_by_agent: context.agent_id,
       })
       this.logger.info(`Stored artifact ${artifact.name} (${artifact.sys_id})`)
     } catch (error) {
       this.logger.error("Failed to store artifact", error)
       throw error
   /**
    * Request Queen intervention for critical issues
    */
   async requestQueenIntervention(
     context: AgentContext,
     issue: {
       type: string
       priority: "low" | "medium" | "high" | "critical"
       description: string
       attempted_solutions?: string[]
     },
   ): Promise<void> {
     try {
       await this.memory.sendAgentMessage({
         session_id: context.session_id,
         from_agent: context.agent_id,
         to_agent: "queen_agent",
         message_type: "error",
         content: JSON.stringify({
           issue_type: issue.type,
           priority: issue.priority,
           description: issue.description,
           attempted_solutions: issue.attempted_solutions || [],
           requesting_agent: context.agent_id,
           timestamp: new Date().toISOString(),
         }),
       })
       // Update agent status to blocked
       await this.memory.updateAgentCoordination({
         session_id: context.session_id,
         agent_id: context.agent_id,
         agent_type: context.agent_type,
         status: "blocked",
         error_state: issue.description,
       })
       this.logger.warn(`Requested Queen intervention for ${issue.type}`)
     } catch (error) {
       this.logger.error("Failed to request Queen intervention", error)
       throw error
   /**
    * Get session artifacts created by all agents
    */
   async getSessionArtifacts(session_id: string): Promise<any[]> {
     try {
       return await this.memory.getSessionArtifacts(session_id)
     } catch (error) {
       this.logger.error("Failed to get session artifacts", error)
       return []
   /**
    * Get current session context
    */
   async getSessionContext(session_id: string): Promise<any> {
     try {
       return await this.memory.getSessionContext(session_id)
     } catch (error) {
       this.logger.error("Failed to get session context", error)
       return {}

src/servicenow/shared/base-mcp-server.ts

Sorry, the diff of this file is too big to display

-387

src/servicenow/shared/enhanced-base-mcp-server.ts

		/**
		* 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 { mcpAuth } from "../../utils/mcp-auth-middleware.js"
		import { ServiceNowAuditLogger, getAuditLogger } from "../../utils/servicenow-audit-logger.js"

		export interface MCPToolResult {
		content: Array<{
		type: string
		text: string
		}>
		[key: string]: unknown // Add index signature for MCP SDK compatibility
		}

		export abstract class EnhancedBaseMCPServer {
		protected server: Server
		protected client: ServiceNowClientWithTracking
		protected logger: MCPLogger
		protected auditLogger: ServiceNowAuditLogger
		protected oauth: ServiceNowOAuth
		protected isAuthenticated: boolean = false
		protected serverName: string

		constructor(name: string, version: string = "1.0.0") {
		this.serverName = name

		// Create enhanced logger
		this.logger = new MCPLogger(name)

		// Initialize ServiceNow audit logger
		this.auditLogger = getAuditLogger(this.logger, name)

		// Log startup
		this.logger.info(`🚀 Starting ${name} MCP Server v${version}`)

		// Create enhanced client with tracking
		this.client = new ServiceNowClientWithTracking(this.logger)

		// Connect audit logger to ServiceNow client
		this.auditLogger.setServiceNowClient(this.client.getBaseClient())

		// Initialize OAuth
		this.oauth = new ServiceNowOAuth()

		// Create server with capabilities
		this.server = new Server(
		{
		name,
		version,
		},
		{
		capabilities: {
		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 with audit logging`)
		}

		/**
		* Execute tool with enhanced tracking and audit logging
		*/
		protected async executeTool(
		toolName: string,
		handler: () => Promise<MCPToolResult>,
		params?: any,
		): Promise<MCPToolResult> {
		const startTime = Date.now()

		// Reset tokens at start of each operation to avoid accumulation
		this.logger.resetTokens()

		// Start operation tracking
		this.logger.operationStart(toolName)

		try {
		// Ensure authentication
		await 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) {
		process.send({
		type: "token_usage",
		data: {
		tool: toolName,
		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}: ${errorMessage}`,
		},
		],
		}
		}
		}

		/**
		* Validate ServiceNow connection with progress
		*/
		protected async validateConnection(): Promise<{ success: boolean; error?: string }> {
		this.logger.progress("Validating ServiceNow connection...")

		try {
		// Check credentials
		const credentials = await this.oauth.loadCredentials()
		if (!credentials) {
		return {
		success: false,
		error: 'No ServiceNow credentials found. Run "snow-flow auth login"',
		}
		}

		// Check token
		if (!credentials.accessToken) {
		return {
		success: false,
		error: 'OAuth authentication required. Run "snow-flow auth login"',
		}
		}

		// Test connection
		this.logger.progress("Testing ServiceNow API connection...")
		const connectionTest = await this.client.testConnection()

		if (!connectionTest.success) {
		return {
		success: false,
		error: `ServiceNow connection failed: ${connectionTest.error}`,
		}
		}

		this.logger.info("✅ ServiceNow connection validated")
		return { success: true }
		} catch (error) {
		this.logger.error("Connection validation failed", error)
		return {
		success: false,
		error: error instanceof Error ? error.message : String(error),
		}
		}
		}

		/**
		* Create standardized response with tracking
		*/
		protected createResponse(message: string, data?: any): MCPToolResult {
		// Log the response
		this.logger.debug("Tool response", { message, hasData: !!data })

		// Format response
		const response: MCPToolResult = {
		content: [
		{
		type: "text",
		text: message,
		},
		],
		}

		// Add data if provided
		if (data) {
		response.content[0].text += "\n\n" + JSON.stringify(data, null, 2)
		}

		return response
		}

		/**
		* Query table with progress tracking and audit logging
		*/
		protected async queryTable(table: string, query: string, limit: number = 10): Promise<any> {
		const startTime = Date.now()
		this.logger.progress(`Querying ${table} table (limit: ${limit})...`)

		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 and audit logging
		*/
		protected async createRecord(table: string, data: any): Promise<any> {
		const startTime = Date.now()
		this.logger.progress(`Creating ${table} record...`)

		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
		}
		}

		/**
		* Update record with tracking and audit logging
		*/
		protected async updateRecord(table: string, sysId: string, data: any): Promise<any> {
		const startTime = Date.now()
		this.logger.progress(`Updating ${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
		}
		}

		/**
		* Get record with tracking and audit logging
		*/
		protected async getRecord(table: string, sysId: string): Promise<any> {
		const startTime = Date.now()
		this.logger.progress(`Getting ${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
		}
		}

		/**
		* Get client for direct use
		*/
		public getClient(): ServiceNowClientWithTracking {
		return this.client
		}

		/**
		* Get logger for direct use
		*/
		public getLogger(): MCPLogger {
		return this.logger
		}

		/**
		* Get audit logger for direct use
		*/
		public getAuditLogger(): ServiceNowAuditLogger {
		return this.auditLogger
		}

		/**
		* Cleanup resources and flush audit logs
		*/
		public async cleanup(): Promise<void> {
		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)
		}
		}
		}

-269

src/servicenow/shared/mcp-logger.ts

		/**
		* Enhanced MCP Logger with Token Tracking and Progress Reporting
		* Sends logs to stderr so they appear in Claude Code console
		*/

		import { mcpDebug } from "./mcp-debug.js"

		interface TokenUsage {
		input: number
		output: number
		total: number
		}

		export class MCPLogger {
		private name: string
		private tokenUsage: TokenUsage = { input: 0, output: 0, total: 0 }
		private startTime: number = Date.now()
		private lastProgressTime: number = Date.now()
		private progressInterval: NodeJS.Timeout \| null = null

		constructor(name: string) {
		this.name = name
		// Don't start progress indicator automatically - only start when needed
		}

		/**
		* Log to stderr with proper formatting
		*/
		private log(level: string, message: string, data?: any) {
		const timestamp = new Date().toISOString()
		const logEntry = {
		timestamp,
		level,
		service: this.name,
		message,
		data,
		tokens: this.tokenUsage.total,
		duration: Math.round((Date.now() - this.startTime) / 1000),
		}

		// Send to stderr so it appears in console
		mcpDebug(`[${this.name}] ${level}: ${message}`, data ? JSON.stringify(data, null, 2) : "")

		// Also send structured log for potential parsing
		if (process.send) {
		process.send({
		type: "log",
		data: logEntry,
		})
		}
		}

		/**
		* Start progress indicator for long-running operations
		*/
		private startProgressIndicator() {
		// Send progress every 5 seconds (reduced frequency)
		this.progressInterval = setInterval(() => {
		const duration = Math.round((Date.now() - this.startTime) / 1000)

		// CRITICAL: Stop progress after 60 seconds to prevent infinite loops
		if (duration > 60) {
		mcpDebug(`⚠️ [${this.name}] Operation exceeded maximum time (60s). Stopping progress indicator.`)
		this.stopProgress()

		// Force stop the operation by throwing timeout error
		const timeoutError = new Error(`Operation timeout: exceeded 60 seconds`)
		this.operationError("Operation timeout", timeoutError)
		return
		}

		if (duration > 3) {
		// Only show progress after 3+ seconds
		this.progress(`Operation in progress... (${duration}s elapsed, ${this.tokenUsage.total} tokens used)`)
		}
		}, 5000)
		}

		/**
		* Stop progress indicator
		*/
		public stopProgress() {
		if (this.progressInterval) {
		clearInterval(this.progressInterval)
		this.progressInterval = null
		}
		}

		/**
		* Log info message
		*/
		public info(message: string, data?: any) {
		this.log("INFO", message, data)
		}

		/**
		* Log warning message
		*/
		public warn(message: string, data?: any) {
		this.log("WARN", message, data)
		}

		/**
		* Log error message
		*/
		public error(message: string, error?: any) {
		const errorData =
		error instanceof Error
		? {
		message: error.message,
		stack: error.stack,
		name: error.name,
		}
		: error
		this.log("ERROR", message, errorData)
		}

		/**
		* Log operation error - ensures progress indicator is stopped
		*/
		public operationError(operation: string, error: any) {
		const duration = Math.round((Date.now() - this.startTime) / 1000)

		// Always stop progress indicator when operation fails
		this.stopProgress()

		this.error(`❌ Failed: ${operation} (${duration}s)`, error)
		}

		/**
		* Log debug message
		*/
		public debug(message: string, data?: any) {
		if (process.env.DEBUG === "true" \|\| process.env.NODE_ENV === "development") {
		this.log("DEBUG", message, data)
		}
		}

		/**
		* Log progress update
		*/
		public progress(message: string) {
		// Only log progress if enough time has passed
		const now = Date.now()
		if (now - this.lastProgressTime > 1000) {
		this.lastProgressTime = now
		mcpDebug(`⏳ [${this.name}] ${message}`)
		}
		}

		/**
		* Track API call
		*/
		public trackAPICall(operation: string, table?: string, recordCount?: number) {
		const message = `🔄 API Call: ${operation}${table ? ` on ${table}` : ""}${recordCount ? ` (${recordCount} records)` : ""}`
		this.info(message)

		// NOTE: Removed automatic token estimation as it was inaccurate
		// Real token usage should come from Claude Code's actual measurements
		}

		/**
		* Add token usage
		*/
		public addTokens(input: number, output: number) {
		this.tokenUsage.input += input
		this.tokenUsage.output += output
		this.tokenUsage.total = this.tokenUsage.input + this.tokenUsage.output

		// Only log token usage in debug mode to avoid spam
		if (process.env.MCP_DEBUG === "true" && this.tokenUsage.total > 0) {
		mcpDebug(
		`📊 [${this.name}] Tokens used: ${this.tokenUsage.total} (in: ${this.tokenUsage.input}, out: ${this.tokenUsage.output})`,
		)
		}
		}

		/**
		* Log operation start
		*/
		public operationStart(operation: string, params?: any) {
		this.startTime = Date.now()
		this.resetTokens() // Actually reset tokens when starting new operation!
		this.info(`🚀 Starting: ${operation}`, params)

		// Start progress indicator after 3 seconds (only for long operations)
		setTimeout(() => {
		if (!this.progressInterval) {
		this.startProgressIndicator()
		}
		}, 3000)
		}

		/**
		* Log operation complete
		*/
		public operationComplete(operation: string, result?: any) {
		const duration = Math.round((Date.now() - this.startTime) / 1000)

		// Always stop progress indicator first
		this.stopProgress()

		this.info(`✅ Completed: ${operation} (${duration}s, ${this.tokenUsage.total} tokens)`, result)

		// Only show token report for operations with actual token usage
		if (this.tokenUsage.total > 0 && duration > 1) {
		mcpDebug(`📊 [${this.name}] ${operation} completed: ${duration}s, ${this.tokenUsage.total} tokens`)
		}
		}

		/**
		* Get token usage
		*/
		public getTokenUsage(): TokenUsage {
		return { ...this.tokenUsage }
		}

		/**
		* Add token usage to MCP response
		* Helper method to append token usage to tool response via _meta field
		*/
		public addTokenUsageToResponse(result: any): any {
		const tokenUsage = this.getTokenUsage()
		if (tokenUsage.total > 0) {
		// Add token usage to _meta field for Claude Code UI
		if (!result._meta) {
		result._meta = {}
		}
		result._meta.tokenUsage = {
		input: tokenUsage.input,
		output: tokenUsage.output,
		total: tokenUsage.total,
		}

		// Token usage is available in _meta.tokenUsage for debugging
		// We no longer automatically add it to response text to avoid pollution
		}
		return result
		}

		/**
		* Reset token usage
		*/
		public resetTokens() {
		this.tokenUsage = { input: 0, output: 0, total: 0 }
		mcpDebug(`🔄 [${this.name}] Token counter reset for new operation`)
		}
		}

		/**
		* Create a singleton logger instance for consistent logging
		*/
		let globalLogger: MCPLogger \| null = null

		export function getGlobalLogger(name?: string): MCPLogger {
		if (!globalLogger) {
		globalLogger = new MCPLogger(name \|\| "MCP-Server")
		}
		return globalLogger
		}

		/**
		* Log formatter for consistent output
		*/
		export function formatLogMessage(level: string, message: string, data?: any): string {
		const timestamp = new Date().toISOString().split("T")[1].split(".")[0]
		const dataStr = data ? ` \| ${JSON.stringify(data)}` : ""
		return `[${timestamp}] ${level.padEnd(5)} \| ${message}${dataStr}`
		}

-567

src/servicenow/shared/mcp-memory-manager.ts

		/**
		* MCP Memory Manager
		* Shared memory integration for all MCP servers to coordinate with agents
		*/

		import Database from "better-sqlite3"
		import * as path from "path"
		import * as fs from "fs"
		import crypto from "crypto"
		import { Logger } from "../utils/logger.js"

		export interface AgentContext {
		session_id: string
		agent_id: string
		agent_type: string
		required_scopes?: string[]
		}

		export interface ArtifactRecord {
		sys_id: string
		artifact_type: string
		name: string
		description?: string
		created_by_agent: string
		session_id: string
		deployment_status: string
		update_set_id?: string
		dependencies?: string
		metadata?: string
		}

		export interface AgentCoordination {
		session_id: string
		agent_id: string
		agent_type: string
		status: "spawned" \| "active" \| "blocked" \| "completed"
		assigned_tasks?: string
		progress_percentage: number
		last_activity: Date
		current_tool?: string
		error_state?: string
		}

		export interface SharedContext {
		session_id: string
		context_key: string
		context_value: string
		created_by_agent: string
		expires_at?: Date
		access_permissions?: string
		}

		export interface AgentMessage {
		id: string
		session_id: string
		from_agent: string
		to_agent: string
		message_type: "handoff" \| "dependency_ready" \| "error" \| "status_update"
		content: string
		artifact_reference?: string
		timestamp: Date
		processed: boolean
		}

		export interface PerformanceMetric {
		session_id: string
		agent_id: string
		operation_name: string
		duration_ms: number
		success: boolean
		error_message?: string
		timestamp: Date
		}

		export class MCPMemoryManager {
		private db: Database.Database
		private logger: Logger
		private static instance: MCPMemoryManager

		private constructor() {
		this.logger = new Logger("MCPMemoryManager")

		// Create memory directory if it doesn't exist
		const memoryDir = path.join(process.cwd(), ".snow-flow", "memory")
		if (!fs.existsSync(memoryDir)) {
		fs.mkdirSync(memoryDir, { recursive: true })
		}

		// Initialize database
		this.db = new Database(path.join(memoryDir, "mcp-coordination.db"))
		this.initializeDatabase()
		}

		static getInstance(): MCPMemoryManager {
		if (!MCPMemoryManager.instance) {
		MCPMemoryManager.instance = new MCPMemoryManager()
		}
		return MCPMemoryManager.instance
		}

		private initializeDatabase(): void {
		this.logger.info("Initializing MCP coordination database")

		this.db.exec(`
		-- Agent coordination and communication
		CREATE TABLE IF NOT EXISTS agent_coordination (
		session_id TEXT NOT NULL,
		agent_id TEXT NOT NULL,
		agent_type TEXT NOT NULL,
		status TEXT NOT NULL,
		assigned_tasks TEXT,
		progress_percentage INTEGER DEFAULT 0,
		last_activity TEXT NOT NULL,
		current_tool TEXT,
		error_state TEXT,
		PRIMARY KEY (session_id, agent_id)
		);

		-- ServiceNow artifact tracking
		CREATE TABLE IF NOT EXISTS servicenow_artifacts (
		sys_id TEXT PRIMARY KEY,
		artifact_type TEXT NOT NULL,
		name TEXT NOT NULL,
		description TEXT,
		created_by_agent TEXT NOT NULL,
		session_id TEXT NOT NULL,
		deployment_status TEXT NOT NULL,
		update_set_id TEXT,
		dependencies TEXT,
		metadata TEXT,
		created_at TEXT DEFAULT (datetime('now'))
		);

		-- Inter-agent communication
		CREATE TABLE IF NOT EXISTS agent_messages (
		id TEXT PRIMARY KEY,
		session_id TEXT NOT NULL,
		from_agent TEXT NOT NULL,
		to_agent TEXT NOT NULL,
		message_type TEXT NOT NULL,
		content TEXT NOT NULL,
		artifact_reference TEXT,
		timestamp TEXT NOT NULL,
		processed INTEGER DEFAULT 0
		);

		-- Shared context between agents
		CREATE TABLE IF NOT EXISTS shared_context (
		session_id TEXT NOT NULL,
		context_key TEXT NOT NULL,
		context_value TEXT NOT NULL,
		created_by_agent TEXT NOT NULL,
		expires_at TEXT,
		access_permissions TEXT,
		created_at TEXT DEFAULT (datetime('now')),
		PRIMARY KEY (session_id, context_key)
		);

		-- Deployment tracking
		CREATE TABLE IF NOT EXISTS deployment_history (
		id TEXT PRIMARY KEY,
		session_id TEXT NOT NULL,
		artifact_sys_id TEXT NOT NULL,
		deployment_type TEXT NOT NULL,
		success INTEGER NOT NULL,
		deployment_time TEXT NOT NULL,
		agent_id TEXT NOT NULL,
		error_details TEXT,
		rollback_available INTEGER DEFAULT 0
		);

		-- Agent dependencies and handoffs
		CREATE TABLE IF NOT EXISTS agent_dependencies (
		session_id TEXT NOT NULL,
		agent_id TEXT NOT NULL,
		depends_on_agent TEXT NOT NULL,
		dependency_type TEXT NOT NULL,
		artifact_reference TEXT,
		status TEXT NOT NULL,
		created_at TEXT DEFAULT (datetime('now')),
		satisfied_at TEXT,
		PRIMARY KEY (session_id, agent_id, depends_on_agent)
		);

		-- Performance metrics
		CREATE TABLE IF NOT EXISTS performance_metrics (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		session_id TEXT NOT NULL,
		agent_id TEXT NOT NULL,
		operation_name TEXT NOT NULL,
		duration_ms INTEGER NOT NULL,
		success INTEGER NOT NULL,
		error_message TEXT,
		timestamp TEXT NOT NULL
		);

		-- Create indexes for better performance
		CREATE INDEX IF NOT EXISTS idx_artifacts_session ON servicenow_artifacts(session_id);
		CREATE INDEX IF NOT EXISTS idx_coordination_session ON agent_coordination(session_id);
		CREATE INDEX IF NOT EXISTS idx_messages_session ON agent_messages(session_id);
		CREATE INDEX IF NOT EXISTS idx_context_session ON shared_context(session_id);
		`)
		}

		// Read session context
		async getSessionContext(session_id: string): Promise<any> {
		try {
		const contexts = this.db
		.prepare(
		`
		SELECT * FROM shared_context
		WHERE session_id = ?
		AND (expires_at IS NULL OR expires_at > datetime('now'))
		`,
		)
		.all(session_id)

		const result: Record<string, any> = {}
		for (const context of contexts as SharedContext[]) {
		try {
		result[context.context_key] = JSON.parse(context.context_value)
		} catch {
		result[context.context_key] = context.context_value
		}
		}

		return result
		} catch (error) {
		this.logger.error("Failed to get session context", error)
		return {}
		}
		}

		// Get active agents for session
		async getActiveAgents(session_id: string): Promise<AgentCoordination[]> {
		try {
		const agents = this.db
		.prepare(
		`
		SELECT * FROM agent_coordination
		WHERE session_id = ? AND status IN ('active', 'spawned')
		`,
		)
		.all(session_id)

		return agents as AgentCoordination[]
		} catch (error) {
		this.logger.error("Failed to get active agents", error)
		return []
		}
		}

		// Store artifact information
		async storeArtifact(artifact: ArtifactRecord): Promise<void> {
		try {
		const stmt = this.db.prepare(`
		INSERT OR REPLACE INTO servicenow_artifacts
		(sys_id, artifact_type, name, description, created_by_agent, session_id,
		deployment_status, update_set_id, dependencies, metadata)
		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
		`)

		stmt.run(
		artifact.sys_id,
		artifact.artifact_type,
		artifact.name,
		artifact.description \|\| null,
		artifact.created_by_agent,
		artifact.session_id,
		artifact.deployment_status,
		artifact.update_set_id \|\| null,
		artifact.dependencies \|\| null,
		artifact.metadata \|\| null,
		)

		this.logger.debug(`Stored artifact ${artifact.name} (${artifact.sys_id})`)
		} catch (error) {
		this.logger.error("Failed to store artifact", error)
		throw error
		}
		}

		// Update shared context
		async updateSharedContext(context: SharedContext): Promise<void> {
		try {
		const stmt = this.db.prepare(`
		INSERT OR REPLACE INTO shared_context
		(session_id, context_key, context_value, created_by_agent, expires_at, access_permissions)
		VALUES (?, ?, ?, ?, ?, ?)
		`)

		stmt.run(
		context.session_id,
		context.context_key,
		context.context_value,
		context.created_by_agent,
		context.expires_at ? context.expires_at.toISOString() : null,
		context.access_permissions \|\| null,
		)

		this.logger.debug(`Updated shared context: ${context.context_key}`)
		} catch (error) {
		this.logger.error("Failed to update shared context", error)
		throw error
		}
		}

		// Update agent coordination status
		async updateAgentCoordination(
		coordination: Partial<AgentCoordination> & { agent_id: string; session_id: string },
		): Promise<void> {
		try {
		// Build dynamic update query based on provided fields
		const updates: string[] = []
		const values: any[] = []

		if (coordination.status !== undefined) {
		updates.push("status = ?")
		values.push(coordination.status)
		}
		if (coordination.progress_percentage !== undefined) {
		updates.push("progress_percentage = ?")
		values.push(coordination.progress_percentage)
		}
		if (coordination.current_tool !== undefined) {
		updates.push("current_tool = ?")
		values.push(coordination.current_tool)
		}
		if (coordination.error_state !== undefined) {
		updates.push("error_state = ?")
		values.push(coordination.error_state)
		}

		// Always update last_activity
		updates.push('last_activity = datetime("now")')

		// Add WHERE clause values
		values.push(coordination.agent_id, coordination.session_id)

		const stmt = this.db.prepare(`
		UPDATE agent_coordination
		SET ${updates.join(", ")}
		WHERE agent_id = ? AND session_id = ?
		`)

		const result = stmt.run(...values)

		// If no rows updated, create new record
		if (result.changes === 0) {
		const insertStmt = this.db.prepare(`
		INSERT INTO agent_coordination
		(session_id, agent_id, agent_type, status, progress_percentage, last_activity)
		VALUES (?, ?, ?, ?, ?, datetime('now'))
		`)

		insertStmt.run(
		coordination.session_id,
		coordination.agent_id,
		coordination.agent_type \|\| "unknown",
		coordination.status \|\| "active",
		coordination.progress_percentage \|\| 0,
		)
		}

		this.logger.debug(`Updated agent coordination for ${coordination.agent_id}`)
		} catch (error) {
		this.logger.error("Failed to update agent coordination", error)
		throw error
		}
		}

		// Send message between agents
		async sendAgentMessage(message: Omit<AgentMessage, "id" \| "timestamp" \| "processed">): Promise<void> {
		try {
		const id = `msg_${Date.now()}_${crypto.randomBytes(6).toString("hex")}`

		const stmt = this.db.prepare(`
		INSERT INTO agent_messages
		(id, session_id, from_agent, to_agent, message_type, content, artifact_reference, timestamp, processed)
		VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'), 0)
		`)

		stmt.run(
		id,
		message.session_id,
		message.from_agent,
		message.to_agent,
		message.message_type,
		message.content,
		message.artifact_reference \|\| null,
		)

		this.logger.debug(`Sent message from ${message.from_agent} to ${message.to_agent}`)
		} catch (error) {
		this.logger.error("Failed to send agent message", error)
		throw error
		}
		}

		// Check for pending messages
		async checkForMessages(agent_id: string, session_id: string): Promise<AgentMessage[]> {
		try {
		const messages = this.db
		.prepare(
		`
		SELECT * FROM agent_messages
		WHERE session_id = ? AND to_agent = ? AND processed = 0
		ORDER BY timestamp ASC
		`,
		)
		.all(session_id, agent_id)

		// Mark messages as processed
		if (messages.length > 0) {
		const ids = messages.map((m: any) => m.id)
		const placeholders = ids.map(() => "?").join(",")
		this.db
		.prepare(
		`
		UPDATE agent_messages
		SET processed = 1
		WHERE id IN (${placeholders})
		`,
		)
		.run(...ids)
		}

		return messages as AgentMessage[]
		} catch (error) {
		this.logger.error("Failed to check for messages", error)
		return []
		}
		}

		// Track performance metrics
		async trackPerformance(metric: Omit<PerformanceMetric, "timestamp">): Promise<void> {
		try {
		const stmt = this.db.prepare(`
		INSERT INTO performance_metrics
		(session_id, agent_id, operation_name, duration_ms, success, error_message, timestamp)
		VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
		`)

		stmt.run(
		metric.session_id,
		metric.agent_id,
		metric.operation_name,
		metric.duration_ms,
		metric.success ? 1 : 0,
		metric.error_message \|\| null,
		)

		this.logger.debug(`Tracked performance: ${metric.operation_name} (${metric.duration_ms}ms)`)
		} catch (error) {
		this.logger.error("Failed to track performance", error)
		}
		}

		// Record deployment
		async recordDeployment(
		session_id: string,
		artifact_sys_id: string,
		deployment_type: string,
		success: boolean,
		agent_id: string,
		error_details?: string,
		): Promise<void> {
		try {
		const id = `deploy_${Date.now()}_${crypto.randomBytes(6).toString("hex")}`

		const stmt = this.db.prepare(`
		INSERT INTO deployment_history
		(id, session_id, artifact_sys_id, deployment_type, success, deployment_time, agent_id, error_details, rollback_available)
		VALUES (?, ?, ?, ?, ?, datetime('now'), ?, ?, ?)
		`)

		stmt.run(
		id,
		session_id,
		artifact_sys_id,
		deployment_type,
		success ? 1 : 0,
		agent_id,
		error_details \|\| null,
		success ? 1 : 0,
		)

		this.logger.debug(`Recorded deployment: ${deployment_type} for ${artifact_sys_id}`)
		} catch (error) {
		this.logger.error("Failed to record deployment", error)
		throw error
		}
		}

		// Get artifact by sys_id
		async getArtifact(sys_id: string): Promise<ArtifactRecord \| null> {
		try {
		const artifact = this.db
		.prepare(
		`
		SELECT * FROM servicenow_artifacts WHERE sys_id = ?
		`,
		)
		.get(sys_id)

		return artifact as ArtifactRecord \| null
		} catch (error) {
		this.logger.error("Failed to get artifact", error)
		return null
		}
		}

		// Get all artifacts for session
		async getSessionArtifacts(session_id: string): Promise<ArtifactRecord[]> {
		try {
		const artifacts = this.db
		.prepare(
		`
		SELECT * FROM servicenow_artifacts
		WHERE session_id = ?
		ORDER BY created_at DESC
		`,
		)
		.all(session_id)

		return artifacts as ArtifactRecord[]
		} catch (error) {
		this.logger.error("Failed to get session artifacts", error)
		return []
		}
		}

		// Clear session data (for cleanup)
		async clearSession(session_id: string): Promise<void> {
		try {
		this.logger.info(`Clearing session data for ${session_id}`)

		// Clear all session-related data
		this.db.prepare("DELETE FROM agent_coordination WHERE session_id = ?").run(session_id)
		this.db.prepare("DELETE FROM agent_messages WHERE session_id = ?").run(session_id)
		this.db.prepare("DELETE FROM shared_context WHERE session_id = ?").run(session_id)
		this.db.prepare("DELETE FROM agent_dependencies WHERE session_id = ?").run(session_id)
		this.db.prepare("DELETE FROM performance_metrics WHERE session_id = ?").run(session_id)

		this.logger.info(`Cleared session data for ${session_id}`)
		} catch (error) {
		this.logger.error("Failed to clear session", error)
		throw error
		}
		}

		// Generic query method for custom queries
		async query(sql: string, params: any[] = []): Promise<any[]> {
		try {
		const stmt = this.db.prepare(sql)
		return stmt.all(...params)
		} catch (error) {
		this.logger.error("Query failed", { sql, error })
		throw error
		}
		}

		// Close database connection
		close(): void {
		this.db.close()
		}
		}

-226

src/servicenow/shared/MCP-PROMPTS.md

		# MCP Prompts - Snow-Flow ServiceNow Templates

		This document describes the MCP Prompts feature in Snow-Flow, providing reusable prompt templates for ServiceNow development tasks.

		## What are MCP Prompts?

		MCP (Model Context Protocol) Prompts are standardized, reusable prompt templates that can be discovered and invoked by MCP clients. They provide:

		- Consistency: Same prompt structure across all clients
		- Discoverability: Clients can list available prompts
		- Arguments: Typed parameters for customization
		- Best Practices: Built-in ServiceNow standards (ES5, patterns)

		## Available Prompts (15 total)

		### Development Category (4 prompts)

		\| Prompt \| Description \| Required Args \|
		\| --------------------------- \| ------------------------------ \| ----------------------------------------- \|
		\| `servicenow_widget_create` \| Generate Service Portal widget \| widget_name, description \|
		\| `servicenow_script_include` \| Create Script Include class \| class_name, purpose \|
		\| `servicenow_business_rule` \| Generate Business Rule \| name, table, when, operation, description \|
		\| `servicenow_client_script` \| Create Client Script \| table, type, description \|

		### Platform Category (3 prompts)

		\| Prompt \| Description \| Required Args \|
		\| ---------------------- \| ---------------------------- \| ------------------------------------- \|
		\| `servicenow_ui_policy` \| Design UI Policy \| table, conditions, actions \|
		\| `servicenow_ui_action` \| Create UI Action button/link \| table, action_name, type, description \|
		\| `servicenow_acl` \| Design Access Control rule \| table, operation, requirements \|

		### Automation Category (3 prompts)

		\| Prompt \| Description \| Required Args \|
		\| -------------------------- \| ------------------------- \| --------------------------------- \|
		\| `servicenow_flow_designer` \| Design Flow Designer flow \| flow_name, trigger, actions \|
		\| `servicenow_notification` \| Create Email Notification \| table, event, recipients, content \|
		\| `servicenow_scheduled_job` \| Create Scheduled Job \| name, schedule, description \|

		### Debugging Category (2 prompts)

		\| Prompt \| Description \| Required Args \|
		\| ------------------------ \| -------------------------- \| ---------------------- \|
		\| `servicenow_debug` \| Debug ServiceNow issues \| error_message, context \|
		\| `servicenow_glide_query` \| Generate GlideRecord query \| table, conditions \|

		### Integration Category (2 prompts)

		\| Prompt \| Description \| Required Args \|
		\| ---------------------------- \| --------------------------- \| ------------------------------------------ \|
		\| `servicenow_api_integration` \| Create REST API integration \| api_name, endpoint, method, description \|
		\| `servicenow_transform_map` \| Design Transform Map \| source_table, target_table, field_mappings \|

		### Catalog Category (1 prompt)

		\| Prompt \| Description \| Required Args \|
		\| ------------------------- \| --------------------------- \| -------------------------------------- \|
		\| `servicenow_catalog_item` \| Design Service Catalog Item \| name, category, description, variables \|

		## Usage

		### Via MCP Protocol

		```javascript
		// List all available prompts
		const prompts = await mcpClient.listPrompts()

		// Get a specific prompt with arguments
		const result = await mcpClient.getPrompt("servicenow_widget_create", {
		widget_name: "user_profile",
		description: "Display user profile information",
		features: "avatar, edit button, activity feed",
		})

		// Result contains messages array ready for LLM
		console.log(result.messages)
		```

		### Via MCPPromptManager (Server-side)

		```typescript
		import { MCPPromptManager } from "./mcp-prompt-manager.js"

		const manager = new MCPPromptManager("my-server")

		// List prompts
		const prompts = manager.listPrompts()

		// Execute prompt
		const result = await manager.executePrompt("servicenow_business_rule", {
		name: "Set Priority",
		table: "incident",
		when: "before",
		operation: "insert",
		description: "Auto-set priority based on impact and urgency",
		})

		// Search prompts
		const debugPrompts = manager.searchPrompts("debug")

		// Get by category
		const devPrompts = manager.getPromptsByCategory("development")
		```

		## Creating Custom Prompts

		You can register custom prompts in your MCP server:

		```typescript
		import { MCPPromptManager } from "./mcp-prompt-manager.js"

		const manager = new MCPPromptManager("my-server")

		// Register a custom prompt
		manager.registerPrompt(
		{
		name: "my_custom_prompt",
		description: "My custom ServiceNow prompt",
		arguments: [
		{ name: "param1", description: "First parameter", required: true },
		{ name: "param2", description: "Optional parameter", required: false },
		],
		},
		async (args) => ({
		messages: [
		{
		role: "user",
		content: {
		type: "text",
		text: `Custom prompt with ${args.param1} and ${args.param2 \|\| "default"}`,
		},
		},
		],
		}),
		)
		```

		## Best Practices

		### All Prompts Include:

		1. ES5 Syntax Requirement - ServiceNow uses Rhino engine
		2. Error Handling - Proper try/catch patterns
		3. Logging - gs.info/warn/error usage
		4. Performance - Query optimization tips
		5. Security - ACL and role considerations

		### When to Use Prompts:

		- UI Applications: Prompt selector for stakeholders
		- Standardization: Consistent output across teams
		- Onboarding: New developers learn patterns
		- Enterprise: Portal integration for non-technical users

		### When to Use CLAUDE.md/AGENTS.md Instead:

		- CLI/Agent workflows: System prompts loaded at session start
		- Complex context: Multi-file operations
		- Persistent rules: Always-active guidelines

		## API Reference

		### MCPPromptManager

		```typescript
		class MCPPromptManager {
		// List all prompts
		listPrompts(): MCPPrompt[]

		// Get specific prompt
		getPrompt(name: string): MCPPrompt \| undefined

		// Execute prompt with args
		executePrompt(name: string, args: Record<string, string>): Promise<MCPPromptResult>

		// Register custom prompt
		registerPrompt(prompt: MCPPrompt, handler: PromptHandler): void

		// Unregister prompt
		unregisterPrompt(name: string): boolean

		// Get prompts by category
		getPromptsByCategory(category: string): MCPPrompt[]

		// Get all categories
		getCategories(): PromptCategory[]

		// Search prompts
		searchPrompts(query: string): MCPPrompt[]

		// Get statistics
		getPromptStats(): { total: number; categories: Record<string, number> }
		}
		```

		### Types

		```typescript
		interface MCPPrompt {
		name: string
		description?: string
		arguments?: MCPPromptArgument[]
		}

		interface MCPPromptArgument {
		name: string
		description?: string
		required?: boolean
		}

		interface MCPPromptResult {
		description?: string
		messages: MCPPromptMessage[]
		}

		interface MCPPromptMessage {
		role: "user" \| "assistant"
		content: MCPPromptContent
		}
		```

		## Version History

		- v9.0.150: Added 8 new prompts (client script, UI policy, UI action, ACL, notification, scheduled job, transform map, catalog item), expanded categories
		- v9.0.149: Initial release with 7 prompts (widget, script include, business rule, flow designer, debug, glide query, API integration)

-367

src/servicenow/shared/mcp-resource-manager.ts

		/**
		* MCP Resource Manager
		* Comprehensive resource management for MCP servers
		*/

		import { readFile, readdir, stat } from "fs/promises"
		import { join, extname, basename } from "path"
		import { Logger } from "../utils/logger.js"

		export interface MCPResource {
		uri: string
		name: string
		description?: string
		mimeType: string
		}

		export interface MCPResourceContent {
		uri: string
		mimeType: string
		text: string
		}

		export interface ResourceCategory {
		name: string
		description: string
		basePath: string
		uriPrefix: string
		}

		export class MCPResourceManager {
		private logger: Logger
		private resourceCache: Map<string, MCPResourceContent> = new Map()
		private resourceIndex: Map<string, MCPResource> = new Map()
		private categories: ResourceCategory[] = []

		constructor(serverName: string = "mcp-server") {
		this.logger = new Logger(`ResourceManager:${serverName}`)
		this.initializeCategories()
		}

		/**
		* Initialize resource categories
		*/
		private initializeCategories(): void {
		const projectRoot = this.getProjectRoot()

		this.categories = [
		{
		name: "templates",
		description: "ServiceNow artifact templates (widgets, flows, scripts, etc.)",
		basePath: join(projectRoot, "src/templates"),
		uriPrefix: "servicenow://templates/",
		},
		{
		name: "documentation",
		description: "Setup guides, deployment documentation, and API references",
		basePath: projectRoot,
		uriPrefix: "servicenow://docs/",
		},
		{
		name: "schemas",
		description: "Data validation schemas and API schemas",
		basePath: join(projectRoot, "src/schemas"),
		uriPrefix: "servicenow://schemas/",
		},
		{
		name: "examples",
		description: "Example implementations and sample data",
		basePath: join(projectRoot, "src/templates/examples"),
		uriPrefix: "servicenow://examples/",
		},
		{
		name: "help",
		description: "Help content and guidance documents",
		basePath: join(projectRoot, "src/sparc"),
		uriPrefix: "servicenow://help/",
		},
		]
		}

		/**
		* Get project root directory
		*/
		private getProjectRoot(): string {
		// Use process.cwd() to get the current working directory
		// This should be the project root when running the application
		return process.cwd()
		}

		/**
		* List all available resources
		*/
		async listResources(): Promise<MCPResource[]> {
		if (this.resourceIndex.size === 0) {
		await this.buildResourceIndex()
		}

		return Array.from(this.resourceIndex.values())
		}

		/**
		* Read a specific resource by URI
		*/
		async readResource(uri: string): Promise<MCPResourceContent> {
		this.logger.debug(`Reading resource: ${uri}`)

		// Check cache first
		if (this.resourceCache.has(uri)) {
		this.logger.debug(`Resource found in cache: ${uri}`)
		return this.resourceCache.get(uri)!
		}

		// Parse URI and determine file path
		const filePath = this.uriToFilePath(uri)
		if (!filePath) {
		throw new Error(`Invalid resource URI: ${uri}`)
		}

		try {
		const content = await this.loadResourceContent(filePath, uri)

		// Cache the content
		this.resourceCache.set(uri, content)

		return content
		} catch (error) {
		this.logger.error(`Failed to read resource ${uri}:`, error)
		throw new Error(`Resource not found or inaccessible: ${uri}`)
		}
		}

		/**
		* Build comprehensive resource index
		*/
		private async buildResourceIndex(): Promise<void> {
		this.logger.info("Building resource index...")

		for (const category of this.categories) {
		try {
		await this.indexCategory(category)
		} catch (error) {
		this.logger.warn(`Failed to index category ${category.name}:`, error)
		}
		}

		this.logger.info(`Resource index built: ${this.resourceIndex.size} resources`)
		}

		/**
		* Index resources in a specific category
		*/
		private async indexCategory(category: ResourceCategory): Promise<void> {
		try {
		const stats = await stat(category.basePath)
		if (!stats.isDirectory()) {
		this.logger.debug(`Category path is not a directory: ${category.basePath}`)
		return
		}
		} catch (error) {
		this.logger.debug(`Category path does not exist: ${category.basePath}`)
		return
		}

		if (category.name === "documentation") {
		await this.indexDocumentationFiles(category)
		} else {
		await this.indexDirectoryRecursive(category.basePath, category)
		}
		}

		/**
		* Index documentation files (special handling for .md files in root)
		*/
		private async indexDocumentationFiles(category: ResourceCategory): Promise<void> {
		try {
		const files = await readdir(category.basePath)

		for (const file of files) {
		if (file.endsWith(".md") && file.toUpperCase().includes("SERVICENOW")) {
		const filePath = join(category.basePath, file)
		const uri = `${category.uriPrefix}${file}`

		const resource: MCPResource = {
		uri,
		name: this.formatResourceName(file),
		description: `ServiceNow documentation: ${this.formatResourceName(file)}`,
		mimeType: this.getMimeType(file),
		}

		this.resourceIndex.set(uri, resource)
		}
		}
		} catch (error) {
		this.logger.warn(`Failed to index documentation files:`, error)
		}
		}

		/**
		* Index directory recursively
		*/
		private async indexDirectoryRecursive(
		dirPath: string,
		category: ResourceCategory,
		relativePath: string = "",
		): Promise<void> {
		try {
		const entries = await readdir(dirPath)

		for (const entry of entries) {
		const fullPath = join(dirPath, entry)
		const entryRelativePath = relativePath ? join(relativePath, entry) : entry

		try {
		const stats = await stat(fullPath)

		if (stats.isDirectory()) {
		await this.indexDirectoryRecursive(fullPath, category, entryRelativePath)
		} else if (this.isResourceFile(entry)) {
		const uri = `${category.uriPrefix}${entryRelativePath.replace(/\\/g, "/")}`

		const resource: MCPResource = {
		uri,
		name: this.formatResourceName(entry),
		description: this.generateResourceDescription(entry, category.name),
		mimeType: this.getMimeType(entry),
		}

		this.resourceIndex.set(uri, resource)
		}
		} catch (error) {
		this.logger.debug(`Failed to process ${fullPath}:`, error)
		}
		}
		} catch (error) {
		this.logger.warn(`Failed to read directory ${dirPath}:`, error)
		}
		}

		/**
		* Check if file should be exposed as a resource
		*/
		private isResourceFile(filename: string): boolean {
		const resourceExtensions = [".json", ".md", ".yaml", ".yml", ".txt", ".ts", ".js"]
		const ext = extname(filename).toLowerCase()
		return resourceExtensions.includes(ext)
		}

		/**
		* Convert URI to file path
		*/
		private uriToFilePath(uri: string): string \| null {
		for (const category of this.categories) {
		if (uri.startsWith(category.uriPrefix)) {
		const relativePath = uri.substring(category.uriPrefix.length)

		if (category.name === "documentation") {
		// Documentation files are in root
		return join(category.basePath, relativePath)
		} else {
		return join(category.basePath, relativePath)
		}
		}
		}

		return null
		}

		/**
		* Load resource content from file
		*/
		private async loadResourceContent(filePath: string, uri: string): Promise<MCPResourceContent> {
		const content = await readFile(filePath, "utf-8")
		const mimeType = this.getMimeType(filePath)

		return {
		uri,
		mimeType,
		text: content,
		}
		}

		/**
		* Get MIME type for file
		*/
		private getMimeType(filePath: string): string {
		const ext = extname(filePath).toLowerCase()

		const mimeTypes: { [key: string]: string } = {
		".json": "application/json",
		".md": "text/markdown",
		".yaml": "application/yaml",
		".yml": "application/yaml",
		".txt": "text/plain",
		".ts": "text/typescript",
		".js": "text/javascript",
		".html": "text/html",
		".css": "text/css",
		}

		return mimeTypes[ext] \|\| "text/plain"
		}

		/**
		* Format resource name for display
		*/
		private formatResourceName(filename: string): string {
		const nameWithoutExt = basename(filename, extname(filename))

		// Convert various naming conventions to readable names
		return nameWithoutExt
		.replace(/[-_]/g, " ")
		.replace(/\b\w/g, (l) => l.toUpperCase())
		.replace(/\.(template\|schema\|example)/i, "")
		}

		/**
		* Generate resource description based on filename and category
		*/
		private generateResourceDescription(filename: string, categoryName: string): string {
		const name = this.formatResourceName(filename)

		const descriptions: { [key: string]: string } = {
		templates: `ServiceNow ${name} template`,
		documentation: `Documentation: ${name}`,
		schemas: `Validation schema for ${name}`,
		examples: `Example implementation: ${name}`,
		help: `Help content: ${name}`,
		}

		return descriptions[categoryName] \|\| `Resource: ${name}`
		}

		/**
		* Clear resource cache
		*/
		clearCache(): void {
		this.resourceCache.clear()
		this.resourceIndex.clear()
		this.logger.debug("Resource cache cleared")
		}

		/**
		* Get resource statistics
		*/
		getResourceStats(): {
		total: number
		cached: number
		categories: { [key: string]: number }
		} {
		const categories: { [key: string]: number } = {}

		for (const resource of this.resourceIndex.values()) {
		for (const category of this.categories) {
		if (resource.uri.startsWith(category.uriPrefix)) {
		categories[category.name] = (categories[category.name] \|\| 0) + 1
		break
		}
		}
		}

		return {
		total: this.resourceIndex.size,
		cached: this.resourceCache.size,
		categories,
		}
		}
		}

-58

src/servicenow/shared/mcp-types.ts

		/**
		* MCP Types
		* Common types for MCP server implementations
		*/

		export interface MCPServerConfig {
		name: string
		description?: string
		version?: string
		}

		export interface MCPTool {
		name: string
		description: string
		inputSchema: any
		}

		export interface MCPResponse<T = any> {
		success: boolean
		data?: T
		error?: string
		message?: string
		}

		export interface MCPRequest {
		tool: string
		params: any
		}

		export interface MCPLogger {
		info(message: string, meta?: any): void
		warn(message: string, meta?: any): void
		error(message: string, meta?: any): void
		debug(message: string, meta?: any): void
		}

		export interface MCPMemoryManager {
		store(key: string, value: any): Promise<void>
		retrieve(key: string): Promise<any>
		delete(key: string): Promise<boolean>
		list(): Promise<string[]>
		}

		export interface MCPToolResult {
		content: Array<{
		type: string
		text: string
		}>
		}

		export interface MCPToolResult {
		success?: boolean
		content: Array<{
		type: string
		text: string
		}>
		[key: string]: any
		}

-315

src/servicenow/shared/reliable-memory-manager.ts

		/**
		* Reliable Memory Manager
		* Direct in-memory storage without database dependencies
		* Solves hanging issues with better-sqlite3
		*/

		import * as fs from "fs"
		import * as path from "path"
		import { Logger } from "../utils/logger.js"

		export interface MemoryEntry {
		key: string
		value: any
		timestamp: Date
		expiresAt?: Date
		sizeBytes: number
		}

		export class ReliableMemoryManager {
		private static instance: ReliableMemoryManager
		private memory: Map<string, MemoryEntry> = new Map()
		private logger: Logger
		private readonly MAX_MEMORY_MB = 100 // 100MB max memory usage
		private readonly PERSIST_FILE: string
		private persistTimer: NodeJS.Timeout \| null = null

		private constructor() {
		this.logger = new Logger("ReliableMemoryManager")

		// Persistence file for recovery
		const memoryDir = path.join(process.cwd(), ".snow-flow", "memory")
		if (!fs.existsSync(memoryDir)) {
		fs.mkdirSync(memoryDir, { recursive: true })
		}
		this.PERSIST_FILE = path.join(memoryDir, "memory-snapshot.json")

		// Load previous memory if exists
		this.loadFromDisk()

		// Auto-persist every 30 seconds
		this.startAutoPersist()
		}

		static getInstance(): ReliableMemoryManager {
		if (!ReliableMemoryManager.instance) {
		ReliableMemoryManager.instance = new ReliableMemoryManager()
		}
		return ReliableMemoryManager.instance
		}

		/**
		* Store value in memory with size checking
		*/
		async store(key: string, value: any, expiresInMs?: number): Promise<void> {
		const serialized = JSON.stringify(value)
		const sizeBytes = Buffer.byteLength(serialized)

		// Check total memory usage
		const currentUsage = this.getMemoryUsageBytes()
		const newUsage = currentUsage + sizeBytes
		const maxBytes = this.MAX_MEMORY_MB * 1024 * 1024

		if (newUsage > maxBytes) {
		// Try to free expired entries first
		this.cleanupExpired()

		// Check again
		const afterCleanup = this.getMemoryUsageBytes() + sizeBytes
		if (afterCleanup > maxBytes) {
		throw new Error(
		`Memory limit exceeded. Current: ${(currentUsage / 1024 / 1024).toFixed(2)}MB, ` +
		`Requested: ${(sizeBytes / 1024 / 1024).toFixed(2)}MB, ` +
		`Max: ${this.MAX_MEMORY_MB}MB`,
		)
		}
		}

		const entry: MemoryEntry = {
		key,
		value,
		timestamp: new Date(),
		sizeBytes,
		expiresAt: expiresInMs ? new Date(Date.now() + expiresInMs) : undefined,
		}

		this.memory.set(key, entry)
		// Only log large stores (>100KB) to reduce log spam
		if (sizeBytes > 100 * 1024) {
		this.logger.debug(`Stored key '${key}' (${(sizeBytes / 1024).toFixed(2)}KB)`)
		}
		}

		/**
		* Retrieve value from memory
		*/
		async retrieve(key: string): Promise<any> {
		const entry = this.memory.get(key)

		if (!entry) {
		return null
		}

		// Check if expired
		if (entry.expiresAt && entry.expiresAt < new Date()) {
		this.memory.delete(key)
		this.logger.debug(`Key '${key}' expired and removed`)
		return null
		}

		return entry.value
		}

		/**
		* Delete a key from memory
		*/
		async delete(key: string): Promise<boolean> {
		const existed = this.memory.has(key)
		this.memory.delete(key)
		return existed
		}

		/**
		* List all keys with optional pattern matching
		*/
		async list(pattern?: string): Promise<string[]> {
		this.cleanupExpired()

		const keys = Array.from(this.memory.keys())

		if (pattern) {
		const regex = new RegExp(pattern)
		return keys.filter((key) => regex.test(key))
		}

		return keys
		}

		/**
		* Clear all memory
		*/
		async clear(): Promise<void> {
		const count = this.memory.size
		this.memory.clear()
		this.logger.info(`Cleared ${count} entries from memory`)
		}

		/**
		* Get memory usage statistics
		*/
		getStats(): {
		entries: number
		totalSizeBytes: number
		totalSizeMB: number
		maxSizeMB: number
		utilizationPercent: number
		} {
		const totalSizeBytes = this.getMemoryUsageBytes()
		const totalSizeMB = totalSizeBytes / 1024 / 1024

		return {
		entries: this.memory.size,
		totalSizeBytes,
		totalSizeMB,
		maxSizeMB: this.MAX_MEMORY_MB,
		utilizationPercent: (totalSizeMB / this.MAX_MEMORY_MB) * 100,
		}
		}

		/**
		* Get total memory usage in bytes
		*/
		private getMemoryUsageBytes(): number {
		let total = 0
		for (const entry of this.memory.values()) {
		total += entry.sizeBytes
		}
		return total
		}

		/**
		* Clean up expired entries
		*/
		private cleanupExpired(): void {
		const now = new Date()
		let removed = 0

		for (const [key, entry] of this.memory.entries()) {
		if (entry.expiresAt && entry.expiresAt < now) {
		this.memory.delete(key)
		removed++
		}
		}

		if (removed > 0) {
		this.logger.debug(`Cleaned up ${removed} expired entries`)
		}
		}

		/**
		* Persist memory to disk for recovery
		*/
		private async persistToDisk(): Promise<void> {
		try {
		const data = {
		version: "1.0",
		timestamp: new Date().toISOString(),
		entries: Array.from(this.memory.entries()).map(([key, entry]) => ({
		key,
		value: entry.value,
		timestamp: entry.timestamp,
		expiresAt: entry.expiresAt,
		sizeBytes: entry.sizeBytes,
		})),
		}

		await fs.promises.writeFile(this.PERSIST_FILE, JSON.stringify(data, null, 2), "utf-8")

		// Only log if there are entries (reduce spam for empty persists)
		if (this.memory.size > 0) {
		this.logger.debug(`Persisted ${this.memory.size} entries to disk`)
		}
		} catch (error: any) {
		this.logger.error("Failed to persist memory to disk:", error)
		}
		}

		/**
		* Load memory from disk
		*/
		private loadFromDisk(): void {
		try {
		if (!fs.existsSync(this.PERSIST_FILE)) {
		return
		}

		// Read file content
		const fileContent = fs.readFileSync(this.PERSIST_FILE, "utf-8")

		// Handle empty or whitespace-only file
		if (!fileContent \|\| fileContent.trim().length === 0) {
		this.logger.debug("Memory persist file is empty, starting with fresh memory")
		return
		}

		// Parse JSON
		const data = JSON.parse(fileContent)

		if (data.version !== "1.0") {
		this.logger.warn("Incompatible memory snapshot version, skipping load")
		return
		}

		// Validate data structure
		if (!data.entries \|\| !Array.isArray(data.entries)) {
		this.logger.warn("Invalid memory snapshot structure, skipping load")
		return
		}

		for (const entry of data.entries) {
		this.memory.set(entry.key, {
		key: entry.key,
		value: entry.value,
		timestamp: new Date(entry.timestamp),
		expiresAt: entry.expiresAt ? new Date(entry.expiresAt) : undefined,
		sizeBytes: entry.sizeBytes,
		})
		}

		this.cleanupExpired()
		this.logger.info(`Loaded ${this.memory.size} entries from disk`)
		} catch (error: any) {
		this.logger.error("Failed to load memory from disk:", error)
		// Don't throw - allow system to start with fresh memory
		}
		}

		/**
		* Start auto-persist timer
		*/
		private startAutoPersist(): void {
		// Persist every 5 minutes (reduced from 30 seconds to prevent log spam)
		this.persistTimer = setInterval(
		() => {
		this.persistToDisk().catch((error) => {
		this.logger.error("Auto-persist failed:", error)
		})
		},
		5 * 60 * 1000,
		) // 5 minutes

		// Don't block process exit
		if (this.persistTimer.unref) {
		this.persistTimer.unref()
		}

		// Persist on exit
		process.on("beforeExit", () => {
		this.persistToDisk()
		})
		}

		/**
		* Stop auto-persist timer
		*/
		destroy(): void {
		if (this.persistTimer) {
		clearInterval(this.persistTimer)
		this.persistTimer = null
		}
		this.persistToDisk()
		}
		}

		// Export singleton instance
		export const reliableMemory = ReliableMemoryManager.getInstance()

-129

src/servicenow/shared/response-limiter.ts

		/**
		* MCP Response Limiter
		* Prevents oversized responses that cause timeouts in Claude Code
		*/

		export class ResponseLimiter {
		// Configurable via environment variable, default to 500KB (reasonable for widgets/flows)
		private static readonly MAX_RESPONSE_SIZE = parseInt(process.env.MCP_MAX_RESPONSE_SIZE \|\| "500000") // 500KB default
		private static readonly MAX_ARRAY_ITEMS = parseInt(process.env.MCP_MAX_ARRAY_ITEMS \|\| "500") // 500 items default
		private static readonly MAX_TOKEN_ESTIMATE = 200000 // Claude's actual 200k context window

		/**
		* Limit response size to prevent timeouts
		*/
		static limitResponse(data: any): { limited: any; wasLimited: boolean; originalSize?: number } {
		const originalString = JSON.stringify(data)
		const originalSize = originalString.length

		// If response is small enough, return as-is
		if (originalSize <= this.MAX_RESPONSE_SIZE) {
		return { limited: data, wasLimited: false }
		}

		// Response too large - need to limit it
		const limited = this.limitObject(data)

		return {
		limited,
		wasLimited: true,
		originalSize,
		}
		}

		/**
		* Recursively limit object size
		*/
		private static limitObject(obj: any, depth: number = 0): any {
		// Don't go too deep
		if (depth > 5) {
		return "[DEPTH_LIMITED]"
		}

		// Handle null/undefined
		if (obj === null \|\| obj === undefined) {
		return obj
		}

		// Handle primitives
		if (typeof obj !== "object") {
		// Limit string length - 10KB per string field is reasonable
		if (typeof obj === "string" && obj.length > 10000) {
		return obj.substring(0, 10000) + "... [TRUNCATED]"
		}
		return obj
		}

		// Handle arrays
		if (Array.isArray(obj)) {
		if (obj.length > this.MAX_ARRAY_ITEMS) {
		return [
		...obj.slice(0, this.MAX_ARRAY_ITEMS).map((item) => this.limitObject(item, depth + 1)),
		`[... ${obj.length - this.MAX_ARRAY_ITEMS} more items]`,
		]
		}
		return obj.map((item) => this.limitObject(item, depth + 1))
		}

		// Handle objects
		const limited: any = {}
		const keys = Object.keys(obj)

		// Limit number of keys
		const maxKeys = 50
		const keysToProcess = keys.slice(0, maxKeys)

		for (const key of keysToProcess) {
		limited[key] = this.limitObject(obj[key], depth + 1)
		}

		if (keys.length > maxKeys) {
		limited._truncated = `${keys.length - maxKeys} more properties omitted`
		}

		return limited
		}

		/**
		* Create a summary response when data is too large
		*/
		static createSummaryResponse(data: any, operation: string): any {
		const originalSize = JSON.stringify(data).length
		const estimatedTokens = Math.ceil(originalSize / 4)

		return {
		content: [
		{
		type: "text",
		text: `⚠️ Response too large (${estimatedTokens} tokens, ${originalSize} bytes)

		Operation: ${operation}
		Status: Success (data limited to prevent timeout)

		Summary:
		- Original size: ${(originalSize / 1024 / 1024).toFixed(2)}MB
		- Token estimate: ${estimatedTokens}
		- Response limit: ${(this.MAX_RESPONSE_SIZE / 1024).toFixed(0)}KB

		🎯 Immediate Solution:
		Run \`/compact\` in Claude Code to clear context and prevent timeouts!

		💡 Tips to reduce response size:
		1. Use specific field queries instead of '*'
		2. Add pagination with smaller limits
		3. Filter results more specifically
		4. Use count operations instead of full data retrieval

		📝 Advanced Config:
		- MCP_MAX_RESPONSE_SIZE (default: 500000 bytes)
		- MCP_MAX_ARRAY_ITEMS (default: 500 items)`,
		},
		],
		_meta: {
		limited: true,
		originalSize,
		tokenEstimate: estimatedTokens,
		},
		}
		}
		}

-101

src/servicenow/utils/dynamic-models.ts

		/**
		* Dynamic LLM Models Utility
		*
		* Provides dynamic listing of available LLM models from various providers.
		* This module fetches model information from provider APIs when possible.
		*/

		export interface ModelInfo {
		name: string
		value: string
		contextWindow?: number
		description?: string
		}

		// Static model definitions as fallback
		const ANTHROPIC_MODELS: ModelInfo[] = [
		{ name: "Claude 3.5 Sonnet", value: "anthropic/claude-3-5-sonnet-20241022", contextWindow: 200000 },
		{ name: "Claude 3.5 Haiku", value: "anthropic/claude-3-5-haiku-20241022", contextWindow: 200000 },
		{ name: "Claude 3 Opus", value: "anthropic/claude-3-opus-20240229", contextWindow: 200000 },
		{ name: "Claude 3 Sonnet", value: "anthropic/claude-3-sonnet-20240229", contextWindow: 200000 },
		{ name: "Claude 3 Haiku", value: "anthropic/claude-3-haiku-20240307", contextWindow: 200000 },
		]

		const OPENAI_MODELS: ModelInfo[] = [
		{ name: "GPT-4 Turbo", value: "openai/gpt-4-turbo", contextWindow: 128000 },
		{ name: "GPT-4o", value: "openai/gpt-4o", contextWindow: 128000 },
		{ name: "GPT-4o Mini", value: "openai/gpt-4o-mini", contextWindow: 128000 },
		{ name: "GPT-4", value: "openai/gpt-4", contextWindow: 8192 },
		{ name: "GPT-3.5 Turbo", value: "openai/gpt-3.5-turbo", contextWindow: 16385 },
		]

		const GOOGLE_MODELS: ModelInfo[] = [
		{ name: "Gemini 1.5 Pro", value: "google/gemini-1.5-pro", contextWindow: 1000000 },
		{ name: "Gemini 1.5 Flash", value: "google/gemini-1.5-flash", contextWindow: 1000000 },
		{ name: "Gemini 2.0 Flash", value: "google/gemini-2.0-flash", contextWindow: 1000000 },
		]

		const OLLAMA_MODELS: ModelInfo[] = [
		{ name: "Llama 3.1 70B", value: "ollama/llama3.1:70b", contextWindow: 128000 },
		{ name: "Llama 3.1 8B", value: "ollama/llama3.1:8b", contextWindow: 128000 },
		{ name: "Llama 3.2 3B", value: "ollama/llama3.2:3b", contextWindow: 128000 },
		{ name: "Mistral 7B", value: "ollama/mistral:7b", contextWindow: 32000 },
		{ name: "CodeLlama 34B", value: "ollama/codellama:34b", contextWindow: 16000 },
		{ name: "Qwen 2.5 Coder 32B", value: "ollama/qwen2.5-coder:32b", contextWindow: 128000 },
		]

		const PROVIDER_MODELS: Record<string, ModelInfo[]> = {
		anthropic: ANTHROPIC_MODELS,
		openai: OPENAI_MODELS,
		google: GOOGLE_MODELS,
		ollama: OLLAMA_MODELS,
		}

		/**
		* Get models for a specific provider
		* @param provider - Provider name (anthropic, openai, google, ollama)
		* @returns Array of model information
		*/
		export async function getProviderModels(provider: string): Promise<ModelInfo[]> {
		const normalizedProvider = provider.toLowerCase()

		// For Ollama, try to fetch from local API
		if (normalizedProvider === "ollama") {
		try {
		const response = await fetch("http://localhost:11434/api/tags", {
		signal: AbortSignal.timeout(2000),
		})

		if (response.ok) {
		const data = (await response.json()) as { models?: Array<{ name: string }> }
		if (data.models && Array.isArray(data.models)) {
		return data.models.map((model: { name: string }) => ({
		name: model.name,
		value: `ollama/${model.name}`,
		}))
		}
		}
		} catch {
		// Fall back to static list
		}
		}

		return PROVIDER_MODELS[normalizedProvider] \|\| []
		}

		/**
		* Get all models from all providers
		* @returns Object mapping provider names to their models
		*/
		export async function getAllProviderModels(): Promise<Record<string, ModelInfo[]>> {
		const providers = ["anthropic", "openai", "google", "ollama"]
		const result: Record<string, ModelInfo[]> = {}

		await Promise.all(
		providers.map(async (provider) => {
		result[provider] = await getProviderModels(provider)
		}),
		)

		return result
		}

-99

src/servicenow/utils/logger.ts

		/**
		* Logger utility for ServiceNow agents
		*
		* Features:
		* - Log rotation with maxsize (5MB per file)
		* - Maximum 3 log files per agent (15MB total max)
		* - Logs stored in ~/.snow-flow/logs (centralized)
		* - Silent mode available via SNOW_FLOW_SILENT_LOGS=true
		*/

		import winston from "winston"
		import path from "path"
		import os from "os"
		import fs from "fs"

		// Centralized log directory in user's home
		const LOG_DIR = path.join(os.homedir(), ".snow-flow", "logs")

		// Ensure log directory exists
		if (!fs.existsSync(LOG_DIR)) {
		fs.mkdirSync(LOG_DIR, { recursive: true })
		}

		export class Logger {
		private logger: winston.Logger

		constructor(agentName: string) {
		// Check if logging should be silent (for production/quiet mode)
		const isSilent = process.env.SNOW_FLOW_SILENT_LOGS === "true"

		// Check if verbose mode is enabled
		const isVerbose = process.env.LOG_LEVEL === "verbose" \|\| process.env.LOG_LEVEL === "debug"

		// Only log errors in production, or respect LOG_LEVEL
		const logLevel = isSilent ? "error" : process.env.LOG_LEVEL \|\| "warn"

		const transports: winston.transport[] = []

		// Console transport - only in verbose mode or for errors
		if (!isSilent) {
		transports.push(
		new winston.transports.Console({
		format: isVerbose
		? winston.format.combine(winston.format.colorize(), winston.format.simple())
		: winston.format.printf((info) => `${info.message}`),
		stderrLevels: ["error", "warn", "info", "debug", "verbose", "silly"],
		}),
		)
		}

		// File transports with rotation
		// maxsize: 5MB per file, maxFiles: 3 files (15MB max total per agent)
		transports.push(
		new winston.transports.File({
		filename: path.join(LOG_DIR, `${agentName}-error.log`),
		level: "error",
		maxsize: 5 * 1024 * 1024, // 5MB
		maxFiles: 3,
		tailable: true,
		}),
		new winston.transports.File({
		filename: path.join(LOG_DIR, `${agentName}.log`),
		maxsize: 5 * 1024 * 1024, // 5MB
		maxFiles: 3,
		tailable: true,
		}),
		)

		this.logger = winston.createLogger({
		level: logLevel,
		format: winston.format.combine(
		winston.format.timestamp(),
		winston.format.errors({ stack: true }),
		winston.format.json(),
		),
		defaultMeta: { agent: agentName },
		transports,
		})
		}

		info(message: string, meta?: any): void {
		this.logger.info(message, meta)
		}

		error(message: string, meta?: any): void {
		this.logger.error(message, meta)
		}

		warn(message: string, meta?: any): void {
		this.logger.warn(message, meta)
		}

		debug(message: string, meta?: any): void {
		this.logger.debug(message, meta)
		}
		}

		// Create a default logger instance
		export const logger = new Logger("snow-flow")

-235

src/servicenow/utils/memory-safe-collections.ts

		/**
		* Memory-safe collections for snow-flow
		* Prevents unbounded growth of Maps and Sets
		*
		* @module memory-safe-collections
		*/

		/**
		* BoundedMap - A Map implementation with a maximum size limit
		* When the limit is reached, the oldest entries are evicted based on the eviction strategy
		*/
		export class BoundedMap<K, V> extends Map<K, V> {
		private maxSize: number
		private evictionStrategy: "lru" \| "fifo"
		private accessOrder: K[] = []

		/**
		* Create a new BoundedMap
		* @param maxSize Maximum number of entries (default: 1000)
		* @param evictionStrategy 'lru' for Least Recently Used, 'fifo' for First In First Out (default: 'lru')
		*/
		constructor(maxSize: number = 1000, evictionStrategy: "lru" \| "fifo" = "lru") {
		super()
		this.maxSize = maxSize
		this.evictionStrategy = evictionStrategy
		}

		/**
		* Set a key-value pair, evicting oldest entry if at capacity
		*/
		set(key: K, value: V): this {
		// Update access order for LRU
		if (this.evictionStrategy === "lru") {
		const idx = this.accessOrder.indexOf(key)
		if (idx > -1) {
		this.accessOrder.splice(idx, 1)
		}
		this.accessOrder.push(key)
		} else if (this.evictionStrategy === "fifo" && !this.has(key)) {
		// For FIFO, only add to order if it's a new key
		this.accessOrder.push(key)
		}

		// Evict oldest if at capacity
		if (this.size >= this.maxSize && !this.has(key)) {
		const evictKey = this.accessOrder.shift()
		if (evictKey !== undefined) {
		super.delete(evictKey)
		}
		}

		return super.set(key, value)
		}

		/**
		* Get a value, updating access order for LRU
		*/
		get(key: K): V \| undefined {
		// Update access order for LRU
		if (this.evictionStrategy === "lru" && this.has(key)) {
		const idx = this.accessOrder.indexOf(key)
		if (idx > -1) {
		this.accessOrder.splice(idx, 1)
		this.accessOrder.push(key)
		}
		}
		return super.get(key)
		}

		/**
		* Delete a key-value pair
		*/
		delete(key: K): boolean {
		const idx = this.accessOrder.indexOf(key)
		if (idx > -1) {
		this.accessOrder.splice(idx, 1)
		}
		return super.delete(key)
		}

		/**
		* Clear all entries
		*/
		clear(): void {
		this.accessOrder = []
		super.clear()
		}

		/**
		* Get the maximum size
		*/
		getMaxSize(): number {
		return this.maxSize
		}

		/**
		* Get the eviction strategy
		*/
		getEvictionStrategy(): "lru" \| "fifo" {
		return this.evictionStrategy
		}

		/**
		* Get statistics about the map
		*/
		getStats(): { size: number; maxSize: number; utilization: number } {
		return {
		size: this.size,
		maxSize: this.maxSize,
		utilization: this.size / this.maxSize,
		}
		}
		}

		/**
		* BoundedSet - A Set implementation with a maximum size limit
		* When the limit is reached, the oldest entries are evicted (FIFO)
		*/
		export class BoundedSet<T> extends Set<T> {
		private maxSize: number
		private insertionOrder: T[] = []

		/**
		* Create a new BoundedSet
		* @param maxSize Maximum number of entries (default: 1000)
		*/
		constructor(maxSize: number = 1000) {
		super()
		this.maxSize = maxSize
		}

		/**
		* Add a value, evicting oldest entry if at capacity
		*/
		add(value: T): this {
		if (this.size >= this.maxSize && !this.has(value)) {
		const evictValue = this.insertionOrder.shift()
		if (evictValue !== undefined) {
		super.delete(evictValue)
		}
		}

		if (!this.has(value)) {
		this.insertionOrder.push(value)
		}

		return super.add(value)
		}

		/**
		* Delete a value
		*/
		delete(value: T): boolean {
		const idx = this.insertionOrder.indexOf(value)
		if (idx > -1) {
		this.insertionOrder.splice(idx, 1)
		}
		return super.delete(value)
		}

		/**
		* Clear all entries
		*/
		clear(): void {
		this.insertionOrder = []
		super.clear()
		}

		/**
		* Get the maximum size
		*/
		getMaxSize(): number {
		return this.maxSize
		}

		/**
		* Get statistics about the set
		*/
		getStats(): { size: number; maxSize: number; utilization: number } {
		return {
		size: this.size,
		maxSize: this.maxSize,
		utilization: this.size / this.maxSize,
		}
		}
		}

		/**
		* BoundedArray - An array with a maximum size limit
		* When the limit is reached, the oldest entries are removed from the front
		*/
		export class BoundedArray<T> extends Array<T> {
		private maxSize: number

		/**
		* Create a new BoundedArray
		* @param maxSize Maximum number of entries (default: 1000)
		*/
		constructor(maxSize: number = 1000) {
		super()
		this.maxSize = maxSize
		}

		/**
		* Push values, removing oldest if over capacity
		*/
		push(...items: T[]): number {
		const result = super.push(...items)

		// Remove oldest entries if over capacity
		while (this.length > this.maxSize) {
		this.shift()
		}

		return Math.min(result, this.maxSize)
		}

		/**
		* Get the maximum size
		*/
		getMaxSize(): number {
		return this.maxSize
		}

		/**
		* Get statistics about the array
		*/
		getStats(): { length: number; maxSize: number; utilization: number } {
		return {
		length: this.length,
		maxSize: this.maxSize,
		utilization: this.length / this.maxSize,
		}
		}
		}

src/servicenow/utils/servicenow-client.ts

Sorry, the diff of this file is too big to display

-1164

src/servicenow/utils/snow-oauth.ts

		#!/usr/bin/env node
		/**
		* ServiceNow OAuth Authentication Utility with Code Paste Flow
		* Handles OAuth2 flow for ServiceNow integration (Claude-style)
		*/

		import { promises as fs, existsSync } from "fs"
		import { join } from "path"
		import os from "os"
		import { createServer } from "http"
		import { URL } from "url"
		import axios from "axios"
		import https from "https"
		import net from "net"
		import crypto from "crypto"
		import * as prompts from "@clack/prompts"
		import { snowFlowConfig } from "../config/snow-flow-config.js"
		import { unifiedAuthStore } from "./unified-auth-store.js"
		import { OAuthTemplates } from "./oauth-html-templates.js"

		export interface ServiceNowAuthResult {
		success: boolean
		accessToken?: string
		refreshToken?: string
		expiresIn?: number
		error?: string
		}

		export interface ServiceNowCredentials {
		instance: string
		clientId: string
		clientSecret: string
		accessToken?: string
		refreshToken?: string
		expiresAt?: string
		}

		interface OAuthCredentials {
		instance: string
		clientId: string
		clientSecret: string
		redirectUri: string
		}

		/**
		* Timing-safe string comparison to prevent timing attacks on security tokens.
		* Returns true if both strings are equal, using constant-time comparison.
		*/
		function timingSafeCompare(a: string, b: string): boolean {
		if (a.length !== b.length) return false
		const bufA = Buffer.from(a, "utf8")
		const bufB = Buffer.from(b, "utf8")
		return crypto.timingSafeEqual(bufA, bufB)
		}

		export class ServiceNowOAuth {
		private credentials?: OAuthCredentials
		private tokenPath: string
		private stateParameter?: string
		private codeVerifier?: string
		private codeChallenge?: string

		// 🔒 SEC-002 FIX: Add rate limiting to prevent authentication bypass attacks
		private lastTokenRequest: number = 0
		private tokenRequestCount: number = 0
		private readonly TOKEN_REQUEST_WINDOW_MS = 60000 // 1 minute window
		private readonly MAX_TOKEN_REQUESTS_PER_WINDOW = 10 // Max 10 token requests per minute

		constructor() {
		// Store tokens in user's home directory
		const configDir = process.env.SNOW_FLOW_HOME \|\| join(os.homedir(), ".snow-flow")
		this.tokenPath = join(configDir, "auth.json")
		}

		/**
		* 🔒 SEC-002 FIX: Check rate limiting for token requests to prevent brute force attacks
		*/
		private checkTokenRequestRateLimit(): boolean {
		const now = Date.now()

		// Reset counter if window has passed
		if (now - this.lastTokenRequest > this.TOKEN_REQUEST_WINDOW_MS) {
		this.tokenRequestCount = 0
		this.lastTokenRequest = now
		}

		// Check if within rate limit
		if (this.tokenRequestCount >= this.MAX_TOKEN_REQUESTS_PER_WINDOW) {
		prompts.log.warn("Rate limit exceeded: Too many token requests. Please wait before retrying.")
		return false
		}

		this.tokenRequestCount++
		return true
		}

		/**
		* Generate a random state parameter for CSRF protection
		* Uses crypto.randomBytes for cryptographic security instead of Math.random()
		*/
		private generateState(): string {
		return crypto.randomBytes(32).toString("base64url")
		}

		/**
		* Generate PKCE code verifier and challenge
		*/
		private generatePKCE() {
		// Generate code verifier (43-128 characters)
		this.codeVerifier = crypto.randomBytes(32).toString("base64url")

		// Generate code challenge (SHA256 hash of verifier)
		const hash = crypto.createHash("sha256")
		hash.update(this.codeVerifier)
		this.codeChallenge = hash.digest("base64url")
		}

		/**
		* Check if a specific port is available
		*/
		private async checkPortAvailable(port: number): Promise<boolean> {
		return new Promise((resolve) => {
		const server = net.createServer()

		server.on("error", () => {
		resolve(false)
		})

		server.listen(port, () => {
		server.close(() => {
		resolve(true)
		})
		})
		})
		}

		/**
		* 🔧 CRIT-002 FIX: Normalize instance URL to prevent trailing slash 400 errors
		*/
		private normalizeInstanceUrl(instance: string): string {
		// Remove any trailing slashes that cause 400 errors
		// SECURITY: Use trimEnd + while loop instead of regex to avoid ReDoS
		let normalized = instance
		while (normalized.endsWith("/")) {
		normalized = normalized.slice(0, -1)
		}

		// Add https:// if missing
		if (!normalized.startsWith("http://") && !normalized.startsWith("https://")) {
		normalized = `https://${normalized}`
		}

		// SECURITY: Use URL parsing to validate hostname instead of string includes
		try {
		const parsed = new URL(normalized)
		const hostname = parsed.hostname.toLowerCase()

		// Check if it's already a valid ServiceNow or local URL
		const isServiceNow = hostname.endsWith(".service-now.com") \|\| hostname.endsWith(".servicenow.com")
		const isLocal = hostname === "localhost" \|\| hostname === "127.0.0.1" \|\| hostname.startsWith("192.168.")

		if (!isServiceNow && !isLocal) {
		// Assume it's just the instance name, append .service-now.com
		normalized = `https://${hostname}.service-now.com`
		}
		} catch {
		// If URL parsing fails, treat input as instance name
		const instanceName = normalized.replace(/^https?:\/\//, "")
		normalized = `https://${instanceName}.service-now.com`
		}

		return normalized
		}

		/**
		* 🎯 NEW: Simplified OAuth flow with code paste (Claude-style)
		* No local server required - user manually pastes authorization code
		*/
		async authenticateWithCodePaste(
		instance: string,
		clientId: string,
		clientSecret: string,
		): Promise<ServiceNowAuthResult> {
		try {
		// Normalize instance URL
		const normalizedInstance = this.normalizeInstanceUrl(instance)

		// Validate client secret
		const secretValidation = this.validateClientSecret(clientSecret)
		if (!secretValidation.valid) {
		prompts.log.error(`Invalid OAuth Client Secret: ${secretValidation.reason}`)
		prompts.log.info("To get a valid OAuth secret:")
		prompts.log.message(" 1. Log into ServiceNow as admin")
		prompts.log.message(" 2. Navigate to: System OAuth > Application Registry")
		prompts.log.message(" 3. Create a new OAuth application")
		prompts.log.message(" 4. Copy the generated Client Secret (long random string)")
		return {
		success: false,
		error: secretValidation.reason,
		}
		}

		// For code paste flow, we use a special redirect URI that shows the code
		const redirectUri = "urn:ietf:wg:oauth:2.0:oob" // Out-of-band redirect for manual code entry

		// Store credentials
		this.credentials = {
		instance: normalizedInstance.replace("https://", "").replace("http://", ""),
		clientId,
		clientSecret,
		redirectUri,
		}

		prompts.log.step("Starting ServiceNow OAuth flow")
		prompts.log.info(`Instance: ${normalizedInstance}`)
		prompts.log.info(`Client ID: ${clientId}`)

		// Generate state parameter and PKCE
		this.stateParameter = this.generateState()
		this.generatePKCE()

		// Generate authorization URL
		const authUrl = this.generateAuthUrl(this.credentials.instance, clientId, redirectUri)

		prompts.log.message("")
		prompts.log.step("Authorization URL generated")
		prompts.log.message(`\n${authUrl}\n`)
		prompts.log.warn(`Go to: ${authUrl}`)
		prompts.log.message("")

		const authCode = (await prompts.text({
		message: "Paste the authorization code here",
		placeholder: "Enter the code from the browser after authorizing",
		validate: (value) => {
		if (!value \|\| value.trim() === "") return "Authorization code is required"
		if (value.length < 10) return "Code seems too short - please paste the full authorization code"
		},
		})) as string

		if (prompts.isCancel(authCode)) {
		prompts.cancel("Authentication cancelled")
		return {
		success: false,
		error: "Authentication cancelled by user",
		}
		}

		// Extract code if user pasted full URL
		let code = authCode.trim()
		if (code.includes("code=")) {
		const match = code.match(/code=([^&]+)/)
		if (match) {
		code = match[1]
		}
		}

		// Exchange code for tokens
		const spinner = prompts.spinner()
		spinner.start("Exchanging authorization code for tokens")

		let tokenResult: ServiceNowAuthResult
		try {
		tokenResult = await this.exchangeCodeForTokens(code)

		if (tokenResult.success && tokenResult.accessToken) {
		// Save tokens
		await this.saveTokens({
		accessToken: tokenResult.accessToken,
		refreshToken: tokenResult.refreshToken \|\| "",
		expiresIn: tokenResult.expiresIn \|\| 3600,
		instance: this.credentials.instance,
		clientId,
		clientSecret,
		})

		spinner.stop("Authentication successful")
		prompts.log.success("Tokens saved securely")
		} else {
		spinner.stop("Token exchange failed")
		}
		} catch (error) {
		spinner.stop("Token exchange failed")
		throw error
		}

		return tokenResult
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		prompts.log.error(`Authentication failed: ${errorMessage}`)
		return {
		success: false,
		error: errorMessage,
		}
		}
		}

		/**
		* Original OAuth flow with local server (fallback)
		*/
		async authenticate(instance: string, clientId: string, clientSecret: string): Promise<ServiceNowAuthResult> {
		try {
		// 🔧 CRIT-002 FIX: Apply URL normalization
		const normalizedInstance = this.normalizeInstanceUrl(instance)
		// Validate client secret format
		const secretValidation = this.validateClientSecret(clientSecret)
		if (!secretValidation.valid) {
		prompts.log.error(`Invalid OAuth Client Secret: ${secretValidation.reason}`)
		prompts.log.info("To get a valid OAuth secret:")
		prompts.log.message(" 1. Log into ServiceNow as admin")
		prompts.log.message(" 2. Navigate to: System OAuth > Application Registry")
		prompts.log.message(" 3. Create a new OAuth application")
		prompts.log.message(" 4. Copy the generated Client Secret (long random string)")
		return {
		success: false,
		error: secretValidation.reason,
		}
		}

		// Get OAuth redirect configuration from environment or use defaults
		const oauthConfig = snowFlowConfig.servicenow.oauth
		const port = oauthConfig.redirectPort
		const host = oauthConfig.redirectHost
		const path = oauthConfig.redirectPath
		const redirectUri = `http://${host}:${port}${path}`

		// Check if port is available
		const isPortAvailable = await this.checkPortAvailable(port)
		if (!isPortAvailable) {
		prompts.log.error(`Port ${port} is already in use!`)
		prompts.log.warn(`Please close any application using port ${port} and try again.`)
		return {
		success: false,
		error: `Port ${port} is already in use. Please free up the port and try again.`,
		}
		}

		// Store credentials temporarily with normalized instance
		this.credentials = {
		instance: normalizedInstance.replace("https://", "").replace("http://", ""),
		clientId,
		clientSecret,
		redirectUri,
		}

		prompts.log.step("Starting ServiceNow OAuth flow")
		prompts.log.info(`Instance: ${normalizedInstance}`)
		prompts.log.info(`Client ID: ${clientId}`)
		prompts.log.info(`Redirect URI: ${redirectUri}`)

		// Generate state parameter for CSRF protection
		this.stateParameter = this.generateState()

		// Generate PKCE parameters
		this.generatePKCE()

		// Generate authorization URL
		const authUrl = this.generateAuthUrl(this.credentials.instance, clientId, redirectUri)

		prompts.log.step("Authorization URL generated")
		prompts.log.message("")
		prompts.log.message(`\n${authUrl}\n`)
		prompts.log.message("")

		// Start local server to handle callback
		const authResult = await this.startCallbackServer(redirectUri, port)

		if (authResult.success && authResult.accessToken) {
		// Save tokens with normalized instance
		await this.saveTokens({
		accessToken: authResult.accessToken,
		refreshToken: authResult.refreshToken \|\| "",
		expiresIn: authResult.expiresIn \|\| 3600,
		instance: this.credentials.instance,
		clientId,
		clientSecret,
		})

		prompts.log.success("Authentication successful")
		prompts.log.success("Tokens saved securely")
		}

		return authResult
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		prompts.log.error(`Authentication failed: ${errorMessage}`)
		return {
		success: false,
		error: errorMessage,
		}
		}
		}

		/**
		* Generate ServiceNow OAuth authorization URL
		*/
		private generateAuthUrl(instance: string, clientId: string, redirectUri: string): string {
		const baseUrl = `https://${instance}/oauth_auth.do`
		const params = new URLSearchParams({
		response_type: "code",
		client_id: clientId,
		redirect_uri: redirectUri,
		scope: "useraccount write admin",
		state: this.stateParameter \|\| "",
		code_challenge: this.codeChallenge \|\| "",
		code_challenge_method: "S256",
		})

		return `${baseUrl}?${params.toString()}`
		}

		/**
		* Start local HTTP server to handle OAuth callback
		* Also supports manual callback URL paste as fallback
		*/
		private async startCallbackServer(redirectUri: string, port: number): Promise<ServiceNowAuthResult> {
		return new Promise(async (resolve) => {
		let resolved = false
		let timeoutHandle: NodeJS.Timeout \| null = null

		// Helper function to cleanup and close server
		const cleanup = () => {
		if (timeoutHandle) {
		clearTimeout(timeoutHandle)
		timeoutHandle = null
		}
		server.close()
		}

		const server = createServer(async (req, res) => {
		if (resolved) return
		try {
		const url = new URL(req.url!, `http://${snowFlowConfig.servicenow.oauth.redirectHost}:${port}`)

		if (url.pathname === "/callback") {
		const code = url.searchParams.get("code")
		const error = url.searchParams.get("error")
		const state = url.searchParams.get("state")

		// Validate state parameter
		if (!state \|\| !this.stateParameter \|\| !timingSafeCompare(state, this.stateParameter)) {
		res.writeHead(400, { "Content-Type": "text/html" })
		res.end(OAuthTemplates.securityError)

		resolved = true
		cleanup()
		resolve({
		success: false,
		error: "Invalid state parameter",
		})
		return
		}

		if (error) {
		res.writeHead(400, { "Content-Type": "text/html" })
		res.end(OAuthTemplates.error(error))

		resolved = true
		cleanup()
		resolve({
		success: false,
		error: `OAuth error: ${error}`,
		})
		return
		}

		if (!code) {
		res.writeHead(400, { "Content-Type": "text/html" })
		res.end(OAuthTemplates.missingCode)

		resolved = true
		cleanup()
		resolve({
		success: false,
		error: "No authorization code received",
		})
		return
		}

		// Exchange code for tokens
		resolved = true
		const spinner = prompts.spinner()
		spinner.start("Exchanging authorization code for tokens")

		let tokenResult: ServiceNowAuthResult
		try {
		tokenResult = await this.exchangeCodeForTokens(code)
		spinner.stop(tokenResult.success ? "Token exchange successful" : "Token exchange failed")

		if (tokenResult.success) {
		res.writeHead(200, { "Content-Type": "text/html" })
		res.end(OAuthTemplates.success)

		cleanup()
		resolve(tokenResult)
		} else {
		res.writeHead(500, { "Content-Type": "text/html" })
		res.end(OAuthTemplates.tokenExchangeFailed(tokenResult.error \|\| "Unknown error"))

		cleanup()
		resolve(tokenResult)
		}
		} catch (error) {
		spinner.stop("Token exchange failed")
		res.writeHead(500, { "Content-Type": "text/html" })
		res.end(OAuthTemplates.tokenExchangeFailed("Unexpected error during token exchange"))

		cleanup()
		resolve({
		success: false,
		error: error instanceof Error ? error.message : String(error),
		})
		}
		} else {
		res.writeHead(404, { "Content-Type": "text/plain" })
		res.end("Not Found")
		}
		} catch (error) {
		prompts.log.error(`Callback server error: ${error}`)
		res.writeHead(500, { "Content-Type": "text/plain" })
		res.end("Internal Server Error")

		resolved = true
		cleanup()
		resolve({
		success: false,
		error: error instanceof Error ? error.message : String(error),
		})
		}
		})

		server.listen(port, () => {
		// Prevent server from keeping process alive after authentication completes
		server.unref()

		prompts.log.step(
		`OAuth callback server started on http://${snowFlowConfig.servicenow.oauth.redirectHost}:${port}`,
		)
		prompts.log.warn("Please open the authorization URL in your browser")
		prompts.log.info("Waiting for OAuth callback...")

		// Auto-open browser if possible
		// Try to auto-open browser if not in headless environment
		const isCodespaces = process.env.CODESPACES === "true"
		const isContainer = process.env.CONTAINER === "true" \|\| existsSync("/.dockerenv")
		const isHeadless = isCodespaces \|\| isContainer \|\| process.env.CI === "true"

		if (!isHeadless) {
		try {
		const { spawn } = require("child_process")
		const authUrl = this.generateAuthUrl(this.credentials!.instance, this.credentials!.clientId, redirectUri)

		let browserProcess: any

		// Try to open browser based on platform
		if (process.platform === "darwin") {
		browserProcess = spawn("open", [authUrl], { detached: true, stdio: "ignore" })
		} else if (process.platform === "win32") {
		browserProcess = spawn("cmd", ["/c", "start", authUrl], { detached: true, stdio: "ignore" })
		} else if (process.platform === "linux") {
		// Try multiple Linux browser openers
		const openers = ["xdg-open", "gnome-open", "kde-open", "sensible-browser"]
		for (const opener of openers) {
		try {
		browserProcess = spawn(opener, [authUrl], { detached: true, stdio: "ignore" })
		break // If successful, stop trying
		} catch (e) {
		// Try next opener
		continue
		}
		}
		} else {
		prompts.log.warn(`Unknown OS: ${process.platform}`)
		}

		// Prevent the spawn from keeping the process alive
		if (browserProcess && browserProcess.unref) {
		browserProcess.unref()
		}
		} catch (err) {
		// Silently fail - user can manually open URL
		prompts.log.warn("Browser auto-open failed. Please manually copy and open the URL above.")
		}
		}

		// Offer manual callback URL paste as alternative
		prompts.log.message("")
		prompts.log.info("Alternatively, paste the callback URL here after authorizing:")

		// Start prompt for manual URL paste (race with server callback)
		;(async () => {
		try {
		const callbackUrl = (await prompts.text({
		message: "Paste callback URL (or press Enter to wait for automatic redirect)",
		placeholder: "http://localhost:3005/callback?code=...&state=...",
		validate: (value) => {
		// Allow empty (waiting for server callback)
		if (!value \|\| value.trim() === "") return undefined

		// Validate if URL was pasted
		if (!value.includes("callback")) return 'Invalid callback URL - must contain "callback"'
		if (!value.includes("code=")) return "Invalid callback URL - must contain code parameter"
		},
		})) as string

		// If user pressed Enter without pasting, just wait for server callback
		if (prompts.isCancel(callbackUrl) \|\| !callbackUrl \|\| callbackUrl.trim() === "") {
		prompts.log.info("Waiting for browser redirect...")
		return
		}

		// User pasted a URL - parse it
		if (resolved) return // Server already handled it
		resolved = true

		try {
		const url = new URL(callbackUrl)
		const code = url.searchParams.get("code")
		const state = url.searchParams.get("state")
		const error = url.searchParams.get("error")

		// Validate state
		if (!state \|\| !this.stateParameter \|\| !timingSafeCompare(state, this.stateParameter)) {
		cleanup()
		resolve({
		success: false,
		error: "Invalid state parameter - security check failed",
		})
		return
		}

		if (error) {
		cleanup()
		resolve({
		success: false,
		error: `OAuth error: ${error}`,
		})
		return
		}

		if (!code) {
		cleanup()
		resolve({
		success: false,
		error: "No authorization code found in URL",
		})
		return
		}

		// Exchange code for tokens
		prompts.log.success("Authorization code received from pasted URL")
		const spinner = prompts.spinner()
		spinner.start("Exchanging authorization code for tokens")

		let tokenResult: ServiceNowAuthResult
		try {
		tokenResult = await this.exchangeCodeForTokens(code)
		spinner.stop(tokenResult.success ? "Token exchange successful" : "Token exchange failed")

		cleanup()
		resolve(tokenResult)
		} catch (error) {
		spinner.stop("Token exchange failed")
		cleanup()
		resolve({
		success: false,
		error: error instanceof Error ? error.message : "Unexpected error during token exchange",
		})
		}
		} catch (err) {
		cleanup()
		resolve({
		success: false,
		error: "Invalid callback URL format",
		})
		}
		} catch (err) {
		// Prompt was cancelled or errored - just wait for server callback
		if (!resolved) {
		prompts.log.info("Waiting for browser redirect...")
		}
		}
		})()

		// Add 5-minute timeout for OAuth flow
		timeoutHandle = setTimeout(() => {
		if (!resolved) {
		resolved = true
		cleanup()
		prompts.log.error("OAuth authorization timed out after 5 minutes")
		prompts.log.info("Please try again: snow-flow auth login")
		resolve({
		success: false,
		error: "OAuth authorization timed out - no callback received within 5 minutes",
		})
		}
		}, 300000) // 5 minutes
		})
		})
		}

		/**
		* Exchange authorization code for tokens
		*/
		private async exchangeCodeForTokens(code: string): Promise<ServiceNowAuthResult> {
		try {
		// 🔒 SEC-002 FIX: Apply rate limiting to prevent authentication bypass attacks
		if (!this.checkTokenRequestRateLimit()) {
		return {
		success: false,
		error: "Rate limit exceeded. Too many token requests. Please wait 1 minute before retrying.",
		}
		}

		const tokenUrl = `https://${this.credentials!.instance}/oauth_token.do`

		const response = await axios.post(
		tokenUrl,
		new URLSearchParams({
		grant_type: "authorization_code",
		code,
		client_id: this.credentials!.clientId,
		client_secret: this.credentials!.clientSecret,
		redirect_uri: this.credentials!.redirectUri,
		code_verifier: this.codeVerifier \|\| "",
		}),
		{
		headers: {
		"Content-Type": "application/x-www-form-urlencoded",
		},
		timeout: 15000, // 🔒 SEC-002 FIX: 15 second timeout to prevent hanging requests
		// SECURITY: Certificate validation enforced (removed rejectUnauthorized: false)
		},
		)

		const data = response.data

		if (data.access_token) {
		return {
		success: true,
		accessToken: data.access_token,
		refreshToken: data.refresh_token,
		expiresIn: data.expires_in,
		}
		} else {
		return {
		success: false,
		error: "No access token received",
		}
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)

		// Check for invalid redirect_uri error
		if (axios.isAxiosError(error) && error.response) {
		const responseData = error.response.data
		const errorDescription = responseData?.error_description \|\| responseData?.error \|\| ""

		// Special handling for redirect_uri errors
		if (
		errorDescription.toLowerCase().includes("redirect_uri") \|\|
		errorDescription.toLowerCase().includes("redirect uri")
		) {
		prompts.log.error("Invalid redirect_uri configuration")
		prompts.log.message("")
		prompts.log.warn("The OAuth application in ServiceNow is not configured correctly.")
		prompts.log.message("")
		prompts.log.step("Fix this by following these steps:")
		prompts.log.message("")
		prompts.log.info("1. Log into ServiceNow as administrator")
		prompts.log.info(`2. Navigate to: System OAuth → Application Registry`)
		prompts.log.info(`3. Find your OAuth application (Client ID: ${this.credentials!.clientId})`)
		prompts.log.info('4. Edit the "Redirect URL" field')
		prompts.log.info("5. Change it to: http://localhost:3005/callback")
		prompts.log.message(" (exactly this - copy/paste to avoid typos!)")
		prompts.log.info("6. Save the application")
		prompts.log.info('7. Run "snow-flow auth login" again')
		prompts.log.message("")
		prompts.log.warn("The redirect URI MUST be exactly: http://localhost:3005/callback")
		prompts.log.message("")

		return {
		success: false,
		error: "Invalid redirect_uri - OAuth application not configured. See instructions above.",
		}
		}

		// Log other API errors
		prompts.log.error(`ServiceNow OAuth error: ${errorDescription}`)
		prompts.log.error(`Response data: ${JSON.stringify(responseData)}`)
		} else {
		prompts.log.error(`Token exchange error: ${errorMessage}`)
		}

		return {
		success: false,
		error: errorMessage,
		}
		}
		}

		/**
		* Save tokens to file
		*/
		private async saveTokens(tokenData: any): Promise<void> {
		try {
		const expiresAt = new Date()
		expiresAt.setSeconds(expiresAt.getSeconds() + tokenData.expiresIn)

		const authData = {
		...tokenData,
		expiresAt: expiresAt.toISOString(),
		}

		// Use unified auth store
		await unifiedAuthStore.saveTokens(authData)

		// Bridge to MCP servers immediately
		await unifiedAuthStore.bridgeToMCP()
		} catch (error) {
		prompts.log.error(`Failed to save tokens: ${error}`)
		throw error
		}
		}

		/**
		* Load tokens from file
		*/
		async loadTokens(): Promise<any> {
		try {
		return await unifiedAuthStore.getTokens()
		} catch (error) {
		return null
		}
		}

		/**
		* Check if authenticated
		*/
		async isAuthenticated(): Promise<boolean> {
		try {
		const tokens = await this.loadTokens()
		if (!tokens) return false

		// Check if token is expired
		const expiresAt = new Date(tokens.expiresAt)
		const now = new Date()

		return now < expiresAt
		} catch (error) {
		return false
		}
		}

		/**
		* Get access token (refresh if needed)
		*/
		async getAccessToken(): Promise<string \| null> {
		try {
		const tokens = await this.loadTokens()
		if (!tokens) return null

		// Check if token is expired
		const expiresAt = new Date(tokens.expiresAt)
		const now = new Date()

		if (now >= expiresAt && tokens.refreshToken) {
		// Token expired, try to refresh
		prompts.log.info("Token expired, refreshing...")
		const refreshResult = await this.refreshAccessToken(tokens)

		if (refreshResult.success && refreshResult.accessToken) {
		// Update saved tokens
		await this.saveTokens({
		...tokens,
		accessToken: refreshResult.accessToken,
		expiresIn: refreshResult.expiresIn \|\| 3600,
		})

		return refreshResult.accessToken
		} else {
		prompts.log.error(`Token refresh failed: ${refreshResult.error}`)
		return null
		}
		}

		return tokens.accessToken
		} catch (error) {
		prompts.log.error(`Failed to get access token: ${error}`)
		return null
		}
		}

		/**
		* Refresh access token
		*/
		public async refreshAccessToken(tokens?: any): Promise<ServiceNowAuthResult> {
		try {
		// 🔒 SEC-002 FIX: Apply rate limiting to prevent authentication bypass attacks
		if (!this.checkTokenRequestRateLimit()) {
		return {
		success: false,
		error: "Rate limit exceeded. Too many token requests. Please wait 1 minute before retrying.",
		}
		}

		// If no tokens provided, load from file
		if (!tokens) {
		tokens = await this.loadTokens()
		if (!tokens) {
		return {
		success: false,
		error: "No tokens found to refresh",
		}
		}
		}

		const tokenUrl = `https://${tokens.instance}/oauth_token.do`

		const response = await axios.post(
		tokenUrl,
		new URLSearchParams({
		grant_type: "refresh_token",
		refresh_token: tokens.refreshToken,
		client_id: tokens.clientId,
		client_secret: tokens.clientSecret,
		}),
		{
		headers: {
		"Content-Type": "application/x-www-form-urlencoded",
		},
		timeout: 15000, // 🔒 SEC-002 FIX: 15 second timeout to prevent hanging requests
		// SECURITY: Certificate validation enforced (removed rejectUnauthorized: false)
		},
		)

		const data = response.data

		if (data.access_token) {
		// Update saved tokens
		await this.saveTokens({
		...tokens,
		accessToken: data.access_token,
		expiresIn: data.expires_in \|\| 3600,
		})

		return {
		success: true,
		accessToken: data.access_token,
		expiresIn: data.expires_in,
		}
		} else {
		return {
		success: false,
		error: "No access token received",
		}
		}
		} catch (error) {
		const errorMessage = error instanceof Error ? error.message : String(error)
		return {
		success: false,
		error: errorMessage,
		}
		}
		}

		/**
		* Logout - clear saved tokens
		*/
		async logout(): Promise<void> {
		try {
		await fs.unlink(this.tokenPath)
		prompts.log.success("Logged out successfully")
		} catch (error) {
		prompts.log.info("No active session to logout from")
		}
		}

		/**
		* Get stored OAuth tokens for use in other contexts (MCP servers)
		*/
		async getStoredTokens(): Promise<any> {
		return await this.loadTokens()
		}

		/**
		* Load credentials (including tokens) with .env fallback
		*/
		async loadCredentials(): Promise<ServiceNowCredentials \| null> {
		try {
		// First, try to load saved OAuth tokens
		const tokens = await this.loadTokens()

		if (tokens && tokens.accessToken) {
		// Validate client secret when loading
		if (tokens.clientSecret) {
		const secretValidation = this.validateClientSecret(tokens.clientSecret)
		if (!secretValidation.valid) {
		prompts.log.warn(`OAuth Configuration Issue: ${secretValidation.reason}`)
		prompts.log.info("Your stored client secret may be incorrect. Re-authenticate with: snow-flow auth login")
		}
		}

		// Check if token is expired
		const expiresAt = new Date(tokens.expiresAt)
		const now = new Date()

		if (now < expiresAt) {
		prompts.log.success("Using saved OAuth tokens")
		return {
		instance: tokens.instance,
		clientId: tokens.clientId,
		clientSecret: tokens.clientSecret,
		accessToken: tokens.accessToken,
		refreshToken: tokens.refreshToken,
		expiresAt: tokens.expiresAt,
		}
		} else {
		prompts.log.warn("Saved OAuth token expired, will try refresh...")
		}
		}

		// 🔧 NEW: Fallback to .env file if no valid tokens
		prompts.log.info("No valid OAuth tokens found, checking .env file...")

		// Load environment variables with dotenv
		try {
		require("dotenv").config()
		} catch (err) {
		prompts.log.message("dotenv not available, using process.env directly")
		}

		const envInstance = process.env.SNOW_INSTANCE
		const envClientId = process.env.SNOW_CLIENT_ID
		const envClientSecret = process.env.SNOW_CLIENT_SECRET

		if (envInstance && envClientId && envClientSecret) {
		prompts.log.success("Found ServiceNow credentials in .env file")
		prompts.log.message(` - Instance: ${envInstance}`)
		prompts.log.message(` - Client ID: ${envClientId}`)
		prompts.log.message(" - Client Secret: Present")

		// Validate client secret
		const secretValidation = this.validateClientSecret(envClientSecret)
		if (!secretValidation.valid) {
		prompts.log.error(`Invalid OAuth Client Secret in .env file: ${secretValidation.reason}`)
		prompts.log.warn("Please update SNOW_CLIENT_SECRET in .env with proper OAuth secret from ServiceNow")
		return null
		}

		prompts.log.message("")
		prompts.log.info("OAuth Setup Required:")
		prompts.log.message(" Your .env has OAuth credentials but no active session.")
		prompts.log.message(" Run: snow-flow auth login")
		prompts.log.message(" This will authenticate and create persistent tokens.")
		prompts.log.message("")

		// Return credentials without access token - this will trigger auth flow
		return {
		instance: envInstance.replace(/\/$/, ""),
		clientId: envClientId,
		clientSecret: envClientSecret,
		// No accessToken - this signals that OAuth login is needed
		}
		}

		// 🔧 Check for old username/password setup in .env
		const envUsername = process.env.SNOW_USERNAME
		const envPassword = process.env.SNOW_PASSWORD

		if (envInstance && envUsername && envPassword) {
		prompts.log.warn("Found username/password in .env - OAuth is recommended")
		prompts.log.info("For better security, set up OAuth credentials:")
		prompts.log.message(" 1. In ServiceNow: System OAuth > Application Registry > New")
		prompts.log.message(" 2. Update .env with SNOW_CLIENT_ID and SNOW_CLIENT_SECRET")
		prompts.log.message(" 3. Run: snow-flow auth login")

		// Don't return username/password - force OAuth setup
		return null
		}

		// No credentials found anywhere
		prompts.log.error("No ServiceNow credentials found!")
		prompts.log.message("")
		prompts.log.info("Setup Instructions:")
		prompts.log.message(" 1. Create .env file with OAuth credentials:")
		prompts.log.message(" SNOW_INSTANCE=your-instance.service-now.com")
		prompts.log.message(" SNOW_CLIENT_ID=your_oauth_client_id")
		prompts.log.message(" SNOW_CLIENT_SECRET=your_oauth_client_secret")
		prompts.log.message(" 2. Run: snow-flow auth login")
		prompts.log.message("")
		prompts.log.info("To get OAuth credentials:")
		prompts.log.message(" • ServiceNow: System OAuth > Application Registry > New OAuth Application")
		prompts.log.message(
		` • Redirect URI: http://${snowFlowConfig.servicenow.oauth.redirectHost}:${snowFlowConfig.servicenow.oauth.redirectPort}${snowFlowConfig.servicenow.oauth.redirectPath}`,
		)
		prompts.log.message(" • Scopes: useraccount write admin")
		prompts.log.message("")

		return null
		} catch (error) {
		prompts.log.error(`Error loading credentials: ${error}`)
		return null
		}
		}

		/**
		* Validate OAuth client secret format
		* OAuth secrets are typically long random strings (32+ chars) with mixed case and alphanumeric
		* Common passwords are shorter and may contain dictionary words
		*/
		validateClientSecret(clientSecret: string): { valid: boolean; reason?: string } {
		// Check minimum length - OAuth secrets are typically 32+ characters
		if (clientSecret.length < 20) {
		return {
		valid: false,
		reason: "OAuth Client Secret too short. Expected 32+ character random string from ServiceNow.",
		}
		}

		// Check for common password patterns
		const commonPasswordPatterns = [
		/^password/i,
		/^admin/i,
		/^test/i,
		/^demo/i,
		/^welcome/i,
		/123456/,
		/qwerty/i,
		/^[a-z]+\d{1,4}$/i, // Simple word + numbers like "Welkom123"
		/^[A-Z][a-z]+\d{1,4}$/, // Capitalized word + numbers
		]

		for (const pattern of commonPasswordPatterns) {
		if (pattern.test(clientSecret)) {
		return {
		valid: false,
		reason: `OAuth Client Secret appears to be a password. ServiceNow OAuth secrets are long random strings (e.g., "a1b2c3d4e5f6..."). Check your Application Registry in ServiceNow.`,
		}
		}
		}

		// Check for sufficient entropy (mix of upper, lower, numbers)
		const hasUpper = /[A-Z]/.test(clientSecret)
		const hasLower = /[a-z]/.test(clientSecret)
		const hasNumber = /[0-9]/.test(clientSecret)
		const charTypes = [hasUpper, hasLower, hasNumber].filter(Boolean).length

		if (charTypes < 2) {
		return {
		valid: false,
		reason: "OAuth Client Secret lacks complexity. ServiceNow generates secrets with mixed case and numbers.",
		}
		}

		return { valid: true }
		}

		/**
		* Get credentials (compatibility method for MCP servers)
		*/
		async getCredentials(): Promise<ServiceNowCredentials \| null> {
		return await this.loadCredentials()
		}
		}

-114

src/servicenow/utils/sync-mcp-configs.ts

		/**
		* MCP Configuration Sync Utility
		*
		* Synchronizes MCP configurations between different locations:
		* - Project .mcp.json
		* - Global ~/.snow-code/.mcp.json
		* - Claude Desktop configuration
		*/

		import fs from "fs/promises"
		import path from "path"
		import os from "os"

		interface McpServerConfig {
		type?: string
		command?: string \| string[]
		args?: string[]
		env?: Record<string, string>
		environment?: Record<string, string>
		enabled?: boolean
		}

		interface McpConfig {
		mcp?: Record<string, McpServerConfig>
		mcpServers?: Record<string, McpServerConfig>
		servers?: Record<string, McpServerConfig>
		}

		/**
		* Sync MCP configurations from project to other locations
		* @param projectDir - Project directory containing .mcp.json
		*/
		export async function syncMcpConfigs(projectDir: string): Promise<void> {
		const projectMcpPath = path.join(projectDir, ".mcp.json")

		// Read project MCP config
		let projectConfig: McpConfig
		try {
		const content = await fs.readFile(projectMcpPath, "utf-8")
		projectConfig = JSON.parse(content)
		} catch (err) {
		throw new Error(`Failed to read project .mcp.json: ${err instanceof Error ? err.message : String(err)}`)
		}

		// Get servers from project config
		const servers = projectConfig.mcp \|\| projectConfig.mcpServers \|\| projectConfig.servers \|\| {}

		// Sync to Claude Desktop config if it exists
		const claudeConfigDir = path.join(projectDir, ".claude")
		const claudeMcpConfigPath = path.join(claudeConfigDir, "mcp-config.json")

		try {
		// Check if .claude directory exists or should be created
		await fs.mkdir(claudeConfigDir, { recursive: true })

		// Read existing Claude MCP config or create new one
		let claudeConfig: { mcpServers?: Record<string, McpServerConfig> } = {}
		try {
		const existingContent = await fs.readFile(claudeMcpConfigPath, "utf-8")
		claudeConfig = JSON.parse(existingContent)
		} catch {
		// File doesn't exist, start fresh
		}

		// Merge servers into Claude config
		if (!claudeConfig.mcpServers) {
		claudeConfig.mcpServers = {}
		}

		// Copy enterprise server config
		if (servers["snow-flow-enterprise"]) {
		claudeConfig.mcpServers["snow-flow-enterprise"] = servers["snow-flow-enterprise"]
		}

		// Write updated Claude config
		await fs.writeFile(claudeMcpConfigPath, JSON.stringify(claudeConfig, null, 2), "utf-8")
		} catch (err) {
		// Silently continue if Claude config sync fails
		console.error(`Warning: Could not sync to Claude config: ${err instanceof Error ? err.message : String(err)}`)
		}

		// Also sync to global config
		const globalConfigDir = path.join(os.homedir(), ".snow-code")
		const globalMcpPath = path.join(globalConfigDir, ".mcp.json")

		try {
		await fs.mkdir(globalConfigDir, { recursive: true })

		let globalConfig: McpConfig = {}
		try {
		const existingContent = await fs.readFile(globalMcpPath, "utf-8")
		globalConfig = JSON.parse(existingContent)
		} catch {
		// File doesn't exist, start fresh
		}

		// Use same key format as project
		const serversKey = projectConfig.mcp ? "mcp" : projectConfig.mcpServers ? "mcpServers" : "servers"

		if (!globalConfig[serversKey]) {
		globalConfig[serversKey] = {}
		}

		// Copy enterprise server config
		if (servers["snow-flow-enterprise"]) {
		globalConfig[serversKey]!["snow-flow-enterprise"] = servers["snow-flow-enterprise"]
		}

		await fs.writeFile(globalMcpPath, JSON.stringify(globalConfig, null, 2), "utf-8")
		} catch (err) {
		// Silently continue if global config sync fails
		console.error(`Warning: Could not sync to global config: ${err instanceof Error ? err.message : String(err)}`)
		}
		}

-346

src/servicenow/utils/timer-registry.ts

		/**
		* Timer Registry - Centralized timer management for snow-flow
		* Ensures all intervals/timeouts are properly tracked and cleaned up
		*
		* This module provides automatic cleanup ONLY during graceful shutdown.
		* Timers are NOT cleaned up aggressively during normal operation.
		*
		* @module timer-registry
		*/

		import { Logger } from "./logger.js"

		/**
		* Shutdown handler function type
		*/
		type ShutdownHandler = () => Promise<void> \| void

		/**
		* Timer info for tracking
		*/
		interface TimerInfo {
		id: string
		type: "interval" \| "timeout"
		timer: NodeJS.Timeout
		createdAt: number
		callback: string // Function name for debugging
		}

		/**
		* TimerRegistry - Singleton class for centralized timer management
		*
		* Features:
		* - Automatic cleanup on process exit
		* - Named timers for easy management
		* - Shutdown handlers for graceful cleanup
		* - Statistics and monitoring
		*/
		export class TimerRegistry {
		private static instance: TimerRegistry
		private intervals: Map<string, TimerInfo> = new Map()
		private timeouts: Map<string, TimerInfo> = new Map()
		private shutdownHandlers: ShutdownHandler[] = []
		private logger: Logger
		private isShuttingDown = false
		private shutdownHandlersRegistered = false

		private constructor() {
		this.logger = new Logger("TimerRegistry")
		this.registerGlobalShutdownHandlers()
		}

		/**
		* Get the singleton instance
		*/
		static getInstance(): TimerRegistry {
		if (!TimerRegistry.instance) {
		TimerRegistry.instance = new TimerRegistry()
		}
		return TimerRegistry.instance
		}

		/**
		* Register global shutdown handlers (only once)
		*/
		private registerGlobalShutdownHandlers(): void {
		if (this.shutdownHandlersRegistered) return

		const shutdownHandler = async (signal: string) => {
		if (this.isShuttingDown) return
		this.isShuttingDown = true

		await this.cleanup()
		}

		// Use once() to avoid listener accumulation
		process.once("beforeExit", () => shutdownHandler("beforeExit"))
		process.once("SIGTERM", () => shutdownHandler("SIGTERM"))
		process.once("SIGINT", () => shutdownHandler("SIGINT"))

		this.shutdownHandlersRegistered = true
		}

		/**
		* Register a named interval
		*
		* @param id Unique identifier for the interval
		* @param callback Function to execute
		* @param ms Interval in milliseconds
		* @param unref If true, don't keep the process alive for this timer (default: true)
		* @returns The NodeJS.Timeout object
		*/
		registerInterval(id: string, callback: () => void \| Promise<void>, ms: number, unref = true): NodeJS.Timeout {
		// Clear existing interval with same id
		this.clearInterval(id)

		const wrappedCallback = async () => {
		try {
		await callback()
		} catch (error) {
		this.logger.error(`Interval ${id} error:`, error)
		}
		}

		const timer = setInterval(wrappedCallback, ms)
		if (unref) timer.unref()

		const info: TimerInfo = {
		id,
		type: "interval",
		timer,
		createdAt: Date.now(),
		callback: callback.name \|\| "anonymous",
		}

		this.intervals.set(id, info)
		this.logger.debug(`Registered interval: ${id} (${ms}ms)`)

		return timer
		}

		/**
		* Register a named timeout
		*
		* @param id Unique identifier for the timeout
		* @param callback Function to execute
		* @param ms Delay in milliseconds
		* @returns The NodeJS.Timeout object
		*/
		registerTimeout(id: string, callback: () => void \| Promise<void>, ms: number): NodeJS.Timeout {
		// Clear existing timeout with same id
		this.clearTimeout(id)

		const wrappedCallback = async () => {
		this.timeouts.delete(id)
		try {
		await callback()
		} catch (error) {
		this.logger.error(`Timeout ${id} error:`, error)
		}
		}

		const timer = setTimeout(wrappedCallback, ms)

		const info: TimerInfo = {
		id,
		type: "timeout",
		timer,
		createdAt: Date.now(),
		callback: callback.name \|\| "anonymous",
		}

		this.timeouts.set(id, info)
		this.logger.debug(`Registered timeout: ${id} (${ms}ms)`)

		return timer
		}

		/**
		* Clear a named interval
		* @param id The interval identifier
		*/
		clearInterval(id: string): void {
		const info = this.intervals.get(id)
		if (info) {
		clearInterval(info.timer)
		this.intervals.delete(id)
		this.logger.debug(`Cleared interval: ${id}`)
		}
		}

		/**
		* Clear a named timeout
		* @param id The timeout identifier
		*/
		clearTimeout(id: string): void {
		const info = this.timeouts.get(id)
		if (info) {
		clearTimeout(info.timer)
		this.timeouts.delete(id)
		this.logger.debug(`Cleared timeout: ${id}`)
		}
		}

		/**
		* Check if an interval exists
		* @param id The interval identifier
		*/
		hasInterval(id: string): boolean {
		return this.intervals.has(id)
		}

		/**
		* Check if a timeout exists
		* @param id The timeout identifier
		*/
		hasTimeout(id: string): boolean {
		return this.timeouts.has(id)
		}

		/**
		* Register a shutdown handler
		* Called during cleanup() in reverse order of registration
		*
		* @param handler Async function to call during shutdown
		*/
		registerShutdownHandler(handler: ShutdownHandler): void {
		this.shutdownHandlers.push(handler)
		this.logger.debug(`Registered shutdown handler (total: ${this.shutdownHandlers.length})`)
		}

		/**
		* Remove a shutdown handler
		* @param handler The handler to remove
		*/
		removeShutdownHandler(handler: ShutdownHandler): void {
		const idx = this.shutdownHandlers.indexOf(handler)
		if (idx > -1) {
		this.shutdownHandlers.splice(idx, 1)
		this.logger.debug(`Removed shutdown handler (total: ${this.shutdownHandlers.length})`)
		}
		}

		/**
		* Cleanup all timers and run shutdown handlers
		*/
		async cleanup(): Promise<void> {
		// Clear all intervals
		const intervalCount = this.intervals.size
		this.intervals.forEach((info) => {
		clearInterval(info.timer)
		})
		this.intervals.clear()

		// Clear all timeouts
		const timeoutCount = this.timeouts.size
		this.timeouts.forEach((info) => {
		clearTimeout(info.timer)
		})
		this.timeouts.clear()

		// Run shutdown handlers in reverse order (LIFO)
		const handlerCount = this.shutdownHandlers.length
		const handlers = [...this.shutdownHandlers].reverse()
		this.shutdownHandlers = []

		for (const handler of handlers) {
		try {
		await handler()
		} catch (error) {
		this.logger.error("Shutdown handler error:", error)
		}
		}
		}

		/**
		* Get statistics about registered timers
		*/
		getStats(): {
		intervals: number
		timeouts: number
		shutdownHandlers: number
		intervalIds: string[]
		timeoutIds: string[]
		} {
		return {
		intervals: this.intervals.size,
		timeouts: this.timeouts.size,
		shutdownHandlers: this.shutdownHandlers.length,
		intervalIds: Array.from(this.intervals.keys()),
		timeoutIds: Array.from(this.timeouts.keys()),
		}
		}

		/**
		* Get detailed information about all timers
		*/
		getDetailedStats(): {
		intervals: Array<{ id: string; ageMs: number; callback: string }>
		timeouts: Array<{ id: string; ageMs: number; callback: string }>
		shutdownHandlerCount: number
		} {
		const now = Date.now()

		return {
		intervals: Array.from(this.intervals.values()).map((info) => ({
		id: info.id,
		ageMs: now - info.createdAt,
		callback: info.callback,
		})),
		timeouts: Array.from(this.timeouts.values()).map((info) => ({
		id: info.id,
		ageMs: now - info.createdAt,
		callback: info.callback,
		})),
		shutdownHandlerCount: this.shutdownHandlers.length,
		}
		}

		/**
		* Clear all timers by prefix
		* Useful for cleaning up all timers from a specific component
		*
		* @param prefix The prefix to match (e.g., 'mcp-' clears 'mcp-auth', 'mcp-metrics', etc.)
		*/
		clearByPrefix(prefix: string): { intervals: number; timeouts: number } {
		let intervalCount = 0
		let timeoutCount = 0

		// Collect keys to clear (can't modify while iterating)
		const intervalsToClear: string[] = []
		const timeoutsToClear: string[] = []

		this.intervals.forEach((_, id) => {
		if (id.startsWith(prefix)) {
		intervalsToClear.push(id)
		}
		})

		this.timeouts.forEach((_, id) => {
		if (id.startsWith(prefix)) {
		timeoutsToClear.push(id)
		}
		})

		// Clear collected timers
		intervalsToClear.forEach((id) => {
		this.clearInterval(id)
		intervalCount++
		})

		timeoutsToClear.forEach((id) => {
		this.clearTimeout(id)
		timeoutCount++
		})

		this.logger.debug(`Cleared by prefix '${prefix}': ${intervalCount} intervals, ${timeoutCount} timeouts`)

		return { intervals: intervalCount, timeouts: timeoutCount }
		}
		}

		/**
		* Singleton instance of TimerRegistry
		* Use this for all timer management in snow-flow
		*/
		export const timerRegistry = TimerRegistry.getInstance()

src/cli/cmd/tui/component/dialog-auth.tsx

Sorry, the diff of this file is too big to display

snow-flow - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics