Extract routes to getRoutes() function

Address review feedback to eliminate duplicated route configuration
and prevent potential inconsistencies.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

examples/auth/main.go

@@ -0,0 +1,418 @@
+//go:build js && wasm
+
+// Package main demonstrates OIDC authentication with Iris.
+//
+// This example shows:
+//   - OIDC client setup
+//   - Login/logout flow
+//   - Protected routes with auth guard
+//   - Displaying user info
+//   - Token handling
+package main
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"strings"
+	"syscall/js"
+
+	"git.flowmade.one/flowmade-one/iris/auth"
+	"git.flowmade.one/flowmade-one/iris/navigation"
+	"git.flowmade.one/flowmade-one/iris/reactive"
+	"git.flowmade.one/flowmade-one/iris/ui"
+)
+
+// Configuration - in production, these would come from environment/config
+const (
+	// OIDC provider configuration
+	// Update these values for your OIDC provider (e.g., Dex, Keycloak, Auth0)
+	OIDCIssuer  = "https://dex.example.com"
+	ClientID    = "iris-example-app"
+	RedirectURI = "http://localhost:8080/callback"
+)
+
+var (
+	// Global OIDC client
+	oidcClient *auth.OIDCClient
+
+	// Reactive state for authentication
+	isAuthenticated = reactive.NewSignal(false)
+	currentUser     = reactive.NewSignal[*UserDisplay](nil)
+	authError       = reactive.NewSignal("")
+	isLoading       = reactive.NewSignal(false)
+
+	// Font presets
+	fontTitle   = ui.NewFont().Size("32px").Weight("700")
+	fontHeading = ui.NewFont().Size("20px").Weight("600")
+)
+
+// UserDisplay holds user information for display
+type UserDisplay struct {
+	Email string
+	Name  string
+	Sub   string
+}
+
+func main() {
+	// Initialize OIDC client
+	oidcClient = auth.NewOIDCClient(OIDCIssuer, ClientID, RedirectURI)
+
+	// Check for existing tokens on startup
+	checkExistingSession()
+
+	// Check if this is an OAuth callback
+	if isCallbackPath() {
+		handleOAuthCallback()
+		return
+	}
+	router := navigation.NewRouter(getRoutes())
+	router.SetNotFoundHandler(notFoundView)
+	navigation.SetGlobalRouter(router)
+
+	// Create the main app with router
+	ui.NewAppWithRouter(router)
+
+	// Keep the application running
+	select {}
+}
+
+// getRoutes returns the route configuration for the application
+func getRoutes() []navigation.Route {
+	return []navigation.Route{
+		{
+			Path:    "/",
+			Handler: homeView,
+		},
+		{
+			Path:    "/callback",
+			Handler: callbackView,
+		},
+		{
+			Path:    "/profile",
+			Handler: profileView,
+			Guards:  []navigation.RouteGuard{authGuard()},
+		},
+		{
+			Path:    "/protected",
+			Handler: protectedView,
+			Guards:  []navigation.RouteGuard{authGuard()},
+		},
+	}
+}
+
+// checkExistingSession checks for existing valid tokens
+func checkExistingSession() {
+	if oidcClient.IsAuthenticated() {
+		isAuthenticated.Set(true)
+		loadUserFromToken()
+	}
+}
+
+// isCallbackPath checks if current path is the OAuth callback
+func isCallbackPath() bool {
+	pathname := js.Global().Get("window").Get("location").Get("pathname").String()
+	search := js.Global().Get("window").Get("location").Get("search").String()
+	return pathname == "/callback" && strings.Contains(search, "code=")
+}
+
+// handleOAuthCallback processes the OAuth callback
+func handleOAuthCallback() {
+	isLoading.Set(true)
+
+	// Discover OIDC configuration and handle callback
+	oidcClient.DiscoverConfigAsync(OIDCIssuer, func(err error) {
+		if err != nil {
+			authError.Set("Failed to load OIDC configuration: " + err.Error())
+			isLoading.Set(false)
+			renderApp()
+			return
+		}
+
+		// Exchange code for tokens
+		tokens, err := oidcClient.HandleCallback(OIDCIssuer)
+		if err != nil {
+			authError.Set("Authentication failed: " + err.Error())
+			isLoading.Set(false)
+			renderApp()
+			return
+		}
+
+		// Store tokens
+		oidcClient.StoreTokens(tokens)
+		isAuthenticated.Set(true)
+		loadUserFromToken()
+		isLoading.Set(false)
+
+		// Clear URL parameters and redirect to home
+		js.Global().Get("window").Get("history").Call("replaceState", nil, "", "/")
+		renderApp()
+	})
+}
+
+// renderApp initializes and renders the app after callback processing
+func renderApp() {
+	router := navigation.NewRouter(getRoutes())
+	router.SetNotFoundHandler(notFoundView)
+	navigation.SetGlobalRouter(router)
+
+	ui.NewAppWithRouter(router)
+
+	select {}
+}
+
+// loadUserFromToken extracts user info from the ID token
+func loadUserFromToken() {
+	tokens := oidcClient.GetStoredTokens()
+	if tokens == nil || tokens.IDToken == "" {
+		return
+	}
+
+	// Parse the ID token to get user info (JWT payload is the second part)
+	parts := strings.Split(tokens.IDToken, ".")
+	if len(parts) != 3 {
+		return
+	}
+
+	// Decode the payload
+	payload, err := base64.RawURLEncoding.DecodeString(parts[1])
+	if err != nil {
+		return
+	}
+
+	var claims struct {
+		Sub   string `json:"sub"`
+		Email string `json:"email"`
+		Name  string `json:"name"`
+	}
+	if err := json.Unmarshal(payload, &claims); err != nil {
+		return
+	}
+
+	currentUser.Set(&UserDisplay{
+		Email: claims.Email,
+		Name:  claims.Name,
+		Sub:   claims.Sub,
+	})
+}
+
+// authGuard creates a route guard that checks authentication
+func authGuard() navigation.RouteGuard {
+	return navigation.AuthGuard(func() bool {
+		return isAuthenticated.Get()
+	})
+}
+
+// login initiates the OIDC login flow
+func login() {
+	isLoading.Set(true)
+	authError.Set("")
+
+	oidcClient.DiscoverConfigAsync(OIDCIssuer, func(err error) {
+		if err != nil {
+			authError.Set("Failed to connect to authentication provider: " + err.Error())
+			isLoading.Set(false)
+			return
+		}
+
+		if err := oidcClient.StartAuthFlow(); err != nil {
+			authError.Set("Failed to start login: " + err.Error())
+			isLoading.Set(false)
+		}
+		// Note: If successful, the browser will redirect to the OIDC provider
+	})
+}
+
+// logout clears authentication state
+func logout() {
+	oidcClient.Logout()
+	isAuthenticated.Set(false)
+	currentUser.Set(nil)
+	navigation.Navigate("/")
+}
+
+// View functions
+
+func homeView(params map[string]string) ui.View {
+	return ui.VerticalGroup(
+		header(),
+		ui.VerticalGroup(
+			ui.TextFromString("Iris Auth Example").
+				Font(fontTitle).
+				Margin("20px 0"),
+			ui.TextFromString("This example demonstrates OIDC authentication with protected routes.").
+				Color("#666"),
+			ui.TextFromFunction(func() string {
+				if authError.Get() != "" {
+					return "Error: " + authError.Get()
+				}
+				return ""
+			}).Color("#ff4444"),
+			authSection(),
+		).Padding("20px").MaxWidth("800px"),
+	).Gap("0")
+}
+
+func header() ui.View {
+	return ui.HorizontalGroup(
+		ui.TextFromString("Auth Example").Font(fontHeading),
+		navigation.Link("/", ui.TextFromString("Home")),
+		navigation.Link("/profile", ui.TextFromString("Profile")),
+		navigation.Link("/protected", ui.TextFromString("Protected")),
+		ui.Spacer(),
+		authButton(),
+	).Padding("16px 24px").Background("#f5f5f5").BorderBottom("1px solid #ddd")
+}
+
+func authSection() ui.View {
+	return ui.VerticalGroup(
+		ui.TextFromFunction(func() string {
+			if isLoading.Get() {
+				return "Loading..."
+			}
+			if isAuthenticated.Get() {
+				user := currentUser.Get()
+				if user != nil {
+					return "Welcome, " + user.Name + "!"
+				}
+				return "You are logged in."
+			}
+			return "You are not logged in."
+		}).Margin("20px 0"),
+
+		ui.TextFromFunction(func() string {
+			if isAuthenticated.Get() {
+				return "Navigate to Profile or Protected pages to see authenticated content."
+			}
+			return "Click Login to authenticate with your OIDC provider."
+		}).Color("#666"),
+	).Padding("20px").Background("#fafafa").BorderRadius("8px").Margin("20px 0")
+}
+
+func authButton() ui.View {
+	return ui.Button(func() {
+		if isAuthenticated.Get() {
+			logout()
+		} else {
+			login()
+		}
+	}, ui.TextFromFunction(func() string {
+		if isLoading.Get() {
+			return "Loading..."
+		}
+		if isAuthenticated.Get() {
+			return "Logout"
+		}
+		return "Login"
+	})).Padding("8px 16px").Background("#007bff").Foreground("#fff").
+		Border("none").BorderRadius("4px").Cursor("pointer")
+}
+
+func callbackView(params map[string]string) ui.View {
+	return ui.VerticalGroup(
+		header(),
+		ui.VerticalGroup(
+			ui.TextFromString("Processing login...").Font(fontHeading),
+			ui.TextFromString("Please wait while we complete authentication.").Color("#666"),
+		).Padding("40px"),
+	).Gap("0")
+}
+
+func profileView(params map[string]string) ui.View {
+	return ui.VerticalGroup(
+		header(),
+		ui.VerticalGroup(
+			ui.TextFromString("User Profile").Font(fontTitle).Margin("20px 0"),
+			userInfoCard(),
+			tokenInfoCard(),
+		).Padding("20px").MaxWidth("800px"),
+	).Gap("0")
+}
+
+func userInfoCard() ui.View {
+	return ui.VerticalGroup(
+		ui.TextFromString("User Information").Font(fontHeading),
+		ui.TextFromFunction(func() string {
+			user := currentUser.Get()
+			if user == nil {
+				return "No user information available"
+			}
+			return "Name: " + user.Name
+		}),
+		ui.TextFromFunction(func() string {
+			user := currentUser.Get()
+			if user == nil {
+				return ""
+			}
+			return "Email: " + user.Email
+		}),
+		ui.TextFromFunction(func() string {
+			user := currentUser.Get()
+			if user == nil {
+				return ""
+			}
+			return "Subject: " + user.Sub
+		}).Color("#888"),
+	).Padding("20px").Background("#fafafa").BorderRadius("8px").Margin("10px 0").Gap("8px")
+}
+
+func tokenInfoCard() ui.View {
+	return ui.VerticalGroup(
+		ui.TextFromString("Token Information").Font(fontHeading),
+		ui.TextFromFunction(func() string {
+			tokens := oidcClient.GetStoredTokens()
+			if tokens == nil {
+				return "No tokens available"
+			}
+			return "Access Token: " + truncateToken(tokens.AccessToken)
+		}),
+		ui.TextFromFunction(func() string {
+			tokens := oidcClient.GetStoredTokens()
+			if tokens == nil {
+				return ""
+			}
+			return "ID Token: " + truncateToken(tokens.IDToken)
+		}),
+		ui.TextFromFunction(func() string {
+			authHeader := oidcClient.GetAuthHeader()
+			if authHeader == "" {
+				return ""
+			}
+			return "Auth Header: " + truncateToken(authHeader)
+		}).Color("#888"),
+	).Padding("20px").Background("#fafafa").BorderRadius("8px").Margin("10px 0").Gap("8px")
+}
+
+func protectedView(params map[string]string) ui.View {
+	return ui.VerticalGroup(
+		header(),
+		ui.VerticalGroup(
+			ui.TextFromString("Protected Content").Font(fontTitle).Margin("20px 0"),
+			ui.TextFromString("This page is only visible to authenticated users.").Color("#666"),
+			ui.VerticalGroup(
+				ui.TextFromString("Access Granted").Font(fontHeading).Color("#28a745"),
+				ui.TextFromString("You have successfully accessed a protected route."),
+				ui.TextFromString("The auth guard verified your authentication status before allowing access.").Color("#888"),
+			).Padding("20px").Background("#e8f5e9").BorderRadius("8px").Margin("20px 0"),
+		).Padding("20px").MaxWidth("800px"),
+	).Gap("0")
+}
+
+func notFoundView() ui.View {
+	return ui.VerticalGroup(
+		header(),
+		ui.VerticalGroup(
+			ui.TextFromString("404 - Page Not Found").Font(fontTitle).Color("#ff4444"),
+			ui.TextFromString("The requested page could not be found.").Color("#666"),
+			navigation.Link("/", ui.TextFromString("Go to Home").Color("#007bff")),
+		).Padding("40px"),
+	).Gap("0")
+}
+
+// Helper functions
+
+func truncateToken(token string) string {
+	if len(token) <= 20 {
+		return token
+	}
+	return token[:10] + "..." + token[len(token)-10:]
+}

host/README.md

@@ -36,9 +36,9 @@ myapp/
 
 The server serves files from the specified public directory. Any request path maps directly to files:
 
-- `/` -> `public/index.html`
+- `/` → `public/index.html`
-- `/app.wasm` -> `public/app.wasm`
+- `/app.wasm` → `public/app.wasm`
-- `/styles.css` -> `public/styles.css`
+- `/styles.css` → `public/styles.css`
 
 **SPA Fallback**: Unknown paths and directories fall back to `index.html`, enabling client-side routing.
 
@@ -68,109 +68,28 @@ Gzip compression is automatically applied to compressible content types when the
 
 Binary assets (PNG, JPEG, etc.) are served uncompressed since they're already compressed.
 
-## Hot Reload (Development)
+## Development vs Production
 
-The `DevServer` provides automatic rebuild and browser reload during development:
+### Development
-
-```go
-package main
-
-import (
-	"git.flowmade.one/flowmade-one/iris/host"
-)
-
-func main() {
-	// Create dev server with hot reload
-	dev := host.NewDevServer(
-		"public",       // Static files directory
-		"index.html",   // Index file
-		".",            // Source directory to watch
-		"public/app.wasm", // WASM output path
-	)
-	
-	// Start watching and serving
-	dev.ListenAndServe(":8080")
-}
-```
-
-### How It Works
-
-1. **File Watcher**: Monitors `.go` files in the source directory for changes
-2. **Auto Build**: Runs `GOOS=js GOARCH=wasm go build` when changes are detected
-3. **Browser Reload**: Injects a WebSocket client into HTML pages that triggers reload on build success
-
-### Directory Structure for Development
-
-```
-myapp/
-├── main.go             # WASM application entry point
-├── server/
-│   └── main.go         # Dev server (code above)
-└── public/
-    ├── index.html
-    ├── app.wasm        # Generated by dev server
-    └── wasm_exec.js
-```
-
-### Workflow
-
-1. Start the dev server: `go run ./server`
-2. Open `http://localhost:8080` in your browser
-3. Edit your Go source files
-4. Save - the browser automatically reloads with your changes
-
-### Custom Watch Configuration
-
-```go
-// Watch additional file types
-watcher := host.NewWatcher(
-	".",
-	onChangeCallback,
-	host.WithExtensions(".go", ".html", ".css"),
-	host.WithInterval(100*time.Millisecond),
-)
-```
-
-### Manual Components
-
-For advanced use cases, you can use the individual components:
-
-```go
-// File watcher
-watcher := host.NewWatcher(".", func() {
-	log.Println("Files changed")
-})
-watcher.Start()
-defer watcher.Stop()
-
-// WASM builder
-builder := host.NewBuilder(".", "public/app.wasm")
-result := builder.Build()
-if result.Success {
-	log.Println("Build succeeded")
-}
-
-// Live reload (WebSocket notifications)
-lr := host.NewLiveReload()
-http.Handle("/__livereload", lr)
-lr.NotifyReload() // Triggers reload in all connected browsers
-```
-
-## Production
-
-For production, use the standard `Server` instead of `DevServer`:
 
 ```go
 func main() {
 	server := host.New("public", "index.html")
-	log.Fatal(http.ListenAndServe(":8080", server))
+	http.ListenAndServe(":8080", server)
 }
 ```
 
-Compile and deploy:
+Run with:
+```bash
+go run server.go
+```
+
+### Production
+
+For production, compile the server and run as a binary:
 
 ```bash
-go build -o server ./server
+go build -o server ./server.go
 ./server
 ```
 

host/builder.go

@@ -1,85 +0,0 @@
-package host
-
-import (
-	"bytes"
-	"fmt"
-	"os/exec"
-	"sync"
-)
-
-// Builder compiles Go source to WASM.
-type Builder struct {
-	sourceDir  string
-	outputPath string
-
-	mu       sync.Mutex
-	building bool
-}
-
-// BuildResult contains the result of a build operation.
-type BuildResult struct {
-	Success bool
-	Output  string
-	Error   error
-}
-
-// NewBuilder creates a new WASM builder.
-// sourceDir is the directory containing Go source files.
-// outputPath is the target WASM file path.
-func NewBuilder(sourceDir, outputPath string) *Builder {
-	return &Builder{
-		sourceDir:  sourceDir,
-		outputPath: outputPath,
-	}
-}
-
-// Build compiles the Go source to WASM.
-func (b *Builder) Build() BuildResult {
-	b.mu.Lock()
-	if b.building {
-		b.mu.Unlock()
-		return BuildResult{
-			Success: false,
-			Output:  "Build already in progress",
-			Error:   fmt.Errorf("build already in progress"),
-		}
-	}
-	b.building = true
-	b.mu.Unlock()
-
-	defer func() {
-		b.mu.Lock()
-		b.building = false
-		b.mu.Unlock()
-	}()
-
-	cmd := exec.Command("go", "build", "-o", b.outputPath, b.sourceDir)
-	cmd.Env = append(cmd.Environ(), "GOOS=js", "GOARCH=wasm")
-
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-
-	err := cmd.Run()
-	output := stdout.String() + stderr.String()
-
-	if err != nil {
-		return BuildResult{
-			Success: false,
-			Output:  output,
-			Error:   err,
-		}
-	}
-
-	return BuildResult{
-		Success: true,
-		Output:  output,
-	}
-}
-
-// IsBuilding returns true if a build is currently in progress.
-func (b *Builder) IsBuilding() bool {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return b.building
-}

host/devserver.go

@@ -1,222 +0,0 @@
-package host
-
-import (
-	"compress/gzip"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-// DevServer provides a development server with hot reload support.
-// It watches source files, rebuilds WASM on changes, and notifies
-// connected browsers to reload.
-type DevServer struct {
-	publicDir  string
-	indexFile  string
-	sourceDir  string
-	outputPath string
-
-	watcher    *Watcher
-	builder    *Builder
-	liveReload *LiveReload
-	logger     *log.Logger
-}
-
-// DevServerOption configures a DevServer.
-type DevServerOption func(*DevServer)
-
-// WithLogger sets a custom logger for the dev server.
-func WithLogger(logger *log.Logger) DevServerOption {
-	return func(d *DevServer) {
-		d.logger = logger
-	}
-}
-
-// NewDevServer creates a new development server with hot reload.
-//
-// Parameters:
-//   - publicDir: Directory containing static files (e.g., "public")
-//   - indexFile: The fallback HTML file (e.g., "index.html")
-//   - sourceDir: Directory containing Go source files to watch (e.g., ".")
-//   - outputPath: Target path for compiled WASM file (e.g., "public/app.wasm")
-func NewDevServer(publicDir, indexFile, sourceDir, outputPath string, opts ...DevServerOption) *DevServer {
-	d := &DevServer{
-		publicDir:  publicDir,
-		indexFile:  indexFile,
-		sourceDir:  sourceDir,
-		outputPath: outputPath,
-		logger:     log.New(os.Stdout, "[iris] ", log.LstdFlags),
-	}
-
-	for _, opt := range opts {
-		opt(d)
-	}
-
-	d.liveReload = NewLiveReload()
-	d.builder = NewBuilder(sourceDir, outputPath)
-
-	d.watcher = NewWatcher(sourceDir, d.onFileChange,
-		WithExtensions(".go"),
-		WithInterval(500*time.Millisecond),
-	)
-
-	return d
-}
-
-// Start begins watching for file changes.
-func (d *DevServer) Start() error {
-	// Initial build
-	d.logger.Println("Performing initial build...")
-	result := d.builder.Build()
-	if !result.Success {
-		d.logger.Printf("Initial build failed: %v\n%s", result.Error, result.Output)
-	} else {
-		d.logger.Println("Initial build succeeded")
-	}
-
-	// Start watcher
-	d.logger.Printf("Watching %s for changes...", d.sourceDir)
-	return d.watcher.Start()
-}
-
-// Stop stops the file watcher.
-func (d *DevServer) Stop() {
-	d.watcher.Stop()
-}
-
-// ServeHTTP implements http.Handler interface.
-func (d *DevServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Handle live reload WebSocket endpoint
-	if r.URL.Path == "/__livereload" {
-		d.liveReload.ServeHTTP(w, r)
-		return
-	}
-
-	p := filepath.Join(d.publicDir, filepath.Clean(r.URL.Path))
-
-	if info, err := os.Stat(p); err != nil {
-		d.serveHTMLWithInjection(w, r, filepath.Join(d.publicDir, d.indexFile))
-		return
-	} else if info.IsDir() {
-		d.serveHTMLWithInjection(w, r, filepath.Join(d.publicDir, d.indexFile))
-		return
-	}
-
-	// Check if this is an HTML file
-	if strings.HasSuffix(p, ".html") {
-		d.serveHTMLWithInjection(w, r, p)
-		return
-	}
-
-	// Serve other files with compression
-	d.serveFileWithCompression(w, r, p)
-}
-
-func (d *DevServer) onFileChange() {
-	d.logger.Println("File change detected, rebuilding...")
-
-	result := d.builder.Build()
-	if !result.Success {
-		d.logger.Printf("Build failed: %v\n%s", result.Error, result.Output)
-		return
-	}
-
-	d.logger.Println("Build succeeded, reloading browsers...")
-	d.liveReload.NotifyReload()
-}
-
-func (d *DevServer) serveHTMLWithInjection(w http.ResponseWriter, r *http.Request, filePath string) {
-	// Read HTML file
-	content, err := os.ReadFile(filePath)
-	if err != nil {
-		http.Error(w, "File not found", http.StatusNotFound)
-		return
-	}
-
-	// Inject reload script
-	content = InjectReloadScript(content)
-
-	// Set headers
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-
-	// Check if client accepts gzip
-	if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
-		w.Header().Set("Content-Encoding", "gzip")
-		w.Header().Set("Vary", "Accept-Encoding")
-
-		gz := gzip.NewWriter(w)
-		defer gz.Close()
-
-		gz.Write(content)
-	} else {
-		w.Write(content)
-	}
-}
-
-func (d *DevServer) serveFileWithCompression(w http.ResponseWriter, r *http.Request, filePath string) {
-	// Check if client accepts gzip
-	if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
-		http.ServeFile(w, r, filePath)
-		return
-	}
-
-	// Open and read file
-	file, err := os.Open(filePath)
-	if err != nil {
-		http.Error(w, "File not found", http.StatusNotFound)
-		return
-	}
-	defer file.Close()
-
-	// Get file info for headers
-	fileInfo, err := file.Stat()
-	if err != nil {
-		http.Error(w, "Error reading file", http.StatusInternalServerError)
-		return
-	}
-
-	// Set content type based on file extension
-	contentType := getContentType(filepath.Ext(filePath))
-	w.Header().Set("Content-Type", contentType)
-
-	// Disable caching in dev mode for WASM files
-	if strings.HasSuffix(filePath, ".wasm") {
-		w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-	}
-
-	// Check if we should compress this file type
-	if shouldCompress(contentType) {
-		// Set gzip headers
-		w.Header().Set("Content-Encoding", "gzip")
-		w.Header().Set("Vary", "Accept-Encoding")
-
-		// Create gzip writer
-		gz := gzip.NewWriter(w)
-		defer gz.Close()
-
-		// Copy file content through gzip
-		_, err = io.Copy(gz, file)
-		if err != nil {
-			return
-		}
-	} else {
-		// Serve without compression
-		http.ServeContent(w, r, fileInfo.Name(), fileInfo.ModTime(), file)
-	}
-}
-
-// ListenAndServe starts the development server on the specified address.
-func (d *DevServer) ListenAndServe(addr string) error {
-	if err := d.Start(); err != nil {
-		return fmt.Errorf("failed to start watcher: %w", err)
-	}
-
-	d.logger.Printf("Development server running on http://%s", addr)
-	return http.ListenAndServe(addr, d)
-}

host/inject.go

@@ -1,80 +0,0 @@
-package host
-
-import (
-	"bytes"
-	"strings"
-)
-
-// ReloadScript is the JavaScript code injected into HTML pages for hot reload.
-const ReloadScript = `<script>
-(function() {
-    var wsUrl = 'ws://' + window.location.host + '/__livereload';
-    var ws;
-    var reconnectAttempts = 0;
-    var maxReconnectDelay = 5000;
-
-    function connect() {
-        ws = new WebSocket(wsUrl);
-        
-        ws.onopen = function() {
-            console.log('[iris] Hot reload connected');
-            reconnectAttempts = 0;
-        };
-        
-        ws.onmessage = function(event) {
-            if (event.data === 'reload') {
-                console.log('[iris] Reloading...');
-                window.location.reload();
-            }
-        };
-        
-        ws.onclose = function() {
-            var delay = Math.min(1000 * Math.pow(2, reconnectAttempts), maxReconnectDelay);
-            reconnectAttempts++;
-            console.log('[iris] Connection lost. Reconnecting in ' + delay + 'ms...');
-            setTimeout(connect, delay);
-        };
-        
-        ws.onerror = function() {
-            ws.close();
-        };
-    }
-
-    connect();
-})();
-</script>`
-
-// InjectReloadScript injects the live reload script into HTML content.
-// The script is inserted just before the closing </body> tag.
-func InjectReloadScript(html []byte) []byte {
-	// Try to inject before </body>
-	bodyEnd := bytes.LastIndex(html, []byte("</body>"))
-	if bodyEnd != -1 {
-		result := make([]byte, 0, len(html)+len(ReloadScript))
-		result = append(result, html[:bodyEnd]...)
-		result = append(result, []byte(ReloadScript)...)
-		result = append(result, html[bodyEnd:]...)
-		return result
-	}
-
-	// Try to inject before </html>
-	htmlEnd := bytes.LastIndex(html, []byte("</html>"))
-	if htmlEnd != -1 {
-		result := make([]byte, 0, len(html)+len(ReloadScript))
-		result = append(result, html[:htmlEnd]...)
-		result = append(result, []byte(ReloadScript)...)
-		result = append(result, html[htmlEnd:]...)
-		return result
-	}
-
-	// Append at the end as fallback
-	result := make([]byte, 0, len(html)+len(ReloadScript))
-	result = append(result, html...)
-	result = append(result, []byte(ReloadScript)...)
-	return result
-}
-
-// IsHTMLContent checks if the content type indicates HTML.
-func IsHTMLContent(contentType string) bool {
-	return strings.Contains(contentType, "text/html")
-}

host/inject_test.go

@@ -1,102 +0,0 @@
-package host
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestInjectReloadScript_BeforeBody(t *testing.T) {
-	html := []byte(`<!DOCTYPE html>
-<html>
-<head><title>Test</title></head>
-<body>
-<h1>Hello</h1>
-</body>
-</html>`)
-
-	result := InjectReloadScript(html)
-
-	// Should contain the script
-	if !strings.Contains(string(result), "livereload") {
-		t.Error("Expected result to contain livereload script")
-	}
-
-	// Script should be before </body>
-	bodyIndex := strings.Index(string(result), "</body>")
-	scriptIndex := strings.Index(string(result), "<script>")
-
-	if scriptIndex > bodyIndex {
-		t.Error("Expected script to be injected before </body>")
-	}
-}
-
-func TestInjectReloadScript_BeforeHTML(t *testing.T) {
-	// HTML without body tag
-	html := []byte(`<!DOCTYPE html>
-<html>
-<head><title>Test</title></head>
-<div>Hello</div>
-</html>`)
-
-	result := InjectReloadScript(html)
-
-	// Should contain the script
-	if !strings.Contains(string(result), "livereload") {
-		t.Error("Expected result to contain livereload script")
-	}
-
-	// Script should be before </html>
-	htmlIndex := strings.Index(string(result), "</html>")
-	scriptIndex := strings.Index(string(result), "<script>")
-
-	if scriptIndex > htmlIndex {
-		t.Error("Expected script to be injected before </html>")
-	}
-}
-
-func TestInjectReloadScript_Fallback(t *testing.T) {
-	// Minimal HTML without body or html closing tags
-	html := []byte(`<div>Hello</div>`)
-
-	result := InjectReloadScript(html)
-
-	// Should contain the script
-	if !strings.Contains(string(result), "livereload") {
-		t.Error("Expected result to contain livereload script")
-	}
-
-	// Should be appended at the end
-	if !strings.HasSuffix(string(result), "</script>") {
-		t.Error("Expected script to be appended at the end")
-	}
-}
-
-func TestInjectReloadScript_ContainsReconnect(t *testing.T) {
-	html := []byte(`<html><body></body></html>`)
-	result := InjectReloadScript(html)
-
-	// Should contain reconnection logic
-	if !strings.Contains(string(result), "reconnect") {
-		t.Error("Expected script to contain reconnection logic")
-	}
-}
-
-func TestIsHTMLContent(t *testing.T) {
-	tests := []struct {
-		contentType string
-		expected    bool
-	}{
-		{"text/html", true},
-		{"text/html; charset=utf-8", true},
-		{"application/json", false},
-		{"text/css", false},
-		{"application/javascript", false},
-	}
-
-	for _, tt := range tests {
-		result := IsHTMLContent(tt.contentType)
-		if result != tt.expected {
-			t.Errorf("IsHTMLContent(%q) = %v, want %v", tt.contentType, result, tt.expected)
-		}
-	}
-}

host/livereload.go

@@ -1,184 +0,0 @@
-package host
-
-import (
-	"bufio"
-	"crypto/sha1"
-	"encoding/base64"
-	"encoding/binary"
-	"io"
-	"net"
-	"net/http"
-	"sync"
-)
-
-// LiveReload manages WebSocket connections for browser reload notifications.
-type LiveReload struct {
-	mu      sync.RWMutex
-	clients map[*wsConn]bool
-}
-
-// NewLiveReload creates a new LiveReload manager.
-func NewLiveReload() *LiveReload {
-	return &LiveReload{
-		clients: make(map[*wsConn]bool),
-	}
-}
-
-// ServeHTTP handles WebSocket upgrade requests.
-func (lr *LiveReload) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	conn, err := lr.upgrade(w, r)
-	if err != nil {
-		http.Error(w, "WebSocket upgrade failed", http.StatusBadRequest)
-		return
-	}
-
-	lr.addClient(conn)
-	defer lr.removeClient(conn)
-
-	// Keep connection alive and handle pings
-	conn.readLoop()
-}
-
-// NotifyReload sends a reload message to all connected clients.
-func (lr *LiveReload) NotifyReload() {
-	lr.mu.RLock()
-	defer lr.mu.RUnlock()
-
-	for conn := range lr.clients {
-		conn.send([]byte("reload"))
-	}
-}
-
-// ClientCount returns the number of connected clients.
-func (lr *LiveReload) ClientCount() int {
-	lr.mu.RLock()
-	defer lr.mu.RUnlock()
-	return len(lr.clients)
-}
-
-func (lr *LiveReload) addClient(conn *wsConn) {
-	lr.mu.Lock()
-	defer lr.mu.Unlock()
-	lr.clients[conn] = true
-}
-
-func (lr *LiveReload) removeClient(conn *wsConn) {
-	lr.mu.Lock()
-	defer lr.mu.Unlock()
-	delete(lr.clients, conn)
-	conn.close()
-}
-
-func (lr *LiveReload) upgrade(w http.ResponseWriter, r *http.Request) (*wsConn, error) {
-	if r.Header.Get("Upgrade") != "websocket" {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	key := r.Header.Get("Sec-WebSocket-Key")
-	if key == "" {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	// Compute accept key
-	h := sha1.New()
-	h.Write([]byte(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))
-	acceptKey := base64.StdEncoding.EncodeToString(h.Sum(nil))
-
-	// Hijack the connection
-	hijacker, ok := w.(http.Hijacker)
-	if !ok {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	conn, bufrw, err := hijacker.Hijack()
-	if err != nil {
-		return nil, err
-	}
-
-	// Send upgrade response
-	bufrw.WriteString("HTTP/1.1 101 Switching Protocols\r\n")
-	bufrw.WriteString("Upgrade: websocket\r\n")
-	bufrw.WriteString("Connection: Upgrade\r\n")
-	bufrw.WriteString("Sec-WebSocket-Accept: " + acceptKey + "\r\n")
-	bufrw.WriteString("\r\n")
-	bufrw.Flush()
-
-	return &wsConn{
-		conn: conn,
-		rw:   bufrw,
-	}, nil
-}
-
-// wsConn is a minimal WebSocket connection.
-type wsConn struct {
-	conn   net.Conn
-	rw     *bufio.ReadWriter
-	mu     sync.Mutex
-	closed bool
-}
-
-func (c *wsConn) send(data []byte) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.closed {
-		return io.ErrClosedPipe
-	}
-
-	// Write text frame
-	frame := makeFrame(1, data) // 1 = text frame
-	_, err := c.conn.Write(frame)
-	return err
-}
-
-func (c *wsConn) close() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.closed {
-		return
-	}
-	c.closed = true
-
-	// Send close frame
-	frame := makeFrame(8, nil) // 8 = close frame
-	c.conn.Write(frame)
-	c.conn.Close()
-}
-
-func (c *wsConn) readLoop() {
-	buf := make([]byte, 1024)
-	for {
-		_, err := c.rw.Read(buf)
-		if err != nil {
-			return
-		}
-		// We don't process incoming messages, just keep connection alive
-	}
-}
-
-func makeFrame(opcode byte, data []byte) []byte {
-	length := len(data)
-
-	var frame []byte
-	if length < 126 {
-		frame = make([]byte, 2+length)
-		frame[0] = 0x80 | opcode // FIN + opcode
-		frame[1] = byte(length)
-		copy(frame[2:], data)
-	} else if length < 65536 {
-		frame = make([]byte, 4+length)
-		frame[0] = 0x80 | opcode
-		frame[1] = 126
-		binary.BigEndian.PutUint16(frame[2:], uint16(length))
-		copy(frame[4:], data)
-	} else {
-		frame = make([]byte, 10+length)
-		frame[0] = 0x80 | opcode
-		frame[1] = 127
-		binary.BigEndian.PutUint64(frame[2:], uint64(length))
-		copy(frame[10:], data)
-	}
-
-	return frame
-}

host/livereload_test.go

@@ -1,74 +0,0 @@
-package host
-
-import (
-	"testing"
-)
-
-func TestLiveReload_ClientCount(t *testing.T) {
-	lr := NewLiveReload()
-
-	if count := lr.ClientCount(); count != 0 {
-		t.Errorf("Expected 0 clients, got %d", count)
-	}
-}
-
-func TestMakeFrame_SmallPayload(t *testing.T) {
-	data := []byte("reload")
-	frame := makeFrame(1, data)
-
-	// First byte: FIN + opcode
-	if frame[0] != 0x81 {
-		t.Errorf("Expected first byte 0x81, got 0x%02x", frame[0])
-	}
-
-	// Second byte: length (no mask, small payload)
-	if frame[1] != byte(len(data)) {
-		t.Errorf("Expected length %d, got %d", len(data), frame[1])
-	}
-
-	// Payload
-	payload := frame[2:]
-	if string(payload) != string(data) {
-		t.Errorf("Expected payload %q, got %q", data, payload)
-	}
-}
-
-func TestMakeFrame_MediumPayload(t *testing.T) {
-	// Create payload between 126 and 65535 bytes
-	data := make([]byte, 200)
-	for i := range data {
-		data[i] = byte(i % 256)
-	}
-
-	frame := makeFrame(1, data)
-
-	// First byte: FIN + opcode
-	if frame[0] != 0x81 {
-		t.Errorf("Expected first byte 0x81, got 0x%02x", frame[0])
-	}
-
-	// Second byte: 126 indicates extended length
-	if frame[1] != 126 {
-		t.Errorf("Expected length indicator 126, got %d", frame[1])
-	}
-
-	// Extended length (2 bytes, big endian)
-	extLen := int(frame[2])<<8 | int(frame[3])
-	if extLen != len(data) {
-		t.Errorf("Expected extended length %d, got %d", len(data), extLen)
-	}
-}
-
-func TestMakeFrame_CloseFrame(t *testing.T) {
-	frame := makeFrame(8, nil)
-
-	// First byte: FIN + close opcode
-	if frame[0] != 0x88 {
-		t.Errorf("Expected first byte 0x88, got 0x%02x", frame[0])
-	}
-
-	// Second byte: 0 length
-	if frame[1] != 0 {
-		t.Errorf("Expected length 0, got %d", frame[1])
-	}
-}

host/watcher.go

@@ -1,169 +0,0 @@
-package host
-
-import (
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-)
-
-// Watcher monitors files for changes and triggers callbacks.
-type Watcher struct {
-	dir        string
-	extensions []string
-	onChange   func()
-	interval   time.Duration
-
-	mu       sync.Mutex
-	modTimes map[string]time.Time
-	stop     chan struct{}
-	wg       sync.WaitGroup
-}
-
-// WatcherOption configures a Watcher.
-type WatcherOption func(*Watcher)
-
-// WithExtensions sets file extensions to watch (e.g., ".go", ".html").
-func WithExtensions(exts ...string) WatcherOption {
-	return func(w *Watcher) {
-		w.extensions = exts
-	}
-}
-
-// WithInterval sets the polling interval for file changes.
-func WithInterval(d time.Duration) WatcherOption {
-	return func(w *Watcher) {
-		w.interval = d
-	}
-}
-
-// NewWatcher creates a new file watcher that monitors the specified directory.
-func NewWatcher(dir string, onChange func(), opts ...WatcherOption) *Watcher {
-	w := &Watcher{
-		dir:        dir,
-		extensions: []string{".go"},
-		onChange:   onChange,
-		interval:   500 * time.Millisecond,
-		modTimes:   make(map[string]time.Time),
-		stop:       make(chan struct{}),
-	}
-
-	for _, opt := range opts {
-		opt(w)
-	}
-
-	return w
-}
-
-// Start begins watching for file changes.
-func (w *Watcher) Start() error {
-	// Initial scan to populate mod times
-	if err := w.scan(false); err != nil {
-		return err
-	}
-
-	w.wg.Add(1)
-	go w.watch()
-	return nil
-}
-
-// Stop stops the watcher.
-func (w *Watcher) Stop() {
-	close(w.stop)
-	w.wg.Wait()
-}
-
-func (w *Watcher) watch() {
-	defer w.wg.Done()
-
-	ticker := time.NewTicker(w.interval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-w.stop:
-			return
-		case <-ticker.C:
-			if err := w.scan(true); err != nil {
-				// Log error but continue watching
-				continue
-			}
-		}
-	}
-}
-
-func (w *Watcher) scan(notify bool) error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	changed := false
-	seen := make(map[string]bool)
-
-	err := filepath.Walk(w.dir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return nil // Skip files we can't access
-		}
-
-		if info.IsDir() {
-			// Skip hidden directories and vendor
-			name := info.Name()
-			if len(name) > 0 && name[0] == '.' {
-				return filepath.SkipDir
-			}
-			if name == "vendor" || name == "node_modules" {
-				return filepath.SkipDir
-			}
-			return nil
-		}
-
-		// Check if extension matches
-		ext := filepath.Ext(path)
-		if !w.matchesExtension(ext) {
-			return nil
-		}
-
-		seen[path] = true
-		modTime := info.ModTime()
-
-		if prev, exists := w.modTimes[path]; !exists {
-			// New file
-			w.modTimes[path] = modTime
-			if notify {
-				changed = true
-			}
-		} else if !modTime.Equal(prev) {
-			// Modified file
-			w.modTimes[path] = modTime
-			changed = true
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		return err
-	}
-
-	// Check for deleted files
-	for path := range w.modTimes {
-		if !seen[path] {
-			delete(w.modTimes, path)
-			changed = true
-		}
-	}
-
-	if changed && notify && w.onChange != nil {
-		w.onChange()
-	}
-
-	return nil
-}
-
-func (w *Watcher) matchesExtension(ext string) bool {
-	for _, e := range w.extensions {
-		if e == ext {
-			return true
-		}
-	}
-	return false
-}

host/watcher_test.go

@@ -1,216 +0,0 @@
-package host
-
-import (
-	"os"
-	"path/filepath"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-func TestWatcher_DetectsNewFiles(t *testing.T) {
-	dir := t.TempDir()
-
-	// Create initial file
-	initialFile := filepath.Join(dir, "initial.go")
-	if err := os.WriteFile(initialFile, []byte("package main"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	var changeCount int32
-	w := NewWatcher(dir, func() {
-		atomic.AddInt32(&changeCount, 1)
-	}, WithInterval(50*time.Millisecond))
-
-	if err := w.Start(); err != nil {
-		t.Fatal(err)
-	}
-	defer w.Stop()
-
-	// Create new file
-	newFile := filepath.Join(dir, "new.go")
-	if err := os.WriteFile(newFile, []byte("package main"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	// Wait for detection
-	time.Sleep(200 * time.Millisecond)
-
-	if count := atomic.LoadInt32(&changeCount); count == 0 {
-		t.Error("Expected change to be detected for new file")
-	}
-}
-
-func TestWatcher_DetectsModifiedFiles(t *testing.T) {
-	dir := t.TempDir()
-
-	// Create initial file
-	file := filepath.Join(dir, "test.go")
-	if err := os.WriteFile(file, []byte("package main"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	var changeCount int32
-	w := NewWatcher(dir, func() {
-		atomic.AddInt32(&changeCount, 1)
-	}, WithInterval(50*time.Millisecond))
-
-	if err := w.Start(); err != nil {
-		t.Fatal(err)
-	}
-	defer w.Stop()
-
-	// Ensure mod time will be different
-	time.Sleep(100 * time.Millisecond)
-
-	// Modify file
-	if err := os.WriteFile(file, []byte("package main\n// updated"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	// Wait for detection
-	time.Sleep(200 * time.Millisecond)
-
-	if count := atomic.LoadInt32(&changeCount); count == 0 {
-		t.Error("Expected change to be detected for modified file")
-	}
-}
-
-func TestWatcher_DetectsDeletedFiles(t *testing.T) {
-	dir := t.TempDir()
-
-	// Create initial file
-	file := filepath.Join(dir, "test.go")
-	if err := os.WriteFile(file, []byte("package main"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	var changeCount int32
-	w := NewWatcher(dir, func() {
-		atomic.AddInt32(&changeCount, 1)
-	}, WithInterval(50*time.Millisecond))
-
-	if err := w.Start(); err != nil {
-		t.Fatal(err)
-	}
-	defer w.Stop()
-
-	// Delete file
-	if err := os.Remove(file); err != nil {
-		t.Fatal(err)
-	}
-
-	// Wait for detection
-	time.Sleep(200 * time.Millisecond)
-
-	if count := atomic.LoadInt32(&changeCount); count == 0 {
-		t.Error("Expected change to be detected for deleted file")
-	}
-}
-
-func TestWatcher_IgnoresNonMatchingExtensions(t *testing.T) {
-	dir := t.TempDir()
-
-	// Create initial go file
-	goFile := filepath.Join(dir, "main.go")
-	if err := os.WriteFile(goFile, []byte("package main"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	var changeCount int32
-	w := NewWatcher(dir, func() {
-		atomic.AddInt32(&changeCount, 1)
-	}, WithInterval(50*time.Millisecond), WithExtensions(".go"))
-
-	if err := w.Start(); err != nil {
-		t.Fatal(err)
-	}
-	defer w.Stop()
-
-	// Create non-matching file
-	txtFile := filepath.Join(dir, "readme.txt")
-	if err := os.WriteFile(txtFile, []byte("readme"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	// Wait
-	time.Sleep(200 * time.Millisecond)
-
-	if count := atomic.LoadInt32(&changeCount); count != 0 {
-		t.Error("Expected no change detected for non-matching extension")
-	}
-}
-
-func TestWatcher_CustomExtensions(t *testing.T) {
-	dir := t.TempDir()
-
-	// Create initial file
-	file := filepath.Join(dir, "style.css")
-	if err := os.WriteFile(file, []byte("body {}"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	var changeCount int32
-	w := NewWatcher(dir, func() {
-		atomic.AddInt32(&changeCount, 1)
-	}, WithInterval(50*time.Millisecond), WithExtensions(".css", ".html"))
-
-	if err := w.Start(); err != nil {
-		t.Fatal(err)
-	}
-	defer w.Stop()
-
-	// Ensure mod time will be different
-	time.Sleep(100 * time.Millisecond)
-
-	// Modify css file
-	if err := os.WriteFile(file, []byte("body { color: red; }"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	// Wait for detection
-	time.Sleep(200 * time.Millisecond)
-
-	if count := atomic.LoadInt32(&changeCount); count == 0 {
-		t.Error("Expected change to be detected for custom extension")
-	}
-}
-
-func TestWatcher_SkipsHiddenDirs(t *testing.T) {
-	dir := t.TempDir()
-
-	// Create hidden directory with go file
-	hiddenDir := filepath.Join(dir, ".hidden")
-	if err := os.MkdirAll(hiddenDir, 0755); err != nil {
-		t.Fatal(err)
-	}
-
-	// Create a visible go file first
-	visibleFile := filepath.Join(dir, "visible.go")
-	if err := os.WriteFile(visibleFile, []byte("package main"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	var changeCount int32
-	w := NewWatcher(dir, func() {
-		atomic.AddInt32(&changeCount, 1)
-	}, WithInterval(50*time.Millisecond))
-
-	if err := w.Start(); err != nil {
-		t.Fatal(err)
-	}
-	defer w.Stop()
-
-	// Create file in hidden directory
-	hiddenFile := filepath.Join(hiddenDir, "hidden.go")
-	if err := os.WriteFile(hiddenFile, []byte("package main"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	// Wait
-	time.Sleep(200 * time.Millisecond)
-
-	if count := atomic.LoadInt32(&changeCount); count != 0 {
-		t.Error("Expected no change detected for hidden directory")
-	}
-}