fix: refactor web

Author: michiosw

internal/app/app.go

@@ -11,9 +11,10 @@ import (
 	"github.com/co-browser/agent-browser/internal/events"
 	"github.com/co-browser/agent-browser/internal/log"
 	"github.com/co-browser/agent-browser/internal/mcp"
-	"github.com/co-browser/agent-browser/internal/mcp/config"
+	mcpConfig "github.com/co-browser/agent-browser/internal/mcp/config"
 	"github.com/co-browser/agent-browser/internal/web"
 	"github.com/co-browser/agent-browser/internal/web/client"
+	webConfig "github.com/co-browser/agent-browser/internal/web/config"
 	"github.com/co-browser/agent-browser/internal/web/handlers"
 
 	"go.uber.org/fx"
@@ -61,7 +62,7 @@ var DatabaseModule = fx.Module("database",
 // Currently loads MCP configuration.
 var ConfigModule = fx.Module("config",
 	fx.Provide(
-		config.NewConfig,
+		mcpConfig.NewConfig,
 	),
 )
 
@@ -94,44 +95,42 @@ var BackendModule = fx.Module("backend",
 	*/
 )
 
-// MCPClientModule provides the components responsible for connecting *to* remote MCP servers.
-// This includes the ConnectionManager and the API client used by the ConnectionManager
-// to update this agent's status and sync tools via its own web API.
+// MCPClientModule provides the components responsible for connecting to remote MCP servers.
 var MCPClientModule = fx.Module("mcp_client",
 	fx.Provide(
-		// Provide the web API client used by MCP components
+		// Provide the web API client
 		func(logger log.Logger) *client.Client {
-			// TODO: Make API client base URL configurable
-			config := client.DefaultConfig()
-			// DefaultConfig likely points to localhost, which is correct for the agent
-			// calling its own API.
+			config := webConfig.ClientConfig{
+				BaseURL:       "http://localhost:8080",
+				TimeoutSec:    10,
+				MaxRetries:    3,
+				RetryDelaySec: 1,
+			}
 			return client.NewClient(config, logger)
 		},
-		// Provide MCP components (like ConnectionManager)
+		// Provide MCP components
 		mcp.NewMCPComponents,
 	),
-	// Register lifecycle hooks for starting/stopping the MCP ConnectionManager
+	// Register lifecycle hooks
 	fx.Invoke(mcp.RegisterMCPServerHooks),
-	// Register event subscribers for the ConnectionManager
+	// Register event subscribers
 	fx.Invoke(mcp.RegisterEventSubscribers),
 )
 
 // WebModule provides the HTTP server, API handlers, UI handlers, and SSE handler.
 var WebModule = fx.Module("web",
 	fx.Provide(
-		// Provide UI handler struct (depends on Logger, BackendService)
+		// Provide UI handler struct
 		handlers.NewUIHandler,
-		// Provide API handlers (depends on BackendService, Logger)
+
+		// Provide API handlers
 		func(bs backend.Service, logger log.Logger) *handlers.APIHandlers {
 			return handlers.NewAPIHandlers(bs, logger)
 		},
-		// Provide SSE handler (depends on Logger, EventBus, BackendService)
-		// Note: Fx automatically provides context.Background() if context.Context is needed.
+
+		// Provide SSE handler
 		func(lc fx.Lifecycle, logger log.Logger, bus events.Bus, bs backend.Service) *handlers.SSEHandler {
-			// Create handler with background context
-			// The handler manages its own internal context cancellation via Stop().
 			sseHandler := handlers.NewSSEHandler(context.Background(), logger, bus, bs)
-			// Register Stop hook
 			lc.Append(fx.Hook{
 				OnStop: func(_ context.Context) error {
 					logger.Info().Msg("Stopping SSE handler...")
@@ -141,42 +140,33 @@ var WebModule = fx.Module("web",
 			})
 			return sseHandler
 		},
-		// Provide the HTTP request router (ServeMux)
-		// Pass apiHandler and uiHandler explicitly if NewMux requires them.
-		// Assuming NewMux takes no arguments for now as per web/server.go structure.
-		// We register handlers via fx.Invoke later.
+
+		// Provide the HTTP router
 		func() *http.ServeMux {
 			return http.NewServeMux()
 		},
-		// Provide the HTTP server itself (depends on ServeMux)
+
+		// Provide the HTTP server
 		web.NewServer,
 	),
+
 	// Register handlers with the router
 	fx.Invoke(func(mux *http.ServeMux, apiHandlers *handlers.APIHandlers, uiHandler *handlers.UIHandler, sseHandler *handlers.SSEHandler) {
-		// API Routes (includes Swagger/OpenAPI docs)
+		// API Routes
 		apiHandlers.RegisterRoutes(mux)
 
-		// --- UI Routes (Registered directly) ---
-		mux.HandleFunc("/ui/", uiHandler.ServeIndex) // Note trailing slash
-		// mux.HandleFunc("/ui/add", uiHandler.ServeAddPage)       // Removed
-		// mux.HandleFunc("/ui/success", uiHandler.ServeSuccessPage) // Removed
-		// mux.HandleFunc("/ui/error", uiHandler.ServeErrorPage)   // Removed
+		// UI Routes
+		mux.HandleFunc("/ui/", uiHandler.ServeIndex)
 
-		// --- Root Redirect ---
-		// Use mux.Handle for http.RedirectHandler as it returns an http.Handler
+		// Root Redirect
 		mux.Handle("/", http.RedirectHandler("/ui/", http.StatusMovedPermanently))
 
-		// --- SSE Route ---
+		// SSE Route
 		mux.HandleFunc("/api/events", sseHandler.ServeHTTP)
-
-		// Metrics Route (example, if needed)
-		// mux.Handle("/metrics", promhttp.Handler())
 	}),
-	// Register web server lifecycle hooks for starting/stopping the server
+
+	// Register web server lifecycle hooks
 	fx.Invoke(web.RegisterWebServerHooks),
-	// Invoke the SSE handler's event listener setup explicitly if needed,
-	// but NewSSEHandler already starts the listener goroutine.
-	// fx.Invoke(func(sse *handlers.SSEHandler) { /* SSE Listener already started in New */ }),
 )
 
 // CursorModule manages interaction with the ~/.cursor/mcp.json file.

internal/web/client/client.go

@@ -1,3 +1,4 @@
+// Package client provides HTTP client functionality for API interactions.
 package client
 
 import (
@@ -10,39 +11,22 @@ import (
 
 	"github.com/co-browser/agent-browser/internal/backend/models"
 	"github.com/co-browser/agent-browser/internal/log"
+	"github.com/co-browser/agent-browser/internal/web/config"
 )
 
-// Config holds configuration for the API client
-type Config struct {
-	BaseURL    string
-	Timeout    time.Duration
-	MaxRetries int
-	RetryDelay time.Duration
-}
-
-// DefaultConfig returns a default configuration
-func DefaultConfig() Config {
-	return Config{
-		BaseURL:    "http://localhost:8080",
-		Timeout:    10 * time.Second,
-		MaxRetries: 3,
-		RetryDelay: time.Second,
-	}
-}
-
 // Client provides methods to interact with the agent-browser API
 type Client struct {
-	config Config
+	config config.ClientConfig
 	http   *http.Client
 	logger log.Logger
 }
 
 // NewClient creates a new API client instance
-func NewClient(config Config, logger log.Logger) *Client {
+func NewClient(config config.ClientConfig, logger log.Logger) *Client {
 	return &Client{
 		config: config,
 		http: &http.Client{
-			Timeout: config.Timeout,
+			Timeout: time.Duration(config.TimeoutSec) * time.Second,
 		},
 		logger: logger,
 	}
@@ -126,15 +110,15 @@ func (c *Client) do(req *http.Request, response interface{}) error {
 		if err != nil {
 			lastErr = err
 			c.logger.Warn().Err(err).Int("attempt", attempt).Msg("Request failed, retrying...")
-			time.Sleep(c.config.RetryDelay)
+			time.Sleep(time.Duration(c.config.RetryDelaySec) * time.Second)
 			continue
 		}
 		defer resp.Body.Close()
 
 		if resp.StatusCode >= 400 {
 			lastErr = fmt.Errorf("request failed with status %d", resp.StatusCode)
 			c.logger.Warn().Int("statusCode", resp.StatusCode).Int("attempt", attempt).Msg("Request failed, retrying...")
-			time.Sleep(c.config.RetryDelay)
+			time.Sleep(time.Duration(c.config.RetryDelaySec) * time.Second)
 			continue
 		}
 

internal/web/config/config.go

@@ -0,0 +1,59 @@
+// Package config provides configuration structures for the web server.
+package config
+
+import (
+	"github.com/co-browser/agent-browser/internal/log"
+	"go.uber.org/fx"
+)
+
+// ServerConfig holds the configuration for the HTTP server
+type ServerConfig struct {
+	Address string `json:"address" default:":8080"`
+}
+
+// ClientConfig holds the configuration for the API client
+type ClientConfig struct {
+	BaseURL       string `json:"base_url" default:"http://localhost:8080"`
+	TimeoutSec    int    `json:"timeout_sec" default:"10"`
+	MaxRetries    int    `json:"max_retries" default:"3"`
+	RetryDelaySec int    `json:"retry_delay_sec" default:"1"`
+}
+
+// ConfigParams contains the parameters needed for configuration
+type ConfigParams struct {
+	fx.In
+
+	Logger log.Logger
+}
+
+// ConfigResult contains the configuration output
+type ConfigResult struct {
+	fx.Out
+
+	ServerConfig ServerConfig
+	ClientConfig ClientConfig
+}
+
+// NewConfig creates a new web configuration
+func NewConfig(p ConfigParams) (ConfigResult, error) {
+	serverConfig := ServerConfig{
+		Address: ":8080",
+	}
+
+	clientConfig := ClientConfig{
+		BaseURL:       "http://localhost:8080",
+		TimeoutSec:    10,
+		MaxRetries:    3,
+		RetryDelaySec: 1,
+	}
+
+	p.Logger.Info().
+		Str("address", serverConfig.Address).
+		Str("base_url", clientConfig.BaseURL).
+		Msg("Web configuration loaded")
+
+	return ConfigResult{
+		ServerConfig: serverConfig,
+		ClientConfig: clientConfig,
+	}, nil
+}