tsunami framework (waveapps v2)

.vscode/settings.json

@@ -59,6 +59,7 @@
     "gopls": {
         "analyses": {
             "QF1003": false
-        }
+        },
+        "directoryFilters": ["-tsunami/frontend/scaffold"]
     }
 }

Taskfile.yml

@@ -438,3 +438,90 @@ tasks:
               ignore_error: true
             - cmd: '{{.RMRF}} "dist"'
               ignore_error: true
+
+    tsunami:demo:todo:
+        desc: Run the tsunami todo demo application
+        cmd: go run demo/todo/*.go
+        dir: tsunami
+        env:
+            TSUNAMI_LISTENADDR: "localhost:12026"
+
+    tsunami:frontend:dev:
+        desc: Run the tsunami frontend vite dev server
+        cmd: npm run dev
+        dir: tsunami/frontend
+
+    tsunami:frontend:build:
+        desc: Build the tsunami frontend
+        cmd: yarn build
+        dir: tsunami/frontend
+
+    tsunami:frontend:devbuild:
+        desc: Build the tsunami frontend in development mode (with source maps and symbols)
+        cmd: yarn build:dev
+        dir: tsunami/frontend
+
+    tsunami:scaffold:
+        desc: Build scaffold for tsunami frontend development
+        deps:
+            - tsunami:frontend:build
+        cmds:
+            - task: tsunami:scaffold:internal
+
+    tsunami:devscaffold:
+        desc: Build scaffold for tsunami frontend development (with source maps and symbols)
+        deps:
+            - tsunami:frontend:devbuild
+        cmds:
+            - task: tsunami:scaffold:internal
+
+    tsunami:scaffold:internal:
+        desc: Internal task to create scaffold directory structure
+        dir: tsunami/frontend
+        internal: true
+        cmds:
+            - cmd: "{{.RMRF}} scaffold"
+              ignore_error: true
+            - mkdir scaffold
+            - cd scaffold && npm --no-workspaces init -y --init-license Apache-2.0
+            - cd scaffold && npm pkg set name=tsunami-scaffold
+            - cd scaffold && npm pkg delete author
+            - cd scaffold && npm pkg set author.name="Command Line Inc"
+            - cd scaffold && npm pkg set author.email="[email protected]"
+            - cd scaffold && npm --no-workspaces install tailwindcss @tailwindcss/cli
+            - cp -r dist scaffold/
+            - cp ../templates/app-main.go.tmpl scaffold/app-main.go
+            - cp ../templates/tailwind.css scaffold/
+            - cp ../templates/gitignore.tmpl scaffold/.gitignore
+
+    tsunami:build:
+        desc: Build the tsunami binary.
+        cmds:
+            - cmd: "{{.RM}} bin/tsunami*"
+              ignore_error: true
+            - mkdir -p bin
+            - cd tsunami && go build -ldflags "-X main.BuildTime=$({{.DATE}} +'%Y%m%d%H%M') -X main.TsunamiVersion={{.VERSION}}" -o ../bin/tsunami{{exeExt}} cmd/main-tsunami.go
+        sources:
+            - "tsunami/**/*.go"
+            - "tsunami/go.mod"
+            - "tsunami/go.sum"
+        generates:
+            - "bin/tsunami{{exeExt}}"
+
+    tsunami:clean:
+        desc: Clean tsunami frontend build artifacts
+        dir: tsunami/frontend
+        cmds:
+            - cmd: "{{.RMRF}} dist"
+              ignore_error: true
+            - cmd: "{{.RMRF}} scaffold"
+              ignore_error: true
+
+    godoc:
+        desc: Start the Go documentation server for the root module
+        cmd: $(go env GOPATH)/bin/pkgsite -http=:6060
+
+    tsunami:godoc:
+        desc: Start the Go documentation server for the tsunami module
+        cmd: $(go env GOPATH)/bin/pkgsite -http=:6060
+        dir: tsunami

frontend/app/view/vdom/vdom.tsx

@@ -16,7 +16,6 @@ import {
     validateAndWrapCss,
     validateAndWrapReactStyle,
 } from "@/app/view/vdom/vdom-utils";
-import "./vdom.scss";
 
 const TextTag = "#text";
 const FragmentTag = "#fragment";
@@ -506,7 +505,7 @@ function VDomView({ blockId, model }: VDomViewProps) {
     model.viewRef = viewRef;
     const vdomClass = "vdom-" + blockId;
     return (
-        <div className={clsx("view-vdom", vdomClass)} ref={viewRef}>
+        <div className={clsx("overflow-auto w-full min-h-full", vdomClass)} ref={viewRef}>
             {contextActive ? <VDomInnerView blockId={blockId} model={model} /> : null}
         </div>
     );

frontend/types/gotypes.d.ts

@@ -837,6 +837,7 @@ declare global {
         "debug:panictype"?: string;
         "block:view"?: string;
         "ai:backendtype"?: string;
+        "ai:local"?: boolean;
         "wsh:cmd"?: string;
         "wsh:haderror"?: boolean;
         "conn:conntype"?: string;

go.mod

@@ -1,6 +1,6 @@
 module github.com/wavetermdev/waveterm
 
-go 1.24.2
+go 1.24.6
 
 require (
 	github.com/alexflint/go-filemutex v1.3.0

package.json

@@ -172,6 +172,7 @@
     },
     "packageManager": "[email protected]",
     "workspaces": [
-        "docs"
+        "docs",
+        "tsunami/frontend"
     ]
 }

tsunami/.gitignore

@@ -0,0 +1 @@
+bin/

tsunami/app/atom.go

@@ -0,0 +1,123 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package app
+
+import (
+	"log"
+	"reflect"
+	"runtime"
+
+	"github.com/wavetermdev/waveterm/tsunami/engine"
+	"github.com/wavetermdev/waveterm/tsunami/util"
+)
+
+// logInvalidAtomSet logs an error when an atom is being set during component render
+func logInvalidAtomSet(atomName string) {
+	_, file, line, ok := runtime.Caller(2)
+	if ok {
+		log.Printf("invalid Set of atom '%s' in component render function at %s:%d", atomName, file, line)
+	} else {
+		log.Printf("invalid Set of atom '%s' in component render function", atomName)
+	}
+}
+
+// sameRef returns true if oldVal and newVal share the same underlying reference
+// (pointer, map, or slice). Nil values return false.
+func sameRef[T any](oldVal, newVal T) bool {
+	vOld := reflect.ValueOf(oldVal)
+	vNew := reflect.ValueOf(newVal)
+
+	if !vOld.IsValid() || !vNew.IsValid() {
+		return false
+	}
+
+	switch vNew.Kind() {
+	case reflect.Ptr:
+		// direct comparison works for *T
+		return any(oldVal) == any(newVal)
+
+	case reflect.Map, reflect.Slice:
+		if vOld.Kind() != vNew.Kind() || vOld.IsZero() || vNew.IsZero() {
+			return false
+		}
+		return vOld.Pointer() == vNew.Pointer()
+	}
+
+	// primitives, structs, etc. → not a reference type
+	return false
+}
+
+// logMutationWarning logs a warning when mutation is detected
+func logMutationWarning(atomName string) {
+	_, file, line, ok := runtime.Caller(2)
+	if ok {
+		log.Printf("WARNING: atom '%s' appears to be mutated instead of copied at %s:%d - use app.DeepCopy to create a copy before mutating", atomName, file, line)
+	} else {
+		log.Printf("WARNING: atom '%s' appears to be mutated instead of copied - use app.DeepCopy to create a copy before mutating", atomName)
+	}
+}
+
+// Atom[T] represents a typed atom implementation
+type Atom[T any] struct {
+	name   string
+	client *engine.ClientImpl
+}
+
+// AtomName implements the vdom.Atom interface
+func (a Atom[T]) AtomName() string {
+	return a.name
+}
+
+// Get returns the current value of the atom. When called during component render,
+// it automatically registers the component as a dependency for this atom, ensuring
+// the component re-renders when the atom value changes.
+func (a Atom[T]) Get() T {
+	vc := engine.GetGlobalRenderContext()
+	if vc != nil {
+		vc.UsedAtoms[a.name] = true
+	}
+	val := a.client.Root.GetAtomVal(a.name)
+	typedVal := util.GetTypedAtomValue[T](val, a.name)
+	return typedVal
+}
+
+// Set updates the atom's value to the provided new value and triggers re-rendering
+// of any components that depend on this atom. This method cannot be called during
+// render cycles - use effects or event handlers instead.
+func (a Atom[T]) Set(newVal T) {
+	vc := engine.GetGlobalRenderContext()
+	if vc != nil {
+		logInvalidAtomSet(a.name)
+		return
+	}
+
+	// Check for potential mutation bugs with reference types
+	currentVal := a.client.Root.GetAtomVal(a.name)
+	currentTyped := util.GetTypedAtomValue[T](currentVal, a.name)
+	if sameRef(currentTyped, newVal) {
+		logMutationWarning(a.name)
+	}
+
+	if err := a.client.Root.SetAtomVal(a.name, newVal); err != nil {
+		log.Printf("Failed to set atom value for %s: %v", a.name, err)
+		return
+	}
+	a.client.Root.AtomAddRenderWork(a.name)
+}
+
+// SetFn updates the atom's value by applying the provided function to the current value.
+// The function receives a copy of the current atom value, which can be safely mutated
+// without affecting the original data. The return value from the function becomes the
+// new atom value. This method cannot be called during render cycles.
+func (a Atom[T]) SetFn(fn func(T) T) {
+	vc := engine.GetGlobalRenderContext()
+	if vc != nil {
+		logInvalidAtomSet(a.name)
+		return
+	}
+	currentVal := a.Get()
+	copiedVal := DeepCopy(currentVal)
+	newVal := fn(copiedVal)
+	a.Set(newVal)
+}

tsunami/app/defaultclient.go

@@ -0,0 +1,110 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package app
+
+import (
+	"encoding/json"
+	"io/fs"
+	"net/http"
+
+	"github.com/wavetermdev/waveterm/tsunami/engine"
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+)
+
+func DefineComponent[P any](name string, renderFn func(props P) any) vdom.Component[P] {
+	return engine.DefineComponentEx(engine.GetDefaultClient(), name, renderFn)
+}
+
+func SetGlobalEventHandler(handler func(event vdom.VDomEvent)) {
+	engine.GetDefaultClient().SetGlobalEventHandler(handler)
+}
+
+// RegisterSetupFn registers a single setup function that is called before the app starts running.
+// Only one setup function is allowed, so calling this will replace any previously registered
+// setup function.
+func RegisterSetupFn(fn func()) {
+	engine.GetDefaultClient().RegisterSetupFn(fn)
+}
+
+// SendAsyncInitiation notifies the frontend that the backend has updated state
+// and requires a re-render. Normally the frontend calls the backend in response
+// to events, but when the backend changes state independently (e.g., from a
+// background process), this function gives the frontend a "nudge" to update.
+func SendAsyncInitiation() error {
+	return engine.GetDefaultClient().SendAsyncInitiation()
+}
+
+func ConfigAtom[T any](name string, defaultValue T) Atom[T] {
+	fullName := "$config." + name
+	client := engine.GetDefaultClient()
+	atom := engine.MakeAtomImpl(defaultValue)
+	client.Root.RegisterAtom(fullName, atom)
+	return Atom[T]{name: fullName, client: client}
+}
+
+func DataAtom[T any](name string, defaultValue T) Atom[T] {
+	fullName := "$data." + name
+	client := engine.GetDefaultClient()
+	atom := engine.MakeAtomImpl(defaultValue)
+	client.Root.RegisterAtom(fullName, atom)
+	return Atom[T]{name: fullName, client: client}
+}
+
+func SharedAtom[T any](name string, defaultValue T) Atom[T] {
+	fullName := "$shared." + name
+	client := engine.GetDefaultClient()
+	atom := engine.MakeAtomImpl(defaultValue)
+	client.Root.RegisterAtom(fullName, atom)
+	return Atom[T]{name: fullName, client: client}
+}
+
+// HandleDynFunc registers a dynamic HTTP handler function with the internal http.ServeMux.
+// The pattern MUST start with "/dyn/" to be valid. This allows registration of dynamic
+// routes that can be handled at runtime.
+func HandleDynFunc(pattern string, fn func(http.ResponseWriter, *http.Request)) {
+	engine.GetDefaultClient().HandleDynFunc(pattern, fn)
+}
+
+// RunMain is used internally by generated code and should not be called directly.
+func RunMain() {
+	engine.GetDefaultClient().RunMain()
+}
+
+// RegisterEmbeds is used internally by generated code and should not be called directly.
+func RegisterEmbeds(assetsFilesystem fs.FS, staticFilesystem fs.FS, manifest []byte) {
+	client := engine.GetDefaultClient()
+	client.AssetsFS = assetsFilesystem
+	client.StaticFS = staticFilesystem
+	client.ManifestFileBytes = manifest
+}
+
+// DeepCopy creates a deep copy of the input value using JSON marshal/unmarshal.
+// Panics on JSON errors.
+func DeepCopy[T any](v T) T {
+	data, err := json.Marshal(v)
+	if err != nil {
+		panic(err)
+	}
+	var result T
+	err = json.Unmarshal(data, &result)
+	if err != nil {
+		panic(err)
+	}
+	return result
+}
+
+// QueueRefOp queues a reference operation to be executed on the DOM element.
+// Operations include actions like "focus", "scrollIntoView", etc.
+// If the ref is nil or not current, the operation is ignored.
+// This function must be called within a component context.
+func QueueRefOp(ref *vdom.VDomRef, op vdom.VDomRefOperation) {
+	if ref == nil || !ref.HasCurrent {
+		return
+	}
+	if op.RefId == "" {
+		op.RefId = ref.RefId
+	}
+	client := engine.GetDefaultClient()
+	client.Root.QueueRefOp(op)
+}