@dcode-dev/dcode-cli 1.0.0

package/internal/mcp/client.go

@@ -0,0 +1,314 @@
+package mcp
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+)
+
+// MCPClient handles communication with MCP servers
+type MCPClient struct {
+	serverURL  string
+	httpClient *http.Client
+	headers    map[string]string
+}
+
+// NewMCPClient creates a new MCP client
+func NewMCPClient(serverURL string) *MCPClient {
+	return &MCPClient{
+		serverURL: serverURL,
+		httpClient: &http.Client{
+			Timeout: 30 * time.Second,
+		},
+		headers: make(map[string]string),
+	}
+}
+
+// SetHeader sets a custom header
+func (c *MCPClient) SetHeader(key, value string) {
+	c.headers[key] = value
+}
+
+// MCPRequest represents a request to an MCP server
+type MCPRequest struct {
+	Method string                 `json:"method"`
+	Params map[string]interface{} `json:"params,omitempty"`
+}
+
+// MCPResponse represents a response from an MCP server
+type MCPResponse struct {
+	Result interface{}            `json:"result,omitempty"`
+	Error  *MCPError              `json:"error,omitempty"`
+	Meta   map[string]interface{} `json:"meta,omitempty"`
+}
+
+// MCPError represents an error from an MCP server
+type MCPError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    interface{} `json:"data,omitempty"`
+}
+
+// ListTools lists all tools available on the MCP server
+func (c *MCPClient) ListTools(ctx context.Context) ([]MCPTool, error) {
+	req := &MCPRequest{
+		Method: "tools/list",
+	}
+	
+	resp, err := c.call(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	
+	if resp.Error != nil {
+		return nil, fmt.Errorf("MCP error: %s", resp.Error.Message)
+	}
+	
+	// Parse tools from result
+	toolsData, ok := resp.Result.(map[string]interface{})
+	if !ok {
+		return nil, fmt.Errorf("unexpected response format")
+	}
+	
+	toolsList, ok := toolsData["tools"].([]interface{})
+	if !ok {
+		return nil, fmt.Errorf("tools not found in response")
+	}
+	
+	tools := make([]MCPTool, 0, len(toolsList))
+	for _, t := range toolsList {
+		toolMap, ok := t.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		
+		tool := MCPTool{
+			Name:        getString(toolMap, "name"),
+			Description: getString(toolMap, "description"),
+			InputSchema: toolMap["inputSchema"],
+		}
+		tools = append(tools, tool)
+	}
+	
+	return tools, nil
+}
+
+// CallTool calls a tool on the MCP server
+func (c *MCPClient) CallTool(ctx context.Context, toolName string, params map[string]interface{}) (interface{}, error) {
+	req := &MCPRequest{
+		Method: "tools/call",
+		Params: map[string]interface{}{
+			"name":      toolName,
+			"arguments": params,
+		},
+	}
+	
+	resp, err := c.call(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	
+	if resp.Error != nil {
+		return nil, fmt.Errorf("MCP error: %s", resp.Error.Message)
+	}
+	
+	return resp.Result, nil
+}
+
+// ListResources lists all resources available on the MCP server
+func (c *MCPClient) ListResources(ctx context.Context) ([]MCPResource, error) {
+	req := &MCPRequest{
+		Method: "resources/list",
+	}
+	
+	resp, err := c.call(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	
+	if resp.Error != nil {
+		return nil, fmt.Errorf("MCP error: %s", resp.Error.Message)
+	}
+	
+	// Parse resources
+	resourcesData, ok := resp.Result.(map[string]interface{})
+	if !ok {
+		return nil, fmt.Errorf("unexpected response format")
+	}
+	
+	resourcesList, ok := resourcesData["resources"].([]interface{})
+	if !ok {
+		return nil, fmt.Errorf("resources not found in response")
+	}
+	
+	resources := make([]MCPResource, 0, len(resourcesList))
+	for _, r := range resourcesList {
+		resMap, ok := r.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		
+		resource := MCPResource{
+			URI:         getString(resMap, "uri"),
+			Name:        getString(resMap, "name"),
+			Description: getString(resMap, "description"),
+			MimeType:    getString(resMap, "mimeType"),
+		}
+		resources = append(resources, resource)
+	}
+	
+	return resources, nil
+}
+
+// ListPrompts lists all prompts available on the MCP server
+func (c *MCPClient) ListPrompts(ctx context.Context) ([]MCPPrompt, error) {
+	req := &MCPRequest{
+		Method: "prompts/list",
+	}
+	
+	resp, err := c.call(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	
+	if resp.Error != nil {
+		return nil, fmt.Errorf("MCP error: %s", resp.Error.Message)
+	}
+	
+	// Parse prompts
+	promptsData, ok := resp.Result.(map[string]interface{})
+	if !ok {
+		return nil, fmt.Errorf("unexpected response format")
+	}
+	
+	promptsList, ok := promptsData["prompts"].([]interface{})
+	if !ok {
+		return nil, fmt.Errorf("prompts not found in response")
+	}
+	
+	prompts := make([]MCPPrompt, 0, len(promptsList))
+	for _, p := range promptsList {
+		promptMap, ok := p.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		
+		prompt := MCPPrompt{
+			Name:        getString(promptMap, "name"),
+			Description: getString(promptMap, "description"),
+		}
+		
+		// Parse arguments if present
+		if argsData, ok := promptMap["arguments"].([]interface{}); ok {
+			prompt.Arguments = make([]MCPPromptArg, 0, len(argsData))
+			for _, a := range argsData {
+				argMap, ok := a.(map[string]interface{})
+				if !ok {
+					continue
+				}
+				arg := MCPPromptArg{
+					Name:        getString(argMap, "name"),
+					Description: getString(argMap, "description"),
+					Required:    getBool(argMap, "required"),
+				}
+				prompt.Arguments = append(prompt.Arguments, arg)
+			}
+		}
+		
+		prompts = append(prompts, prompt)
+	}
+	
+	return prompts, nil
+}
+
+// call makes a call to the MCP server
+func (c *MCPClient) call(ctx context.Context, req *MCPRequest) (*MCPResponse, error) {
+	// Marshal request
+	reqData, err := json.Marshal(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
+	}
+	
+	// Create HTTP request
+	httpReq, err := http.NewRequestWithContext(ctx, "POST", c.serverURL, io.NopCloser(nil))
+	httpReq.Body = io.NopCloser(io.Reader(nil))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	
+	// Set headers
+	httpReq.Header.Set("Content-Type", "application/json")
+	for k, v := range c.headers {
+		httpReq.Header.Set(k, v)
+	}
+	
+	_ = reqData // Use the marshaled data in production
+	
+	// Send request
+	httpResp, err := c.httpClient.Do(httpReq)
+	if err != nil {
+		return nil, fmt.Errorf("request failed: %w", err)
+	}
+	defer httpResp.Body.Close()
+	
+	// Read response
+	respData, err := io.ReadAll(httpResp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+	
+	// Unmarshal response
+	var resp MCPResponse
+	if err := json.Unmarshal(respData, &resp); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+	
+	return &resp, nil
+}
+
+// Helper functions
+func getString(m map[string]interface{}, key string) string {
+	if v, ok := m[key].(string); ok {
+		return v
+	}
+	return ""
+}
+
+func getBool(m map[string]interface{}, key string) bool {
+	if v, ok := m[key].(bool); ok {
+		return v
+	}
+	return false
+}
+
+// MCPTool represents a tool from an MCP server
+type MCPTool struct {
+	Name        string      `json:"name"`
+	Description string      `json:"description"`
+	InputSchema interface{} `json:"inputSchema"`
+}
+
+// MCPResource represents a resource from an MCP server
+type MCPResource struct {
+	URI         string `json:"uri"`
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	MimeType    string `json:"mimeType"`
+}
+
+// MCPPrompt represents a prompt from an MCP server
+type MCPPrompt struct {
+	Name        string          `json:"name"`
+	Description string          `json:"description"`
+	Arguments   []MCPPromptArg  `json:"arguments,omitempty"`
+}
+
+// MCPPromptArg represents a prompt argument
+type MCPPromptArg struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Required    bool   `json:"required"`
+}

package/internal/mcp/manager.go

@@ -0,0 +1,221 @@
+package mcp
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// MCPServer represents a configured MCP server
+type MCPServer struct {
+	ID          string                 `json:"id"`
+	Name        string                 `json:"name"`
+	URL         string                 `json:"url"`
+	Enabled     bool                   `json:"enabled"`
+	Config      map[string]interface{} `json:"config,omitempty"`
+	client      *MCPClient
+}
+
+// MCPManager manages multiple MCP server connections
+type MCPManager struct {
+	servers      map[string]*MCPServer
+	toolRegistry *registry.ToolRegistry
+	mu           sync.RWMutex
+}
+
+// NewMCPManager creates a new MCP manager
+func NewMCPManager(toolRegistry *registry.ToolRegistry) *MCPManager {
+	return &MCPManager{
+		servers:      make(map[string]*MCPServer),
+		toolRegistry: toolRegistry,
+	}
+}
+
+// AddServer adds a new MCP server
+func (m *MCPManager) AddServer(server *MCPServer) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	
+	if _, exists := m.servers[server.ID]; exists {
+		return fmt.Errorf("server %s already exists", server.ID)
+	}
+	
+	// Create client
+	server.client = NewMCPClient(server.URL)
+	
+	m.servers[server.ID] = server
+	return nil
+}
+
+// RemoveServer removes an MCP server
+func (m *MCPManager) RemoveServer(serverID string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	
+	server, exists := m.servers[serverID]
+	if !exists {
+		return fmt.Errorf("server %s not found", serverID)
+	}
+	
+	// Unregister all tools from this server
+	if err := m.unregisterServerTools(server); err != nil {
+		return fmt.Errorf("failed to unregister tools: %w", err)
+	}
+	
+	delete(m.servers, serverID)
+	return nil
+}
+
+// EnableServer enables an MCP server
+func (m *MCPManager) EnableServer(serverID string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	
+	server, exists := m.servers[serverID]
+	if !exists {
+		return fmt.Errorf("server %s not found", serverID)
+	}
+	
+	server.Enabled = true
+	
+	// Discover and register tools
+	return m.discoverAndRegisterTools(server)
+}
+
+// DisableServer disables an MCP server
+func (m *MCPManager) DisableServer(serverID string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	
+	server, exists := m.servers[serverID]
+	if !exists {
+		return fmt.Errorf("server %s not found", serverID)
+	}
+	
+	server.Enabled = false
+	
+	// Unregister tools
+	return m.unregisterServerTools(server)
+}
+
+// ListServers lists all configured MCP servers
+func (m *MCPManager) ListServers() []*MCPServer {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	
+	servers := make([]*MCPServer, 0, len(m.servers))
+	for _, server := range m.servers {
+		servers = append(servers, server)
+	}
+	
+	return servers
+}
+
+// GetServer gets a specific server
+func (m *MCPManager) GetServer(serverID string) (*MCPServer, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	
+	server, exists := m.servers[serverID]
+	if !exists {
+		return nil, fmt.Errorf("server %s not found", serverID)
+	}
+	
+	return server, nil
+}
+
+// DiscoverAll discovers tools from all enabled servers
+func (m *MCPManager) DiscoverAll(ctx context.Context) error {
+	m.mu.RLock()
+	servers := make([]*MCPServer, 0)
+	for _, server := range m.servers {
+		if server.Enabled {
+			servers = append(servers, server)
+		}
+	}
+	m.mu.RUnlock()
+	
+	for _, server := range servers {
+		if err := m.discoverAndRegisterTools(server); err != nil {
+			// Log error but continue
+			fmt.Printf("Warning: failed to discover tools from %s: %v\n", server.Name, err)
+		}
+	}
+	
+	return nil
+}
+
+// discoverAndRegisterTools discovers tools from a server and registers them
+func (m *MCPManager) discoverAndRegisterTools(server *MCPServer) error {
+	ctx := context.Background()
+	
+	// List tools from MCP server
+	tools, err := server.client.ListTools(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to list tools: %w", err)
+	}
+	
+	// Register each tool
+	for _, mcpTool := range tools {
+		toolDef := &registry.ToolDefinition{
+			ID:          fmt.Sprintf("mcp_%s_%s", server.ID, mcpTool.Name),
+			Name:        mcpTool.Name,
+			Description: mcpTool.Description,
+			RiskLevel:   "low", // Default to low, could be configured
+			Category:    "mcp",
+			Executor:    m.createMCPToolExecutor(server, mcpTool.Name),
+		}
+		
+		// Register tool (ignore if already exists)
+		if err := m.toolRegistry.Register(toolDef); err != nil {
+			// Log but continue
+			fmt.Printf("Warning: failed to register tool %s: %v\n", toolDef.ID, err)
+		}
+	}
+	
+	return nil
+}
+
+// unregisterServerTools unregisters all tools from a server
+func (m *MCPManager) unregisterServerTools(server *MCPServer) error {
+	// Get all tools
+	allTools := m.toolRegistry.List()
+	
+	// Find and unregister tools from this server
+	prefix := fmt.Sprintf("mcp_%s_", server.ID)
+	for _, tool := range allTools {
+		if len(tool.ID) > len(prefix) && tool.ID[:len(prefix)] == prefix {
+			// Unregister would need to be added to registry
+			// For now, just skip
+		}
+	}
+	
+	return nil
+}
+
+// createMCPToolExecutor creates an executor function for an MCP tool
+func (m *MCPManager) createMCPToolExecutor(server *MCPServer, toolName string) func(*registry.ToolInput) (*registry.ToolOutput, error) {
+	return func(input *registry.ToolInput) (*registry.ToolOutput, error) {
+		ctx := context.Background()
+		
+		// Call the MCP tool
+		result, err := server.client.CallTool(ctx, toolName, input.Parameters)
+		if err != nil {
+			return &registry.ToolOutput{
+				Success: false,
+				Error:   err.Error(),
+			}, err
+		}
+		
+		return &registry.ToolOutput{
+			Success: true,
+			Data:    result,
+			Metadata: map[string]interface{}{
+				"mcp_server": server.Name,
+				"tool_name":  toolName,
+			},
+		}, nil
+	}
+}

package/internal/policy/policy.go

@@ -0,0 +1,89 @@
+package policy
+
+import (
+	"fmt"
+
+	"github.com/ddhanush1/dcode/internal/config"
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// Policy represents a confirmation policy
+type Policy interface {
+	// Evaluate returns whether a tool execution should be confirmed
+	Evaluate(tool *registry.ToolDefinition, params map[string]interface{}) bool
+	
+	// GetName returns the policy name
+	GetName() string
+}
+
+// AlwaysConfirmPolicy always requires confirmation
+type AlwaysConfirmPolicy struct{}
+
+func (p *AlwaysConfirmPolicy) Evaluate(tool *registry.ToolDefinition, params map[string]interface{}) bool {
+	return true
+}
+
+func (p *AlwaysConfirmPolicy) GetName() string {
+	return "always"
+}
+
+// AutoApprovePolicy auto-approves all tool executions
+type AutoApprovePolicy struct{}
+
+func (p *AutoApprovePolicy) Evaluate(tool *registry.ToolDefinition, params map[string]interface{}) bool {
+	return false
+}
+
+func (p *AutoApprovePolicy) GetName() string {
+	return "auto"
+}
+
+// RiskBasedPolicy evaluates based on risk level
+type RiskBasedPolicy struct {
+	policy *config.PolicyFile
+}
+
+func NewRiskBasedPolicy(policy *config.PolicyFile) *RiskBasedPolicy {
+	return &RiskBasedPolicy{
+		policy: policy,
+	}
+}
+
+func (p *RiskBasedPolicy) Evaluate(tool *registry.ToolDefinition, params map[string]interface{}) bool {
+	riskLevel := p.policy.GetRiskLevel(tool.ID)
+	
+	switch riskLevel {
+	case "low":
+		return !p.policy.RiskBased.AutoApproveLowRisk
+	case "medium":
+		return !p.policy.RiskBased.AutoApproveMediumRisk
+	case "high":
+		return true // Always confirm high risk
+	default:
+		return true // Unknown risk, be safe
+	}
+}
+
+func (p *RiskBasedPolicy) GetName() string {
+	return "risk_based"
+}
+
+// PolicyFactory creates policies based on configuration
+type PolicyFactory struct{}
+
+func NewPolicyFactory() *PolicyFactory {
+	return &PolicyFactory{}
+}
+
+func (f *PolicyFactory) CreatePolicy(policyFile *config.PolicyFile) (Policy, error) {
+	switch policyFile.Mode {
+	case "always":
+		return &AlwaysConfirmPolicy{}, nil
+	case "auto":
+		return &AutoApprovePolicy{}, nil
+	case "risk_based":
+		return NewRiskBasedPolicy(policyFile), nil
+	default:
+		return nil, fmt.Errorf("unknown policy mode: %s", policyFile.Mode)
+	}
+}