whatsapp-rpc 0.0.4

package/src/go/cmd/server/main.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/sirupsen/logrus"
+
+	"whatsapp-rpc/src/go/config"
+	server "whatsapp-rpc/src/go/rpc"
+	"whatsapp-rpc/src/go/whatsapp"
+)
+
+func main() {
+	// Initialize logger
+	logger := logrus.New()
+	logger.SetFormatter(&logrus.TextFormatter{
+		FullTimestamp: true,
+	})
+
+	// Load configuration
+	cfg, err := config.Load()
+	if err != nil {
+		logger.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Set log level (5 = Debug, 4 = Info)
+	if cfg.LogLevel >= 5 {
+		logger.SetLevel(logrus.DebugLevel)
+	}
+
+	logger.Info("Starting WhatsApp WebSocket RPC Server")
+
+	// Initialize WhatsApp service
+	whatsappService, err := whatsapp.NewService(cfg.Database, logger)
+	if err != nil {
+		logger.Fatalf("Failed to initialize WhatsApp service: %v", err)
+	}
+
+	// Auto-start if there's an existing session (no need to press Start button)
+	if whatsappService.HasExistingSession() {
+		logger.Info("Existing session found, auto-connecting...")
+		if err := whatsappService.Start(); err != nil {
+			logger.Warnf("Auto-start failed: %v (user can manually start)", err)
+		}
+	} else {
+		logger.Info("No existing session, waiting for user to start pairing")
+	}
+
+	// Create and start server (WebSocket RPC only)
+	srv := server.New(whatsappService, logger)
+	router := srv.SetupRoutes()
+
+	httpServer := &http.Server{
+		Addr:    fmt.Sprintf(":%d", cfg.Server.Port),
+		Handler: router,
+	}
+
+	// Start server in goroutine
+	go func() {
+		logger.Infof("WebSocket RPC server listening on port %d", cfg.Server.Port)
+		logger.Infof("Connect via: ws://localhost:%d/ws/rpc", cfg.Server.Port)
+		if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logger.Fatalf("Server error: %v", err)
+		}
+	}()
+
+	// Wait for interrupt signal
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+
+	logger.Info("Shutting down server...")
+
+	// Graceful shutdown
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	whatsappService.Shutdown()
+
+	if err := httpServer.Shutdown(ctx); err != nil {
+		logger.Errorf("Server shutdown error: %v", err)
+	}
+
+	logger.Info("Server stopped")
+}

package/src/go/config/config.go

@@ -0,0 +1,49 @@
+package config
+
+import (
+	"github.com/spf13/viper"
+)
+
+type Config struct {
+	Environment string         `mapstructure:"environment"`
+	LogLevel    int            `mapstructure:"log_level"`
+	Server      ServerConfig   `mapstructure:"server"`
+	Database    DatabaseConfig `mapstructure:"database"`
+}
+
+type ServerConfig struct {
+	Port int    `mapstructure:"port"`
+	Host string `mapstructure:"host"`
+}
+
+type DatabaseConfig struct {
+	Path string `mapstructure:"path"`
+}
+
+func Load() (*Config, error) {
+	viper.SetDefault("environment", "development")
+	viper.SetDefault("log_level", 4) // Info level
+	viper.SetDefault("server.port", 9400)
+	viper.SetDefault("server.host", "0.0.0.0")
+	viper.SetDefault("database.path", "data/whatsapp.db")
+
+	// Environment variables
+	viper.SetEnvPrefix("WA")
+	viper.AutomaticEnv()
+
+	// Config file
+	viper.SetConfigName("config")
+	viper.SetConfigType("yaml")
+	viper.AddConfigPath(".")
+	viper.AddConfigPath("./configs")
+
+	// Read config file (optional)
+	viper.ReadInConfig()
+
+	var config Config
+	if err := viper.Unmarshal(&config); err != nil {
+		return nil, err
+	}
+
+	return &config, nil
+}

package/src/go/rpc/rpc.go

@@ -0,0 +1,446 @@
+package server
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"os"
+	"sync"
+
+	"github.com/gorilla/websocket"
+	"github.com/sirupsen/logrus"
+
+	"whatsapp-rpc/src/go/whatsapp"
+)
+
+// JSON-RPC 2.0 message types
+type RPCRequest struct {
+	JSONRPC string          `json:"jsonrpc"`
+	ID      interface{}     `json:"id,omitempty"`
+	Method  string          `json:"method"`
+	Params  json.RawMessage `json:"params,omitempty"`
+}
+
+type RPCResponse struct {
+	JSONRPC string      `json:"jsonrpc"`
+	ID      interface{} `json:"id,omitempty"`
+	Result  interface{} `json:"result,omitempty"`
+	Error   *RPCError   `json:"error,omitempty"`
+}
+
+type RPCError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+// RPCHandler processes JSON-RPC requests
+type RPCHandler struct {
+	service *whatsapp.Service
+	logger  *logrus.Logger
+}
+
+// NewRPCHandler creates a new RPC handler
+func NewRPCHandler(service *whatsapp.Service, logger *logrus.Logger) *RPCHandler {
+	return &RPCHandler{
+		service: service,
+		logger:  logger,
+	}
+}
+
+// HandleRequest processes a JSON-RPC request and returns a response
+func (h *RPCHandler) HandleRequest(req *RPCRequest) RPCResponse {
+	resp := RPCResponse{JSONRPC: "2.0", ID: req.ID}
+
+	switch req.Method {
+	case "status":
+		resp.Result = h.service.GetStatus()
+
+	case "start":
+		if err := h.service.Start(); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]string{"message": "Started"}
+		}
+
+	case "stop":
+		h.service.Shutdown()
+		resp.Result = map[string]string{"message": "Stopped"}
+
+	case "restart":
+		// Full restart: cleanup QR codes, reset session, then start fresh
+		h.service.CleanupQRCodes()
+		if err := h.service.Reset(); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else if err := h.service.Start(); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]string{"message": "Restarted (session cleared)"}
+		}
+
+	case "reset":
+		if err := h.service.Reset(); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]string{"message": "Reset"}
+		}
+
+	case "diagnostics":
+		resp.Result = h.service.GetDiagnostics()
+
+	case "qr":
+		if qr := h.service.GetCurrentQRCode(); qr != nil {
+			result := map[string]interface{}{
+				"has_qr":   true,
+				"code":     qr.Code,
+				"filename": qr.Filename,
+			}
+			// Read PNG file and encode to base64 for Docker compatibility
+			// qr.Filename already contains full path like "data/qr/qr_xxx.png"
+			if data, err := os.ReadFile(qr.Filename); err == nil {
+				result["image_data"] = base64.StdEncoding.EncodeToString(data)
+			}
+			resp.Result = result
+		} else {
+			resp.Error = &RPCError{Code: -32001, Message: "No QR available"}
+		}
+
+	case "send":
+		var msgReq whatsapp.MessageRequest
+		if err := json.Unmarshal(req.Params, &msgReq); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if err := h.service.SendEnhancedMessage(&msgReq); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]string{"message": "Sent"}
+		}
+
+	case "media":
+		var p struct {
+			MessageID string `json:"message_id"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if data, mime, err := h.service.DownloadMedia(p.MessageID); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]interface{}{
+				"data":      data,
+				"mime_type": mime,
+			}
+		}
+
+	case "groups":
+		if groups, err := h.service.GetGroups(); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = groups
+		}
+
+	case "group_info":
+		var p struct {
+			GroupID string `json:"group_id"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.GroupID == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "group_id is required"}
+		} else if info, err := h.service.GetGroupInfo(p.GroupID); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = info
+		}
+
+	case "group_update":
+		var p whatsapp.GroupUpdateRequest
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.GroupID == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "group_id is required"}
+		} else if p.Name == "" && p.Topic == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "name or topic is required"}
+		} else if err := h.service.UpdateGroupInfo(p.GroupID, p.Name, p.Topic); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]string{"message": "Updated"}
+		}
+
+	case "contact_check":
+		var p struct {
+			Phones []string `json:"phones"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if len(p.Phones) == 0 {
+			resp.Error = &RPCError{Code: -32602, Message: "phones array is required and must not be empty"}
+		} else if results, err := h.service.CheckContacts(p.Phones); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = results
+		}
+
+	case "contact_profile_pic":
+		var p struct {
+			JID     string `json:"jid"`
+			Preview bool   `json:"preview"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.JID == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "jid is required"}
+		} else if result, err := h.service.GetProfilePicture(p.JID, p.Preview); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = result
+		}
+
+	case "contacts":
+		var p struct {
+			Query string `json:"query"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			// If params parsing fails, use empty query (list all)
+			p.Query = ""
+		}
+		if contacts, err := h.service.GetContacts(p.Query); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]interface{}{
+				"contacts": contacts,
+				"total":    len(contacts),
+			}
+		}
+
+	case "contact_info":
+		var p struct {
+			Phone string `json:"phone"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.Phone == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "phone is required"}
+		} else if info, err := h.service.GetContactInfo(p.Phone); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = info
+		}
+
+	case "typing":
+		var p struct {
+			JID   string `json:"jid"`
+			State string `json:"state"`
+			Media string `json:"media"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.JID == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "jid is required"}
+		} else if p.State == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "state is required ('composing' or 'paused')"}
+		} else if err := h.service.SendTyping(p.JID, p.State, p.Media); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]string{"message": "Typing indicator sent"}
+		}
+
+	case "presence":
+		var p struct {
+			Status string `json:"status"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.Status == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "status is required ('available' or 'unavailable')"}
+		} else if err := h.service.SetPresence(p.Status); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]string{"message": "Presence set"}
+		}
+
+	case "mark_read":
+		var p struct {
+			MessageIDs []string `json:"message_ids"`
+			ChatJID    string   `json:"chat_jid"`
+			SenderJID  string   `json:"sender_jid"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if len(p.MessageIDs) == 0 {
+			resp.Error = &RPCError{Code: -32602, Message: "message_ids array is required"}
+		} else if p.ChatJID == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "chat_jid is required"}
+		} else if err := h.service.MarkRead(p.MessageIDs, p.ChatJID, p.SenderJID); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]string{"message": "Messages marked as read"}
+		}
+
+	case "group_participants_add":
+		var p struct {
+			GroupID      string   `json:"group_id"`
+			Participants []string `json:"participants"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.GroupID == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "group_id is required"}
+		} else if len(p.Participants) == 0 {
+			resp.Error = &RPCError{Code: -32602, Message: "participants array is required and must not be empty"}
+		} else if result, err := h.service.AddGroupParticipants(p.GroupID, p.Participants); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = result
+		}
+
+	case "group_participants_remove":
+		var p struct {
+			GroupID      string   `json:"group_id"`
+			Participants []string `json:"participants"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.GroupID == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "group_id is required"}
+		} else if len(p.Participants) == 0 {
+			resp.Error = &RPCError{Code: -32602, Message: "participants array is required and must not be empty"}
+		} else if result, err := h.service.RemoveGroupParticipants(p.GroupID, p.Participants); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = result
+		}
+
+	case "group_invite_link":
+		var p struct {
+			GroupID string `json:"group_id"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.GroupID == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "group_id is required"}
+		} else if result, err := h.service.GetGroupInviteLink(p.GroupID); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = result
+		}
+
+	case "group_revoke_invite":
+		var p struct {
+			GroupID string `json:"group_id"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if p.GroupID == "" {
+			resp.Error = &RPCError{Code: -32602, Message: "group_id is required"}
+		} else if result, err := h.service.RevokeGroupInviteLink(p.GroupID); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = result
+		}
+
+	case "chat_history":
+		var p struct {
+			ChatID      string `json:"chat_id"`
+			Phone       string `json:"phone"`
+			GroupID     string `json:"group_id"`
+			Limit       int    `json:"limit"`
+			Offset      int    `json:"offset"`
+			SenderPhone string `json:"sender_phone"`
+			TextOnly    bool   `json:"text_only"`
+		}
+		if err := json.Unmarshal(req.Params, &p); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else {
+			// Resolve chat_id from phone or group_id if not directly provided
+			chatID := p.ChatID
+			if chatID == "" {
+				if p.Phone != "" {
+					chatID = p.Phone + "@s.whatsapp.net"
+				} else if p.GroupID != "" {
+					chatID = p.GroupID
+				} else {
+					resp.Error = &RPCError{Code: -32602, Message: "Either chat_id, phone, or group_id is required"}
+					break
+				}
+			}
+
+			// Set defaults
+			limit := p.Limit
+			if limit <= 0 {
+				limit = 50
+			}
+			if limit > 500 {
+				limit = 500
+			}
+
+			if result, err := h.service.GetChatHistory(chatID, limit, p.Offset, p.SenderPhone, p.TextOnly); err != nil {
+				resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+			} else {
+				resp.Result = result
+			}
+		}
+
+	case "rate_limit_get":
+		resp.Result = map[string]interface{}{
+			"config": h.service.GetRateLimitConfig(),
+			"stats":  h.service.GetRateLimitStats(),
+		}
+
+	case "rate_limit_set":
+		var config whatsapp.RateLimitConfig
+		if err := json.Unmarshal(req.Params, &config); err != nil {
+			resp.Error = &RPCError{Code: -32602, Message: "Invalid params: " + err.Error()}
+		} else if err := h.service.SetRateLimitConfig(&config); err != nil {
+			resp.Error = &RPCError{Code: -32000, Message: err.Error()}
+		} else {
+			resp.Result = map[string]interface{}{
+				"message": "Rate limit config updated",
+				"config":  h.service.GetRateLimitConfig(),
+			}
+		}
+
+	case "rate_limit_stats":
+		resp.Result = h.service.GetRateLimitStats()
+
+	case "rate_limit_unpause":
+		h.service.UnpauseRateLimiting()
+		resp.Result = map[string]interface{}{
+			"message": "Rate limiting unpaused",
+			"stats":   h.service.GetRateLimitStats(),
+		}
+
+	default:
+		resp.Error = &RPCError{Code: -32601, Message: "Method not found: " + req.Method}
+	}
+
+	return resp
+}
+
+// ForwardEvents sends WhatsApp events as JSON-RPC notifications
+func (h *RPCHandler) ForwardEvents(conn *websocket.Conn, mu *sync.Mutex, done chan struct{}) {
+	eventChan := h.service.GetEventChannel()
+	for {
+		select {
+		case <-done:
+			return
+		case event, ok := <-eventChan:
+			if !ok {
+				return
+			}
+			notif := RPCRequest{
+				JSONRPC: "2.0",
+				Method:  "event." + event.Type,
+				Params:  mustMarshal(event.Data),
+			}
+			mu.Lock()
+			if err := conn.WriteJSON(notif); err != nil {
+				mu.Unlock()
+				h.logger.Errorf("Failed to send event: %v", err)
+				return
+			}
+			mu.Unlock()
+		}
+	}
+}
+
+func mustMarshal(v interface{}) json.RawMessage {
+	b, _ := json.Marshal(v)
+	return b
+}

package/src/go/rpc/server.go

@@ -0,0 +1,112 @@
+package server
+
+import (
+	"net/http"
+	"sync"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"github.com/sirupsen/logrus"
+
+	"whatsapp-rpc/src/go/whatsapp"
+)
+
+// Server handles WebSocket RPC connections
+type Server struct {
+	whatsapp *whatsapp.Service
+	logger   *logrus.Logger
+	upgrader websocket.Upgrader
+}
+
+// New creates a new WebSocket RPC server
+func New(whatsappService *whatsapp.Service, logger *logrus.Logger) *Server {
+	return &Server{
+		whatsapp: whatsappService,
+		logger:   logger,
+		upgrader: websocket.Upgrader{
+			CheckOrigin: func(r *http.Request) bool {
+				return true
+			},
+			ReadBufferSize:  1024 * 1024,       // 1 MB read buffer
+			WriteBufferSize: 100 * 1024 * 1024, // 100 MB write buffer for large media
+		},
+	}
+}
+
+// SetupRoutes configures WebSocket RPC routes only
+func (s *Server) SetupRoutes() *gin.Engine {
+	gin.SetMode(gin.ReleaseMode)
+	router := gin.New()
+	router.Use(gin.Recovery())
+
+	// CORS middleware
+	router.Use(func(c *gin.Context) {
+		c.Header("Access-Control-Allow-Origin", "*")
+		c.Header("Access-Control-Allow-Methods", "GET, OPTIONS")
+		c.Header("Access-Control-Allow-Headers", "Content-Type")
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(200)
+			return
+		}
+		c.Next()
+	})
+
+	// WebSocket RPC endpoint - the only endpoint
+	router.GET("/ws/rpc", s.handleWebSocketRPC)
+
+	// Health check
+	router.GET("/health", func(c *gin.Context) {
+		c.JSON(200, gin.H{"status": "ok", "type": "websocket-rpc"})
+	})
+
+	return router
+}
+
+// handleWebSocketRPC handles bidirectional JSON-RPC over WebSocket
+func (s *Server) handleWebSocketRPC(c *gin.Context) {
+	conn, err := s.upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		s.logger.Errorf("WebSocket upgrade failed: %v", err)
+		return
+	}
+	defer conn.Close()
+
+	s.logger.Info("RPC client connected")
+
+	var writeMu sync.Mutex
+	done := make(chan struct{})
+	handler := NewRPCHandler(s.whatsapp, s.logger)
+
+	// Forward events as JSON-RPC notifications
+	go handler.ForwardEvents(conn, &writeMu, done)
+
+	// Send initial status
+	status := s.whatsapp.GetStatus()
+	writeMu.Lock()
+	conn.WriteJSON(RPCRequest{
+		JSONRPC: "2.0",
+		Method:  "event.status",
+		Params:  mustMarshal(status),
+	})
+	writeMu.Unlock()
+
+	// Read and handle incoming requests
+	for {
+		var req RPCRequest
+		if err := conn.ReadJSON(&req); err != nil {
+			s.logger.Debugf("RPC client disconnected: %v", err)
+			close(done)
+			return
+		}
+
+		s.logger.Debugf("RPC request: %s", req.Method)
+
+		// Process request and send response
+		resp := handler.HandleRequest(&req)
+		if req.ID != nil {
+			writeMu.Lock()
+			conn.WriteJSON(resp)
+			writeMu.Unlock()
+		}
+	}
+}