snow-flow 10.0.1-dev.424 → 10.0.1-dev.426

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-dev.424",
+  "version": "10.0.1-dev.426",
   "name": "snow-flow",
   "description": "Snow-Flow - ServiceNow Multi-Agent Development Framework powered by AI",
   "license": "Elastic-2.0",

package/src/project/agents-template.txt

@@ -135,6 +135,12 @@ await activity_start({
   updateSetUrl: "https://instance.service-now.com/sys_update_set.do?sys_id=abc123..."
 });
 
+await activity_update({
+  activityId: activityId,
+  status: "in_progress",  // or "review", "failed", "cancelled"
+  summary: "Progress update: completed widget creation, starting business rule"
+});
+
 await activity_add_artifact({
   activityId: activityId,
   artifactType: "widget",

package/src/servicenow/servicenow-mcp-unified/shared/tool-registry.ts

@@ -83,6 +83,7 @@ import * as platformTools from '../tools/platform/index.js';
 import * as devopsTools from '../tools/devops/index.js';
 import * as virtualAgentTools from '../tools/virtual-agent/index.js';
 import * as flowDesignerTools from '../tools/flow-designer/index.js';
+import * as pluginsTools from '../tools/plugins/index.js';
 
 // ES Module compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -150,6 +151,7 @@ const STATIC_TOOL_MODULES: Record<string, any> = {
   'devops': devopsTools,
   'virtual-agent': virtualAgentTools,
   'flow-designer': flowDesignerTools,
+  'plugins': pluginsTools,
 };
 
 export class ToolRegistry {

package/src/servicenow/servicenow-mcp-unified/tools/flow-designer/snow_manage_flow.ts

@@ -4,10 +4,10 @@
  * Create, list, get, update, activate, deactivate, delete and publish
  * Flow Designer flows and subflows.
  *
- * For create/create_subflow: uses a Scheduled Job (sysauto_script) that
- * runs GlideRecord server-side, ensuring sys_hub_flow_version records are
- * created, flow_definition is set, and sn_fd engine registration is
- * attempted. Falls back to Table API if the scheduled job fails.
+ * For create/create_subflow: uses the ProcessFlow REST API
+ * (/api/now/processflow/flow) — the same endpoint the Flow Designer UI
+ * uses. This creates engine-registered flows that can be opened in Flow
+ * Designer without "corrupted flow" errors. Falls back to Table API.
  *
  * All other actions (list, get, update, activate, etc.) use the Table API.
  */
@@ -36,6 +36,94 @@ function escForScript(s: string): string {
   return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n').replace(/\r/g, '');
 }
 
+/**
+ * Create a flow via the ProcessFlow REST API — the same endpoint the Flow Designer UI uses.
+ *
+ * Uses /api/now/processflow/flow to create engine-registered flows, then
+ * /api/now/processflow/versioning/create_version for versioning.
+ *
+ * This is the only method that produces flows openable in Flow Designer
+ * without "corrupted flow" errors, because it sets:
+ *   - flowEngineVersion
+ *   - label_cache / attributes
+ *   - flowCatalogVariableModelId
+ *   - proper internal_name
+ */
+async function createFlowViaProcessFlowAPI(
+  client: any,
+  params: {
+    name: string;
+    description: string;
+    isSubflow: boolean;
+    runAs: string;
+    shouldActivate: boolean;
+  }
+): Promise<{
+  success: boolean;
+  flowSysId?: string;
+  versionCreated?: boolean;
+  flowData?: any;
+  error?: string;
+}> {
+  try {
+    // Step 1: Create flow via ProcessFlow API (same as Flow Designer UI)
+    var flowResp = await client.post(
+      '/api/now/processflow/flow',
+      {
+        access: 'public',
+        description: params.description || '',
+        flowPriority: 'MEDIUM',
+        name: params.name,
+        protection: '',
+        runAs: params.runAs || 'user',
+        runWithRoles: { value: '', displayValue: '' },
+        scope: 'global',
+        scopeDisplayName: '',
+        scopeName: '',
+        security: { can_read: true, can_write: true },
+        status: 'draft',
+        type: params.isSubflow ? 'subflow' : 'flow',
+        userHasRolesAssignedToFlow: true,
+        active: false,
+        deleted: false
+      },
+      {
+        params: {
+          param_only_properties: 'true',
+          sysparm_transaction_scope: 'global'
+        }
+      }
+    );
+
+    var flowResult = flowResp.data?.result?.data;
+    if (!flowResult?.id) {
+      var errDetail = flowResp.data?.result?.errorMessage || 'no flow id returned';
+      return { success: false, error: 'ProcessFlow API: ' + errDetail };
+    }
+
+    var flowSysId = flowResult.id;
+
+    // Step 2: Create version via ProcessFlow versioning API
+    var versionCreated = false;
+    try {
+      await client.post(
+        '/api/now/processflow/versioning/create_version',
+        { item_sys_id: flowSysId, type: 'Autosave', annotation: '', favorite: false },
+        { params: { sysparm_transaction_scope: 'global' } }
+      );
+      versionCreated = true;
+    } catch (_) {
+      // Non-fatal: flow was created, version creation is best-effort
+    }
+
+    return { success: true, flowSysId, versionCreated, flowData: flowResult };
+  } catch (e: any) {
+    var msg = e.message || '';
+    try { msg += ' — ' + JSON.stringify(e.response?.data || '').substring(0, 200); } catch (_) {}
+    return { success: false, error: 'ProcessFlow API: ' + msg };
+  }
+}
+
 /**
  * Create a flow via a ServiceNow Scheduled Job (sysauto_script).
  *
@@ -1405,7 +1493,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
     switch (action) {
 
       // ────────────────────────────────────────────────────────────────
-      // CREATE  (Scripted REST API → Table API fallback)
+      // CREATE  (ProcessFlow API → Table API fallback)
       // ────────────────────────────────────────────────────────────────
       case 'create':
       case 'create_subflow': {
@@ -1468,7 +1556,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           delete flowDefinition.trigger;
         }
 
-        // ── Pipeline: Scheduled Job (primary) → Table API (fallback) ──
+        // ── Pipeline: ProcessFlow API (primary) → Table API (fallback) ──
         var flowSysId: string | null = null;
         var usedMethod = 'table_api';
         var versionCreated = false;
@@ -1477,82 +1565,119 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         var actionsCreated = 0;
         var varsCreated = 0;
 
-        // Diagnostics: track every step for debugging "flow cannot be found" issues
+        // Diagnostics
         var diagnostics: any = {
+          processflow_api: null,
           table_api_used: false,
           version_created: false,
           version_method: null,
           post_verify: null
         };
 
-        // ── Scheduled Job (primary — server-side GlideRecord) ───────
-        // This runs inside ServiceNow as a system job, so it CAN set
-        // computed fields like latest_version that Table API cannot.
-        // Also attempts sn_fd engine registration server-side.
+        // ── ProcessFlow API (primary — same REST endpoint as Flow Designer UI) ──
+        // Uses /api/now/processflow/flow to create engine-registered flows,
+        // then /api/now/processflow/versioning/create_version for versioning.
         try {
-          var scheduledResult = await createFlowViaScheduledJob(client, {
+          var pfResult = await createFlowViaProcessFlowAPI(client, {
             name: flowName,
             description: flowDescription,
-            internalName: sanitizeInternalName(flowName),
             isSubflow: isSubflow,
-            category: flowCategory,
             runAs: flowRunAs,
-            shouldActivate: shouldActivate,
-            triggerType: triggerType,
-            triggerTable: flowTable,
-            triggerCondition: triggerCondition,
-            activities: activitiesArg.map(function (act: any, idx: number) {
-              return { name: act.name, type: act.type || 'script', inputs: act.inputs || {} };
-            }),
-            inputs: inputsArg,
-            outputs: outputsArg,
-            flowDefinition: flowDefinition
+            shouldActivate: shouldActivate
           });
-          diagnostics.scheduled_job = {
-            success: scheduledResult.success,
-            tierUsed: scheduledResult.tierUsed,
-            latestVersionSet: scheduledResult.latestVersionSet,
-            latestVersionValue: scheduledResult.latestVersionValue,
-            steps: scheduledResult.steps,
-            error: scheduledResult.error
+          diagnostics.processflow_api = {
+            success: pfResult.success,
+            versionCreated: pfResult.versionCreated,
+            error: pfResult.error
           };
-          if (scheduledResult.success && scheduledResult.flowSysId) {
-            flowSysId = scheduledResult.flowSysId;
-            usedMethod = 'scheduled_job (' + (scheduledResult.tierUsed || 'unknown') + ')';
-            versionCreated = !!scheduledResult.versionSysId;
+          if (pfResult.success && pfResult.flowSysId) {
+            flowSysId = pfResult.flowSysId;
+            usedMethod = 'processflow_api';
+            versionCreated = !!pfResult.versionCreated;
             diagnostics.version_created = versionCreated;
-            diagnostics.version_method = 'scheduled_job';
-            diagnostics.latest_version_auto_set = scheduledResult.latestVersionSet;
-            // Extract engine registration results from scheduled job
-            if (scheduledResult.steps?.engine) {
-              diagnostics.engine_registration = scheduledResult.steps.engine;
-            }
-            // Extract trigger/action/variable results from scheduled job
-            if (scheduledResult.steps?.trigger) {
-              triggerCreated = !!scheduledResult.steps.trigger.success;
-              if (!scheduledResult.steps.trigger.success && scheduledResult.steps.trigger.error) {
-                factoryWarnings.push('Trigger: ' + scheduledResult.steps.trigger.error);
+            diagnostics.version_method = 'processflow_api';
+          }
+        } catch (pfErr: any) {
+          diagnostics.processflow_api = { error: pfErr.message || 'unknown' };
+          factoryWarnings.push('ProcessFlow API failed: ' + (pfErr.message || pfErr));
+        }
+
+        // ── Triggers, actions, variables for ProcessFlow-created flows ──
+        // ProcessFlow API creates empty flows; add components via Table API
+        if (flowSysId && usedMethod === 'processflow_api') {
+          if (!isSubflow && triggerType !== 'manual') {
+            try {
+              var pfTrigDefId: string | null = null;
+              var pfExactNames: Record<string, string[]> = {
+                'record_created': ['sn_fd.trigger.record_created', 'global.sn_fd.trigger.record_created'],
+                'record_updated': ['sn_fd.trigger.record_updated', 'global.sn_fd.trigger.record_updated'],
+                'scheduled': ['sn_fd.trigger.scheduled', 'global.sn_fd.trigger.scheduled']
+              };
+              var pfCands = pfExactNames[triggerType] || [];
+              for (var pfi = 0; pfi < pfCands.length && !pfTrigDefId; pfi++) {
+                var pfExResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+                  params: { sysparm_query: 'internal_name=' + pfCands[pfi], sysparm_fields: 'sys_id', sysparm_limit: 1 }
+                });
+                pfTrigDefId = pfExResp.data.result?.[0]?.sys_id || null;
               }
+              if (!pfTrigDefId) {
+                var pfPfxResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+                  params: { sysparm_query: 'internal_nameSTARTSWITHsn_fd.trigger', sysparm_fields: 'sys_id,internal_name', sysparm_limit: 10 }
+                });
+                var pfPfxResults = pfPfxResp.data.result || [];
+                for (var pfpi = 0; pfpi < pfPfxResults.length && !pfTrigDefId; pfpi++) {
+                  if ((pfPfxResults[pfpi].internal_name || '').indexOf(triggerType.replace('record_', '')) > -1) {
+                    pfTrigDefId = pfPfxResults[pfpi].sys_id;
+                  }
+                }
+              }
+              var pfTrigData: any = { flow: flowSysId, name: triggerType, order: 0, active: true };
+              if (pfTrigDefId) pfTrigData.action_type = pfTrigDefId;
+              if (flowTable) pfTrigData.table = flowTable;
+              if (triggerCondition) pfTrigData.condition = triggerCondition;
+              await client.post('/api/now/table/sys_hub_trigger_instance', pfTrigData);
+              triggerCreated = true;
+            } catch (_) { /* best-effort */ }
+          }
+          for (var pfai = 0; pfai < activitiesArg.length; pfai++) {
+            try {
+              var pfAct = activitiesArg[pfai];
+              var pfActQ = 'internal_nameLIKE' + (pfAct.type || 'script') + '^ORnameLIKE' + (pfAct.type || 'script');
+              var pfActDefResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+                params: { sysparm_query: pfActQ, sysparm_fields: 'sys_id', sysparm_limit: 1 }
+              });
+              var pfActDef = pfActDefResp.data.result?.[0]?.sys_id;
+              var pfInstData: any = { flow: flowSysId, name: pfAct.name, order: (pfai + 1) * 100, active: true };
+              if (pfActDef) pfInstData.action_type = pfActDef;
+              await client.post('/api/now/table/sys_hub_action_instance', pfInstData);
+              actionsCreated++;
+            } catch (_) { /* best-effort */ }
+          }
+          if (isSubflow) {
+            for (var pfvi = 0; pfvi < inputsArg.length; pfvi++) {
+              try {
+                var pfInp = inputsArg[pfvi];
+                await client.post('/api/now/table/sys_hub_flow_variable', {
+                  flow: flowSysId, name: pfInp.name, label: pfInp.label || pfInp.name,
+                  type: pfInp.type || 'string', mandatory: pfInp.mandatory || false,
+                  default_value: pfInp.default_value || '', variable_type: 'input'
+                });
+                varsCreated++;
+              } catch (_) {}
             }
-            if (scheduledResult.steps?.actions) {
-              actionsCreated = scheduledResult.steps.actions.created || 0;
-            }
-            if (scheduledResult.steps?.variables) {
-              varsCreated = scheduledResult.steps.variables.created || 0;
+            for (var pfvo = 0; pfvo < outputsArg.length; pfvo++) {
+              try {
+                var pfOut = outputsArg[pfvo];
+                await client.post('/api/now/table/sys_hub_flow_variable', {
+                  flow: flowSysId, name: pfOut.name, label: pfOut.label || pfOut.name,
+                  type: pfOut.type || 'string', variable_type: 'output'
+                });
+                varsCreated++;
+              } catch (_) {}
             }
           }
-        } catch (schedErr: any) {
-          diagnostics.scheduled_job = { error: schedErr.message || 'unknown' };
-          factoryWarnings.push('Scheduled job failed: ' + (schedErr.message || schedErr));
         }
 
-        // BR compile + engine REST registration skipped:
-        // - BR: FlowDesigner unavailable in all contexts, FlowAPI.compile returns error,
-        //   all Script Includes (FlowDesignerScriptable etc.) don't exist on PDI instances
-        // - REST: all sn_fd endpoints return 400 "Requested URI does not represent any resource"
-        // Both add ~20s combined and provide zero value. Flow records are functional
-        // (listable, queryable, deletable) but cannot be opened in Flow Designer UI.
-
         // ── Table API fallback (last resort) ─────────────────────────
         if (!flowSysId) {
           diagnostics.table_api_used = true;
@@ -1815,11 +1940,9 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         }
 
         // ── Build summary ───────────────────────────────────────────
-        var methodLabel = usedMethod.startsWith('scheduled_job')
-          ? 'Scheduled Job (server-side GlideRecord)'
-          : usedMethod === 'scripted_rest_api'
-            ? 'Scripted REST API (GlideRecord)'
-            : 'Table API' + (factoryWarnings.length > 0 ? ' (fallback)' : '');
+        var methodLabel = usedMethod === 'processflow_api'
+          ? 'ProcessFlow API (Flow Designer engine)'
+          : 'Table API' + (factoryWarnings.length > 0 ? ' (fallback)' : '');
 
         var createSummary = summary()
           .success('Created ' + (isSubflow ? 'subflow' : 'flow') + ': ' + flowName)
@@ -1855,17 +1978,13 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
 
         // Diagnostics section
         createSummary.blank().line('Diagnostics:');
-        if (diagnostics.scheduled_job) {
-          var sj = diagnostics.scheduled_job;
-          createSummary.indented('Scheduled job: ' + (sj.success ? 'success' : 'failed') + (sj.tierUsed ? ' (' + sj.tierUsed + ')' : ''));
-          if (sj.error) createSummary.indented('  Error: ' + sj.error);
+        if (diagnostics.processflow_api) {
+          var pf = diagnostics.processflow_api;
+          createSummary.indented('ProcessFlow API: ' + (pf.success ? 'success' : 'failed') + (pf.versionCreated ? ' (version created)' : ''));
+          if (pf.error) createSummary.indented('  Error: ' + pf.error);
         }
-        createSummary.indented('Table API used: ' + diagnostics.table_api_used);
+        createSummary.indented('Table API fallback used: ' + diagnostics.table_api_used);
         createSummary.indented('Version created: ' + diagnostics.version_created + (diagnostics.version_method ? ' (' + diagnostics.version_method + ')' : ''));
-        createSummary.indented('Engine compile: skipped (not available on this instance — FlowDesigner unavailable, REST 400s, no Script Includes)');
-        if (diagnostics.latest_version_auto_set !== undefined) {
-          createSummary.indented('latest_version: ' + (diagnostics.latest_version_auto_set ? 'set' : 'null'));
-        }
         if (diagnostics.post_verify) {
           if (diagnostics.post_verify.error) {
             createSummary.indented('Post-verify: error — ' + diagnostics.post_verify.error);
@@ -2251,5 +2370,5 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
   }
 }
 
-export const version = '5.0.0';
+export const version = '6.0.0';
 export const author = 'Snow-Flow Team';

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

@@ -166,7 +166,7 @@ export * from './mappers/index.js';
 // Decoders (1 tool)
 export * from './decoders/index.js';
 
-// Plugins (3 tools)
+// Plugins (1 tool - unified plugin management)
 export * from './plugins/index.js';
 
 // Addons (3 tools)

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

@@ -1,3 +1 @@
-export { toolDefinition as snow_custom_plugin_def, execute as snow_custom_plugin_exec } from './snow_custom_plugin.js';
-export { toolDefinition as snow_activate_plugin_def, execute as snow_activate_plugin_exec } from './snow_activate_plugin.js';
-export { toolDefinition as snow_list_plugins_def, execute as snow_list_plugins_exec } from './snow_list_plugins.js';
+export { toolDefinition as snow_plugin_manage_def, execute as snow_plugin_manage_exec } from './snow_plugin_manage.js'

package/src/servicenow/servicenow-mcp-unified/tools/plugins/snow_plugin_manage.ts

@@ -0,0 +1,295 @@
+/**
+ * snow_plugin_manage - Unified Plugin Management
+ *
+ * Single tool for all ServiceNow plugin operations:
+ * list, check, activate, deactivate.
+ */
+
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js'
+import { getAuthenticatedClient } from '../../shared/auth.js'
+import { createSuccessResult, createErrorResult } from '../../shared/error-handler.js'
+
+export const toolDefinition: MCPToolDefinition = {
+  name: 'snow_plugin_manage',
+  description: `Manage ServiceNow plugins: list, check status, activate, or deactivate.
+
+Actions:
+• list — Search and list plugins. Filter by name/ID, show only active.
+• check — Get detailed info on a specific plugin (status, version, dependencies).
+• activate — Activate a plugin (admin only). Uses CICD API with table fallback.
+• deactivate — Deactivate a plugin (admin only). Uses CICD API with table fallback.
+
+Examples:
+• { action: "list", search: "incident" }
+• { action: "check", plugin_id: "com.snc.incident" }
+• { action: "activate", plugin_id: "com.snc.incident" }`,
+  category: 'advanced',
+  subcategory: 'administration',
+  use_cases: ['plugin-discovery', 'plugin-management', 'plugin-status', 'activation', 'deactivation'],
+  complexity: 'intermediate',
+  frequency: 'low',
+  permission: 'write',
+  allowedRoles: ['developer', 'admin'],
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Operation to perform',
+        enum: ['list', 'check', 'activate', 'deactivate'],
+      },
+      plugin_id: {
+        type: 'string',
+        description: '[check/activate/deactivate] Plugin identifier (e.g. "com.snc.incident") or sys_id',
+      },
+      search: {
+        type: 'string',
+        description: '[list] Filter by plugin name or ID (e.g. "incident", "com.snc")',
+      },
+      active_only: {
+        type: 'boolean',
+        description: '[list] Only show active plugins',
+        default: false,
+      },
+      limit: {
+        type: 'number',
+        description: '[list] Max results to return (default 50)',
+        default: 50,
+      },
+    },
+    required: ['action'],
+  },
+}
+
+export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
+  const { action } = args
+  try {
+    switch (action) {
+      case 'list':
+        return await executeList(args, context)
+      case 'check':
+        return await executeCheck(args, context)
+      case 'activate':
+        return await executeActivate(args, context)
+      case 'deactivate':
+        return await executeDeactivate(args, context)
+      default:
+        return createErrorResult(
+          'Unknown action: ' + action + '. Valid actions: list, check, activate, deactivate'
+        )
+    }
+  } catch (error: any) {
+    return createErrorResult(error.message)
+  }
+}
+
+// ==================== LIST ====================
+async function executeList(args: any, context: ServiceNowContext): Promise<ToolResult> {
+  const { search, active_only = false, limit = 50 } = args
+  const client = await getAuthenticatedClient(context)
+
+  const queryParts: string[] = []
+  if (search) {
+    queryParts.push('nameLIKE' + search + '^ORidLIKE' + search)
+  }
+  if (active_only) {
+    queryParts.push('active=true')
+  }
+
+  const response = await client.get('/api/now/table/v_plugin', {
+    params: {
+      sysparm_query: queryParts.join('^'),
+      sysparm_fields: 'sys_id,id,name,active,version,description',
+      sysparm_limit: limit,
+      sysparm_display_value: 'true',
+    },
+  })
+
+  const plugins = response.data.result || []
+  const activeCount = plugins.filter((p: any) => p.active === 'true' || p.active === true).length
+  const inactiveCount = plugins.length - activeCount
+
+  const summary =
+    'Found ' +
+    plugins.length +
+    ' plugin(s)' +
+    (search ? ' matching "' + search + '"' : '') +
+    '. Active: ' +
+    activeCount +
+    ', Inactive: ' +
+    inactiveCount +
+    '.'
+
+  return createSuccessResult(
+    { action: 'list', plugins, count: plugins.length },
+    { active_count: activeCount, inactive_count: inactiveCount },
+    summary
+  )
+}
+
+// ==================== CHECK ====================
+async function executeCheck(args: any, context: ServiceNowContext): Promise<ToolResult> {
+  const { plugin_id } = args
+  if (!plugin_id) return createErrorResult('plugin_id is required for check action')
+
+  const client = await getAuthenticatedClient(context)
+
+  const response = await client.get('/api/now/table/v_plugin', {
+    params: {
+      sysparm_query: 'id=' + plugin_id + '^ORsys_id=' + plugin_id,
+      sysparm_fields: 'sys_id,id,name,active,version,description,parent,optional,licensable',
+      sysparm_limit: 1,
+      sysparm_display_value: 'true',
+    },
+  })
+
+  const results = response.data.result || []
+  if (results.length === 0) {
+    return createErrorResult('Plugin not found: ' + plugin_id)
+  }
+
+  const plugin = results[0]
+  const active = plugin.active === 'true' || plugin.active === true
+  const summary =
+    'Plugin "' +
+    plugin.name +
+    '" (' +
+    plugin.id +
+    ') is ' +
+    (active ? 'ACTIVE' : 'INACTIVE') +
+    '. Version: ' +
+    (plugin.version || 'unknown') +
+    '.'
+
+  return createSuccessResult(
+    { action: 'check', plugin },
+    { status: active ? 'active' : 'inactive' },
+    summary
+  )
+}
+
+// ==================== ACTIVATE ====================
+async function executeActivate(args: any, context: ServiceNowContext): Promise<ToolResult> {
+  const { plugin_id } = args
+  if (!plugin_id) return createErrorResult('plugin_id is required for activate action')
+
+  const client = await getAuthenticatedClient(context)
+  const plugin = await lookupPlugin(client, plugin_id)
+  if (!plugin) return createErrorResult('Plugin not found: ' + plugin_id)
+
+  if (plugin.active === 'true' || plugin.active === true) {
+    return createSuccessResult(
+      { action: 'activate', plugin, activated: false, already_active: true },
+      {},
+      'Plugin "' + plugin.name + '" (' + plugin.id + ') is already active.'
+    )
+  }
+
+  const { success, method, error } = await togglePlugin(client, plugin, 'activate')
+  if (!success) return createErrorResult(error!)
+
+  const verified = await verifyPluginState(client, plugin.sys_id, true)
+  const summary = verified
+    ? 'Plugin "' + plugin.name + '" (' + plugin.id + ') activated successfully via ' + method + '.'
+    : 'Activation request sent for "' + plugin.name + '" via ' + method + '. May take a moment to fully activate.'
+
+  return createSuccessResult({ action: 'activate', plugin, activated: true, verified, method }, {}, summary)
+}
+
+// ==================== DEACTIVATE ====================
+async function executeDeactivate(args: any, context: ServiceNowContext): Promise<ToolResult> {
+  const { plugin_id } = args
+  if (!plugin_id) return createErrorResult('plugin_id is required for deactivate action')
+
+  const client = await getAuthenticatedClient(context)
+  const plugin = await lookupPlugin(client, plugin_id)
+  if (!plugin) return createErrorResult('Plugin not found: ' + plugin_id)
+
+  if (plugin.active !== 'true' && plugin.active !== true) {
+    return createSuccessResult(
+      { action: 'deactivate', plugin, deactivated: false, already_inactive: true },
+      {},
+      'Plugin "' + plugin.name + '" (' + plugin.id + ') is already inactive.'
+    )
+  }
+
+  const { success, method, error } = await togglePlugin(client, plugin, 'deactivate')
+  if (!success) return createErrorResult(error!)
+
+  const verified = await verifyPluginState(client, plugin.sys_id, false)
+  const summary = verified
+    ? 'Plugin "' + plugin.name + '" (' + plugin.id + ') deactivated successfully via ' + method + '.'
+    : 'Deactivation request sent for "' + plugin.name + '" via ' + method + '. May take a moment to fully deactivate.'
+
+  return createSuccessResult({ action: 'deactivate', plugin, deactivated: true, verified, method }, {}, summary)
+}
+
+// ==================== HELPERS ====================
+
+async function lookupPlugin(client: any, pluginId: string): Promise<any | null> {
+  const response = await client.get('/api/now/table/v_plugin', {
+    params: {
+      sysparm_query: 'id=' + pluginId + '^ORsys_id=' + pluginId,
+      sysparm_fields: 'sys_id,id,name,active',
+      sysparm_limit: 1,
+    },
+  })
+  const results = response.data.result || []
+  return results.length > 0 ? results[0] : null
+}
+
+async function togglePlugin(
+  client: any,
+  plugin: any,
+  operation: 'activate' | 'deactivate'
+): Promise<{ success: boolean; method: string; error?: string }> {
+  // Try CICD Plugin API first
+  try {
+    await client.post('/api/sn_cicd/plugin/' + encodeURIComponent(plugin.id) + '/' + operation)
+    return { success: true, method: 'cicd_api' }
+  } catch (cicdError: any) {
+    const status = cicdError.response ? cicdError.response.status : 0
+    if (status === 404 || status === 400) {
+      // Fallback to sys_plugins PATCH
+      try {
+        const activeValue = operation === 'activate' ? 'true' : 'false'
+        await client.patch('/api/now/table/sys_plugins/' + plugin.sys_id, { active: activeValue })
+        return { success: true, method: 'table_api' }
+      } catch (patchError: any) {
+        return {
+          success: false,
+          method: '',
+          error:
+            'Failed to ' +
+            operation +
+            ' plugin via both CICD API and Table API. CICD: ' +
+            (cicdError.message || 'unknown') +
+            '. Table API: ' +
+            (patchError.message || 'unknown'),
+        }
+      }
+    }
+    return { success: false, method: '', error: 'CICD Plugin API error: ' + (cicdError.message || 'unknown') }
+  }
+}
+
+async function verifyPluginState(client: any, sysId: string, expectActive: boolean): Promise<boolean> {
+  try {
+    const response = await client.get('/api/now/table/v_plugin', {
+      params: {
+        sysparm_query: 'sys_id=' + sysId,
+        sysparm_fields: 'active',
+        sysparm_limit: 1,
+      },
+    })
+    const results = response.data.result || []
+    if (results.length === 0) return false
+    const isActive = results[0].active === 'true' || results[0].active === true
+    return expectActive ? isActive : !isActive
+  } catch {
+    return false
+  }
+}
+
+export const version = '1.0.0'
+export const author = 'Snow-Flow'

package/src/servicenow/servicenow-mcp-unified/tools/plugins/snow_activate_plugin.ts

@@ -1,47 +0,0 @@
-/**
- * snow_activate_plugin
- */
-
-import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
-import { getAuthenticatedClient } from '../../shared/auth.js';
-import { createSuccessResult, createErrorResult } from '../../shared/error-handler.js';
-
-export const toolDefinition: MCPToolDefinition = {
-  name: 'snow_activate_plugin',
-  description: 'Activate ServiceNow plugin',
-  // Metadata for tool discovery (not sent to LLM)
-  category: 'advanced',
-  subcategory: 'administration',
-  use_cases: ['plugin-management', 'activation', 'configuration'],
-  complexity: 'intermediate',
-  frequency: 'low',
-
-  // Permission enforcement
-  // Classification: WRITE - Write operation based on name pattern
-  permission: 'write',
-  allowedRoles: ['developer', 'admin'],
-  inputSchema: {
-    type: 'object',
-    properties: {
-      plugin_id: { type: 'string', description: 'Plugin ID' }
-    },
-    required: ['plugin_id']
-  }
-};
-
-export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
-  const { plugin_id } = args;
-  try {
-    const client = await getAuthenticatedClient(context);
-    const response = await client.post('/api/now/table/v_plugin', {
-      id: plugin_id,
-      active: true
-    });
-    return createSuccessResult({ activated: true, plugin: response.data.result });
-  } catch (error: any) {
-    return createErrorResult(error.message);
-  }
-}
-
-export const version = '1.0.0';
-export const author = 'Snow-Flow SDK Migration';

package/src/servicenow/servicenow-mcp-unified/tools/plugins/snow_custom_plugin.ts

@@ -1,46 +0,0 @@
-/**
- * snow_custom_plugin
- */
-
-import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
-import { createSuccessResult, createErrorResult } from '../../shared/error-handler.js';
-
-export const toolDefinition: MCPToolDefinition = {
-  name: 'snow_custom_plugin',
-  description: 'Execute custom plugin logic',
-  // Metadata for tool discovery (not sent to LLM)
-  category: 'advanced',
-  subcategory: 'administration',
-  use_cases: ['plugin-customization', 'extensions', 'custom-logic'],
-  complexity: 'advanced',
-  frequency: 'low',
-
-  // Permission enforcement
-  // Classification: WRITE - Plugin function - executes custom plugin which can modify data
-  permission: 'write',
-  allowedRoles: ['developer', 'admin'],
-  inputSchema: {
-    type: 'object',
-    properties: {
-      plugin_name: { type: 'string', description: 'Plugin name' },
-      parameters: { type: 'object', description: 'Plugin parameters' }
-    },
-    required: ['plugin_name']
-  }
-};
-
-export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
-  const { plugin_name, parameters = {} } = args;
-  try {
-    return createSuccessResult({
-      executed: true,
-      plugin_name,
-      parameters
-    });
-  } catch (error: any) {
-    return createErrorResult(error.message);
-  }
-}
-
-export const version = '1.0.0';
-export const author = 'Snow-Flow SDK Migration';

package/src/servicenow/servicenow-mcp-unified/tools/plugins/snow_list_plugins.ts

@@ -1,52 +0,0 @@
-/**
- * snow_list_plugins
- */
-
-import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
-import { getAuthenticatedClient } from '../../shared/auth.js';
-import { createSuccessResult, createErrorResult } from '../../shared/error-handler.js';
-
-export const toolDefinition: MCPToolDefinition = {
-  name: 'snow_list_plugins',
-  description: 'List installed plugins',
-  // Metadata for tool discovery (not sent to LLM)
-  category: 'advanced',
-  subcategory: 'administration',
-  use_cases: ['plugin-discovery', 'plugin-management', 'administration'],
-  complexity: 'beginner',
-  frequency: 'low',
-
-  // Permission enforcement
-  // Classification: READ - Read-only operation based on name pattern
-  permission: 'read',
-  allowedRoles: ['developer', 'stakeholder', 'admin'],
-  inputSchema: {
-    type: 'object',
-    properties: {
-      active_only: { type: 'boolean', default: false }
-    }
-  }
-};
-
-export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
-  const { active_only = false } = args;
-  try {
-    const client = await getAuthenticatedClient(context);
-    const query = active_only ? 'active=true' : '';
-    const response = await client.get('/api/now/table/v_plugin', {
-      params: {
-        sysparm_query: query,
-        sysparm_limit: 100
-      }
-    });
-    return createSuccessResult({
-      plugins: response.data.result,
-      count: response.data.result.length
-    });
-  } catch (error: any) {
-    return createErrorResult(error.message);
-  }
-}
-
-export const version = '1.0.0';
-export const author = 'Snow-Flow SDK Migration';