snow-flow 4.6.9 → 5.0.1

package/dist/mcp/servicenow-mcp-unified/tools/deployment/snow_deploy.js

@@ -0,0 +1,312 @@
+"use strict";
+/**
+ * snow_deploy - Deploy ServiceNow artifacts with validation
+ *
+ * Deploys widgets, pages, flows, and other artifacts to ServiceNow
+ * with automatic ES5 validation, coherence checking, and Update Set management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_deploy',
+    description: 'Deploy ServiceNow artifacts (widgets, pages, flows) with automatic validation and Update Set management',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            type: {
+                type: 'string',
+                enum: ['widget', 'page', 'flow', 'application', 'component'],
+                description: 'Type of artifact to deploy'
+            },
+            config: {
+                type: 'object',
+                description: 'Artifact configuration (fields depend on type)',
+                properties: {
+                    name: { type: 'string', description: 'Artifact name' },
+                    title: { type: 'string', description: 'Display title' },
+                    description: { type: 'string', description: 'Artifact description' },
+                    template: { type: 'string', description: 'HTML template (for widgets)' },
+                    script: { type: 'string', description: 'Server script (for widgets)' },
+                    client_script: { type: 'string', description: 'Client script (for widgets)' },
+                    css: { type: 'string', description: 'CSS styles (for widgets)' },
+                    option_schema: { type: 'string', description: 'Option schema JSON (for widgets)' }
+                }
+            },
+            validate_coherence: {
+                type: 'boolean',
+                description: 'Validate widget coherence (HTML/Client/Server communication)',
+                default: true
+            },
+            validate_es5: {
+                type: 'boolean',
+                description: 'Validate ES5 syntax in server scripts',
+                default: true
+            },
+            create_update_set: {
+                type: 'boolean',
+                description: 'Create new Update Set for this deployment',
+                default: false
+            },
+            update_set_name: {
+                type: 'string',
+                description: 'Name for new Update Set (if create_update_set=true)'
+            }
+        },
+        required: ['type', 'config']
+    }
+};
+async function execute(args, context) {
+    const { type, config, validate_coherence = true, validate_es5 = true, create_update_set = false, update_set_name } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Step 1: Pre-deployment validation
+        if (type === 'widget') {
+            // ES5 validation for server script
+            if (validate_es5 && config.script) {
+                const es5Validation = validateES5Syntax(config.script);
+                if (!es5Validation.valid) {
+                    throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.ES5_SYNTAX_ERROR, 'Server script contains non-ES5 syntax', {
+                        retryable: false,
+                        details: {
+                            violations: es5Validation.violations.map(v => ({
+                                type: v.type,
+                                line: v.line,
+                                code: v.code,
+                                fix: v.fix
+                            }))
+                        }
+                    });
+                }
+            }
+            // Widget coherence validation
+            if (validate_coherence) {
+                const coherenceResult = validateWidgetCoherence(config);
+                if (!coherenceResult.coherent) {
+                    const criticalIssues = coherenceResult.issues.filter(i => i.severity === 'critical');
+                    if (criticalIssues.length > 0) {
+                        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.WIDGET_COHERENCE_ERROR, 'Widget coherence validation failed', {
+                            retryable: false,
+                            details: {
+                                critical: criticalIssues,
+                                warnings: coherenceResult.issues.filter(i => i.severity === 'warning'),
+                                analysis: coherenceResult.analysis
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        // Step 2: Create/ensure Update Set if needed
+        let updateSetId;
+        if (create_update_set && update_set_name) {
+            const updateSetResponse = await client.post('/api/now/table/sys_update_set', {
+                name: update_set_name,
+                description: `Deployment: ${config.name || 'Artifact'}`,
+                state: 'in progress'
+            });
+            updateSetId = updateSetResponse.data.result.sys_id;
+            // Set as current Update Set
+            await client.put(`/api/now/table/sys_update_set/${updateSetId}`, {
+                is_current: true
+            });
+        }
+        // Step 3: Deploy artifact based on type
+        let deploymentResult;
+        switch (type) {
+            case 'widget':
+                deploymentResult = await deployWidget(client, config);
+                break;
+            case 'page':
+                deploymentResult = await deployPage(client, config);
+                break;
+            case 'flow':
+                deploymentResult = await deployFlow(client, config);
+                break;
+            default:
+                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, `Unsupported artifact type: ${type}`, { retryable: false });
+        }
+        // Step 4: Return success result
+        return (0, error_handler_js_1.createSuccessResult)({
+            sys_id: deploymentResult.sys_id,
+            table: deploymentResult.table,
+            name: config.name,
+            type,
+            url: `${context.instanceUrl}/nav_to.do?uri=${deploymentResult.table}.do?sys_id=${deploymentResult.sys_id}`
+        }, {
+            updateSetId,
+            validations: {
+                es5: validate_es5 ? 'passed' : 'skipped',
+                coherence: validate_coherence ? 'passed' : 'skipped'
+            }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError
+            ? error
+            : new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.DEPLOYMENT_FAILED, error.message, { originalError: error }));
+    }
+}
+/**
+ * Deploy Service Portal widget
+ */
+async function deployWidget(client, config) {
+    const widgetData = {
+        id: config.name,
+        name: config.title || config.name,
+        description: config.description || '',
+        template: config.template || '',
+        script: config.script || '',
+        client_script: config.client_script || '',
+        css: config.css || '',
+        option_schema: config.option_schema || ''
+    };
+    // Check if widget exists
+    const existingResponse = await client.get('/api/now/table/sp_widget', {
+        params: {
+            sysparm_query: `id=${config.name}`,
+            sysparm_limit: 1
+        }
+    });
+    let result;
+    if (existingResponse.data.result.length > 0) {
+        // Update existing widget
+        const sys_id = existingResponse.data.result[0].sys_id;
+        const updateResponse = await client.put(`/api/now/table/sp_widget/${sys_id}`, widgetData);
+        result = updateResponse.data.result;
+    }
+    else {
+        // Create new widget
+        const createResponse = await client.post('/api/now/table/sp_widget', widgetData);
+        result = createResponse.data.result;
+    }
+    return {
+        sys_id: result.sys_id,
+        table: 'sp_widget'
+    };
+}
+/**
+ * Deploy UI Builder page
+ */
+async function deployPage(client, config) {
+    const pageData = {
+        name: config.name,
+        title: config.title || config.name,
+        description: config.description || ''
+    };
+    const response = await client.post('/api/now/table/sys_ux_page', pageData);
+    return {
+        sys_id: response.data.result.sys_id,
+        table: 'sys_ux_page'
+    };
+}
+/**
+ * Deploy Flow Designer flow (via XML import only)
+ */
+async function deployFlow(client, config) {
+    throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.INVALID_REQUEST, 'Flow deployment requires XML import via snow_import_flow_from_xml', { retryable: false });
+}
+/**
+ * Validate ES5 syntax in JavaScript code
+ */
+function validateES5Syntax(code) {
+    const violations = [];
+    // Check for const/let
+    const constLetPattern = /\b(const|let)\s+/g;
+    let match;
+    while ((match = constLetPattern.exec(code)) !== null) {
+        violations.push({
+            type: match[1] === 'const' ? 'const' : 'let',
+            line: code.substring(0, match.index).split('\n').length,
+            code: match[0],
+            fix: `Use 'var' instead of '${match[1]}'`
+        });
+    }
+    // Check for arrow functions
+    const arrowPattern = /\([^)]*\)\s*=>/g;
+    while ((match = arrowPattern.exec(code)) !== null) {
+        violations.push({
+            type: 'arrow_function',
+            line: code.substring(0, match.index).split('\n').length,
+            code: match[0],
+            fix: 'Use function() {} instead of arrow function'
+        });
+    }
+    // Check for template literals
+    const templatePattern = /`[^`]*`/g;
+    while ((match = templatePattern.exec(code)) !== null) {
+        violations.push({
+            type: 'template_literal',
+            line: code.substring(0, match.index).split('\n').length,
+            code: match[0],
+            fix: 'Use string concatenation with + instead of template literals'
+        });
+    }
+    return {
+        valid: violations.length === 0,
+        violations
+    };
+}
+/**
+ * Validate widget coherence (HTML/Client/Server communication)
+ */
+function validateWidgetCoherence(config) {
+    const issues = [];
+    const analysis = {
+        serverInitializedData: [],
+        clientMethods: [],
+        htmlReferences: [],
+        inputActions: []
+    };
+    // Extract data properties from server script
+    if (config.script) {
+        const dataPattern = /data\.(\w+)\s*=/g;
+        let match;
+        while ((match = dataPattern.exec(config.script)) !== null) {
+            analysis.serverInitializedData.push(match[1]);
+        }
+        // Extract input.action handlers
+        const actionPattern = /input\.action\s*===?\s*['"](\w+)['"]/g;
+        while ((match = actionPattern.exec(config.script)) !== null) {
+            analysis.inputActions.push(match[1]);
+        }
+    }
+    // Extract data references from HTML
+    if (config.template) {
+        const htmlDataPattern = /\{\{data\.(\w+)\}\}/g;
+        let match;
+        while ((match = htmlDataPattern.exec(config.template)) !== null) {
+            analysis.htmlReferences.push(match[1]);
+        }
+        // Check if HTML references exist in server data
+        analysis.htmlReferences.forEach(ref => {
+            if (!analysis.serverInitializedData.includes(ref)) {
+                issues.push({
+                    type: 'missing_data',
+                    severity: 'critical',
+                    description: `HTML references data.${ref} but server doesn't initialize it`,
+                    location: 'template',
+                    fix: `Add 'data.${ref} = ...;' to server script`
+                });
+            }
+        });
+    }
+    // Extract methods from client script
+    if (config.client_script) {
+        const methodPattern = /(?:c|$scope)\.(\w+)\s*=\s*function/g;
+        let match;
+        while ((match = methodPattern.exec(config.client_script)) !== null) {
+            analysis.clientMethods.push(match[1]);
+        }
+    }
+    return {
+        coherent: issues.filter(i => i.severity === 'critical').length === 0,
+        issues,
+        analysis
+    };
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_deploy.js.map

package/dist/mcp/servicenow-mcp-unified/tools/deployment/snow_deployment_debug.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snow_deployment_debug - Deployment debugging information
+ *
+ * Provides detailed debugging info including auth status, permissions, sessions, and logs
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_deployment_debug.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/deployment/snow_deployment_debug.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * snow_deployment_debug - Deployment debugging information
+ *
+ * Provides detailed debugging info including auth status, permissions, sessions, and logs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_deployment_debug',
+    description: 'Provides detailed debugging information including authentication status, permissions, active sessions, and recent deployment logs for troubleshooting.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    }
+};
+async function execute(args, context) {
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const debugInfo = {
+            timestamp: new Date().toISOString(),
+            instance: context.instanceUrl,
+            checks: {}
+        };
+        // Check 1: Authentication Status
+        try {
+            const userResponse = await client.get('/api/now/table/sys_user/me');
+            debugInfo.checks.authentication = {
+                status: '✅ Authenticated',
+                user: userResponse.data.result?.user_name || 'Unknown',
+                roles: userResponse.data.result?.roles || 'Not retrieved'
+            };
+        }
+        catch (authError) {
+            debugInfo.checks.authentication = {
+                status: '❌ Authentication Failed',
+                error: authError.message
+            };
+        }
+        // Check 2: Update Set Status
+        try {
+            const updateSetResponse = await client.get('/api/now/table/sys_update_set', {
+                params: {
+                    sysparm_query: 'state=in progress',
+                    sysparm_limit: 5,
+                    sysparm_fields: 'name,state,sys_id'
+                }
+            });
+            debugInfo.checks.updateSets = {
+                status: '✅ Accessible',
+                active: updateSetResponse.data.result || []
+            };
+        }
+        catch (updateSetError) {
+            debugInfo.checks.updateSets = {
+                status: '❌ Not Accessible',
+                error: updateSetError.message
+            };
+        }
+        // Check 3: Recent Errors
+        try {
+            const logsResponse = await client.get('/api/now/table/syslog', {
+                params: {
+                    sysparm_query: 'level=error^sys_created_on>=javascript:gs.daysAgoStart(1)^ORDERBYDESCsys_created_on',
+                    sysparm_limit: 5,
+                    sysparm_fields: 'message,source,sys_created_on'
+                }
+            });
+            debugInfo.checks.recentErrors = {
+                status: logsResponse.data.result?.length > 0 ? '⚠️ Errors Found' : '✅ No Recent Errors',
+                errors: logsResponse.data.result || []
+            };
+        }
+        catch (logError) {
+            debugInfo.checks.recentErrors = {
+                status: '⚠️ Cannot Access Logs',
+                error: logError.message
+            };
+        }
+        // Check 4: Service Portal Access
+        try {
+            const portalResponse = await client.get('/api/now/table/sp_portal', {
+                params: {
+                    sysparm_limit: 1,
+                    sysparm_fields: 'title'
+                }
+            });
+            debugInfo.checks.servicePortal = {
+                status: '✅ Accessible',
+                portals: portalResponse.data.result?.length || 0
+            };
+        }
+        catch (portalError) {
+            debugInfo.checks.servicePortal = {
+                status: '❌ Not Accessible',
+                error: portalError.message
+            };
+        }
+        // Check 5: API Rate Limits
+        debugInfo.checks.apiLimits = {
+            status: '✅ No Limits Detected',
+            note: 'ServiceNow typically allows 5000 API calls per hour'
+        };
+        // Generate summary
+        const successfulChecks = Object.values(debugInfo.checks).filter((check) => check.status?.includes('✅')).length;
+        const totalChecks = Object.keys(debugInfo.checks).length;
+        const summary = `🔍 Deployment Debug Information\n\n` +
+            `Instance: ${debugInfo.instance}\n` +
+            `Timestamp: ${debugInfo.timestamp}\n` +
+            `Health: ${successfulChecks}/${totalChecks} checks passed\n\n` +
+            Object.entries(debugInfo.checks).map(([key, value]) => `${value.status} ${key}: ${value.error || value.note || 'OK'}`).join('\n');
+        return (0, error_handler_js_1.createSuccessResult)(debugInfo, { message: summary });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError
+            ? error
+            : new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NETWORK_ERROR, `Debug info failed: ${error.message}`, { originalError: error }));
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_deployment_debug.js.map

package/dist/mcp/servicenow-mcp-unified/tools/deployment/snow_deployment_status.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snow_deployment_status - Get comprehensive deployment status
+ *
+ * Retrieves deployment history, active deployments, and success rates
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_deployment_status.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/deployment/snow_deployment_status.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * snow_deployment_status - Get comprehensive deployment status
+ *
+ * Retrieves deployment history, active deployments, and success rates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_deployment_status',
+    description: 'Retrieves comprehensive deployment status including active deployments, recent history, success rates, and performance metrics.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            limit: { type: 'number', description: 'Number of recent deployments to show', default: 10 },
+        },
+    }
+};
+async function execute(args, context) {
+    const { limit = 10 } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Get recent Update Sets as deployment history
+        const updateSetsResponse = await client.get('/api/now/table/sys_update_set', {
+            params: {
+                sysparm_query: 'sys_created_on>=javascript:gs.daysAgoStart(7)^ORDERBYDESCsys_created_on',
+                sysparm_limit: limit,
+                sysparm_fields: 'name,description,state,sys_created_on,sys_updated_on,sys_created_by,sys_updated_by'
+            }
+        });
+        // Get deployment-related Service Portal widgets
+        const widgetsResponse = await client.get('/api/now/table/sp_widget', {
+            params: {
+                sysparm_query: 'sys_created_on>=javascript:gs.daysAgoStart(7)^ORDERBYDESCsys_created_on',
+                sysparm_limit: 5,
+                sysparm_fields: 'name,title,sys_created_on,sys_created_by'
+            }
+        });
+        // Process deployment history
+        const deployments = [];
+        // Add update sets
+        if (updateSetsResponse.data.result) {
+            for (const updateSet of updateSetsResponse.data.result) {
+                const status = updateSet.state === 'complete' ? '✅' :
+                    updateSet.state === 'ignore' ? '❌' : '⏳';
+                const timeAgo = formatTimeAgo(updateSet.sys_created_on);
+                deployments.push({
+                    type: 'Update Set',
+                    name: updateSet.name,
+                    status: status,
+                    time: timeAgo,
+                    details: `State: ${updateSet.state}${updateSet.description ? ` - ${updateSet.description}` : ''}`
+                });
+            }
+        }
+        // Add recent widgets
+        if (widgetsResponse.data.result) {
+            for (const widget of widgetsResponse.data.result) {
+                const timeAgo = formatTimeAgo(widget.sys_created_on);
+                deployments.push({
+                    type: 'Widget',
+                    name: widget.name,
+                    status: '✅',
+                    time: timeAgo,
+                    details: widget.title || 'Service Portal Widget'
+                });
+            }
+        }
+        // Sort by creation time (most recent first)
+        deployments.sort((a, b) => {
+            const timeA = new Date(a.time.includes('ago') ? Date.now() : a.time);
+            const timeB = new Date(b.time.includes('ago') ? Date.now() : b.time);
+            return timeB.getTime() - timeA.getTime();
+        });
+        const topDeployments = deployments.slice(0, limit);
+        // Calculate statistics
+        const totalToday = deployments.filter(d => d.time.includes('hour') || d.time.includes('minute')).length;
+        const successful = deployments.filter(d => d.status === '✅').length;
+        const total = deployments.length;
+        const successRate = total > 0 ? Math.round((successful / total) * 100) : 0;
+        // Format deployment list
+        const deploymentList = topDeployments.map((deployment, index) => `${index + 1}. ${deployment.status} ${deployment.type}: ${deployment.name} - ${deployment.time}\n   ${deployment.details}`).join('\n');
+        // Get active/pending update sets
+        const activeResponse = await client.get('/api/now/table/sys_update_set', {
+            params: {
+                sysparm_query: 'state!=complete^state!=ignore',
+                sysparm_fields: 'name,state',
+                sysparm_limit: 5
+            }
+        });
+        let activeStatus = '';
+        if (activeResponse.data.result?.length > 0) {
+            activeStatus = '\n🔄 Active Update Sets:\n' +
+                activeResponse.data.result.map((us) => `   - ${us.name} (${us.state})`).join('\n');
+        }
+        return (0, error_handler_js_1.createSuccessResult)({
+            deployments: topDeployments,
+            statistics: {
+                successRate,
+                successful,
+                total,
+                totalToday
+            },
+            activeUpdateSets: activeResponse.data.result || []
+        }, {
+            message: `📊 Recent Deployment History (Last ${limit}):\n\n${deploymentList || 'No recent deployments found in the last 7 days'}\n\n📈 Deployment Statistics:\n- Success Rate: ${successRate}% (${successful}/${total} deployments)\n- Total Deployments Today: ${totalToday}\n- Total Deployments (7 days): ${total}${activeStatus}\n\n🔗 View complete history in ServiceNow: System Update Sets > Local Update Sets`
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError
+            ? error
+            : new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NETWORK_ERROR, `Failed to get deployment status: ${error.message}`, { originalError: error }));
+    }
+}
+function formatTimeAgo(dateString) {
+    try {
+        const date = new Date(dateString);
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        const diffMinutes = Math.floor(diffMs / (1000 * 60));
+        const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+        const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+        if (diffMinutes < 60) {
+            return `${diffMinutes} minutes ago`;
+        }
+        else if (diffHours < 24) {
+            return `${diffHours} hours ago`;
+        }
+        else {
+            return `${diffDays} days ago`;
+        }
+    }
+    catch (error) {
+        return dateString;
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_deployment_status.js.map

package/dist/mcp/servicenow-mcp-unified/tools/deployment/snow_export_artifact.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snow_export_artifact - Export ServiceNow artifacts
+ *
+ * Exports widgets, applications to JSON/XML format for backup or migration
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_export_artifact.d.ts.map