@elliotding/ai-agent-mcp 0.1.25 → 0.1.26

package/src/tools/manage-subscription.ts

@@ -1,388 +0,0 @@
-/**
- * manage_subscription Tool
- * Manage resource subscriptions
- */
-
-import { logger, logToolCall } from '../utils/logger';
-import { apiClient } from '../api/client';
-import { MCPServerError, createValidationError } from '../types/errors';
-import type { ManageSubscriptionParams, ManageSubscriptionResult, ToolResult } from '../types/tools';
-import { syncResources } from './sync-resources';
-import { uninstallResource } from './uninstall-resource';
-import { promptManager } from '../prompts/index.js';
-
-export async function manageSubscription(params: unknown): Promise<ToolResult<ManageSubscriptionResult>> {
-  const startTime = Date.now();
-
-  // Type assertion for params
-  const typedParams = params as ManageSubscriptionParams;
-
-  logger.info({ tool: 'manage_subscription', params }, 'manage_subscription called');
-
-  try {
-    let result: ManageSubscriptionResult;
-
-    switch (typedParams.action) {
-      case 'subscribe': {
-        // Validate resource_ids
-        if (!typedParams.resource_ids || typedParams.resource_ids.length === 0) {
-          throw createValidationError(
-            'resource_ids',
-            'array',
-            'resource_ids is required for subscribe action'
-          );
-        }
-
-        logger.debug({ resourceIds: typedParams.resource_ids, autoSync: typedParams.auto_sync }, 'Subscribing to resources...');
-
-        // Subscribe to resources
-        const subResult = await apiClient.subscribe(
-          typedParams.resource_ids,
-          typedParams.auto_sync,
-          undefined,
-          typedParams.user_token
-        );
-
-        logger.info({ count: subResult.subscriptions.length }, 'Resources subscribed successfully');
-
-        // Auto-sync newly subscribed resources immediately (default: true)
-        const shouldAutoSync = typedParams.auto_sync !== false;
-        let syncSummary: string | undefined;
-        let syncDetails: Array<{ id: string; name: string; action: string }> | undefined;
-        let pendingSetup: unknown[] | undefined;
-
-        if (shouldAutoSync && subResult.subscriptions.length > 0) {
-          logger.info({ resourceIds: typedParams.resource_ids }, 'Auto-syncing newly subscribed resources...');
-          const syncResult = await syncResources({
-            mode: 'incremental',
-            scope: typedParams.scope || 'global',
-            user_token: typedParams.user_token,
-          });
-          if (syncResult.success && syncResult.data) {
-            const sd = syncResult.data;
-            syncSummary = `Auto-sync: ${sd.summary.synced} synced, ${sd.summary.cached} cached, ${sd.summary.failed} failed`;
-            syncDetails = sd.details.map(d => ({ id: d.id, name: d.name, action: d.action }));
-            if (sd.pending_setup && sd.pending_setup.length > 0) {
-              pendingSetup = sd.pending_setup;
-            }
-            logger.info({ summary: sd.summary }, 'Auto-sync after subscribe completed');
-          } else {
-            logger.warn({ error: syncResult.error }, 'Auto-sync after subscribe failed, subscription still recorded');
-            syncSummary = 'Auto-sync failed — run sync_resources manually if needed';
-          }
-        }
-
-        result = {
-          action: 'subscribe',
-          success: true,
-          subscriptions: subResult.subscriptions.map(sub => ({
-            id: sub.id,
-            name: sub.name,
-            type: sub.type,
-            subscribed_at: sub.subscribed_at,
-          })),
-          message: [
-            `Successfully subscribed to ${subResult.subscriptions.length} resource${subResult.subscriptions.length > 1 ? 's' : ''}.`,
-            syncSummary,
-            'If you need to execute a newly subscribed Command or Skill in this same conversation, call resolve_prompt_content next to retrieve the real prompt body.',
-          ].filter(Boolean).join(' '),
-          ...(syncDetails ? { sync_details: syncDetails } : {}),
-          ...(pendingSetup ? { pending_setup: pendingSetup } : {}),
-        };
-        break;
-      }
-
-      case 'unsubscribe': {
-        // Validate resource_ids
-        if (!typedParams.resource_ids || typedParams.resource_ids.length === 0) {
-          throw createValidationError(
-            'resource_ids',
-            'array',
-            'resource_ids is required for unsubscribe action'
-          );
-        }
-
-        logger.debug({ resourceIds: typedParams.resource_ids }, 'Unsubscribing from resources...');
-
-        // Build a resource_id → type map from the current subscription list so
-        // uninstall actions can be scoped precisely to rule vs mcp resources.
-        let idToType: Map<string, string> = new Map();
-        try {
-          const currentSubs = await apiClient.getSubscriptions({}, typedParams.user_token);
-          for (const s of currentSubs.subscriptions) {
-            idToType.set(s.id, s.type);
-          }
-        } catch (e) {
-          logger.warn({ error: (e as Error).message }, 'Could not fetch subscriptions for type resolution — uninstall will emit both rule+mcp actions as fallback');
-        }
-
-        // Cancel server-side subscription
-        await apiClient.unsubscribe(typedParams.resource_ids, typedParams.user_token);
-        logger.info({ count: typedParams.resource_ids.length }, 'Server-side subscriptions removed');
-
-        // Uninstall local files and MCP config for each resource.
-        // For Command/Skill: unregister MCP Prompt instead of deleting local files.
-        const uninstallResults: Array<{ id: string; removed: boolean; detail: string }> = [];
-        for (const resourceId of typedParams.resource_ids) {
-          // Determine if this is a Command or Skill by checking the prompt registry.
-          // API resource IDs are UUIDs (e.g. "0ccd800f..."), NOT prefixed with "cmd-"/"skill-".
-          // Check whether any registered prompt for this user matches the resource_id.
-          const matchedPromptName = promptManager.promptNames(typedParams.user_token ?? '').find(
-            (name) => {
-              // Prompt names are "<type>/<resource_name>"; check by looking up the registered meta.
-              const registered = promptManager.getByPromptName(name, typedParams.user_token ?? '');
-              return registered?.meta?.resource_id === resourceId;
-            },
-          );
-          if (matchedPromptName) {
-            const parts = matchedPromptName.split('/');
-            const resourceType = (parts[0] ?? 'command') as 'command' | 'skill';
-            const resourceName = parts.slice(1).join('/') || matchedPromptName;
-            promptManager.unregisterPrompt(resourceId, resourceType, resourceName, typedParams.user_token ?? '');
-            uninstallResults.push({ id: resourceId, removed: true, detail: `Unregistered MCP Prompt for "${resourceName}"` });
-            logger.info({ resourceId, resourceType, matchedPromptName }, 'MCP Prompt unregistered on unsubscribe');
-            continue;
-          }
-          // Use the last segment of the resource ID as the search pattern
-          // e.g. "mcp-client-sdk-ai-hub-jenkins" → "jenkins"
-          //      "rule-csp-elliotTest"            → "elliotTest"
-          const namePart = resourceId.split('-').slice(-1)[0] ||
-                           resourceId.split('-').slice(-2).join('-') ||
-                           resourceId;
-
-          // Try full name match first (e.g. "elliotTest"), fallback to last segment
-          const patternsToTry = Array.from(new Set([
-            resourceId,                                   // full id
-            resourceId.replace(/^(skill|cmd|rule|mcp)-[^-]+-/, ''), // strip prefix+source
-            namePart,
-          ]));
-
-          const resolvedType = idToType.get(resourceId) as 'rule' | 'mcp' | undefined;
-          let uninstalled = false;
-          for (const pattern of patternsToTry) {
-            const uninstallResult = await uninstallResource({
-              resource_id_or_name: pattern,
-              remove_from_account: false, // already unsubscribed above
-              ...(resolvedType ? { resource_type: resolvedType } : {}),
-            });
-            if (uninstallResult.success && uninstallResult.data && uninstallResult.data.removed_resources.length > 0) {
-              uninstallResults.push({ id: resourceId, removed: true, detail: `Removed local files for "${pattern}"` });
-              uninstalled = true;
-              break;
-            }
-          }
-          if (!uninstalled) {
-            uninstallResults.push({ id: resourceId, removed: false, detail: 'No local files found (may not have been installed)' });
-          }
-        }
-
-        const removedCount = uninstallResults.filter(r => r.removed).length;
-        const notFoundCount = uninstallResults.filter(r => !r.removed).length;
-
-        result = {
-          action: 'unsubscribe',
-          success: true,
-          message: [
-            `Successfully unsubscribed from ${typedParams.resource_ids.length} resource${typedParams.resource_ids.length > 1 ? 's' : ''}.`,
-            removedCount > 0 ? `Removed local files for ${removedCount} resource${removedCount > 1 ? 's' : ''}.` : null,
-            notFoundCount > 0 ? `${notFoundCount} resource${notFoundCount > 1 ? 's were' : ' was'} not installed locally.` : null,
-          ].filter(Boolean).join(' '),
-          sync_details: uninstallResults.map(r => ({ id: r.id, name: r.id, action: r.removed ? 'uninstalled' : 'not_found_locally' })),
-        };
-
-        logger.info({ count: typedParams.resource_ids.length, removedCount }, 'Resources unsubscribed and local files cleaned up');
-        break;
-      }
-
-      case 'list': {
-        logger.debug({ scope: typedParams.scope || 'all' }, 'Listing subscriptions...');
-
-        // Get subscriptions list
-        const subs = await apiClient.getSubscriptions({}, typedParams.user_token);
-
-        result = {
-          action: 'list',
-          success: true,
-          subscriptions: subs.subscriptions.map(sub => ({
-            id: sub.id,
-            name: sub.name,
-            type: sub.type,
-            subscribed_at: sub.subscribed_at,
-          })),
-          message: `Found ${subs.total} subscription${subs.total !== 1 ? 's' : ''}`,
-        };
-
-        logger.info({ total: subs.total }, 'Subscriptions listed successfully');
-        break;
-      }
-
-      case 'batch_subscribe': {
-        // Validate resource_ids
-        if (!typedParams.resource_ids || typedParams.resource_ids.length === 0) {
-          throw createValidationError(
-            'resource_ids',
-            'array',
-            'resource_ids is required for batch_subscribe action'
-          );
-        }
-
-        logger.debug({ count: typedParams.resource_ids.length, autoSync: typedParams.auto_sync }, 'Batch subscribing to resources...');
-
-        const batchSubResult = await apiClient.subscribe(
-          typedParams.resource_ids,
-          typedParams.auto_sync,
-          undefined,
-          typedParams.user_token
-        );
-
-        logger.info({ count: batchSubResult.subscriptions.length }, 'Batch subscription completed');
-
-        // Auto-sync newly subscribed resources immediately (default: true)
-        const shouldBatchAutoSync = typedParams.auto_sync !== false;
-        let batchSyncSummary: string | undefined;
-        let batchSyncDetails: Array<{ id: string; name: string; action: string }> | undefined;
-        let batchPendingSetup: unknown[] | undefined;
-
-        if (shouldBatchAutoSync && batchSubResult.subscriptions.length > 0) {
-          logger.info({ count: batchSubResult.subscriptions.length }, 'Auto-syncing batch subscribed resources...');
-          const batchSyncResult = await syncResources({
-            mode: 'incremental',
-            scope: typedParams.scope || 'global',
-            user_token: typedParams.user_token,
-          });
-          if (batchSyncResult.success && batchSyncResult.data) {
-            const sd = batchSyncResult.data;
-            batchSyncSummary = `Auto-sync: ${sd.summary.synced} synced, ${sd.summary.cached} cached, ${sd.summary.failed} failed`;
-            batchSyncDetails = sd.details.map(d => ({ id: d.id, name: d.name, action: d.action }));
-            if (sd.pending_setup && sd.pending_setup.length > 0) {
-              batchPendingSetup = sd.pending_setup;
-            }
-          } else {
-            batchSyncSummary = 'Auto-sync failed — run sync_resources manually if needed';
-          }
-        }
-
-        result = {
-          action: 'batch_subscribe',
-          success: true,
-          subscriptions: batchSubResult.subscriptions.map(sub => ({
-            id: sub.id,
-            name: sub.name,
-            type: sub.type,
-            subscribed_at: sub.subscribed_at,
-          })),
-          message: [
-            `Successfully batch subscribed to ${batchSubResult.subscriptions.length} resource${batchSubResult.subscriptions.length > 1 ? 's' : ''}.`,
-            batchSyncSummary,
-          ].filter(Boolean).join(' '),
-          ...(batchSyncDetails ? { sync_details: batchSyncDetails } : {}),
-          ...(batchPendingSetup ? { pending_setup: batchPendingSetup } : {}),
-        };
-        break;
-      }
-
-      case 'batch_unsubscribe': {
-        // Validate resource_ids
-        if (!typedParams.resource_ids || typedParams.resource_ids.length === 0) {
-          throw createValidationError(
-            'resource_ids',
-            'array',
-            'resource_ids is required for batch_unsubscribe action'
-          );
-        }
-
-        logger.debug({ count: typedParams.resource_ids.length }, 'Batch unsubscribing from resources...');
-
-        // Delegate entirely to the unsubscribe case for unified cleanup logic
-        return manageSubscription({ ...typedParams, action: 'unsubscribe' });
-      }
-
-      default: {
-        throw createValidationError(
-          'action',
-          'string',
-          `Unknown action. Must be one of: subscribe, unsubscribe, list, batch_subscribe, batch_unsubscribe`
-        );
-      }
-    }
-
-    const duration = Date.now() - startTime;
-    logToolCall('manage_subscription', 'user-id', params as Record<string, unknown>, duration);
-
-    logger.info(
-      {
-        action: typedParams.action,
-        duration,
-      },
-      'manage_subscription completed successfully'
-    );
-
-    return {
-      success: true,
-      data: result,
-    };
-  } catch (error) {
-    logger.error({ error, action: typedParams.action }, 'manage_subscription failed');
-    return {
-      success: false,
-      error: {
-        code: error instanceof MCPServerError ? error.code : 'UNKNOWN_ERROR',
-        message: error instanceof Error ? error.message : String(error),
-      },
-    };
-  }
-}
-
-// Tool definition for registry
-export const manageSubscriptionTool = {
-  name: 'manage_subscription',
-  description:
-    'Manage resource subscriptions (subscribe, unsubscribe, list). ' +
-    'When action is "subscribe" or "batch_subscribe", the tool automatically syncs ' +
-    'the newly subscribed resources to the local machine immediately after subscribing ' +
-    '(auto_sync defaults to true). Pass auto_sync: false only when the user explicitly ' +
-    'says they do NOT want the resource installed right now. ' +
-    'For newly subscribed Command or Skill resources that must be used immediately in the same conversation, ' +
-    'follow with `resolve_prompt_content` after sync instead of assuming Cursor will fetch the prompt body automatically.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      action: {
-        type: 'string',
-        description: 'Action to perform',
-        enum: ['subscribe', 'unsubscribe', 'list', 'batch_subscribe', 'batch_unsubscribe'],
-      },
-      resource_ids: {
-        type: 'array',
-        description: 'Resource IDs (required for subscribe/unsubscribe actions)',
-      },
-      auto_sync: {
-        type: 'boolean',
-        description:
-          'Whether to immediately sync (install) the subscribed resources to the local machine after subscribing. ' +
-          'Defaults to true — omit this field in normal usage. ' +
-          'Set to false only when the user explicitly says they want to subscribe but NOT install yet.',
-        default: true,
-      },
-      scope: {
-        type: 'string',
-        description: 'Installation scope',
-        enum: ['global', 'workspace'],
-        default: 'global',
-      },
-      notify: {
-        type: 'boolean',
-        description: 'Enable update notifications',
-        default: true,
-      },
-      user_token: {
-        type: 'string',
-        description:
-          'DO NOT set this field — it is automatically injected by the MCP server from ' +
-          'the authenticated SSE connection. The server always provides the correct token.',
-      },
-    },
-    required: ['action'],
-  },
-  handler: manageSubscription,
-};

package/src/tools/registry.ts

@@ -1,97 +0,0 @@
-/**
- * Tool Registry
- * Central registry for MCP tools
- */
-
-import { logger } from '../utils/logger';
-import type { ToolDefinition } from '../types/tools';
-import type { MCPToolDefinition } from '../types/mcp';
-
-class ToolRegistry {
-  private tools: Map<string, ToolDefinition> = new Map();
-
-  /**
-   * Register a tool
-   */
-  registerTool(tool: ToolDefinition): void {
-    if (this.tools.has(tool.name)) {
-      throw new Error(`Tool '${tool.name}' is already registered`);
-    }
-
-    this.tools.set(tool.name, tool);
-    logger.info({ toolName: tool.name }, `Tool registered: ${tool.name}`);
-  }
-
-  /**
-   * Get a tool by name
-   */
-  getTool(name: string): ToolDefinition | undefined {
-    return this.tools.get(name);
-  }
-
-  /**
-   * List all registered tools
-   */
-  listTools(): ToolDefinition[] {
-    return Array.from(this.tools.values());
-  }
-
-  /**
-   * Get MCP tool definitions (for tools/list response)
-   */
-  getMCPToolDefinitions(): MCPToolDefinition[] {
-    return this.listTools().map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      inputSchema: tool.inputSchema,
-    }));
-  }
-
-  /**
-   * Check if a tool exists
-   */
-  hasTool(name: string): boolean {
-    return this.tools.has(name);
-  }
-
-  /**
-   * Get tool count
-   */
-  getToolCount(): number {
-    return this.tools.size;
-  }
-
-  /**
-   * Call a tool by name with arguments
-   */
-  async callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
-    const tool = this.getTool(name);
-    if (!tool) {
-      throw new Error(`Tool '${name}' not found`);
-    }
-
-    logger.debug({ toolName: name, args }, 'Calling tool');
-    
-    try {
-      const result = await tool.handler(args);
-      
-      // Debug: Log the result structure
-      logger.debug({ 
-        toolName: name, 
-        resultType: typeof result,
-        resultKeys: result && typeof result === 'object' ? Object.keys(result) : undefined,
-        hasSuccess: result && typeof result === 'object' && 'success' in result,
-        hasData: result && typeof result === 'object' && 'data' in result,
-        hasError: result && typeof result === 'object' && 'error' in result
-      }, 'Tool execution result structure');
-      
-      return result;
-    } catch (error) {
-      logger.error({ toolName: name, error, errorType: typeof error, errorMessage: error instanceof Error ? error.message : String(error) }, 'Tool execution threw error');
-      throw error;
-    }
-  }
-}
-
-// Global singleton
-export const toolRegistry = new ToolRegistry();

package/src/tools/resolve-prompt-content.ts

@@ -1,113 +0,0 @@
-/**
- * resolve_prompt_content Tool
- *
- * Stable fallback for retrieving the fully resolved body of a dynamically
- * subscribed Command or Skill without relying on Cursor to issue prompts/get.
- */
-
-import { logger } from '../utils/logger';
-import { promptManager } from '../prompts/index.js';
-import type {
-  ResolvePromptContentParams,
-  ResolvePromptContentResult,
-  ToolResult,
-} from '../types/tools';
-
-export async function resolvePromptContent(
-  params: unknown,
-): Promise<ToolResult<ResolvePromptContentResult>> {
-  const p = params as ResolvePromptContentParams;
-  const promptName = typeof p.prompt_name === 'string' && p.prompt_name.trim() !== ''
-    ? p.prompt_name.trim()
-    : undefined;
-  const resourceId = typeof p.resource_id === 'string' && p.resource_id.trim() !== ''
-    ? p.resource_id.trim()
-    : undefined;
-  const userToken = typeof p.user_token === 'string' ? p.user_token : '';
-  const jiraId = typeof p.jira_id === 'string' && p.jira_id.trim() !== ''
-    ? p.jira_id.trim()
-    : undefined;
-
-  if (!promptName && !resourceId) {
-    return {
-      success: false,
-      error: {
-        code: 'VALIDATION_ERROR',
-        message: 'Either prompt_name or resource_id is required',
-      },
-    };
-  }
-
-  const resolved = await promptManager.resolvePromptContentForInvocation({
-    promptName,
-    resourceId,
-    userToken,
-    jiraId,
-  });
-
-  if (!resolved) {
-    const target = promptName ?? resourceId ?? 'unknown';
-    logger.warn({ promptName, resourceId }, 'resolve_prompt_content: prompt not found');
-    return {
-      success: false,
-      error: {
-        code: 'PROMPT_NOT_FOUND',
-        message: `Prompt "${target}" is not available. Please run sync_resources first.`,
-      },
-    };
-  }
-
-  logger.info(
-    {
-      promptName: resolved.promptName,
-      resourceId: resolved.meta.resource_id,
-      contentSource: resolved.contentSource,
-    },
-    'resolve_prompt_content: prompt resolved successfully',
-  );
-
-  return {
-    success: true,
-    data: {
-      prompt_name: resolved.promptName,
-      resource_id: resolved.meta.resource_id,
-      resource_type: resolved.meta.resource_type,
-      resource_name: resolved.meta.resource_name,
-      description: resolved.description,
-      content: resolved.content,
-      content_source: resolved.contentSource,
-      usage_tracked: Boolean(userToken),
-    },
-  };
-}
-
-export const resolvePromptContentTool = {
-  name: 'resolve_prompt_content',
-  description:
-    'Retrieve the fully resolved content of a Command or Skill prompt without relying on native prompts/get. ' +
-    'Use this immediately after search_resources -> manage_subscription -> sync_resources when you need the prompt body in the same workflow. ' +
-    'Provide either prompt_name (for example "command/acm-helper") or resource_id. ' +
-    'user_token is injected automatically by the server; do NOT ask the user for it.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      prompt_name: {
-        type: 'string',
-        description: 'Registered MCP prompt name, for example "command/acm-helper".',
-      },
-      resource_id: {
-        type: 'string',
-        description: 'Canonical CSP resource ID for the Command or Skill.',
-      },
-      user_token: {
-        type: 'string',
-        description: 'DO NOT set this field — it is injected automatically by the server.',
-      },
-      jira_id: {
-        type: 'string',
-        description: 'Optional Jira issue ID for usage correlation.',
-      },
-    },
-  },
-  handler: resolvePromptContent,
-};