conn updates 3

cmd/server/main-server.go

@@ -17,6 +17,7 @@ import (
 
 	"github.com/wavetermdev/waveterm/pkg/authkey"
 	"github.com/wavetermdev/waveterm/pkg/blockcontroller"
+	"github.com/wavetermdev/waveterm/pkg/blocklogger"
 	"github.com/wavetermdev/waveterm/pkg/filestore"
 	"github.com/wavetermdev/waveterm/pkg/panichandler"
 	"github.com/wavetermdev/waveterm/pkg/remote/conncontroller"
@@ -297,6 +298,7 @@ func main() {
 	go stdinReadWatch()
 	go telemetryLoop()
 	configWatcher()
+	blocklogger.InitBlockLogger()
 	webListener, err := web.MakeTCPListener("web")
 	if err != nil {
 		log.Printf("error creating web listener: %v\n", err)

cmd/wsh/cmd/wshcmd-conn.go

@@ -128,7 +128,11 @@ func connReinstallRun(cmd *cobra.Command, args []string) error {
 	if err := validateConnectionName(connName); err != nil {
 		return err
 	}
-	err := wshclient.ConnReinstallWshCommand(RpcClient, connName, &wshrpc.RpcOpts{Timeout: 60000})
+	data := wshrpc.ConnExtData{
+		ConnName:   connName,
+		LogBlockId: RpcContext.BlockId,
+	}
+	err := wshclient.ConnReinstallWshCommand(RpcClient, data, &wshrpc.RpcOpts{Timeout: 60000})
 	if err != nil {
 		return fmt.Errorf("reinstalling connection: %w", err)
 	}
@@ -173,7 +177,11 @@ func connConnectRun(cmd *cobra.Command, args []string) error {
 	if err := validateConnectionName(connName); err != nil {
 		return err
 	}
-	err := wshclient.ConnConnectCommand(RpcClient, wshrpc.ConnRequest{Host: connName}, &wshrpc.RpcOpts{Timeout: 60000})
+	data := wshrpc.ConnRequest{
+		Host:       connName,
+		LogBlockId: RpcContext.BlockId,
+	}
+	err := wshclient.ConnConnectCommand(RpcClient, data, &wshrpc.RpcOpts{Timeout: 60000})
 	if err != nil {
 		return fmt.Errorf("connecting connection: %w", err)
 	}
@@ -186,7 +194,11 @@ func connEnsureRun(cmd *cobra.Command, args []string) error {
 	if err := validateConnectionName(connName); err != nil {
 		return err
 	}
-	err := wshclient.ConnEnsureCommand(RpcClient, connName, &wshrpc.RpcOpts{Timeout: 60000})
+	data := wshrpc.ConnExtData{
+		ConnName:   connName,
+		LogBlockId: RpcContext.BlockId,
+	}
+	err := wshclient.ConnEnsureCommand(RpcClient, data, &wshrpc.RpcOpts{Timeout: 60000})
 	if err != nil {
 		return fmt.Errorf("ensuring connection: %w", err)
 	}

cmd/wsh/cmd/wshcmd-ssh.go

@@ -39,7 +39,8 @@ func sshRun(cmd *cobra.Command, args []string) (rtnErr error) {
 	}
 	// first, make a connection independent of the block
 	connOpts := wshrpc.ConnRequest{
-		Host: sshArg,
+		Host:       sshArg,
+		LogBlockId: blockId,
 		Keywords: wshrpc.ConnKeywords{
 			SshIdentityFile: identityFiles,
 		},

frontend/app/block/blockframe.tsx

@@ -23,10 +23,10 @@ import {
     getSettingsKeyAtom,
     getUserName,
     globalStore,
-    refocusNode,
     useBlockAtom,
     WOS,
 } from "@/app/store/global";
+import { globalRefocusWithTimeout } from "@/app/store/keymodel";
 import { RpcApi } from "@/app/store/wshclientapi";
 import { TabRpcClient } from "@/app/store/wshrpcutil";
 import { ErrorBoundary } from "@/element/errorboundary";
@@ -356,7 +356,11 @@ const ConnStatusOverlay = React.memo(
         }, [width, connStatus, setShowError]);
 
         const handleTryReconnect = React.useCallback(() => {
-            const prtn = RpcApi.ConnConnectCommand(TabRpcClient, { host: connName }, { timeout: 60000 });
+            const prtn = RpcApi.ConnConnectCommand(
+                TabRpcClient,
+                { host: connName, logblockid: nodeModel.blockId },
+                { timeout: 60000 }
+            );
             prtn.catch((e) => console.log("error reconnecting", connName, e));
         }, [connName]);
 
@@ -541,7 +545,11 @@ const BlockFrame_Default_Component = (props: BlockFrameProps) => {
         const connName = blockData?.meta?.connection;
         if (!util.isBlank(connName)) {
             console.log("ensure conn", nodeModel.blockId, connName);
-            RpcApi.ConnEnsureCommand(TabRpcClient, connName, { timeout: 60000 }).catch((e) => {
+            RpcApi.ConnEnsureCommand(
+                TabRpcClient,
+                { connname: connName, logblockid: nodeModel.blockId },
+                { timeout: 60000 }
+            ).catch((e) => {
                 console.log("error ensuring connection", nodeModel.blockId, connName, e);
             });
         }
@@ -691,7 +699,11 @@ const ChangeConnectionBlockModal = React.memo(
                     meta: { connection: connName, file: newCwd },
                 });
                 try {
-                    await RpcApi.ConnEnsureCommand(TabRpcClient, connName, { timeout: 60000 });
+                    await RpcApi.ConnEnsureCommand(
+                        TabRpcClient,
+                        { connname: connName, logblockid: blockId },
+                        { timeout: 60000 }
+                    );
                 } catch (e) {
                     console.log("error connecting", blockId, connName, e);
                 }
@@ -756,7 +768,7 @@ const ChangeConnectionBlockModal = React.memo(
             onSelect: async (_: string) => {
                 const prtn = RpcApi.ConnConnectCommand(
                     TabRpcClient,
-                    { host: connStatus.connection },
+                    { host: connStatus.connection, logblockid: blockId },
                     { timeout: 60000 }
                 );
                 prtn.catch((e) => console.log("error reconnecting", connStatus.connection, e));
@@ -879,12 +891,13 @@ const ChangeConnectionBlockModal = React.memo(
                     } else {
                         changeConnection(rowItem.value);
                         globalStore.set(changeConnModalAtom, false);
+                        globalRefocusWithTimeout(10);
                     }
                 }
                 if (keyutil.checkKeyPressed(waveEvent, "Escape")) {
                     globalStore.set(changeConnModalAtom, false);
                     setConnSelected("");
-                    refocusNode(blockId);
+                    globalRefocusWithTimeout(10);
                     return true;
                 }
                 if (keyutil.checkKeyPressed(waveEvent, "ArrowUp")) {
@@ -916,6 +929,7 @@ const ChangeConnectionBlockModal = React.memo(
                 onSelect={(selected: string) => {
                     changeConnection(selected);
                     globalStore.set(changeConnModalAtom, false);
+                    globalRefocusWithTimeout(10);
                 }}
                 selectIndex={rowIndex}
                 autoFocus={isNodeFocused}

frontend/app/store/keymodel.ts

@@ -146,6 +146,12 @@ function handleCmdI() {
     globalRefocus();
 }
 
+function globalRefocusWithTimeout(timeoutVal: number) {
+    setTimeout(() => {
+        globalRefocus();
+    }, timeoutVal);
+}
+
 function globalRefocus() {
     const layoutModel = getLayoutModelForStaticTab();
     const focusedNode = globalStore.get(layoutModel.focusedNode);
@@ -403,6 +409,7 @@ export {
     getAllGlobalKeyBindings,
     getSimpleControlShiftAtom,
     globalRefocus,
+    globalRefocusWithTimeout,
     registerControlShiftStateUpdateHandler,
     registerElectronReinjectKeyHandler,
     registerGlobalKeys,

frontend/app/store/wshclientapi.ts

@@ -38,7 +38,7 @@ class RpcApiType {
     }
 
     // command "connensure" [call]
-    ConnEnsureCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
+    ConnEnsureCommand(client: WshClient, data: ConnExtData, opts?: RpcOpts): Promise<void> {
         return client.wshRpcCall("connensure", data, opts);
     }
 
@@ -48,7 +48,7 @@ class RpcApiType {
     }
 
     // command "connreinstallwsh" [call]
-    ConnReinstallWshCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
+    ConnReinstallWshCommand(client: WshClient, data: ConnExtData, opts?: RpcOpts): Promise<void> {
         return client.wshRpcCall("connreinstallwsh", data, opts);
     }
 
@@ -57,6 +57,11 @@ class RpcApiType {
         return client.wshRpcCall("connstatus", null, opts);
     }
 
+    // command "controllerappendoutput" [call]
+    ControllerAppendOutputCommand(client: WshClient, data: CommandControllerAppendOutputData, opts?: RpcOpts): Promise<void> {
+        return client.wshRpcCall("controllerappendoutput", data, opts);
+    }
+
     // command "controllerinput" [call]
     ControllerInputCommand(client: WshClient, data: CommandBlockInputData, opts?: RpcOpts): Promise<void> {
         return client.wshRpcCall("controllerinput", data, opts);

frontend/app/view/preview/preview.tsx

@@ -364,7 +364,7 @@ export class PreviewModel implements ViewModel {
         this.connection = atom<Promise<string>>(async (get) => {
             const connName = get(this.blockAtom)?.meta?.connection;
             try {
-                await RpcApi.ConnEnsureCommand(TabRpcClient, connName, { timeout: 60000 });
+                await RpcApi.ConnEnsureCommand(TabRpcClient, { connname: connName }, { timeout: 60000 });
                 globalStore.set(this.connectionError, "");
             } catch (e) {
                 globalStore.set(this.connectionError, e as string);

frontend/app/view/term/term.tsx

@@ -682,6 +682,45 @@ class TermViewModel implements ViewModel {
                 },
             });
         }
+        const debugConn = blockData?.meta?.["term:conndebug"];
+        fullMenu.push({
+            label: "Debug Connection",
+            submenu: [
+                {
+                    label: "Off",
+                    type: "checkbox",
+                    checked: !debugConn,
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "term:conndebug": null },
+                        });
+                    },
+                },
+                {
+                    label: "Info",
+                    type: "checkbox",
+                    checked: debugConn == "info",
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "term:conndebug": "info" },
+                        });
+                    },
+                },
+                {
+                    label: "Verbose",
+                    type: "checkbox",
+                    checked: debugConn == "debug",
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "term:conndebug": "debug" },
+                        });
+                    },
+                },
+            ],
+        });
         return fullMenu;
     }
 }

frontend/types/gotypes.d.ts

@@ -125,6 +125,12 @@ declare global {
         view: string;
     };
 
+    // wshrpc.CommandControllerAppendOutputData
+    type CommandControllerAppendOutputData = {
+        blockid: string;
+        data64: string;
+    };
+
     // wshrpc.CommandControllerResyncData
     type CommandControllerResyncData = {
         forcerestart?: boolean;
@@ -286,11 +292,18 @@ declare global {
         metamaptype: MetaType;
     };
 
+    // wshrpc.ConnExtData
+    type ConnExtData = {
+        connname: string;
+        logblockid?: string;
+    };
+
     // wshrpc.ConnKeywords
     type ConnKeywords = {
         "conn:wshenabled"?: boolean;
         "conn:askbeforewshinstall"?: boolean;
         "conn:overrideconfig"?: boolean;
+        "conn:wshpath"?: string;
         "display:hidden"?: boolean;
         "display:order"?: number;
         "term:*"?: boolean;
@@ -317,6 +330,7 @@ declare global {
     type ConnRequest = {
         host: string;
         keywords?: ConnKeywords;
+        logblockid?: string;
     };
 
     // wshrpc.ConnStatus
@@ -329,6 +343,8 @@ declare global {
         activeconnnum: number;
         error?: string;
         wsherror?: string;
+        nowshreason?: string;
+        wshversion?: string;
     };
 
     // wshrpc.CpuDataRequest
@@ -494,6 +510,7 @@ declare global {
         "term:vdomtoolbarblockid"?: string;
         "term:transparency"?: number;
         "term:allowbracketedpaste"?: boolean;
+        "term:conndebug"?: string;
         "web:zoom"?: number;
         "web:hidenav"?: boolean;
         "markdown:fontsize"?: number;

pkg/blockcontroller/blockcontroller.go

@@ -16,6 +16,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/wavetermdev/waveterm/pkg/blocklogger"
 	"github.com/wavetermdev/waveterm/pkg/filestore"
 	"github.com/wavetermdev/waveterm/pkg/panichandler"
 	"github.com/wavetermdev/waveterm/pkg/remote"
@@ -375,9 +376,7 @@ func (bc *BlockController) setupAndStartShellProcess(rc *RunShellOpts, blockMeta
 		} else {
 			shellProc, err = shellexec.StartRemoteShellProc(rc.TermSize, cmdStr, cmdOpts, conn)
 			if err != nil {
-				conn.WithLock(func() {
-					conn.WshError = err.Error()
-				})
+				conn.SetWshError(err)
 				conn.WshEnabled.Store(false)
 				log.Printf("error starting remote shell proc with wsh: %v", err)
 				log.Print("attempting install without wsh")
@@ -759,6 +758,13 @@ func getOrCreateBlockController(tabId string, blockId string, controllerName str
 	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")
@@ -769,6 +775,7 @@ func ResyncController(ctx context.Context, tabId string, blockId string, rtOpts
 	}
 	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, "")
@@ -784,8 +791,10 @@ func ResyncController(ctx context.Context, tabId string, blockId string, rtOpts
 	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