windows, have a new "local" conn option for Git Bash if installed

Taskfile.yml

@@ -54,6 +54,17 @@ tasks:
             WCLOUD_ENDPOINT: "https://api-dev.waveterm.dev/central"
             WCLOUD_WS_ENDPOINT: "wss://wsapi-dev.waveterm.dev/"
 
+    electron:winquickdev:
+        desc: Run the Electron application via the Vite dev server (quick dev - Windows amd64 only, no generate, no wsh).
+        cmd: npm run dev
+        deps:
+            - npm:install
+            - build:backend:quickdev:windows
+        env:
+            WAVETERM_ENVFILE: "{{.ROOT_DIR}}/.env"
+            WCLOUD_ENDPOINT: "https://api-dev.waveterm.dev/central"
+            WCLOUD_WS_ENDPOINT: "wss://wsapi-dev.waveterm.dev/"
+
     docs:npm:install:
         desc: Runs `npm install` in docs directory
         internal: true
@@ -186,6 +197,25 @@ tasks:
         generates:
             - dist/bin/wavesrv.*
 
+    build:backend:quickdev:windows:
+        desc: Build only the wavesrv component for quickdev (Windows amd64 only, no generate, no wsh).
+        platforms: [windows]
+        cmds:
+            - task: build:server:internal
+              vars:
+                  ARCHS: amd64
+                  GO_ENV_VARS: CC="zig cc -target x86_64-windows-gnu"
+        deps:
+            - go:mod:tidy
+        sources:
+            - "cmd/server/*.go"
+            - "pkg/**/*.go"
+            - "pkg/**/*.json"
+            - "pkg/**/*.sh"
+            - "tsunami/**/*.go"
+        generates:
+            - dist/bin/wavesrv.x64.exe
+
     build:server:windows:
         desc: Build the wavesrv component for Windows platforms (only generates artifacts for the current architecture).
         platforms: [windows]

frontend/app/block/blockframe.tsx

@@ -254,7 +254,8 @@ const BlockFrame_Header = ({
         icon: "link-slash",
         title: "wsh is not installed for this connection",
     };
-    const showNoWshButton = manageConnection && wshProblem && !util.isBlank(connName) && !connName.startsWith("aws:");
+    const showNoWshButton =
+        manageConnection && wshProblem && !util.isLocalConnName(connName) && !connName.startsWith("aws:");
 
     return (
         <div
@@ -600,7 +601,7 @@ const BlockFrame_Default_Component = (props: BlockFrameProps) => {
             return;
         }
         const connName = blockData?.meta?.connection;
-        if (!util.isBlank(connName)) {
+        if (!util.isLocalConnName(connName)) {
             console.log("ensure conn", nodeModel.blockId, connName);
             RpcApi.ConnEnsureCommand(
                 TabRpcClient,

frontend/app/block/blockutil.tsx

@@ -166,7 +166,7 @@ export const ConnectionButton = React.memo(
     React.forwardRef<HTMLDivElement, ConnectionButtonProps>(
         ({ connection, changeConnModalAtom }: ConnectionButtonProps, ref) => {
             const [connModalOpen, setConnModalOpen] = jotai.useAtom(changeConnModalAtom);
-            const isLocal = util.isBlank(connection);
+            const isLocal = util.isLocalConnName(connection);
             const connStatusAtom = getConnStatusAtom(connection);
             const connStatus = jotai.useAtomValue(connStatusAtom);
             let showDisconnectedSlash = false;
@@ -178,9 +178,15 @@ export const ConnectionButton = React.memo(
             };
             let titleText = null;
             let shouldSpin = false;
+            let connDisplayName: string = null;
             if (isLocal) {
                 color = "var(--grey-text-color)";
-                titleText = "Connected to Local Machine";
+                if (connection === "local:gitbash") {
+                    titleText = "Connected to Git Bash";
+                    connDisplayName = "Git Bash";
+                } else {
+                    titleText = "Connected to Local Machine";
+                }
                 connIconElem = (
                     <i
                         className={clsx(util.makeIconClass("laptop", false), "fa-stack-1x")}
@@ -238,7 +244,11 @@ export const ConnectionButton = React.memo(
                             }}
                         />
                     </span>
-                    {isLocal ? null : <div className="connection-name ellipsis">{connection}</div>}
+                    {connDisplayName ? (
+                        <div className="connection-name ellipsis">{connDisplayName}</div>
+                    ) : isLocal ? null : (
+                        <div className="connection-name ellipsis">{connection}</div>
+                    )}
                 </div>
             );
         }

frontend/app/modals/conntypeahead.tsx

@@ -3,16 +3,8 @@
 
 import { computeConnColorNum } from "@/app/block/blockutil";
 import { TypeAheadModal } from "@/app/modals/typeaheadmodal";
-import {
-    atoms,
-    createBlock,
-    getApi,
-    getConnStatusAtom,
-    getHostName,
-    getUserName,
-    globalStore,
-    WOS,
-} from "@/app/store/global";
+import { ConnectionsModel } from "@/app/store/connections-model";
+import { atoms, createBlock, getConnStatusAtom, getHostName, getUserName, globalStore, WOS } from "@/app/store/global";
 import { globalRefocusWithTimeout } from "@/app/store/keymodel";
 import { RpcApi } from "@/app/store/wshclientapi";
 import { TabRpcClient } from "@/app/store/wshrpcutil";
@@ -107,7 +99,7 @@ function createFilteredLocalSuggestionItem(
             iconColor: "var(--grey-text-color)",
             value: "",
             label: localName,
-            current: connection == null,
+            current: util.isBlank(connection),
         };
         return [localSuggestion];
     }
@@ -172,12 +164,26 @@ function getLocalSuggestions(
     connSelected: string,
     connStatusMap: Map<string, ConnStatus>,
     fullConfig: FullConfigType,
-    filterOutNowsh: boolean
+    filterOutNowsh: boolean,
+    hasGitBash: boolean
 ): SuggestionConnectionScope | null {
     const wslFiltered = filterConnections(connList, connSelected, fullConfig, filterOutNowsh);
     const wslSuggestionItems = createWslSuggestionItems(wslFiltered, connection, connStatusMap);
     const localSuggestionItem = createFilteredLocalSuggestionItem(localName, connection, connSelected);
-    const combinedSuggestionItems = [...localSuggestionItem, ...wslSuggestionItems];
+
+    const gitBashItems: Array<SuggestionConnectionItem> = [];
+    if (hasGitBash && "Git Bash".toLowerCase().includes(connSelected.toLowerCase())) {
+        gitBashItems.push({
+            status: "connected",
+            icon: "laptop",
+            iconColor: "var(--grey-text-color)",
+            value: "local:gitbash",
+            label: "Git Bash",
+            current: connection === "local:gitbash",
+        });
+    }
+
+    const combinedSuggestionItems = [...localSuggestionItem, ...gitBashItems, ...wslSuggestionItems];
     const sortedSuggestionItems = sortConnSuggestionItems(combinedSuggestionItems, fullConfig);
     if (sortedSuggestionItems.length == 0) {
         return null;
@@ -235,7 +241,7 @@ function getDisconnectItem(
     connection: string,
     connStatusMap: Map<string, ConnStatus>
 ): SuggestionConnectionItem | null {
-    if (!connection) {
+    if (util.isLocalConnName(connection)) {
         return null;
     }
     const connStatus = connStatusMap.get(connection);
@@ -346,6 +352,7 @@ const ChangeConnectionBlockModal = React.memo(
         const fullConfig = jotai.useAtomValue(atoms.fullConfigAtom);
         let filterOutNowsh = util.useAtomValueSafe(viewModel.filterOutNowsh) ?? true;
         const showS3 = util.useAtomValueSafe(viewModel.showS3) ?? false;
+        const hasGitBash = jotai.useAtomValue(ConnectionsModel.getInstance().hasGitBashAtom);
 
         let maxActiveConnNum = 1;
         for (const conn of allConnStatus) {
@@ -402,7 +409,7 @@ const ChangeConnectionBlockModal = React.memo(
                     oref: WOS.makeORef("block", blockId),
                     meta: { connection: connName, file: newFile, "cmd:cwd": null },
                 });
-                
+
                 try {
                     await RpcApi.ConnEnsureCommand(
                         TabRpcClient,
@@ -425,7 +432,8 @@ const ChangeConnectionBlockModal = React.memo(
             connSelected,
             connStatusMap,
             fullConfig,
-            filterOutNowsh
+            filterOutNowsh,
+            hasGitBash
         );
         const remoteSuggestions = getRemoteSuggestions(
             connList,

frontend/app/store/connections-model.ts

@@ -0,0 +1,51 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { RpcApi } from "@/app/store/wshclientapi";
+import { TabRpcClient } from "@/app/store/wshrpcutil";
+import { isWindows } from "@/util/platformutil";
+import { atom, type Atom, type PrimitiveAtom } from "jotai";
+import { globalStore } from "./jotaiStore";
+
+class ConnectionsModel {
+    private static instance: ConnectionsModel;
+    gitBashPathAtom: PrimitiveAtom<string> = atom("") as PrimitiveAtom<string>;
+    hasGitBashAtom: Atom<boolean>;
+
+    private constructor() {
+        this.hasGitBashAtom = atom((get) => {
+            if (!isWindows()) {
+                return false;
+            }
+            const path = get(this.gitBashPathAtom);
+            return path !== "";
+        });
+        this.loadGitBashPath();
+    }
+
+    static getInstance(): ConnectionsModel {
+        if (!ConnectionsModel.instance) {
+            ConnectionsModel.instance = new ConnectionsModel();
+        }
+        return ConnectionsModel.instance;
+    }
+
+    async loadGitBashPath(rescan: boolean = false): Promise<void> {
+        if (!isWindows()) {
+            return;
+        }
+        try {
+            const path = await RpcApi.FindGitBashCommand(TabRpcClient, rescan, { timeout: 2000 });
+            globalStore.set(this.gitBashPathAtom, path);
+        } catch (error) {
+            console.error("Failed to find git bash path:", error);
+            globalStore.set(this.gitBashPathAtom, "");
+        }
+    }
+
+    getGitBashPath(): string {
+        return globalStore.get(this.gitBashPathAtom);
+    }
+}
+
+export { ConnectionsModel };

frontend/app/store/global.ts

@@ -17,7 +17,14 @@ import {
 import { getWebServerEndpoint } from "@/util/endpoints";
 import { fetch } from "@/util/fetchutil";
 import { setPlatform } from "@/util/platformutil";
-import { base64ToString, deepCompareReturnPrev, fireAndForget, getPrefixedSettings, isBlank } from "@/util/util";
+import {
+    base64ToString,
+    deepCompareReturnPrev,
+    fireAndForget,
+    getPrefixedSettings,
+    isBlank,
+    isLocalConnName,
+} from "@/util/util";
 import { atom, Atom, PrimitiveAtom, useAtomValue } from "jotai";
 import { globalStore } from "./jotaiStore";
 import { modalsModel } from "./modalmodel";
@@ -730,8 +737,7 @@ function getConnStatusAtom(conn: string): PrimitiveAtom<ConnStatus> {
     const connStatusMap = globalStore.get(ConnStatusMapAtom);
     let rtn = connStatusMap.get(conn);
     if (rtn == null) {
-        if (isBlank(conn)) {
-            // create a fake "local" status atom that's always connected
+        if (isLocalConnName(conn)) {
             const connStatus: ConnStatus = {
                 connection: conn,
                 connected: true,

frontend/app/store/wshclientapi.ts

@@ -282,6 +282,11 @@ class RpcApiType {
         return client.wshRpcCall("filewrite", data, opts);
     }
 
+    // command "findgitbash" [call]
+    FindGitBashCommand(client: WshClient, data: boolean, opts?: RpcOpts): Promise<string> {
+        return client.wshRpcCall("findgitbash", data, opts);
+    }
+
     // command "focuswindow" [call]
     FocusWindowCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
         return client.wshRpcCall("focuswindow", data, opts);

frontend/app/view/term/termwrap.ts

@@ -526,14 +526,14 @@ export class TermWrap {
                 oref: WOS.makeORef("block", this.blockId),
             });
 
-            if (rtInfo["shell:integration"]) {
+            if (rtInfo && rtInfo["shell:integration"]) {
                 const shellState = rtInfo["shell:state"] as ShellIntegrationStatus;
                 globalStore.set(this.shellIntegrationStatusAtom, shellState || null);
             } else {
                 globalStore.set(this.shellIntegrationStatusAtom, null);
             }
 
-            const lastCmd = rtInfo["shell:lastcmd"];
+            const lastCmd = rtInfo ? rtInfo["shell:lastcmd"] : null;
             globalStore.set(this.lastCommandAtom, lastCmd || null);
         } catch (e) {
             console.log("Error loading runtime info:", e);

frontend/types/gotypes.d.ts

@@ -1082,6 +1082,7 @@ declare global {
         "term:disablewebgl"?: boolean;
         "term:localshellpath"?: string;
         "term:localshellopts"?: string[];
+        "term:gitbashpath"?: string;
         "term:scrollback"?: number;
         "term:copyonselect"?: boolean;
         "term:transparency"?: number;

frontend/util/util.ts

@@ -12,6 +12,13 @@ function isBlank(str: string): boolean {
     return str == null || str == "";
 }
 
+function isLocalConnName(connName: string): boolean {
+    if (isBlank(connName)) {
+        return true;
+    }
+    return connName === "local" || connName.startsWith("local:");
+}
+
 function base64ToString(b64: string): string {
     if (b64 == null) {
         return null;
@@ -509,6 +516,7 @@ export {
     getPromiseState,
     getPromiseValue,
     isBlank,
+    isLocalConnName,
     jotaiLoadableValue,
     jsonDeepEqual,
     lazy,

pkg/blockcontroller/blockcontroller.go

@@ -83,15 +83,15 @@ func getController(blockId string) Controller {
 
 func registerController(blockId string, controller Controller) {
 	var existingController Controller
-	
+
 	registryLock.Lock()
 	existing, exists := controllerRegistry[blockId]
 	if exists {
 		existingController = existing
 	}
 	controllerRegistry[blockId] = controller
 	registryLock.Unlock()
-	
+
 	if existingController != nil {
 		existingController.Stop(false, Status_Done)
 		wstore.DeleteRTInfo(waveobj.MakeORef(waveobj.OType_Block, blockId))
@@ -169,8 +169,9 @@ func ResyncController(ctx context.Context, tabId string, blockId string, rtOpts
 		// For shell/cmd, check if connection changed
 		if !needsReplace && (controllerName == BlockController_Shell || controllerName == BlockController_Cmd) {
 			connName := blockData.Meta.GetString(waveobj.MetaKey_Connection, "")
+			// Check if connection changed, including between different local connections
 			if existingStatus.ShellProcStatus == Status_Running && existingStatus.ShellProcConnName != connName {
-				log.Printf("stopping blockcontroller %s due to conn change\n", blockId)
+				log.Printf("stopping blockcontroller %s due to conn change (from %q to %q)\n", blockId, existingStatus.ShellProcConnName, connName)
 				StopBlockControllerAndSetStatus(blockId, Status_Init)
 				time.Sleep(100 * time.Millisecond)
 				// Don't delete, will reuse same controller type
@@ -209,10 +210,10 @@ func ResyncController(ctx context.Context, tabId string, blockId string, rtOpts
 	// 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
+		// For shell/cmd, check connection status first (for non-local connections)
 		if controllerName == BlockController_Shell || controllerName == BlockController_Cmd {
 			connName := blockData.Meta.GetString(waveobj.MetaKey_Connection, "")
-			if connName != "" {
+			if !conncontroller.IsLocalConnName(connName) {
 				err = CheckConnStatus(blockId)
 				if err != nil {
 					return fmt.Errorf("cannot start shellproc: %w", err)
@@ -362,7 +363,7 @@ func CheckConnStatus(blockId string) error {
 		return fmt.Errorf("error getting block: %w", err)
 	}
 	connName := bdata.Meta.GetString(waveobj.MetaKey_Connection, "")
-	if connName == "" {
+	if conncontroller.IsLocalConnName(connName) {
 		return nil
 	}
 	if strings.HasPrefix(connName, "wsl://") {