miadi 1.0.14 → 2.0.1

package/scripts/start-with-ngrok.sh

@@ -1,140 +0,0 @@
-#!/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

@@ -1,254 +0,0 @@
-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;