Exit LSP process if parent process stops existing (#2478)

Author: jakebailey

cmd/tsgo/isprocessalive_other.go

@@ -0,0 +1,10 @@
+//go:build !unix && !windows
+
+package main
+
+// isProcessAlive on unsupported platforms always returns true,
+// meaning the watchdog will never fire. This is safe: the server
+// simply won't detect a dead parent on these platforms.
+func isProcessAlive(pid int) bool {
+	return true
+}

cmd/tsgo/isprocessalive_unix.go

@@ -0,0 +1,23 @@
+//go:build unix
+
+package main
+
+import (
+	"errors"
+	"os"
+	"syscall"
+)
+
+// isProcessAlive checks if a process with the given PID is still running.
+// On Unix, FindProcess always succeeds, so we send signal 0 to probe the
+// process. If the signal returns nil or EPERM, the process exists (EPERM
+// means it exists but we lack permission to signal it). ESRCH or any
+// other error indicates the process is gone.
+func isProcessAlive(pid int) bool {
+	proc, err := os.FindProcess(pid)
+	if err != nil {
+		return false
+	}
+	err = proc.Signal(syscall.Signal(0))
+	return err == nil || errors.Is(err, syscall.EPERM)
+}

cmd/tsgo/isprocessalive_windows.go

@@ -0,0 +1,24 @@
+//go:build windows
+
+package main
+
+import "syscall"
+
+// isProcessAlive checks if a process with the given PID is still running.
+// On Windows, we open the process with SYNCHRONIZE access and use
+// WaitForSingleObject with a zero timeout. If the wait times out, the
+// process is still running. If the object is signaled, it has exited.
+func isProcessAlive(pid int) bool {
+	const SYNCHRONIZE = 0x00100000
+	handle, err := syscall.OpenProcess(SYNCHRONIZE, false, uint32(pid))
+	if err != nil {
+		return false
+	}
+	defer func() { _ = syscall.CloseHandle(handle) }()
+	ret, err := syscall.WaitForSingleObject(handle, 0)
+	if err != nil {
+		return false
+	}
+	const WAIT_TIMEOUT = 258
+	return ret == WAIT_TIMEOUT
+}

cmd/tsgo/lsp.go

@@ -44,6 +44,9 @@ func runLSP(args []string) int {
 	defaultLibraryPath := bundled.LibPath()
 	typingsLocation := osvfs.GetGlobalTypingsCacheLocation()
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
 	s := lsp.NewServer(&lsp.ServerOptions{
 		In:                 lsp.ToReader(os.Stdin),
 		Out:                lsp.ToWriter(os.Stdout),
@@ -58,14 +61,39 @@ func runLSP(args []string) int {
 			return cmd.Output()
 		},
 		ProgressDelay: 250 * time.Millisecond,
+		SetParentProcessID: func(parentPID int) {
+			startParentProcessWatchdog(ctx, stop, parentPID)
+		},
 	})
 
-	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
-	defer stop()
-
 	if err := s.Run(ctx); err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return 1
 	}
 	return 0
 }
+
+// startParentProcessWatchdog starts a goroutine that monitors the parent process
+// and cancels the context if the parent dies. This prevents orphaned language
+// server processes when the editor crashes or is killed.
+func startParentProcessWatchdog(ctx context.Context, stop context.CancelFunc, parentPID int) {
+	if parentPID <= 0 {
+		return
+	}
+	go func() {
+		ticker := time.NewTicker(5 * time.Second)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				if !isProcessAlive(parentPID) {
+					fmt.Fprintf(os.Stderr, "Parent process %d has exited, shutting down.\n", parentPID)
+					stop()
+					return
+				}
+			}
+		}
+	}()
+}

internal/lsp/server.go

@@ -45,6 +45,7 @@ type ServerOptions struct {
 	ParseCache         *project.ParseCache
 	NpmInstall         func(cwd string, args []string) ([]byte, error)
 	ProgressDelay      time.Duration // delay before showing progress UI; 0 means no delay
+	SetParentProcessID func(parentPID int)
 }
 
 func NewServer(opts *ServerOptions) *Server {
@@ -66,6 +67,7 @@ func NewServer(opts *ServerOptions) *Server {
 		typingsLocation:       opts.TypingsLocation,
 		parseCache:            opts.ParseCache,
 		npmInstall:            opts.NpmInstall,
+		startWatchdog:         opts.SetParentProcessID,
 		initComplete:          make(chan struct{}),
 		progressDelay:         opts.ProgressDelay,
 	}
@@ -204,6 +206,8 @@ type Server struct {
 
 	progressDelay   time.Duration
 	projectProgress *projectLoadingProgress
+
+	startWatchdog func(parentPID int)
 }
 
 func (s *Server) Session() *project.Session { return s.session }
@@ -1011,6 +1015,10 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ
 		s.logger.SetVerbose(true)
 	}
 
+	if s.startWatchdog != nil && params.ProcessId.Integer != nil {
+		s.startWatchdog(int(*params.ProcessId.Integer))
+	}
+
 	response := &lsproto.InitializeResult{
 		ServerInfo: &lsproto.ServerInfo{
 			Name:    "typescript-go",