snow-flow 10.0.21 → 10.0.23

package/package.json

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

package/src/cli/cmd/tui/component/dialog-auth.tsx

@@ -1284,6 +1284,7 @@ function DialogAuthEnterpriseCombined() {
     | "code"
     | "verifying-enterprise"
     | "checking-portal-sn"
+    | "select-sn-instance"
     | "sn-method"
     | "sn-instance"
     | "sn-oauth-clientid"
@@ -1309,6 +1310,18 @@ function DialogAuthEnterpriseCombined() {
     clientSecret?: string
   } | null>(null)
 
+  // ServiceNow instances from enterprise portal (for multi-instance selection)
+  const [snInstances, setSnInstances] = createSignal<
+    Array<{
+      id: number
+      instanceName: string
+      instanceUrl: string
+      environmentType: string
+      isDefault: boolean
+      enabled: boolean
+    }>
+  >([])
+
   // ServiceNow state
   const [snMethod, setSnMethod] = createSignal<"oauth" | "basic">("oauth")
   const [snInstance, setSnInstance] = createSignal("")
@@ -1369,6 +1382,9 @@ function DialogAuthEnterpriseCombined() {
         setSessionId("")
         setAuthCode("")
         setTimeout(() => subdomainInput?.focus(), 10)
+      } else if (currentStep === "select-sn-instance") {
+        // Can't re-do enterprise auth, go back to main auth menu
+        dialog.replace(() => <DialogAuth />)
       } else if (currentStep === "sn-method") {
         // Can't go back to enterprise flow, go to main menu
         dialog.replace(() => <DialogAuth />)
@@ -1520,28 +1536,42 @@ function DialogAuthEnterpriseCombined() {
         duration: 3000,
       })
 
-      // Check if enterprise portal has ServiceNow credentials
+      // Check if enterprise portal has ServiceNow instances
       setStep("checking-portal-sn")
-      const portalCreds = await fetchPortalSnCredentials(portalUrl, data.token)
+      const instances = await fetchPortalSnInstances(portalUrl, data.token)
 
-      if (portalCreds) {
-        // Portal has ServiceNow credentials - use them directly
-        setPortalSnCredentials(portalCreds)
+      if (instances.length === 0) {
+        // No instances — manual setup
+        toast.show({
+          variant: "info",
+          message: "No ServiceNow instances found on portal. Please configure manually.",
+          duration: 3000,
+        })
+        setStep("sn-method")
+      } else if (instances.length === 1) {
+        // Single instance — fetch creds and proceed
         toast.show({
           variant: "info",
-          message: "ServiceNow credentials found in enterprise portal!",
+          message: `ServiceNow instance found: ${instances[0].instanceName}`,
           duration: 3000,
         })
-        // Skip manual ServiceNow input, go directly to completing
-        await startBothMcpServersWithPortalCreds(portalUrl, data.token, portalCreds, data.user)
+        const creds = await fetchPortalSnInstanceById(portalUrl, data.token, instances[0].id)
+        if (creds) {
+          setPortalSnCredentials(creds)
+          await startBothMcpServersWithPortalCreds(portalUrl, data.token, creds, data.user)
+        } else {
+          toast.show({ variant: "error", message: "Failed to fetch instance credentials.", duration: 3000 })
+          setStep("sn-method")
+        }
       } else {
-        // No ServiceNow credentials on portal - ask user to input manually
+        // Multiple instances — show selection
+        setSnInstances(instances)
         toast.show({
           variant: "info",
-          message: "No ServiceNow credentials found on portal. Please configure manually.",
+          message: `${instances.length} ServiceNow instances found. Please select one.`,
           duration: 3000,
         })
-        setStep("sn-method")
+        setStep("select-sn-instance")
       }
     } catch (e) {
       toast.show({ variant: "error", message: e instanceof Error ? e.message : "Verification failed" })
@@ -1552,38 +1582,58 @@ function DialogAuthEnterpriseCombined() {
 
   // === Portal ServiceNow Credentials ===
 
-  const fetchPortalSnCredentials = async (
+  const fetchPortalSnInstances = async (
     portalUrl: string,
-    token: string
-  ): Promise<{ instanceUrl: string; clientId: string; clientSecret: string } | null> => {
+    token: string,
+  ): Promise<
+    Array<{
+      id: number
+      instanceName: string
+      instanceUrl: string
+      environmentType: string
+      isDefault: boolean
+      enabled: boolean
+    }>
+  > => {
     try {
-      const response = await fetch(`${portalUrl}/api/user-credentials/servicenow/default`, {
+      const response = await fetch(`${portalUrl}/api/user-credentials/servicenow/instances`, {
         method: "GET",
         headers: {
           Authorization: `Bearer ${token}`,
           Accept: "application/json",
         },
       })
-
-      if (!response.ok) {
-        return null
-      }
-
+      if (!response.ok) return []
       const data = await response.json()
+      if (!data.success || !Array.isArray(data.instances)) return []
+      return data.instances.filter((i: any) => i.enabled)
+    } catch {
+      return []
+    }
+  }
 
-      if (!data.success || !data.instance) {
-        return null
-      }
-
-      const instance = data.instance
-      if (!instance.instanceUrl || !instance.clientId || !instance.clientSecret) {
-        return null
-      }
-
+  const fetchPortalSnInstanceById = async (
+    portalUrl: string,
+    token: string,
+    instanceId: number,
+  ): Promise<{ instanceUrl: string; clientId: string; clientSecret: string } | null> => {
+    try {
+      const response = await fetch(`${portalUrl}/api/user-credentials/servicenow/instances/${instanceId}`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: "application/json",
+        },
+      })
+      if (!response.ok) return null
+      const data = await response.json()
+      if (!data.success || !data.instance) return null
+      const inst = data.instance
+      if (!inst.instanceUrl || !inst.clientId || !inst.clientSecret) return null
       return {
-        instanceUrl: instance.instanceUrl,
-        clientId: instance.clientId,
-        clientSecret: instance.clientSecret,
+        instanceUrl: inst.instanceUrl,
+        clientId: inst.clientId,
+        clientSecret: inst.clientSecret,
       }
     } catch {
       return null
@@ -1938,6 +1988,33 @@ function DialogAuthEnterpriseCombined() {
         </box>
       </Show>
 
+      {/* Step 4c: Select ServiceNow instance */}
+      <Show when={step() === "select-sn-instance"}>
+        <DialogSelect
+          title="Select ServiceNow Instance"
+          options={snInstances().map((inst) => ({
+            title: inst.instanceName,
+            value: String(inst.id),
+            description: inst.instanceUrl,
+            footer: inst.environmentType + (inst.isDefault ? " (default)" : ""),
+            category: "ServiceNow Instances",
+            onSelect: async () => {
+              setStep("completing")
+              const portalUrl = `https://${subdomain().trim().toLowerCase()}.snow-flow.dev`
+              const token = enterpriseData().token!
+              const creds = await fetchPortalSnInstanceById(portalUrl, token, inst.id)
+              if (creds) {
+                setPortalSnCredentials(creds)
+                await startBothMcpServersWithPortalCreds(portalUrl, token, creds, enterpriseData().user)
+              } else {
+                toast.show({ variant: "error", message: "Failed to fetch instance credentials.", duration: 3000 })
+                setStep("sn-method")
+              }
+            },
+          }))}
+        />
+      </Show>
+
       {/* Step 5: Choose ServiceNow method */}
       <Show when={step() === "sn-method"}>
         <box gap={1}>

package/src/project/agents-template.txt

@@ -125,6 +125,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

@@ -82,6 +82,7 @@ import * as integrationTools from '../tools/integration/index.js';
 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 pluginsTools from '../tools/plugins/index.js';
 
 // ES Module compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -148,6 +149,7 @@ const STATIC_TOOL_MODULES: Record<string, any> = {
   'platform': platformTools,
   'devops': devopsTools,
   'virtual-agent': virtualAgentTools,
+  'plugins': pluginsTools,
 };
 
 export class ToolRegistry {

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';