miadi 1.0.14

package/scripts/start-with-ngrok.sh

@@ -0,0 +1,140 @@
+#!/bin/bash
+
+# Start Miadi MCP HTTP Server with ngrok tunnel
+# Usage: ./scripts/start-with-ngrok.sh [port]
+
+set -e
+
+PORT=${1:-3330}
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+. .env &>/dev/null || true
+
+echo "🚀 Starting Miadi MCP HTTP Server with ngrok tunnel"
+echo "📍 Project directory: $PROJECT_DIR"
+echo "🌐 Port: $PORT"
+
+# Load environment variables with fallback strategy
+load_environment() {
+    # First check if already set
+    if [[ -n "$EH_TOKEN" && -n "$EH_API_URL" ]]; then
+        echo "✅ Using existing environment variables"
+        return 0
+    fi
+    
+    # Try to source $HOME/.env if it exists
+    if [[ -f "$HOME/.env" ]]; then
+        echo "🔍 Loading environment from $HOME/.env"
+        set -a  # Automatically export all variables
+        source "$HOME/.env"
+        set +a  # Turn off automatic export
+        
+        # Check again after sourcing
+        if [[ -n "$EH_TOKEN" && -n "$EH_API_URL" ]]; then
+            echo "✅ Environment variables loaded from $HOME/.env"
+            return 0
+        fi
+    fi
+    
+    # Final validation
+    if [[ -z "$EH_TOKEN" ]]; then
+        echo "❌ Error: EH_TOKEN environment variable is required"
+        echo "💡 Either export EH_TOKEN or add it to $HOME/.env"
+        exit 1
+    fi
+
+    if [[ -z "$EH_API_URL" ]]; then
+        echo "❌ Error: EH_API_URL environment variable is required"
+        echo "💡 Either export EH_API_URL or add it to $HOME/.env"
+        exit 1
+    fi
+}
+
+# Load environment variables
+load_environment
+
+# Build the working server
+echo "🔨 Building working server with REAL TOOLS..."
+cd "$PROJECT_DIR"
+npm run build:working
+
+# Start the working server in background
+echo "🖥️ Starting working server on port $PORT..."
+export MCP_PORT="$PORT"
+node dist/index-working.js &
+SERVER_PID=$!
+
+# Wait for server to start
+sleep 3
+
+# Check if server is running
+if ! curl -s "http://localhost:$PORT/health" > /dev/null; then
+    echo "❌ Error: HTTP server failed to start"
+    kill $SERVER_PID 2>/dev/null || true
+    exit 1
+fi
+
+echo "✅ HTTP server started successfully"
+
+# Start ngrok tunnel
+echo "🌍 Starting ngrok tunnel..."
+if [[ -n "$NGROK_DOMAIN" ]]; then
+    echo "📍 Using dedicated domain: $NGROK_DOMAIN"
+    ngrok http --url="$NGROK_DOMAIN" $PORT --log=stdout --log-level=info &
+else
+    echo "📍 Using random domain"
+    ngrok http $PORT --log=stdout --log-level=info &
+fi
+NGROK_PID=$!
+
+# Wait for ngrok to start
+sleep 5
+
+# Get ngrok public URL
+if [[ -n "$NGROK_DOMAIN" ]]; then
+    NGROK_URL="https://$NGROK_DOMAIN"
+else
+    NGROK_URL=$(curl -s http://localhost:4040/api/tunnels | jq -r '.tunnels[0].public_url' 2>/dev/null || echo "")
+fi
+
+if [[ -z "$NGROK_URL" || "$NGROK_URL" == "null" ]]; then
+    echo "❌ Error: Failed to get ngrok tunnel URL"
+    echo "🔍 Check ngrok web interface at: http://localhost:4040"
+    echo "📡 Local server: http://localhost:$PORT"
+else
+    echo ""
+    echo "🎉 Miadi MCP Server is ready!"
+    echo "📡 Local URL: http://localhost:$PORT"
+    echo "🌍 Public URL: $NGROK_URL"
+    echo "🔍 Ngrok Dashboard: http://localhost:4040"
+    echo ""
+    echo "📋 Claude.ai Connector Configuration:"
+    echo "   Name: Miadi Agent System"
+    echo "   Base URL: $NGROK_URL"
+    echo "   Description: Access to Miadi Three-Pathway Agent System with 26 tools"
+    echo ""
+    echo "🧪 Test endpoints:"
+    echo "   Health: $NGROK_URL/health"
+    echo "   MCP JSON-RPC: $NGROK_URL/mcp/jsonrpc"
+    echo "   OAuth Metadata: $NGROK_URL/.well-known/oauth-protected-resource"
+    echo "   Dev Token: $NGROK_URL/oauth/dev-token"
+fi
+
+# Cleanup function
+cleanup() {
+    echo ""
+    echo "🛑 Shutting down..."
+    kill $SERVER_PID 2>/dev/null || true
+    kill $NGROK_PID 2>/dev/null || true
+    wait $SERVER_PID 2>/dev/null || true
+    wait $NGROK_PID 2>/dev/null || true
+    echo "✅ Cleanup complete"
+}
+
+# Handle shutdown signals
+trap cleanup SIGINT SIGTERM
+
+echo "🔄 Server running. Press Ctrl+C to stop..."
+
+# Keep script running
+wait $SERVER_PID

package/src/api-client.ts

@@ -0,0 +1,254 @@
+import axios, { AxiosInstance, AxiosError } from 'axios';
+import dotenv from 'dotenv';
+import {
+  ErrorResponse,
+  GetMemoryResponse,
+  StoreMemoryRequest,
+  StoreMemoryResponse,
+  ScanResponse,
+  GatherMemoryResponse,
+  SessionStartRequest,
+  SessionStartResponse,
+  SessionCurrentResponse,
+  SessionSwitchModeRequest,
+  SessionSwitchPersonaRequest,
+  SessionListResponse,
+  CapabilityResolveRequest,
+  CapabilityResolveResponse,
+  AgentInfoResponse,
+  OpenAIRequest,
+  OpenAIResponse,
+  AIRequest,
+  AIResponse,
+  AgentRegisterRequest,
+  AgentRegisterResponse,
+  AgentEventsResponse,
+  WorkflowHowtoResponse,
+  ForgeStateRequest,
+  ForgeStateResponse,
+  ForgeStateUpdateResponse,
+  CueDetectRequest,
+  CueDetectResponse
+} from './types';
+
+dotenv.config();
+
+const EH_API_URL = process.env.EH_API_URL;
+const EH_TOKEN = process.env.EH_TOKEN;
+
+if (!EH_API_URL || !EH_TOKEN) {
+  console.error('Missing EH_API_URL or EH_TOKEN environment variables.');
+  process.exit(1);
+}
+
+const apiClient: AxiosInstance = axios.create({
+  baseURL: EH_API_URL,
+  headers: {
+    'Authorization': `Bearer ${EH_TOKEN}`,
+    'Content-Type': 'application/json',
+  },
+  timeout: 30000, // 30 second timeout
+});
+
+// Response interceptor for error handling
+apiClient.interceptors.response.use(
+  response => response,
+  (error: AxiosError<ErrorResponse>) => {
+    if (error.response) {
+      const status = error.response.status;
+      const errorData = error.response.data;
+      const message = errorData?.message || errorData?.error || `HTTP ${status} error`;
+      console.error(`API Error: ${status} - ${message}`);
+      return Promise.reject(new Error(`API Error (${status}): ${message}`));
+    } else if (error.request) {
+      console.error('No response received from API:', error.request);
+      return Promise.reject(new Error('No response received from Miadi API. Check network connectivity.'));
+    } else {
+      console.error('Error setting up API request:', error.message);
+      return Promise.reject(new Error(`Request setup error: ${error.message}`));
+    }
+  }
+);
+
+export const miadiApi = {
+  // Memory Operations
+  getMemory: async (
+    key?: string,
+    list?: boolean,
+    pattern?: string,
+    type?: 'auto' | 'string' | 'hash' | 'list' | 'set' | 'zset'
+  ): Promise<GetMemoryResponse> => {
+    const params: any = {};
+    if (key) params.key = key;
+    if (list) params.list = list.toString();
+    if (pattern) params.pattern = pattern;
+    if (type) params.type = type;
+    
+    const response = await apiClient.get<GetMemoryResponse>('/api/memory', { params });
+    return response.data;
+  },
+
+  storeMemory: async (data: StoreMemoryRequest): Promise<StoreMemoryResponse> => {
+    const response = await apiClient.post<StoreMemoryResponse>('/api/memory', data);
+    return response.data;
+  },
+
+  updateMemoryTTL: async (key: string, ttl: number): Promise<any> => {
+    const response = await apiClient.post('/api/memory/ttl', { key, ttl });
+    return response.data;
+  },
+
+  getMemoryMeta: async (key: string): Promise<any> => {
+    const response = await apiClient.get('/api/memory/meta', { params: { key } });
+    return response.data;
+  },
+
+  scanKeys: async (pattern?: string, regex?: string, limit?: number): Promise<ScanResponse> => {
+    const params: any = {};
+    if (pattern) params.pattern = pattern;
+    if (regex) params.regex = regex;
+    if (limit) params.limit = limit;
+    
+    const response = await apiClient.get<ScanResponse>('/api/scan', { params });
+    return response.data;
+  },
+
+  gatherMemoryValues: async (
+    pattern?: string,
+    regex?: string,
+    limit?: number,
+    scanLimit?: number
+  ): Promise<GatherMemoryResponse> => {
+    const params: any = {};
+    if (pattern) params.pattern = pattern;
+    if (regex) params.regex = regex;
+    if (limit) params.limit = limit;
+    if (scanLimit) params.scanLimit = scanLimit;
+    
+    const response = await apiClient.get<GatherMemoryResponse>('/api/gather-memory', { params });
+    return response.data;
+  },
+
+  collectMemory: async (keys: string[]): Promise<any> => {
+    const response = await apiClient.post('/api/collect-memory', { keys });
+    return response.data;
+  },
+
+  // Session Management
+  startSession: async (data: SessionStartRequest): Promise<SessionStartResponse> => {
+    const response = await apiClient.post<SessionStartResponse>('/api/session/start', data);
+    return response.data;
+  },
+
+  getCurrentSession: async (sessionId?: string): Promise<SessionCurrentResponse> => {
+    const params: any = {};
+    if (sessionId) params.sessionId = sessionId;
+    
+    const response = await apiClient.get<SessionCurrentResponse>('/api/session/current', { params });
+    return response.data;
+  },
+
+  switchMode: async (data: SessionSwitchModeRequest): Promise<SessionCurrentResponse> => {
+    const response = await apiClient.put<SessionCurrentResponse>('/api/session/switch-mode', data);
+    return response.data;
+  },
+
+  switchPersona: async (data: SessionSwitchPersonaRequest): Promise<SessionCurrentResponse> => {
+    const response = await apiClient.put<SessionCurrentResponse>('/api/session/switch-persona', data);
+    return response.data;
+  },
+
+  endSession: async (sessionId: string): Promise<{ success: boolean; message: string; timestamp: string }> => {
+    const response = await apiClient.delete('/api/session/end', { params: { sessionId } });
+    return response.data;
+  },
+
+  listSessions: async (userId?: string, limit?: number, offset?: number): Promise<SessionListResponse> => {
+    const params: any = {};
+    if (userId) params.userId = userId;
+    if (limit) params.limit = limit;
+    if (offset) params.offset = offset;
+    
+    const response = await apiClient.get<SessionListResponse>('/api/session/list', { params });
+    return response.data;
+  },
+
+  // Capability Resolution
+  resolveCapabilities: async (data: CapabilityResolveRequest): Promise<CapabilityResolveResponse> => {
+    const response = await apiClient.post<CapabilityResolveResponse>('/api/capabilities/resolve', data);
+    return response.data;
+  },
+
+  detectCues: async (data: CueDetectRequest): Promise<CueDetectResponse> => {
+    const response = await apiClient.post<CueDetectResponse>('/api/cues/detect', data);
+    return response.data;
+  },
+
+  // Agent Information
+  getAgentInfo: async (): Promise<AgentInfoResponse> => {
+    const response = await apiClient.get<AgentInfoResponse>('/api/agent-info');
+    return response.data;
+  },
+
+  // AI Integration
+  openaiRequest: async (data: OpenAIRequest): Promise<OpenAIResponse> => {
+    const response = await apiClient.post<OpenAIResponse>('/api/openai', data);
+    return response.data;
+  },
+
+  aiRequest: async (data: AIRequest): Promise<AIResponse> => {
+    const response = await apiClient.post<AIResponse>('/api/ai', data);
+    return response.data;
+  },
+
+  // Workflow Management
+  registerAgent: async (data: AgentRegisterRequest): Promise<AgentRegisterResponse> => {
+    const response = await apiClient.post<AgentRegisterResponse>('/api/workflow/agent-notify', data);
+    return response.data;
+  },
+
+  getAgentEvents: async (agentId: string): Promise<AgentEventsResponse> => {
+    const response = await apiClient.get<AgentEventsResponse>('/api/workflow/agent-notify', {
+      params: { agentId }
+    });
+    return response.data;
+  },
+
+  getWorkflowHowto: async (topic?: string): Promise<WorkflowHowtoResponse | any> => {
+    const params: any = {};
+    if (topic) params.topic = topic;
+    
+    const response = await apiClient.get('/api/workflow/howto', { params });
+    return response.data;
+  },
+
+  // Forge State
+  getForgeState: async (): Promise<ForgeStateResponse> => {
+    const response = await apiClient.get<ForgeStateResponse>('/api/forge-state');
+    return response.data;
+  },
+
+  updateForgeState: async (data: ForgeStateRequest): Promise<ForgeStateUpdateResponse> => {
+    const response = await apiClient.post<ForgeStateUpdateResponse>('/api/forge-state', data);
+    return response.data;
+  },
+
+  // Cluster Operations
+  viewKeyContent: async (key: string): Promise<any> => {
+    const response = await apiClient.get('/api/cluster/view-key', { params: { key } });
+    return response.data;
+  },
+
+  searchCluster: async (term: string): Promise<{ keys: string[] }> => {
+    const response = await apiClient.get('/api/cluster/search', { params: { term } });
+    return response.data;
+  },
+
+  // Glyph Map
+  getGlyphMap: async (): Promise<any> => {
+    const response = await apiClient.get('/api/glyph-map');
+    return response.data;
+  }
+};
+
+export default miadiApi;