AGENTS.md

@@ -1,19 +0,0 @@
-# Agent Guidelines for clink
-
-## Build & Test Commands
-- Build: `go build -o clink .`
-- Cross-compile: `./build.sh` (creates binaries in `dist/` for all platforms)
-- Run client: `go run . -host localhost:9000`
-- Run server: `go run . -server -host localhost:9000`
-- Test: `go test ./...` (currently no tests)
-- Format: `gofmt -w .`
-- Lint: `go vet ./...`
-
-## Code Style
-- **Imports**: Standard library first, then third-party (blank line between), use named imports for clarity (e.g., `tea "github.com/charmbracelet/bubbletea"`)
-- **Formatting**: Use `gofmt`, tabs for indentation
-- **Types**: Explicit types, struct fields exported when needed for JSON/external use
-- **Naming**: CamelCase for exports, camelCase for private, descriptive names (e.g., `connectedMsg`, `fetchMenuCmd`)
-- **Error handling**: Check all errors explicitly, wrap with `fmt.Errorf("context: %w", err)` for context
-- **Comments**: Minimal, only for public APIs or complex logic
-- **Concurrency**: Use channels and goroutines for I/O operations (see `connectCmd`, `Hub.Run`)

README.md

@@ -1,664 +0,0 @@
-# Clink - TCP Socket-Based Order System
-
-## Overview
-
-Clink is a real-time order management system demonstrating TCP socket programming concepts in Go. The application consists of a TCP server that manages client connections and broadcasts order updates, and a Terminal User Interface (TUI) client that connects to the server to place orders and receive real-time updates from all connected clients.
-
-**Main Topic:** Socket Programming with TCP in Go
-
----
-
-## Architecture
-
-### Components
-
-1. **TCP Server** (`server.go`) - Multi-client socket server with broadcast capability
-2. **TUI Client** (`main.go`) - Interactive terminal client using TCP sockets
-3. **Protocol** - Custom text-based protocol over TCP
-
----
-
-## Socket Programming Concepts Demonstrated
-
-### 1. TCP Server Socket Creation
-
-**Location:** `server.go:252-256`
-
-```go
-func startTCPServer(addr string) error {
-    ln, err := net.Listen("tcp", addr)
-    if err != nil {
-        return err
-    }
-```
-
-- Uses `net.Listen()` to create a TCP listener socket
-- Binds to the specified address (default: `localhost:9000`)
-- Returns a `net.Listener` that can accept incoming connections
-
----
-
-### 2. Accepting Client Connections
-
-**Location:** `server.go:261-268`
-
-```go
-for {
-    c, err := ln.Accept()
-    if err != nil {
-        log.Printf("accept error: %v", err)
-        continue
-    }
-    go handleConn(hub, c)
-}
-```
-
-- `Accept()` blocks until a client connects
-- Each connection is handled in a separate goroutine
-- This enables concurrent handling of multiple clients
-
----
-
-### 3. Client Socket Connection
-
-**Location:** `main.go:484-493`
-
-```go
-func connectCmd(addr string) tea.Cmd {
-    return func() tea.Msg {
-        conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
-        if err != nil {
-            return statusMsg(fmt.Sprintf("Connect failed: %v", err))
-        }
-        return connectedMsg{conn: conn}
-    }
-}
-```
-
-- Uses `net.DialTimeout()` to establish TCP connection
-- Includes 3-second timeout to prevent indefinite blocking
-- Returns `net.Conn` interface for bidirectional communication
-
----
-
-### 4. Buffered Reading from Socket
-
-**Location:** `main.go:148-150`
-
-```go
-case connectedMsg:
-    m.conn = msg.conn
-    m.reader = bufio.NewReader(m.conn)
-```
-
-**Why Buffered Reading?**
-- Raw socket reads are byte-level and inefficient
-- `bufio.Reader` provides buffering and line-reading capabilities
-- **Critical:** Single `bufio.Reader` instance per connection prevents data corruption
-- Multiple readers on the same socket would compete for bytes
-
----
-
-### 5. Reading Greeting Messages
-
-**Location:** `main.go:153-159`
-
-```go
-_ = m.conn.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
-for i := 0; i < 2; i++ {
-    if _, err := m.reader.ReadString('\n'); err != nil {
-        break
-    }
-}
-_ = m.conn.SetReadDeadline(time.Time{})
-```
-
-- Server sends 2 greeting lines upon connection (lines 131-132 in `server.go`)
-- Client consumes these to prevent interference with protocol messages
-- **Socket Deadline:** Temporary 500ms timeout prevents indefinite blocking
-- Deadline is reset to zero (no timeout) after consuming greetings
-
----
-
-### 6. Writing to Socket
-
-**Location:** `main.go:506`, `main.go:544`
-
-```go
-// Sending MENU request
-fmt.Fprintln(conn, "MENU")
-
-// Sending ORDER request
-fmt.Fprintf(conn, "ORDER %s\n", string(b))
-```
-
-**Location:** `server.go:155`, `server.go:211`
-
-```go
-// Server responses
-fmt.Fprintln(c, string(b))           // MENU response
-fmt.Fprintf(c, "OK|%.2f\n", total)   // ORDER response
-```
-
-- `fmt.Fprintln()` and `fmt.Fprintf()` write to any `io.Writer`, including sockets
-- Newline-delimited protocol (each message ends with `\n`)
-- Text-based protocol for simplicity and debuggability
-
----
-
-### 7. Socket Read Deadlines (Timeouts)
-
-**Location:** `main.go:510-511`, `main.go:550-551`, `main.go:581-583`
-
-```go
-// Set 3-second timeout for MENU
-_ = conn.SetReadDeadline(time.Now().Add(3 * time.Second))
-defer func() { _ = conn.SetReadDeadline(time.Time{}) }()
-
-// Set 5-second timeout for ORDER
-_ = conn.SetReadDeadline(time.Now().Add(5 * time.Second))
-
-// Set 100ms timeout for broadcasts (polling)
-_ = conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
-```
-
-**Why Different Timeouts?**
-- **MENU/ORDER (3-5s):** Synchronous request-response, expect immediate reply
-- **Broadcasts (100ms):** Asynchronous polling loop, short timeout prevents blocking
-- Deadlines prevent reads from blocking forever if server stops responding
-
-**Deadline vs Timeout:**
-- `SetReadDeadline()` sets an absolute time
-- After deadline expires, read returns `net.Error` with `Timeout() == true`
-
----
-
-### 8. Handling Timeout Errors
-
-**Location:** `main.go:585-589`
-
-```go
-if err != nil {
-    if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
-        return broadcastMsg("")  // Timeout is expected, continue polling
-    }
-    return statusMsg(fmt.Sprintf("Connection closed: %v", err))
-}
-```
-
-- Type assertion to check if error is `net.Error`
-- Distinguish between timeout (expected) and connection failure
-- Timeouts in broadcast loop are normal behavior (polling mechanism)
-
----
-
-### 9. Concurrent Socket Communication Challenge
-
-**The Problem:** Race condition between synchronous requests and asynchronous broadcasts
-
-**Location:** `main.go:130`, `main.go:548`, `main.go:213-215`
-
-```go
-// Before ORDER: Pause broadcast listener
-m.pauseBroadcast = true
-
-// Wait for broadcast listener's current read to timeout
-time.Sleep(150 * time.Millisecond)
-
-// Broadcast handler: Slow down polling when paused
-if m.pauseBroadcast {
-    time.Sleep(50 * time.Millisecond)
-}
-```
-
-**Why This Is Needed:**
-- Single TCP socket shared between request-response and broadcast listening
-- Only one goroutine can read from socket at a time
-- Without coordination, broadcast listener might consume ORDER response
-- Solution: Coordinate reads using pause flag and timeouts
-
-**Timeline Without Coordination:**
-```
-Time    Action
-t=0     ORDER sent
-t=1     Broadcast listener reads "OK|9.00" (WRONG!)
-t=3000  submitOrderCmd times out (never got response)
-```
-
-**Timeline With Coordination:**
-```
-Time    Action
-t=0     pauseBroadcast = true
-t=0     ORDER sent
-t=150   Broadcast listener's 100ms timeout expires
-t=150   Broadcast listener sees pause, sleeps 50ms
-t=150   submitOrderCmd reads "OK|9.00" (SUCCESS!)
-t=200   Broadcast listener resumes with pause = false
-```
-
----
-
-### 10. Hub Pattern for Broadcasting
-
-**Location:** `server.go:36-80`
-
-```go
-type Hub struct {
-    mu      sync.Mutex
-    conns   map[net.Conn]struct{}
-    joinCh  chan net.Conn
-    leaveCh chan net.Conn
-    msgCh   chan broadcast
-}
-
-func (h *Hub) Run() {
-    for {
-        select {
-        case c := <-h.joinCh:
-            h.mu.Lock()
-            h.conns[c] = struct{}{}
-            h.mu.Unlock()
-        case c := <-h.leaveCh:
-            h.mu.Lock()
-            if _, ok := h.conns[c]; ok {
-                delete(h.conns, c)
-                _ = c.Close()
-            }
-            h.mu.Unlock()
-        case msg := <-h.msgCh:
-            h.mu.Lock()
-            for c := range h.conns {
-                if msg.exclude != nil && c == msg.exclude {
-                    continue
-                }
-                fmt.Fprintln(c, msg.text)  // Write to each socket
-            }
-            h.mu.Unlock()
-        }
-    }
-}
-```
-
-**Pattern Benefits:**
-- Centralized connection management
-- Thread-safe access to connection map using mutex
-- Fan-out broadcast to all connected sockets
-- Optional exclusion (don't echo back to sender)
-
-**Broadcasting an Order:** `server.go:207-209`
-```go
-h.msgCh <- broadcast{
-    text: fmt.Sprintf("[order] %s ordered %d × %s ($%.2f)", 
-                      ord.Name, ord.Quantity, chosen.Name, total),
-}
-```
-
----
-
-### 11. Per-Connection Handler
-
-**Location:** `server.go:115-248`
-
-```go
-func handleConn(h *Hub, c net.Conn) {
-    defer func() { h.leaveCh <- c }()
-    h.joinCh <- c
-    
-    scanner := bufio.NewScanner(c)
-    scanner.Buffer(make([]byte, 0, 1024), 64*1024)
-    
-    for scanner.Scan() {
-        line := strings.TrimSpace(scanner.Text())
-        // Protocol handling...
-    }
-}
-```
-
-**Key Points:**
-- Runs in separate goroutine per connection
-- `defer` ensures cleanup when connection closes
-- Uses `bufio.Scanner` for line-by-line reading
-- Handles multiple protocol commands: `MENU`, `ORDER`, `/name`, `/quit`
-
----
-
-### 12. Connection Lifecycle
-
-**Server Side:**
-1. `ln.Accept()` - Accept incoming connection (`server.go:262`)
-2. `h.joinCh <- c` - Register connection in hub (`server.go:117`)
-3. Send greeting messages (`server.go:131-132`)
-4. Process commands in loop (`server.go:141-240`)
-5. `h.leaveCh <- c` - Unregister and close (`server.go:116`)
-
-**Client Side:**
-1. `net.DialTimeout()` - Establish connection (`main.go:487`)
-2. Create `bufio.Reader` (`main.go:150`)
-3. Consume greeting messages (`main.go:153-159`)
-4. Send protocol commands (`MENU`, `ORDER`)
-5. Listen for broadcasts (`main.go:570-593`)
-6. `conn.Close()` - Close on quit (`main.go:234`)
-
----
-
-## Protocol Specification
-
-### Text-Based Protocol over TCP
-
-All messages are newline-delimited (`\n`).
-
-#### Client → Server
-
-**1. MENU Request**
-- Format: `MENU\n`
-- Location: `main.go:506`
-- Server handler: `server.go:149-157`
-- Response: JSON array of menu items
-
-**Example:**
-```
-Client: MENU
-Server: [{"id":"latte","name":"Caffè Latte","price":4.5},...]
-```
-
-**2. ORDER Request**
-- Format: `ORDER <json>\n`
-- Location: `main.go:544`
-- Server handler: `server.go:160-213`
-- Response: `OK|<total>\n`
-
-**Example:**
-```
-Client: ORDER {"name":"Alice","itemId":"latte","quantity":2}
-Server: OK|9.00
-```
-
-#### Server → Client (Broadcasts)
-
-**1. Order Broadcast**
-- Format: `[order] <name> ordered <qty> × <item> ($<total>)\n`
-- Location: `server.go:207-209`
-- Client handler: `main.go:205-216`
-
-**Example:**
-```
-[order] Alice ordered 2 × Caffè Latte ($9.00)
-```
-
-**2. Join/Leave Broadcasts**
-- Format: `[join] <username> (<id>)\n` or `[leave] <username> (<id>)\n`
-- Location: `server.go:135`, `server.go:247`
-
----
-
-## Application Flow
-
-### Server Startup Flow
-
-```
-1. main() [server.go:595]
-   └─ Parse flags: --server
-   
-2. startTCPServer() [server.go:251]
-   └─ net.Listen("tcp", addr)
-   
-3. hub.Run() [server.go:54]
-   └─ Goroutine: Handle join/leave/broadcast channels
-   
-4. Accept loop [server.go:261-268]
-   └─ For each connection:
-      └─ go handleConn(hub, conn)
-         ├─ Register: hub.joinCh <- conn
-         ├─ Send greeting [131-132]
-         ├─ Process commands [141-240]
-         │  ├─ MENU → JSON response [149-157]
-         │  ├─ ORDER → Validate, broadcast, ack [160-213]
-         │  └─ /name, /quit [216-236]
-         └─ Cleanup: hub.leaveCh <- conn [116]
-```
-
----
-
-### Client Startup Flow
-
-```
-1. main() [main.go:595]
-   └─ tea.NewProgram(initialModel(host))
-   
-2. Init() [main.go:88-91]
-   └─ Return connectCmd(host)
-   
-3. connectCmd() [main.go:484-493]
-   └─ net.DialTimeout("tcp", addr, 3s)
-   └─ Return connectedMsg{conn}
-   
-4. Update(connectedMsg) [main.go:148-161]
-   ├─ Create bufio.Reader(conn)
-   ├─ Consume 2 greeting lines
-   └─ Status: "Connected"
-```
-
----
-
-### Order Submission Flow (Client)
-
-```
-1. User presses 'n' [main.go:247]
-   └─ If menu cached: Show form
-   └─ Else: fetchMenuCmd()
-   
-2. fetchMenuCmd() [main.go:500-527]
-   ├─ Write: "MENU\n"
-   ├─ SetReadDeadline(3s)
-   └─ Read JSON response
-   
-3. Update(menuLoadedMsg) [main.go:163-175]
-   └─ Build and show order form
-   
-4. User fills form [name, item, quantity, confirm]
-   └─ Form completed [main.go:107-135]
-   
-5. If confirmed:
-   ├─ Set pauseBroadcast = true [130]
-   └─ submitOrderCmd() [534-567]
-      ├─ Marshal order to JSON
-      ├─ Write: "ORDER <json>\n"
-      ├─ Sleep 150ms (coordination)
-      ├─ SetReadDeadline(5s)
-      └─ Read: "OK|<total>\n"
-      
-6. Update(orderSubmittedMsg) [main.go:177-203]
-   ├─ Set pauseBroadcast = false
-   ├─ Display success status
-   ├─ If first order:
-   │  └─ Start broadcast listener
-   └─ Else:
-      └─ Resume broadcast listener
-```
-
----
-
-### Broadcast Listening Flow (Client)
-
-```
-1. Start after first order [main.go:192-194]
-   └─ Set broadcastListening = true
-   
-2. listenForBroadcastsCmd() [main.go:570-593]
-   ├─ SetReadDeadline(100ms)  # Poll with timeout
-   ├─ line, err := reader.ReadString('\n')
-   └─ Three outcomes:
-      ├─ Timeout → Return broadcastMsg("")
-      ├─ Error → Connection closed
-      └─ Success → Return broadcastMsg(line)
-      
-3. Update(broadcastMsg) [main.go:205-216]
-   ├─ If "[order]" prefix:
-   │  └─ Append to broadcasts list (max 10)
-   ├─ If pauseBroadcast:
-   │  └─ Sleep 50ms (slow down polling)
-   └─ Restart: listenForBroadcastsCmd()
-```
-
-**Polling Loop Visualization:**
-```
-Time (ms)  Action
-0          SetReadDeadline(+100ms)
-0-100      Blocking read...
-100        Timeout → broadcastMsg("")
-100        Handle message, restart
-100        SetReadDeadline(+100ms)
-100-200    Blocking read...
-150        [Data arrives: "[order] Alice..."]
-150        Success → broadcastMsg("[order]...")
-150        Handle message, append to list
-150        Restart loop
-```
-
----
-
-### Order Processing Flow (Server)
-
-```
-1. Receive: "ORDER <json>\n" [server.go:160]
-   
-2. Parse and validate [server.go:161-203]
-   ├─ json.Unmarshal(raw, &ord)
-   ├─ Check: ord.Name != ""
-   ├─ Check: ord.Quantity > 0
-   └─ Lookup: Find menuItem by ord.ItemID
-   
-3. Calculate total [server.go:205]
-   └─ total = quantity × price
-   
-4. Broadcast to all clients [server.go:207-209]
-   └─ hub.msgCh <- broadcast{...}
-      └─ Hub writes to ALL sockets [server.go:68-77]
-         └─ fmt.Fprintln(c, msg.text)
-   
-5. Acknowledge to sender [server.go:211]
-   └─ Write: "OK|<total>\n"
-```
-
----
-
-## Key Socket Programming Challenges & Solutions
-
-### Challenge 1: Single Socket, Dual Purpose
-
-**Problem:** Same socket used for:
-- Synchronous request-response (MENU, ORDER)
-- Asynchronous broadcast receiving
-
-**Solution:** 
-- Broadcast listener uses short (100ms) timeouts
-- Before synchronous requests: pause broadcast polling
-- Coordination via `pauseBroadcast` flag and sleep delays
-- Locations: `main.go:130`, `main.go:548`, `main.go:213-215`
-
----
-
-### Challenge 2: Buffered Reader Data Corruption
-
-**Problem:** Multiple `bufio.Reader` instances on same socket would:
-- Compete for bytes from socket buffer
-- Corrupt message boundaries
-- Cause incomplete/split messages
-
-**Solution:**
-- Single `bufio.Reader` created once at connection (`main.go:150`)
-- Shared across all read operations
-- Passed to all command functions
-
----
-
-### Challenge 3: Greeting Message Interference
-
-**Problem:** Server sends 2 greeting lines on connect
-- Would be parsed as protocol responses
-- MENU/ORDER reads would get greeting instead of response
-
-**Solution:**
-- Consume greetings immediately after connect (`main.go:153-159`)
-- Use short deadline (500ms) to prevent blocking
-- Clear socket buffer before protocol starts
-
----
-
-### Challenge 4: Connection Cleanup
-
-**Problem:** Connections must be cleaned up on:
-- Client disconnect
-- Server shutdown
-- Network errors
-
-**Solution (Server):**
-- `defer func() { h.leaveCh <- c }()` guarantees cleanup (`server.go:116`)
-- Hub centralizes close logic (`server.go:61-67`)
-
-**Solution (Client):**
-- Detect "Connection closed" in status messages (`main.go:220-227`)
-- Reset all socket-related state: `conn`, `reader`, `broadcastListening`
-
----
-
-## Summary
-
-This application demonstrates:
-
-1. **TCP Client-Server Architecture**
-   - Server: `net.Listen()`, `Accept()`, per-connection goroutines
-   - Client: `net.DialTimeout()`, shared connection
-
-2. **Custom Text Protocol**
-   - Newline-delimited messages
-   - Request-response (MENU, ORDER)
-   - Server-initiated broadcasts
-
-3. **Concurrent Socket Communication**
-   - Multiple clients handled concurrently (server)
-   - Synchronous + asynchronous reads on single socket (client)
-
-4. **Socket I/O Techniques**
-   - Buffered reading with `bufio.Reader`
-   - Read deadlines for timeouts
-   - Formatted writing with `fmt.Fprintf()`
-
-5. **Broadcast Pattern**
-   - Hub with channels for thread-safe fan-out
-   - Write to multiple sockets from single goroutine
-
-6. **Real-World Challenges**
-   - Read coordination between sync/async operations
-   - Connection lifecycle management
-   - Error handling and recovery
-
----
-
-## Running the Application
-
-**Start Server:**
-```bash
-go run . -server -host localhost:9000
-```
-
-**Start Client(s):**
-```bash
-go run . -host localhost:9000
-```
-
-**Client Controls:**
-- `n` - New order (loads menu if needed)
-- `r` - Reconnect
-- `q` - Quit
-
----
-
-## File Structure
-
-```
-clink/
-├── main.go       # TUI client with socket operations
-├── server.go     # TCP server with hub pattern
-└── README.md     # This documentation
-```

main.go

@@ -2,675 +2,282 @@ package main
 
 import (
 	"bufio"
-
-	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
+	"io"
 	"net"
-	"strconv"
+	"regexp"
+
 	"strings"
 	"time"
 
+	"github.com/charmbracelet/bubbles/textarea"
+	"github.com/charmbracelet/bubbles/viewport"
 	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/huh"
 	"github.com/charmbracelet/lipgloss"
 )
 
-type menuItem struct {
+// colorizeLine applies ANSI styling to usernames based on 6-hex-digit id from the server.
-	ID    string  `json:"id"`
+func colorizeLine(s string) string {
-	Name  string  `json:"name"`
+	reChat := regexp.MustCompile(`^(.+?) \(([0-9a-fA-F]{6})\):[ \t]*(.*)$`)
-	Price float64 `json:"price"`
+	if m := reChat.FindStringSubmatch(s); m != nil {
+		id := strings.ToLower(m[2])
+		nameStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#" + id)).Bold(true)
+		name := nameStyle.Render(m[1])
+		rest := strings.TrimSpace(m[3])
+		return fmt.Sprintf("%s: %s", name, rest)
+	}
+
+	reJoinLeave := regexp.MustCompile(`^\[(join|leave)\] (.+?) \(([0-9a-fA-F]{6})\)$`)
+	if m := reJoinLeave.FindStringSubmatch(s); m != nil {
+		id := strings.ToLower(m[3])
+		nameStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#" + id)).Bold(true)
+		uname := nameStyle.Render(m[2])
+		return fmt.Sprintf("[%s] %s", m[1], uname)
+	}
+
+	reRename := regexp.MustCompile(`^\[rename\] (.+?) \(([0-9a-fA-F]{6})\) -> (.+)$`)
+	if m := reRename.FindStringSubmatch(s); m != nil {
+		id := strings.ToLower(m[2])
+		nameStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#" + id)).Bold(true)
+		oldN := nameStyle.Render(m[1])
+		newN := nameStyle.Render(m[3])
+		return fmt.Sprintf("[rename] %s -> %s", oldN, newN)
+	}
+
+	reWelcome := regexp.MustCompile(`^Welcome (.+?) \(([0-9a-fA-F]{6})\)$`)
+	if m := reWelcome.FindStringSubmatch(s); m != nil {
+		id := strings.ToLower(m[2])
+		nameStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#" + id)).Bold(true)
+		uname := nameStyle.Render(m[1])
+		return fmt.Sprintf("Welcome %s", uname)
+	}
+
+	return s
 }
 
-// order represents the payload we submit back to the server.
+type netMsg string
+type connectedMsg struct{ conn net.Conn }
+type disconnectedMsg struct{}
+type errorMsg struct{ err error }
 
-// messages used by Bubble Tea
-type (
-	connectedMsg  struct{ conn net.Conn }
-	menuLoadedMsg struct {
-		items []menuItem
-		err   error
-	}
-	orderSubmittedMsg struct {
-		ack   string
-		total float64
-		err   error
-	}
-	broadcastMsg  string
-	statusMsg     string
-	serverLineMsg string
-)
-
-type FormFields struct {
-	name        string
-	itemID      string
-	quantityStr string
-	confirm     bool
-}
-
-// model holds the TUI state.
 type model struct {
-	host string
+	vp       viewport.Model
+	input    textarea.Model
+	messages []string
+
 	conn   net.Conn
-
+	server string
-	title      string
-	status     string
-	loading    bool
 	err    error
-	lastOrder  *order
-	broadcasts []string
-
-	form        *huh.Form
-	formFields  *FormFields
-	menu        []menuItem
-	name        string
-	itemID      string
-	quantityStr string
-	confirm     bool
-
-	width  int
-	height int
-
-	reader             *bufio.Reader
-	broadcastListening bool
-	pauseBroadcast     bool
 }
 
-// initialModel creates a base model.
+func initialModel(serverAddr string) model {
-func initialModel(host string) model {
+	vp := viewport.New(80, 20)
+	vp.Style = lipgloss.NewStyle().Border(lipgloss.NormalBorder()).Padding(0, 1).BorderForeground(lipgloss.Color("#bada55"))
+
+	ta := textarea.New()
+	ta.FocusedStyle.CursorLine = lipgloss.NewStyle()
+	ta.Placeholder = "Type message and press Enter..."
+	ta.Focus()
+	ta.Prompt = "┃ "
+	ta.CharLimit = 0
+	ta.SetHeight(2)
+	ta.ShowLineNumbers = false
+
 	return model{
-		host:       host,
+		vp:       vp,
-		title:      "Order Console",
+		input:    ta,
-		formFields: &FormFields{},
+		messages: []string{},
+		server:   serverAddr,
 	}
 }
 
 func (m model) Init() tea.Cmd {
-	// Connect on startup
-	return connectCmd(m.host)
-}
-
-func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	var cmds []tea.Cmd
-
-	// If a form is active, delegate to it first.
-	if m.form != nil {
-		var cmd tea.Cmd
-		form, cmd := m.form.Update(msg)
-
-		if f, ok := form.(*huh.Form); ok {
-			m.form = f
-			cmds = append(cmds, cmd)
-		}
-
-		if m.form.State == huh.StateCompleted {
-			// Parse and submit order if confirmed.
-			qty, err := strconv.Atoi(strings.TrimSpace(m.formFields.quantityStr))
-			if err != nil || qty <= 0 {
-				m.err = fmt.Errorf("invalid quantity: %v", m.formFields.quantityStr)
-				m.form = nil
-				return m, nil
-			}
-			ord := &order{
-				Name:     strings.TrimSpace(m.formFields.name),
-				ItemID:   m.formFields.itemID,
-				Quantity: qty,
-			}
-			m.lastOrder = ord
-			m.form = nil
-
-			if m.formFields.confirm {
-				if m.conn == nil {
-					m.status = "Not connected. Unable to submit order."
-					return m, nil
-				}
-				m.err = nil
-				m.loading = true
-				m.pauseBroadcast = true
-				m.status = "Submitting order..."
-				return m, submitOrderCmd(m.conn, *ord, m.reader)
-			}
-			m.status = "Order canceled."
-			if m.broadcastListening {
-				return m, listenForBroadcastsCmd(m.conn, m.reader)
-			}
-			return m, cmd
-		}
-
-		if m.form.State == huh.StateAborted {
-			m.status = "Order form aborted."
-			m.form = nil
-			if m.broadcastListening {
-				return m, listenForBroadcastsCmd(m.conn, m.reader)
-			}
-			return m, cmd
-		}
-
-		return m, tea.Batch(cmds...)
-	}
-
-	switch msg := msg.(type) {
-	case connectedMsg:
-		m.conn = msg.conn
-		m.reader = bufio.NewReader(m.conn)
-		m.status = fmt.Sprintf("Connected to %s", m.host)
-
-		_ = m.conn.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
-		for i := 0; i < 2; i++ {
-			if _, err := m.reader.ReadString('\n'); err != nil {
-				break
-			}
-		}
-		_ = m.conn.SetReadDeadline(time.Time{})
-
-		m.broadcastListening = true
-		return m, listenForBroadcastsCmd(m.conn, m.reader)
-
-	case menuLoadedMsg:
-		m.loading = false
-		m.pauseBroadcast = false
-		if msg.err != nil {
-			m.err = msg.err
-			m.status = "Failed to load menu."
-			if m.broadcastListening {
-				return m, listenForBroadcastsCmd(m.conn, m.reader)
-			}
-			return m, nil
-		}
-		m.err = nil
-		m.menu = msg.items
-		m.status = "Menu loaded."
-
-		m.form = m.buildForm()
-		if m.broadcastListening {
-			return m, tea.Batch(m.form.Init(), listenForBroadcastsCmd(m.conn, m.reader))
-		}
-		return m, m.form.Init()
-
-	case orderSubmittedMsg:
-		m.loading = false
-		m.pauseBroadcast = false
-		if msg.err != nil {
-			m.err = msg.err
-			m.status = "Order submission failed."
-			if m.broadcastListening {
-				return m, listenForBroadcastsCmd(m.conn, m.reader)
-			}
-			return m, nil
-		}
-		m.err = nil
-		if msg.total > 0 {
-			m.status = fmt.Sprintf("Order submitted. Total: $%.2f", msg.total)
-
-			if !m.broadcastListening {
-				m.broadcastListening = true
-				return m, listenForBroadcastsCmd(m.conn, m.reader)
-			}
-			return m, listenForBroadcastsCmd(m.conn, m.reader)
-		} else if msg.ack != "" {
-			m.status = fmt.Sprintf("Order submitted. Server says: %s", msg.ack)
-		}
-		if m.broadcastListening {
-			return m, listenForBroadcastsCmd(m.conn, m.reader)
-		}
-		return m, nil
-
-	case broadcastMsg:
-		msgText := string(msg)
-		if msgText != "" && strings.HasPrefix(msgText, "[order]") {
-			m.broadcasts = append(m.broadcasts, msgText)
-			if len(m.broadcasts) > 10 {
-				m.broadcasts = m.broadcasts[1:]
-			}
-		}
-		if m.pauseBroadcast {
-			return m, nil
-		}
-		return m, listenForBroadcastsCmd(m.conn, m.reader)
-	case statusMsg:
-		msgStr := string(msg)
-		m.status = msgStr
-		if strings.Contains(msgStr, "Connection closed") {
 	if m.conn != nil {
-				_ = m.conn.Close()
+		return tea.Batch(textarea.Blink, readLineCmd(m.conn))
-				m.conn = nil
 	}
-			m.broadcastListening = false
+	return tea.Batch(textarea.Blink, connectCmd(m.server))
-			m.reader = nil
-		}
-		return m, nil
-
-	case tea.KeyMsg:
-		switch msg.String() {
-		case "q", "ctrl+c", "esc":
-			if m.conn != nil {
-				_ = m.conn.Close()
-			}
-			return m, tea.Quit
-		case "r":
-			// Reconnect
-			if m.conn != nil {
-				_ = m.conn.Close()
-				m.conn = nil
-			}
-			m.broadcastListening = false
-			m.reader = nil
-			m.status = "Reconnecting..."
-			return m, connectCmd(m.host)
-		case "n":
-			if m.loading || m.form != nil {
-				return m, nil
-			}
-			if m.conn == nil {
-				m.status = "Not connected. Press 'r' to reconnect."
-				return m, nil
-			}
-			m.err = nil
-			if len(m.menu) > 0 {
-				m.form = m.buildForm()
-				return m, m.form.Init()
-			}
-			m.loading = true
-			m.pauseBroadcast = true
-			m.status = "Loading menu..."
-			return m, fetchMenuCmd(m.conn, m.reader)
-		}
-
-	case tea.WindowSizeMsg:
-		m.width = msg.Width
-		m.height = msg.Height
-	}
-
-	return m, nil
 }
 
-func (m model) renderHeader() string {
-	titleStyle := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("212"))
-	hostStyle := lipgloss.NewStyle().Faint(true)
-
-	title := titleStyle.Render(m.title)
-	host := hostStyle.Render(m.host)
-
-	header := lipgloss.JoinVertical(lipgloss.Center, title, host)
-	return lipgloss.NewStyle().Width(m.width).Align(lipgloss.Center).Render(header)
-}
-
-func (m model) renderLeftColumn() string {
-	lines := []string{}
-
-	if m.loading {
-		loadingText := "Loading..."
-		if m.status != "" {
-			loadingText = m.status
-		}
-		lines = append(lines, "Status: "+lipgloss.NewStyle().Foreground(lipgloss.Color("178")).Render(loadingText))
-	} else if m.status != "" {
-		lines = append(lines, "Status: "+m.status)
-	}
-
-	if m.err != nil {
-		lines = append(lines, lipgloss.NewStyle().Foreground(lipgloss.Color("9")).Render(fmt.Sprintf("Error: %v", m.err)))
-	}
-
-	if m.lastOrder != nil {
-		lines = append(lines, "", lipgloss.NewStyle().Bold(true).Render("Last Order:"))
-		lines = append(lines, fmt.Sprintf("  Name: %s", m.lastOrder.Name))
-		var label string
-		for _, it := range m.menu {
-			if it.ID == m.lastOrder.ItemID {
-				label = it.Name
-				break
-			}
-		}
-		if label != "" {
-			lines = append(lines, fmt.Sprintf("  Item: %s", label))
-		} else {
-			lines = append(lines, fmt.Sprintf("  Item: %s", m.lastOrder.ItemID))
-		}
-		lines = append(lines, fmt.Sprintf("  Quantity: %d", m.lastOrder.Quantity))
-	}
-
-	content := lipgloss.JoinVertical(lipgloss.Left, lines...)
-	return lipgloss.NewStyle().
-		Width(m.width/2 - 2).
-		Height(m.height - 6).
-		Padding(1).
-		Border(lipgloss.RoundedBorder()).
-		Render(content)
-}
-
-func (m model) renderRightColumn() string {
-	lines := []string{}
-	headerStyle := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("212"))
-	lines = append(lines, headerStyle.Render("Recent Orders:"))
-	lines = append(lines, "")
-
-	if len(m.broadcasts) == 0 {
-		lines = append(lines, lipgloss.NewStyle().Faint(true).Render("No orders yet..."))
-	} else {
-		bulletStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("141"))
-		nameStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("86")).Bold(true)
-		itemStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("117"))
-		priceStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("220")).Bold(true)
-
-		for _, b := range m.broadcasts {
-			msg := strings.TrimPrefix(b, "[order] ")
-			parts := strings.SplitN(msg, " ordered ", 2)
-			if len(parts) == 2 {
-				customer := parts[0]
-				orderDetails := parts[1]
-
-				line := fmt.Sprintf("%s %s ordered %s",
-					bulletStyle.Render("•"),
-					nameStyle.Render(customer),
-					itemStyle.Render(orderDetails))
-
-				if idx := strings.Index(orderDetails, "($"); idx != -1 {
-					priceStart := idx
-					priceEnd := strings.Index(orderDetails[priceStart:], ")")
-					if priceEnd != -1 {
-						priceEnd += priceStart + 1
-						beforePrice := orderDetails[:priceStart]
-						priceText := orderDetails[priceStart:priceEnd]
-
-						line = fmt.Sprintf("%s %s ordered %s %s",
-							bulletStyle.Render("•"),
-							nameStyle.Render(customer),
-							itemStyle.Render(beforePrice),
-							priceStyle.Render(priceText))
-					}
-				}
-
-				lines = append(lines, line)
-			}
-		}
-	}
-
-	content := lipgloss.JoinVertical(lipgloss.Left, lines...)
-	return lipgloss.NewStyle().
-		Width(m.width/2 - 2).
-		Height(m.height - 6).
-		Padding(1).
-		Border(lipgloss.RoundedBorder()).
-		Render(content)
-}
-
-func (m model) renderFooter() string {
-	connStatus := ""
-	if m.conn != nil {
-		connStatus = lipgloss.NewStyle().Foreground(lipgloss.Color("10")).Render("● Connected")
-	} else {
-		connStatus = lipgloss.NewStyle().Foreground(lipgloss.Color("9")).Render("● Disconnected")
-	}
-
-	controls := lipgloss.NewStyle().Faint(true).Render("n: New Order  r: Reconnect  q: Quit")
-
-	leftSide := connStatus
-	rightSide := controls
-
-	footer := lipgloss.JoinHorizontal(lipgloss.Top,
-		lipgloss.NewStyle().Width(m.width/2).Render(leftSide),
-		lipgloss.NewStyle().Width(m.width/2).Align(lipgloss.Right).Render(rightSide),
-	)
-
-	return lipgloss.NewStyle().Width(m.width).Render(footer)
-}
-
-func (m model) View() string {
-	if m.width == 0 || m.height == 0 {
-		return "Loading..."
-	}
-
-	header := m.renderHeader()
-
-	var leftCol string
-	if m.form != nil {
-		formView := m.form.WithHeight(m.height - 10).View()
-		leftCol = lipgloss.NewStyle().
-			Width(m.width/2 - 2).
-			Height(m.height - 6).
-			Padding(1).
-			Border(lipgloss.RoundedBorder()).
-			Render(formView)
-	} else {
-		leftCol = m.renderLeftColumn()
-	}
-
-	rightCol := m.renderRightColumn()
-	body := lipgloss.JoinHorizontal(lipgloss.Top, leftCol, rightCol)
-
-	footer := m.renderFooter()
-
-	return lipgloss.JoinVertical(lipgloss.Left,
-		header,
-		"",
-		body,
-		"",
-		footer,
-	)
-}
-
-// buildForm constructs the order form: Input (name) -> Select (menu) -> Input (qty) -> Confirm.
-func (m *model) buildForm() *huh.Form {
-	opts := make([]huh.Option[string], 0, len(m.menu))
-	for _, it := range m.menu {
-		opts = append(opts, huh.NewOption(fmt.Sprintf("%s - $%.2f", it.Name, it.Price), it.ID))
-	}
-
-	// Reset bound fields for a fresh form
-	m.formFields.name = ""
-	m.formFields.itemID = ""
-	m.formFields.quantityStr = ""
-	m.formFields.confirm = false
-
-	f := huh.NewForm(
-		huh.NewGroup(
-			huh.NewInput().
-				Title("Your name").
-				Prompt("> ").
-				Placeholder("Jane Doe").
-				Value(&m.formFields.name).
-				Validate(func(s string) error {
-					if strings.TrimSpace(s) == "" {
-						return errors.New("name is required")
-					}
-					return nil
-				}),
-			huh.NewSelect[string]().
-				Title("Menu item").
-				Options(opts...).
-				Value(&m.formFields.itemID).
-				Validate(func(v string) error {
-					if v == "" {
-						return errors.New("please select a menu item")
-					}
-					return nil
-				}),
-		),
-		huh.NewGroup(
-			huh.NewInput().
-				Title("Quantity").
-				Prompt("> ").
-				Placeholder("1").
-				Value(&m.formFields.quantityStr).
-				Validate(func(s string) error {
-					n, err := strconv.Atoi(strings.TrimSpace(s))
-					if err != nil || n <= 0 {
-						return errors.New("enter a positive integer")
-					}
-					return nil
-				}),
-			huh.NewConfirm().
-				Title("Place order?").
-				Affirmative("Yes").
-				Negative("No").
-				Value(&m.formFields.confirm),
-		),
-	).WithTheme(huh.ThemeBase())
-
-	return f
-}
-
-// connectCmd connects to the TCP server.
 func connectCmd(addr string) tea.Cmd {
 	return func() tea.Msg {
 		conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
 		if err != nil {
-			return statusMsg(fmt.Sprintf("Connect failed: %v", err))
+			return netMsg(fmt.Sprintf("[error] connect: %v", err))
 		}
 
 		return connectedMsg{conn: conn}
 	}
 }
 
-// fetchMenuCmd asks the server for a menu via the TCP connection.
+func readLineCmd(conn net.Conn) tea.Cmd {
-// Protocol (proposed):
-// - client: "MENU\n"
-// - server: single line JSON array: [{"id":"x","name":"..."}]\n
-func fetchMenuCmd(conn net.Conn, reader *bufio.Reader) tea.Cmd {
 	return func() tea.Msg {
-		if conn == nil || reader == nil {
+		if conn == nil {
-			return menuLoadedMsg{err: errors.New("not connected")}
+			return disconnectedMsg{}
 		}
 
-		time.Sleep(150 * time.Millisecond)
+		reader := bufio.NewReader(conn)
-
+		line, err := reader.ReadString('\n')
-		if _, err := fmt.Fprintln(conn, "MENU"); err != nil {
-			return menuLoadedMsg{err: fmt.Errorf("send MENU: %w", err)}
-		}
-
-		_ = conn.SetReadDeadline(time.Now().Add(3 * time.Second))
-		defer func() { _ = conn.SetReadDeadline(time.Time{}) }()
-
-		var line string
-		for {
-			l, err := reader.ReadString('\n')
 		if err != nil {
-				return menuLoadedMsg{err: fmt.Errorf("read MENU: %w", err)}
+			if errors.Is(err, io.EOF) {
+				return disconnectedMsg{}
 			}
-			l = strings.TrimRight(l, "\r\n")
+			return netMsg(fmt.Sprintf("[error] read: %v", err))
-			if strings.HasPrefix(l, "[join]") || strings.HasPrefix(l, "[leave]") || strings.HasPrefix(l, "[rename]") || strings.HasPrefix(l, "[order]") {
-				continue
-			}
-			line = l
-			break
 		}
 
-		if strings.HasPrefix(line, "[error]") {
+		return netMsg(strings.TrimRight(line, "\r\n"))
-			return menuLoadedMsg{err: fmt.Errorf("server: %s", line)}
-		}
-
-		var items []menuItem
-		if err := json.Unmarshal([]byte(line), &items); err != nil {
-			return menuLoadedMsg{err: fmt.Errorf("invalid menu JSON: %w", err)}
-		}
-		return menuLoadedMsg{items: items}
 	}
 }
 
-// submitOrderCmd sends the order over TCP.
+func sendCmd(conn net.Conn, text string) tea.Cmd {
-// Protocol (proposed):
-// - client: "ORDER <json>\n"
-// - server: a single line acknowledgement (freeform), e.g. "OK\n"
-func submitOrderCmd(conn net.Conn, ord order, reader *bufio.Reader) tea.Cmd {
 	return func() tea.Msg {
-		if conn == nil || reader == nil {
+		if conn == nil {
-			return orderSubmittedMsg{err: errors.New("not connected")}
+			return netMsg("[error] not connected")
 		}
-		b, err := json.Marshal(ord)
+
+		_, err := fmt.Fprintln(conn, text)
 		if err != nil {
-			return orderSubmittedMsg{err: fmt.Errorf("marshal order: %w", err)}
+			return netMsg(fmt.Sprintf("[error] send: %v", err))
 		}
-
-		if _, err := fmt.Fprintf(conn, "ORDER %s\n", string(b)); err != nil {
-			return orderSubmittedMsg{err: fmt.Errorf("send ORDER: %w", err)}
-		}
-
-		time.Sleep(150 * time.Millisecond)
-
-		_ = conn.SetReadDeadline(time.Now().Add(5 * time.Second))
-		defer func() { _ = conn.SetReadDeadline(time.Time{}) }()
-
-		var line string
-		for {
-			l, err := reader.ReadString('\n')
-			if err != nil {
-				return orderSubmittedMsg{err: fmt.Errorf("read ORDER ack: %w", err)}
-			}
-			l = strings.TrimRight(l, "\r\n")
-			if strings.HasPrefix(l, "[join]") || strings.HasPrefix(l, "[leave]") || strings.HasPrefix(l, "[rename]") || strings.HasPrefix(l, "[order]") {
-				continue
-			}
-			line = l
-			break
-		}
-
-		parts := strings.Split(line, "|")
-		ack := parts[0]
-		var total float64
-		if len(parts) > 1 {
-			if t, err := strconv.ParseFloat(parts[1], 64); err == nil {
-				total = t
-			}
-		}
-		return orderSubmittedMsg{ack: ack, total: total}
-	}
-}
-
-func listenForBroadcastsCmd(conn net.Conn, reader *bufio.Reader) tea.Cmd {
-	return func() tea.Msg {
-		defer func() {
-			if r := recover(); r != nil {
-				return
-			}
-		}()
-		if conn == nil || reader == nil {
 		return nil
 	}
+}
 
-		_ = conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-		line, err := reader.ReadString('\n')
+	var cmds []tea.Cmd
-		_ = conn.SetReadDeadline(time.Time{})
 
-		if err != nil {
+	switch msg := msg.(type) {
-			if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+
-				return broadcastMsg("")
+	case connectedMsg:
+		m.conn = msg.conn
+		m.messages = append(m.messages, "[connected]")
+		m.refreshViewport()
+
+		return m, readLineCmd(m.conn)
+
+	case disconnectedMsg:
+		m.messages = append(m.messages, "[disconnected]")
+		if m.conn != nil {
+			_ = m.conn.Close()
+			m.conn = nil
 		}
-			return statusMsg(fmt.Sprintf("Connection closed: %v", err))
+		m.refreshViewport()
+		return m, nil
+
+	case netMsg:
+		m.messages = append(m.messages, colorizeLine(string(msg)))
+		m.refreshViewport()
+
+		if m.conn != nil && !strings.HasPrefix(string(msg), "[error] read") {
+			cmds = append(cmds, readLineCmd(m.conn))
 		}
-		return broadcastMsg(strings.TrimRight(line, "\r\n"))
+
+	case tea.KeyMsg:
+		switch msg.Type {
+		case tea.KeyCtrlC, tea.KeyEsc:
+			if m.conn != nil {
+				_ = m.conn.Close()
 			}
+			return m, tea.Quit
+		case tea.KeyEnter:
+			text := m.input.Value()
+			if text != "" {
+				cmds = append(cmds, sendCmd(m.conn, text))
+				m.input.SetValue("")
+				m.refreshViewport()
+			}
+			return m, tea.Batch(cmds...)
+		}
+
+	case tea.WindowSizeMsg:
+		// Allocate space: viewport above, input below
+		m.vp.Width = msg.Width
+		m.vp.Height = msg.Height - 4
+		m.input.SetWidth(msg.Width - 2)
+		m.refreshViewport()
+	}
+
+	// Let textarea handle remaining keys
+	var cmd tea.Cmd
+	m.input, cmd = m.input.Update(msg)
+	if cmd != nil {
+		cmds = append(cmds, cmd)
+	}
+
+	return m, tea.Batch(cmds...)
+}
+
+func (m *model) refreshViewport() {
+	contentWidth := m.vp.Width - m.vp.Style.GetHorizontalFrameSize()
+
+	var b strings.Builder
+	for _, line := range m.messages {
+		wrapped := lipgloss.NewStyle().Width(contentWidth).Render(line)
+		b.WriteString(wrapped)
+		if !strings.HasSuffix(wrapped, "\n") {
+			b.WriteString("\n")
+		}
+	}
+	m.vp.SetContent(b.String())
+	m.vp.GotoBottom()
+}
+
+func (m model) View() string {
+	header := lipgloss.NewStyle().Width(m.vp.Width).Padding(0, 1).Align(lipgloss.Center).Foreground(lipgloss.Color("241")).Bold(true).Render(m.server)
+	return lipgloss.JoinVertical(
+		lipgloss.Left,
+		header,
+		m.vp.View(),
+		m.input.View(),
+	)
 }
 
 func main() {
 	var (
 		host       string
 		serverOnly bool
-		menuJSON   string
 	)
+
 	flag.StringVar(&host, "host", "localhost:9000", "host:port to connect to or bind the server on")
 	flag.BoolVar(&serverOnly, "server", false, "run only the server")
-	flag.StringVar(&menuJSON, "menu", "", "JSON array of menu items (server mode only), e.g. '[{\"id\":\"tea\",\"name\":\"Green Tea\",\"price\":2.5}]'")
 	flag.Parse()
 
 	if serverOnly {
-		var menu []menuItem
+		if err := startTCPServer(host); err != nil {
-		if menuJSON != "" {
-			if err := json.Unmarshal([]byte(menuJSON), &menu); err != nil {
-				fmt.Printf("Invalid menu JSON: %v\n", err)
-				return
-			}
-		}
-		if err := startTCPServer(host, menu); err != nil {
 			fmt.Println("Server error:", err)
 		}
 		return
 	}
 
+	time.Sleep(200 * time.Millisecond)
+
+	// Pre-connect and read initial welcome/instruction before starting UI
+	var preConn net.Conn
+	var preMsgs []string
+	if conn, err := net.DialTimeout("tcp", host, 3*time.Second); err == nil {
+		preConn = conn
+		// Read up to two initial lines with a short deadline
+		_ = conn.SetReadDeadline(time.Now().Add(1 * time.Second))
+		r := bufio.NewReader(conn)
+		for i := 0; i < 2; i++ {
+			line, err := r.ReadString('\n')
+			if err != nil {
+				break
+			}
+			preMsgs = append(preMsgs, strings.TrimRight(line, "\r\n"))
+		}
+		_ = conn.SetReadDeadline(time.Time{})
+	}
+
 	m := initialModel(host)
-	p := tea.NewProgram(m, tea.WithAltScreen())
+	if preConn != nil {
+		m.conn = preConn
+		m.messages = append(m.messages, preMsgs...)
+	}
+
+	p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion())
 	if _, err := p.Run(); err != nil {
-		fmt.Println("error:", err)
+		fmt.Println("Error:", err)
 	}
 }

server.go

@@ -2,32 +2,15 @@ package main
 
 import (
 	"bufio"
-	"encoding/json"
 	"fmt"
 	"log"
 	"net"
-	"strconv"
 	"strings"
 	"sync"
 
 	gonanoid "github.com/matoous/go-nanoid/v2"
 )
 
-var defaultMenu = []menuItem{
-	{ID: "latte", Name: "Caffè Latte", Price: 4.50},
-	{ID: "cap", Name: "Cappuccino", Price: 4.00},
-	{ID: "esp", Name: "Espresso", Price: 3.00},
-}
-
-var serverMenu []menuItem
-
-// order is the structure the server expects for ORDER.
-type order struct {
-	Name     string `json:"name"`
-	ItemID   string `json:"itemId"`
-	Quantity int    `json:"quantity"`
-}
-
 // broadcast represents a line to send to all connections with the ability
 // to exclude a single connection (e.g., exclude self on join).
 type broadcast struct {
@@ -146,75 +129,7 @@ func handleConn(h *Hub, c net.Conn) {
 			continue
 		}
 
-		// New protocol commands:
+		// Commands
-		// MENU -> server returns single-line JSON array of menuItem
-		if strings.EqualFold(line, "MENU") {
-			b, err := json.Marshal(serverMenu)
-			if err != nil {
-				fmt.Fprintln(c, `[error] failed to encode menu`)
-				continue
-			}
-			fmt.Fprintln(c, string(b))
-			continue
-		}
-
-		// ORDER <json> -> server validates and replies with a single-line ack
-		if strings.HasPrefix(line, "ORDER") {
-			raw := strings.TrimSpace(line[len("ORDER"):])
-			var ord order
-			if err := json.Unmarshal([]byte(raw), &ord); err != nil {
-				fmt.Fprintln(c, "[error] invalid order json")
-				continue
-			}
-			ord.Name = strings.TrimSpace(ord.Name)
-			log.Printf("ORDER parsed: name=%q itemId=%q qty=%d", ord.Name, ord.ItemID, ord.Quantity)
-			if ord.Name == "" {
-				fmt.Fprintln(c, "[error] missing name")
-				continue
-			}
-			// Fallback handling: accept numeric strings or floats for quantity
-			if ord.Quantity <= 0 {
-				var generic map[string]any
-				if err := json.Unmarshal([]byte(raw), &generic); err == nil {
-					if v, ok := generic["quantity"]; ok {
-						switch t := v.(type) {
-						case string:
-							if n, err := strconv.Atoi(strings.TrimSpace(t)); err == nil {
-								ord.Quantity = n
-							}
-						case float64:
-							ord.Quantity = int(t)
-						}
-					}
-				}
-			}
-			if ord.Quantity <= 0 {
-				fmt.Fprintln(c, "[error] invalid quantity")
-				continue
-			}
-			var chosen *menuItem
-			for i := range serverMenu {
-				if serverMenu[i].ID == ord.ItemID {
-					chosen = &serverMenu[i]
-					break
-				}
-			}
-			if chosen == nil {
-				fmt.Fprintln(c, "[error] unknown item")
-				continue
-			}
-
-			total := float64(ord.Quantity) * chosen.Price
-
-			h.msgCh <- broadcast{
-				text: fmt.Sprintf("[order] %s ordered %d × %s ($%.2f)", ord.Name, ord.Quantity, chosen.Name, total),
-			}
-
-			fmt.Fprintf(c, "OK|%.2f\n", total)
-			continue
-		}
-
-		// Chat commands
 		if line == "/quit" {
 			break // unified leave handling below
 		}
@@ -250,18 +165,12 @@ func handleConn(h *Hub, c net.Conn) {
 }
 
 // startTCPServer starts a TCP chat server and never returns unless an error occurs.
-func startTCPServer(addr string, menu []menuItem) error {
+func startTCPServer(addr string) error {
-	if len(menu) == 0 {
-		menu = defaultMenu
-	}
-	serverMenu = menu
-
 	ln, err := net.Listen("tcp", addr)
 	if err != nil {
 		return err
 	}
 	log.Printf("TCP chat server listening on %s", ln.Addr())
-	log.Printf("Menu items: %d", len(serverMenu))
 
 	hub := NewHub()
 	go hub.Run()