feat: realtime HTML update via WebSocket

go.mod

@@ -2,4 +2,10 @@ module github.com/sun-praise/static-html
 
 go 1.24.1
 
-require github.com/mattn/go-sqlite3 v1.14.37
+require (
+	github.com/coder/websocket v1.8.14
+	github.com/fsnotify/fsnotify v1.10.1
+	github.com/mattn/go-sqlite3 v1.14.37
+)
+
+require golang.org/x/sys v0.13.0 // indirect

go.sum

@@ -1,2 +1,8 @@
+github.com/coder/websocket v1.8.14 h1:9L0p0iKiNOibykf283eHkKUHHrpG7f65OE3BhhO7v9g=
+github.com/coder/websocket v1.8.14/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
+github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
+github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
 github.com/mattn/go-sqlite3 v1.14.37 h1:3DOZp4cXis1cUIpCfXLtmlGolNLp2VEqhiB/PARNBIg=
 github.com/mattn/go-sqlite3 v1.14.37/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
+golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

internal/cli/cli.go

@@ -47,6 +47,8 @@ func Run(args []string, stdout io.Writer, stderr io.Writer) error {
 		return runSearch(args[1:], stdout)
 	case "delete":
 		return runDelete(args[1:], stdout)
+	case "watch":
+		return runWatch(args[1:], stdout)
 	default:
 		return fmt.Errorf("unknown command: %s", args[0])
 	}
@@ -61,7 +63,8 @@ func printUsage(w io.Writer) {
   sth project <session-id> <project> [--db /path/to/sessions.db] [--server http://...]
   sth list [--tag <tag>] [--category <cat>] [--project <proj>] [--limit <n>] [--offset <n>] [--db /path/to/sessions.db]
   sth search <query> [--tag <tag>] [--category <cat>] [--project <proj>] [--limit <n>] [--offset <n>] [--db /path/to/sessions.db]
-  sth delete <session-id> [--db /path/to/sessions.db]`)
+  sth delete <session-id> [--db /path/to/sessions.db]
+  sth watch <path> --session <id> [--server http://127.0.0.1:3939]`)
 }
 
 func runStart(args []string, stdout io.Writer) error {

internal/cli/watch.go

@@ -0,0 +1,258 @@
+package cli
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/sun-praise/static-html/internal/server"
+)
+
+func runWatch(args []string, stdout io.Writer) error {
+	flags, positionals, err := parseArgs(args)
+	if err != nil {
+		return err
+	}
+
+	if len(positionals) < 1 {
+		return errors.New("usage: sth watch <path> --session <id> [--server http://127.0.0.1:3939]")
+	}
+
+	sessionID := flags["session"]
+	if sessionID == "" {
+		return errors.New("--session is required")
+	}
+
+	serverURL := server.DefaultServerURL
+	if v, ok := flags["server"]; ok {
+		serverURL = v
+	}
+
+	watchPath, err := filepath.Abs(positionals[0])
+	if err != nil {
+		return fmt.Errorf("failed to resolve path: %w", err)
+	}
+
+	info, err := os.Stat(watchPath)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return fmt.Errorf("path does not exist: %q", watchPath)
+		}
+		return err
+	}
+	if !info.IsDir() {
+		return errors.New("watch path must be a directory")
+	}
+
+	if err := validateSession(serverURL, sessionID); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(stdout, "Watching %s → session %s\n", watchPath, sessionID)
+
+	return watchAndSync(context.Background(), watchPath, sessionID, serverURL, stdout)
+}
+
+func validateSession(serverURL, sessionID string) error {
+	parsedURL, err := url.Parse(serverURL)
+	if err != nil {
+		return fmt.Errorf("invalid server URL: %w", err)
+	}
+
+	resp, err := http.Get(parsedURL.ResolveReference(&url.URL{Path: "/api/sessions/" + sessionID + "/metadata"}).String())
+	if err != nil {
+		return fmt.Errorf("could not reach server at %s: %w", parsedURL.Host, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusNotFound {
+		return fmt.Errorf("session %q not found", sessionID)
+	}
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("server returned status %d", resp.StatusCode)
+	}
+	return nil
+}
+
+func watchAndSync(ctx context.Context, dir, sessionID, serverURL string, stdout io.Writer) error {
+	w, err := fsnotify.NewWatcher()
+	if err != nil {
+		return fmt.Errorf("failed to create file watcher: %w", err)
+	}
+	defer w.Close()
+
+	if err := addWatchDirs(w, dir); err != nil {
+		return fmt.Errorf("failed to set up file watching: %w", err)
+	}
+
+	ctx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	var (
+		mu         sync.Mutex
+		pending    = make(map[string]struct{})
+		debounce   *time.Timer
+	)
+	const debounceMs = 300 * time.Millisecond
+
+	flush := func() {
+		mu.Lock()
+		paths := make([]string, 0, len(pending))
+		for p := range pending {
+			paths = append(paths, p)
+		}
+		pending = make(map[string]struct{})
+		debounce = nil
+		mu.Unlock()
+
+		if len(paths) == 0 {
+			return
+		}
+
+		if err := uploadFiles(serverURL, sessionID, dir, paths); err != nil {
+			fmt.Fprintf(stdout, "Error syncing %d file(s): %v\n", len(paths), err)
+		} else {
+			for _, p := range paths {
+				rel, _ := filepath.Rel(dir, p)
+				fmt.Fprintf(stdout, "Synced: %s\n", rel)
+			}
+		}
+	}
+
+	for {
+		select {
+		case <-ctx.Done():
+			if debounce != nil {
+				debounce.Stop()
+			}
+			fmt.Fprintln(stdout, "\nStopped watching.")
+			return nil
+		case event, ok := <-w.Events:
+			if !ok {
+				return nil
+			}
+			if shouldIgnorePath(event.Name) {
+				continue
+			}
+			if event.Has(fsnotify.Create) {
+				if info, err := os.Stat(event.Name); err == nil && info.IsDir() {
+					_ = addWatchDirs(w, event.Name)
+					continue
+				}
+			}
+			mu.Lock()
+			pending[event.Name] = struct{}{}
+			mu.Unlock()
+			if debounce != nil {
+				debounce.Reset(debounceMs)
+			} else {
+				debounce = time.AfterFunc(debounceMs, flush)
+			}
+		case _, ok := <-w.Errors:
+			if !ok {
+				return nil
+			}
+		}
+	}
+}
+
+func addWatchDirs(w *fsnotify.Watcher, root string) error {
+	return filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if d.IsDir() && !shouldIgnorePath(path) {
+			return w.Add(path)
+		}
+		return nil
+	})
+}
+
+func uploadFiles(serverURL, sessionID, watchRoot string, paths []string) error {
+	pr, pw := io.Pipe()
+	mpw := multipart.NewWriter(pw)
+
+	go func() {
+		defer pw.Close()
+		for _, p := range paths {
+			f, err := os.Open(p)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "watch: cannot open %s: %v\n", p, err)
+				continue
+			}
+			info, err := f.Stat()
+			if err != nil || !info.Mode().IsRegular() {
+				f.Close()
+				continue
+			}
+			rel, err := filepath.Rel(watchRoot, p)
+			if err != nil {
+				f.Close()
+				continue
+			}
+			part, err := mpw.CreateFormFile("files", filepath.ToSlash(rel))
+			if err != nil {
+				f.Close()
+				_ = pw.CloseWithError(err)
+				return
+			}
+			if _, err := io.Copy(part, f); err != nil {
+				f.Close()
+				_ = pw.CloseWithError(err)
+				return
+			}
+			f.Close()
+		}
+		_ = mpw.Close()
+	}()
+
+	parsedURL, err := url.Parse(serverURL)
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequest(http.MethodPut,
+		parsedURL.ResolveReference(&url.URL{Path: "/api/sessions/" + sessionID + "/files"}).String(),
+		pr)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", mpw.FormDataContentType())
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("server returned %d", resp.StatusCode)
+	}
+	return nil
+}
+
+func shouldIgnorePath(path string) bool {
+	base := filepath.Base(path)
+	if strings.HasPrefix(base, ".") && base != "." && base != ".." {
+		return true
+	}
+	ext := strings.ToLower(filepath.Ext(base))
+	switch ext {
+	case ".swp", ".tmp":
+		return true
+	}
+	return false
+}

internal/live/client.go

@@ -0,0 +1,30 @@
+package live
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/coder/websocket"
+)
+
+type WSClient struct {
+	conn *websocket.Conn
+	mu   sync.Mutex
+}
+
+func NewWSClient(conn *websocket.Conn) *WSClient {
+	return &WSClient{conn: conn}
+}
+
+func (c *WSClient) Send(data []byte) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	_ = c.conn.Write(ctx, websocket.MessageText, data)
+}
+
+func (c *WSClient) Close() {
+	_ = c.conn.Close(websocket.StatusNormalClosure, "")
+}