1 files changed, 32 insertions, 61 deletions

diff --git a/cmd/server/main.go b/cmd/server/main.go
index 532a059..870bd7c 100644
--- a/cmd/server/main.go
+++ b/cmd/server/main.go
@@ -1,80 +1,51 @@
 package main
 
 import (
-	"context"
-	"fmt"
 	"log"
-	"net"
+	"net/http"
+	"os"
 
+	mux "github.com/gorilla/mux"
 	"github.com/ketsuna-org/sovrabase/internal/config"
-	pb "github.com/ketsuna-org/sovrabase/pkg/proto"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
+	"github.com/ketsuna-org/sovrabase/internal/middleware"
 )
 
-type server struct {
-	pb.UnimplementedForwardCommandServiceServer
-	nodeClients map[string]pb.ForwardCommandServiceClient
-}
-
-func (s *server) ForwardCommand(ctx context.Context, req *pb.ForwardCommandRequest) (*pb.ForwardCommandResponse, error) {
-	log.Printf("Received command: %s for node: %s", req.Command, req.TargetNode)
-
-	// Si c'est pour ce node, traiter localement
-	if req.TargetNode == "" || req.TargetNode == "self" {
-		return &pb.ForwardCommandResponse{
-			Success: true,
-			Result:  fmt.Sprintf("Command '%s' executed locally", req.Command),
-		}, nil
+func main() {
+	// Get config path from environment variable or use default
+	configPath := os.Getenv("CONFIG_PATH")
+	if configPath == "" {
+		configPath = "config.yaml"
 	}
 
-	// Sinon, forwarder au node cible
-	if client, exists := s.nodeClients[req.TargetNode]; exists {
-		resp, err := client.ForwardCommand(ctx, req)
-		if err != nil {
-			return &pb.ForwardCommandResponse{
-				Success:      false,
-				ErrorMessage: fmt.Sprintf("Failed to forward to %s: %v", req.TargetNode, err),
-			}, nil
-		}
-		return resp, nil
+	cfg, err := config.LoadConfig(configPath)
+	if err != nil {
+		log.Fatalf("failed to load config from %s: %v", configPath, err)
 	}
 
-	// Node inconnu
-	return &pb.ForwardCommandResponse{
-		Success:      false,
-		ErrorMessage: fmt.Sprintf("Unknown target node: %s", req.TargetNode),
-	}, nil
-}
+	// Setup HTTP Server
 
-func main() {
-	cfg, err := config.LoadConfig("config.toml")
-	if err != nil {
-		log.Fatalf("failed to load config: %v", err)
+	router := mux.NewRouter()
+	log.Printf("Starting API server on %s", cfg.API.APIAddr)
+	if cfg.API.Domain != "" {
+		log.Printf("  - Configured domain: %s", cfg.API.Domain)
 	}
-
-	// Initialiser les connexions aux autres nodes
-	nodeClients := make(map[string]pb.ForwardCommandServiceClient)
-	for _, addr := range cfg.Cluster.RPCServers {
-		if addr != cfg.RPC.RPCAddr { // Ne pas se connecter à soi-même
-			conn, err := grpc.NewClient(addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
-			if err != nil {
-				log.Printf("Failed to connect to node %s: %v", addr, err)
-				continue
-			}
-			nodeClients[addr] = pb.NewForwardCommandServiceClient(conn)
-			log.Printf("Connected to node: %s", addr)
-		}
+	if len(cfg.API.CORSAllow) > 0 {
+		log.Printf("  - CORS allowed origins: %v", cfg.API.CORSAllow)
 	}
 
-	lis, err := net.Listen("tcp", cfg.RPC.RPCAddr)
-	if err != nil {
-		log.Fatalf("failed to listen: %v", err)
+	// Appliquer le middleware CORS
+	corsConfig := &middleware.CORSConfig{
+		Domain:         cfg.API.Domain,
+		AllowedOrigins: cfg.API.CORSAllow,
 	}
-	s := grpc.NewServer()
-	pb.RegisterForwardCommandServiceServer(s, &server{nodeClients: nodeClients})
-	log.Printf("server listening at %v", lis.Addr())
-	if err := s.Serve(lis); err != nil {
-		log.Fatalf("failed to serve: %v", err)
+	router.Use(middleware.CORSMiddleware(corsConfig))
+
+	router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("Sovrabase API is running"))
+	})
+
+	if err := http.ListenAndServe(cfg.API.APIAddr, router); err != nil {
+		log.Fatalf("failed to start API server: %v", err)
 	}
 }