Add TCP log stream broadcaster for real-time log streaming

- New internal/logstream package: captures Go log output and broadcasts
  to connected TCP clients via a listener on a random port
- DevTunnelCreate now accepts extra ports (log port) for forwarding
- Workflow engine exposes LogPort template variable
- tunnel.devtunnel_create action passes log_port param and captures it

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: yasithdev

internal/logstream/logstream.go

@@ -0,0 +1,100 @@
+package logstream
+
+import (
+	"io"
+	"log"
+	"net"
+	"sync"
+)
+
+// Broadcaster captures log output and fans it out to connected TCP clients.
+// It implements io.Writer so it can be installed via log.SetOutput.
+type Broadcaster struct {
+	mu      sync.RWMutex
+	clients map[net.Conn]struct{}
+	dest    io.Writer // original destination (os.Stderr)
+}
+
+// New creates a Broadcaster that tees to dest and any connected TCP clients.
+func New(dest io.Writer) *Broadcaster {
+	return &Broadcaster{
+		clients: make(map[net.Conn]struct{}),
+		dest:    dest,
+	}
+}
+
+// Write implements io.Writer. Every log line is written to the original
+// destination AND broadcast to all connected clients.
+func (b *Broadcaster) Write(p []byte) (int, error) {
+	n, err := b.dest.Write(p)
+
+	b.mu.RLock()
+	for c := range b.clients {
+		_, writeErr := c.Write(p)
+		if writeErr != nil {
+			// Mark for removal but don't modify map during iteration
+			go b.remove(c)
+		}
+	}
+	b.mu.RUnlock()
+
+	return n, err
+}
+
+func (b *Broadcaster) remove(c net.Conn) {
+	b.mu.Lock()
+	delete(b.clients, c)
+	b.mu.Unlock()
+	c.Close()
+}
+
+// ListenAndServe starts a TCP listener on addr and accepts clients that
+// receive the log stream. Returns the listener so the caller can retrieve
+// the bound port.
+func (b *Broadcaster) ListenAndServe(addr string) (net.Listener, error) {
+	ln, err := net.Listen("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	go func() {
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				return // listener closed
+			}
+			b.mu.Lock()
+			b.clients[conn] = struct{}{}
+			b.mu.Unlock()
+			log.Printf("[logstream] client connected from %s", conn.RemoteAddr())
+
+			// Drain reads so we detect client disconnect
+			go func(c net.Conn) {
+				buf := make([]byte, 256)
+				for {
+					if _, err := c.Read(buf); err != nil {
+						b.remove(c)
+						return
+					}
+				}
+			}(conn)
+		}
+	}()
+
+	return ln, nil
+}
+
+// Install redirects the standard logger to this broadcaster.
+func (b *Broadcaster) Install() {
+	log.SetOutput(b)
+}
+
+// Close disconnects all clients.
+func (b *Broadcaster) Close() {
+	b.mu.Lock()
+	for c := range b.clients {
+		c.Close()
+		delete(b.clients, c)
+	}
+	b.mu.Unlock()
+}

internal/workflow/actions.go

@@ -39,8 +39,9 @@ func actionDevTunnelCreate(params map[string]any) (*ActionResult, error) {
 	}
 	serverPort := toInt(params["server_port"])
 	sshPort := toInt(params["ssh_port"])
+	logPort := toInt(params["log_port"])
 
-	conn, err := tunnel.DevTunnelCreate(tunnelName, expiration, authToken, serverPort, sshPort)
+	conn, err := tunnel.DevTunnelCreate(tunnelName, expiration, authToken, serverPort, sshPort, logPort)
 	if err != nil {
 		return nil, err
 	}
@@ -51,6 +52,7 @@ func actionDevTunnelCreate(params map[string]any) (*ActionResult, error) {
 		"connection_url": conn.ConnectionURL,
 		"token":          conn.Token,
 		"ssh_port":       sshPort,
+		"log_port":       logPort,
 	}
 	return &result, nil
 }

main.go

@@ -16,6 +16,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/cyber-shuttle/linkspan/internal/logstream"
 	pm "github.com/cyber-shuttle/linkspan/internal/process"
 	"github.com/cyber-shuttle/linkspan/internal/workflow"
 	jupyter "github.com/cyber-shuttle/linkspan/subsystems/jupyter"
@@ -40,6 +41,11 @@ var (
 
 func main() {
 
+	// Install log broadcaster so connected clients receive log output in
+	// real time.  Must happen before any log.* calls.
+	logBroadcaster := logstream.New(os.Stderr)
+	logBroadcaster.Install()
+
 	// parse CLI flags
 	tunnelAPI := flag.String("tunnel-api", "devtunnels", "tunnel API provider name (e.g. devtunnels)")
 	tunnelEnable := flag.Bool("tunnel-enable", false, "enable tunnel startup")
@@ -221,6 +227,14 @@ func main() {
 	vscode.StartSSHServerForVSCodeConnection(sshSessionID, sshAddr)
 	log.Printf("SSH server listening on %s", sshAddr)
 
+	// Start log stream TCP listener so clients can connect for real-time logs.
+	logListener, err := logBroadcaster.ListenAndServe("0.0.0.0:0")
+	if err != nil {
+		log.Fatalf("failed to start log stream listener: %v", err)
+	}
+	logPort := logListener.Addr().(*net.TCPAddr).Port
+	log.Printf("log stream listening on 0.0.0.0:%d", logPort)
+
 	// Run workflow if specified. Use "-" to read from stdin.
 	if *workflowFile != "" {
 		var wf *workflow.WorkflowConfig
@@ -237,6 +251,7 @@ func main() {
 			"Timestamp":        time.Now().Unix(),
 			"ServerPort":       serverPort,
 			"SshPort":          sshPort,
+			"LogPort":          logPort,
 			"ServerHost":       serverHost,
 			"TunnelAuthToken":  *tunnelAuthToken,
 			"LocalTunnelID":    os.Getenv("CS_LOCAL_TUNNEL_ID"),

subsystems/tunnel/devtunnel.go

@@ -11,7 +11,7 @@ import (
 // DevTunnelCreate creates a tunnel, starts hosting the relay, and forwards the
 // given serverPort so the client can communicate with linkspan immediately.
 // Additional ports (e.g. SSH) can be added later via DevTunnelForward.
-func DevTunnelCreate(tunnelName string, expiration string, authToken string, serverPort int, sshPort int) (DevTunnelConnection, error) {
+func DevTunnelCreate(tunnelName string, expiration string, authToken string, serverPort int, sshPort int, extraPorts ...int) (DevTunnelConnection, error) {
 	if err := InitSDK(authToken); err != nil {
 		return DevTunnelConnection{}, fmt.Errorf("devtunnel create: init SDK: %w", err)
 	}
@@ -51,6 +51,16 @@ func DevTunnelCreate(tunnelName string, expiration string, authToken string, ser
 		info.Ports = append(info.Ports, sshPort)
 	}
 
+	// 2c. Register any extra ports (e.g. log stream).
+	for _, p := range extraPorts {
+		if p > 0 {
+			if err := SDKAddPort(ctx, tunnelName, p); err != nil {
+				return DevTunnelConnection{}, fmt.Errorf("devtunnel create: add extra port %d to %q: %w", p, tunnelName, err)
+			}
+			info.Ports = append(info.Ports, p)
+		}
+	}
+
 	// 3. Obtain host token and start the relay.
 	// Ports are already registered via SDK above — the CLI doesn't need -p flags
 	// (which would require manage scope the host token doesn't have).