tsunami apps, autoload (resync), fix logging, fix sse handling (if multiple conns), update tw css...

Author: sawka

Taskfile.yml

@@ -498,7 +498,7 @@ tasks:
             - cd scaffold && npm pkg delete author
             - cd scaffold && npm pkg set author.name="Command Line Inc"
             - cd scaffold && npm pkg set author.email="info@commandline.dev"
-            - cd scaffold && npm --no-workspaces install tailwindcss@4.1.12 @tailwindcss/cli@4.1.12
+            - cd scaffold && npm --no-workspaces install tailwindcss@4.1.13 @tailwindcss/cli@4.1.13
             - cp -r dist scaffold/
             - cp ../templates/app-main.go.tmpl scaffold/app-main.go
             - cp ../templates/tailwind.css scaffold/

frontend/app/view/tsunami/tsunami.tsx

@@ -8,7 +8,7 @@ import { RpcApi } from "@/app/store/wshclientapi";
 import { TabRpcClient } from "@/app/store/wshrpcutil";
 import * as services from "@/store/services";
 import * as jotai from "jotai";
-import { memo } from "react";
+import { memo, useEffect } from "react";
 
 class TsunamiViewModel implements ViewModel {
     viewType: string;
@@ -65,6 +65,15 @@ class TsunamiViewModel implements ViewModel {
         }, 300);
     }
 
+    resyncController() {
+        const prtn = RpcApi.ControllerResyncCommand(TabRpcClient, {
+            tabid: globalStore.get(atoms.staticTabId),
+            blockid: this.blockId,
+            forcerestart: false,
+        });
+        prtn.catch((e) => console.log("error controller resync", e));
+    }
+
     forceRestartController() {
         if (globalStore.get(this.isRestarting)) {
             return;
@@ -98,6 +107,10 @@ const TsunamiView = memo(({ model }: TsunamiViewProps) => {
     const blockData = jotai.useAtomValue(model.blockAtom);
     const isRestarting = jotai.useAtomValue(model.isRestarting);
 
+    useEffect(() => {
+        model.resyncController();
+    }, [model]);
+
     const appPath = blockData?.meta?.["tsunami:apppath"];
     const controller = blockData?.meta?.controller;
 

package-lock.json

@@ -217,7 +217,7 @@ func (c *TsunamiController) Start(ctx context.Context, blockMeta waveobj.MetaMap
 		return fmt.Errorf("app cache is not executable: %s", cachePath)
 	}
 
-	tsunamiProc, err := runTsunamiAppBinary(ctx, cachePath)
+	tsunamiProc, err := runTsunamiAppBinary(ctx, cachePath, appPath)
 	if err != nil {
 		return fmt.Errorf("failed to run tsunami app: %w", err)
 	}
@@ -300,7 +300,7 @@ func (c *TsunamiController) SendInput(input *BlockInputUnion) error {
 	return fmt.Errorf("tsunami controller send input not implemented")
 }
 
-func runTsunamiAppBinary(ctx context.Context, appBinPath string) (*TsunamiAppProc, error) {
+func runTsunamiAppBinary(ctx context.Context, appBinPath string, appPath string) (*TsunamiAppProc, error) {
 	cmd := exec.Command(appBinPath, "--close-on-stdin")
 
 	stdoutPipe, err := cmd.StdoutPipe()
@@ -318,8 +318,17 @@ func runTsunamiAppBinary(ctx context.Context, appBinPath string) (*TsunamiAppPro
 		return nil, fmt.Errorf("failed to create stdin pipe: %w", err)
 	}
 
+	appName := build.GetAppName(appPath)
+	
 	stdoutBuffer := utilds.MakeReaderLineBuffer(stdoutPipe, 1000)
+	stdoutBuffer.SetLineCallback(func(line string) {
+		log.Printf("[tsunami:%s] %s\n", appName, line)
+	})
+	
 	stderrBuffer := utilds.MakeReaderLineBuffer(stderrPipe, 1000)
+	stderrBuffer.SetLineCallback(func(line string) {
+		log.Printf("[tsunami:%s] %s\n", appName, line)
+	})
 
 	err = cmd.Start()
 	if err != nil {
@@ -371,7 +380,6 @@ func runTsunamiAppBinary(ctx context.Context, appBinPath string) (*TsunamiAppPro
 				errChan <- fmt.Errorf("stderr buffer error: %w", err)
 				return
 			}
-			log.Printf("[stderr-readline] %s\n", line)
 
 			port := build.ParseTsunamiPort(line)
 			if port > 0 {

pkg/blockcontroller/tsunamicontroller.go

@@ -14,6 +14,7 @@ type ReaderLineBuffer struct {
 	reader         io.Reader
 	scanner        *bufio.Scanner
 	done           bool
+	lineCallback   func(string)
 }
 
 func MakeReaderLineBuffer(reader io.Reader, maxLines int) *ReaderLineBuffer {
@@ -33,6 +34,12 @@ func MakeReaderLineBuffer(reader io.Reader, maxLines int) *ReaderLineBuffer {
 	return rlb
 }
 
+func (rlb *ReaderLineBuffer) SetLineCallback(callback func(string)) {
+	rlb.lock.Lock()
+	defer rlb.lock.Unlock()
+	rlb.lineCallback = callback
+}
+
 func (rlb *ReaderLineBuffer) IsDone() bool {
 	rlb.lock.Lock()
 	defer rlb.lock.Unlock()
@@ -106,9 +113,12 @@ func (rlb *ReaderLineBuffer) GetTotalLineCount() int {
 
 func (rlb *ReaderLineBuffer) ReadAll() {
 	for {
-		_, err := rlb.ReadLine()
+		line, err := rlb.ReadLine()
 		if err != nil {
 			break
 		}
+		if rlb.lineCallback != nil {
+			rlb.lineCallback(line)
+		}
 	}
 }

pkg/utilds/readerlinebuffer.go

@@ -43,6 +43,10 @@ func (b BuildOpts) AppName() string {
 	return filepath.Base(b.AppPath)
 }
 
+func GetAppName(appPath string) string {
+	return filepath.Base(appPath)
+}
+
 type BuildEnv struct {
 	GoVersion   string
 	TempDir     string

tsunami/build/build.go

@@ -43,7 +43,8 @@ type ClientImpl struct {
 	IsDone             bool
 	DoneReason         string
 	DoneCh             chan struct{}
-	SSEventCh          chan ssEvent
+	SSEChannels        map[string]chan ssEvent // map of connectionId to SSE channel
+	SSEChannelsLock    *sync.Mutex
 	GlobalEventHandler func(event vdom.VDomEvent)
 	UrlHandlerMux      *http.ServeMux
 	SetupFn            func()
@@ -62,12 +63,13 @@ type ClientImpl struct {
 
 func makeClient() *ClientImpl {
 	client := &ClientImpl{
-		Lock:          &sync.Mutex{},
-		DoneCh:        make(chan struct{}),
-		SSEventCh:     make(chan ssEvent, 100),
-		UrlHandlerMux: http.NewServeMux(),
-		ServerId:      uuid.New().String(),
-		RootElem:      vdom.H(DefaultComponentName, nil),
+		Lock:            &sync.Mutex{},
+		DoneCh:          make(chan struct{}),
+		SSEChannels:     make(map[string]chan ssEvent),
+		SSEChannelsLock: &sync.Mutex{},
+		UrlHandlerMux:   http.NewServeMux(),
+		ServerId:        uuid.New().String(),
+		RootElem:        vdom.H(DefaultComponentName, nil),
 	}
 	client.Root = MakeRoot(client)
 	return client
@@ -214,18 +216,49 @@ func (c *ClientImpl) listenAndServe(ctx context.Context) error {
 	return nil
 }
 
-func (c *ClientImpl) SendAsyncInitiation() error {
-	log.Printf("send async initiation\n")
+func (c *ClientImpl) RegisterSSEChannel(connectionId string) chan ssEvent {
+	c.SSEChannelsLock.Lock()
+	defer c.SSEChannelsLock.Unlock()
+	
+	ch := make(chan ssEvent, 100)
+	c.SSEChannels[connectionId] = ch
+	return ch
+}
+
+func (c *ClientImpl) UnregisterSSEChannel(connectionId string) {
+	c.SSEChannelsLock.Lock()
+	defer c.SSEChannelsLock.Unlock()
+	
+	if ch, exists := c.SSEChannels[connectionId]; exists {
+		close(ch)
+		delete(c.SSEChannels, connectionId)
+	}
+}
+
+func (c *ClientImpl) SendSSEvent(event ssEvent) error {
 	if c.GetIsDone() {
 		return fmt.Errorf("client is done")
 	}
 
-	select {
-	case c.SSEventCh <- ssEvent{Event: "asyncinitiation", Data: nil}:
-		return nil
-	default:
-		return fmt.Errorf("SSEvent channel is full")
+	c.SSEChannelsLock.Lock()
+	defer c.SSEChannelsLock.Unlock()
+
+	// Send to all registered SSE channels
+	for connectionId, ch := range c.SSEChannels {
+		select {
+		case ch <- event:
+			// Successfully sent
+		default:
+			log.Printf("SSEvent channel is full for connection %s, skipping event", connectionId)
+		}
 	}
+
+	return nil
+}
+
+func (c *ClientImpl) SendAsyncInitiation() error {
+	log.Printf("send async initiation\n")
+	return c.SendSSEvent(ssEvent{Event: "asyncinitiation", Data: nil})
 }
 
 func makeNullRendered() *rpctypes.RenderedElem {

tsunami/engine/clientimpl.go

@@ -340,6 +340,13 @@ func (h *httpHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Generate unique connection ID for this SSE connection
+	connectionId := fmt.Sprintf("%s-%d", clientId, time.Now().UnixNano())
+	
+	// Register SSE channel for this connection
+	eventCh := h.Client.RegisterSSEChannel(connectionId)
+	defer h.Client.UnregisterSSEChannel(connectionId)
+
 	// Set SSE headers
 	setNoCacheHeaders(w)
 	w.Header().Set("Content-Type", "text/event-stream")
@@ -366,7 +373,7 @@ func (h *httpHandlers) handleSSE(w http.ResponseWriter, r *http.Request) {
 			// Send keepalive comment
 			fmt.Fprintf(w, ": keepalive\n\n")
 			rc.Flush()
-		case event := <-h.Client.SSEventCh:
+		case event := <-eventCh:
 			if event.Event == "" {
 				break
 			}

tsunami/engine/serverhandlers.go

@@ -27,12 +27,12 @@
         "tailwind-merge": "^3.3.1"
     },
     "devDependencies": {
-        "@tailwindcss/cli": "^4.1.12",
+        "@tailwindcss/cli": "^4.1.13",
         "@tailwindcss/vite": "^4.0.17",
         "@types/react": "^19",
         "@types/react-dom": "^19",
         "@vitejs/plugin-react-swc": "^4.0.1",
-        "tailwindcss": "^4.1.12",
+        "tailwindcss": "^4.1.13",
         "typescript": "^5.9.2",
         "vite": "^6.3.6"
     }

tsunami/frontend/package.json

@@ -60,3 +60,51 @@
     --ansi-brightcyan: #b7b8cb;
     --ansi-brightwhite: #f0f0f0;
 }
+
+/* Disable overscroll behavior */
+html, body {
+    overscroll-behavior: none;
+    overscroll-behavior-x: none;
+    overscroll-behavior-y: none;
+}
+
+/* Custom dark theme scrollbar */
+::-webkit-scrollbar {
+    width: 6px !important;
+    height: 6px !important;
+}
+
+::-webkit-scrollbar-track {
+    background: rgba(0, 0, 0, 0.1);
+    width: 6px !important;
+}
+
+::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.15);
+    border-radius: 3px;
+    width: 6px !important;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: rgba(255, 255, 255, 0.25);
+    width: 6px !important;
+}
+
+::-webkit-scrollbar-corner {
+    background: rgba(0, 0, 0, 0.1);
+}
+
+/* Force consistent scrollbar width across all states */
+::-webkit-scrollbar:horizontal {
+    height: 6px !important;
+}
+
+::-webkit-scrollbar:vertical {
+    width: 6px !important;
+}
+
+/* Firefox scrollbar styling */
+* {
+    scrollbar-width: thin;
+    scrollbar-color: rgba(255, 255, 255, 0.15) rgba(0, 0, 0, 0.1);
+}