snow-flow 4.6.9 → 5.0.1

package/dist/mcp/servicenow-mcp-unified/tools/workspace/snow_create_ux_page_macroponent.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * snow_create_ux_page_macroponent - Create page macroponent
+ *
+ * STEP 3: Create Page Macroponent Record (sys_ux_macroponent) -
+ * Defines the actual page content that will be displayed.
+ */
+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_ux_page_macroponent',
+    description: 'STEP 3: Create Page Macroponent Record (sys_ux_macroponent) - Defines the actual page content that will be displayed.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: {
+                type: 'string',
+                description: 'Page macroponent name (e.g., "My Home Page")'
+            },
+            root_component: {
+                type: 'string',
+                default: 'sn-canvas-panel',
+                description: 'Root component to render (default: sn-canvas-panel for simple pages)'
+            },
+            composition: {
+                type: 'object',
+                description: 'JSON layout configuration (default: simple single column)'
+            },
+            description: {
+                type: 'string',
+                description: 'Page macroponent description'
+            }
+        },
+        required: ['name']
+    }
+};
+async function execute(args, context) {
+    const { name, root_component = 'sn-canvas-panel', composition, description } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Default simple composition if not provided
+        const defaultComposition = {
+            layout: 'single-column',
+            components: []
+        };
+        // Create macroponent
+        const macroponentData = {
+            name,
+            root_component,
+            composition: JSON.stringify(composition || defaultComposition),
+            description: description || `Page macroponent: ${name}`,
+            active: true
+        };
+        const response = await client.post('/api/now/table/sys_ux_macroponent', macroponentData);
+        const macroponent = response.data.result;
+        return (0, error_handler_js_1.createSuccessResult)({
+            created: true,
+            macroponent_sys_id: macroponent.sys_id,
+            name: macroponent.name,
+            root_component: macroponent.root_component,
+            message: `Page Macroponent '${name}' created successfully`,
+            next_step: 'Create Page Registry (Step 4) using snow_create_ux_page_registry'
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_create_ux_page_macroponent.js.map

package/dist/mcp/servicenow-mcp-unified/tools/workspace/snow_create_ux_page_registry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_create_ux_page_registry - Create page registry
+ *
+ * STEP 4: Create Page Registry Record (sys_ux_page_registry) -
+ * Registers the page for use within the workspace configuration.
+ */
+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_ux_page_registry.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/workspace/snow_create_ux_page_registry.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * snow_create_ux_page_registry - Create page registry
+ *
+ * STEP 4: Create Page Registry Record (sys_ux_page_registry) -
+ * Registers the page for use within the workspace configuration.
+ */
+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_ux_page_registry',
+    description: 'STEP 4: Create Page Registry Record (sys_ux_page_registry) - Registers the page for use within the workspace configuration.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sys_name: {
+                type: 'string',
+                description: 'Unique technical name for the page (e.g., "my_home_page")'
+            },
+            app_config_sys_id: {
+                type: 'string',
+                description: 'App config sys_id from Step 2'
+            },
+            macroponent_sys_id: {
+                type: 'string',
+                description: 'Macroponent sys_id from Step 3'
+            },
+            description: {
+                type: 'string',
+                description: 'Page registry description'
+            }
+        },
+        required: ['sys_name', 'app_config_sys_id', 'macroponent_sys_id']
+    }
+};
+async function execute(args, context) {
+    const { sys_name, app_config_sys_id, macroponent_sys_id, description } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Validate app config exists
+        const appConfigCheck = await client.get(`/api/now/table/sys_ux_app_config/${app_config_sys_id}`);
+        if (!appConfigCheck.data.result) {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `App Config '${app_config_sys_id}' not found`, { details: { app_config_sys_id } });
+        }
+        // Validate macroponent exists
+        const macroponentCheck = await client.get(`/api/now/table/sys_ux_macroponent/${macroponent_sys_id}`);
+        if (!macroponentCheck.data.result) {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `Macroponent '${macroponent_sys_id}' not found`, { details: { macroponent_sys_id } });
+        }
+        // Create page registry
+        const registryData = {
+            sys_name,
+            app_config: app_config_sys_id,
+            macroponent: macroponent_sys_id,
+            description: description || `Page registry for ${sys_name}`,
+            active: true
+        };
+        const response = await client.post('/api/now/table/sys_ux_page_registry', registryData);
+        const registry = response.data.result;
+        return (0, error_handler_js_1.createSuccessResult)({
+            created: true,
+            registry_sys_id: registry.sys_id,
+            sys_name: registry.sys_name,
+            app_config_sys_id,
+            macroponent_sys_id,
+            message: `Page Registry '${sys_name}' created successfully`,
+            next_step: 'Create Route (Step 5) using snow_create_ux_app_route'
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_create_ux_page_registry.js.map

package/dist/mcp/servicenow-mcp-unified/tools/workspace/snow_discover_all_workspaces.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_discover_all_workspaces - Discover all workspaces
+ *
+ * Discover all workspaces (UX Experiences, Agent Workspaces, UI Builder pages)
+ * with comprehensive details and usage analytics.
+ */
+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_discover_all_workspaces.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/workspace/snow_discover_all_workspaces.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * snow_discover_all_workspaces - Discover all workspaces
+ *
+ * Discover all workspaces (UX Experiences, Agent Workspaces, UI Builder pages)
+ * with comprehensive details and usage analytics.
+ */
+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_discover_all_workspaces',
+    description: 'Discover all workspaces (UX Experiences, Agent Workspaces, UI Builder pages) with comprehensive details and usage analytics.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            include_ux_experiences: {
+                type: 'boolean',
+                default: true,
+                description: 'Include Now Experience Framework workspaces'
+            },
+            include_agent_workspaces: {
+                type: 'boolean',
+                default: true,
+                description: 'Include Configurable Agent Workspaces'
+            },
+            include_ui_builder: {
+                type: 'boolean',
+                default: true,
+                description: 'Include UI Builder pages'
+            },
+            active_only: {
+                type: 'boolean',
+                default: true,
+                description: 'Only show active workspaces'
+            }
+        }
+    }
+};
+async function execute(args, context) {
+    const { include_ux_experiences = true, include_agent_workspaces = true, include_ui_builder = true, active_only = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const discovery = {
+            ux_experiences: [],
+            agent_workspaces: [],
+            ui_builder_pages: [],
+            total_count: 0
+        };
+        // Discover UX Experiences
+        if (include_ux_experiences) {
+            const experiencesQuery = active_only ? 'active=true' : '';
+            const experiencesResponse = await client.get('/api/now/table/sys_ux_experience', {
+                params: {
+                    sysparm_query: experiencesQuery,
+                    sysparm_limit: 50,
+                    sysparm_fields: 'sys_id,name,description,active'
+                }
+            });
+            if (experiencesResponse.data.result) {
+                discovery.ux_experiences = experiencesResponse.data.result.map((exp) => ({
+                    type: 'UX Experience',
+                    name: exp.name,
+                    sys_id: exp.sys_id,
+                    description: exp.description || 'No description',
+                    active: exp.active,
+                    url: `/now/experience/${exp.name?.toLowerCase().replace(/\s+/g, '-')}`
+                }));
+            }
+        }
+        // Discover Agent Workspaces
+        if (include_agent_workspaces) {
+            const routesQuery = active_only ? 'active=true^route_type=workspace' : 'route_type=workspace';
+            const routesResponse = await client.get('/api/now/table/sys_ux_app_route', {
+                params: {
+                    sysparm_query: routesQuery,
+                    sysparm_limit: 50,
+                    sysparm_fields: 'sys_id,name,description,route,active'
+                }
+            });
+            if (routesResponse.data.result) {
+                discovery.agent_workspaces = routesResponse.data.result.map((route) => ({
+                    type: 'Agent Workspace',
+                    name: route.name,
+                    sys_id: route.sys_id,
+                    description: route.description || 'No description',
+                    route: route.route,
+                    active: route.active,
+                    url: `/now/workspace${route.route}`
+                }));
+            }
+        }
+        // Discover UI Builder Pages
+        if (include_ui_builder) {
+            const pagesQuery = active_only ? 'active=true' : '';
+            const pagesResponse = await client.get('/api/now/table/sys_ux_page', {
+                params: {
+                    sysparm_query: pagesQuery,
+                    sysparm_limit: 50,
+                    sysparm_fields: 'sys_id,name,description,active'
+                }
+            });
+            if (pagesResponse.data.result) {
+                discovery.ui_builder_pages = pagesResponse.data.result.map((page) => ({
+                    type: 'UI Builder Page',
+                    name: page.name,
+                    sys_id: page.sys_id,
+                    description: page.description || 'No description',
+                    active: page.active
+                }));
+            }
+        }
+        discovery.total_count = discovery.ux_experiences.length +
+            discovery.agent_workspaces.length +
+            discovery.ui_builder_pages.length;
+        return (0, error_handler_js_1.createSuccessResult)({
+            discovery,
+            summary: {
+                ux_experiences: discovery.ux_experiences.length,
+                agent_workspaces: discovery.agent_workspaces.length,
+                ui_builder_pages: discovery.ui_builder_pages.length,
+                total_workspaces: discovery.total_count
+            },
+            message: `Found ${discovery.total_count} workspaces across all types`
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_discover_all_workspaces.js.map

package/dist/mcp/servicenow-mcp-unified/tools/workspace/snow_update_ux_app_config_landing_page.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_update_ux_app_config_landing_page - Update landing page
+ *
+ * STEP 6: Update App Configuration with Landing Page Route -
+ * Sets the default landing page for the workspace.
+ */
+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_update_ux_app_config_landing_page.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/workspace/snow_update_ux_app_config_landing_page.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * snow_update_ux_app_config_landing_page - Update landing page
+ *
+ * STEP 6: Update App Configuration with Landing Page Route -
+ * Sets the default landing page for the workspace.
+ */
+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_update_ux_app_config_landing_page',
+    description: 'STEP 6: Update App Configuration with Landing Page Route - Sets the default landing page for the workspace.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            app_config_sys_id: {
+                type: 'string',
+                description: 'App config sys_id from Step 2'
+            },
+            route_name: {
+                type: 'string',
+                description: 'Route name from Step 5'
+            }
+        },
+        required: ['app_config_sys_id', 'route_name']
+    }
+};
+async function execute(args, context) {
+    const { app_config_sys_id, route_name } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Validate app config exists
+        const appConfigCheck = await client.get(`/api/now/table/sys_ux_app_config/${app_config_sys_id}`);
+        if (!appConfigCheck.data.result) {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `App Config '${app_config_sys_id}' not found`, { details: { app_config_sys_id } });
+        }
+        // Update app config with landing page route
+        const updateData = {
+            landing_page: route_name
+        };
+        const response = await client.patch(`/api/now/table/sys_ux_app_config/${app_config_sys_id}`, updateData);
+        const appConfig = response.data.result;
+        return (0, error_handler_js_1.createSuccessResult)({
+            updated: true,
+            app_config_sys_id: appConfig.sys_id,
+            landing_page: appConfig.landing_page,
+            message: `App Configuration landing page set to '${route_name}'`,
+            workspace_complete: true,
+            summary: 'All 6 steps completed! Your UX workspace is now fully configured and ready to use.'
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_update_ux_app_config_landing_page.js.map

package/dist/mcp/servicenow-mcp-unified/tools/workspace/snow_validate_workspace_configuration.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_validate_workspace_configuration - Validate workspace config
+ *
+ * Validate workspace configuration for completeness, best practices,
+ * and potential issues across all workspace types.
+ */
+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_validate_workspace_configuration.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/workspace/snow_validate_workspace_configuration.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * snow_validate_workspace_configuration - Validate workspace config
+ *
+ * Validate workspace configuration for completeness, best practices,
+ * and potential issues across all workspace types.
+ */
+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_validate_workspace_configuration',
+    description: 'Validate workspace configuration for completeness, best practices, and potential issues across all workspace types.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            workspace_sys_id: {
+                type: 'string',
+                description: 'Workspace sys_id to validate'
+            },
+            workspace_type: {
+                type: 'string',
+                enum: ['ux_experience', 'agent_workspace', 'ui_builder'],
+                description: 'Type of workspace to validate'
+            },
+            check_performance: {
+                type: 'boolean',
+                default: true,
+                description: 'Include performance analysis'
+            },
+            check_security: {
+                type: 'boolean',
+                default: true,
+                description: 'Include security validation'
+            }
+        },
+        required: ['workspace_sys_id', 'workspace_type']
+    }
+};
+async function execute(args, context) {
+    const { workspace_sys_id, workspace_type, check_performance = true, check_security = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const validation = {
+            workspace_sys_id,
+            workspace_type,
+            issues: [],
+            warnings: [],
+            recommendations: [],
+            score: 0,
+            max_score: 100
+        };
+        if (workspace_type === 'ux_experience') {
+            // Validate UX Experience workspace
+            const experienceResponse = await client.get(`/api/now/table/sys_ux_experience/${workspace_sys_id}`);
+            if (!experienceResponse.data.result) {
+                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `Experience '${workspace_sys_id}' not found`, { details: { workspace_sys_id } });
+            }
+            const expData = experienceResponse.data.result;
+            // Check if experience is active
+            if (!expData.active) {
+                validation.issues.push('Experience is not active');
+            }
+            else {
+                validation.score += 25;
+            }
+            // Check if it has app config
+            const appConfigResponse = await client.get('/api/now/table/sys_ux_app_config', {
+                params: {
+                    sysparm_query: `experience_assoc=${workspace_sys_id}`,
+                    sysparm_limit: 1
+                }
+            });
+            if (!appConfigResponse.data.result || appConfigResponse.data.result.length === 0) {
+                validation.issues.push('No app configuration found for experience');
+            }
+            else {
+                validation.score += 25;
+                // Check if app config has list configuration
+                const appConfig = appConfigResponse.data.result[0];
+                if (!appConfig.list_config_id) {
+                    validation.warnings.push('No list configuration linked to app config');
+                }
+                else {
+                    validation.score += 25;
+                }
+            }
+            // Check for page properties
+            const pagePropsResponse = await client.get('/api/now/table/sys_ux_page_property', {
+                params: {
+                    sysparm_query: `experience=${workspace_sys_id}`,
+                    sysparm_limit: 10
+                }
+            });
+            if (pagePropsResponse.data.result && pagePropsResponse.data.result.length > 0) {
+                validation.score += 25;
+            }
+            else {
+                validation.warnings.push('No page properties configured (chrome_tab, chrome_main)');
+            }
+        }
+        else if (workspace_type === 'agent_workspace') {
+            // Validate Agent Workspace
+            const routeResponse = await client.get(`/api/now/table/sys_ux_app_route/${workspace_sys_id}`);
+            if (!routeResponse.data.result) {
+                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `Agent Workspace route '${workspace_sys_id}' not found`, { details: { workspace_sys_id } });
+            }
+            const routeData = routeResponse.data.result;
+            // Check if route is active
+            if (!routeData.active) {
+                validation.issues.push('Workspace route is not active');
+            }
+            else {
+                validation.score += 30;
+            }
+            // Check for screen types
+            const screenTypesResponse = await client.get('/api/now/table/sys_ux_screen_type', {
+                params: {
+                    sysparm_query: `app_route=${workspace_sys_id}`,
+                    sysparm_limit: 10
+                }
+            });
+            if (screenTypesResponse.data.result && screenTypesResponse.data.result.length > 0) {
+                validation.score += 40;
+                if (screenTypesResponse.data.result.length === 1) {
+                    validation.warnings.push('Only one screen type configured - consider adding more for better functionality');
+                }
+            }
+            else {
+                validation.issues.push('No screen types configured for agent workspace');
+            }
+            // Check route format
+            if (!routeData.route || !routeData.route.startsWith('/')) {
+                validation.warnings.push('Route format should start with /');
+            }
+            else {
+                validation.score += 30;
+            }
+        }
+        else if (workspace_type === 'ui_builder') {
+            // Validate UI Builder page
+            const pageResponse = await client.get(`/api/now/table/sys_ux_page/${workspace_sys_id}`);
+            if (!pageResponse.data.result) {
+                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `UI Builder page '${workspace_sys_id}' not found`, { details: { workspace_sys_id } });
+            }
+            const pageData = pageResponse.data.result;
+            if (!pageData.active) {
+                validation.issues.push('UI Builder page is not active');
+            }
+            else {
+                validation.score += 50;
+            }
+            if (pageData.name && pageData.title) {
+                validation.score += 50;
+            }
+            else {
+                validation.warnings.push('Page should have both name and title configured');
+            }
+        }
+        // Performance recommendations
+        if (check_performance && validation.score > 50) {
+            validation.recommendations.push('Consider enabling caching for better performance');
+            validation.recommendations.push('Add loading indicators for better user experience');
+            validation.recommendations.push('Optimize queries to reduce page load time');
+        }
+        // Security recommendations
+        if (check_security) {
+            validation.recommendations.push('Review access controls and role requirements');
+            validation.recommendations.push('Validate data privacy settings for workspace');
+            validation.recommendations.push('Ensure sensitive data is properly masked');
+        }
+        // Overall status
+        let status = 'excellent';
+        if (validation.issues.length > 0) {
+            status = 'critical';
+        }
+        else if (validation.warnings.length > 2) {
+            status = 'needs_improvement';
+        }
+        else if (validation.score < 75) {
+            status = 'good';
+        }
+        return (0, error_handler_js_1.createSuccessResult)({
+            validation: {
+                ...validation,
+                status,
+                passed: validation.issues.length === 0
+            },
+            summary: {
+                score: `${validation.score}/${validation.max_score}`,
+                status,
+                issues_count: validation.issues.length,
+                warnings_count: validation.warnings.length,
+                recommendations_count: validation.recommendations.length
+            },
+            message: validation.issues.length === 0
+                ? `Workspace validation passed with score ${validation.score}/${validation.max_score}`
+                : `Workspace validation found ${validation.issues.length} critical issues`
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_validate_workspace_configuration.js.map