diff --git a/Taskfile.yml b/Taskfile.yml
index 27ae3a03ac..2f47c49a73 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -166,6 +166,7 @@ tasks:
             - "cmd/server/*.go"
             - "pkg/**/*.go"
             - "pkg/**/*.json"
+            - tsunami/**/*.go
         generates:
             - dist/bin/wavesrv.*
 
@@ -194,6 +195,7 @@ tasks:
             - "cmd/server/*.go"
             - "pkg/**/*.go"
             - "pkg/**/*.json"
+            - "tsunami/**/*.go"
         generates:
             - dist/bin/wavesrv.*
 
@@ -485,6 +487,19 @@ tasks:
         cmds:
             - task: tsunami:scaffold:internal
 
+    tsunami:scaffold:packagejson:
+        desc: Create package.json for tsunami scaffold using npm commands
+        dir: tsunami/frontend/scaffold
+        cmds:
+            - cmd: "{{.RM}} package.json"
+              ignore_error: true
+            - npm --no-workspaces init -y --init-license Apache-2.0
+            - npm pkg set name=tsunami-scaffold
+            - npm pkg delete author
+            - npm pkg set author.name="Command Line Inc"
+            - npm pkg set author.email="info@commandline.dev"
+            - npm --no-workspaces install tailwindcss@4.1.13 @tailwindcss/cli@4.1.13
+
     tsunami:scaffold:internal:
         desc: Internal task to create scaffold directory structure
         dir: tsunami/frontend
@@ -493,12 +508,8 @@ tasks:
             - 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="info@commandline.dev"
-            - cd scaffold && npm --no-workspaces install tailwindcss @tailwindcss/cli
+            - cp ../templates/package.json.tmpl scaffold/package.json
+            - cd scaffold && npm install
             - cp -r dist scaffold/
             - cp ../templates/app-main.go.tmpl scaffold/app-main.go
             - cp ../templates/tailwind.css scaffold/
diff --git a/electron.vite.config.ts b/electron.vite.config.ts
index 9ee2965117..acbf7c667d 100644
--- a/electron.vite.config.ts
+++ b/electron.vite.config.ts
@@ -78,7 +78,7 @@ export default defineConfig({
         server: {
             open: false,
             watch: {
-                ignored: ["dist/**", "**/*.go", "**/go.mod", "**/go.sum", "**/*.md", "**/*.json"],
+                ignored: ["dist/**", "**/*.go", "**/go.mod", "**/go.sum", "**/*.md", "**/*.json", "emain/**"],
             },
         },
         css: {
diff --git a/emain/emain-util.ts b/emain/emain-util.ts
index a24a4e3c62..89ef975a50 100644
--- a/emain/emain-util.ts
+++ b/emain/emain-util.ts
@@ -5,6 +5,11 @@ import * as electron from "electron";
 import { getWebServerEndpoint } from "../frontend/util/endpoints";
 
 export const WaveAppPathVarName = "WAVETERM_APP_PATH";
+export const WaveAppElectronExecPath = "WAVETERM_ELECTRONEXECPATH";
+
+export function getElectronExecPath(): string {
+    return process.execPath;
+}
 
 // not necessarily exact, but we use this to help get us unstuck in certain cases
 let lastCtrlShiftSate: boolean = false;
@@ -57,8 +62,13 @@ export function handleCtrlShiftState(sender: Electron.WebContents, waveEvent: Wa
 
 export function shNavHandler(event: Electron.Event<Electron.WebContentsWillNavigateEventParams>, url: string) {
     const isDev = !electron.app.isPackaged;
-    if (isDev && (url.startsWith("http://127.0.0.1:5173/index.html") || url.startsWith("http://localhost:5173/index.html") ||
-                  url.startsWith("http://127.0.0.1:5174/index.html") || url.startsWith("http://localhost:5174/index.html"))) {
+    if (
+        isDev &&
+        (url.startsWith("http://127.0.0.1:5173/index.html") ||
+            url.startsWith("http://localhost:5173/index.html") ||
+            url.startsWith("http://127.0.0.1:5174/index.html") ||
+            url.startsWith("http://localhost:5174/index.html"))
+    ) {
         // this is a dev-mode hot-reload, ignore it
         console.log("allowing hot-reload of index.html");
         return;
@@ -97,6 +107,30 @@ export function shFrameNavHandler(event: Electron.Event<Electron.WebContentsWill
         // allowed
         return;
     }
+    if (event.frame.name != null && event.frame.name.startsWith("tsunami:")) {
+        // Parse port from frame name: tsunami:[port]:[blockid]
+        const nameParts = event.frame.name.split(":");
+        const expectedPort = nameParts.length >= 2 ? nameParts[1] : null;
+
+        try {
+            const tsunamiUrl = new URL(url);
+            if (
+                tsunamiUrl.protocol === "http:" &&
+                tsunamiUrl.hostname === "localhost" &&
+                expectedPort &&
+                tsunamiUrl.port === expectedPort
+            ) {
+                // allowed
+                return;
+            }
+            // If navigation is not to expected port, open externally
+            event.preventDefault();
+            electron.shell.openExternal(url);
+            return;
+        } catch (e) {
+            // Invalid URL, fall through to prevent navigation
+        }
+    }
     event.preventDefault();
     console.log("frame navigation canceled");
 }
diff --git a/emain/emain-wavesrv.ts b/emain/emain-wavesrv.ts
index beca7d684a..686ee87f76 100644
--- a/emain/emain-wavesrv.ts
+++ b/emain/emain-wavesrv.ts
@@ -7,7 +7,7 @@ import * as readline from "readline";
 import { WebServerEndpointVarName, WSServerEndpointVarName } from "../frontend/util/endpoints";
 import { AuthKey, WaveAuthKeyEnv } from "./authkey";
 import { setForceQuit } from "./emain-activity";
-import { WaveAppPathVarName } from "./emain-util";
+import { WaveAppPathVarName, WaveAppElectronExecPath, getElectronExecPath } from "./emain-util";
 import {
     getElectronAppUnpackedBasePath,
     getWaveConfigDir,
@@ -59,6 +59,7 @@ export function runWaveSrv(handleWSEvent: (evtMsg: WSEventType) => void): Promis
         envCopy["XDG_CURRENT_DESKTOP"] = xdgCurrentDesktop;
     }
     envCopy[WaveAppPathVarName] = getElectronAppUnpackedBasePath();
+    envCopy[WaveAppElectronExecPath] = getElectronExecPath();
     envCopy[WaveAuthKeyEnv] = AuthKey;
     envCopy[WaveDataHomeVarName] = getWaveDataDir();
     envCopy[WaveConfigHomeVarName] = getWaveConfigDir();
diff --git a/frontend/app/block/block.tsx b/frontend/app/block/block.tsx
index 1aa507f4f8..350f984563 100644
--- a/frontend/app/block/block.tsx
+++ b/frontend/app/block/block.tsx
@@ -12,6 +12,7 @@ import {
 import { LauncherViewModel } from "@/app/view/launcher/launcher";
 import { PreviewModel } from "@/app/view/preview/preview-model";
 import { SysinfoViewModel } from "@/app/view/sysinfo/sysinfo";
+import { TsunamiViewModel } from "@/app/view/tsunami/tsunami";
 import { VDomModel } from "@/app/view/vdom/vdom-model";
 import { ErrorBoundary } from "@/element/errorboundary";
 import { CenteredDiv } from "@/element/quickelems";
@@ -48,6 +49,7 @@ BlockRegistry.set("vdom", VDomModel);
 BlockRegistry.set("tips", QuickTipsViewModel);
 BlockRegistry.set("help", HelpViewModel);
 BlockRegistry.set("launcher", LauncherViewModel);
+BlockRegistry.set("tsunami", TsunamiViewModel);
 
 function makeViewModel(blockId: string, blockView: string, nodeModel: BlockNodeModel): ViewModel {
     const ctor = BlockRegistry.get(blockView);
diff --git a/frontend/app/view/tsunami/tsunami.tsx b/frontend/app/view/tsunami/tsunami.tsx
new file mode 100644
index 0000000000..19121ff61f
--- /dev/null
+++ b/frontend/app/view/tsunami/tsunami.tsx
@@ -0,0 +1,175 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { BlockNodeModel } from "@/app/block/blocktypes";
+import { atoms, globalStore, WOS } from "@/app/store/global";
+import { waveEventSubscribe } from "@/app/store/wps";
+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, useEffect } from "react";
+
+class TsunamiViewModel implements ViewModel {
+    viewType: string;
+    blockAtom: jotai.Atom<Block>;
+    blockId: string;
+    viewIcon: jotai.Atom<string>;
+    viewName: jotai.Atom<string>;
+    shellProcFullStatus: jotai.PrimitiveAtom<BlockControllerRuntimeStatus>;
+    shellProcStatusUnsubFn: () => void;
+    isRestarting: jotai.PrimitiveAtom<boolean>;
+
+    constructor(blockId: string, nodeModel: BlockNodeModel) {
+        this.viewType = "tsunami";
+        this.blockId = blockId;
+        this.blockAtom = WOS.getWaveObjectAtom<Block>(`block:${blockId}`);
+        this.viewIcon = jotai.atom("cube");
+        this.viewName = jotai.atom("Tsunami");
+        this.isRestarting = jotai.atom(false);
+
+        this.shellProcFullStatus = jotai.atom(null) as jotai.PrimitiveAtom<BlockControllerRuntimeStatus>;
+        const initialShellProcStatus = services.BlockService.GetControllerStatus(blockId);
+        initialShellProcStatus.then((rts) => {
+            this.updateShellProcStatus(rts);
+        });
+        this.shellProcStatusUnsubFn = waveEventSubscribe({
+            eventType: "controllerstatus",
+            scope: WOS.makeORef("block", blockId),
+            handler: (event) => {
+                let bcRTS: BlockControllerRuntimeStatus = event.data;
+                this.updateShellProcStatus(bcRTS);
+            },
+        });
+    }
+
+    get viewComponent(): ViewComponent {
+        return TsunamiView;
+    }
+
+    updateShellProcStatus(fullStatus: BlockControllerRuntimeStatus) {
+        console.log("tsunami-status", fullStatus);
+        if (fullStatus == null) {
+            return;
+        }
+        const curStatus = globalStore.get(this.shellProcFullStatus);
+        if (curStatus == null || curStatus.version < fullStatus.version) {
+            globalStore.set(this.shellProcFullStatus, fullStatus);
+        }
+    }
+
+    triggerRestartAtom() {
+        globalStore.set(this.isRestarting, true);
+        setTimeout(() => {
+            globalStore.set(this.isRestarting, false);
+        }, 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;
+        }
+        this.triggerRestartAtom();
+        const prtn = RpcApi.ControllerResyncCommand(TabRpcClient, {
+            tabid: globalStore.get(atoms.staticTabId),
+            blockid: this.blockId,
+            forcerestart: true,
+        });
+        prtn.catch((e) => console.log("error controller resync (force restart)", e));
+    }
+
+    dispose() {
+        if (this.shellProcStatusUnsubFn) {
+            this.shellProcStatusUnsubFn();
+        }
+    }
+
+    getSettingsMenuItems(): ContextMenuItem[] {
+        return [];
+    }
+}
+
+type TsunamiViewProps = {
+    model: TsunamiViewModel;
+};
+
+const TsunamiView = memo(({ model }: TsunamiViewProps) => {
+    const shellProcFullStatus = jotai.useAtomValue(model.shellProcFullStatus);
+    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;
+
+    // Check for configuration errors
+    const errors = [];
+    if (!appPath) {
+        errors.push("App path must be set (tsunami:apppath)");
+    }
+    if (controller !== "tsunami") {
+        errors.push("Invalid controller (must be 'tsunami')");
+    }
+
+    // Show errors if any exist
+    if (errors.length > 0) {
+        return (
+            <div className="w-full h-full flex flex-col items-center justify-center gap-4">
+                <h1 className="text-4xl font-bold text-main-text-color">Tsunami</h1>
+                <div className="flex flex-col gap-2">
+                    {errors.map((error, index) => (
+                        <div key={index} className="text-sm" style={{ color: "var(--color-error)" }}>
+                            {error}
+                        </div>
+                    ))}
+                </div>
+            </div>
+        );
+    }
+
+    // Check if we should show the iframe
+    const shouldShowIframe =
+        shellProcFullStatus?.shellprocstatus === "running" &&
+        shellProcFullStatus?.tsunamiport &&
+        shellProcFullStatus.tsunamiport !== 0;
+
+    if (shouldShowIframe) {
+        const iframeUrl = `http://localhost:${shellProcFullStatus.tsunamiport}/?clientid=wave:${model.blockId}`;
+        return <iframe src={iframeUrl} className="w-full h-full border-0" title="Tsunami Application" name={`tsunami:${shellProcFullStatus.tsunamiport}:${model.blockId}`} />;
+    }
+
+    const status = shellProcFullStatus?.shellprocstatus ?? "init";
+    const isNotRunning = status === "done" || status === "init";
+
+    return (
+        <div className="w-full h-full flex flex-col items-center justify-center gap-4">
+            <h1 className="text-4xl font-bold text-main-text-color">Tsunami</h1>
+            {appPath && <div className="text-sm text-main-text-color opacity-70">{appPath}</div>}
+            {isNotRunning && !isRestarting && (
+                <button
+                    onClick={() => model.forceRestartController()}
+                    className="px-4 py-2 bg-accent-color text-primary-text-color rounded hover:bg-accent-color/80 transition-colors cursor-pointer"
+                >
+                    Start
+                </button>
+            )}
+            {isRestarting && <div className="text-sm text-success-color">Starting...</div>}
+        </div>
+    );
+});
+
+TsunamiView.displayName = "TsunamiView";
+
+export { TsunamiViewModel };
diff --git a/frontend/types/gotypes.d.ts b/frontend/types/gotypes.d.ts
index 0d70582e48..647af8cf47 100644
--- a/frontend/types/gotypes.d.ts
+++ b/frontend/types/gotypes.d.ts
@@ -60,6 +60,7 @@ declare global {
         shellprocstatus?: string;
         shellprocconnname?: string;
         shellprocexitcode: number;
+        tsunamiport?: number;
     };
 
     // waveobj.BlockDef
@@ -590,6 +591,10 @@ declare global {
         "web:partition"?: string;
         "markdown:fontsize"?: number;
         "markdown:fixedfontsize"?: number;
+        "tsunami:*"?: boolean;
+        "tsunami:sdkreplacepath"?: string;
+        "tsunami:apppath"?: string;
+        "tsunami:scaffoldpath"?: string;
         "vdom:*"?: boolean;
         "vdom:initialized"?: boolean;
         "vdom:correlationid"?: string;
diff --git a/go.mod b/go.mod
index bd93069362..3cf3dc45e4 100644
--- a/go.mod
+++ b/go.mod
@@ -33,6 +33,7 @@ require (
 	github.com/spf13/cobra v1.10.1
 	github.com/ubuntu/gowsl v0.0.0-20240906163211-049fd49bd93b
 	github.com/wavetermdev/htmltoken v0.2.0
+	github.com/wavetermdev/waveterm/tsunami v0.0.0-00010101000000-000000000000
 	golang.org/x/crypto v0.42.0
 	golang.org/x/mod v0.28.0
 	golang.org/x/sync v0.17.0
@@ -112,3 +113,5 @@ require (
 replace github.com/kevinburke/ssh_config => github.com/wavetermdev/ssh_config v0.0.0-20241219203747-6409e4292f34
 
 replace github.com/creack/pty => github.com/photostorm/pty v1.1.19-0.20230903182454-31354506054b
+
+replace github.com/wavetermdev/waveterm/tsunami => ./tsunami
diff --git a/package-lock.json b/package-lock.json
index ff792839fc..16d416b52f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -34166,12 +34166,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"
             }
diff --git a/pkg/blockcontroller/.gitignore b/pkg/blockcontroller/.gitignore
new file mode 100644
index 0000000000..a27ba57401
--- /dev/null
+++ b/pkg/blockcontroller/.gitignore
@@ -0,0 +1 @@
+*.old
\ No newline at end of file
diff --git a/pkg/blockcontroller/blockcontroller.go b/pkg/blockcontroller/blockcontroller.go
index 23a3ffdbb6..777798cc40 100644
--- a/pkg/blockcontroller/blockcontroller.go
+++ b/pkg/blockcontroller/blockcontroller.go
@@ -4,50 +4,30 @@
 package blockcontroller
 
 import (
-	"bytes"
 	"context"
 	"encoding/base64"
 	"fmt"
-	"io"
 	"io/fs"
 	"log"
-	"os"
 	"strings"
 	"sync"
-	"sync/atomic"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/wavetermdev/waveterm/pkg/blocklogger"
 	"github.com/wavetermdev/waveterm/pkg/filestore"
-	"github.com/wavetermdev/waveterm/pkg/panichandler"
 	"github.com/wavetermdev/waveterm/pkg/remote"
 	"github.com/wavetermdev/waveterm/pkg/remote/conncontroller"
-	"github.com/wavetermdev/waveterm/pkg/shellexec"
-	"github.com/wavetermdev/waveterm/pkg/util/envutil"
-	"github.com/wavetermdev/waveterm/pkg/util/fileutil"
-	"github.com/wavetermdev/waveterm/pkg/util/shellutil"
-	"github.com/wavetermdev/waveterm/pkg/util/utilfn"
 	"github.com/wavetermdev/waveterm/pkg/wavebase"
 	"github.com/wavetermdev/waveterm/pkg/waveobj"
-	"github.com/wavetermdev/waveterm/pkg/wconfig"
 	"github.com/wavetermdev/waveterm/pkg/wps"
-	"github.com/wavetermdev/waveterm/pkg/wshrpc"
-	"github.com/wavetermdev/waveterm/pkg/wshrpc/wshclient"
-	"github.com/wavetermdev/waveterm/pkg/wshutil"
 	"github.com/wavetermdev/waveterm/pkg/wslconn"
 	"github.com/wavetermdev/waveterm/pkg/wstore"
 )
 
 const (
-	BlockController_Shell = "shell"
-	BlockController_Cmd   = "cmd"
-)
-
-const (
-	ConnType_Local = "local"
-	ConnType_Wsl   = "wsl"
-	ConnType_Ssh   = "ssh"
+	BlockController_Shell   = "shell"
+	BlockController_Cmd     = "cmd"
+	BlockController_Tsunami = "tsunami"
 )
 
 const (
@@ -63,9 +43,7 @@ const (
 )
 
 const DefaultTimeout = 2 * time.Second
-
-var globalLock = &sync.Mutex{}
-var blockControllerMap = make(map[string]*BlockController)
+const DefaultGracefulKillWait = 400 * time.Millisecond
 
 type BlockInputUnion struct {
 	InputData []byte            `json:"inputdata,omitempty"`
@@ -73,740 +51,225 @@ type BlockInputUnion struct {
 	TermSize  *waveobj.TermSize `json:"termsize,omitempty"`
 }
 
-type BlockController struct {
-	Lock              *sync.Mutex
-	ControllerType    string
-	TabId             string
-	BlockId           string
-	BlockDef          *waveobj.BlockDef
-	CreatedHtmlFile   bool
-	ShellProc         *shellexec.ShellProc
-	ShellInputCh      chan *BlockInputUnion
-	ShellProcStatus   string
-	ShellProcExitCode int
-	RunLock           *atomic.Bool
-	StatusVersion     int
-}
-
 type BlockControllerRuntimeStatus struct {
 	BlockId           string `json:"blockid"`
 	Version           int    `json:"version"`
 	ShellProcStatus   string `json:"shellprocstatus,omitempty"`
 	ShellProcConnName string `json:"shellprocconnname,omitempty"`
 	ShellProcExitCode int    `json:"shellprocexitcode"`
+	TsunamiPort       int    `json:"tsunamiport,omitempty"`
 }
 
-func (bc *BlockController) WithLock(f func()) {
-	bc.Lock.Lock()
-	defer bc.Lock.Unlock()
-	f()
-}
-
-func (bc *BlockController) GetRuntimeStatus() *BlockControllerRuntimeStatus {
-	var rtn BlockControllerRuntimeStatus
-	bc.WithLock(func() {
-		bc.StatusVersion++
-		rtn.Version = bc.StatusVersion
-		rtn.BlockId = bc.BlockId
-		rtn.ShellProcStatus = bc.ShellProcStatus
-		if bc.ShellProc != nil {
-			rtn.ShellProcConnName = bc.ShellProc.ConnName
-		}
-		rtn.ShellProcExitCode = bc.ShellProcExitCode
-	})
-	return &rtn
-}
-
-func (bc *BlockController) getShellProc() *shellexec.ShellProc {
-	bc.Lock.Lock()
-	defer bc.Lock.Unlock()
-	return bc.ShellProc
+// Controller interface that all block controllers must implement
+type Controller interface {
+	Start(ctx context.Context, blockMeta waveobj.MetaMapType, rtOpts *waveobj.RuntimeOpts, force bool) error
+	Stop(graceful bool, newStatus string) error
+	GetRuntimeStatus() *BlockControllerRuntimeStatus
+	SendInput(input *BlockInputUnion) error
 }
 
-type RunShellOpts struct {
-	TermSize waveobj.TermSize `json:"termsize,omitempty"`
-}
+// Registry for all controllers
+var (
+	controllerRegistry = make(map[string]Controller)
+	registryLock       sync.RWMutex
+)
 
-func (bc *BlockController) UpdateControllerAndSendUpdate(updateFn func() bool) {
-	var sendUpdate bool
-	bc.WithLock(func() {
-		sendUpdate = updateFn()
-	})
-	if sendUpdate {
-		rtStatus := bc.GetRuntimeStatus()
-		log.Printf("sending blockcontroller update %#v\n", rtStatus)
-		wps.Broker.Publish(wps.WaveEvent{
-			Event: wps.Event_ControllerStatus,
-			Scopes: []string{
-				waveobj.MakeORef(waveobj.OType_Tab, bc.TabId).String(),
-				waveobj.MakeORef(waveobj.OType_Block, bc.BlockId).String(),
-			},
-			Data: rtStatus,
-		})
-	}
+// Registry operations
+func getController(blockId string) Controller {
+	registryLock.RLock()
+	defer registryLock.RUnlock()
+	return controllerRegistry[blockId]
 }
 
-func HandleTruncateBlockFile(blockId string) error {
-	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
-	defer cancelFn()
-	err := filestore.WFS.WriteFile(ctx, blockId, wavebase.BlockFile_Term, nil)
-	if err == fs.ErrNotExist {
-		return nil
-	}
-	if err != nil {
-		return fmt.Errorf("error truncating blockfile: %w", err)
-	}
-	err = filestore.WFS.DeleteFile(ctx, blockId, wavebase.BlockFile_Cache)
-	if err == fs.ErrNotExist {
-		err = nil
+func registerController(blockId string, controller Controller) {
+	var existingController Controller
+	
+	registryLock.Lock()
+	existing, exists := controllerRegistry[blockId]
+	if exists {
+		existingController = existing
 	}
-	if err != nil {
-		log.Printf("error deleting cache file (continuing): %v\n", err)
+	controllerRegistry[blockId] = controller
+	registryLock.Unlock()
+	
+	if existingController != nil {
+		existingController.Stop(false, Status_Done)
 	}
-	wps.Broker.Publish(wps.WaveEvent{
-		Event:  wps.Event_BlockFile,
-		Scopes: []string{waveobj.MakeORef(waveobj.OType_Block, blockId).String()},
-		Data: &wps.WSFileEventData{
-			ZoneId:   blockId,
-			FileName: wavebase.BlockFile_Term,
-			FileOp:   wps.FileOp_Truncate,
-		},
-	})
-	return nil
-
 }
 
-func HandleAppendBlockFile(blockId string, blockFile string, data []byte) error {
-	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
-	defer cancelFn()
-	err := filestore.WFS.AppendData(ctx, blockId, blockFile, data)
-	if err != nil {
-		return fmt.Errorf("error appending to blockfile: %w", err)
-	}
-	wps.Broker.Publish(wps.WaveEvent{
-		Event: wps.Event_BlockFile,
-		Scopes: []string{
-			waveobj.MakeORef(waveobj.OType_Block, blockId).String(),
-		},
-		Data: &wps.WSFileEventData{
-			ZoneId:   blockId,
-			FileName: blockFile,
-			FileOp:   wps.FileOp_Append,
-			Data64:   base64.StdEncoding.EncodeToString(data),
-		},
-	})
-	return nil
+func deleteController(blockId string) {
+	registryLock.Lock()
+	defer registryLock.Unlock()
+	delete(controllerRegistry, blockId)
 }
 
-func (bc *BlockController) resetTerminalState(logCtx context.Context) {
-	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
-	defer cancelFn()
-	wfile, statErr := filestore.WFS.Stat(ctx, bc.BlockId, wavebase.BlockFile_Term)
-	if statErr == fs.ErrNotExist || wfile.Size == 0 {
-		return
-	}
-	blocklogger.Debugf(logCtx, "[conndebug] resetTerminalState: resetting terminal state\n")
-	// controller type = "shell"
-	var buf bytes.Buffer
-	// buf.WriteString("\x1b[?1049l") // disable alternative buffer
-	buf.WriteString("\x1b[0m")     // reset attributes
-	buf.WriteString("\x1b[?25h")   // show cursor
-	buf.WriteString("\x1b[?1000l") // disable mouse tracking
-	buf.WriteString("\r\n\r\n")
-	err := HandleAppendBlockFile(bc.BlockId, wavebase.BlockFile_Term, buf.Bytes())
-	if err != nil {
-		log.Printf("error appending to blockfile (terminal reset): %v\n", err)
+func getAllControllers() map[string]Controller {
+	registryLock.RLock()
+	defer registryLock.RUnlock()
+	// Return a copy to avoid lock issues
+	result := make(map[string]Controller)
+	for k, v := range controllerRegistry {
+		result[k] = v
 	}
+	return result
 }
 
-func getCustomInitScriptKeyCascade(shellType string) []string {
-	if shellType == "bash" {
-		return []string{waveobj.MetaKey_CmdInitScriptBash, waveobj.MetaKey_CmdInitScriptSh, waveobj.MetaKey_CmdInitScript}
-	}
-	if shellType == "zsh" {
-		return []string{waveobj.MetaKey_CmdInitScriptZsh, waveobj.MetaKey_CmdInitScriptSh, waveobj.MetaKey_CmdInitScript}
-	}
-	if shellType == "pwsh" {
-		return []string{waveobj.MetaKey_CmdInitScriptPwsh, waveobj.MetaKey_CmdInitScript}
-	}
-	if shellType == "fish" {
-		return []string{waveobj.MetaKey_CmdInitScriptFish, waveobj.MetaKey_CmdInitScript}
-	}
-	return []string{waveobj.MetaKey_CmdInitScript}
-}
+// Public API Functions
 
-func getCustomInitScript(logCtx context.Context, meta waveobj.MetaMapType, connName string, shellType string) string {
-	initScriptVal, metaKeyName := getCustomInitScriptValue(meta, connName, shellType)
-	if initScriptVal == "" {
-		return ""
-	}
-	if !fileutil.IsInitScriptPath(initScriptVal) {
-		blocklogger.Infof(logCtx, "[conndebug] inline initScript (size=%d) found in meta key: %s\n", len(initScriptVal), metaKeyName)
-		return initScriptVal
-	}
-	blocklogger.Infof(logCtx, "[conndebug] initScript detected as a file %q from meta key: %s\n", initScriptVal, metaKeyName)
-	initScriptVal, err := wavebase.ExpandHomeDir(initScriptVal)
-	if err != nil {
-		blocklogger.Infof(logCtx, "[conndebug] cannot expand home dir in Wave initscript file: %v\n", err)
-		return fmt.Sprintf("echo \"cannot expand home dir in Wave initscript file, from key %s\";\n", metaKeyName)
-	}
-	fileData, err := os.ReadFile(initScriptVal)
-	if err != nil {
-		blocklogger.Infof(logCtx, "[conndebug] cannot open Wave initscript file: %v\n", err)
-		return fmt.Sprintf("echo \"cannot open Wave initscript file, from key %s\";\n", metaKeyName)
-	}
-	if len(fileData) > MaxInitScriptSize {
-		blocklogger.Infof(logCtx, "[conndebug] initscript file too large, size=%d, max=%d\n", len(fileData), MaxInitScriptSize)
-		return fmt.Sprintf("echo \"initscript file too large, from key %s\";\n", metaKeyName)
-	}
-	if utilfn.HasBinaryData(fileData) {
-		blocklogger.Infof(logCtx, "[conndebug] initscript file contains binary data\n")
-		return fmt.Sprintf("echo \"initscript file contains binary data, from key %s\";\n", metaKeyName)
+func ResyncController(ctx context.Context, tabId string, blockId string, rtOpts *waveobj.RuntimeOpts, force bool) error {
+	if tabId == "" || blockId == "" {
+		return fmt.Errorf("invalid tabId or blockId passed to ResyncController")
 	}
-	blocklogger.Infof(logCtx, "[conndebug] initscript file read successfully, size=%d\n", len(fileData))
-	return string(fileData)
-}
 
-// returns (value, metakey)
-func getCustomInitScriptValue(meta waveobj.MetaMapType, connName string, shellType string) (string, string) {
-	keys := getCustomInitScriptKeyCascade(shellType)
-	connMeta := meta.GetConnectionOverride(connName)
-	if connMeta != nil {
-		for _, key := range keys {
-			if connMeta.HasKey(key) {
-				return connMeta.GetString(key, ""), "blockmeta/[" + connName + "]/" + key
-			}
-		}
-	}
-	for _, key := range keys {
-		if meta.HasKey(key) {
-			return meta.GetString(key, ""), "blockmeta/" + key
-		}
-	}
-	fullConfig := wconfig.GetWatcher().GetFullConfig()
-	connKeywords := fullConfig.Connections[connName]
-	connKeywordsMap := make(map[string]any)
-	err := utilfn.ReUnmarshal(&connKeywordsMap, connKeywords)
+	blockData, err := wstore.DBMustGet[*waveobj.Block](ctx, blockId)
 	if err != nil {
-		log.Printf("error re-unmarshalling connKeywords: %v\n", err)
-		return "", ""
-	}
-	ckMeta := waveobj.MetaMapType(connKeywordsMap)
-	for _, key := range keys {
-		if ckMeta.HasKey(key) {
-			return ckMeta.GetString(key, ""), "connections.json/" + connName + "/" + key
-		}
+		return fmt.Errorf("error getting block: %w", err)
 	}
-	return "", ""
-}
 
-func resolveEnvMap(blockId string, blockMeta waveobj.MetaMapType, connName string) (map[string]string, error) {
-	rtn := make(map[string]string)
-	config := wconfig.GetWatcher().GetFullConfig()
-	connKeywords := config.Connections[connName]
-	ckEnv := connKeywords.CmdEnv
-	for k, v := range ckEnv {
-		rtn[k] = v
-	}
-	ctx, cancelFn := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancelFn()
-	_, envFileData, err := filestore.WFS.ReadFile(ctx, blockId, wavebase.BlockFile_Env)
-	if err == fs.ErrNotExist {
-		err = nil
-	}
-	if err != nil {
-		return nil, fmt.Errorf("error reading command env file: %w", err)
-	}
-	if len(envFileData) > 0 {
-		envMap := envutil.EnvToMap(string(envFileData))
-		for k, v := range envMap {
-			rtn[k] = v
-		}
-	}
-	cmdEnv := blockMeta.GetStringMap(waveobj.MetaKey_CmdEnv, true)
-	for k, v := range cmdEnv {
-		if v == waveobj.MetaMap_DeleteSentinel {
-			delete(rtn, k)
-			continue
-		}
-		rtn[k] = v
-	}
-	connEnv := blockMeta.GetConnectionOverride(connName).GetStringMap(waveobj.MetaKey_CmdEnv, true)
-	for k, v := range connEnv {
-		if v == waveobj.MetaMap_DeleteSentinel {
-			delete(rtn, k)
-			continue
-		}
-		rtn[k] = v
-	}
-	return rtn, nil
-}
+	controllerName := blockData.Meta.GetString(waveobj.MetaKey_Controller, "")
 
-// for "cmd" type blocks
-func createCmdStrAndOpts(blockId string, blockMeta waveobj.MetaMapType, connName string) (string, *shellexec.CommandOptsType, error) {
-	var cmdStr string
-	var cmdOpts shellexec.CommandOptsType
-	cmdStr = blockMeta.GetString(waveobj.MetaKey_Cmd, "")
-	if cmdStr == "" {
-		return "", nil, fmt.Errorf("missing cmd in block meta")
-	}
-	cmdOpts.Cwd = blockMeta.GetString(waveobj.MetaKey_CmdCwd, "")
-	if cmdOpts.Cwd != "" {
-		cwdPath, err := wavebase.ExpandHomeDir(cmdOpts.Cwd)
-		if err != nil {
-			return "", nil, err
-		}
-		cmdOpts.Cwd = cwdPath
-	}
-	useShell := blockMeta.GetBool(waveobj.MetaKey_CmdShell, true)
-	if !useShell {
-		if strings.Contains(cmdStr, " ") {
-			return "", nil, fmt.Errorf("cmd should not have spaces if cmd:shell is false (use cmd:args)")
-		}
-		cmdArgs := blockMeta.GetStringList(waveobj.MetaKey_CmdArgs)
-		// shell escape the args
-		for _, arg := range cmdArgs {
-			cmdStr = cmdStr + " " + utilfn.ShellQuote(arg, false, -1)
+	// Get existing controller
+	existing := getController(blockId)
+
+	// If no controller needed, stop existing if present
+	if controllerName == "" {
+		if existing != nil {
+			StopBlockController(blockId)
+			deleteController(blockId)
 		}
+		return nil
 	}
-	cmdOpts.ForceJwt = blockMeta.GetBool(waveobj.MetaKey_CmdJwt, false)
-	return cmdStr, &cmdOpts, nil
-}
 
-func (bc *BlockController) DoRunShellCommand(logCtx context.Context, rc *RunShellOpts, blockMeta waveobj.MetaMapType) error {
-	blocklogger.Debugf(logCtx, "[conndebug] DoRunShellCommand\n")
-	shellProc, err := bc.setupAndStartShellProcess(logCtx, rc, blockMeta)
-	if err != nil {
-		return err
-	}
-	return bc.manageRunningShellProcess(shellProc, rc, blockMeta)
-}
+	// Check if we need to morph controller type
+	if existing != nil {
+		existingStatus := existing.GetRuntimeStatus()
+		needsReplace := false
 
-func (bc *BlockController) makeSwapToken(ctx context.Context, logCtx context.Context, blockMeta waveobj.MetaMapType, remoteName string, shellType string) *shellutil.TokenSwapEntry {
-	token := &shellutil.TokenSwapEntry{
-		Token: uuid.New().String(),
-		Env:   make(map[string]string),
-		Exp:   time.Now().Add(5 * time.Minute),
-	}
-	token.Env["TERM_PROGRAM"] = "waveterm"
-	token.Env["WAVETERM_BLOCKID"] = bc.BlockId
-	token.Env["WAVETERM_VERSION"] = wavebase.WaveVersion
-	token.Env["WAVETERM"] = "1"
-	tabId, err := wstore.DBFindTabForBlockId(ctx, bc.BlockId)
-	if err != nil {
-		log.Printf("error finding tab for block: %v\n", err)
-	} else {
-		token.Env["WAVETERM_TABID"] = tabId
-	}
-	if tabId != "" {
-		wsId, err := wstore.DBFindWorkspaceForTabId(ctx, tabId)
-		if err != nil {
-			log.Printf("error finding workspace for tab: %v\n", err)
-		} else {
-			token.Env["WAVETERM_WORKSPACEID"] = wsId
+		// Determine if existing controller type matches what we need
+		switch existing.(type) {
+		case *ShellController:
+			if controllerName != BlockController_Shell && controllerName != BlockController_Cmd {
+				needsReplace = true
+			}
+		case *TsunamiController:
+			if controllerName != BlockController_Tsunami {
+				needsReplace = true
+			}
 		}
-	}
-	clientData, err := wstore.DBGetSingleton[*waveobj.Client](ctx)
-	if err != nil {
-		log.Printf("error getting client data: %v\n", err)
-	} else {
-		token.Env["WAVETERM_CLIENTID"] = clientData.OID
-	}
-	token.Env["WAVETERM_CONN"] = remoteName
-	envMap, err := resolveEnvMap(bc.BlockId, blockMeta, remoteName)
-	if err != nil {
-		log.Printf("error resolving env map: %v\n", err)
-	}
-	for k, v := range envMap {
-		token.Env[k] = v
-	}
-	token.ScriptText = getCustomInitScript(logCtx, blockMeta, remoteName, shellType)
-	return token
-}
 
-type ConnUnion struct {
-	ConnName   string
-	ConnType   string
-	SshConn    *conncontroller.SSHConn
-	WslConn    *wslconn.WslConn
-	WshEnabled bool
-	ShellPath  string
-	ShellOpts  []string
-	ShellType  string
-}
-
-func getLocalShellPath(blockMeta waveobj.MetaMapType) string {
-	shellPath := blockMeta.GetString(waveobj.MetaKey_TermLocalShellPath, "")
-	if shellPath != "" {
-		return shellPath
-	}
-	settings := wconfig.GetWatcher().GetFullConfig().Settings
-	if settings.TermLocalShellPath != "" {
-		return settings.TermLocalShellPath
+		if needsReplace {
+			log.Printf("stopping blockcontroller %s due to controller type change\n", blockId)
+			StopBlockController(blockId)
+			time.Sleep(100 * time.Millisecond)
+			deleteController(blockId)
+			existing = nil
+		}
+
+		// For shell/cmd, check if connection changed
+		if !needsReplace && (controllerName == BlockController_Shell || controllerName == BlockController_Cmd) {
+			connName := blockData.Meta.GetString(waveobj.MetaKey_Connection, "")
+			if existingStatus.ShellProcStatus == Status_Running && existingStatus.ShellProcConnName != connName {
+				log.Printf("stopping blockcontroller %s due to conn change\n", blockId)
+				StopBlockControllerAndSetStatus(blockId, Status_Init)
+				time.Sleep(100 * time.Millisecond)
+				// Don't delete, will reuse same controller type
+				existing = getController(blockId)
+			}
+		}
 	}
-	return shellutil.DetectLocalShellPath()
-}
 
-func getLocalShellOpts(blockMeta waveobj.MetaMapType) []string {
-	if blockMeta.HasKey(waveobj.MetaKey_TermLocalShellOpts) {
-		opts := blockMeta.GetStringList(waveobj.MetaKey_TermLocalShellOpts)
-		return append([]string{}, opts...)
-	}
-	settings := wconfig.GetWatcher().GetFullConfig().Settings
-	if len(settings.TermLocalShellOpts) > 0 {
-		return append([]string{}, settings.TermLocalShellOpts...)
+	// Force restart if requested
+	if force && existing != nil {
+		StopBlockController(blockId)
+		time.Sleep(100 * time.Millisecond)
+		existing = getController(blockId)
 	}
-	return nil
-}
 
-func (union *ConnUnion) getRemoteInfoAndShellType(blockMeta waveobj.MetaMapType) error {
-	if !union.WshEnabled {
-		return nil
-	}
-	if union.ConnType == ConnType_Ssh || union.ConnType == ConnType_Wsl {
-		connRoute := wshutil.MakeConnectionRouteId(union.ConnName)
-		remoteInfo, err := wshclient.RemoteGetInfoCommand(wshclient.GetBareRpcClient(), &wshrpc.RpcOpts{Route: connRoute, Timeout: 2000})
-		if err != nil {
-			// weird error, could flip the wshEnabled flag and allow it to go forward, but the connection should have already been vetted
-			return fmt.Errorf("unable to obtain remote info from connserver: %w", err)
-		}
-		// TODO allow overriding remote shell path
-		union.ShellPath = remoteInfo.Shell
+	// Create or restart controller
+	var controller Controller
+	if existing != nil {
+		controller = existing
 	} else {
-		union.ShellPath = getLocalShellPath(blockMeta)
-	}
-	union.ShellType = shellutil.GetShellTypeFromShellPath(union.ShellPath)
-	return nil
-}
+		// Create new controller based on type
+		switch controllerName {
+		case BlockController_Shell, BlockController_Cmd:
+			controller = MakeShellController(tabId, blockId, controllerName)
+			registerController(blockId, controller)
 
-func (bc *BlockController) getConnUnion(logCtx context.Context, remoteName string, blockMeta waveobj.MetaMapType) (ConnUnion, error) {
-	rtn := ConnUnion{ConnName: remoteName}
-	wshEnabled := !blockMeta.GetBool(waveobj.MetaKey_CmdNoWsh, false)
-	if strings.HasPrefix(remoteName, "wsl://") {
-		wslName := strings.TrimPrefix(remoteName, "wsl://")
-		wslConn := wslconn.GetWslConn(wslName)
-		if wslConn == nil {
-			return ConnUnion{}, fmt.Errorf("wsl connection not found: %s", remoteName)
-		}
-		connStatus := wslConn.DeriveConnStatus()
-		if connStatus.Status != conncontroller.Status_Connected {
-			return ConnUnion{}, fmt.Errorf("wsl connection %s not connected, cannot start shellproc", remoteName)
-		}
-		rtn.ConnType = ConnType_Wsl
-		rtn.WslConn = wslConn
-		rtn.WshEnabled = wshEnabled && wslConn.WshEnabled.Load()
-	} else if remoteName != "" {
-		opts, err := remote.ParseOpts(remoteName)
-		if err != nil {
-			return ConnUnion{}, fmt.Errorf("invalid ssh remote name (%s): %w", remoteName, err)
-		}
-		conn := conncontroller.GetConn(opts)
-		if conn == nil {
-			return ConnUnion{}, fmt.Errorf("ssh connection not found: %s", remoteName)
-		}
-		connStatus := conn.DeriveConnStatus()
-		if connStatus.Status != conncontroller.Status_Connected {
-			return ConnUnion{}, fmt.Errorf("ssh connection %s not connected, cannot start shellproc", remoteName)
-		}
-		rtn.ConnType = ConnType_Ssh
-		rtn.SshConn = conn
-		rtn.WshEnabled = wshEnabled && conn.WshEnabled.Load()
-	} else {
-		rtn.ConnType = ConnType_Local
-		rtn.WshEnabled = wshEnabled
-	}
-	err := rtn.getRemoteInfoAndShellType(blockMeta)
-	if err != nil {
-		return ConnUnion{}, err
-	}
-	return rtn, nil
-}
+		case BlockController_Tsunami:
+			controller = MakeTsunamiController(tabId, blockId)
+			registerController(blockId, controller)
 
-func (bc *BlockController) setupAndStartShellProcess(logCtx context.Context, rc *RunShellOpts, blockMeta waveobj.MetaMapType) (*shellexec.ShellProc, error) {
-	// create a circular blockfile for the output
-	ctx, cancelFn := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancelFn()
-	fsErr := filestore.WFS.MakeFile(ctx, bc.BlockId, wavebase.BlockFile_Term, nil, wshrpc.FileOpts{MaxSize: DefaultTermMaxFileSize, Circular: true})
-	if fsErr != nil && fsErr != fs.ErrExist {
-		return nil, fmt.Errorf("error creating blockfile: %w", fsErr)
-	}
-	if fsErr == fs.ErrExist {
-		// reset the terminal state
-		bc.resetTerminalState(logCtx)
-	}
-	bcInitStatus := bc.GetRuntimeStatus()
-	if bcInitStatus.ShellProcStatus == Status_Running {
-		return nil, nil
-	}
-	// TODO better sync here (don't let two starts happen at the same times)
-	remoteName := blockMeta.GetString(waveobj.MetaKey_Connection, "")
-	connUnion, err := bc.getConnUnion(logCtx, remoteName, blockMeta)
-	if err != nil {
-		return nil, err
-	}
-	blocklogger.Infof(logCtx, "[conndebug] remoteName: %q, connType: %s, wshEnabled: %v, shell: %q, shellType: %s\n", remoteName, connUnion.ConnType, connUnion.WshEnabled, connUnion.ShellPath, connUnion.ShellType)
-	var cmdStr string
-	var cmdOpts shellexec.CommandOptsType
-	if bc.ControllerType == BlockController_Shell {
-		cmdOpts.Interactive = true
-		cmdOpts.Login = true
-		cmdOpts.Cwd = blockMeta.GetString(waveobj.MetaKey_CmdCwd, "")
-		if cmdOpts.Cwd != "" {
-			cwdPath, err := wavebase.ExpandHomeDir(cmdOpts.Cwd)
-			if err != nil {
-				return nil, err
-			}
-			cmdOpts.Cwd = cwdPath
-		}
-	} else if bc.ControllerType == BlockController_Cmd {
-		var cmdOptsPtr *shellexec.CommandOptsType
-		cmdStr, cmdOptsPtr, err = createCmdStrAndOpts(bc.BlockId, blockMeta, remoteName)
-		if err != nil {
-			return nil, err
+		default:
+			return fmt.Errorf("unknown controller type %q", controllerName)
 		}
-		cmdOpts = *cmdOptsPtr
-	} else {
-		return nil, fmt.Errorf("unknown controller type %q", bc.ControllerType)
 	}
-	var shellProc *shellexec.ShellProc
-	swapToken := bc.makeSwapToken(ctx, logCtx, blockMeta, remoteName, connUnion.ShellType)
-	cmdOpts.SwapToken = swapToken
-	blocklogger.Debugf(logCtx, "[conndebug] created swaptoken: %s\n", swapToken.Token)
-	if connUnion.ConnType == ConnType_Wsl {
-		wslConn := connUnion.WslConn
-		if !connUnion.WshEnabled {
-			shellProc, err = shellexec.StartWslShellProcNoWsh(ctx, rc.TermSize, cmdStr, cmdOpts, wslConn)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			sockName := wslConn.GetDomainSocketName()
-			rpcContext := wshrpc.RpcContext{TabId: bc.TabId, BlockId: bc.BlockId, Conn: wslConn.GetName()}
-			jwtStr, err := wshutil.MakeClientJWTToken(rpcContext, sockName)
-			if err != nil {
-				return nil, fmt.Errorf("error making jwt token: %w", err)
-			}
-			swapToken.SockName = sockName
-			swapToken.RpcContext = &rpcContext
-			swapToken.Env[wshutil.WaveJwtTokenVarName] = jwtStr
-			shellProc, err = shellexec.StartWslShellProc(ctx, rc.TermSize, cmdStr, cmdOpts, wslConn)
-			if err != nil {
-				wslConn.SetWshError(err)
-				wslConn.WshEnabled.Store(false)
-				blocklogger.Infof(logCtx, "[conndebug] error starting wsl shell proc with wsh: %v\n", err)
-				blocklogger.Infof(logCtx, "[conndebug] attempting install without wsh\n")
-				shellProc, err = shellexec.StartWslShellProcNoWsh(ctx, rc.TermSize, cmdStr, cmdOpts, wslConn)
-				if err != nil {
-					return nil, err
-				}
-			}
-		}
-	} else if connUnion.ConnType == ConnType_Ssh {
-		conn := connUnion.SshConn
-		if !connUnion.WshEnabled {
-			shellProc, err = shellexec.StartRemoteShellProcNoWsh(ctx, rc.TermSize, cmdStr, cmdOpts, conn)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			sockName := conn.GetDomainSocketName()
-			rpcContext := wshrpc.RpcContext{TabId: bc.TabId, BlockId: bc.BlockId, Conn: conn.Opts.String()}
-			jwtStr, err := wshutil.MakeClientJWTToken(rpcContext, sockName)
-			if err != nil {
-				return nil, fmt.Errorf("error making jwt token: %w", err)
-			}
-			swapToken.SockName = sockName
-			swapToken.RpcContext = &rpcContext
-			swapToken.Env[wshutil.WaveJwtTokenVarName] = jwtStr
-			shellProc, err = shellexec.StartRemoteShellProc(ctx, logCtx, rc.TermSize, cmdStr, cmdOpts, conn)
-			if err != nil {
-				conn.SetWshError(err)
-				conn.WshEnabled.Store(false)
-				blocklogger.Infof(logCtx, "[conndebug] error starting remote shell proc with wsh: %v\n", err)
-				blocklogger.Infof(logCtx, "[conndebug] attempting install without wsh\n")
-				shellProc, err = shellexec.StartRemoteShellProcNoWsh(ctx, rc.TermSize, cmdStr, cmdOpts, conn)
+
+	// Check if we need to start/restart
+	status := controller.GetRuntimeStatus()
+	if status.ShellProcStatus == Status_Init || status.ShellProcStatus == Status_Done {
+		// For shell/cmd, check connection status first
+		if controllerName == BlockController_Shell || controllerName == BlockController_Cmd {
+			connName := blockData.Meta.GetString(waveobj.MetaKey_Connection, "")
+			if connName != "" {
+				err = CheckConnStatus(blockId)
 				if err != nil {
-					return nil, err
+					return fmt.Errorf("cannot start shellproc: %w", err)
 				}
 			}
 		}
-	} else if connUnion.ConnType == ConnType_Local {
-		if connUnion.WshEnabled {
-			sockName := wavebase.GetDomainSocketName()
-			rpcContext := wshrpc.RpcContext{TabId: bc.TabId, BlockId: bc.BlockId}
-			jwtStr, err := wshutil.MakeClientJWTToken(rpcContext, sockName)
-			if err != nil {
-				return nil, fmt.Errorf("error making jwt token: %w", err)
-			}
-			swapToken.SockName = sockName
-			swapToken.RpcContext = &rpcContext
-			swapToken.Env[wshutil.WaveJwtTokenVarName] = jwtStr
-		}
-		cmdOpts.ShellPath = connUnion.ShellPath
-		cmdOpts.ShellOpts = getLocalShellOpts(blockMeta)
-		shellProc, err = shellexec.StartLocalShellProc(logCtx, rc.TermSize, cmdStr, cmdOpts)
+
+		// Start controller
+		err = controller.Start(ctx, blockData.Meta, rtOpts, force)
 		if err != nil {
-			return nil, err
+			return fmt.Errorf("error starting controller: %w", err)
 		}
-	} else {
-		return nil, fmt.Errorf("unknown connection type for conn %q: %s", remoteName, connUnion.ConnType)
-	}
-	bc.UpdateControllerAndSendUpdate(func() bool {
-		bc.ShellProc = shellProc
-		bc.ShellProcStatus = Status_Running
-		return true
-	})
-	return shellProc, nil
-}
-
-func (bc *BlockController) getBlockData_noErr() *waveobj.Block {
-	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
-	defer cancelFn()
-	blockData, err := wstore.DBGet[*waveobj.Block](ctx, bc.BlockId)
-	if err != nil {
-		log.Printf("error getting block data (getBlockData_noErr): %v\n", err)
-		return nil
 	}
-	return blockData
-}
 
-func (bc *BlockController) manageRunningShellProcess(shellProc *shellexec.ShellProc, rc *RunShellOpts, blockMeta waveobj.MetaMapType) error {
-	shellInputCh := make(chan *BlockInputUnion, 32)
-	bc.ShellInputCh = shellInputCh
-
-	// make esc sequence wshclient wshProxy
-	// we don't need to authenticate this wshProxy since it is coming direct
-	wshProxy := wshutil.MakeRpcProxy()
-	wshProxy.SetRpcContext(&wshrpc.RpcContext{TabId: bc.TabId, BlockId: bc.BlockId})
-	wshutil.DefaultRouter.RegisterRoute(wshutil.MakeControllerRouteId(bc.BlockId), wshProxy, true)
-	ptyBuffer := wshutil.MakePtyBuffer(wshutil.WaveOSCPrefix, shellProc.Cmd, wshProxy.FromRemoteCh)
-	go func() {
-		// handles regular output from the pty (goes to the blockfile and xterm)
-		defer func() {
-			panichandler.PanicHandler("blockcontroller:shellproc-pty-read-loop", recover())
-		}()
-		defer func() {
-			log.Printf("[shellproc] pty-read loop done\n")
-			shellProc.Close()
-			bc.WithLock(func() {
-				// so no other events are sent
-				bc.ShellInputCh = nil
-			})
-			shellProc.Cmd.Wait()
-			exitCode := shellProc.Cmd.ExitCode()
-			blockData := bc.getBlockData_noErr()
-			if blockData != nil && blockData.Meta.GetString(waveobj.MetaKey_Controller, "") == BlockController_Cmd {
-				termMsg := fmt.Sprintf("\r\nprocess finished with exit code = %d\r\n\r\n", exitCode)
-				HandleAppendBlockFile(bc.BlockId, wavebase.BlockFile_Term, []byte(termMsg))
-			}
-			// to stop the inputCh loop
-			time.Sleep(100 * time.Millisecond)
-			close(shellInputCh) // don't use bc.ShellInputCh (it's nil)
-		}()
-		buf := make([]byte, 4096)
-		for {
-			nr, err := ptyBuffer.Read(buf)
-			if nr > 0 {
-				err := HandleAppendBlockFile(bc.BlockId, wavebase.BlockFile_Term, buf[:nr])
-				if err != nil {
-					log.Printf("error appending to blockfile: %v\n", err)
-				}
-			}
-			if err == io.EOF {
-				break
-			}
-			if err != nil {
-				log.Printf("error reading from shell: %v\n", err)
-				break
-			}
-		}
-	}()
-	go func() {
-		// handles input from the shellInputCh, sent to pty
-		// use shellInputCh instead of bc.ShellInputCh (because we want to be attached to *this* ch.  bc.ShellInputCh can be updated)
-		defer func() {
-			panichandler.PanicHandler("blockcontroller:shellproc-input-loop", recover())
-		}()
-		for ic := range shellInputCh {
-			if len(ic.InputData) > 0 {
-				shellProc.Cmd.Write(ic.InputData)
-			}
-			if ic.TermSize != nil {
-				updateTermSize(shellProc, bc.BlockId, *ic.TermSize)
-			}
-		}
-	}()
-	go func() {
-		defer func() {
-			panichandler.PanicHandler("blockcontroller:shellproc-output-loop", recover())
-		}()
-		// handles outputCh -> shellInputCh
-		for msg := range wshProxy.ToRemoteCh {
-			encodedMsg, err := wshutil.EncodeWaveOSCBytes(wshutil.WaveServerOSC, msg)
-			if err != nil {
-				log.Printf("error encoding OSC message: %v\n", err)
-			}
-			shellInputCh <- &BlockInputUnion{InputData: encodedMsg}
-		}
-	}()
-	go func() {
-		defer func() {
-			panichandler.PanicHandler("blockcontroller:shellproc-wait-loop", recover())
-		}()
-		// wait for the shell to finish
-		var exitCode int
-		defer func() {
-			wshutil.DefaultRouter.UnregisterRoute(wshutil.MakeControllerRouteId(bc.BlockId))
-			bc.UpdateControllerAndSendUpdate(func() bool {
-				if bc.ShellProcStatus == Status_Running {
-					bc.ShellProcStatus = Status_Done
-				}
-				bc.ShellProcExitCode = exitCode
-				return true
-			})
-			log.Printf("[shellproc] shell process wait loop done\n")
-		}()
-		waitErr := shellProc.Cmd.Wait()
-		exitCode = shellProc.Cmd.ExitCode()
-		shellProc.SetWaitErrorAndSignalDone(waitErr)
-		go checkCloseOnExit(bc.BlockId, exitCode)
-	}()
 	return nil
 }
 
-func updateTermSize(shellProc *shellexec.ShellProc, blockId string, termSize waveobj.TermSize) {
-	err := setTermSizeInDB(blockId, termSize)
-	if err != nil {
-		log.Printf("error setting pty size: %v\n", err)
-	}
-	err = shellProc.Cmd.SetSize(termSize.Rows, termSize.Cols)
-	if err != nil {
-		log.Printf("error setting pty size: %v\n", err)
+func GetBlockControllerRuntimeStatus(blockId string) *BlockControllerRuntimeStatus {
+	controller := getController(blockId)
+	if controller == nil {
+		return nil
 	}
+	return controller.GetRuntimeStatus()
 }
 
-func checkCloseOnExit(blockId string, exitCode int) {
-	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
-	defer cancelFn()
-	blockData, err := wstore.DBMustGet[*waveobj.Block](ctx, blockId)
-	if err != nil {
-		log.Printf("error getting block data: %v\n", err)
+func StopBlockController(blockId string) {
+	controller := getController(blockId)
+	if controller == nil {
 		return
 	}
-	closeOnExit := blockData.Meta.GetBool(waveobj.MetaKey_CmdCloseOnExit, false)
-	closeOnExitForce := blockData.Meta.GetBool(waveobj.MetaKey_CmdCloseOnExitForce, false)
-	if !closeOnExitForce && !(closeOnExit && exitCode == 0) {
+	controller.Stop(true, Status_Done)
+}
+
+func StopBlockControllerAndSetStatus(blockId string, newStatus string) {
+	controller := getController(blockId)
+	if controller == nil {
 		return
 	}
-	delayMs := blockData.Meta.GetFloat(waveobj.MetaKey_CmdCloseOnExitDelay, 2000)
-	if delayMs < 0 {
-		delayMs = 0
+	controller.Stop(true, newStatus)
+}
+
+func SendInput(blockId string, inputUnion *BlockInputUnion) error {
+	controller := getController(blockId)
+	if controller == nil {
+		return fmt.Errorf("no controller found for block %s", blockId)
 	}
-	time.Sleep(time.Duration(delayMs) * time.Millisecond)
-	rpcClient := wshclient.GetBareRpcClient()
-	err = wshclient.DeleteBlockCommand(rpcClient, wshrpc.CommandDeleteBlockData{BlockId: blockId}, nil)
-	if err != nil {
-		log.Printf("error deleting block data (close on exit): %v\n", err)
+	return controller.SendInput(inputUnion)
+}
+
+func StopAllBlockControllers() {
+	controllers := getAllControllers()
+	for blockId, controller := range controllers {
+		status := controller.GetRuntimeStatus()
+		if status != nil && status.ShellProcStatus == Status_Running {
+			go func(id string, c Controller) {
+				c.Stop(true, Status_Done)
+			}(blockId, controller)
+		}
 	}
 }
 
@@ -832,111 +295,61 @@ func getTermSize(bdata *waveobj.Block) waveobj.TermSize {
 	}
 }
 
-func setTermSizeInDB(blockId string, termSize waveobj.TermSize) error {
-	ctx, cancelFn := context.WithTimeout(context.Background(), 2*time.Second)
+func HandleAppendBlockFile(blockId string, blockFile string, data []byte) error {
+	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
 	defer cancelFn()
-	ctx = waveobj.ContextWithUpdates(ctx)
-	bdata, err := wstore.DBMustGet[*waveobj.Block](ctx, blockId)
-	if err != nil {
-		return fmt.Errorf("error getting block data: %v", err)
-	}
-	if bdata.RuntimeOpts == nil {
-		bdata.RuntimeOpts = &waveobj.RuntimeOpts{}
-	}
-	bdata.RuntimeOpts.TermSize = termSize
-	err = wstore.DBUpdate(ctx, bdata)
+	err := filestore.WFS.AppendData(ctx, blockId, blockFile, data)
 	if err != nil {
-		return fmt.Errorf("error updating block data: %v", err)
+		return fmt.Errorf("error appending to blockfile: %w", err)
 	}
-	updates := waveobj.ContextGetUpdatesRtn(ctx)
-	wps.Broker.SendUpdateEvents(updates)
+	wps.Broker.Publish(wps.WaveEvent{
+		Event: wps.Event_BlockFile,
+		Scopes: []string{
+			waveobj.MakeORef(waveobj.OType_Block, blockId).String(),
+		},
+		Data: &wps.WSFileEventData{
+			ZoneId:   blockId,
+			FileName: blockFile,
+			FileOp:   wps.FileOp_Append,
+			Data64:   base64.StdEncoding.EncodeToString(data),
+		},
+	})
 	return nil
 }
 
-func (bc *BlockController) LockRunLock() bool {
-	rtn := bc.RunLock.CompareAndSwap(false, true)
-	if rtn {
-		log.Printf("block %q run() lock\n", bc.BlockId)
+func HandleTruncateBlockFile(blockId string) error {
+	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
+	defer cancelFn()
+	err := filestore.WFS.WriteFile(ctx, blockId, wavebase.BlockFile_Term, nil)
+	if err == fs.ErrNotExist {
+		return nil
 	}
-	return rtn
-}
-
-func (bc *BlockController) UnlockRunLock() {
-	bc.RunLock.Store(false)
-	log.Printf("block %q run() unlock\n", bc.BlockId)
-}
-
-func (bc *BlockController) run(logCtx context.Context, bdata *waveobj.Block, blockMeta map[string]any, rtOpts *waveobj.RuntimeOpts, force bool) {
-	blocklogger.Debugf(logCtx, "[conndebug] BlockController.run() %q\n", bc.BlockId)
-	runningShellCommand := false
-	ok := bc.LockRunLock()
-	if !ok {
-		log.Printf("block %q is already executing run()\n", bc.BlockId)
-		return
+	if err != nil {
+		return fmt.Errorf("error truncating blockfile: %w", err)
 	}
-	defer func() {
-		if !runningShellCommand {
-			bc.UnlockRunLock()
-		}
-	}()
-	curStatus := bc.GetRuntimeStatus()
-	controllerName := bdata.Meta.GetString(waveobj.MetaKey_Controller, "")
-	if controllerName != BlockController_Shell && controllerName != BlockController_Cmd {
-		log.Printf("unknown controller %q\n", controllerName)
-		return
+	err = filestore.WFS.DeleteFile(ctx, blockId, wavebase.BlockFile_Cache)
+	if err == fs.ErrNotExist {
+		err = nil
 	}
-	runOnce := getBoolFromMeta(blockMeta, waveobj.MetaKey_CmdRunOnce, false)
-	runOnStart := getBoolFromMeta(blockMeta, waveobj.MetaKey_CmdRunOnStart, true)
-	if ((runOnStart || runOnce) && curStatus.ShellProcStatus == Status_Init) || force {
-		if getBoolFromMeta(blockMeta, waveobj.MetaKey_CmdClearOnStart, false) {
-			err := HandleTruncateBlockFile(bc.BlockId)
-			if err != nil {
-				log.Printf("error truncating term blockfile: %v\n", err)
-			}
-		}
-		if runOnce {
-			ctx, cancelFn := context.WithTimeout(context.Background(), 2*time.Second)
-			defer cancelFn()
-			metaUpdate := map[string]any{
-				waveobj.MetaKey_CmdRunOnce:    false,
-				waveobj.MetaKey_CmdRunOnStart: false,
-			}
-			err := wstore.UpdateObjectMeta(ctx, waveobj.MakeORef(waveobj.OType_Block, bc.BlockId), metaUpdate, false)
-			if err != nil {
-				log.Printf("error updating block meta (in blockcontroller.run): %v\n", err)
-				return
-			}
-		}
-		runningShellCommand = true
-		go func() {
-			defer func() {
-				panichandler.PanicHandler("blockcontroller:run-shell-command", recover())
-			}()
-			defer bc.UnlockRunLock()
-			var termSize waveobj.TermSize
-			if rtOpts != nil {
-				termSize = rtOpts.TermSize
-			} else {
-				termSize = getTermSize(bdata)
-			}
-			err := bc.DoRunShellCommand(logCtx, &RunShellOpts{TermSize: termSize}, bdata.Meta)
-			if err != nil {
-				debugLog(logCtx, "error running shell: %v\n", err)
-			}
-		}()
+	if err != nil {
+		log.Printf("error deleting cache file (continuing): %v\n", err)
 	}
-}
-
-func (bc *BlockController) SendInput(inputUnion *BlockInputUnion) error {
-	var shellInputCh chan *BlockInputUnion
-	bc.WithLock(func() {
-		shellInputCh = bc.ShellInputCh
+	wps.Broker.Publish(wps.WaveEvent{
+		Event:  wps.Event_BlockFile,
+		Scopes: []string{waveobj.MakeORef(waveobj.OType_Block, blockId).String()},
+		Data: &wps.WSFileEventData{
+			ZoneId:   blockId,
+			FileName: wavebase.BlockFile_Term,
+			FileOp:   wps.FileOp_Truncate,
+		},
 	})
-	if shellInputCh == nil {
-		return fmt.Errorf("no shell input chan")
-	}
-	shellInputCh <- inputUnion
 	return nil
+
+}
+
+func debugLog(ctx context.Context, fmtStr string, args ...interface{}) {
+	blocklogger.Infof(ctx, "[conndebug] "+fmtStr, args...)
+	log.Printf(fmtStr, args...)
 }
 
 func CheckConnStatus(blockId string) error {
@@ -968,178 +381,3 @@ func CheckConnStatus(blockId string) error {
 	}
 	return nil
 }
-
-func (bc *BlockController) StopShellProc(shouldWait bool) {
-	bc.Lock.Lock()
-	defer bc.Lock.Unlock()
-	if bc.ShellProc == nil || bc.ShellProcStatus == Status_Done || bc.ShellProcStatus == Status_Init {
-		return
-	}
-	bc.ShellProc.Close()
-	if shouldWait {
-		doneCh := bc.ShellProc.DoneCh
-		<-doneCh
-	}
-}
-
-func getOrCreateBlockController(tabId string, blockId string, controllerName string) *BlockController {
-	var createdController bool
-	var bc *BlockController
-	defer func() {
-		if !createdController || bc == nil {
-			return
-		}
-		bc.UpdateControllerAndSendUpdate(func() bool {
-			return true
-		})
-	}()
-	globalLock.Lock()
-	defer globalLock.Unlock()
-	bc = blockControllerMap[blockId]
-	if bc == nil {
-		bc = &BlockController{
-			Lock:            &sync.Mutex{},
-			ControllerType:  controllerName,
-			TabId:           tabId,
-			BlockId:         blockId,
-			ShellProcStatus: Status_Init,
-			RunLock:         &atomic.Bool{},
-		}
-		blockControllerMap[blockId] = bc
-		createdController = true
-	}
-	return bc
-}
-
-func formatConnNameForLog(connName string) string {
-	if connName == "" {
-		return "local"
-	}
-	return connName
-}
-
-func ResyncController(ctx context.Context, tabId string, blockId string, rtOpts *waveobj.RuntimeOpts, force bool) error {
-	if tabId == "" || blockId == "" {
-		return fmt.Errorf("invalid tabId or blockId passed to ResyncController")
-	}
-	blockData, err := wstore.DBMustGet[*waveobj.Block](ctx, blockId)
-	if err != nil {
-		return fmt.Errorf("error getting block: %w", err)
-	}
-	if force {
-		StopBlockController(blockId)
-		time.Sleep(100 * time.Millisecond) // TODO see if we can remove this (the "process finished with exit code" message comes out after we start reconnecting otherwise)
-	}
-	connName := blockData.Meta.GetString(waveobj.MetaKey_Connection, "")
-	controllerName := blockData.Meta.GetString(waveobj.MetaKey_Controller, "")
-	curBc := GetBlockController(blockId)
-	if controllerName == "" {
-		if curBc != nil {
-			StopBlockController(blockId)
-		}
-		return nil
-	}
-	log.Printf("resync controller %s %q (%q) (force %v)\n", blockId, controllerName, connName, force)
-	// check if conn is different, if so, stop the current controller, and set status back to init
-	if curBc != nil {
-		bcStatus := curBc.GetRuntimeStatus()
-		if bcStatus.ShellProcStatus == Status_Running && bcStatus.ShellProcConnName != connName {
-			blocklogger.Infof(ctx, "\n[conndebug] stopping blockcontroller due to conn change %q => %q\n", formatConnNameForLog(bcStatus.ShellProcConnName), formatConnNameForLog(connName))
-			log.Printf("stopping blockcontroller %s due to conn change\n", blockId)
-			StopBlockControllerAndSetStatus(blockId, Status_Init)
-			time.Sleep(100 * time.Millisecond) // TODO see if we can remove this (the "process finished with exit code" message comes out after we start reconnecting otherwise)
-		}
-	}
-	// now if there is a conn, ensure it is connected
-	if connName != "" {
-		err = CheckConnStatus(blockId)
-		if err != nil {
-			return fmt.Errorf("cannot start shellproc: %w", err)
-		}
-	}
-	if curBc == nil {
-		return startBlockController(ctx, tabId, blockId, rtOpts, force)
-	}
-	bcStatus := curBc.GetRuntimeStatus()
-	if bcStatus.ShellProcStatus == Status_Init || bcStatus.ShellProcStatus == Status_Done {
-		return startBlockController(ctx, tabId, blockId, rtOpts, force)
-	}
-	return nil
-}
-
-func debugLog(ctx context.Context, fmtStr string, args ...interface{}) {
-	blocklogger.Infof(ctx, "[conndebug] "+fmtStr, args...)
-	log.Printf(fmtStr, args...)
-}
-
-func startBlockController(ctx context.Context, tabId string, blockId string, rtOpts *waveobj.RuntimeOpts, force bool) error {
-	blockData, err := wstore.DBMustGet[*waveobj.Block](ctx, blockId)
-	if err != nil {
-		return fmt.Errorf("error getting block: %w", err)
-	}
-	controllerName := blockData.Meta.GetString(waveobj.MetaKey_Controller, "")
-	if controllerName == "" {
-		// nothing to start
-		return nil
-	}
-	if controllerName != BlockController_Shell && controllerName != BlockController_Cmd {
-		return fmt.Errorf("unknown controller %q", controllerName)
-	}
-	connName := blockData.Meta.GetString(waveobj.MetaKey_Connection, "")
-	err = CheckConnStatus(blockId)
-	if err != nil {
-		return fmt.Errorf("cannot start shellproc: %w", err)
-	}
-	bc := getOrCreateBlockController(tabId, blockId, controllerName)
-	bcStatus := bc.GetRuntimeStatus()
-	debugLog(ctx, "start blockcontroller %s %q (%q) (curstatus %s) (force %v)\n", blockId, controllerName, connName, bcStatus.ShellProcStatus, force)
-	if bcStatus.ShellProcStatus == Status_Init || bcStatus.ShellProcStatus == Status_Done {
-		go bc.run(ctx, blockData, blockData.Meta, rtOpts, force)
-	}
-	return nil
-}
-
-func StopBlockControllerAndSetStatus(blockId string, newStatus string) {
-	bc := GetBlockController(blockId)
-	if bc == nil {
-		return
-	}
-	if bc.getShellProc() != nil {
-		bc.ShellProc.Close()
-		<-bc.ShellProc.DoneCh
-		bc.UpdateControllerAndSendUpdate(func() bool {
-			bc.ShellProcStatus = newStatus
-			return true
-		})
-	}
-
-}
-
-func StopBlockController(blockId string) {
-	StopBlockControllerAndSetStatus(blockId, Status_Done)
-}
-
-func getControllerList() []*BlockController {
-	globalLock.Lock()
-	defer globalLock.Unlock()
-	var rtn []*BlockController
-	for _, bc := range blockControllerMap {
-		rtn = append(rtn, bc)
-	}
-	return rtn
-}
-
-func StopAllBlockControllers() {
-	clist := getControllerList()
-	for _, bc := range clist {
-		if bc.ShellProcStatus == Status_Running {
-			go StopBlockController(bc.BlockId)
-		}
-	}
-}
-
-func GetBlockController(blockId string) *BlockController {
-	globalLock.Lock()
-	defer globalLock.Unlock()
-	return blockControllerMap[blockId]
-}
diff --git a/pkg/blockcontroller/shell_controller.go b/pkg/blockcontroller/shell_controller.go
deleted file mode 100644
index 14bb0fa65b..0000000000
--- a/pkg/blockcontroller/shell_controller.go
+++ /dev/null
@@ -1,4 +0,0 @@
-// Copyright 2025, Command Line Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package blockcontroller
diff --git a/pkg/blockcontroller/shellcontroller.go b/pkg/blockcontroller/shellcontroller.go
new file mode 100644
index 0000000000..2aabec9eaf
--- /dev/null
+++ b/pkg/blockcontroller/shellcontroller.go
@@ -0,0 +1,904 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package blockcontroller
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"os"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/wavetermdev/waveterm/pkg/blocklogger"
+	"github.com/wavetermdev/waveterm/pkg/filestore"
+	"github.com/wavetermdev/waveterm/pkg/panichandler"
+	"github.com/wavetermdev/waveterm/pkg/remote"
+	"github.com/wavetermdev/waveterm/pkg/remote/conncontroller"
+	"github.com/wavetermdev/waveterm/pkg/shellexec"
+	"github.com/wavetermdev/waveterm/pkg/util/envutil"
+	"github.com/wavetermdev/waveterm/pkg/util/fileutil"
+	"github.com/wavetermdev/waveterm/pkg/util/shellutil"
+	"github.com/wavetermdev/waveterm/pkg/util/utilfn"
+	"github.com/wavetermdev/waveterm/pkg/wavebase"
+	"github.com/wavetermdev/waveterm/pkg/waveobj"
+	"github.com/wavetermdev/waveterm/pkg/wconfig"
+	"github.com/wavetermdev/waveterm/pkg/wps"
+	"github.com/wavetermdev/waveterm/pkg/wshrpc"
+	"github.com/wavetermdev/waveterm/pkg/wshrpc/wshclient"
+	"github.com/wavetermdev/waveterm/pkg/wshutil"
+	"github.com/wavetermdev/waveterm/pkg/wslconn"
+	"github.com/wavetermdev/waveterm/pkg/wstore"
+)
+
+const (
+	ConnType_Local = "local"
+	ConnType_Wsl   = "wsl"
+	ConnType_Ssh   = "ssh"
+)
+
+type ShellController struct {
+	Lock *sync.Mutex
+
+	// shared fields
+	ControllerType string
+	TabId          string
+	BlockId        string
+	BlockDef       *waveobj.BlockDef
+	RunLock        *atomic.Bool
+	ProcStatus     string
+	ProcExitCode   int
+	StatusVersion  int
+
+	// for shell/cmd
+	ShellProc    *shellexec.ShellProc
+	ShellInputCh chan *BlockInputUnion
+}
+
+// Constructor that returns the Controller interface
+func MakeShellController(tabId string, blockId string, controllerType string) Controller {
+	return &ShellController{
+		Lock:           &sync.Mutex{},
+		ControllerType: controllerType,
+		TabId:          tabId,
+		BlockId:        blockId,
+		ProcStatus:     Status_Init,
+		RunLock:        &atomic.Bool{},
+	}
+}
+
+// Implement Controller interface methods
+
+func (sc *ShellController) Start(ctx context.Context, blockMeta waveobj.MetaMapType, rtOpts *waveobj.RuntimeOpts, force bool) error {
+	// Get the block data
+	blockData, err := wstore.DBMustGet[*waveobj.Block](ctx, sc.BlockId)
+	if err != nil {
+		return fmt.Errorf("error getting block: %w", err)
+	}
+
+	// Use the existing run method which handles all the start logic
+	go sc.run(ctx, blockData, blockData.Meta, rtOpts, force)
+	return nil
+}
+
+func (sc *ShellController) Stop(graceful bool, newStatus string) error {
+	sc.Lock.Lock()
+	defer sc.Lock.Unlock()
+
+	if sc.ShellProc == nil || sc.ProcStatus == Status_Done || sc.ProcStatus == Status_Init {
+		if newStatus != sc.ProcStatus {
+			sc.ProcStatus = newStatus
+			sc.sendUpdate_nolock()
+		}
+		return nil
+	}
+
+	sc.ShellProc.Close()
+	if graceful {
+		doneCh := sc.ShellProc.DoneCh
+		sc.Lock.Unlock() // Unlock before waiting
+		<-doneCh
+		sc.Lock.Lock() // Re-lock after waiting
+	}
+
+	// Update status
+	sc.ProcStatus = newStatus
+	sc.sendUpdate_nolock()
+	return nil
+}
+
+func (sc *ShellController) getRuntimeStatus_nolock() BlockControllerRuntimeStatus {
+	var rtn BlockControllerRuntimeStatus
+	sc.StatusVersion++
+	rtn.Version = sc.StatusVersion
+	rtn.BlockId = sc.BlockId
+	rtn.ShellProcStatus = sc.ProcStatus
+	if sc.ShellProc != nil {
+		rtn.ShellProcConnName = sc.ShellProc.ConnName
+	}
+	rtn.ShellProcExitCode = sc.ProcExitCode
+	return rtn
+}
+
+func (sc *ShellController) GetRuntimeStatus() *BlockControllerRuntimeStatus {
+	var rtn BlockControllerRuntimeStatus
+	sc.WithLock(func() {
+		rtn = sc.getRuntimeStatus_nolock()
+	})
+	return &rtn
+}
+
+func (sc *ShellController) SendInput(inputUnion *BlockInputUnion) error {
+	var shellInputCh chan *BlockInputUnion
+	sc.WithLock(func() {
+		shellInputCh = sc.ShellInputCh
+	})
+	if shellInputCh == nil {
+		return fmt.Errorf("no shell input chan")
+	}
+	shellInputCh <- inputUnion
+	return nil
+}
+
+func (sc *ShellController) WithLock(f func()) {
+	sc.Lock.Lock()
+	defer sc.Lock.Unlock()
+	f()
+}
+
+type RunShellOpts struct {
+	TermSize waveobj.TermSize `json:"termsize,omitempty"`
+}
+
+// only call when holding the lock
+func (sc *ShellController) sendUpdate_nolock() {
+	rtStatus := sc.getRuntimeStatus_nolock()
+	log.Printf("sending blockcontroller update %#v\n", rtStatus)
+	wps.Broker.Publish(wps.WaveEvent{
+		Event: wps.Event_ControllerStatus,
+		Scopes: []string{
+			waveobj.MakeORef(waveobj.OType_Tab, sc.TabId).String(),
+			waveobj.MakeORef(waveobj.OType_Block, sc.BlockId).String(),
+		},
+		Data: rtStatus,
+	})
+}
+
+func (sc *ShellController) UpdateControllerAndSendUpdate(updateFn func() bool) {
+	var sendUpdate bool
+	sc.WithLock(func() {
+		sendUpdate = updateFn()
+	})
+	if sendUpdate {
+		rtStatus := sc.GetRuntimeStatus()
+		log.Printf("sending blockcontroller update %#v\n", rtStatus)
+		wps.Broker.Publish(wps.WaveEvent{
+			Event: wps.Event_ControllerStatus,
+			Scopes: []string{
+				waveobj.MakeORef(waveobj.OType_Tab, sc.TabId).String(),
+				waveobj.MakeORef(waveobj.OType_Block, sc.BlockId).String(),
+			},
+			Data: rtStatus,
+		})
+	}
+}
+
+func (sc *ShellController) resetTerminalState(logCtx context.Context) {
+	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
+	defer cancelFn()
+	wfile, statErr := filestore.WFS.Stat(ctx, sc.BlockId, wavebase.BlockFile_Term)
+	if statErr == fs.ErrNotExist || wfile.Size == 0 {
+		return
+	}
+	blocklogger.Debugf(logCtx, "[conndebug] resetTerminalState: resetting terminal state\n")
+	// controller type = "shell"
+	var buf bytes.Buffer
+	// buf.WriteString("\x1b[?1049l") // disable alternative buffer
+	buf.WriteString("\x1b[0m")     // reset attributes
+	buf.WriteString("\x1b[?25h")   // show cursor
+	buf.WriteString("\x1b[?1000l") // disable mouse tracking
+	buf.WriteString("\r\n\r\n")
+	err := HandleAppendBlockFile(sc.BlockId, wavebase.BlockFile_Term, buf.Bytes())
+	if err != nil {
+		log.Printf("error appending to blockfile (terminal reset): %v\n", err)
+	}
+}
+
+// [All the other existing private methods remain exactly the same - I'm not including them all here for brevity, but they would all be copied over with sc. replacing bc. throughout]
+
+func (sc *ShellController) DoRunShellCommand(logCtx context.Context, rc *RunShellOpts, blockMeta waveobj.MetaMapType) error {
+	blocklogger.Debugf(logCtx, "[conndebug] DoRunShellCommand\n")
+	shellProc, err := sc.setupAndStartShellProcess(logCtx, rc, blockMeta)
+	if err != nil {
+		return err
+	}
+	return sc.manageRunningShellProcess(shellProc, rc, blockMeta)
+}
+
+// [Continue with all other methods, replacing bc with sc throughout...]
+
+func (sc *ShellController) LockRunLock() bool {
+	rtn := sc.RunLock.CompareAndSwap(false, true)
+	if rtn {
+		log.Printf("block %q run() lock\n", sc.BlockId)
+	}
+	return rtn
+}
+
+func (sc *ShellController) UnlockRunLock() {
+	sc.RunLock.Store(false)
+	log.Printf("block %q run() unlock\n", sc.BlockId)
+}
+
+func (sc *ShellController) run(logCtx context.Context, bdata *waveobj.Block, blockMeta map[string]any, rtOpts *waveobj.RuntimeOpts, force bool) {
+	blocklogger.Debugf(logCtx, "[conndebug] ShellController.run() %q\n", sc.BlockId)
+	runningShellCommand := false
+	ok := sc.LockRunLock()
+	if !ok {
+		log.Printf("block %q is already executing run()\n", sc.BlockId)
+		return
+	}
+	defer func() {
+		if !runningShellCommand {
+			sc.UnlockRunLock()
+		}
+	}()
+	curStatus := sc.GetRuntimeStatus()
+	controllerName := bdata.Meta.GetString(waveobj.MetaKey_Controller, "")
+	if controllerName != BlockController_Shell && controllerName != BlockController_Cmd {
+		log.Printf("unknown controller %q\n", controllerName)
+		return
+	}
+	runOnce := getBoolFromMeta(blockMeta, waveobj.MetaKey_CmdRunOnce, false)
+	runOnStart := getBoolFromMeta(blockMeta, waveobj.MetaKey_CmdRunOnStart, true)
+	if ((runOnStart || runOnce) && curStatus.ShellProcStatus == Status_Init) || force {
+		if getBoolFromMeta(blockMeta, waveobj.MetaKey_CmdClearOnStart, false) {
+			err := HandleTruncateBlockFile(sc.BlockId)
+			if err != nil {
+				log.Printf("error truncating term blockfile: %v\n", err)
+			}
+		}
+		if runOnce {
+			ctx, cancelFn := context.WithTimeout(context.Background(), 2*time.Second)
+			defer cancelFn()
+			metaUpdate := map[string]any{
+				waveobj.MetaKey_CmdRunOnce:    false,
+				waveobj.MetaKey_CmdRunOnStart: false,
+			}
+			err := wstore.UpdateObjectMeta(ctx, waveobj.MakeORef(waveobj.OType_Block, sc.BlockId), metaUpdate, false)
+			if err != nil {
+				log.Printf("error updating block meta (in blockcontroller.run): %v\n", err)
+				return
+			}
+		}
+		runningShellCommand = true
+		go func() {
+			defer func() {
+				panichandler.PanicHandler("blockcontroller:run-shell-command", recover())
+			}()
+			defer sc.UnlockRunLock()
+			var termSize waveobj.TermSize
+			if rtOpts != nil {
+				termSize = rtOpts.TermSize
+			} else {
+				termSize = getTermSize(bdata)
+			}
+			err := sc.DoRunShellCommand(logCtx, &RunShellOpts{TermSize: termSize}, bdata.Meta)
+			if err != nil {
+				debugLog(logCtx, "error running shell: %v\n", err)
+			}
+		}()
+	}
+}
+
+// [Include all the remaining private methods with bc replaced by sc]
+
+type ConnUnion struct {
+	ConnName   string
+	ConnType   string
+	SshConn    *conncontroller.SSHConn
+	WslConn    *wslconn.WslConn
+	WshEnabled bool
+	ShellPath  string
+	ShellOpts  []string
+	ShellType  string
+}
+
+func (bc *ShellController) getConnUnion(logCtx context.Context, remoteName string, blockMeta waveobj.MetaMapType) (ConnUnion, error) {
+	rtn := ConnUnion{ConnName: remoteName}
+	wshEnabled := !blockMeta.GetBool(waveobj.MetaKey_CmdNoWsh, false)
+	if strings.HasPrefix(remoteName, "wsl://") {
+		wslName := strings.TrimPrefix(remoteName, "wsl://")
+		wslConn := wslconn.GetWslConn(wslName)
+		if wslConn == nil {
+			return ConnUnion{}, fmt.Errorf("wsl connection not found: %s", remoteName)
+		}
+		connStatus := wslConn.DeriveConnStatus()
+		if connStatus.Status != conncontroller.Status_Connected {
+			return ConnUnion{}, fmt.Errorf("wsl connection %s not connected, cannot start shellproc", remoteName)
+		}
+		rtn.ConnType = ConnType_Wsl
+		rtn.WslConn = wslConn
+		rtn.WshEnabled = wshEnabled && wslConn.WshEnabled.Load()
+	} else if remoteName != "" {
+		opts, err := remote.ParseOpts(remoteName)
+		if err != nil {
+			return ConnUnion{}, fmt.Errorf("invalid ssh remote name (%s): %w", remoteName, err)
+		}
+		conn := conncontroller.GetConn(opts)
+		if conn == nil {
+			return ConnUnion{}, fmt.Errorf("ssh connection not found: %s", remoteName)
+		}
+		connStatus := conn.DeriveConnStatus()
+		if connStatus.Status != conncontroller.Status_Connected {
+			return ConnUnion{}, fmt.Errorf("ssh connection %s not connected, cannot start shellproc", remoteName)
+		}
+		rtn.ConnType = ConnType_Ssh
+		rtn.SshConn = conn
+		rtn.WshEnabled = wshEnabled && conn.WshEnabled.Load()
+	} else {
+		rtn.ConnType = ConnType_Local
+		rtn.WshEnabled = wshEnabled
+	}
+	err := rtn.getRemoteInfoAndShellType(blockMeta)
+	if err != nil {
+		return ConnUnion{}, err
+	}
+	return rtn, nil
+}
+
+func (bc *ShellController) setupAndStartShellProcess(logCtx context.Context, rc *RunShellOpts, blockMeta waveobj.MetaMapType) (*shellexec.ShellProc, error) {
+	// create a circular blockfile for the output
+	ctx, cancelFn := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancelFn()
+	fsErr := filestore.WFS.MakeFile(ctx, bc.BlockId, wavebase.BlockFile_Term, nil, wshrpc.FileOpts{MaxSize: DefaultTermMaxFileSize, Circular: true})
+	if fsErr != nil && fsErr != fs.ErrExist {
+		return nil, fmt.Errorf("error creating blockfile: %w", fsErr)
+	}
+	if fsErr == fs.ErrExist {
+		// reset the terminal state
+		bc.resetTerminalState(logCtx)
+	}
+	bcInitStatus := bc.GetRuntimeStatus()
+	if bcInitStatus.ShellProcStatus == Status_Running {
+		return nil, nil
+	}
+	// TODO better sync here (don't let two starts happen at the same times)
+	remoteName := blockMeta.GetString(waveobj.MetaKey_Connection, "")
+	connUnion, err := bc.getConnUnion(logCtx, remoteName, blockMeta)
+	if err != nil {
+		return nil, err
+	}
+	blocklogger.Infof(logCtx, "[conndebug] remoteName: %q, connType: %s, wshEnabled: %v, shell: %q, shellType: %s\n", remoteName, connUnion.ConnType, connUnion.WshEnabled, connUnion.ShellPath, connUnion.ShellType)
+	var cmdStr string
+	var cmdOpts shellexec.CommandOptsType
+	if bc.ControllerType == BlockController_Shell {
+		cmdOpts.Interactive = true
+		cmdOpts.Login = true
+		cmdOpts.Cwd = blockMeta.GetString(waveobj.MetaKey_CmdCwd, "")
+		if cmdOpts.Cwd != "" {
+			cwdPath, err := wavebase.ExpandHomeDir(cmdOpts.Cwd)
+			if err != nil {
+				return nil, err
+			}
+			cmdOpts.Cwd = cwdPath
+		}
+	} else if bc.ControllerType == BlockController_Cmd {
+		var cmdOptsPtr *shellexec.CommandOptsType
+		cmdStr, cmdOptsPtr, err = createCmdStrAndOpts(bc.BlockId, blockMeta, remoteName)
+		if err != nil {
+			return nil, err
+		}
+		cmdOpts = *cmdOptsPtr
+	} else {
+		return nil, fmt.Errorf("unknown controller type %q", bc.ControllerType)
+	}
+	var shellProc *shellexec.ShellProc
+	swapToken := bc.makeSwapToken(ctx, logCtx, blockMeta, remoteName, connUnion.ShellType)
+	cmdOpts.SwapToken = swapToken
+	blocklogger.Debugf(logCtx, "[conndebug] created swaptoken: %s\n", swapToken.Token)
+	if connUnion.ConnType == ConnType_Wsl {
+		wslConn := connUnion.WslConn
+		if !connUnion.WshEnabled {
+			shellProc, err = shellexec.StartWslShellProcNoWsh(ctx, rc.TermSize, cmdStr, cmdOpts, wslConn)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			sockName := wslConn.GetDomainSocketName()
+			rpcContext := wshrpc.RpcContext{TabId: bc.TabId, BlockId: bc.BlockId, Conn: wslConn.GetName()}
+			jwtStr, err := wshutil.MakeClientJWTToken(rpcContext, sockName)
+			if err != nil {
+				return nil, fmt.Errorf("error making jwt token: %w", err)
+			}
+			swapToken.SockName = sockName
+			swapToken.RpcContext = &rpcContext
+			swapToken.Env[wshutil.WaveJwtTokenVarName] = jwtStr
+			shellProc, err = shellexec.StartWslShellProc(ctx, rc.TermSize, cmdStr, cmdOpts, wslConn)
+			if err != nil {
+				wslConn.SetWshError(err)
+				wslConn.WshEnabled.Store(false)
+				blocklogger.Infof(logCtx, "[conndebug] error starting wsl shell proc with wsh: %v\n", err)
+				blocklogger.Infof(logCtx, "[conndebug] attempting install without wsh\n")
+				shellProc, err = shellexec.StartWslShellProcNoWsh(ctx, rc.TermSize, cmdStr, cmdOpts, wslConn)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	} else if connUnion.ConnType == ConnType_Ssh {
+		conn := connUnion.SshConn
+		if !connUnion.WshEnabled {
+			shellProc, err = shellexec.StartRemoteShellProcNoWsh(ctx, rc.TermSize, cmdStr, cmdOpts, conn)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			sockName := conn.GetDomainSocketName()
+			rpcContext := wshrpc.RpcContext{TabId: bc.TabId, BlockId: bc.BlockId, Conn: conn.Opts.String()}
+			jwtStr, err := wshutil.MakeClientJWTToken(rpcContext, sockName)
+			if err != nil {
+				return nil, fmt.Errorf("error making jwt token: %w", err)
+			}
+			swapToken.SockName = sockName
+			swapToken.RpcContext = &rpcContext
+			swapToken.Env[wshutil.WaveJwtTokenVarName] = jwtStr
+			shellProc, err = shellexec.StartRemoteShellProc(ctx, logCtx, rc.TermSize, cmdStr, cmdOpts, conn)
+			if err != nil {
+				conn.SetWshError(err)
+				conn.WshEnabled.Store(false)
+				blocklogger.Infof(logCtx, "[conndebug] error starting remote shell proc with wsh: %v\n", err)
+				blocklogger.Infof(logCtx, "[conndebug] attempting install without wsh\n")
+				shellProc, err = shellexec.StartRemoteShellProcNoWsh(ctx, rc.TermSize, cmdStr, cmdOpts, conn)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	} else if connUnion.ConnType == ConnType_Local {
+		if connUnion.WshEnabled {
+			sockName := wavebase.GetDomainSocketName()
+			rpcContext := wshrpc.RpcContext{TabId: bc.TabId, BlockId: bc.BlockId}
+			jwtStr, err := wshutil.MakeClientJWTToken(rpcContext, sockName)
+			if err != nil {
+				return nil, fmt.Errorf("error making jwt token: %w", err)
+			}
+			swapToken.SockName = sockName
+			swapToken.RpcContext = &rpcContext
+			swapToken.Env[wshutil.WaveJwtTokenVarName] = jwtStr
+		}
+		cmdOpts.ShellPath = connUnion.ShellPath
+		cmdOpts.ShellOpts = getLocalShellOpts(blockMeta)
+		shellProc, err = shellexec.StartLocalShellProc(logCtx, rc.TermSize, cmdStr, cmdOpts)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		return nil, fmt.Errorf("unknown connection type for conn %q: %s", remoteName, connUnion.ConnType)
+	}
+	bc.UpdateControllerAndSendUpdate(func() bool {
+		bc.ShellProc = shellProc
+		bc.ProcStatus = Status_Running
+		return true
+	})
+	return shellProc, nil
+}
+
+func (bc *ShellController) manageRunningShellProcess(shellProc *shellexec.ShellProc, rc *RunShellOpts, blockMeta waveobj.MetaMapType) error {
+	shellInputCh := make(chan *BlockInputUnion, 32)
+	bc.ShellInputCh = shellInputCh
+
+	// make esc sequence wshclient wshProxy
+	// we don't need to authenticate this wshProxy since it is coming direct
+	wshProxy := wshutil.MakeRpcProxy()
+	wshProxy.SetRpcContext(&wshrpc.RpcContext{TabId: bc.TabId, BlockId: bc.BlockId})
+	wshutil.DefaultRouter.RegisterRoute(wshutil.MakeControllerRouteId(bc.BlockId), wshProxy, true)
+	ptyBuffer := wshutil.MakePtyBuffer(wshutil.WaveOSCPrefix, shellProc.Cmd, wshProxy.FromRemoteCh)
+	go func() {
+		// handles regular output from the pty (goes to the blockfile and xterm)
+		defer func() {
+			panichandler.PanicHandler("blockcontroller:shellproc-pty-read-loop", recover())
+		}()
+		defer func() {
+			log.Printf("[shellproc] pty-read loop done\n")
+			shellProc.Close()
+			bc.WithLock(func() {
+				// so no other events are sent
+				bc.ShellInputCh = nil
+			})
+			shellProc.Cmd.Wait()
+			exitCode := shellProc.Cmd.ExitCode()
+			blockData := bc.getBlockData_noErr()
+			if blockData != nil && blockData.Meta.GetString(waveobj.MetaKey_Controller, "") == BlockController_Cmd {
+				termMsg := fmt.Sprintf("\r\nprocess finished with exit code = %d\r\n\r\n", exitCode)
+				HandleAppendBlockFile(bc.BlockId, wavebase.BlockFile_Term, []byte(termMsg))
+			}
+			// to stop the inputCh loop
+			time.Sleep(100 * time.Millisecond)
+			close(shellInputCh) // don't use bc.ShellInputCh (it's nil)
+		}()
+		buf := make([]byte, 4096)
+		for {
+			nr, err := ptyBuffer.Read(buf)
+			if nr > 0 {
+				err := HandleAppendBlockFile(bc.BlockId, wavebase.BlockFile_Term, buf[:nr])
+				if err != nil {
+					log.Printf("error appending to blockfile: %v\n", err)
+				}
+			}
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				log.Printf("error reading from shell: %v\n", err)
+				break
+			}
+		}
+	}()
+	go func() {
+		// handles input from the shellInputCh, sent to pty
+		// use shellInputCh instead of bc.ShellInputCh (because we want to be attached to *this* ch.  bc.ShellInputCh can be updated)
+		defer func() {
+			panichandler.PanicHandler("blockcontroller:shellproc-input-loop", recover())
+		}()
+		for ic := range shellInputCh {
+			if len(ic.InputData) > 0 {
+				shellProc.Cmd.Write(ic.InputData)
+			}
+			if ic.TermSize != nil {
+				updateTermSize(shellProc, bc.BlockId, *ic.TermSize)
+			}
+		}
+	}()
+	go func() {
+		defer func() {
+			panichandler.PanicHandler("blockcontroller:shellproc-output-loop", recover())
+		}()
+		// handles outputCh -> shellInputCh
+		for msg := range wshProxy.ToRemoteCh {
+			encodedMsg, err := wshutil.EncodeWaveOSCBytes(wshutil.WaveServerOSC, msg)
+			if err != nil {
+				log.Printf("error encoding OSC message: %v\n", err)
+			}
+			shellInputCh <- &BlockInputUnion{InputData: encodedMsg}
+		}
+	}()
+	go func() {
+		defer func() {
+			panichandler.PanicHandler("blockcontroller:shellproc-wait-loop", recover())
+		}()
+		// wait for the shell to finish
+		var exitCode int
+		defer func() {
+			wshutil.DefaultRouter.UnregisterRoute(wshutil.MakeControllerRouteId(bc.BlockId))
+			bc.UpdateControllerAndSendUpdate(func() bool {
+				if bc.ProcStatus == Status_Running {
+					bc.ProcStatus = Status_Done
+				}
+				bc.ProcExitCode = exitCode
+				return true
+			})
+			log.Printf("[shellproc] shell process wait loop done\n")
+		}()
+		waitErr := shellProc.Cmd.Wait()
+		exitCode = shellProc.Cmd.ExitCode()
+		shellProc.SetWaitErrorAndSignalDone(waitErr)
+		go checkCloseOnExit(bc.BlockId, exitCode)
+	}()
+	return nil
+}
+
+func (union *ConnUnion) getRemoteInfoAndShellType(blockMeta waveobj.MetaMapType) error {
+	if !union.WshEnabled {
+		return nil
+	}
+	if union.ConnType == ConnType_Ssh || union.ConnType == ConnType_Wsl {
+		connRoute := wshutil.MakeConnectionRouteId(union.ConnName)
+		remoteInfo, err := wshclient.RemoteGetInfoCommand(wshclient.GetBareRpcClient(), &wshrpc.RpcOpts{Route: connRoute, Timeout: 2000})
+		if err != nil {
+			// weird error, could flip the wshEnabled flag and allow it to go forward, but the connection should have already been vetted
+			return fmt.Errorf("unable to obtain remote info from connserver: %w", err)
+		}
+		// TODO allow overriding remote shell path
+		union.ShellPath = remoteInfo.Shell
+	} else {
+		union.ShellPath = getLocalShellPath(blockMeta)
+	}
+	union.ShellType = shellutil.GetShellTypeFromShellPath(union.ShellPath)
+	return nil
+}
+
+func checkCloseOnExit(blockId string, exitCode int) {
+	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
+	defer cancelFn()
+	blockData, err := wstore.DBMustGet[*waveobj.Block](ctx, blockId)
+	if err != nil {
+		log.Printf("error getting block data: %v\n", err)
+		return
+	}
+	closeOnExit := blockData.Meta.GetBool(waveobj.MetaKey_CmdCloseOnExit, false)
+	closeOnExitForce := blockData.Meta.GetBool(waveobj.MetaKey_CmdCloseOnExitForce, false)
+	if !closeOnExitForce && !(closeOnExit && exitCode == 0) {
+		return
+	}
+	delayMs := blockData.Meta.GetFloat(waveobj.MetaKey_CmdCloseOnExitDelay, 2000)
+	if delayMs < 0 {
+		delayMs = 0
+	}
+	time.Sleep(time.Duration(delayMs) * time.Millisecond)
+	rpcClient := wshclient.GetBareRpcClient()
+	err = wshclient.DeleteBlockCommand(rpcClient, wshrpc.CommandDeleteBlockData{BlockId: blockId}, nil)
+	if err != nil {
+		log.Printf("error deleting block data (close on exit): %v\n", err)
+	}
+}
+
+func getLocalShellPath(blockMeta waveobj.MetaMapType) string {
+	shellPath := blockMeta.GetString(waveobj.MetaKey_TermLocalShellPath, "")
+	if shellPath != "" {
+		return shellPath
+	}
+	settings := wconfig.GetWatcher().GetFullConfig().Settings
+	if settings.TermLocalShellPath != "" {
+		return settings.TermLocalShellPath
+	}
+	return shellutil.DetectLocalShellPath()
+}
+
+func getLocalShellOpts(blockMeta waveobj.MetaMapType) []string {
+	if blockMeta.HasKey(waveobj.MetaKey_TermLocalShellOpts) {
+		opts := blockMeta.GetStringList(waveobj.MetaKey_TermLocalShellOpts)
+		return append([]string{}, opts...)
+	}
+	settings := wconfig.GetWatcher().GetFullConfig().Settings
+	if len(settings.TermLocalShellOpts) > 0 {
+		return append([]string{}, settings.TermLocalShellOpts...)
+	}
+	return nil
+}
+
+// for "cmd" type blocks
+func createCmdStrAndOpts(blockId string, blockMeta waveobj.MetaMapType, connName string) (string, *shellexec.CommandOptsType, error) {
+	var cmdStr string
+	var cmdOpts shellexec.CommandOptsType
+	cmdStr = blockMeta.GetString(waveobj.MetaKey_Cmd, "")
+	if cmdStr == "" {
+		return "", nil, fmt.Errorf("missing cmd in block meta")
+	}
+	cmdOpts.Cwd = blockMeta.GetString(waveobj.MetaKey_CmdCwd, "")
+	if cmdOpts.Cwd != "" {
+		cwdPath, err := wavebase.ExpandHomeDir(cmdOpts.Cwd)
+		if err != nil {
+			return "", nil, err
+		}
+		cmdOpts.Cwd = cwdPath
+	}
+	useShell := blockMeta.GetBool(waveobj.MetaKey_CmdShell, true)
+	if !useShell {
+		if strings.Contains(cmdStr, " ") {
+			return "", nil, fmt.Errorf("cmd should not have spaces if cmd:shell is false (use cmd:args)")
+		}
+		cmdArgs := blockMeta.GetStringList(waveobj.MetaKey_CmdArgs)
+		// shell escape the args
+		for _, arg := range cmdArgs {
+			cmdStr = cmdStr + " " + utilfn.ShellQuote(arg, false, -1)
+		}
+	}
+	cmdOpts.ForceJwt = blockMeta.GetBool(waveobj.MetaKey_CmdJwt, false)
+	return cmdStr, &cmdOpts, nil
+}
+
+func (bc *ShellController) makeSwapToken(ctx context.Context, logCtx context.Context, blockMeta waveobj.MetaMapType, remoteName string, shellType string) *shellutil.TokenSwapEntry {
+	token := &shellutil.TokenSwapEntry{
+		Token: uuid.New().String(),
+		Env:   make(map[string]string),
+		Exp:   time.Now().Add(5 * time.Minute),
+	}
+	token.Env["TERM_PROGRAM"] = "waveterm"
+	token.Env["WAVETERM_BLOCKID"] = bc.BlockId
+	token.Env["WAVETERM_VERSION"] = wavebase.WaveVersion
+	token.Env["WAVETERM"] = "1"
+	tabId, err := wstore.DBFindTabForBlockId(ctx, bc.BlockId)
+	if err != nil {
+		log.Printf("error finding tab for block: %v\n", err)
+	} else {
+		token.Env["WAVETERM_TABID"] = tabId
+	}
+	if tabId != "" {
+		wsId, err := wstore.DBFindWorkspaceForTabId(ctx, tabId)
+		if err != nil {
+			log.Printf("error finding workspace for tab: %v\n", err)
+		} else {
+			token.Env["WAVETERM_WORKSPACEID"] = wsId
+		}
+	}
+	clientData, err := wstore.DBGetSingleton[*waveobj.Client](ctx)
+	if err != nil {
+		log.Printf("error getting client data: %v\n", err)
+	} else {
+		token.Env["WAVETERM_CLIENTID"] = clientData.OID
+	}
+	token.Env["WAVETERM_CONN"] = remoteName
+	envMap, err := resolveEnvMap(bc.BlockId, blockMeta, remoteName)
+	if err != nil {
+		log.Printf("error resolving env map: %v\n", err)
+	}
+	for k, v := range envMap {
+		token.Env[k] = v
+	}
+	token.ScriptText = getCustomInitScript(logCtx, blockMeta, remoteName, shellType)
+	return token
+}
+
+func (bc *ShellController) getBlockData_noErr() *waveobj.Block {
+	ctx, cancelFn := context.WithTimeout(context.Background(), DefaultTimeout)
+	defer cancelFn()
+	blockData, err := wstore.DBGet[*waveobj.Block](ctx, bc.BlockId)
+	if err != nil {
+		log.Printf("error getting block data (getBlockData_noErr): %v\n", err)
+		return nil
+	}
+	return blockData
+}
+
+func resolveEnvMap(blockId string, blockMeta waveobj.MetaMapType, connName string) (map[string]string, error) {
+	rtn := make(map[string]string)
+	config := wconfig.GetWatcher().GetFullConfig()
+	connKeywords := config.Connections[connName]
+	ckEnv := connKeywords.CmdEnv
+	for k, v := range ckEnv {
+		rtn[k] = v
+	}
+	ctx, cancelFn := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancelFn()
+	_, envFileData, err := filestore.WFS.ReadFile(ctx, blockId, wavebase.BlockFile_Env)
+	if err == fs.ErrNotExist {
+		err = nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("error reading command env file: %w", err)
+	}
+	if len(envFileData) > 0 {
+		envMap := envutil.EnvToMap(string(envFileData))
+		for k, v := range envMap {
+			rtn[k] = v
+		}
+	}
+	cmdEnv := blockMeta.GetStringMap(waveobj.MetaKey_CmdEnv, true)
+	for k, v := range cmdEnv {
+		if v == waveobj.MetaMap_DeleteSentinel {
+			delete(rtn, k)
+			continue
+		}
+		rtn[k] = v
+	}
+	connEnv := blockMeta.GetConnectionOverride(connName).GetStringMap(waveobj.MetaKey_CmdEnv, true)
+	for k, v := range connEnv {
+		if v == waveobj.MetaMap_DeleteSentinel {
+			delete(rtn, k)
+			continue
+		}
+		rtn[k] = v
+	}
+	return rtn, nil
+}
+
+func getCustomInitScriptKeyCascade(shellType string) []string {
+	if shellType == "bash" {
+		return []string{waveobj.MetaKey_CmdInitScriptBash, waveobj.MetaKey_CmdInitScriptSh, waveobj.MetaKey_CmdInitScript}
+	}
+	if shellType == "zsh" {
+		return []string{waveobj.MetaKey_CmdInitScriptZsh, waveobj.MetaKey_CmdInitScriptSh, waveobj.MetaKey_CmdInitScript}
+	}
+	if shellType == "pwsh" {
+		return []string{waveobj.MetaKey_CmdInitScriptPwsh, waveobj.MetaKey_CmdInitScript}
+	}
+	if shellType == "fish" {
+		return []string{waveobj.MetaKey_CmdInitScriptFish, waveobj.MetaKey_CmdInitScript}
+	}
+	return []string{waveobj.MetaKey_CmdInitScript}
+}
+
+func getCustomInitScript(logCtx context.Context, meta waveobj.MetaMapType, connName string, shellType string) string {
+	initScriptVal, metaKeyName := getCustomInitScriptValue(meta, connName, shellType)
+	if initScriptVal == "" {
+		return ""
+	}
+	if !fileutil.IsInitScriptPath(initScriptVal) {
+		blocklogger.Infof(logCtx, "[conndebug] inline initScript (size=%d) found in meta key: %s\n", len(initScriptVal), metaKeyName)
+		return initScriptVal
+	}
+	blocklogger.Infof(logCtx, "[conndebug] initScript detected as a file %q from meta key: %s\n", initScriptVal, metaKeyName)
+	initScriptVal, err := wavebase.ExpandHomeDir(initScriptVal)
+	if err != nil {
+		blocklogger.Infof(logCtx, "[conndebug] cannot expand home dir in Wave initscript file: %v\n", err)
+		return fmt.Sprintf("echo \"cannot expand home dir in Wave initscript file, from key %s\";\n", metaKeyName)
+	}
+	fileData, err := os.ReadFile(initScriptVal)
+	if err != nil {
+		blocklogger.Infof(logCtx, "[conndebug] cannot open Wave initscript file: %v\n", err)
+		return fmt.Sprintf("echo \"cannot open Wave initscript file, from key %s\";\n", metaKeyName)
+	}
+	if len(fileData) > MaxInitScriptSize {
+		blocklogger.Infof(logCtx, "[conndebug] initscript file too large, size=%d, max=%d\n", len(fileData), MaxInitScriptSize)
+		return fmt.Sprintf("echo \"initscript file too large, from key %s\";\n", metaKeyName)
+	}
+	if utilfn.HasBinaryData(fileData) {
+		blocklogger.Infof(logCtx, "[conndebug] initscript file contains binary data\n")
+		return fmt.Sprintf("echo \"initscript file contains binary data, from key %s\";\n", metaKeyName)
+	}
+	blocklogger.Infof(logCtx, "[conndebug] initscript file read successfully, size=%d\n", len(fileData))
+	return string(fileData)
+}
+
+// returns (value, metakey)
+func getCustomInitScriptValue(meta waveobj.MetaMapType, connName string, shellType string) (string, string) {
+	keys := getCustomInitScriptKeyCascade(shellType)
+	connMeta := meta.GetConnectionOverride(connName)
+	if connMeta != nil {
+		for _, key := range keys {
+			if connMeta.HasKey(key) {
+				return connMeta.GetString(key, ""), "blockmeta/[" + connName + "]/" + key
+			}
+		}
+	}
+	for _, key := range keys {
+		if meta.HasKey(key) {
+			return meta.GetString(key, ""), "blockmeta/" + key
+		}
+	}
+	fullConfig := wconfig.GetWatcher().GetFullConfig()
+	connKeywords := fullConfig.Connections[connName]
+	connKeywordsMap := make(map[string]any)
+	err := utilfn.ReUnmarshal(&connKeywordsMap, connKeywords)
+	if err != nil {
+		log.Printf("error re-unmarshalling connKeywords: %v\n", err)
+		return "", ""
+	}
+	ckMeta := waveobj.MetaMapType(connKeywordsMap)
+	for _, key := range keys {
+		if ckMeta.HasKey(key) {
+			return ckMeta.GetString(key, ""), "connections.json/" + connName + "/" + key
+		}
+	}
+	return "", ""
+}
+
+func updateTermSize(shellProc *shellexec.ShellProc, blockId string, termSize waveobj.TermSize) {
+	err := setTermSizeInDB(blockId, termSize)
+	if err != nil {
+		log.Printf("error setting pty size: %v\n", err)
+	}
+	err = shellProc.Cmd.SetSize(termSize.Rows, termSize.Cols)
+	if err != nil {
+		log.Printf("error setting pty size: %v\n", err)
+	}
+}
+
+func setTermSizeInDB(blockId string, termSize waveobj.TermSize) error {
+	ctx, cancelFn := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancelFn()
+	ctx = waveobj.ContextWithUpdates(ctx)
+	bdata, err := wstore.DBMustGet[*waveobj.Block](ctx, blockId)
+	if err != nil {
+		return fmt.Errorf("error getting block data: %v", err)
+	}
+	if bdata.RuntimeOpts == nil {
+		bdata.RuntimeOpts = &waveobj.RuntimeOpts{}
+	}
+	bdata.RuntimeOpts.TermSize = termSize
+	err = wstore.DBUpdate(ctx, bdata)
+	if err != nil {
+		return fmt.Errorf("error updating block data: %v", err)
+	}
+	updates := waveobj.ContextGetUpdatesRtn(ctx)
+	wps.Broker.SendUpdateEvents(updates)
+	return nil
+}
diff --git a/pkg/blockcontroller/tsunamicontroller.go b/pkg/blockcontroller/tsunamicontroller.go
new file mode 100644
index 0000000000..e487bb1cf8
--- /dev/null
+++ b/pkg/blockcontroller/tsunamicontroller.go
@@ -0,0 +1,459 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package blockcontroller
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"syscall"
+
+	"github.com/wavetermdev/waveterm/pkg/utilds"
+	"github.com/wavetermdev/waveterm/pkg/wavebase"
+	"github.com/wavetermdev/waveterm/pkg/waveobj"
+	"github.com/wavetermdev/waveterm/pkg/wps"
+	"github.com/wavetermdev/waveterm/tsunami/build"
+)
+
+type TsunamiAppProc struct {
+	Cmd          *exec.Cmd
+	StdoutBuffer *utilds.ReaderLineBuffer
+	StderrBuffer *utilds.ReaderLineBuffer // May be nil if stderr was consumed for port detection
+	StdinWriter  io.WriteCloser
+	Port         int           // Port the tsunami app is listening on
+	WaitCh       chan struct{} // Channel that gets closed when cmd.Wait() returns
+	WaitRtn      error         // Error returned by cmd.Wait()
+}
+
+type TsunamiController struct {
+	blockId       string
+	tabId         string
+	runLock       sync.Mutex
+	tsunamiProc   *TsunamiAppProc
+	statusLock    sync.Mutex
+	status        string
+	statusVersion int
+	exitCode      int
+	port          int
+}
+
+func getCachesDir() string {
+	var cacheDir string
+	appBundle := "waveterm"
+	if wavebase.IsDevMode() {
+		appBundle = "waveterm-dev"
+	}
+
+	switch runtime.GOOS {
+	case "darwin":
+		// macOS: ~/Library/Caches/<appbundle>
+		homeDir := wavebase.GetHomeDir()
+		cacheDir = filepath.Join(homeDir, "Library", "Caches", appBundle)
+	case "linux":
+		// Linux: XDG_CACHE_HOME or ~/.cache/<appbundle>
+		xdgCache := os.Getenv("XDG_CACHE_HOME")
+		if xdgCache != "" {
+			cacheDir = filepath.Join(xdgCache, appBundle)
+		} else {
+			homeDir := wavebase.GetHomeDir()
+			cacheDir = filepath.Join(homeDir, ".cache", appBundle)
+		}
+	case "windows":
+		localAppData := os.Getenv("LOCALAPPDATA")
+		if localAppData != "" {
+			cacheDir = filepath.Join(localAppData, appBundle, "Cache")
+		}
+	}
+
+	if cacheDir == "" {
+		tmpDir := os.TempDir()
+		cacheDir = filepath.Join(tmpDir, appBundle)
+	}
+
+	return cacheDir
+}
+
+func getTsunamiAppCachePath(scope string, appName string, osArch string) (string, error) {
+	cachesDir := getCachesDir()
+	tsunamiCacheDir := filepath.Join(cachesDir, "tsunami-build-cache")
+	fullAppName := appName + "." + osArch
+	if strings.HasPrefix(osArch, "windows") {
+		fullAppName = fullAppName + ".exe"
+	}
+	fullPath := filepath.Join(tsunamiCacheDir, scope, fullAppName)
+
+	// Create the directory if it doesn't exist
+	dirPath := filepath.Dir(fullPath)
+	err := wavebase.TryMkdirs(dirPath, 0755, "tsunami cache directory")
+	if err != nil {
+		return "", fmt.Errorf("failed to create tsunami cache directory: %w", err)
+	}
+
+	return fullPath, nil
+}
+
+func isBuildCacheUpToDate(appPath string) (bool, error) {
+	appName := build.GetAppName(appPath)
+
+	osArch := runtime.GOOS + "-" + runtime.GOARCH
+
+	cachePath, err := getTsunamiAppCachePath("local", appName, osArch)
+	if err != nil {
+		return false, err
+	}
+
+	cacheInfo, err := os.Stat(cachePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err
+	}
+
+	appModTime, err := build.GetAppModTime(appPath)
+	if err != nil {
+		return false, err
+	}
+
+	cacheModTime := cacheInfo.ModTime()
+	return !cacheModTime.Before(appModTime), nil
+}
+
+func (c *TsunamiController) Start(ctx context.Context, blockMeta waveobj.MetaMapType, rtOpts *waveobj.RuntimeOpts, force bool) error {
+	log.Printf("TsunamiController.Start called for block %s", c.blockId)
+	c.runLock.Lock()
+	defer c.runLock.Unlock()
+
+	scaffoldPath := blockMeta.GetString(waveobj.MetaKey_TsunamiScaffoldPath, "")
+	if scaffoldPath == "" {
+		return fmt.Errorf("tsunami:scaffoldpath is required")
+	}
+	scaffoldPath, err := wavebase.ExpandHomeDir(scaffoldPath)
+	if err != nil {
+		return fmt.Errorf("tsunami:scaffoldpath invalid: %w", err)
+	}
+	if !filepath.IsAbs(scaffoldPath) {
+		return fmt.Errorf("tsunami:scaffoldpath must be absolute: %s", scaffoldPath)
+	}
+
+	sdkReplacePath := blockMeta.GetString(waveobj.MetaKey_TsunamiSdkReplacePath, "")
+	if sdkReplacePath == "" {
+		return fmt.Errorf("tsunami:sdkreplacepath is required")
+	}
+	sdkReplacePath, err = wavebase.ExpandHomeDir(sdkReplacePath)
+	if err != nil {
+		return fmt.Errorf("tsunami:sdkreplacepath invalid: %w", err)
+	}
+	if !filepath.IsAbs(sdkReplacePath) {
+		return fmt.Errorf("tsunami:sdkreplacepath must be absolute: %s", sdkReplacePath)
+	}
+
+	appPath := blockMeta.GetString(waveobj.MetaKey_TsunamiAppPath, "")
+	if appPath == "" {
+		return fmt.Errorf("tsunami:apppath is required")
+	}
+	appPath, err = wavebase.ExpandHomeDir(appPath)
+	if err != nil {
+		return fmt.Errorf("tsunami:apppath invalid: %w", err)
+	}
+	if !filepath.IsAbs(appPath) {
+		return fmt.Errorf("tsunami:apppath must be absolute: %s", appPath)
+	}
+
+	appName := build.GetAppName(appPath)
+	osArch := runtime.GOOS + "-" + runtime.GOARCH
+
+	cachePath, err := getTsunamiAppCachePath("local", appName, osArch)
+	if err != nil {
+		return fmt.Errorf("failed to get cache path: %w", err)
+	}
+
+	upToDate, err := isBuildCacheUpToDate(appPath)
+	if err != nil {
+		return fmt.Errorf("failed to check build cache: %w", err)
+	}
+
+	if !upToDate || force {
+		nodePath := wavebase.GetWaveAppElectronExecPath()
+		if nodePath == "" {
+			return fmt.Errorf("electron executable path not set")
+		}
+
+		opts := build.BuildOpts{
+			AppPath:        appPath,
+			Verbose:        true,
+			Open:           false,
+			KeepTemp:       false,
+			OutputFile:     cachePath,
+			ScaffoldPath:   scaffoldPath,
+			SdkReplacePath: sdkReplacePath,
+			NodePath:       nodePath,
+		}
+
+		err = build.TsunamiBuild(opts)
+		if err != nil {
+			log.Printf("TsunamiController build error for block %s: %v", c.blockId, err)
+			return fmt.Errorf("failed to build tsunami app: %w", err)
+		}
+	}
+
+	info, err := os.Stat(cachePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("app cache does not exist: %s", cachePath)
+		}
+		return fmt.Errorf("failed to stat app cache: %w", err)
+	}
+
+	if runtime.GOOS != "windows" && info.Mode()&0111 == 0 {
+		return fmt.Errorf("app cache is not executable: %s", cachePath)
+	}
+
+	tsunamiProc, err := runTsunamiAppBinary(ctx, cachePath, appPath)
+	if err != nil {
+		return fmt.Errorf("failed to run tsunami app: %w", err)
+	}
+
+	c.tsunamiProc = tsunamiProc
+	c.WithStatusLock(func() {
+		c.status = Status_Running
+		c.port = tsunamiProc.Port
+	})
+	go c.sendStatusUpdate()
+
+	// Monitor process completion
+	go func() {
+		<-tsunamiProc.WaitCh
+		c.runLock.Lock()
+		if c.tsunamiProc == tsunamiProc {
+			c.tsunamiProc = nil
+			c.WithStatusLock(func() {
+				c.status = Status_Done
+				c.port = 0
+				c.exitCode = exitCodeFromWaitErr(tsunamiProc.WaitRtn)
+			})
+			go c.sendStatusUpdate()
+		}
+		c.runLock.Unlock()
+	}()
+
+	return nil
+}
+
+func (c *TsunamiController) Stop(graceful bool, newStatus string) error {
+	log.Printf("TsunamiController.Stop called for block %s (graceful: %t, newStatus: %s)", c.blockId, graceful, newStatus)
+	c.runLock.Lock()
+	defer c.runLock.Unlock()
+
+	if c.tsunamiProc == nil {
+		return nil
+	}
+
+	if c.tsunamiProc.Cmd.Process != nil {
+		c.tsunamiProc.Cmd.Process.Kill()
+	}
+
+	if c.tsunamiProc.StdinWriter != nil {
+		c.tsunamiProc.StdinWriter.Close()
+	}
+
+	c.tsunamiProc = nil
+	if newStatus == "" {
+		newStatus = Status_Done
+	}
+	c.WithStatusLock(func() {
+		c.status = newStatus
+		c.port = 0
+	})
+	go c.sendStatusUpdate()
+	return nil
+}
+
+func (c *TsunamiController) GetRuntimeStatus() *BlockControllerRuntimeStatus {
+	var rtn *BlockControllerRuntimeStatus
+	c.WithStatusLock(func() {
+		c.statusVersion++
+		rtn = &BlockControllerRuntimeStatus{
+			BlockId:           c.blockId,
+			Version:           c.statusVersion,
+			ShellProcStatus:   c.status,
+			ShellProcExitCode: c.exitCode,
+		}
+
+		if c.status == Status_Running && c.port > 0 {
+			rtn.TsunamiPort = c.port
+		}
+	})
+
+	return rtn
+}
+
+func (c *TsunamiController) SendInput(input *BlockInputUnion) error {
+	return fmt.Errorf("tsunami controller send input not implemented")
+}
+
+func runTsunamiAppBinary(ctx context.Context, appBinPath string, appPath string) (*TsunamiAppProc, error) {
+	cmd := exec.Command(appBinPath)
+	cmd.Env = append(os.Environ(), "TSUNAMI_CLOSEONSTDIN=1")
+
+	stdoutPipe, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create stdout pipe: %w", err)
+	}
+
+	stderrPipe, err := cmd.StderrPipe()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create stderr pipe: %w", err)
+	}
+
+	stdinPipe, err := cmd.StdinPipe()
+	if err != nil {
+		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 {
+		return nil, fmt.Errorf("failed to start tsunami app: %w", err)
+	}
+
+	// Create wait channel and tsunami proc first
+	waitCh := make(chan struct{})
+	tsunamiProc := &TsunamiAppProc{
+		Cmd:          cmd,
+		StdoutBuffer: stdoutBuffer,
+		StderrBuffer: stderrBuffer,
+		StdinWriter:  stdinPipe,
+		WaitCh:       waitCh,
+	}
+
+	// Start goroutine to handle cmd.Wait()
+	go func() {
+		tsunamiProc.WaitRtn = cmd.Wait()
+		log.Printf("WAIT RETURN: %v\n", tsunamiProc.WaitRtn)
+		if err := tsunamiProc.WaitRtn; err != nil {
+			if ee, ok := err.(*exec.ExitError); ok {
+				if ws, ok := ee.ProcessState.Sys().(syscall.WaitStatus); ok {
+					if ws.Signaled() {
+						sig := ws.Signal()
+						log.Printf("tsunami proc killed by signal: %s (%d)", sig, int(sig))
+					} else {
+						log.Printf("tsunami proc exited with code %d", ee.ExitCode())
+					}
+				}
+			} else {
+				log.Printf("tsunami proc error: %v", err)
+			}
+		}
+
+		close(waitCh)
+	}()
+
+	go stdoutBuffer.ReadAll()
+
+	// Monitor stderr for port information
+	portChan := make(chan int, 1)
+	errChan := make(chan error, 1)
+
+	go func() {
+		for {
+			line, err := stderrBuffer.ReadLine()
+			if err != nil {
+				errChan <- fmt.Errorf("stderr buffer error: %w", err)
+				return
+			}
+
+			port := build.ParseTsunamiPort(line)
+			if port > 0 {
+				portChan <- port
+				return
+			}
+		}
+	}()
+
+	// Wait for either port detection, process death, or context timeout
+	go func() {
+		<-tsunamiProc.WaitCh
+		select {
+		case <-portChan:
+			// Port already found, nothing to do
+		default:
+			errChan <- fmt.Errorf("tsunami process died before emitting listening message")
+		}
+	}()
+
+	select {
+	case port := <-portChan:
+		// Start the stderr ReadAll goroutine now that we have the port
+		go stderrBuffer.ReadAll()
+
+		tsunamiProc.Port = port
+		return tsunamiProc, nil
+	case err := <-errChan:
+		cmd.Process.Kill()
+		return nil, err
+	case <-ctx.Done():
+		cmd.Process.Kill()
+		return nil, fmt.Errorf("timeout waiting for tsunami port: %w", ctx.Err())
+	}
+}
+
+func MakeTsunamiController(tabId string, blockId string) Controller {
+	log.Printf("make tsunami controller: %s %s\n", tabId, blockId)
+	return &TsunamiController{
+		blockId: blockId,
+		tabId:   tabId,
+		status:  Status_Init,
+	}
+}
+
+// requires the lock (so do not call while holding statusLock)
+func (c *TsunamiController) sendStatusUpdate() {
+	rtStatus := c.GetRuntimeStatus()
+	log.Printf("sending blockcontroller update %#v\n", rtStatus)
+	wps.Broker.Publish(wps.WaveEvent{
+		Event: wps.Event_ControllerStatus,
+		Scopes: []string{
+			waveobj.MakeORef(waveobj.OType_Tab, c.tabId).String(),
+			waveobj.MakeORef(waveobj.OType_Block, c.blockId).String(),
+		},
+		Data: rtStatus,
+	})
+}
+
+func (c *TsunamiController) WithStatusLock(fn func()) {
+	c.statusLock.Lock()
+	defer c.statusLock.Unlock()
+	fn()
+}
+
+func exitCodeFromWaitErr(waitErr error) int {
+	if waitErr != nil {
+		if exitError, ok := waitErr.(*exec.ExitError); ok {
+			return exitError.ExitCode()
+		} else {
+			return 1
+		}
+	} else {
+		return 0
+	}
+}
diff --git a/pkg/service/blockservice/blockservice.go b/pkg/service/blockservice/blockservice.go
index 22caff961b..68d8bc9980 100644
--- a/pkg/service/blockservice/blockservice.go
+++ b/pkg/service/blockservice/blockservice.go
@@ -31,11 +31,7 @@ func (bs *BlockService) SendCommand_Meta() tsgenmeta.MethodMeta {
 }
 
 func (bs *BlockService) GetControllerStatus(ctx context.Context, blockId string) (*blockcontroller.BlockControllerRuntimeStatus, error) {
-	bc := blockcontroller.GetBlockController(blockId)
-	if bc == nil {
-		return nil, nil
-	}
-	return bc.GetRuntimeStatus(), nil
+	return blockcontroller.GetBlockControllerRuntimeStatus(blockId), nil
 }
 
 func (*BlockService) SaveTerminalState_Meta() tsgenmeta.MethodMeta {
diff --git a/pkg/utilds/readerlinebuffer.go b/pkg/utilds/readerlinebuffer.go
new file mode 100644
index 0000000000..bb4bce44e8
--- /dev/null
+++ b/pkg/utilds/readerlinebuffer.go
@@ -0,0 +1,122 @@
+package utilds
+
+import (
+	"bufio"
+	"io"
+	"sync"
+)
+
+type ReaderLineBuffer struct {
+	lock           sync.Mutex
+	lines          []string
+	maxLines       int
+	totalLineCount int
+	reader         io.Reader
+	scanner        *bufio.Scanner
+	done           bool
+	lineCallback   func(string)
+}
+
+func MakeReaderLineBuffer(reader io.Reader, maxLines int) *ReaderLineBuffer {
+	if maxLines <= 0 {
+		maxLines = 1000 // default max lines
+	}
+
+	rlb := &ReaderLineBuffer{
+		lines:          make([]string, 0, maxLines),
+		maxLines:       maxLines,
+		totalLineCount: 0,
+		reader:         reader,
+		scanner:        bufio.NewScanner(reader),
+		done:           false,
+	}
+
+	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()
+	return rlb.done
+}
+
+func (rlb *ReaderLineBuffer) setDone() {
+	rlb.lock.Lock()
+	defer rlb.lock.Unlock()
+	rlb.done = true
+}
+
+func (rlb *ReaderLineBuffer) ReadLine() (string, error) {
+	if rlb.IsDone() {
+		return "", io.EOF
+	}
+
+	if rlb.scanner.Scan() {
+		line := rlb.scanner.Text()
+		rlb.addLine(line)
+		return line, nil
+	}
+
+	// Check for scanner error
+	if err := rlb.scanner.Err(); err != nil {
+		rlb.setDone()
+		return "", err
+	}
+
+	rlb.setDone()
+	return "", io.EOF
+}
+
+func (rlb *ReaderLineBuffer) addLine(line string) {
+	rlb.lock.Lock()
+	defer rlb.lock.Unlock()
+
+	rlb.totalLineCount++
+
+	if len(rlb.lines) >= rlb.maxLines {
+		rlb.lines = append(rlb.lines[1:], line)
+	} else {
+		rlb.lines = append(rlb.lines, line)
+	}
+}
+
+func (rlb *ReaderLineBuffer) GetLines() []string {
+	rlb.lock.Lock()
+	defer rlb.lock.Unlock()
+
+	result := make([]string, len(rlb.lines))
+	copy(result, rlb.lines)
+	return result
+}
+
+func (rlb *ReaderLineBuffer) GetLineCount() int {
+	rlb.lock.Lock()
+	defer rlb.lock.Unlock()
+
+	return len(rlb.lines)
+}
+
+func (rlb *ReaderLineBuffer) GetTotalLineCount() int {
+	rlb.lock.Lock()
+	defer rlb.lock.Unlock()
+
+	return rlb.totalLineCount
+}
+
+func (rlb *ReaderLineBuffer) ReadAll() {
+	for {
+		line, err := rlb.ReadLine()
+		if err != nil {
+			break
+		}
+		if rlb.lineCallback != nil {
+			rlb.lineCallback(line)
+		}
+	}
+}
diff --git a/pkg/wavebase/wavebase.go b/pkg/wavebase/wavebase.go
index 351426060c..1757429956 100644
--- a/pkg/wavebase/wavebase.go
+++ b/pkg/wavebase/wavebase.go
@@ -26,12 +26,13 @@ var WaveVersion = "0.0.0"
 var BuildTime = "0"
 
 const (
-	WaveConfigHomeEnvVar      = "WAVETERM_CONFIG_HOME"
-	WaveDataHomeEnvVar        = "WAVETERM_DATA_HOME"
-	WaveAppPathVarName        = "WAVETERM_APP_PATH"
-	WaveDevVarName            = "WAVETERM_DEV"
-	WaveDevViteVarName        = "WAVETERM_DEV_VITE"
-	WaveWshForceUpdateVarName = "WAVETERM_WSHFORCEUPDATE"
+	WaveConfigHomeEnvVar           = "WAVETERM_CONFIG_HOME"
+	WaveDataHomeEnvVar             = "WAVETERM_DATA_HOME"
+	WaveAppPathVarName             = "WAVETERM_APP_PATH"
+	WaveAppElectronExecPathVarName = "WAVETERM_ELECTRONEXECPATH"
+	WaveDevVarName                 = "WAVETERM_DEV"
+	WaveDevViteVarName             = "WAVETERM_DEV_VITE"
+	WaveWshForceUpdateVarName      = "WAVETERM_WSHFORCEUPDATE"
 
 	WaveJwtTokenVarName  = "WAVETERM_JWT"
 	WaveSwapTokenVarName = "WAVETERM_SWAPTOKEN"
@@ -46,10 +47,11 @@ const (
 
 const NeedJwtConst = "NEED-JWT"
 
-var ConfigHome_VarCache string // caches WAVETERM_CONFIG_HOME
-var DataHome_VarCache string   // caches WAVETERM_DATA_HOME
-var AppPath_VarCache string    // caches WAVETERM_APP_PATH
-var Dev_VarCache string        // caches WAVETERM_DEV
+var ConfigHome_VarCache string          // caches WAVETERM_CONFIG_HOME
+var DataHome_VarCache string            // caches WAVETERM_DATA_HOME
+var AppPath_VarCache string             // caches WAVETERM_APP_PATH
+var AppElectronExecPath_VarCache string // caches WAVETERM_ELECTRONEXECPATH
+var Dev_VarCache string                 // caches WAVETERM_DEV
 
 const WaveLockFile = "wave.lock"
 const DomainSocketBaseName = "wave.sock"
@@ -93,6 +95,8 @@ func CacheAndRemoveEnvVars() error {
 	os.Unsetenv(WaveDataHomeEnvVar)
 	AppPath_VarCache = os.Getenv(WaveAppPathVarName)
 	os.Unsetenv(WaveAppPathVarName)
+	AppElectronExecPath_VarCache = os.Getenv(WaveAppElectronExecPathVarName)
+	os.Unsetenv(WaveAppElectronExecPathVarName)
 	Dev_VarCache = os.Getenv(WaveDevVarName)
 	os.Unsetenv(WaveDevVarName)
 	os.Unsetenv(WaveDevViteVarName)
@@ -119,6 +123,10 @@ func GetWaveAppBinPath() string {
 	return filepath.Join(GetWaveAppPath(), AppPathBinDir)
 }
 
+func GetWaveAppElectronExecPath() string {
+	return AppElectronExecPath_VarCache
+}
+
 func GetHomeDir() string {
 	homeVar, err := os.UserHomeDir()
 	if err != nil {
diff --git a/pkg/waveobj/metaconsts.go b/pkg/waveobj/metaconsts.go
index 0f3eb8fc09..3cbbb3d44d 100644
--- a/pkg/waveobj/metaconsts.go
+++ b/pkg/waveobj/metaconsts.go
@@ -114,6 +114,11 @@ const (
 	MetaKey_MarkdownFontSize                 = "markdown:fontsize"
 	MetaKey_MarkdownFixedFontSize            = "markdown:fixedfontsize"
 
+	MetaKey_TsunamiClear                     = "tsunami:*"
+	MetaKey_TsunamiSdkReplacePath            = "tsunami:sdkreplacepath"
+	MetaKey_TsunamiAppPath                   = "tsunami:apppath"
+	MetaKey_TsunamiScaffoldPath              = "tsunami:scaffoldpath"
+
 	MetaKey_VDomClear                        = "vdom:*"
 	MetaKey_VDomInitialized                  = "vdom:initialized"
 	MetaKey_VDomCorrelationId                = "vdom:correlationid"
diff --git a/pkg/waveobj/wtypemeta.go b/pkg/waveobj/wtypemeta.go
index 6fffeb9b7a..ef3e18b566 100644
--- a/pkg/waveobj/wtypemeta.go
+++ b/pkg/waveobj/wtypemeta.go
@@ -117,6 +117,11 @@ type MetaTSType struct {
 	MarkdownFontSize      float64 `json:"markdown:fontsize,omitempty"`
 	MarkdownFixedFontSize float64 `json:"markdown:fixedfontsize,omitempty"`
 
+	TsunamiClear           bool   `json:"tsunami:*,omitempty"`
+	TsunamiSdkReplacePath  string `json:"tsunami:sdkreplacepath,omitempty"`
+	TsunamiAppPath         string `json:"tsunami:apppath,omitempty"`
+	TsunamiScaffoldPath    string `json:"tsunami:scaffoldpath,omitempty"`
+
 	VDomClear         bool   `json:"vdom:*,omitempty"`
 	VDomInitialized   bool   `json:"vdom:initialized,omitempty"`
 	VDomCorrelationId string `json:"vdom:correlationid,omitempty"`
diff --git a/pkg/wshrpc/wshserver/wshserver.go b/pkg/wshrpc/wshserver/wshserver.go
index 70029392bc..82740fc645 100644
--- a/pkg/wshrpc/wshserver/wshserver.go
+++ b/pkg/wshrpc/wshserver/wshserver.go
@@ -301,11 +301,7 @@ func (ws *WshServer) SetViewCommand(ctx context.Context, data wshrpc.CommandBloc
 }
 
 func (ws *WshServer) ControllerStopCommand(ctx context.Context, blockId string) error {
-	bc := blockcontroller.GetBlockController(blockId)
-	if bc == nil {
-		return nil
-	}
-	bc.StopShellProc(true)
+	blockcontroller.StopBlockController(blockId)
 	return nil
 }
 
@@ -316,10 +312,6 @@ func (ws *WshServer) ControllerResyncCommand(ctx context.Context, data wshrpc.Co
 }
 
 func (ws *WshServer) ControllerInputCommand(ctx context.Context, data wshrpc.CommandBlockInputData) error {
-	bc := blockcontroller.GetBlockController(data.BlockId)
-	if bc == nil {
-		return fmt.Errorf("block controller not found for block %q", data.BlockId)
-	}
 	inputUnion := &blockcontroller.BlockInputUnion{
 		SigName:  data.SigName,
 		TermSize: data.TermSize,
@@ -332,7 +324,7 @@ func (ws *WshServer) ControllerInputCommand(ctx context.Context, data wshrpc.Com
 		}
 		inputUnion.InputData = inputBuf[:nw]
 	}
-	return bc.SendInput(inputUnion)
+	return blockcontroller.SendInput(data.BlockId, inputUnion)
 }
 
 func (ws *WshServer) ControllerAppendOutputCommand(ctx context.Context, data wshrpc.CommandControllerAppendOutputData) error {
diff --git a/tsunami/.gitignore b/tsunami/.gitignore
index 6dd29b7f8d..9e2a40e004 100644
--- a/tsunami/.gitignore
+++ b/tsunami/.gitignore
@@ -1 +1,2 @@
-bin/
\ No newline at end of file
+bin/
+*.tsapp
\ No newline at end of file
diff --git a/tsunami/app/defaultclient.go b/tsunami/app/defaultclient.go
index 17dbfbe84f..ae46f9a081 100644
--- a/tsunami/app/defaultclient.go
+++ b/tsunami/app/defaultclient.go
@@ -5,13 +5,18 @@ package app
 
 import (
 	"encoding/json"
+	"io"
 	"io/fs"
+	"log"
 	"net/http"
+	"os"
 
 	"github.com/wavetermdev/waveterm/tsunami/engine"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
+const TsunamiCloseOnStdinEnvVar = "TSUNAMI_CLOSEONSTDIN"
+
 func DefineComponent[P any](name string, renderFn func(props P) any) vdom.Component[P] {
 	return engine.DefineComponentEx(engine.GetDefaultClient(), name, renderFn)
 }
@@ -88,6 +93,17 @@ func HandleDynFunc(pattern string, fn func(http.ResponseWriter, *http.Request))
 
 // RunMain is used internally by generated code and should not be called directly.
 func RunMain() {
+	closeOnStdin := os.Getenv(TsunamiCloseOnStdinEnvVar) != ""
+
+	if closeOnStdin {
+		go func() {
+			// Read stdin until EOF/close, then exit the process
+			io.Copy(io.Discard, os.Stdin)
+			log.Printf("[tsunami] shutting down due to close of stdin\n")
+			os.Exit(0)
+		}()
+	}
+
 	engine.GetDefaultClient().RunMain()
 }
 
diff --git a/tsunami/build/build.go b/tsunami/build/build.go
index 7ac516760e..dfdd0e28dc 100644
--- a/tsunami/build/build.go
+++ b/tsunami/build/build.go
@@ -1,12 +1,15 @@
 package build
 
 import (
+	"archive/zip"
 	"bufio"
 	"fmt"
 	"go/parser"
 	"go/token"
 	"io"
+	"io/fs"
 	"log"
+	"net/url"
 	"os"
 	"os/exec"
 	"os/signal"
@@ -27,13 +30,20 @@ const MinSupportedGoMinorVersion = 22
 const TsunamiUIImportPath = "github.com/wavetermdev/waveterm/tsunami/ui"
 
 type BuildOpts struct {
-	Dir            string
+	AppPath        string
 	Verbose        bool
 	Open           bool
 	KeepTemp       bool
 	OutputFile     string
 	ScaffoldPath   string
 	SdkReplacePath string
+	NodePath       string
+	MoveFileBack   bool
+}
+
+func GetAppName(appPath string) string {
+	baseName := filepath.Base(appPath)
+	return strings.TrimSuffix(baseName, ".tsapp")
 }
 
 type BuildEnv struct {
@@ -42,6 +52,13 @@ type BuildEnv struct {
 	cleanupOnce *sync.Once
 }
 
+func (opts BuildOpts) getNodePath() string {
+	if opts.NodePath != "" {
+		return opts.NodePath
+	}
+	return "node"
+}
+
 func findGoExecutable() (string, error) {
 	// First try the standard PATH lookup
 	if goPath, err := exec.LookPath("go"); err == nil {
@@ -50,7 +67,7 @@ func findGoExecutable() (string, error) {
 
 	// Define platform-specific paths to check
 	var pathsToCheck []string
-	
+
 	if runtime.GOOS == "windows" {
 		pathsToCheck = []string{
 			`c:\go\bin\go.exe`,
@@ -59,10 +76,10 @@ func findGoExecutable() (string, error) {
 	} else {
 		// Unix-like systems (macOS, Linux, etc.)
 		pathsToCheck = []string{
-			"/opt/homebrew/bin/go",     // Homebrew on Apple Silicon
-			"/usr/local/bin/go",        // Traditional Homebrew or manual install
-			"/usr/local/go/bin/go",     // Official Go installation
-			"/usr/bin/go",              // System package manager
+			"/opt/homebrew/bin/go", // Homebrew on Apple Silicon
+			"/usr/local/bin/go",    // Traditional Homebrew or manual install
+			"/usr/local/go/bin/go", // Official Go installation
+			"/usr/bin/go",          // System package manager
 		}
 	}
 
@@ -79,7 +96,7 @@ func findGoExecutable() (string, error) {
 	return "", fmt.Errorf("go command not found in PATH or common installation locations")
 }
 
-func verifyEnvironment(verbose bool) (*BuildEnv, error) {
+func verifyEnvironment(verbose bool, opts BuildOpts) (*BuildEnv, error) {
 	// Find Go executable using enhanced search
 	goPath, err := findGoExecutable()
 	if err != nil {
@@ -120,44 +137,40 @@ func verifyEnvironment(verbose bool) (*BuildEnv, error) {
 		return nil, fmt.Errorf("go version 1.%d or higher required, found: %s", MinSupportedGoMinorVersion, versionStr)
 	}
 
-	// Check if npx is in PATH
-	_, err = exec.LookPath("npx")
-	if err != nil {
-		return nil, fmt.Errorf("npx command not found in PATH: %w", err)
-	}
-
-	if verbose {
-		log.Printf("Found npx in PATH")
-	}
+	// Check if node is available
+	if opts.NodePath != "" {
+		// Custom node path specified - verify it's absolute and executable
+		if !filepath.IsAbs(opts.NodePath) {
+			return nil, fmt.Errorf("NodePath must be an absolute path, got: %s", opts.NodePath)
+		}
 
-	// Check Tailwind CSS version
-	tailwindCmd := exec.Command("npx", "@tailwindcss/cli")
-	tailwindOutput, err := tailwindCmd.CombinedOutput()
-	if err != nil {
-		return nil, fmt.Errorf("failed to run 'npx @tailwindcss/cli': %w", err)
-	}
+		info, err := os.Stat(opts.NodePath)
+		if err != nil {
+			return nil, fmt.Errorf("NodePath does not exist: %s: %w", opts.NodePath, err)
+		}
 
-	tailwindStr := strings.TrimSpace(string(tailwindOutput))
-	lines := strings.Split(tailwindStr, "\n")
-	if len(lines) == 0 {
-		return nil, fmt.Errorf("no output from tailwindcss command")
-	}
+		if info.IsDir() {
+			return nil, fmt.Errorf("NodePath is a directory, not an executable: %s", opts.NodePath)
+		}
 
-	firstLine := lines[0]
-	if verbose {
-		log.Printf("Found %s", firstLine)
-	}
+		// Check if file is executable (Unix-like systems)
+		if runtime.GOOS != "windows" && info.Mode()&0111 == 0 {
+			return nil, fmt.Errorf("NodePath is not executable: %s", opts.NodePath)
+		}
 
-	// Check for v4 (format: "≈ tailwindcss v4.1.12")
-	tailwindRegex := regexp.MustCompile(`tailwindcss v(\d+)`)
-	tailwindMatches := tailwindRegex.FindStringSubmatch(firstLine)
-	if len(tailwindMatches) < 2 {
-		return nil, fmt.Errorf("unable to parse tailwindcss version from: %s", firstLine)
-	}
+		if verbose {
+			log.Printf("Using custom node path: %s", opts.NodePath)
+		}
+	} else {
+		// Use standard PATH lookup
+		_, err = exec.LookPath("node")
+		if err != nil {
+			return nil, fmt.Errorf("node command not found in PATH: %w", err)
+		}
 
-	majorVersion, err := strconv.Atoi(tailwindMatches[1])
-	if err != nil || majorVersion != 4 {
-		return nil, fmt.Errorf("tailwindcss v4 required, found: %s", firstLine)
+		if verbose {
+			log.Printf("Found node in PATH")
+		}
 	}
 
 	return &BuildEnv{
@@ -166,42 +179,24 @@ func verifyEnvironment(verbose bool) (*BuildEnv, error) {
 	}, nil
 }
 
-func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose bool) error {
-	modulePath := fmt.Sprintf("tsunami/app/%s", appDirName)
+func createGoMod(tempDir, appName, goVersion string, opts BuildOpts, verbose bool) error {
+	modulePath := fmt.Sprintf("tsunami/app/%s", appName)
 
-	// Check if go.mod already exists in original directory
-	originalGoModPath := filepath.Join(opts.Dir, "go.mod")
+	// Check if go.mod already exists in temp directory (copied from app path)
+	tempGoModPath := filepath.Join(tempDir, "go.mod")
 	var modFile *modfile.File
 	var err error
 
-	if _, err := os.Stat(originalGoModPath); err == nil {
-		// go.mod exists, copy and parse it
+	if _, err := os.Stat(tempGoModPath); err == nil {
+		// go.mod exists in temp dir, parse it
 		if verbose {
-			log.Printf("Found existing go.mod, copying from %s", originalGoModPath)
-		}
-
-		// Copy existing go.mod to temp directory
-		tempGoModPath := filepath.Join(tempDir, "go.mod")
-		if err := copyFile(originalGoModPath, tempGoModPath); err != nil {
-			return fmt.Errorf("failed to copy existing go.mod: %w", err)
-		}
-
-		// Also copy go.sum if it exists
-		originalGoSumPath := filepath.Join(opts.Dir, "go.sum")
-		if _, err := os.Stat(originalGoSumPath); err == nil {
-			tempGoSumPath := filepath.Join(tempDir, "go.sum")
-			if err := copyFile(originalGoSumPath, tempGoSumPath); err != nil {
-				return fmt.Errorf("failed to copy existing go.sum: %w", err)
-			}
-			if verbose {
-				log.Printf("Found and copied existing go.sum from %s", originalGoSumPath)
-			}
+			log.Printf("Found existing go.mod in temp directory, parsing it")
 		}
 
 		// Parse the existing go.mod
 		goModContent, err := os.ReadFile(tempGoModPath)
 		if err != nil {
-			return fmt.Errorf("failed to read copied go.mod: %w", err)
+			return fmt.Errorf("failed to read go.mod: %w", err)
 		}
 
 		modFile, err = modfile.Parse("go.mod", goModContent, nil)
@@ -228,7 +223,7 @@ func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose
 			return fmt.Errorf("failed to add require directive: %w", err)
 		}
 	} else {
-		return fmt.Errorf("error checking for existing go.mod: %w", err)
+		return fmt.Errorf("error checking for go.mod in temp directory: %w", err)
 	}
 
 	// Add replace directive for tsunami SDK
@@ -275,99 +270,69 @@ func createGoMod(tempDir, appDirName, goVersion string, opts BuildOpts, verbose
 	return nil
 }
 
-func verifyTsunamiDir(dir string) error {
-	if dir == "" {
-		return fmt.Errorf("directory path cannot be empty")
-	}
-
-	// Check if directory exists
-	info, err := os.Stat(dir)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return fmt.Errorf("directory %q does not exist", dir)
-		}
-		return fmt.Errorf("error accessing directory %q: %w", dir, err)
-	}
-
-	if !info.IsDir() {
-		return fmt.Errorf("%q is not a directory", dir)
-	}
-
+func verifyAppPathFs(fsys fs.FS) error {
 	// Check for app.go file
-	appGoPath := filepath.Join(dir, "app.go")
-	if err := CheckFileExists(appGoPath); err != nil {
-		return fmt.Errorf("app.go check failed in directory %q: %w", dir, err)
+	if err := checkFileExistsFS(fsys, "app.go"); err != nil {
+		return fmt.Errorf("app.go check failed: %w", err)
 	}
 
 	// Check static directory if it exists
-	staticPath := filepath.Join(dir, "static")
-	if err := IsDirOrNotFound(staticPath); err != nil {
-		return fmt.Errorf("static directory check failed in %q: %w", dir, err)
-	}
-
-	// Check that dist doesn't exist
-	distPath := filepath.Join(dir, "dist")
-	if err := FileMustNotExist(distPath); err != nil {
-		return fmt.Errorf("dist check failed in %q: %w", dir, err)
+	if err := isDirOrNotFoundFS(fsys, "static"); err != nil {
+		return fmt.Errorf("static directory check failed: %w", err)
 	}
 
 	return nil
 }
 
-func verifyScaffoldPath(scaffoldPath string) error {
-	if scaffoldPath == "" {
-		return fmt.Errorf("scaffoldPath cannot be empty")
-	}
-
-	// Check if directory exists
-	info, err := os.Stat(scaffoldPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return fmt.Errorf("scaffoldPath directory %q does not exist", scaffoldPath)
+func GetAppModTime(appPath string) (time.Time, error) {
+	if strings.HasSuffix(appPath, ".tsapp") {
+		info, err := os.Stat(appPath)
+		if err != nil {
+			return time.Time{}, fmt.Errorf("failed to get tsapp mod time: %w", err)
 		}
-		return fmt.Errorf("error accessing scaffoldPath directory %q: %w", scaffoldPath, err)
+		return info.ModTime(), nil
 	}
 
-	if !info.IsDir() {
-		return fmt.Errorf("scaffoldPath %q is not a directory", scaffoldPath)
+	appGoPath := filepath.Join(appPath, "app.go")
+	info, err := os.Stat(appGoPath)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("failed to get app.go mod time: %w", err)
 	}
+	return info.ModTime(), nil
+}
 
+func verifyScaffoldFs(fsys fs.FS) error {
 	// Check for dist directory
-	distPath := filepath.Join(scaffoldPath, "dist")
-	if err := IsDirOrNotFound(distPath); err != nil {
-		return fmt.Errorf("dist directory check failed in scaffoldPath %q: %w", scaffoldPath, err)
+	if err := isDirOrNotFoundFS(fsys, "dist"); err != nil {
+		return fmt.Errorf("dist directory check failed: %w", err)
 	}
-	info, err = os.Stat(distPath)
+	info, err := fs.Stat(fsys, "dist")
 	if err != nil || !info.IsDir() {
-		return fmt.Errorf("dist directory must exist in scaffoldPath %q", scaffoldPath)
+		return fmt.Errorf("dist directory must exist in scaffold")
 	}
 
 	// Check for app-main.go file
-	appMainPath := filepath.Join(scaffoldPath, "app-main.go")
-	if err := CheckFileExists(appMainPath); err != nil {
-		return fmt.Errorf("app-main.go check failed in scaffoldPath %q: %w", scaffoldPath, err)
+	if err := checkFileExistsFS(fsys, "app-main.go"); err != nil {
+		return fmt.Errorf("app-main.go check failed: %w", err)
 	}
 
 	// Check for tailwind.css file
-	tailwindPath := filepath.Join(scaffoldPath, "tailwind.css")
-	if err := CheckFileExists(tailwindPath); err != nil {
-		return fmt.Errorf("tailwind.css check failed in scaffoldPath %q: %w", scaffoldPath, err)
+	if err := checkFileExistsFS(fsys, "tailwind.css"); err != nil {
+		return fmt.Errorf("tailwind.css check failed: %w", err)
 	}
 
 	// Check for package.json file
-	packageJsonPath := filepath.Join(scaffoldPath, "package.json")
-	if err := CheckFileExists(packageJsonPath); err != nil {
-		return fmt.Errorf("package.json check failed in scaffoldPath %q: %w", scaffoldPath, err)
+	if err := checkFileExistsFS(fsys, "package.json"); err != nil {
+		return fmt.Errorf("package.json check failed: %w", err)
 	}
 
 	// Check for node_modules directory
-	nodeModulesPath := filepath.Join(scaffoldPath, "node_modules")
-	if err := IsDirOrNotFound(nodeModulesPath); err != nil {
-		return fmt.Errorf("node_modules directory check failed in scaffoldPath %q: %w", scaffoldPath, err)
+	if err := isDirOrNotFoundFS(fsys, "node_modules"); err != nil {
+		return fmt.Errorf("node_modules directory check failed: %w", err)
 	}
-	info, err = os.Stat(nodeModulesPath)
+	info, err = fs.Stat(fsys, "node_modules")
 	if err != nil || !info.IsDir() {
-		return fmt.Errorf("node_modules directory must exist in scaffoldPath %q", scaffoldPath)
+		return fmt.Errorf("node_modules directory must exist in scaffold")
 	}
 
 	return nil
@@ -434,7 +399,7 @@ func setupSignalCleanup(buildEnv *BuildEnv, keepTemp, verbose bool) {
 }
 
 func TsunamiBuild(opts BuildOpts) error {
-	buildEnv, err := tsunamiBuildInternal(opts)
+	buildEnv, err := TsunamiBuildInternal(opts)
 	defer buildEnv.cleanupTempDir(opts.KeepTemp, opts.Verbose)
 	if err != nil {
 		return err
@@ -443,17 +408,33 @@ func TsunamiBuild(opts BuildOpts) error {
 	return nil
 }
 
-func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
-	buildEnv, err := verifyEnvironment(opts.Verbose)
+func TsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
+	buildEnv, err := verifyEnvironment(opts.Verbose, opts)
 	if err != nil {
 		return nil, err
 	}
 
-	if err := verifyTsunamiDir(opts.Dir); err != nil {
-		return nil, err
+	appFS, canWrite, appCloser, err := pathToFS(opts.AppPath)
+	if err != nil {
+		return nil, fmt.Errorf("bad app path: %w", err)
+	}
+	if appCloser != nil {
+		defer appCloser()
+	}
+
+	if err := verifyAppPathFs(appFS); err != nil {
+		return nil, fmt.Errorf("bad app path: %w", err)
+	}
+
+	scaffoldFS, _, scaffoldCloser, err := pathToFS(opts.ScaffoldPath)
+	if err != nil {
+		return nil, fmt.Errorf("bad scaffold path: %w", err)
+	}
+	if scaffoldCloser != nil {
+		defer scaffoldCloser()
 	}
 
-	if err := verifyScaffoldPath(opts.ScaffoldPath); err != nil {
+	if err := verifyScaffoldFs(scaffoldFS); err != nil {
 		return nil, err
 	}
 
@@ -465,34 +446,27 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 
 	buildEnv.TempDir = tempDir
 
-	log.Printf("Building tsunami app from %s\n", opts.Dir)
+	log.Printf("Building tsunami app from %s\n", opts.AppPath)
 
-	if opts.Verbose {
+	if opts.Verbose || opts.KeepTemp {
 		log.Printf("Temp dir: %s\n", tempDir)
 	}
 
-	// Copy all *.go files from the root directory
-	goCount, err := copyGoFiles(opts.Dir, tempDir)
-	if err != nil {
-		return buildEnv, fmt.Errorf("failed to copy go files: %w", err)
-	}
-
-	// Copy static directory
-	staticSrcDir := filepath.Join(opts.Dir, "static")
-	staticDestDir := filepath.Join(tempDir, "static")
-	staticCount, err := copyDirRecursive(staticSrcDir, staticDestDir, true)
+	// Copy files from app path (go.mod, go.sum, static/, *.go)
+	copyStats, err := copyFilesFromAppFS(appFS, opts.AppPath, tempDir, opts.Verbose)
 	if err != nil {
-		return buildEnv, fmt.Errorf("failed to copy static directory: %w", err)
+		return buildEnv, fmt.Errorf("failed to copy files from app path: %w", err)
 	}
 
 	// Copy scaffold directory contents selectively
-	scaffoldCount, err := copyScaffoldSelective(opts.ScaffoldPath, tempDir)
+	scaffoldCount, err := copyScaffoldFS(scaffoldFS, tempDir, opts.Verbose)
 	if err != nil {
 		return buildEnv, fmt.Errorf("failed to copy scaffold directory: %w", err)
 	}
 
 	if opts.Verbose {
-		log.Printf("Copied %d go files, %d static files, %d scaffold files\n", goCount, staticCount, scaffoldCount)
+		log.Printf("Copied %d go files, %d static files, %d scaffold files (go.mod: %t, go.sum: %t)\n",
+			copyStats.GoFiles, copyStats.StaticFiles, scaffoldCount, copyStats.GoMod, copyStats.GoSum)
 	}
 
 	// Copy app-main.go from scaffold to main-app.go in temp dir
@@ -503,8 +477,8 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 	}
 
 	// Create go.mod file
-	appDirName := filepath.Base(opts.Dir)
-	if err := createGoMod(tempDir, appDirName, buildEnv.GoVersion, opts, opts.Verbose); err != nil {
+	appName := GetAppName(opts.AppPath)
+	if err := createGoMod(tempDir, appName, buildEnv.GoVersion, opts, opts.Verbose); err != nil {
 		return buildEnv, fmt.Errorf("failed to create go.mod: %w", err)
 	}
 
@@ -529,7 +503,7 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 	}
 
 	// Generate Tailwind CSS
-	if err := generateAppTailwindCss(tempDir, opts.Verbose); err != nil {
+	if err := generateAppTailwindCss(tempDir, opts.Verbose, opts); err != nil {
 		return buildEnv, fmt.Errorf("failed to generate tailwind css: %w", err)
 	}
 
@@ -539,8 +513,14 @@ func tsunamiBuildInternal(opts BuildOpts) (*BuildEnv, error) {
 	}
 
 	// Move generated files back to original directory
-	if err := moveFilesBack(tempDir, opts.Dir, opts.Verbose); err != nil {
-		return buildEnv, fmt.Errorf("failed to move files back: %w", err)
+	if opts.MoveFileBack && canWrite {
+		if err := moveFilesBack(tempDir, opts.AppPath, opts.Verbose); err != nil {
+			return buildEnv, fmt.Errorf("failed to move files back: %w", err)
+		}
+	} else if opts.MoveFileBack && !canWrite {
+		if opts.Verbose {
+			log.Printf("Skipping move files back - app path is not writable: %s", opts.AppPath)
+		}
 	}
 
 	return buildEnv, nil
@@ -643,14 +623,15 @@ func runGoBuild(tempDir string, opts BuildOpts) error {
 	return nil
 }
 
-func generateAppTailwindCss(tempDir string, verbose bool) error {
+func generateAppTailwindCss(tempDir string, verbose bool, opts BuildOpts) error {
 	// tailwind.css is already in tempDir from scaffold copy
 	tailwindOutput := filepath.Join(tempDir, "static", "tw.css")
 
-	tailwindCmd := exec.Command("npx", "@tailwindcss/cli",
+	tailwindCmd := exec.Command(opts.getNodePath(), "node_modules/@tailwindcss/cli/dist/index.mjs",
 		"-i", "./tailwind.css",
 		"-o", tailwindOutput)
 	tailwindCmd.Dir = tempDir
+	tailwindCmd.Env = append(os.Environ(), "ELECTRON_RUN_AS_NODE=1")
 
 	if verbose {
 		log.Printf("Running: %s", strings.Join(tailwindCmd.Args, " "))
@@ -667,8 +648,15 @@ func generateAppTailwindCss(tempDir string, verbose bool) error {
 	return nil
 }
 
-func copyGoFiles(srcDir, destDir string) (int, error) {
-	entries, err := os.ReadDir(srcDir)
+type CopyStats struct {
+	GoFiles     int
+	StaticFiles int
+	GoMod       bool
+	GoSum       bool
+}
+
+func copyGoFilesFromFS(fsys fs.FS, destDir string) (int, error) {
+	entries, err := fs.ReadDir(fsys, ".")
 	if err != nil {
 		return 0, err
 	}
@@ -680,10 +668,9 @@ func copyGoFiles(srcDir, destDir string) (int, error) {
 		}
 
 		if strings.HasSuffix(entry.Name(), ".go") {
-			srcPath := filepath.Join(srcDir, entry.Name())
 			destPath := filepath.Join(destDir, entry.Name())
 
-			if err := copyFile(srcPath, destPath); err != nil {
+			if err := CopyFileFromFS(fsys, entry.Name(), destPath); err != nil {
 				return 0, fmt.Errorf("failed to copy %s: %w", entry.Name(), err)
 			}
 			fileCount++
@@ -693,8 +680,62 @@ func copyGoFiles(srcDir, destDir string) (int, error) {
 	return fileCount, nil
 }
 
+// appPath is just used for logging (we do the copies from appFS)
+func copyFilesFromAppFS(appFS fs.FS, appPath, tempDir string, verbose bool) (*CopyStats, error) {
+	stats := &CopyStats{}
+
+	// Copy go.mod if it exists
+	goModDest := filepath.Join(tempDir, "go.mod")
+	copied, err := CopyFileIfExists(appFS, "go.mod", goModDest)
+	if err != nil {
+		return nil, err
+	}
+	stats.GoMod = copied
+	if copied && verbose {
+		log.Printf("Copied go.mod from %s", filepath.Join(appPath, "go.mod"))
+	}
+
+	// Copy go.sum if it exists
+	goSumDest := filepath.Join(tempDir, "go.sum")
+	copied, err = CopyFileIfExists(appFS, "go.sum", goSumDest)
+	if err != nil {
+		return nil, err
+	}
+	stats.GoSum = copied
+	if copied && verbose {
+		log.Printf("Copied go.sum from %s", filepath.Join(appPath, "go.sum"))
+	}
+
+	// Copy manifest.json if it exists
+	manifestDest := filepath.Join(tempDir, "manifest.json")
+	copied, err = CopyFileIfExists(appFS, "manifest.json", manifestDest)
+	if err != nil {
+		return nil, err
+	}
+	if copied && verbose {
+		log.Printf("Copied manifest.json from %s", filepath.Join(appPath, "manifest.json"))
+	}
+
+	// Copy static directory
+	staticDestDir := filepath.Join(tempDir, "static")
+	staticCount, err := copyDirFromFS(appFS, "static", staticDestDir, true)
+	if err != nil {
+		return nil, fmt.Errorf("failed to copy static directory: %w", err)
+	}
+	stats.StaticFiles = staticCount
+
+	// Copy all *.go files from the root directory
+	goCount, err := copyGoFilesFromFS(appFS, tempDir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to copy go files: %w", err)
+	}
+	stats.GoFiles = goCount
+
+	return stats, nil
+}
+
 func TsunamiRun(opts BuildOpts) error {
-	buildEnv, err := tsunamiBuildInternal(opts)
+	buildEnv, err := TsunamiBuildInternal(opts)
 	defer buildEnv.cleanupTempDir(opts.KeepTemp, opts.Verbose)
 	if err != nil {
 		return err
@@ -702,11 +743,11 @@ func TsunamiRun(opts BuildOpts) error {
 	setupSignalCleanup(buildEnv, opts.KeepTemp, opts.Verbose)
 
 	// Run the built application
-	appPath := filepath.Join(buildEnv.TempDir, "bin", "app")
-	runCmd := exec.Command(appPath)
+	appBinPath := filepath.Join(buildEnv.TempDir, "bin", "app")
+	runCmd := exec.Command(appBinPath)
 	runCmd.Dir = buildEnv.TempDir
 
-	log.Printf("Running tsunami app from %s", opts.Dir)
+	log.Printf("Running tsunami app from %s", opts.AppPath)
 
 	runCmd.Stdin = os.Stdin
 
@@ -731,7 +772,7 @@ func TsunamiRun(opts BuildOpts) error {
 	} else {
 		// Normal execution without browser opening
 		if opts.Verbose {
-			log.Printf("Executing: %s", appPath)
+			log.Printf("Executing: %s", appBinPath)
 			runCmd.Stdout = os.Stdout
 			runCmd.Stderr = os.Stderr
 		}
@@ -752,7 +793,6 @@ func monitorAndOpenBrowser(r io.ReadCloser, verbose bool) {
 	defer r.Close()
 
 	scanner := bufio.NewScanner(r)
-	urlRegex := regexp.MustCompile(`\[tsunami\] listening at (http://[^\s]+)`)
 	browserOpened := false
 	if verbose {
 		log.Printf("monitoring for browser open\n")
@@ -762,14 +802,177 @@ func monitorAndOpenBrowser(r io.ReadCloser, verbose bool) {
 		line := scanner.Text()
 		fmt.Println(line)
 
-		if !browserOpened && len(urlRegex.FindStringSubmatch(line)) > 1 {
-			matches := urlRegex.FindStringSubmatch(line)
-			url := matches[1]
+		if !browserOpened {
+			port := ParseTsunamiPort(line)
+			if port > 0 {
+				url := fmt.Sprintf("http://localhost:%d", port)
+				if verbose {
+					log.Printf("Opening browser to %s", url)
+				}
+				go util.OpenBrowser(url, 100*time.Millisecond)
+				browserOpened = true
+			}
+		}
+	}
+}
+
+func ParseTsunamiPort(line string) int {
+	urlRegex := regexp.MustCompile(`\[tsunami\] listening at (http://[^\s]+)`)
+	matches := urlRegex.FindStringSubmatch(line)
+	if len(matches) < 2 {
+		return 0
+	}
+
+	u, err := url.Parse(matches[1])
+	if err != nil {
+		return 0
+	}
+
+	portStr := u.Port()
+	if portStr == "" {
+		return 0
+	}
+
+	port, err := strconv.Atoi(portStr)
+	if err != nil {
+		return 0
+	}
+
+	return port
+}
+
+func copyScaffoldFS(scaffoldFS fs.FS, destDir string, verbose bool) (int, error) {
+	fileCount := 0
+
+	// Handle node_modules directory - prefer symlink if possible, otherwise copy
+	if _, err := fs.Stat(scaffoldFS, "node_modules"); err == nil {
+		destPath := filepath.Join(destDir, "node_modules")
+
+		// Try to create symlink if we have DirFS
+		if dirFS, ok := scaffoldFS.(DirFS); ok {
+			srcPath := dirFS.JoinOS("node_modules")
+			if err := os.Symlink(srcPath, destPath); err != nil {
+				return 0, fmt.Errorf("failed to create symlink for node_modules: %w", err)
+			}
 			if verbose {
-				log.Printf("Opening browser to %s", url)
+				log.Printf("Symlinked node_modules directory\n")
+			}
+			fileCount++
+		} else {
+			// Fallback to recursive copy
+			dirCount, err := copyDirFromFS(scaffoldFS, "node_modules", destPath, false)
+			if err != nil {
+				return 0, fmt.Errorf("failed to copy node_modules directory: %w", err)
+			}
+			if verbose {
+				log.Printf("Copied node_modules directory (%d files)\n", dirCount)
+			}
+			fileCount += dirCount
+		}
+	} else if !os.IsNotExist(err) {
+		return 0, fmt.Errorf("error checking node_modules: %w", err)
+	}
+
+	// Copy package files instead of symlinking
+	packageFiles := []string{"package.json", "package-lock.json"}
+	for _, fileName := range packageFiles {
+		destPath := filepath.Join(destDir, fileName)
+
+		// Check if source exists in FS
+		if _, err := fs.Stat(scaffoldFS, fileName); err != nil {
+			if os.IsNotExist(err) {
+				continue // Skip if doesn't exist
+			}
+			return 0, fmt.Errorf("error checking %s: %w", fileName, err)
+		}
+
+		// Copy file from FS
+		if err := CopyFileFromFS(scaffoldFS, fileName, destPath); err != nil {
+			return 0, fmt.Errorf("failed to copy %s: %w", fileName, err)
+		}
+		fileCount++
+	}
+
+	// Copy dist directory using FS
+	distDestPath := filepath.Join(destDir, "dist")
+	dirCount, err := copyDirFromFS(scaffoldFS, "dist", distDestPath, false)
+	if err != nil {
+		return 0, fmt.Errorf("failed to copy dist directory: %w", err)
+	}
+	fileCount += dirCount
+
+	// Copy files by pattern (*.go, *.md, *.json, tailwind.css)
+	patterns := []string{"*.go", "*.md", "*.json", "tailwind.css"}
+
+	for _, pattern := range patterns {
+		matches, err := fs.Glob(scaffoldFS, pattern)
+		if err != nil {
+			return 0, fmt.Errorf("failed to glob pattern %s: %w", pattern, err)
+		}
+
+		for _, match := range matches {
+			destPath := filepath.Join(destDir, match)
+			if err := CopyFileFromFS(scaffoldFS, match, destPath); err != nil {
+				return 0, fmt.Errorf("failed to copy %s: %w", match, err)
 			}
-			go util.OpenBrowser(url, 100*time.Millisecond)
-			browserOpened = true
+			fileCount++
 		}
 	}
+
+	return fileCount, nil
+}
+
+func MakeAppPackage(appFS fs.FS, appPath string, verbose bool, outputFile string) error {
+	if verbose {
+		log.Printf("Creating app package from %s to %s", appPath, outputFile)
+	}
+
+	// Create output directory if it doesn't exist
+	outputDir := filepath.Dir(outputFile)
+	if err := os.MkdirAll(outputDir, 0755); err != nil {
+		return fmt.Errorf("failed to create output directory: %w", err)
+	}
+
+	// Create zip file
+	zipFile, err := os.Create(outputFile)
+	if err != nil {
+		return fmt.Errorf("failed to create zip file: %w", err)
+	}
+	defer zipFile.Close()
+
+	zipWriter := zip.NewWriter(zipFile)
+	defer zipWriter.Close()
+
+	fileCount := 0
+
+	// Add go.mod if it exists
+	if err := addFileToZipIfExists(zipWriter, appFS, "go.mod", &fileCount, verbose); err != nil {
+		return fmt.Errorf("failed to add go.mod: %w", err)
+	}
+
+	// Add go.sum if it exists
+	if err := addFileToZipIfExists(zipWriter, appFS, "go.sum", &fileCount, verbose); err != nil {
+		return fmt.Errorf("failed to add go.sum: %w", err)
+	}
+
+	// Add manifest.json if it exists
+	if err := addFileToZipIfExists(zipWriter, appFS, "manifest.json", &fileCount, verbose); err != nil {
+		return fmt.Errorf("failed to add manifest.json: %w", err)
+	}
+
+	// Add all *.go files
+	if err := addGoFilesToZip(zipWriter, appFS, &fileCount, verbose); err != nil {
+		return fmt.Errorf("failed to add go files: %w", err)
+	}
+
+	// Add static directory if it exists
+	if err := addDirToZipIfExists(zipWriter, appFS, "static", &fileCount, verbose); err != nil {
+		return fmt.Errorf("failed to add static directory: %w", err)
+	}
+
+	if verbose {
+		log.Printf("Package created successfully with %d files", fileCount)
+	}
+
+	return nil
 }
diff --git a/tsunami/build/buildutil.go b/tsunami/build/buildutil.go
index 3ad35233e0..9a3798f09e 100644
--- a/tsunami/build/buildutil.go
+++ b/tsunami/build/buildutil.go
@@ -1,12 +1,75 @@
 package build
 
 import (
+	"archive/zip"
 	"fmt"
 	"io"
+	"io/fs"
+	"log"
 	"os"
 	"path/filepath"
+	"strings"
 )
 
+type DirFS struct {
+	Root string
+	fs.FS
+}
+
+func NewDirFS(root string) DirFS {
+	return DirFS{Root: root, FS: os.DirFS(root)}
+}
+
+func (d DirFS) JoinOS(name string) string {
+	return filepath.Join(d.Root, filepath.FromSlash(name))
+}
+
+func (d DirFS) Stat(name string) (fs.FileInfo, error)      { return fs.Stat(d.FS, name) }
+func (d DirFS) ReadFile(name string) ([]byte, error)       { return fs.ReadFile(d.FS, name) }
+func (d DirFS) ReadDir(name string) ([]fs.DirEntry, error) { return fs.ReadDir(d.FS, name) }
+func (d DirFS) Glob(p string) ([]string, error)            { return fs.Glob(d.FS, p) }
+
+func pathToFS(path string) (fs.FS, bool, func() error, error) {
+	if path == "" {
+		return nil, false, nil, fmt.Errorf("directory path cannot be empty")
+	}
+
+	// Check if path exists
+	info, err := os.Stat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, false, nil, fmt.Errorf("path %q does not exist", path)
+		}
+		return nil, false, nil, fmt.Errorf("error accessing path %q: %w", path, err)
+	}
+
+	// Check if it's a .tsapp file (zip archive)
+	if strings.HasSuffix(path, ".tsapp") {
+		if info.IsDir() {
+			return nil, false, nil, fmt.Errorf("%q is a directory, but .tsapp files must be zip archives", path)
+		}
+
+		// Open as zip file
+		zipReader, err := zip.OpenReader(path)
+		if err != nil {
+			return nil, false, nil, fmt.Errorf("failed to open .tsapp file %q as zip archive: %w", path, err)
+		}
+
+		// Return zip filesystem (not writable) with closer function
+		return zipReader, false, zipReader.Close, nil
+	}
+
+	// Handle regular directories
+	if !info.IsDir() {
+		return nil, false, nil, fmt.Errorf("%q is not a directory", path)
+	}
+
+	// Check if directory is writable by checking permissions
+	canWrite := info.Mode().Perm()&0200 != 0 // Check if owner has write permission
+
+	return NewDirFS(path), canWrite, nil, nil
+}
+
 func IsDirOrNotFound(path string) error {
 	info, err := os.Stat(path)
 	if err != nil {
@@ -48,9 +111,116 @@ func FileMustNotExist(path string) error {
 	return nil // Not found is OK
 }
 
-func copyDirRecursive(srcDir, destDir string, forceCreateDestDir bool) (int, error) {
+func copyFile(srcPath, destPath string) error {
+	return CopyFileFromFS(os.DirFS("/"), strings.TrimPrefix(srcPath, "/"), destPath)
+}
+
+func listGoFilesInDir(dirPath string) ([]string, error) {
+	entries, err := os.ReadDir(dirPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read directory %s: %w", dirPath, err)
+	}
+
+	var goFiles []string
+	for _, entry := range entries {
+		if !entry.IsDir() && filepath.Ext(entry.Name()) == ".go" {
+			goFiles = append(goFiles, entry.Name())
+		}
+	}
+
+	return goFiles, nil
+}
+
+func CopyFileIfExists(fsys fs.FS, srcPath, destPath string) (bool, error) {
+	if fileInfo, err := fs.Stat(fsys, srcPath); err == nil {
+		if fileInfo.IsDir() {
+			return false, fmt.Errorf("source path %s is a directory", srcPath)
+		}
+		if err := CopyFileFromFS(fsys, srcPath, destPath); err != nil {
+			return false, fmt.Errorf("failed to copy %s: %w", srcPath, err)
+		}
+		return true, nil
+	} else if os.IsNotExist(err) {
+		return false, nil
+	} else {
+		return false, fmt.Errorf("error checking %s: %w", srcPath, err)
+	}
+}
+
+func CopyFileFromFS(fsys fs.FS, srcPath, destPath string) error {
+	// Open source file from filesystem
+	srcFile, err := fsys.Open(srcPath)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+
+	// Get source file info
+	srcInfo, err := fs.Stat(fsys, srcPath)
+	if err != nil {
+		return err
+	}
+
+	// Create destination directory if it doesn't exist
+	destDir := filepath.Dir(destPath)
+	if err := os.MkdirAll(destDir, 0755); err != nil {
+		return err
+	}
+
+	// Create destination file
+	destFile, err := os.Create(destPath)
+	if err != nil {
+		return err
+	}
+	defer destFile.Close()
+
+	// Copy content
+	_, err = io.Copy(destFile, srcFile)
+	if err != nil {
+		return err
+	}
+
+	// Set the same mode as source file
+	return os.Chmod(destPath, srcInfo.Mode())
+}
+
+func checkFileExistsFS(fsys fs.FS, path string) error {
+	info, err := fs.Stat(fsys, path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("file %q not found", path)
+		}
+		return fmt.Errorf("error accessing file %q: %w", path, err)
+	}
+
+	if info.IsDir() {
+		return fmt.Errorf("%q is a directory, not a file", path)
+	}
+
+	return nil
+}
+
+func isDirOrNotFoundFS(fsys fs.FS, path string) error {
+	info, err := fs.Stat(fsys, path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // Not found is OK
+		}
+		return err // Other errors are not OK
+	}
+
+	if !info.IsDir() {
+		return fmt.Errorf("%q exists but is not a directory", path)
+	}
+
+	return nil // It's a directory, which is OK
+}
+
+func copyDirFromFS(fsys fs.FS, srcDir, destDir string, forceCreateDestDir bool) (int, error) {
+	fileCount := 0
+
 	// Check if source directory exists
-	srcInfo, err := os.Stat(srcDir)
+	srcInfo, err := fs.Stat(fsys, srcDir)
 	if err != nil {
 		if os.IsNotExist(err) {
 			if forceCreateDestDir {
@@ -69,8 +239,7 @@ func copyDirRecursive(srcDir, destDir string, forceCreateDestDir bool) (int, err
 		return 0, fmt.Errorf("source %s is not a directory", srcDir)
 	}
 
-	fileCount := 0
-	err = filepath.Walk(srcDir, func(path string, info os.FileInfo, err error) error {
+	err = fs.WalkDir(fsys, srcDir, func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
@@ -82,14 +251,15 @@ func copyDirRecursive(srcDir, destDir string, forceCreateDestDir bool) (int, err
 		}
 		destPath := filepath.Join(destDir, relPath)
 
-		if info.IsDir() {
-			// Create directory
-			if err := os.MkdirAll(destPath, info.Mode()); err != nil {
+		if d.IsDir() {
+			// Create directory with standard permissions (0755) regardless of source permissions
+			// This is important when extracting from zip files which may have read-only dirs
+			if err := os.MkdirAll(destPath, 0755); err != nil {
 				return err
 			}
 		} else {
 			// Copy file
-			if err := copyFile(path, destPath); err != nil {
+			if err := CopyFileFromFS(fsys, path, destPath); err != nil {
 				return err
 			}
 			fileCount++
@@ -101,128 +271,113 @@ func copyDirRecursive(srcDir, destDir string, forceCreateDestDir bool) (int, err
 	return fileCount, err
 }
 
-func copyFile(srcPath, destPath string) error {
-	// Get source file info for mode
-	srcInfo, err := os.Stat(srcPath)
-	if err != nil {
-		return err
+func addFileToZipIfExists(zipWriter *zip.Writer, fsys fs.FS, fileName string, fileCount *int, verbose bool) error {
+	if _, err := fs.Stat(fsys, fileName); err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return fmt.Errorf("error checking %s: %w", fileName, err)
 	}
 
-	// Create destination directory if it doesn't exist
-	destDir := filepath.Dir(destPath)
-	if err := os.MkdirAll(destDir, 0755); err != nil {
+	if err := addFileToZip(zipWriter, fsys, fileName, fileName); err != nil {
 		return err
 	}
 
-	srcFile, err := os.Open(srcPath)
-	if err != nil {
-		return err
+	*fileCount++
+	if verbose {
+		log.Printf("Added %s to package", fileName)
 	}
-	defer srcFile.Close()
 
-	destFile, err := os.Create(destPath)
-	if err != nil {
-		return err
-	}
-	defer destFile.Close()
-
-	_, err = io.Copy(destFile, srcFile)
-	if err != nil {
-		return err
-	}
-
-	// Set the same mode as source file
-	return os.Chmod(destPath, srcInfo.Mode())
+	return nil
 }
 
-func listGoFilesInDir(dirPath string) ([]string, error) {
-	entries, err := os.ReadDir(dirPath)
+func addGoFilesToZip(zipWriter *zip.Writer, fsys fs.FS, fileCount *int, verbose bool) error {
+	entries, err := fs.ReadDir(fsys, ".")
 	if err != nil {
-		return nil, fmt.Errorf("failed to read directory %s: %w", dirPath, err)
+		return fmt.Errorf("failed to read directory: %w", err)
 	}
 
-	var goFiles []string
 	for _, entry := range entries {
-		if !entry.IsDir() && filepath.Ext(entry.Name()) == ".go" {
-			goFiles = append(goFiles, entry.Name())
+		if entry.IsDir() {
+			continue
 		}
-	}
 
-	return goFiles, nil
-}
-
-func copyScaffoldSelective(scaffoldPath, destDir string) (int, error) {
-	fileCount := 0
-
-	// Create symlinks for node_modules directory
-	symlinkItems := []string{"node_modules"}
-	for _, item := range symlinkItems {
-		srcPath := filepath.Join(scaffoldPath, item)
-		destPath := filepath.Join(destDir, item)
+		if strings.HasSuffix(entry.Name(), ".go") {
+			if err := addFileToZip(zipWriter, fsys, entry.Name(), entry.Name()); err != nil {
+				return fmt.Errorf("failed to add %s: %w", entry.Name(), err)
+			}
 
-		// Check if source exists
-		if _, err := os.Stat(srcPath); err != nil {
-			if os.IsNotExist(err) {
-				continue // Skip if doesn't exist
+			*fileCount++
+			if verbose {
+				log.Printf("Added %s to package", entry.Name())
 			}
-			return 0, fmt.Errorf("error checking %s: %w", item, err)
 		}
+	}
+
+	return nil
+}
 
-		// Create symlink
-		if err := os.Symlink(srcPath, destPath); err != nil {
-			return 0, fmt.Errorf("failed to create symlink for %s: %w", item, err)
+func addDirToZipIfExists(zipWriter *zip.Writer, fsys fs.FS, dirName string, fileCount *int, verbose bool) error {
+	info, err := fs.Stat(fsys, dirName)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
 		}
-		fileCount++
+		return fmt.Errorf("error checking %s: %w", dirName, err)
 	}
 
-	// Copy package files instead of symlinking
-	packageFiles := []string{"package.json", "package-lock.json"}
-	for _, fileName := range packageFiles {
-		srcPath := filepath.Join(scaffoldPath, fileName)
-		destPath := filepath.Join(destDir, fileName)
+	if !info.IsDir() {
+		return fmt.Errorf("%s exists but is not a directory", dirName)
+	}
 
-		// Check if source exists
-		if _, err := os.Stat(srcPath); err != nil {
-			if os.IsNotExist(err) {
-				continue // Skip if doesn't exist
-			}
-			return 0, fmt.Errorf("error checking %s: %w", fileName, err)
+	return fs.WalkDir(fsys, dirName, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
 		}
 
-		// Copy file
-		if err := copyFile(srcPath, destPath); err != nil {
-			return 0, fmt.Errorf("failed to copy %s: %w", fileName, err)
+		if !d.IsDir() {
+			if err := addFileToZip(zipWriter, fsys, path, path); err != nil {
+				return fmt.Errorf("failed to add file %s: %w", path, err)
+			}
+
+			*fileCount++
+			if verbose {
+				log.Printf("Added %s to package", path)
+			}
 		}
-		fileCount++
+
+		return nil
+	})
+}
+
+func addFileToZip(zipWriter *zip.Writer, fsys fs.FS, srcPath, destPath string) error {
+	srcFile, err := fsys.Open(srcPath)
+	if err != nil {
+		return fmt.Errorf("failed to open source file %s: %w", srcPath, err)
 	}
+	defer srcFile.Close()
 
-	// Copy dist directory that needs to be fully copied for go embed
-	distSrcPath := filepath.Join(scaffoldPath, "dist")
-	distDestPath := filepath.Join(destDir, "dist")
-	dirCount, err := copyDirRecursive(distSrcPath, distDestPath, false)
+	info, err := fs.Stat(fsys, srcPath)
 	if err != nil {
-		return 0, fmt.Errorf("failed to copy dist directory: %w", err)
+		return fmt.Errorf("failed to get file info for %s: %w", srcPath, err)
 	}
-	fileCount += dirCount
 
-	// Copy files by pattern (*.go, *.md, *.json, tailwind.css)
-	patterns := []string{"*.go", "*.md", "*.json", "tailwind.css"}
-	for _, pattern := range patterns {
-		matches, err := filepath.Glob(filepath.Join(scaffoldPath, pattern))
-		if err != nil {
-			return 0, fmt.Errorf("failed to glob pattern %s: %w", pattern, err)
-		}
+	header, err := zip.FileInfoHeader(info)
+	if err != nil {
+		return fmt.Errorf("failed to create zip header for %s: %w", srcPath, err)
+	}
 
-		for _, srcPath := range matches {
-			fileName := filepath.Base(srcPath)
-			destPath := filepath.Join(destDir, fileName)
+	header.Name = destPath
 
-			if err := copyFile(srcPath, destPath); err != nil {
-				return 0, fmt.Errorf("failed to copy %s: %w", fileName, err)
-			}
-			fileCount++
-		}
+	destFile, err := zipWriter.CreateHeader(header)
+	if err != nil {
+		return fmt.Errorf("failed to create zip entry for %s: %w", destPath, err)
 	}
 
-	return fileCount, nil
+	_, err = io.Copy(destFile, srcFile)
+	if err != nil {
+		return fmt.Errorf("failed to copy content for %s: %w", srcPath, err)
+	}
+
+	return nil
 }
diff --git a/tsunami/cmd/main-tsunami.go b/tsunami/cmd/main-tsunami.go
index 1ca4ffefd8..0d571b4ead 100644
--- a/tsunami/cmd/main-tsunami.go
+++ b/tsunami/cmd/main-tsunami.go
@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 
 	"github.com/spf13/cobra"
 	"github.com/wavetermdev/waveterm/tsunami/build"
@@ -12,6 +13,7 @@ import (
 const (
 	EnvTsunamiScaffoldPath   = "TSUNAMI_SCAFFOLDPATH"
 	EnvTsunamiSdkReplacePath = "TSUNAMI_SDKREPLACEPATH"
+	EnvTsunamiNodePath       = "TSUNAMI_NODEPATH"
 )
 
 // these are set at build time
@@ -46,13 +48,19 @@ func validateEnvironmentVars(opts *build.BuildOpts) error {
 
 	opts.ScaffoldPath = scaffoldPath
 	opts.SdkReplacePath = sdkReplacePath
+
+	// NodePath is optional
+	if nodePath := os.Getenv(EnvTsunamiNodePath); nodePath != "" {
+		opts.NodePath = nodePath
+	}
+
 	return nil
 }
 
 var buildCmd = &cobra.Command{
-	Use:          "build [directory]",
+	Use:          "build [apppath]",
 	Short:        "Build a Tsunami application",
-	Long:         `Build a Tsunami application from the specified directory.`,
+	Long:         `Build a Tsunami application.`,
 	Args:         cobra.ExactArgs(1),
 	SilenceUsage: true,
 	Run: func(cmd *cobra.Command, args []string) {
@@ -60,10 +68,11 @@ var buildCmd = &cobra.Command{
 		keepTemp, _ := cmd.Flags().GetBool("keeptemp")
 		output, _ := cmd.Flags().GetString("output")
 		opts := build.BuildOpts{
-			Dir:        args[0],
-			Verbose:    verbose,
-			KeepTemp:   keepTemp,
-			OutputFile: output,
+			AppPath:      args[0],
+			Verbose:      verbose,
+			KeepTemp:     keepTemp,
+			OutputFile:   output,
+			MoveFileBack: true,
 		}
 		if err := validateEnvironmentVars(&opts); err != nil {
 			fmt.Println(err)
@@ -77,9 +86,9 @@ var buildCmd = &cobra.Command{
 }
 
 var runCmd = &cobra.Command{
-	Use:          "run [directory]",
+	Use:          "run [apppath]",
 	Short:        "Build and run a Tsunami application",
-	Long:         `Build and run a Tsunami application from the specified directory.`,
+	Long:         `Build and run a Tsunami application.`,
 	Args:         cobra.ExactArgs(1),
 	SilenceUsage: true,
 	Run: func(cmd *cobra.Command, args []string) {
@@ -87,10 +96,11 @@ var runCmd = &cobra.Command{
 		open, _ := cmd.Flags().GetBool("open")
 		keepTemp, _ := cmd.Flags().GetBool("keeptemp")
 		opts := build.BuildOpts{
-			Dir:      args[0],
-			Verbose:  verbose,
-			Open:     open,
-			KeepTemp: keepTemp,
+			AppPath:      args[0],
+			Verbose:      verbose,
+			Open:         open,
+			KeepTemp:     keepTemp,
+			MoveFileBack: true,
 		}
 		if err := validateEnvironmentVars(&opts); err != nil {
 			fmt.Println(err)
@@ -103,6 +113,34 @@ var runCmd = &cobra.Command{
 	},
 }
 
+var packageCmd = &cobra.Command{
+	Use:          "package [apppath]",
+	Short:        "Package a Tsunami application into a .tsapp file",
+	Long:         `Package a Tsunami application into a .tsapp file.`,
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	Run: func(cmd *cobra.Command, args []string) {
+		verbose, _ := cmd.Flags().GetBool("verbose")
+		output, _ := cmd.Flags().GetString("output")
+		appPath := args[0]
+		
+		if output == "" {
+			appName := build.GetAppName(appPath)
+			output = filepath.Join(appPath, appName+".tsapp")
+		}
+		
+		appFS := build.NewDirFS(appPath)
+		if err := build.MakeAppPackage(appFS, appPath, verbose, output); err != nil {
+			fmt.Printf("Error: %v\n", err)
+			os.Exit(1)
+		}
+		
+		if verbose {
+			fmt.Printf("Successfully created package: %s\n", output)
+		}
+	},
+}
+
 func init() {
 	rootCmd.AddCommand(versionCmd)
 
@@ -115,6 +153,10 @@ func init() {
 	runCmd.Flags().Bool("open", false, "Open the application in the browser after starting")
 	runCmd.Flags().Bool("keeptemp", false, "Keep temporary build directory")
 	rootCmd.AddCommand(runCmd)
+
+	packageCmd.Flags().BoolP("verbose", "v", false, "Enable verbose output")
+	packageCmd.Flags().StringP("output", "o", "", "Output file path for the package (default: [appname].tsapp in apppath)")
+	rootCmd.AddCommand(packageCmd)
 }
 
 func main() {
diff --git a/tsunami/engine/clientimpl.go b/tsunami/engine/clientimpl.go
index 73697c1754..4071ede145 100644
--- a/tsunami/engine/clientimpl.go
+++ b/tsunami/engine/clientimpl.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,50 @@ 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 _, ch := range c.SSEChannels {
+		select {
+		case ch <- event:
+			// Successfully sent
+		default:
+			// silently drop (below is just for debugging).  this wont happen in general
+			// 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 {
diff --git a/tsunami/engine/serverhandlers.go b/tsunami/engine/serverhandlers.go
index 80dcb0292f..fd162e718c 100644
--- a/tsunami/engine/serverhandlers.go
+++ b/tsunami/engine/serverhandlers.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
 			}
diff --git a/tsunami/frontend/package.json b/tsunami/frontend/package.json
index 1876f02eec..c82f377bbf 100644
--- a/tsunami/frontend/package.json
+++ b/tsunami/frontend/package.json
@@ -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"
     }
diff --git a/tsunami/frontend/src/tailwind.css b/tsunami/frontend/src/tailwind.css
index 224623f0bd..945398cd53 100644
--- a/tsunami/frontend/src/tailwind.css
+++ b/tsunami/frontend/src/tailwind.css
@@ -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);
+}
diff --git a/tsunami/frontend/src/util/clientid.ts b/tsunami/frontend/src/util/clientid.ts
index 4217e291ae..f6dc5f2e8d 100644
--- a/tsunami/frontend/src/util/clientid.ts
+++ b/tsunami/frontend/src/util/clientid.ts
@@ -9,6 +9,14 @@ const CLIENT_ID_KEY = "tsunami:clientid";
  * If no client ID exists, a new UUID is generated and stored.
  */
 export function getOrCreateClientId(): string {
+    // First check for URL parameter
+    const urlParams = new URLSearchParams(window.location.search);
+    const urlClientId = urlParams.get("clientid");
+    if (urlClientId) {
+        return urlClientId;
+    }
+    
+    // Fall back to session storage
     let clientId = sessionStorage.getItem(CLIENT_ID_KEY);
     if (!clientId) {
         clientId = crypto.randomUUID();
diff --git a/tsunami/frontend/src/vdom.tsx b/tsunami/frontend/src/vdom.tsx
index 5ee1b29760..97219fcb72 100644
--- a/tsunami/frontend/src/vdom.tsx
+++ b/tsunami/frontend/src/vdom.tsx
@@ -67,6 +67,35 @@ const AllowedSimpleTags: { [tagName: string]: boolean } = {
     pre: true,
     code: true,
     canvas: true,
+    strong: true,
+    em: true,
+    small: true,
+    sub: true,
+    sup: true,
+    u: true,
+    mark: true,
+    blockquote: true,
+    section: true,
+    article: true,
+    header: true,
+    footer: true,
+    main: true,
+    nav: true,
+    dl: true,
+    dt: true,
+    dd: true,
+    video: true,
+    audio: true,
+    picture: true,
+    source: true,
+    figure: true,
+    figcaption: true,
+    details: true,
+    summary: true,
+    fieldset: true,
+    legend: true,
+    progress: true,
+    meter: true,
 };
 
 const AllowedSvgTags = {
diff --git a/tsunami/templates/package.json.tmpl b/tsunami/templates/package.json.tmpl
new file mode 100644
index 0000000000..a214510649
--- /dev/null
+++ b/tsunami/templates/package.json.tmpl
@@ -0,0 +1,16 @@
+{
+  "name": "tsunami-scaffold",
+  "version": "1.0.0",
+  "main": "index.js",
+  "keywords": [],
+  "license": "Apache-2.0",
+  "description": "",
+  "author": {
+    "name": "Command Line Inc",
+    "email": "info@commandline.dev"
+  },
+  "dependencies": {
+    "@tailwindcss/cli": "^4.1.13",
+    "tailwindcss": "^4.1.13"
+  }
+}