feat(playground): chat web sobre claude_wire (SSE interceptado de la red)

Backend Go (web/server.go) con SSE que por cada mensaje lanza claude_wire y
reenvia su NDJSON (text_delta + result) al navegador. Frontend vanilla
(web/index.html). Mensajes serializados (mutex: claude_wire usa puerto mitmproxy
fijo). Validado end-to-end: la respuesta llega token a token del SSE real
(O, K -> OK), sin parsear el render. ~9s por mensaje vs ~15s del chat de
claude_pipe. Puerto 8100.

playground/web/server.go

@@ -0,0 +1,123 @@
+// Command server is a browser chat over claude_wire — the network-intercept path.
+// For each message it launches claude_wire, which drives the interactive claude TUI
+// through a mitmproxy and reads the model's SSE off the wire, then relays the
+// resulting NDJSON (text_delta + result) to the browser as Server-Sent Events.
+//
+// Versus the claude_pipe chat (which parses the terminal render), this one shows the
+// exact model text token by token and finishes as soon as the model's message_stop
+// arrives — no blind idle wait. ~9s vs ~15s per message.
+//
+// claude_wire uses a fixed mitmproxy port, so messages are serialized with a mutex
+// (a chat is sequential anyway: you wait for the reply before sending the next).
+//
+// Each message is an independent one-shot claude session (no memory across turns).
+//
+// Run:
+//
+//	cd apps/claude_pipe && CGO_ENABLED=1 go build -tags fts5 -o claude_pipe .   # the TUI driver
+//	cd ../claude_wire   && go build -o claude_wire .                            # the runner
+//	cd playground       && go run ./web                                        # http://localhost:8100
+package main
+
+import (
+	"bufio"
+	_ "embed"
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sync"
+)
+
+//go:embed index.html
+var indexHTML []byte
+
+var (
+	wireBin string
+	root    string
+	one     sync.Mutex // serialize: one claude_wire at a time (fixed proxy port)
+)
+
+func main() {
+	port := flag.String("port", "8100", "port to listen on")
+	bin := flag.String("wire", "/home/enmanuel/fn_registry/apps/claude_wire/claude_wire", "path to the claude_wire binary")
+	rootDir := flag.String("root", "/home/enmanuel/fn_registry", "cwd for claude (MCP-approved repo)")
+	flag.Parse()
+
+	abs, err := filepath.Abs(*bin)
+	if err != nil {
+		log.Fatalf("resolve --wire: %v", err)
+	}
+	if _, err := os.Stat(abs); err != nil {
+		log.Fatalf("claude_wire binary not found at %s — build it first:\n  (cd .. && go build -o claude_wire .)", abs)
+	}
+	wireBin, root = abs, *rootDir
+
+	http.HandleFunc("/", handleIndex)
+	http.HandleFunc("/chat", handleChat)
+
+	log.Printf("claude_wire web chat → http://localhost:%s  (wire=%s root=%s)", *port, wireBin, root)
+	log.Fatal(http.ListenAndServe(":"+*port, nil))
+}
+
+func handleIndex(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path != "/" {
+		http.NotFound(w, r)
+		return
+	}
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	_, _ = w.Write(indexHTML)
+}
+
+// handleChat runs claude_wire for the prompt and relays its NDJSON as SSE.
+func handleChat(w http.ResponseWriter, r *http.Request) {
+	prompt := r.URL.Query().Get("prompt")
+	if prompt == "" {
+		http.Error(w, "missing prompt", http.StatusBadRequest)
+		return
+	}
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, "streaming unsupported", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+	w.Header().Set("X-Accel-Buffering", "no")
+
+	// Serialize: claude_wire binds a fixed mitmproxy port.
+	one.Lock()
+	defer one.Unlock()
+
+	cmd := exec.CommandContext(r.Context(), wireBin, "--prompt", prompt, "--cwd", root)
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		sse(w, flusher, "error", fmt.Sprintf(`{"message":%q}`, err.Error()))
+		return
+	}
+	cmd.Stderr = os.Stderr
+	if err := cmd.Start(); err != nil {
+		sse(w, flusher, "error", fmt.Sprintf(`{"message":%q}`, err.Error()))
+		return
+	}
+
+	sc := bufio.NewScanner(stdout)
+	sc.Buffer(make([]byte, 1024*1024), 1024*1024)
+	for sc.Scan() {
+		sse(w, flusher, "", sc.Text())
+	}
+	_ = cmd.Wait()
+	sse(w, flusher, "done", "{}")
+}
+
+func sse(w http.ResponseWriter, f http.Flusher, event, data string) {
+	if event != "" {
+		fmt.Fprintf(w, "event: %s\n", event)
+	}
+	fmt.Fprintf(w, "data: %s\n\n", data)
+	f.Flush()
+}