atom-marketplace-mcp-server/api/chatgpt-optimized.js

MCP server for Atom marketplace APIs - domain search, availability, trademarks, and appraisals

import { AtomMarketplaceMCPServer } from '../server.js';

// Optimized endpoint for ChatGPT Custom GPTs to reduce permission prompts
export default async (req, res) => {
  // Set CORS headers
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');

  // Handle preflight requests
  if (req.method === 'OPTIONS') {
    res.status(200).end();
    return;
  }

  try {
    const mcpServer = new AtomMarketplaceMCPServer();

    if (req.method === 'GET') {
      // Return available operations
      res.json({
        success: true,
        message: "Atom Marketplace - Optimized API",
        operations: {
          "domain_appraisal": "Get domain appraisal",
          "domain_availability": "Check domain availability",
          "domain_search": "Search marketplace domains",
          "trademark_search": "Search trademarks",
          "semantic_search": "AI semantic search",
          "batch_operations": "Multiple operations in one call"
        },
        batch_example: {
          operation: "batch",
          actions: [
            { type: "domain_appraisal", domain_name: "example.com" },
            { type: "domain_availability", domains: [{"domain_name": "example", "tld": "com"}] },
            { type: "domain_search", query: "tech startup" }
          ]
        }
      });
      return;
    }

    if (req.method !== 'POST') {
      res.status(405).json({
        success: false,
        error: 'Method not allowed. Use POST.'
      });
      return;
    }

    const { operation, actions, ...singleParams } = req.body;

    // Handle batch operations
    if (operation === 'batch' && Array.isArray(actions)) {
      const results = [];
      
      for (const action of actions) {
        try {
          const result = await executeAction(mcpServer, action);
          results.push({
            action: action.type,
            success: true,
            data: result
          });
        } catch (error) {
          results.push({
            action: action.type,
            success: false,
            error: error.message
          });
        }
      }

      res.json({
        success: true,
        operation: 'batch',
        results: results
      });
      return;
    }

    // Handle single operation
    const action = {
      type: operation,
      ...singleParams
    };

    const result = await executeAction(mcpServer, action);
    
    res.json({
      success: true,
      operation: operation,
      data: result
    });

  } catch (error) {
    console.error('Optimized API error:', error);
    res.status(500).json({
      success: false,
      error: error.message || 'Internal server error'
    });
  }
};

async function executeAction(mcpServer, action) {
  const { type, ...params } = action;

  switch (type) {
    case 'domain_appraisal':
      const appraisalResult = await mcpServer.handleRequest('get_domain_appraisal', {
        domain_name: params.domain_name
      });
      return extractContent(appraisalResult);

    case 'domain_availability':
      const availabilityResult = await mcpServer.handleRequest('check_domain_availability', {
        domains: params.domains
      });
      return extractContent(availabilityResult);

    case 'domain_search':
      const searchResult = await mcpServer.handleRequest('search_marketplace_domains', {
        query: params.query,
        page: params.page || 1,
        page_size: params.page_size || 20
      });
      return extractContent(searchResult);

    case 'trademark_search':
      const trademarkResult = await mcpServer.handleRequest('search_trademarks', {
        query: params.query,
        search_type: params.search_type || 'phrase',
        filing_status: params.filing_status || 'active',
        page: params.page || 1,
        page_size: params.page_size || 20
      });
      return extractContent(trademarkResult);

    case 'semantic_search':
      const semanticResult = await mcpServer.handleRequest('semantic_search_domains', {
        query: params.query,
        page: params.page || 1,
        page_size: params.page_size || 20
      });
      return extractContent(semanticResult);

    default:
      throw new Error(`Unknown operation type: ${type}`);
  }
}

function extractContent(result) {
  if (result.content && result.content[0] && result.content[0].text) {
    try {
      return JSON.parse(result.content[0].text);
    } catch (e) {
      return { raw_response: result.content[0].text };
    }
  }
  return result;
}