miadi 1.0.14 → 2.0.1

package/src/index-remote.ts

@@ -1,406 +0,0 @@
-#!/usr/bin/env node
-
-import express from 'express';
-import cors from 'cors';
-import { randomUUID } from 'node:crypto';
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { z } from "zod";
-
-import { getEnvVar } from './utils.js';
-import { memoryTools } from './tools/memory-tools.js';
-import { sessionTools } from './tools/session-tools.js';
-import { capabilityTools } from './tools/capability-tools.js';
-import { aiTools } from './tools/ai-tools.js';
-import { workflowTools } from './tools/workflow-tools.js';
-import { forgeTools } from './tools/forge-tools.js';
-
-// Validate required environment variables
-try {
-  getEnvVar('EH_TOKEN');
-  getEnvVar('EH_API_URL');
-  console.log('✅ Environment variables validated');
-} catch (error: any) {
-  console.error('❌ Environment validation failed:', error.message);
-  process.exit(1);
-}
-
-// Create MCP server instance
-const server = new McpServer({
-  name: 'miadi-mcp-server',
-  version: '1.0.0'
-}, {
-  capabilities: {
-    tools: {},
-    resources: {},
-    prompts: {}
-  }
-});
-
-// Function to register a Miadi tool using the official SDK pattern
-function registerMiadiTool(
-  name: string,
-  description: string,
-  inputSchema: Record<string, z.ZodType<any>>,
-  handler: (args: any) => Promise<any>
-) {
-  server.registerTool(
-    name,
-    {
-      description,
-      inputSchema
-    },
-    async (args) => {
-      try {
-        console.log(`[${name}] Called with:`, JSON.stringify(args, null, 2));
-        const result = await handler(args);
-        
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify(result, null, 2)
-          }]
-        };
-      } catch (error: any) {
-        console.error(`[${name}] Error:`, error);
-        return {
-          content: [{
-            type: 'text', 
-            text: `Error in ${name}: ${error.message}`
-          }]
-        };
-      }
-    }
-  );
-}
-
-// Register all Miadi tools using the official pattern
-console.log('📝 Registering Miadi tools...');
-
-// Intelligent parameter router that fixes parameter mistakes and unpacks arguments
-function createIntelligentParameterAdapter(toolName: string, originalHandler: Function) {
-  return (args: any) => {
-    const adaptedArgs = { ...args };
-    
-    console.log(`[${toolName}] Called with:`, Object.keys(args));
-    
-    // Route and fix parameters based on tool and provided parameters
-    switch (toolName) {
-      case 'collectMemory':
-        if (args.pattern && !args.keys) {
-          throw new Error(`collectMemory requires 'keys' array. For pattern matching, use gatherMemoryValues tool instead.`);
-        }
-        if (args.key && !args.keys) {
-          adaptedArgs.keys = [args.key];
-          console.log(`[${toolName}] Smart adapter: converted 'key' to 'keys' array`);
-        }
-        // Handle ANY keys parameter format - nuclear option
-        if (adaptedArgs.keys && !Array.isArray(adaptedArgs.keys)) {
-          const keysStr = String(adaptedArgs.keys);
-          if (keysStr.includes(',')) {
-            adaptedArgs.keys = keysStr.split(',').map(key => key.trim());
-            console.log(`[${toolName}] Nuclear adapter: split "${keysStr}" to array:`, adaptedArgs.keys);
-          } else {
-            adaptedArgs.keys = [keysStr];
-            console.log(`[${toolName}] Nuclear adapter: converted "${keysStr}" to array`);
-          }
-        }
-        // Ensure we have an array
-        if (!adaptedArgs.keys) {
-          throw new Error('collectMemory requires keys parameter');
-        }
-        if (!Array.isArray(adaptedArgs.keys)) {
-          adaptedArgs.keys = [adaptedArgs.keys];
-        }
-        // Call with unpacked parameters
-        return memoryTools.collectMemory(adaptedArgs.keys);
-        
-      case 'getMemory':
-        // Call with unpacked parameters in correct order
-        return memoryTools.getMemory(adaptedArgs.key, adaptedArgs.list, adaptedArgs.pattern, adaptedArgs.type);
-        
-      case 'storeMemory':
-        return memoryTools.storeMemory(adaptedArgs.key, adaptedArgs.value, adaptedArgs.ttl, adaptedArgs.type);
-        
-      case 'updateMemoryTTL':
-        return memoryTools.updateMemoryTTL(adaptedArgs.key, adaptedArgs.ttl);
-        
-      case 'getMemoryMeta':
-        return memoryTools.getMemoryMeta(adaptedArgs.key);
-        
-      case 'scanKeys':
-        return memoryTools.scanKeys(adaptedArgs.pattern, adaptedArgs.regex, adaptedArgs.limit);
-        
-      case 'gatherMemoryValues':
-        return memoryTools.gatherMemoryValues(adaptedArgs.pattern, adaptedArgs.regex, adaptedArgs.limit, adaptedArgs.scanLimit);
-        
-      case 'viewKeyContent':
-        return memoryTools.viewKeyContent(adaptedArgs.key);
-        
-      case 'searchCluster':
-        // Map common parameter names to 'term'
-        if (args.key && !args.term) {
-          adaptedArgs.term = args.key;
-          console.log(`[${toolName}] Smart adapter: mapped 'key' to 'term'`);
-        }
-        if (args.value && !args.term) {
-          adaptedArgs.term = args.value;
-          console.log(`[${toolName}] Smart adapter: mapped 'value' to 'term'`);
-        }
-        return memoryTools.searchCluster(adaptedArgs.term);
-        
-      default:
-        // Fallback to original handler for unknown tools
-        return originalHandler(adaptedArgs);
-    }
-  };
-}
-
-// Memory tools with smart parameter adaptation
-Object.entries(memoryTools).forEach(([name, handler]) => {
-  registerMiadiTool(
-    name,
-    `Miadi ${name.replace('miadi-', '').replace(/-/g, ' ')} operation`,
-    {
-      // Comprehensive schema for all memory tools
-      key: z.string().optional().describe('Memory key'),
-      keys: z.any().optional().describe('Memory key(s) - any format accepted'),
-      value: z.any().optional().describe('Value to store'),
-      pattern: z.string().optional().describe('Pattern for key matching'),
-      regex: z.string().optional().describe('Regex for key matching'),
-      ttl: z.number().optional().describe('Time to live in seconds'),
-      type: z.enum(['auto', 'string', 'hash', 'list', 'set', 'zset']).optional().describe('Redis data type'),
-      list: z.boolean().optional().describe('List mode for pattern matching'),
-      limit: z.number().optional().describe('Maximum number of items to return'),
-      scanLimit: z.number().optional().describe('Maximum number of keys to scan'),
-      term: z.string().optional().describe('Search term')
-    },
-    createIntelligentParameterAdapter(name, handler)
-  );
-});
-
-// Session tools  
-Object.entries(sessionTools).forEach(([name, handler]) => {
-  registerMiadiTool(
-    name,
-    `Miadi ${name.replace('miadi-', '').replace(/-/g, ' ')} operation`,
-    {
-      persona: z.string().optional().describe('Agent persona'),
-      mode: z.string().optional().describe('Agent mode'),
-      context: z.any().optional().describe('Session context')
-    },
-    handler
-  );
-});
-
-// Capability tools
-Object.entries(capabilityTools).forEach(([name, handler]) => {
-  registerMiadiTool(
-    name,
-    `Miadi ${name.replace('miadi-', '').replace(/-/g, ' ')} operation`,
-    {
-      persona: z.string().optional().describe('Agent persona'),
-      mode: z.string().optional().describe('Agent mode'),
-      text: z.string().optional().describe('Text input')
-    },
-    handler
-  );
-});
-
-// AI tools
-Object.entries(aiTools).forEach(([name, handler]) => {
-  registerMiadiTool(
-    name,
-    `Miadi ${name.replace('miadi-', '').replace(/-/g, ' ')} operation`,
-    {
-      prompt: z.string().optional().describe('AI prompt'),
-      model: z.string().optional().describe('AI model'),
-      messages: z.array(z.any()).optional().describe('Chat messages')
-    },
-    handler
-  );
-});
-
-// Workflow tools
-Object.entries(workflowTools).forEach(([name, handler]) => {
-  registerMiadiTool(
-    name,
-    `Miadi ${name.replace('miadi-', '').replace(/-/g, ' ')} operation`,
-    {
-      agent: z.string().optional().describe('Agent identifier'),
-      event: z.string().optional().describe('Event type'),
-      data: z.any().optional().describe('Event data')
-    },
-    handler
-  );
-});
-
-// Forge tools
-Object.entries(forgeTools).forEach(([name, handler]) => {
-  registerMiadiTool(
-    name,
-    `Miadi ${name.replace('miadi-', '').replace(/-/g, ' ')} operation`,
-    {
-      state: z.any().optional().describe('Forge state'),
-      glyph: z.string().optional().describe('Glyph identifier'),
-      operation: z.string().optional().describe('Forge operation')
-    },
-    handler
-  );
-});
-
-// Count registered tools
-const allTools = {
-  ...memoryTools,
-  ...sessionTools, 
-  ...capabilityTools,
-  ...aiTools,
-  ...workflowTools,
-  ...forgeTools
-};
-
-console.log(`✅ Registered ${Object.keys(allTools).length} Miadi tools`);
-
-// Create Express app for HTTP transport
-const app = express();
-const PORT = parseInt(getEnvVar('MCP_PORT', '3330'));
-
-// CORS configuration for Claude.ai
-app.use(cors({
-  origin: [
-    'https://claude.ai',
-    'https://api.claude.ai',
-    'https://app.claude.ai',
-    /\.ngrok\.io$/,
-    /\.ngrok-free\.app$/
-  ],
-  credentials: true,
-  methods: ['GET', 'POST', 'DELETE', 'OPTIONS'],
-  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With', 'Mcp-Session-Id']
-}));
-
-app.use(express.json({ limit: '10mb' }));
-
-// Health check endpoint
-app.get('/health', (req, res) => {
-  res.json({
-    status: 'healthy',
-    server: 'miadi-mcp-official',
-    version: '1.0.0',
-    tools: Object.keys(allTools).length,
-    timestamp: new Date().toISOString()
-  });
-});
-
-// Root info endpoint
-app.get('/', (req, res) => {
-  res.json({
-    name: 'miadi-mcp-official',
-    version: '1.0.0',
-    description: 'Miadi Three-Pathway Agent System MCP Server (Official SDK)',
-    tools: Object.keys(allTools).length,
-    endpoints: {
-      health: '/health',
-      mcp: '/mcp'
-    },
-    sdk: 'Official MCP TypeScript SDK'
-  });
-});
-
-// Create StreamableHTTP transport
-const transport = new StreamableHTTPServerTransport({
-  sessionIdGenerator: () => randomUUID(),
-});
-
-// Store transports by session ID (for session management)
-const transports: { [sessionId: string]: StreamableHTTPServerTransport } = {};
-
-// MCP endpoint handler
-const handleMcpRequest = async (req: express.Request, res: express.Response) => {
-  const sessionId = req.headers['mcp-session-id'] as string | undefined;
-  
-  if (sessionId) {
-    console.log(`[MCP] Request for session: ${sessionId}`);
-  } else {
-    console.log('[MCP] New request:', req.body?.method || 'unknown');
-  }
-
-  try {
-    let currentTransport: StreamableHTTPServerTransport;
-
-    if (sessionId && transports[sessionId]) {
-      // Use existing transport for this session
-      currentTransport = transports[sessionId];
-    } else {
-      // Create new transport and connect to server
-      currentTransport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-        onsessioninitialized: (sessionId) => {
-          console.log(`[MCP] Session initialized: ${sessionId}`);
-          transports[sessionId] = currentTransport;
-        }
-      });
-
-      // Set up cleanup handler
-      currentTransport.onclose = () => {
-        const sid = currentTransport.sessionId;
-        if (sid && transports[sid]) {
-          console.log(`[MCP] Session ${sid} closed`);
-          delete transports[sid];
-        }
-      };
-
-      // Connect server to transport
-      await server.connect(currentTransport);
-    }
-
-    // Handle the request using SDK transport
-    await currentTransport.handleRequest(req, res, req.body);
-
-  } catch (error: any) {
-    console.error('[MCP] Request error:', error);
-    if (!res.headersSent) {
-      res.status(500).json({
-        jsonrpc: '2.0',
-        id: req.body?.id || null,
-        error: {
-          code: -32603,
-          message: 'Internal server error',
-          data: error.message
-        }
-      });
-    }
-  }
-};
-
-// Set up MCP endpoints
-app.post('/mcp', handleMcpRequest);
-app.get('/mcp', handleMcpRequest);
-app.delete('/mcp', handleMcpRequest);
-
-// Start server
-app.listen(PORT, '0.0.0.0', () => {
-  console.log(`🚀 Miadi MCP Official Server listening on http://0.0.0.0:${PORT}`);
-  console.log(`📡 MCP endpoint: http://0.0.0.0:${PORT}/mcp`);
-  console.log(`🔧 ${Object.keys(allTools).length} Miadi tools registered and ready`);
-  console.log(`✨ Using official MCP TypeScript SDK patterns`);
-});
-
-// Graceful shutdown
-process.on('SIGINT', async () => {
-  console.log('\n🛑 Shutting down server...');
-  
-  // Close all active transports
-  for (const sessionId in transports) {
-    try {
-      console.log(`Closing transport for session ${sessionId}`);
-      await transports[sessionId].close();
-      delete transports[sessionId];
-    } catch (error) {
-      console.error(`Error closing transport for session ${sessionId}:`, error);
-    }
-  }
-  
-  console.log('✅ Server shutdown complete');
-  process.exit(0);
-});

package/src/index-simple.ts

@@ -1,232 +0,0 @@
-#!/usr/bin/env node
-
-import express from 'express';
-import cors from 'cors';
-import { randomUUID } from 'node:crypto';
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { z } from "zod";
-
-import { getEnvVar } from './utils.js';
-import { memoryTools } from './tools/memory-tools.js';
-
-// Validate environment variables
-try {
-  getEnvVar('EH_TOKEN');
-  getEnvVar('EH_API_URL');
-  console.log('✅ Environment variables validated');
-} catch (error: any) {
-  console.error('❌ Environment validation failed:', error.message);
-  process.exit(1);
-}
-
-// Create MCP server instance - EXACTLY like the guide
-const server = new McpServer({
-  name: 'miadi-mcp-server',
-  version: '1.0.0'
-}, {
-  capabilities: {
-    tools: {},
-    resources: {},
-    prompts: {}
-  }
-});
-
-// DIRECT TOOL REGISTRATION - Following the guide exactly
-server.registerTool('collectMemory', {
-  description: 'Collect specific memory values by keys',
-  inputSchema: {
-    keys: z.array(z.string()).describe('Array of memory keys to collect')
-  }
-}, async ({ keys }) => {
-  try {
-    console.log('[collectMemory] Called with keys:', keys);
-    const result = await memoryTools.collectMemory(keys);
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify(result, null, 2)
-      }]
-    };
-  } catch (error: any) {
-    console.error('[collectMemory] Error:', error);
-    return {
-      content: [{
-        type: 'text',
-        text: `Error: ${error.message}`
-      }]
-    };
-  }
-});
-
-server.registerTool('getMemory', {
-  description: 'Retrieve memory data from Redis storage',
-  inputSchema: {
-    key: z.string().describe('Memory key to retrieve'),
-    list: z.boolean().optional().describe('List mode'),
-    pattern: z.string().optional().describe('Pattern matching'),
-    type: z.enum(['auto', 'string', 'hash', 'list', 'set', 'zset']).optional().describe('Redis data type')
-  }
-}, async ({ key, list, pattern, type }) => {
-  try {
-    const result = await memoryTools.getMemory(key, list, pattern, type);
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify(result, null, 2)
-      }]
-    };
-  } catch (error: any) {
-    return {
-      content: [{
-        type: 'text', 
-        text: `Error: ${error.message}`
-      }]
-    };
-  }
-});
-
-server.registerTool('gatherMemoryValues', {
-  description: 'Gather memory values using pattern matching',
-  inputSchema: {
-    pattern: z.string().optional().describe('Pattern for key matching'),
-    regex: z.string().optional().describe('Regex for key matching'),
-    limit: z.number().optional().describe('Maximum number of values'),
-    scanLimit: z.number().optional().describe('Maximum keys to scan')
-  }
-}, async ({ pattern, regex, limit, scanLimit }) => {
-  try {
-    const result = await memoryTools.gatherMemoryValues(pattern, regex, limit, scanLimit);
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify(result, null, 2)
-      }]
-    };
-  } catch (error: any) {
-    return {
-      content: [{
-        type: 'text',
-        text: `Error: ${error.message}`
-      }]
-    };
-  }
-});
-
-server.registerTool('scanKeys', {
-  description: 'Scan Redis keys using pattern matching',
-  inputSchema: {
-    pattern: z.string().optional().describe('Pattern for key matching'),
-    regex: z.string().optional().describe('Regex for key matching'), 
-    limit: z.number().optional().describe('Maximum number of keys')
-  }
-}, async ({ pattern, regex, limit }) => {
-  try {
-    const result = await memoryTools.scanKeys(pattern, regex, limit);
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify(result, null, 2)
-      }]
-    };
-  } catch (error: any) {
-    return {
-      content: [{
-        type: 'text',
-        text: `Error: ${error.message}`
-      }]
-    };
-  }
-});
-
-// Create Express app - EXACTLY like the guide
-const app = express();
-const PORT = parseInt(getEnvVar('MCP_PORT', '3330'));
-
-// Essential CORS for Claude.ai - EXACTLY like the guide
-app.use(cors({
-  origin: [
-    'https://claude.ai',
-    'https://api.claude.ai',
-    'https://app.claude.ai',
-    /\.ngrok\.io$/,
-    /\.ngrok-free\.app$/
-  ],
-  credentials: true,
-  methods: ['GET', 'POST', 'DELETE', 'OPTIONS'],
-  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With', 'Mcp-Session-Id']
-}));
-
-app.use(express.json({ limit: '10mb' }));
-
-// Health check
-app.get('/health', (req, res) => {
-  res.json({
-    status: 'healthy',
-    server: 'miadi-mcp-server',
-    version: '1.0.0',
-    timestamp: new Date().toISOString()
-  });
-});
-
-// Session management - EXACTLY like the guide
-const transports: { [sessionId: string]: StreamableHTTPServerTransport } = {};
-
-// MCP endpoint handler - EXACTLY like the guide
-const handleMcpRequest = async (req: express.Request, res: express.Response) => {
-  const sessionId = req.headers['mcp-session-id'] as string | undefined;
-
-  try {
-    let currentTransport: StreamableHTTPServerTransport;
-
-    if (sessionId && transports[sessionId]) {
-      currentTransport = transports[sessionId];
-    } else {
-      currentTransport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-        onsessioninitialized: (sessionId) => {
-          console.log(`[MCP] Session initialized: ${sessionId}`);
-          transports[sessionId] = currentTransport;
-        }
-      });
-
-      currentTransport.onclose = () => {
-        const sid = currentTransport.sessionId;
-        if (sid && transports[sid]) {
-          delete transports[sid];
-          console.log(`[MCP] Session closed: ${sid}`);
-        }
-      };
-
-      await server.connect(currentTransport);
-    }
-
-    // Let the SDK handle the request - DON'T PARSE JSON-RPC MANUALLY
-    await currentTransport.handleRequest(req, res, req.body);
-
-  } catch (error: any) {
-    console.error('[MCP] Request error:', error);
-    if (!res.headersSent) {
-      res.status(500).json({
-        jsonrpc: '2.0',
-        id: req.body?.id || null,
-        error: {
-          code: -32603,
-          message: 'Internal server error'
-        }
-      });
-    }
-  }
-};
-
-// Set up MCP endpoints - EXACTLY like the guide
-app.post('/mcp', handleMcpRequest);
-app.get('/mcp', handleMcpRequest);
-app.delete('/mcp', handleMcpRequest);
-
-// Start server
-app.listen(PORT, '0.0.0.0', () => {
-  console.log(`🚀 Simple MCP Server listening on http://0.0.0.0:${PORT}`);
-  console.log(`📡 MCP endpoint: http://0.0.0.0:${PORT}/mcp`);
-  console.log(`📋 Tools registered: collectMemory, getMemory, gatherMemoryValues, scanKeys`);
-});