snow-flow 3.3.7 → 3.3.8

package/.mcp.json.template

@@ -131,6 +131,18 @@
         "SNOW_CLIENT_ID": "{{SNOW_CLIENT_ID}}",
         "SNOW_CLIENT_SECRET": "{{SNOW_CLIENT_SECRET}}"
       }
+    },
+    "servicenow-system-properties": {
+      "command": "node",
+      "args": [
+        "{{PROJECT_ROOT}}/dist/mcp/servicenow-system-properties-mcp.js"
+      ],
+      "description": "System property management via official ServiceNow APIs: get/set/list/delete properties, bulk operations, import/export JSON, validate values, search, categories, audit history - all using standard Table API on sys_properties",
+      "env": {
+        "SNOW_INSTANCE": "{{SNOW_INSTANCE}}",
+        "SNOW_CLIENT_ID": "{{SNOW_CLIENT_ID}}",
+        "SNOW_CLIENT_SECRET": "{{SNOW_CLIENT_SECRET}}"
+      }
     }
   }
 }

package/dist/dynamic-version.js

@@ -36,7 +36,7 @@ function getDynamicVersion() {
         console.warn('Warning: Could not read version from package.json:', error);
     }
     // Fallback to hardcoded version
-    return '3.3.7';
+    return '3.3.8';
 }
 // Export a constant that uses the dynamic version
 exports.VERSION = getDynamicVersion();

package/dist/mcp/servicenow-system-properties-mcp.d.ts

@@ -0,0 +1,68 @@
+/**
+ * ServiceNow System Properties MCP Server
+ *
+ * Provides comprehensive system property management through official ServiceNow APIs
+ * Uses the standard Table API on sys_properties table
+ */
+/**
+ * ServiceNow System Properties MCP Server
+ * Manages system properties through official ServiceNow REST APIs
+ */
+export declare class ServiceNowSystemPropertiesMCP {
+    private server;
+    private client;
+    private propertyCache;
+    constructor();
+    private setupHandlers;
+    private setupTools;
+    /**
+     * Get a system property value
+     */
+    private getProperty;
+    /**
+     * Set or create a system property
+     */
+    private setProperty;
+    /**
+     * List system properties
+     */
+    private listProperties;
+    /**
+     * Delete a system property
+     */
+    private deleteProperty;
+    /**
+     * Search properties
+     */
+    private searchProperties;
+    /**
+     * Bulk get properties
+     */
+    private bulkGetProperties;
+    /**
+     * Bulk set properties
+     */
+    private bulkSetProperties;
+    /**
+     * Export properties
+     */
+    private exportProperties;
+    /**
+     * Import properties
+     */
+    private importProperties;
+    /**
+     * Validate property value
+     */
+    private validateProperty;
+    /**
+     * Get property categories
+     */
+    private getCategories;
+    /**
+     * Get property audit history
+     */
+    private getPropertyHistory;
+    start(): Promise<void>;
+}
+//# sourceMappingURL=servicenow-system-properties-mcp.d.ts.map

package/dist/mcp/servicenow-system-properties-mcp.js

@@ -0,0 +1,1142 @@
+"use strict";
+/**
+ * ServiceNow System Properties MCP Server
+ *
+ * Provides comprehensive system property management through official ServiceNow APIs
+ * Uses the standard Table API on sys_properties table
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceNowSystemPropertiesMCP = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const servicenow_client_js_1 = require("../utils/servicenow-client.js");
+const logger_js_1 = require("../utils/logger.js");
+const logger = new logger_js_1.Logger('ServiceNowSystemProperties');
+/**
+ * ServiceNow System Properties MCP Server
+ * Manages system properties through official ServiceNow REST APIs
+ */
+class ServiceNowSystemPropertiesMCP {
+    constructor() {
+        this.propertyCache = new Map();
+        this.server = new index_js_1.Server({
+            name: 'servicenow-system-properties',
+            version: '1.0.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.client = new servicenow_client_js_1.ServiceNowClient();
+        this.setupHandlers();
+        this.setupTools();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(types_js_1.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']
+                    }
+                }
+            ]
+        }));
+    }
+    setupTools() {
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                // Ensure authentication
+                const isAuthenticated = await this.client.isAuthenticated();
+                if (!isAuthenticated) {
+                    throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, 'Not authenticated. Please run "snow-flow auth login" first.');
+                }
+                switch (name) {
+                    case 'snow_property_get':
+                        return await this.getProperty(args);
+                    case 'snow_property_set':
+                        return await this.setProperty(args);
+                    case 'snow_property_list':
+                        return await this.listProperties(args);
+                    case 'snow_property_delete':
+                        return await this.deleteProperty(args);
+                    case 'snow_property_search':
+                        return await this.searchProperties(args);
+                    case 'snow_property_bulk_get':
+                        return await this.bulkGetProperties(args);
+                    case 'snow_property_bulk_set':
+                        return await this.bulkSetProperties(args);
+                    case 'snow_property_export':
+                        return await this.exportProperties(args);
+                    case 'snow_property_import':
+                        return await this.importProperties(args);
+                    case 'snow_property_validate':
+                        return await this.validateProperty(args);
+                    case 'snow_property_categories':
+                        return await this.getCategories(args);
+                    case 'snow_property_history':
+                        return await this.getPropertyHistory(args);
+                    default:
+                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                logger.error(`Tool execution failed: ${name}`, error);
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+    /**
+     * Get a system property value
+     */
+    async getProperty(args) {
+        const { name, include_metadata = false } = args;
+        logger.info(`Getting property: ${name}`);
+        try {
+            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) {
+            logger.error('Failed to get property:', error);
+            throw error;
+        }
+    }
+    /**
+     * Set or create a system property
+     */
+    async setProperty(args) {
+        const { name, value, description, type = 'string', choices, is_private = false, suffix } = args;
+        logger.info(`Setting property: ${name} = ${value}`);
+        try {
+            // Check if property exists
+            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;
+                result = await this.client.updateRecord('sys_properties', sys_id, {
+                    value,
+                    ...(description && { description }),
+                    ...(type && { type }),
+                    ...(choices && { choices }),
+                    ...(suffix && { suffix }),
+                    is_private: is_private ? 'true' : 'false'
+                });
+                logger.info(`Updated property: ${name}`);
+            }
+            else {
+                // Create new property
+                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'
+                });
+                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) {
+            logger.error('Failed to set property:', error);
+            throw error;
+        }
+    }
+    /**
+     * List system properties
+     */
+    async listProperties(args) {
+        const { pattern, category, is_private, limit = 100, include_values = true } = args;
+        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 = {};
+            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) {
+            logger.error('Failed to list properties:', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete a system property
+     */
+    async deleteProperty(args) {
+        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!`
+                    }]
+            };
+        }
+        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) {
+            logger.error('Failed to delete property:', error);
+            throw error;
+        }
+    }
+    /**
+     * Search properties
+     */
+    async searchProperties(args) {
+        const { search_term, search_in = 'all', limit = 50 } = args;
+        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) {
+            logger.error('Search failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Bulk get properties
+     */
+    async bulkGetProperties(args) {
+        const { names, include_metadata = false } = args;
+        logger.info(`Bulk getting ${names.length} properties`);
+        const results = {};
+        const errors = [];
+        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) {
+                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
+     */
+    async bulkSetProperties(args) {
+        const { properties } = args;
+        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
+                    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) {
+                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
+     */
+    async exportProperties(args) {
+        const { pattern, include_system = false, include_private = false } = args;
+        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 = {};
+            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) {
+            logger.error('Export failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Import properties
+     */
+    async importProperties(args) {
+        const { properties, overwrite = false, dry_run = false } = args;
+        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.value,
+                        ...(propertyData.description && { description: propertyData.description }),
+                        ...(propertyData.type && { type: propertyData.type }),
+                        ...(propertyData.suffix && { suffix: propertyData.suffix }),
+                        ...(propertyData.choices && { choices: propertyData.choices }),
+                        ...(propertyData.is_private !== undefined && { is_private: propertyData.is_private ? 'true' : 'false' })
+                    });
+                    if (result.success) {
+                        results.updated.push(name);
+                    }
+                    else {
+                        results.failed.push(`${name}: ${result.error}`);
+                    }
+                }
+                else {
+                    // Create
+                    const result = await this.client.createRecord('sys_properties', {
+                        name,
+                        value: propertyData.value,
+                        description: propertyData.description || `Imported by Snow-Flow`,
+                        type: propertyData.type || 'string',
+                        suffix: propertyData.suffix || 'global',
+                        choices: propertyData.choices || '',
+                        is_private: propertyData.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) {
+                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
+     */
+    async validateProperty(args) {
+        const { name, value } = args;
+        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) => 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) {
+            logger.error('Validation failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get property categories
+     */
+    async getCategories(args) {
+        const { include_counts = true } = args;
+        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 = {};
+            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) {
+            logger.error('Failed to get categories:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get property audit history
+     */
+    async getPropertyHistory(args) {
+        const { name, limit = 10 } = args;
+        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) {
+            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 start() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        logger.info('ServiceNow System Properties MCP Server started');
+    }
+}
+exports.ServiceNowSystemPropertiesMCP = ServiceNowSystemPropertiesMCP;
+// Start the server
+const server = new ServiceNowSystemPropertiesMCP();
+server.start().catch((error) => {
+    console.error('Failed to start ServiceNow System Properties MCP:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=servicenow-system-properties-mcp.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.3.7",
-  "description": "Snow-Flow v3.3.7: PORTAL PAGE FIX - Fixed portal_page deployment field mapping! Now correctly maps id->page_id, handles sp_portal sys_id, and converts containers to widgets format. Fixed widget instance creation with proper sys_id handling. Portal pages with AI chatbots and complex widgets now deploy successfully. Improved validation messages and support for both single widgets and widget arrays. 180+ MCP tools across 17 specialized servers.",
+  "version": "3.3.8",
+  "description": "Snow-Flow v3.3.8: SYSTEM PROPERTIES MCP - Complete system property management via official ServiceNow APIs! 12 new tools: get, set, list, delete, search, bulk operations, import/export, validation, categories, and audit history. All using standard Table API on sys_properties - no hacks, 100% official! Manage configurations, feature flags, and system settings programmatically. Now 192+ MCP tools across 18 specialized servers.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {
@@ -27,6 +27,7 @@
     "mcp:clean": "node scripts/cleanup-mcp-servers.js && npm run build",
     "mcp:start": "node scripts/start-mcp-proper.js",
     "mcp:start-proper": "node scripts/start-mcp-proper.js",
+    "mcp:sysprops": "node scripts/start-sysprops-mcp.js",
     "test:integration": "npm run build && node dist/tests/integration-test.js",
     "postbuild-disabled": "npm run setup-mcp",
     "postinstall": "node scripts/postinstall.js",