add-resource

Add Resource to MCP Server

Adds a new resource endpoint to your MCP server with proper URI handling.

Usage

/add-resource <name> <description> [uri-pattern] [mime-type]

Examples

/add-resource config "Server configuration" config://settings application/json
/add-resource users "User database" data://users/{id} application/json
/add-resource files "File system access" file:///{path} text/plain

Implementation

import * as fs from 'fs/promises';
import * as path from 'path';

async function addResource(
  name: string,
  description: string,
  uriPattern?: string,
  mimeType: string = 'application/json'
) {
  // Generate URI pattern if not provided
  const uri = uriPattern || `${name}://default`;
  
  // Generate resource file
  const resourceContent = generateResourceFile(name, description, uri, mimeType);
  
  // Write resource file
  const resourcePath = path.join('src/resources', `${name}.ts`);
  await fs.writeFile(resourcePath, resourceContent);
  
  // Update resource index
  await updateResourceIndex(name);
  
  // Generate test file
  const testContent = generateResourceTest(name, uri);
  const testPath = path.join('tests/unit/resources', `${name}.test.ts`);
  await fs.writeFile(testPath, testContent);
  
  console.log(`✅ Resource "${name}" added successfully!`);
  console.log(`  - Implementation: ${resourcePath}`);
  console.log(`  - Test file: ${testPath}`);
  console.log(`  - URI pattern: ${uri}`);
  console.log(`  - MIME type: ${mimeType}`);
  console.log(`\nNext steps:`);
  console.log(`  1. Implement the resource provider in ${resourcePath}`);
  console.log(`  2. Test with MCP Inspector`);
}

function generateResourceFile(
  name: string,
  description: string,
  uri: string,
  mimeType: string
): string {
  const hasDynamicParams = uri.includes('{');
  
  return `
import type { Resource, ResourceContent } from '../types/resources.js';

export const ${name}Resource: Resource = {
  uri: '${uri}',
  name: '${name}',
  description: '${description}',
  mimeType: '${mimeType}',
};

export async function read${capitalize(name)}Resource(
  uri: string
): Promise<ResourceContent[]> {
  ${hasDynamicParams ? generateDynamicResourceHandler(uri) : generateStaticResourceHandler()}
  
  return [
    {
      uri,
      mimeType: '${mimeType}',
      text: ${mimeType === 'application/json' ? 'JSON.stringify(data, null, 2)' : 'data'},
    },
  ];
}

${generateResourceDataFunction(name, mimeType)}
`;
}

function generateDynamicResourceHandler(uriPattern: string): string {
  return `
  // Parse dynamic parameters from URI
  const params = parseUriParams('${uriPattern}', uri);
  
  // Fetch data based on parameters
  const data = await fetch${capitalize(name)}Data(params);
  
  if (!data) {
    throw new Error(\`Resource not found: \${uri}\`);
  }
`;
}

function generateStaticResourceHandler(): string {
  return `
  // Fetch static resource data
  const data = await fetch${capitalize(name)}Data();
`;
}

function generateResourceDataFunction(name: string, mimeType: string): string {
  if (mimeType === 'application/json') {
    return `
async function fetch${capitalize(name)}Data(params?: Record<string, string>) {
  // TODO: Implement data fetching logic
  // This is a placeholder implementation
  
  if (params?.id) {
    // Return specific item
    return {
      id: params.id,
      name: 'Example Item',
      timestamp: new Date().toISOString(),
    };
  }
  
  // Return collection
  return {
    items: [
      { id: '1', name: 'Item 1' },
      { id: '2', name: 'Item 2' },
    ],
    total: 2,
  };
}

function parseUriParams(pattern: string, uri: string): Record<string, string> {
  // Convert pattern to regex
  const regexPattern = pattern
    .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
    .replace(/\{(\w+)\}/g, '(?<$1>[^/]+)');
  
  const regex = new RegExp(\`^\${regexPattern}$\`);
  const match = uri.match(regex);
  
  return match?.groups || {};
}
`;
  } else {
    return `
async function fetch${capitalize(name)}Data(params?: Record<string, string>) {