implement termproxy support in tsunami command

wavetermdev · sawka · Apr 27, 2026 · Apr 27, 2026 · Apr 27, 2026 · Apr 27, 2026
commit 507a988a88be9f95423320bcd74cbdb5a9f840e1
diff --git a/tsunami/build/build.go b/tsunami/build/build.go
@@ -95,6 +95,7 @@ type BuildOpts struct {
 	Verbose        bool
 	Open           bool
 	KeepTemp       bool
+	TermProxy      bool
 	OutputFile     string
 	ScaffoldPath   string
 	SdkReplacePath string
@@ -979,7 +980,17 @@ func TsunamiRun(opts BuildOpts) error {
 
 	runCmd.Stdin = os.Stdin
 
-	if opts.Open {
+	if opts.TermProxy {
+		runCmd.Stdout = os.Stdout
+		runCmd.Stderr = os.Stderr
+		runCmd.Env = append(os.Environ(), "TSUNAMI_TERMPROXY=1")
+		if err := runCmd.Start(); err != nil {
+			return fmt.Errorf("failed to start application: %w", err)
+		}
+		if err := runCmd.Wait(); err != nil {
+			return fmt.Errorf("application exited with error: %w", err)
+		}
+	} else if opts.Open {
 		// If --open flag is set, we need to capture stderr to parse the listening message
 		stderr, err := runCmd.StderrPipe()
 		if err != nil {

diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
@@ -105,11 +105,13 @@ var runCmd = &cobra.Command{
 		verbose, _ := cmd.Flags().GetBool("verbose")
 		open, _ := cmd.Flags().GetBool("open")
 		keepTemp, _ := cmd.Flags().GetBool("keeptemp")
+		termProxy, _ := cmd.Flags().GetBool("termproxy")
 		opts := build.BuildOpts{
 			AppPath:      args[0],
 			Verbose:      verbose,
 			Open:         open,
 			KeepTemp:     keepTemp,
+			TermProxy:    termProxy,
 			MoveFileBack: true,
 			SdkVersion:   TsunamiSdkVersion,
 		}
@@ -163,6 +165,7 @@ func init() {
 	runCmd.Flags().BoolP("verbose", "v", false, "Enable verbose output")
 	runCmd.Flags().Bool("open", false, "Open the application in the browser after starting")
 	runCmd.Flags().Bool("keeptemp", false, "Keep temporary build directory")
+	runCmd.Flags().Bool("termproxy", false, "Proxy HTTP through the terminal via OSC 9010")
 	rootCmd.AddCommand(runCmd)
 
 	packageCmd.Flags().BoolP("verbose", "v", false, "Enable verbose output")

diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
@@ -8,6 +8,7 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"io"
 	"io/fs"
 	"log"
 	"net"
@@ -21,11 +22,13 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
+	"github.com/wavetermdev/waveterm/tsunami/termlisten"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
 const TsunamiListenAddrEnvVar = "TSUNAMI_LISTENADDR"
+const TsunamiTermProxyEnvVar = "TSUNAMI_TERMPROXY"
 const DefaultListenAddr = "localhost:0"
 const DefaultComponentName = "App"
 
@@ -208,50 +211,53 @@ func (c *ClientImpl) RunMain() {
 }
 
 func (c *ClientImpl) listenAndServe(ctx context.Context) error {
-	// Create HTTP handlers
 	handlers := newHTTPHandlers(c)
 
-	// Create a new ServeMux and register handlers
 	mux := http.NewServeMux()
 	handlers.registerHandlers(mux, handlerOpts{
 		AssetsFS:     c.AssetsFS,
 		StaticFS:     c.StaticFS,
 		ManifestFile: c.ManifestFileBytes,
 	})
 
-	// Determine listen address from environment variable or use default
-	listenAddr := os.Getenv(TsunamiListenAddrEnvVar)
-	if listenAddr == "" {
-		listenAddr = DefaultListenAddr
-	}
+	server := &http.Server{Handler: mux}
 
-	// Create server and listen on specified address
-	server := &http.Server{
-		Addr:    listenAddr,
-		Handler: mux,
-	}
+	var listener net.Listener
+	var port int
 
-	// Start listening
-	listener, err := net.Listen("tcp", listenAddr)
-	if err != nil {
-		return fmt.Errorf("failed to listen: %v", err)
+	if os.Getenv(TsunamiTermProxyEnvVar) != "" {
+		tl, passthrough, err := termlisten.MakeListener(os.Stdin)
+		if err != nil {
+			return fmt.Errorf("termproxy: %w", err)
+		}
+		go io.Copy(io.Discard, passthrough)
+		termlisten.SetupSignals(tl, nil, nil)
+		listener = tl
+		port = tl.Port()
+	} else {
-	if shouldRunTsunamiTermProxy() {
-		tl, passthrough, err := termlisten.MakeListener(os.Stdin)
-		if err != nil {
-			return fmt.Errorf("terminal proxy unavailable: %v\n[tsunami] To bind a regular TCP port instead, run with --tcp", err)
-		}
-		go io.Copy(io.Discard, passthrough)
-		termlisten.SetupSignals(tl, nil, nil)
-		listener = tl
-		port = tl.Port()
-		sendOsc9009Tsunami(port)
-	} else {
+	if shouldRunTsunamiTermProxy() {
+		tl, passthrough, err := termlisten.MakeListener(os.Stdin)
+		if err != nil {
+			return fmt.Errorf("terminal proxy unavailable: %v\n[tsunami] To bind a regular TCP port instead, run with --tcp", err)
+		}
+		go io.Copy(io.Discard, passthrough)
+		termlisten.SetupSignals(tl, nil, sendOsc9009Tsunami)
+		listener = tl
+		port = tl.Port()
+		sendOsc9009Tsunami(port)
+	} else {
-	if shouldRunTsunamiTermProxy() {
-		tl, passthrough, err := termlisten.MakeListener(os.Stdin)
-		if err != nil {
-			return fmt.Errorf("terminal proxy unavailable: %v\n[tsunami] To bind a regular TCP port instead, run with --tcp", err)
-		}
-		go io.Copy(io.Discard, passthrough)
-		termlisten.SetupSignals(tl, nil, nil)
-		listener = tl
-		port = tl.Port()
-		sendOsc9009Tsunami(port)
-	} else {
+	if shouldRunTsunamiTermProxy() {
+		tl, passthrough, err := termlisten.MakeListener(os.Stdin)
+		if err != nil {
+			return fmt.Errorf("terminal proxy unavailable: %v\n[tsunami] To bind a regular TCP port instead, run with --tcp", err)
+		}
+		go io.Copy(io.Discard, passthrough)
+		termlisten.SetupSignals(tl, nil, sendOsc9009Tsunami)
+		listener = tl
+		port = tl.Port()
+		sendOsc9009Tsunami(port)
+	} else {
+		listenAddr := os.Getenv(TsunamiListenAddrEnvVar)
+		if listenAddr == "" {
+			listenAddr = DefaultListenAddr
+		}
+		server.Addr = listenAddr
+		var err error
+		listener, err = net.Listen("tcp", listenAddr)
+		if err != nil {
+			return fmt.Errorf("failed to listen: %v", err)
+		}
+		port = listener.Addr().(*net.TCPAddr).Port
 	}
 
-	// Log the address we're listening on
-	port := listener.Addr().(*net.TCPAddr).Port
 	log.Printf("[tsunami] listening at http://localhost:%d", port)
 
-	// Serve in a goroutine so we don't block
 	go func() {
 		if err := server.Serve(listener); err != nil && err != http.ErrServerClosed {
-			log.Printf("HTTP server error: %v", err)
+			c.doShutdown("http server closed")
 		}
 	}()
 
-	// Wait for context cancellation and shutdown server gracefully
 	go func() {
 		<-ctx.Done()
-		log.Printf("Context canceled, shutting down server...")
 		if err := server.Shutdown(context.Background()); err != nil {
 			log.Printf("Server shutdown error: %v", err)
 		}