fix all panichandlers for the new format (inline recover())

cmd/server/main-server.go

@@ -120,7 +120,9 @@ func panicTelemetryHandler() {
 }
 
 func sendTelemetryWrapper() {
-	defer panichandler.PanicHandler("sendTelemetryWrapper")
+	defer func() {
+		panichandler.PanicHandler("sendTelemetryWrapper", recover())
+	}()
 	ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancelFn()
 	beforeSendActivityUpdate(ctx)
@@ -270,7 +272,9 @@ func main() {
 	}
 	panichandler.PanicTelemetryHandler = panicTelemetryHandler
 	go func() {
-		defer panichandler.PanicHandler("InitCustomShellStartupFiles")
+		defer func() {
+			panichandler.PanicHandler("InitCustomShellStartupFiles", recover())
+		}()
 		err := shellutil.InitCustomShellStartupFiles()
 		if err != nil {
 			log.Printf("error initializing wsh and shell-integration files: %v\n", err)

cmd/wsh/cmd/wshcmd-connserver.go

@@ -60,15 +60,19 @@ func handleNewListenerConn(conn net.Conn, router *wshutil.WshRouter) {
 	var routeIdContainer atomic.Pointer[string]
 	proxy := wshutil.MakeRpcProxy()
 	go func() {
-		defer panichandler.PanicHandler("handleNewListenerConn:AdaptOutputChToStream")
+		defer func() {
+			panichandler.PanicHandler("handleNewListenerConn:AdaptOutputChToStream", recover())
+		}()
 		writeErr := wshutil.AdaptOutputChToStream(proxy.ToRemoteCh, conn)
 		if writeErr != nil {
 			log.Printf("error writing to domain socket: %v\n", writeErr)
 		}
 	}()
 	go func() {
 		// when input is closed, close the connection
-		defer panichandler.PanicHandler("handleNewListenerConn:AdaptStreamToMsgCh")
+		defer func() {
+			panichandler.PanicHandler("handleNewListenerConn:AdaptStreamToMsgCh", recover())
+		}()
 		defer func() {
 			conn.Close()
 			routeIdPtr := routeIdContainer.Load()
@@ -145,7 +149,9 @@ func serverRunRouter() error {
 	rawCh := make(chan []byte, wshutil.DefaultOutputChSize)
 	go packetparser.Parse(os.Stdin, termProxy.FromRemoteCh, rawCh)
 	go func() {
-		defer panichandler.PanicHandler("serverRunRouter:WritePackets")
+		defer func() {
+			panichandler.PanicHandler("serverRunRouter:WritePackets", recover())
+		}()
 		for msg := range termProxy.ToRemoteCh {
 			packetparser.WritePacket(os.Stdout, msg)
 		}

pkg/blockcontroller/blockcontroller.go

@@ -426,7 +426,9 @@ func (bc *BlockController) DoRunShellCommand(rc *RunShellOpts, blockMeta waveobj
 	ptyBuffer := wshutil.MakePtyBuffer(wshutil.WaveOSCPrefix, shellProc.Cmd, wshProxy.FromRemoteCh)
 	go func() {
 		// handles regular output from the pty (goes to the blockfile and xterm)
-		defer panichandler.PanicHandler("blockcontroller:shellproc-pty-read-loop")
+		defer func() {
+			panichandler.PanicHandler("blockcontroller:shellproc-pty-read-loop", recover())
+		}()
 		defer func() {
 			log.Printf("[shellproc] pty-read loop done\n")
 			shellProc.Close()
@@ -463,7 +465,9 @@ func (bc *BlockController) DoRunShellCommand(rc *RunShellOpts, blockMeta waveobj
 	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 panichandler.PanicHandler("blockcontroller:shellproc-input-loop")
+		defer func() {
+			panichandler.PanicHandler("blockcontroller:shellproc-input-loop", recover())
+		}()
 		for ic := range shellInputCh {
 			if len(ic.InputData) > 0 {
 				shellProc.Cmd.Write(ic.InputData)
@@ -481,7 +485,9 @@ func (bc *BlockController) DoRunShellCommand(rc *RunShellOpts, blockMeta waveobj
 		}
 	}()
 	go func() {
-		defer panichandler.PanicHandler("blockcontroller:shellproc-output-loop")
+		defer func() {
+			panichandler.PanicHandler("blockcontroller:shellproc-output-loop", recover())
+		}()
 		// handles outputCh -> shellInputCh
 		for msg := range wshProxy.ToRemoteCh {
 			encodedMsg, err := wshutil.EncodeWaveOSCBytes(wshutil.WaveServerOSC, msg)
@@ -492,7 +498,9 @@ func (bc *BlockController) DoRunShellCommand(rc *RunShellOpts, blockMeta waveobj
 		}
 	}()
 	go func() {
-		defer panichandler.PanicHandler("blockcontroller:shellproc-wait-loop")
+		defer func() {
+			panichandler.PanicHandler("blockcontroller:shellproc-wait-loop", recover())
+		}()
 		// wait for the shell to finish
 		var exitCode int
 		defer func() {
@@ -631,7 +639,9 @@ func (bc *BlockController) run(bdata *waveobj.Block, blockMeta map[string]any, r
 		}
 		runningShellCommand = true
 		go func() {
-			defer panichandler.PanicHandler("blockcontroller:run-shell-command")
+			defer func() {
+				panichandler.PanicHandler("blockcontroller:run-shell-command", recover())
+			}()
 			defer bc.UnlockRunLock()
 			var termSize waveobj.TermSize
 			if rtOpts != nil {

pkg/filestore/blockstore.go

@@ -514,7 +514,9 @@ func (s *FileStore) runFlushWithNewContext() (FlushStats, error) {
 }
 
 func (s *FileStore) runFlusher() {
-	defer panichandler.PanicHandler("filestore flusher")
+	defer func() {
+		panichandler.PanicHandler("filestore flusher", recover())
+	}()
 	for {
 		stats, err := s.runFlushWithNewContext()
 		if err != nil || stats.NumDirtyEntries > 0 {

pkg/panichandler/panichandler.go

@@ -13,31 +13,29 @@ import (
 // gets around import cycles
 var PanicTelemetryHandler func()
 
-func PanicHandlerNoTelemetry(debugStr string) {
-	r := recover()
-	if r == nil {
+func PanicHandlerNoTelemetry(debugStr string, recoverVal any) {
+	if recoverVal == nil {
 		return
 	}
-	log.Printf("[panic] in %s: %v\n", debugStr, r)
+	log.Printf("[panic] in %s: %v\n", debugStr, recoverVal)
 	debug.PrintStack()
 }
 
 // returns an error (wrapping the panic) if a panic occurred
-func PanicHandler(debugStr string) error {
-	r := recover()
-	if r == nil {
+func PanicHandler(debugStr string, recoverVal any) error {
+	if recoverVal == nil {
 		return nil
 	}
-	log.Printf("[panic] in %s: %v\n", debugStr, r)
+	log.Printf("[panic] in %s: %v\n", debugStr, recoverVal)
 	debug.PrintStack()
 	if PanicTelemetryHandler != nil {
 		go func() {
-			defer PanicHandlerNoTelemetry("PanicTelemetryHandler")
+			defer PanicHandlerNoTelemetry("PanicTelemetryHandler", recover())
 			PanicTelemetryHandler()
 		}()
 	}
-	if err, ok := r.(error); ok {
+	if err, ok := recoverVal.(error); ok {
 		return fmt.Errorf("panic in %s: %w", debugStr, err)
 	}
-	return fmt.Errorf("panic in %s: %v", debugStr, r)
+	return fmt.Errorf("panic in %s: %v", debugStr, recoverVal)
 }

pkg/remote/conncontroller/conncontroller.go

@@ -198,7 +198,9 @@ func (conn *SSHConn) OpenDomainSocketListener() error {
 		conn.DomainSockListener = listener
 	})
 	go func() {
-		defer panichandler.PanicHandler("conncontroller:OpenDomainSocketListener")
+		defer func() {
+			panichandler.PanicHandler("conncontroller:OpenDomainSocketListener", recover())
+		}()
 		defer conn.WithLock(func() {
 			conn.DomainSockListener = nil
 			conn.SockName = ""
@@ -258,7 +260,9 @@ func (conn *SSHConn) StartConnServer() error {
 	})
 	// service the I/O
 	go func() {
-		defer panichandler.PanicHandler("conncontroller:sshSession.Wait")
+		defer func() {
+			panichandler.PanicHandler("conncontroller:sshSession.Wait", recover())
+		}()
 		// wait for termination, clear the controller
 		defer conn.WithLock(func() {
 			conn.ConnController = nil
@@ -267,7 +271,9 @@ func (conn *SSHConn) StartConnServer() error {
 		log.Printf("conn controller (%q) terminated: %v", conn.GetName(), waitErr)
 	}()
 	go func() {
-		defer panichandler.PanicHandler("conncontroller:sshSession-output")
+		defer func() {
+			panichandler.PanicHandler("conncontroller:sshSession-output", recover())
+		}()
 		readErr := wshutil.StreamToLines(pipeRead, func(line []byte) {
 			lineStr := string(line)
 			if !strings.HasSuffix(lineStr, "\n") {

pkg/remote/connutil.go

@@ -274,7 +274,9 @@ func CpHostToRemote(client *ssh.Client, sourcePath string, destPath string) erro
 	}
 
 	go func() {
-		defer panichandler.PanicHandler("connutil:CpHostToRemote")
+		defer func() {
+			panichandler.PanicHandler("connutil:CpHostToRemote", recover())
+		}()
 		io.Copy(installStdin, input)
 		session.Close() // this allows the command to complete for reasons i don't fully understand
 	}()

pkg/remote/sshclient.go

@@ -720,9 +720,9 @@ func ConnectToClient(connCtx context.Context, opts *SSHOpts, currentClient *ssh.
 // when given unexpected strings
 func findSshConfigKeywords(hostPattern string) (connKeywords *wshrpc.ConnKeywords, outErr error) {
 	defer func() {
-		err := panichandler.PanicHandler("sshclient:find-ssh-config-keywords")
-		if err != nil {
-			outErr = err
+		panicErr := panichandler.PanicHandler("sshclient:find-ssh-config-keywords", recover())
+		if panicErr != nil {
+			outErr = panicErr
 		}
 	}()
 	WaveSshConfigUserSettings().ReloadConfigs()

pkg/service/windowservice/windowservice.go

@@ -151,7 +151,9 @@ func (svc *WindowService) SwitchWorkspace(ctx context.Context, windowId string,
 
 	updates := waveobj.ContextGetUpdatesRtn(ctx)
 	go func() {
-		defer panichandler.PanicHandler("WindowService:SwitchWorkspace:SendUpdateEvents")
+		defer func() {
+			panichandler.PanicHandler("WindowService:SwitchWorkspace:SendUpdateEvents", recover())
+		}()
 		wps.Broker.SendUpdateEvents(updates)
 	}()
 	return ws, err

pkg/service/workspaceservice/workspaceservice.go

@@ -59,7 +59,9 @@ func (svc *WorkspaceService) UpdateWorkspace(ctx context.Context, workspaceId st
 
 	updates := waveobj.ContextGetUpdatesRtn(ctx)
 	go func() {
-		defer panichandler.PanicHandler("WorkspaceService:UpdateWorkspace:SendUpdateEvents")
+		defer func() {
+			panichandler.PanicHandler("WorkspaceService:UpdateWorkspace:SendUpdateEvents", recover())
+		}()
 		wps.Broker.SendUpdateEvents(updates)
 	}()
 	return updates, nil
@@ -104,7 +106,9 @@ func (svc *WorkspaceService) DeleteWorkspace(workspaceId string) (waveobj.Update
 	}
 	updates := waveobj.ContextGetUpdatesRtn(ctx)
 	go func() {
-		defer panichandler.PanicHandler("WorkspaceService:DeleteWorkspace:SendUpdateEvents")
+		defer func() {
+			panichandler.PanicHandler("WorkspaceService:DeleteWorkspace:SendUpdateEvents", recover())
+		}()
 		wps.Broker.SendUpdateEvents(updates)
 	}()
 	return updates, claimableWorkspace, nil
@@ -153,7 +157,9 @@ func (svc *WorkspaceService) CreateTab(workspaceId string, tabName string, activ
 	}
 	updates := waveobj.ContextGetUpdatesRtn(ctx)
 	go func() {
-		defer panichandler.PanicHandler("WorkspaceService:CreateTab:SendUpdateEvents")
+		defer func() {
+			panichandler.PanicHandler("WorkspaceService:CreateTab:SendUpdateEvents", recover())
+		}()
 		wps.Broker.SendUpdateEvents(updates)
 	}()
 	return tabId, updates, nil
@@ -174,7 +180,9 @@ func (svc *WorkspaceService) ChangeTabPinning(ctx context.Context, workspaceId s
 	}
 	updates := waveobj.ContextGetUpdatesRtn(ctx)
 	go func() {
-		defer panichandler.PanicHandler("WorkspaceService:ChangeTabPinning:SendUpdateEvents")
+		defer func() {
+			panichandler.PanicHandler("WorkspaceService:ChangeTabPinning:SendUpdateEvents", recover())
+		}()
 		wps.Broker.SendUpdateEvents(updates)
 	}()
 	return updates, nil
@@ -224,7 +232,9 @@ func (svc *WorkspaceService) SetActiveTab(workspaceId string, tabId string) (wav
 	}
 	updates := waveobj.ContextGetUpdatesRtn(ctx)
 	go func() {
-		defer panichandler.PanicHandler("WorkspaceService:SetActiveTab:SendUpdateEvents")
+		defer func() {
+			panichandler.PanicHandler("WorkspaceService:SetActiveTab:SendUpdateEvents", recover())
+		}()
 		wps.Broker.SendUpdateEvents(updates)
 	}()
 	var extraUpdates waveobj.UpdatesRtnType
@@ -270,7 +280,9 @@ func (svc *WorkspaceService) CloseTab(ctx context.Context, workspaceId string, t
 	}
 	updates := waveobj.ContextGetUpdatesRtn(ctx)
 	go func() {
-		defer panichandler.PanicHandler("WorkspaceService:CloseTab:SendUpdateEvents")
+		defer func() {
+			panichandler.PanicHandler("WorkspaceService:CloseTab:SendUpdateEvents", recover())
+		}()
 		wps.Broker.SendUpdateEvents(updates)
 	}()
 	return rtn, updates, nil

pkg/shellexec/conninterface.go

@@ -76,7 +76,9 @@ func (cw CmdWrap) KillGraceful(timeout time.Duration) {
 		cw.Cmd.Process.Signal(syscall.SIGTERM)
 	}
 	go func() {
-		defer panichandler.PanicHandler("KillGraceful:Kill")
+		defer func() {
+			panichandler.PanicHandler("KillGraceful:Kill", recover())
+		}()
 		time.Sleep(timeout)
 		if cw.Cmd.ProcessState == nil || !cw.Cmd.ProcessState.Exited() {
 			cw.Cmd.Process.Kill() // force kill if it is already not exited
@@ -208,7 +210,9 @@ func (wcw WslCmdWrap) KillGraceful(timeout time.Duration) {
 	}
 	process.Signal(os.Interrupt)
 	go func() {
-		defer panichandler.PanicHandler("KillGraceful-wsl:Kill")
+		defer func() {
+			panichandler.PanicHandler("KillGraceful-wsl:Kill", recover())
+		}()
 		time.Sleep(timeout)
 		process := wcw.WslCmd.GetProcess()
 		processState := wcw.WslCmd.GetProcessState()

pkg/shellexec/shellexec.go

@@ -52,7 +52,9 @@ type ShellProc struct {
 func (sp *ShellProc) Close() {
 	sp.Cmd.KillGraceful(DefaultGracefulKillWait)
 	go func() {
-		defer panichandler.PanicHandler("ShellProc.Close")
+		defer func() {
+			panichandler.PanicHandler("ShellProc.Close", recover())
+		}()
 		waitErr := sp.Cmd.Wait()
 		sp.SetWaitErrorAndSignalDone(waitErr)
 
@@ -496,7 +498,7 @@ func RunSimpleCmdInPty(ecmd *exec.Cmd, termSize waveobj.TermSize) ([]byte, error
 	ioDone := make(chan bool)
 	var outputBuf bytes.Buffer
 	go func() {
-		panichandler.PanicHandler("RunSimpleCmdInPty:ioCopy")
+		panichandler.PanicHandler("RunSimpleCmdInPty:ioCopy", recover())
 		// ignore error (/dev/ptmx has read error when process is done)
 		defer close(ioDone)
 		io.Copy(&outputBuf, cmdPty)

pkg/telemetry/telemetry.go

@@ -83,7 +83,7 @@ func AutoUpdateChannel() string {
 // Wraps UpdateCurrentActivity, spawns goroutine, and logs errors
 func GoUpdateActivityWrap(update wshrpc.ActivityUpdate, debugStr string) {
 	go func() {
-		defer panichandler.PanicHandlerNoTelemetry("GoUpdateActivityWrap")
+		defer panichandler.PanicHandlerNoTelemetry("GoUpdateActivityWrap", recover())
 		ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancelFn()
 		err := UpdateActivity(ctx, update)

pkg/waveai/anthropicbackend.go

@@ -114,7 +114,7 @@ func (AnthropicBackend) StreamCompletion(ctx context.Context, request wshrpc.Wav
 
 	go func() {
 		defer func() {
-			panicErr := panichandler.PanicHandler("AnthropicBackend.StreamCompletion")
+			panicErr := panichandler.PanicHandler("AnthropicBackend.StreamCompletion", recover())
 			if panicErr != nil {
 				rtn <- makeAIError(panicErr)
 			}

pkg/waveai/cloudbackend.go

@@ -44,7 +44,7 @@ func (WaveAICloudBackend) StreamCompletion(ctx context.Context, request wshrpc.W
 	wsEndpoint := wcloud.GetWSEndpoint()
 	go func() {
 		defer func() {
-			panicErr := panichandler.PanicHandler("WaveAICloudBackend.StreamCompletion")
+			panicErr := panichandler.PanicHandler("WaveAICloudBackend.StreamCompletion", recover())
 			if panicErr != nil {
 				rtn <- makeAIError(panicErr)
 			}

pkg/waveai/openaibackend.go

@@ -65,7 +65,7 @@ func (OpenAIBackend) StreamCompletion(ctx context.Context, request wshrpc.WaveAI
 	rtn := make(chan wshrpc.RespOrErrorUnion[wshrpc.WaveAIPacketType])
 	go func() {
 		defer func() {
-			panicErr := panichandler.PanicHandler("OpenAIBackend.StreamCompletion")
+			panicErr := panichandler.PanicHandler("OpenAIBackend.StreamCompletion", recover())
 			if panicErr != nil {
 				rtn <- makeAIError(panicErr)
 			}

pkg/waveai/perplexitybackend.go

@@ -54,7 +54,7 @@ func (PerplexityBackend) StreamCompletion(ctx context.Context, request wshrpc.Wa
 
 	go func() {
 		defer func() {
-			panicErr := panichandler.PanicHandler("PerplexityBackend.StreamCompletion")
+			panicErr := panichandler.PanicHandler("PerplexityBackend.StreamCompletion", recover())
 			if panicErr != nil {
 				rtn <- makeAIError(panicErr)
 			}