snow-flow 4.6.9 → 5.0.0

package/dist/mcp/servicenow-mcp-unified/tools/system-properties/snow_property_search.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Search properties by name or value content
+ * Uses official ServiceNow Table API on sys_properties
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tool = void 0;
+exports.snow_property_search = snow_property_search;
+const zod_1 = require("zod");
+const servicenow_client_js_1 = require("../../../../utils/servicenow-client.js");
+const mcp_logger_js_1 = require("../../../shared/mcp-logger.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const schema = zod_1.z.object({
+    search_term: zod_1.z.string().describe('Search term to find in property names or values'),
+    search_in: zod_1.z.enum(['name', 'value', 'description', 'all']).optional().default('all').describe('Where to search'),
+    limit: zod_1.z.number().optional().default(50).describe('Maximum results'),
+});
+async function snow_property_search(args) {
+    const params = schema.parse(args);
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    const logger = new mcp_logger_js_1.MCPLogger('snow_property_search');
+    try {
+        logger.info(`Searching properties for: ${params.search_term}`);
+        let query = '';
+        switch (params.search_in) {
+            case 'name':
+                query = `nameLIKE${params.search_term}`;
+                break;
+            case 'value':
+                query = `valueLIKE${params.search_term}`;
+                break;
+            case 'description':
+                query = `descriptionLIKE${params.search_term}`;
+                break;
+            case 'all':
+            default:
+                query = `nameLIKE${params.search_term}^ORvalueLIKE${params.search_term}^ORdescriptionLIKE${params.search_term}`;
+        }
+        const response = await client.searchRecords('sys_properties', query, params.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: "${params.search_term}"`
+                    }]
+            };
+        }
+        let output = `🔍 **Search Results** (Found: ${results.length})\n`;
+        output += `Search term: "${params.search_term}" in ${params.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) {
+        logger.error('Search failed:', error);
+        throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Search failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+exports.tool = {
+    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',
+                enum: ['name', 'value', 'description', 'all'],
+                description: 'Where to search',
+                default: 'all'
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum results',
+                default: 50
+            }
+        },
+        required: ['search_term']
+    }
+};
+//# sourceMappingURL=snow_property_search.js.map

package/dist/mcp/servicenow-mcp-unified/tools/system-properties/snow_property_set.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Set or update a system property value
+ * Uses official ServiceNow Table API on sys_properties
+ */
+export declare function snow_property_set(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare const tool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            value: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            choices: {
+                type: string;
+                description: string;
+            };
+            is_private: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            suffix: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=snow_property_set.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/system-properties/snow_property_set.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Set or update a system property value
+ * Uses official ServiceNow Table API on sys_properties
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tool = void 0;
+exports.snow_property_set = snow_property_set;
+const zod_1 = require("zod");
+const servicenow_client_js_1 = require("../../../../utils/servicenow-client.js");
+const mcp_logger_js_1 = require("../../../shared/mcp-logger.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const schema = zod_1.z.object({
+    name: zod_1.z.string().describe('Property name'),
+    value: zod_1.z.string().describe('Property value'),
+    description: zod_1.z.string().optional().describe('Property description (optional)'),
+    type: zod_1.z.string().optional().default('string').describe('Property type (string, boolean, integer, etc.)'),
+    choices: zod_1.z.string().optional().describe('Comma-separated list of valid choices (optional)'),
+    is_private: zod_1.z.boolean().optional().default(false).describe('Mark property as private'),
+    suffix: zod_1.z.string().optional().describe('Property suffix/scope (optional)'),
+});
+async function snow_property_set(args) {
+    const params = schema.parse(args);
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    const logger = new mcp_logger_js_1.MCPLogger('snow_property_set');
+    try {
+        logger.info(`Setting property: ${params.name} = ${params.value}`);
+        // Check if property exists
+        logger.trackAPICall('SEARCH', 'sys_properties', 1);
+        const existing = await client.searchRecords('sys_properties', `name=${params.name}`, 1);
+        let result;
+        if (existing.success && existing.data?.result?.length > 0) {
+            // Update existing property
+            const sys_id = existing.data.result[0].sys_id;
+            logger.trackAPICall('UPDATE', 'sys_properties', 1);
+            result = await client.updateRecord('sys_properties', sys_id, {
+                value: params.value,
+                ...(params.description && { description: params.description }),
+                ...(params.type && { type: params.type }),
+                ...(params.choices && { choices: params.choices }),
+                ...(params.suffix && { suffix: params.suffix }),
+                is_private: params.is_private ? 'true' : 'false'
+            });
+            logger.info(`Updated property: ${params.name}`);
+        }
+        else {
+            // Create new property
+            logger.trackAPICall('CREATE', 'sys_properties', 1);
+            result = await client.createRecord('sys_properties', {
+                name: params.name,
+                value: params.value,
+                description: params.description || `Created by Snow-Flow`,
+                type: params.type,
+                choices: params.choices || '',
+                is_private: params.is_private ? 'true' : 'false',
+                suffix: params.suffix || 'global'
+            });
+            logger.info(`Created new property: ${params.name}`);
+        }
+        if (!result.success) {
+            throw new Error(`Failed to set property: ${result.error}`);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ Property set successfully!
+
+**Name:** ${params.name}
+**Value:** ${params.value}
+**Type:** ${params.type}
+${params.description ? `**Description:** ${params.description}` : ''}
+${params.choices ? `**Choices:** ${params.choices}` : ''}
+**Private:** ${params.is_private ? 'Yes' : 'No'}
+
+💡 Changes take effect immediately in ServiceNow`
+                }]
+        };
+    }
+    catch (error) {
+        logger.error('Failed to set property:', error);
+        throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to set property: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+exports.tool = {
+    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']
+    }
+};
+//# sourceMappingURL=snow_property_set.js.map

package/dist/mcp/servicenow-mcp-unified/tools/system-properties/snow_property_validate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Validate property value against its type and constraints
+ * Uses official ServiceNow Table API on sys_properties
+ */
+export declare function snow_property_validate(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare const tool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            value: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=snow_property_validate.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/system-properties/snow_property_validate.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Validate property value against its type and constraints
+ * Uses official ServiceNow Table API on sys_properties
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tool = void 0;
+exports.snow_property_validate = snow_property_validate;
+const zod_1 = require("zod");
+const servicenow_client_js_1 = require("../../../../utils/servicenow-client.js");
+const mcp_logger_js_1 = require("../../../shared/mcp-logger.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const schema = zod_1.z.object({
+    name: zod_1.z.string().describe('Property name'),
+    value: zod_1.z.string().describe('Value to validate'),
+});
+async function snow_property_validate(args) {
+    const params = schema.parse(args);
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    const logger = new mcp_logger_js_1.MCPLogger('snow_property_validate');
+    try {
+        logger.info(`Validating property: ${params.name} = ${params.value}`);
+        // Get property metadata
+        const response = await client.searchRecords('sys_properties', `name=${params.name}`, 1);
+        if (!response.success || !response.data?.result?.length) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Property not found: ${params.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(params.value.toLowerCase())) {
+                        validationResults.push('❌ Value must be true/false');
+                        isValid = false;
+                    }
+                    else {
+                        validationResults.push('✅ Valid boolean value');
+                    }
+                    break;
+                case 'integer':
+                    if (!/^-?\d+$/.test(params.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(params.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) => c.trim());
+            if (!validChoices.includes(params.value)) {
+                validationResults.push(`❌ Value must be one of: ${validChoices.join(', ')}`);
+                isValid = false;
+            }
+            else {
+                validationResults.push('✅ Valid choice');
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `🔍 **Property Validation: ${params.name}**
+
+**Current Value:** ${property.value}
+**New Value:** ${params.value}
+**Type:** ${property.type || 'string'}
+${property.choices ? `**Valid Choices:** ${property.choices}` : ''}
+
+**Validation Results:**
+${validationResults.join('\n')}
+
+**Overall:** ${isValid ? '✅ VALID' : '❌ INVALID'}`
+                }]
+        };
+    }
+    catch (error) {
+        logger.error('Validation failed:', error);
+        throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Validation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+exports.tool = {
+    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']
+    }
+};
+//# sourceMappingURL=snow_property_validate.js.map

package/dist/mcp/servicenow-mcp-unified/tools/templates/index.d.ts

@@ -0,0 +1,3 @@
+export { toolDefinition as snow_create_template_def, execute as snow_create_template_exec } from './snow_create_template.js';
+export { toolDefinition as snow_apply_template_def, execute as snow_apply_template_exec } from './snow_apply_template.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/templates/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snow_apply_template_exec = exports.snow_apply_template_def = exports.snow_create_template_exec = exports.snow_create_template_def = void 0;
+var snow_create_template_js_1 = require("./snow_create_template.js");
+Object.defineProperty(exports, "snow_create_template_def", { enumerable: true, get: function () { return snow_create_template_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_create_template_exec", { enumerable: true, get: function () { return snow_create_template_js_1.execute; } });
+var snow_apply_template_js_1 = require("./snow_apply_template.js");
+Object.defineProperty(exports, "snow_apply_template_def", { enumerable: true, get: function () { return snow_apply_template_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_apply_template_exec", { enumerable: true, get: function () { return snow_apply_template_js_1.execute; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/servicenow-mcp-unified/tools/templates/snow_apply_template.d.ts

@@ -0,0 +1,9 @@
+/**
+ * snow_apply_template
+ */
+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_apply_template.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/templates/snow_apply_template.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * snow_apply_template
+ */
+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_apply_template',
+    description: 'Apply template to create record',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            template_sys_id: { type: 'string', description: 'Template sys_id' },
+            additional_values: { type: 'object', description: 'Additional field values' }
+        },
+        required: ['template_sys_id']
+    }
+};
+async function execute(args, context) {
+    const { template_sys_id, additional_values = {} } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const templateRecord = await client.get(`/api/now/table/sys_template/${template_sys_id}`);
+        const table = templateRecord.data.result.table;
+        const templateData = JSON.parse(templateRecord.data.result.template);
+        const recordData = { ...templateData, ...additional_values };
+        const response = await client.post(`/api/now/table/${table}`, recordData);
+        return (0, error_handler_js_1.createSuccessResult)({ created: true, record: response.data.result });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_apply_template.js.map

package/dist/mcp/servicenow-mcp-unified/tools/templates/snow_create_template.d.ts

@@ -0,0 +1,9 @@
+/**
+ * snow_create_template
+ */
+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_create_template.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/templates/snow_create_template.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * snow_create_template
+ */
+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_create_template',
+    description: 'Create record template',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Template name' },
+            table: { type: 'string', description: 'Table name' },
+            template: { type: 'object', description: 'Template field values' },
+            active: { type: 'boolean', default: true }
+        },
+        required: ['name', 'table', 'template']
+    }
+};
+async function execute(args, context) {
+    const { name, table, template, active = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const templateData = {
+            name,
+            table,
+            template: JSON.stringify(template),
+            active
+        };
+        const response = await client.post('/api/now/table/sys_template', templateData);
+        return (0, error_handler_js_1.createSuccessResult)({ created: true, template: response.data.result });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_create_template.js.map

package/dist/mcp/servicenow-mcp-unified/tools/transformers/index.d.ts

@@ -0,0 +1,2 @@
+export { toolDefinition as snow_transform_data_def, execute as snow_transform_data_exec } from './snow_transform_data.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/transformers/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snow_transform_data_exec = exports.snow_transform_data_def = void 0;
+var snow_transform_data_js_1 = require("./snow_transform_data.js");
+Object.defineProperty(exports, "snow_transform_data_def", { enumerable: true, get: function () { return snow_transform_data_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_transform_data_exec", { enumerable: true, get: function () { return snow_transform_data_js_1.execute; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/servicenow-mcp-unified/tools/transformers/snow_transform_data.d.ts

@@ -0,0 +1,9 @@
+/**
+ * snow_transform_data
+ */
+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_transform_data.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/transformers/snow_transform_data.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * snow_transform_data
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_transform_data',
+    description: 'Transform data using field mappings',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source_data: { type: 'object', description: 'Source data' },
+            field_mappings: { type: 'object', description: 'Field mapping rules' }
+        },
+        required: ['source_data', 'field_mappings']
+    }
+};
+async function execute(args, context) {
+    const { source_data, field_mappings } = args;
+    try {
+        const transformed = {};
+        for (const [targetField, sourceField] of Object.entries(field_mappings)) {
+            transformed[targetField] = source_data[sourceField];
+        }
+        return (0, error_handler_js_1.createSuccessResult)({
+            transformed: true,
+            data: transformed
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_transform_data.js.map

package/dist/mcp/servicenow-mcp-unified/tools/ui-actions/index.d.ts

@@ -0,0 +1,2 @@
+export { toolDefinition as snow_create_ui_action_def, execute as snow_create_ui_action_exec } from './snow_create_ui_action.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/ui-actions/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snow_create_ui_action_exec = exports.snow_create_ui_action_def = void 0;
+var snow_create_ui_action_js_1 = require("./snow_create_ui_action.js");
+Object.defineProperty(exports, "snow_create_ui_action_def", { enumerable: true, get: function () { return snow_create_ui_action_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_create_ui_action_exec", { enumerable: true, get: function () { return snow_create_ui_action_js_1.execute; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/servicenow-mcp-unified/tools/ui-actions/snow_create_ui_action.d.ts

@@ -0,0 +1,9 @@
+/**
+ * snow_create_ui_action
+ */
+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_create_ui_action.d.ts.map