@elliotding/ai-agent-mcp 0.1.24 → 0.1.26

package/src/tools/manage-subscription.ts

@@ -1,385 +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,
-          ].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.',
-  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/search-resources.ts

@@ -1,185 +0,0 @@
-/**
- * search_resources Tool
- * Search for available resources
- */
-
-import { logger, logToolCall } from '../utils/logger';
-import { apiClient } from '../api/client';
-import { filesystemManager } from '../filesystem/manager';
-import { getCursorResourcePath } from '../utils/cursor-paths.js';
-import { MCPServerError } from '../types/errors';
-import type { SearchResourcesParams, SearchResourcesResult, ToolResult } from '../types/tools';
-// Simple in-memory cache
-const searchCache = new Map<string, { results: SearchResourcesResult; timestamp: number }>();
-const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-
-/**
- * Generate cache key from search parameters
- */
-function getCacheKey(params: SearchResourcesParams): string {
-  return JSON.stringify({
-    team: params.team || '',
-    type: params.type || '',
-    keyword: params.keyword || '',
-  });
-}
-
-/**
- * Get cached search results if available and not expired
- */
-function getCachedResults(cacheKey: string): SearchResourcesResult | null {
-  const cached = searchCache.get(cacheKey);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
-    logger.debug({ cacheKey }, 'Search cache hit');
-    return cached.results;
-  }
-  
-  if (cached) {
-    // Remove expired cache entry
-    searchCache.delete(cacheKey);
-    logger.debug({ cacheKey }, 'Search cache expired, removed');
-  }
-  
-  return null;
-}
-
-/**
- * Cache search results
- */
-function cacheResults(cacheKey: string, results: SearchResourcesResult): void {
-  searchCache.set(cacheKey, {
-    results,
-    timestamp: Date.now(),
-  });
-  logger.debug({ cacheKey, total: results.total }, 'Search results cached');
-}
-
-export async function searchResources(params: unknown): Promise<ToolResult<SearchResourcesResult>> {
-  const startTime = Date.now();
-
-  // Type assertion for params
-  const typedParams = params as SearchResourcesParams;
-
-  logger.info({ tool: 'search_resources', params }, 'search_resources called');
-
-  try {
-    // Generate cache key
-    const cacheKey = getCacheKey(typedParams);
-
-    // Check cache first
-    const cachedResult = getCachedResults(cacheKey);
-    if (cachedResult) {
-      const duration = Date.now() - startTime;
-      logToolCall('search_resources', 'user-id', params as Record<string, unknown>, duration);
-      
-      logger.info({ total: cachedResult.total, duration, cached: true }, 'search_resources completed (cache hit)');
-      
-      return {
-        success: true,
-        data: cachedResult,
-      };
-    }
-
-    // Search via API
-    logger.debug({ team: typedParams.team, type: typedParams.type, keyword: typedParams.keyword }, 'Searching resources...');
-    
-    const searchResults = await apiClient.searchResources(
-      {
-        team: typedParams.team,
-        type: typedParams.type,
-        keyword: typedParams.keyword,
-      },
-      typedParams.user_token
-    );
-
-    // Check subscription and installation status for each result
-    const enhancedResults = await Promise.all(
-      searchResults.results.map(async (resource) => {
-        // Check if installed locally in the Cursor directory for this resource type
-        let isInstalled = false;
-        try {
-          const resourcePath = getCursorResourcePath(resource.type, resource.name);
-          isInstalled = await filesystemManager.fileExists(resourcePath);
-        } catch {
-          // Unknown type or path check failed — treat as not installed
-          isInstalled = false;
-        }
-
-        return {
-          ...resource,
-          is_installed: isInstalled,
-        };
-      })
-    );
-
-    // Build final result
-    const result: SearchResourcesResult = {
-      total: searchResults.total,
-      results: enhancedResults,
-    };
-
-    // Cache the results
-    cacheResults(cacheKey, result);
-
-    const duration = Date.now() - startTime;
-    logToolCall('search_resources', 'user-id', params as Record<string, unknown>, duration);
-
-    logger.info(
-      {
-        team: typedParams.team,
-        type: typedParams.type,
-        keyword: typedParams.keyword,
-        total: result.total,
-        duration,
-        cached: false,
-      },
-      'search_resources completed successfully'
-    );
-
-    return {
-      success: true,
-      data: result,
-    };
-  } catch (error) {
-    logger.error({ error, tool: 'search_resources', errorStack: error instanceof Error ? error.stack : undefined }, 'search_resources 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 searchResourcesTool = {
-  name: 'search_resources',
-  description: 'Search for available resources by team, type, or keyword',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      team: {
-        type: 'string',
-        description: 'Filter by team (empty = all teams)',
-      },
-      type: {
-        type: 'string',
-        description: 'Filter by resource type',
-        enum: ['command', 'skill', 'rule', 'mcp', ''],
-      },
-      keyword: {
-        type: 'string',
-        description: 'Search keyword (searches in name, description, tags)',
-      },
-      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: ['keyword'],
-  },
-  handler: searchResources,
-};