feat(agent): implement /v1/serial endpoint

GET /v1/serial/{namespace}/{vm} streams the guest serial console log
(ttyS0) that was captured to disk by the Firecracker process stdout
redirect.

Without ?follow=true, the current file contents are streamed and the
connection is closed. With ?follow=true, the file is tailed: available
bytes are sent immediately, then the handler polls every 200 ms for
new data until the client disconnects.

Content-Type is set to text/plain; charset=utf-8. Returns 404 when
the log file does not yet exist.

Unit tests cover the 404 path and non-follow streaming of known content.

Author: syscod3

internal/agent/api/serial.go

@@ -2,8 +2,69 @@
 
 package api
 
-import "net/http"
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"time"
+)
 
-func (s *APIServer) handleSerial(w http.ResponseWriter, _ *http.Request) {
-	http.Error(w, "not implemented", http.StatusNotImplemented)
+func (s *APIServer) handleSerial(w http.ResponseWriter, r *http.Request) {
+	namespace := r.PathValue("namespace")
+	vmName := r.PathValue("vm")
+
+	logPath := filepath.Join(s.SocketDir, namespace+"-"+vmName+".serial.log")
+
+	f, err := os.Open(logPath)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			http.Error(w, fmt.Sprintf("serial log for %s/%s not found", namespace, vmName), http.StatusNotFound)
+			return
+		}
+		http.Error(w, "open serial log: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	defer f.Close() //nolint:errcheck
+
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+
+	follow := r.URL.Query().Get("follow") == "true"
+	if !follow {
+		// Stream the file contents and close.
+		w.WriteHeader(http.StatusOK)
+		_, _ = io.Copy(w, f) //nolint:errcheck
+		return
+	}
+
+	// Tail mode: stream available bytes, then poll every 200ms until the client
+	// disconnects (ctx.Done()) or the request context is cancelled.
+	w.WriteHeader(http.StatusOK)
+	flusher, canFlush := w.(http.Flusher)
+	ctx := r.Context()
+	buf := make([]byte, 32*1024)
+	for {
+		n, err := f.Read(buf)
+		if n > 0 {
+			_, _ = w.Write(buf[:n]) //nolint:errcheck
+			if canFlush {
+				flusher.Flush()
+			}
+		}
+		if err != nil && !errors.Is(err, io.EOF) {
+			return
+		}
+		if err == nil {
+			continue // there may be more data immediately
+		}
+		// EOF — wait for more data or client disconnect.
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(200 * time.Millisecond):
+			// poll again
+		}
+	}
 }