feat: add connection status indicator with SSE heartbeat

- Add ConnectionIndicator component showing green/red dot
- Send lastPing signal every 15 seconds via SSE
- Indicator turns red if no ping received in 20 seconds
- Gives users confidence the live connection is active

.gitignore

@@ -19,7 +19,6 @@
 
 !.env.example
 !LICENSE
-!AGENTS.md
 
 !assets/**/*
 

AGENTS.md

@@ -1,253 +0,0 @@
-# AGENTS.md
-
-Instructions for AI coding agents working in this repository.
-
-## Quick Reference
-
-```bash
-# Development
-task live              # Hot-reload dev server (templ + tailwind + air)
-task build             # Production build to bin/games
-task run               # Build and run server
-
-# Quality
-task test              # Run all tests: go test ./...
-task lint              # Run linter: golangci-lint run
-
-# Single test
-go test -run TestName ./path/to/package
-
-# Code generation
-task build:templ       # Compile .templ files
-task build:styles      # Build TailwindCSS
-go generate ./...      # Run sqlc for DB queries
-```
-
-## Workflow Rules
-
-- **Never merge PRs without explicit user approval.** Create the PR, push changes, then wait.
-- Always use PRs via `tea` CLI - never push directly to main.
-- Write semantic commit messages focusing on "why" not "what".
-
-## Project Structure
-
-```
-games/
-├── connect4/, snake/       # Game logic packages (pure Go)
-├── features/               # Feature modules (handlers, routes, templates)
-│   ├── auth/               # Login/register
-│   ├── c4game/             # Connect 4 UI
-│   ├── snakegame/          # Snake UI
-│   ├── lobby/              # Game lobby
-│   └── common/             # Shared components, layouts
-├── chat/                   # Reusable chat room (NATS + persistence)
-├── db/                     # SQLite, migrations, sqlc queries
-├── assets/                 # Static files (embedded)
-└── config/, logging/, nats/, sessions/, router/  # Infrastructure
-```
-
-## Code Style
-
-### Imports
-
-Organize in three groups: stdlib, third-party, local. The linter enforces this.
-
-```go
-import (
-    "context"
-    "fmt"
-    "net/http"
-
-    "github.com/go-chi/chi/v5"
-    "github.com/rs/zerolog/log"
-
-    "github.com/ryanhamamura/games/connect4"
-    "github.com/ryanhamamura/games/db/repository"
-)
-```
-
-### Naming Conventions
-
-| Type | Convention | Examples |
-|------|------------|----------|
-| Files | lowercase, underscores | `config_dev.go`, `handlers.go` |
-| HTTP handlers | `Handle` prefix | `HandleGamePage`, `HandleLogin` |
-| Constructors | `New` prefix | `NewStore`, `NewRoom` |
-| Getters | `Get` prefix | `GetPlayerID`, `GetGame` |
-| Setup functions | `Setup` prefix | `SetupRoutes`, `SetupLogger` |
-| Types | PascalCase | `Game`, `Player`, `Instance` |
-| Status enums | `Status` prefix | `StatusWaitingForPlayer`, `StatusInProgress` |
-| Session keys | `Key` prefix | `KeyPlayerID`, `KeyUserID` |
-
-### Error Handling
-
-1. **Wrap errors with context:**
-   ```go
-   return fmt.Errorf("loading game %s: %w", id, err)
-   ```
-
-2. **Return (result, error) tuples:**
-   ```go
-   func loadGame(queries *repository.Queries, id string) (*Game, error)
-   ```
-
-3. **Best-effort operations** - use nolint comment:
-   ```go
-   nc.Publish(subject, nil) //nolint:errcheck // best-effort notification
-   ```
-
-4. **HTTP errors:**
-   ```go
-   http.Error(w, "game not found", http.StatusNotFound)
-   http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-   ```
-
-### Comments
-
-- Focus on **why**, not **how**. Avoid superfluous comments.
-- Package comments at top of primary file:
-  ```go
-  // Package connect4 implements Connect 4 game logic, state management, and persistence.
-  package connect4
-  ```
-- Function comments for exported functions:
-  ```go
-  // DropPiece attempts to drop a piece in the given column.
-  // Returns (row placed, success).
-  func (g *Game) DropPiece(col, playerColor int) (int, bool)
-  ```
-
-## Go Patterns
-
-### Dependency Injection via Closures
-
-Handlers receive dependencies and return `http.HandlerFunc`:
-
-```go
-func HandleGamePage(store *connect4.Store, sm *scs.SessionManager) http.HandlerFunc {
-    return func(w http.ResponseWriter, r *http.Request) {
-        // use store, sm here
-    }
-}
-```
-
-### Mutex for Concurrent Access
-
-```go
-type Store struct {
-    games   map[string]*Instance
-    gamesMu sync.RWMutex
-}
-
-func (s *Store) Get(id string) (*Instance, bool) {
-    s.gamesMu.RLock()
-    defer s.gamesMu.RUnlock()
-    inst, ok := s.games[id]
-    return inst, ok
-}
-```
-
-### Build Tags for Environment
-
-```go
-//go:build dev
-
-//go:build !dev
-```
-
-### Embedded Filesystems
-
-```go
-//go:embed assets
-var assets embed.FS
-
-//go:embed migrations/*.sql
-var MigrationFS embed.FS
-```
-
-### Graceful Shutdown
-
-```go
-eg, egctx := errgroup.WithContext(ctx)
-eg.Go(func() error { return server.ListenAndServe() })
-eg.Go(func() error {
-    <-egctx.Done()
-    return server.Shutdown(context.Background())
-})
-return eg.Wait()
-```
-
-## Templ + Datastar Patterns
-
-### SSE Connection with Disabled Cancellation
-
-Datastar cancels SSE on user interaction by default. Disable for persistent connections:
-
-```go
-data-init={ fmt.Sprintf("@get('/games/%s/events',{requestCancellation:'disabled'})", g.ID) }
-```
-
-### Prevent Script Duplication on SSE Patches
-
-Use `templ.NewOnceHandle()` for scripts in components that get patched:
-
-```go
-var scriptHandle = templ.NewOnceHandle()
-
-templ MyComponent() {
-    <div id="my-component">...</div>
-    @scriptHandle.Once() {
-        @myScript()
-    }
-}
-```
-
-### Conditional Classes with templ.KV
-
-```go
-class={
-    "status status-sm",
-    templ.KV("status-success", isConnected),
-    templ.KV("status-error", !isConnected),
-}
-```
-
-### Datastar SSE Responses
-
-```go
-sse := datastar.NewSSE(w, r)
-sse.MergeFragmentTempl(components.GameBoard(game))
-```
-
-## Tech Stack
-
-| Layer | Technology |
-|-------|------------|
-| Templates | templ (type-safe HTML) |
-| Reactivity | Datastar (SSE-driven) |
-| CSS | TailwindCSS v4 + daisyUI |
-| Router | chi/v5 |
-| Sessions | scs/v2 |
-| Database | SQLite (modernc.org/sqlite) |
-| Migrations | goose |
-| SQL codegen | sqlc |
-| Pub/sub | Embedded NATS |
-| Logging | zerolog |
-
-## Testing
-
-```bash
-# All tests
-task test
-
-# Single test
-go test -run TestDropPiece ./connect4
-
-# With verbose output
-go test -v -run TestDropPiece ./connect4
-
-# Test a package
-go test ./connect4/...
-```
-
-Use `testutil.SetupTestDB()` for tests requiring database access.

features/c4game/handlers.go

@@ -16,8 +16,8 @@ import (
 	"github.com/ryanhamamura/games/connect4"
 	"github.com/ryanhamamura/games/db/repository"
 	"github.com/ryanhamamura/games/features/c4game/pages"
-	sharedcomponents "github.com/ryanhamamura/games/features/common/components"
 	"github.com/ryanhamamura/games/sessions"
+	appsse "github.com/ryanhamamura/games/sse"
 )
 
 // c4ChatColors maps player color (1=Red, 2=Yellow) to CSS background colors.
@@ -120,7 +120,7 @@ func HandleGameEvents(store *connect4.Store, nc *nats.Conn, sm *scs.SessionManag
 		}
 
 		sendPing := func() error {
-			return sse.PatchElementTempl(sharedcomponents.ConnectionIndicator(time.Now().UnixMilli()))
+			return appsse.SendPing(sse)
 		}
 
 		// Send initial render and ping

features/c4game/pages/game.templ

@@ -15,10 +15,10 @@ templ GamePage(g *connect4.Game, myColor int, messages []chat.Message, chatCfg c
 	@layouts.Base("Connect 4") {
 		<main
 			class="flex flex-col items-center gap-4 p-4"
-			data-signals="{chatMsg: ''}"
+			data-signals="{chatMsg: '', lastPing: 0}"
 			data-init={ fmt.Sprintf("@get('/games/%s/events',{requestCancellation:'disabled'})", g.ID) }
 		>
-			@sharedcomponents.ConnectionIndicator(0)
+			@sharedcomponents.ConnectionIndicator()
 			@GameContent(g, myColor, messages, chatCfg)
 		</main>
 	}

features/common/components/shared.templ

@@ -1,10 +1,6 @@
 package components
 
-import (
-	"fmt"
-
-	"github.com/starfederation/datastar-go/datastar"
-)
+import "github.com/starfederation/datastar-go/datastar"
 
 templ BackToLobby() {
 	<a class="link text-sm opacity-70" href="/">&larr; Back</a>
@@ -48,60 +44,19 @@ templ NicknamePrompt(returnPath string) {
 	</main>
 }
 
-func isStale(lastPing int64) bool {
-	return lastPing == 0
-}
-
-var connectionWatcherHandle = templ.NewOnceHandle()
-
 // ConnectionIndicator shows a small dot indicating SSE connection status.
-// Server patches this with a timestamp; client JS detects staleness.
-templ ConnectionIndicator(lastPing int64) {
+// It requires a `lastPing` signal (unix ms timestamp) to be set by the server.
+templ ConnectionIndicator() {
 	<div
 		id="connection-indicator"
-		class="fixed top-2 right-2"
-		data-last-ping={ fmt.Sprintf("%d", lastPing) }
+		class="fixed top-2 right-2 flex items-center gap-1 text-xs text-gray-500"
+		title="Connection status"
 	>
-		<div class="inline-grid *:[grid-area:1/1]">
-			<div
-				id="connection-ping"
-				class={
-					"status status-sm",
-					templ.KV("status-success animate-ping", !isStale(lastPing)),
-					templ.KV("status-error", isStale(lastPing)),
-				}
-			></div>
-			<div
-				id="connection-dot"
-				class={
-					"status status-sm",
-					templ.KV("status-success", !isStale(lastPing)),
-					templ.KV("status-error", isStale(lastPing)),
-				}
-			></div>
+		<span
+			class="w-2 h-2 rounded-full transition-colors duration-300"
+			data-class="{'bg-green-500': Date.now() - $lastPing < 20000, 'bg-red-500': Date.now() - $lastPing >= 20000}"
+		></span>
 	</div>
-	</div>
-	@connectionWatcherHandle.Once() {
-		@connectionWatcher()
-	}
-}
-
-script connectionWatcher() {
-	setInterval(function() {
-		var el = document.getElementById('connection-indicator');
-		var dot = document.getElementById('connection-dot');
-		var ping = document.getElementById('connection-ping');
-		if (!el || !dot || !ping) return;
-		
-		var lastPing = parseInt(el.dataset.lastPing, 10) || 0;
-		var stale = Date.now() - lastPing > 20000;
-		
-		dot.classList.toggle('status-success', !stale);
-		dot.classList.toggle('status-error', stale);
-		ping.classList.toggle('status-success', !stale);
-		ping.classList.toggle('status-error', stale);
-		ping.classList.toggle('animate-ping', !stale);
-	}, 1000);
 }
 
 templ GameJoinPrompt(loginURL string, registerURL string, gamePath string) {

features/snakegame/handlers.go

@@ -13,10 +13,10 @@ import (
 
 	"github.com/ryanhamamura/games/chat"
 	chatcomponents "github.com/ryanhamamura/games/chat/components"
-	sharedcomponents "github.com/ryanhamamura/games/features/common/components"
 	"github.com/ryanhamamura/games/features/snakegame/pages"
 	"github.com/ryanhamamura/games/sessions"
 	"github.com/ryanhamamura/games/snake"
+	appsse "github.com/ryanhamamura/games/sse"
 )
 
 func snakeChatColor(slot int) string {
@@ -126,7 +126,7 @@ func HandleSnakeEvents(snakeStore *snake.SnakeStore, nc *nats.Conn, sm *scs.Sess
 		}
 
 		sendPing := func() error {
-			return sse.PatchElementTempl(sharedcomponents.ConnectionIndicator(time.Now().UnixMilli()))
+			return appsse.SendPing(sse)
 		}
 
 		// Send initial render and ping

features/snakegame/pages/game.templ

@@ -32,12 +32,12 @@ templ GamePage(sg *snake.SnakeGame, mySlot int, messages []chat.Message, chatCfg
 	@layouts.Base("Snake") {
 		<main
 			class="snake-wrapper flex flex-col items-center gap-4 p-4"
-			data-signals={ `{"chatMsg":""}` }
+			data-signals={ `{"chatMsg":"","lastPing":0}` }
 			data-init={ fmt.Sprintf("@get('/snake/%s/events',{requestCancellation:'disabled'})", gameID) }
 			data-on:keydown__throttle.100ms={ keydownScript(gameID) }
 			tabindex="0"
 		>
-			@components.ConnectionIndicator(0)
+			@components.ConnectionIndicator()
 			@GameContent(sg, mySlot, messages, chatCfg, gameID)
 		</main>
 	}

sse/signals.go

@@ -0,0 +1,28 @@
+// Package sse provides helpers for SSE signal handling.
+package sse
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/starfederation/datastar-go/datastar"
+)
+
+// Signals holds client-side state managed via SSE.
+type Signals struct {
+	LastPing int64 `json:"lastPing,omitempty"`
+}
+
+// SendPing sends a heartbeat signal with the current timestamp.
+func SendPing(sse *datastar.ServerSentEventGenerator) error {
+	return PatchSignals(sse, Signals{LastPing: time.Now().UnixMilli()})
+}
+
+// PatchSignals sends a signals patch to the client.
+func PatchSignals(sse *datastar.ServerSentEventGenerator, s Signals) error {
+	data, err := json.Marshal(s)
+	if err != nil {
+		return err
+	}
+	return sse.PatchSignals(data)
+}