package api import ( "bufio" "context" "encoding/json" "errors" "fmt" "io" "net/http" "net/url" "strings" "sync" "time" "github.com/gin-gonic/gin" "github.com/gorilla/websocket" "github.com/kandev/kandev/internal/agentctl/server/process" "github.com/kandev/kandev/internal/agentctl/types" "github.com/kandev/kandev/internal/lsp/installer" "github.com/kandev/kandev/internal/lsp/protocol" tools "github.com/kandev/kandev/internal/tools/installer" "go.uber.org/zap" ) const ( lspCloseBinaryNotFound = 4001 lspCloseInstallFailed = 4003 lspCloseServerExited = 4006 lspCloseAutoInstallUnsupported = 4007 lspCloseStartFailed = 4008 lspLanguageTypeScript = "typescript" lspLanguagePython = "python" lspLanguageGo = "go" lspLanguageRust = "rust" lspLanguageKey = "language" lspStatusKey = "status" lspStatusInstalling = "installing" lspStatusInstalled = "installed" lspStatusInstallFailed = "install_failed" lspStatusReady = "ready" lspWorkspacePathJSONKey = "workspacePath" lspWorkspaceURIJSONKey = "workspaceUri" lspRepoSubpathsJSONKey = "repoSubpaths" lspStdinWriteTimeout = 30 * time.Second lspWebSocketWriteTimeout = 5 * time.Second ) var errLSPStdinWriteTimeout = errors.New("LSP stdin write timed out") type lspServerProcess struct { id string stdin io.WriteCloser stdout io.ReadCloser done <-chan struct{} // forwarderDone keeps caller-owned stdout open until its sole reader exits. forwarderDone <-chan struct{} } type lspClientRead struct { message []byte err error } type lspInstallerRegistry interface { BinaryPath(language string) (string, error) StrategyFor(language string) (tools.Strategy, error) } type lspInstallCoordinator struct { mu sync.Mutex active map[string]chan struct{} } func newLSPInstallCoordinator() *lspInstallCoordinator { return &lspInstallCoordinator{active: make(map[string]chan struct{})} } func (c *lspInstallCoordinator) run(ctx context.Context, key string, install func() (string, error)) (string, error) { for { if err := ctx.Err(); err != nil { return "", err } c.mu.Lock() wait, busy := c.active[key] if !busy { wait = make(chan struct{}) c.active[key] = wait c.mu.Unlock() defer c.release(key, wait) return install() } c.mu.Unlock() select { case <-wait: case <-ctx.Done(): return "", ctx.Err() } } } func (c *lspInstallCoordinator) release(key string, completed chan struct{}) { c.mu.Lock() if c.active[key] == completed { delete(c.active, key) close(completed) } c.mu.Unlock() } // lspInstallMutationKey groups installers by the files they can rewrite. // npm updates prefix-wide metadata, while Go and release installs only // collide when they publish the same binary target. func lspInstallMutationKey(language string) string { binary, _ := installer.LspCommand(language) switch language { case lspLanguageTypeScript, lspLanguagePython: return "npm-prefix" case lspLanguageGo: return "go:" + binary case lspLanguageRust: return "release:" + binary default: return "language:" + language } } var sharedLSPInstallCoordinator = newLSPInstallCoordinator() func (s *Server) handleLSPStreamWS(c *gin.Context) { language := c.Query("language") if language == "" { c.JSON(http.StatusBadRequest, gin.H{errKey: "language query parameter is required"}) return } if !installer.IsSupported(language) { c.JSON(http.StatusBadRequest, gin.H{errKey: fmt.Sprintf("unsupported language: %s", language)}) return } conn, err := s.upgrader.Upgrade(c.Writer, c.Request, nil) if err != nil { s.logger.Error("LSP: failed to upgrade WebSocket", zap.Error(err)) return } conn.SetReadLimit(protocol.MaxMessageBytes) binaryPath, err := s.lspInstaller.BinaryPath(language) if err != nil { autoInstall := lspAutoInstallRequested(c) if !installer.CanAutoInstall(language) { _ = writeLSPMessage(conn, websocket.CloseMessage, websocket.FormatCloseMessage( lspCloseAutoInstallUnsupported, "auto-install unsupported on task host", )) _ = conn.Close() return } s.handleLSPBinaryNotFound( c.Request.Context(), conn, language, autoInstall, err, ) return } s.handleLSPBridge(conn, language, binaryPath, nil) } func lspAutoInstallRequested(c *gin.Context) bool { value := c.Query("autoInstall") return value == "1" || strings.EqualFold(value, "true") } func (s *Server) handleLSPBinaryNotFound(ctx context.Context, conn *websocket.Conn, language string, autoInstall bool, binaryErr error) { if !autoInstall { _ = writeLSPMessage(conn, websocket.CloseMessage, websocket.FormatCloseMessage(lspCloseBinaryNotFound, binaryErr.Error())) _ = conn.Close() return } if err := writeLSPJSONMessage(conn, map[string]string{lspStatusKey: lspStatusInstalling, lspLanguageKey: language}); err != nil { s.logger.Warn("failed to send LSP installing status", zap.String("language", language), zap.Error(err)) _ = conn.Close() return } installCtx, cancelInstall := context.WithCancel(ctx) firstClientRead := readFirstLSPClientMessage(conn, cancelInstall) binaryPath, err := s.awaitOrInstallLSP(installCtx, language) cancelInstall() if err != nil { if errors.Is(err, context.Canceled) || errors.Is(err, process.ErrManagerStopping) { s.logger.Debug("LSP auto-install canceled", zap.String("language", language)) _ = writeLSPMessage(conn, websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseGoingAway, "")) _ = conn.Close() return } s.logger.Error("LSP auto-install failed", zap.String("language", language), zap.Error(err)) if writeErr := writeLSPJSONMessage(conn, map[string]string{lspStatusKey: lspStatusInstallFailed, lspLanguageKey: language, errKey: err.Error()}); writeErr != nil { s.logger.Warn("failed to send LSP install failure status", zap.String("language", language), zap.Error(writeErr)) } _ = writeLSPMessage(conn, websocket.CloseMessage, websocket.FormatCloseMessage(lspCloseInstallFailed, "install failed")) _ = conn.Close() return } if err := writeLSPJSONMessage(conn, map[string]string{lspStatusKey: lspStatusInstalled, lspLanguageKey: language}); err != nil { s.logger.Warn("failed to send LSP installed status", zap.String("language", language), zap.Error(err)) } s.handleLSPBridge(conn, language, binaryPath, firstClientRead) } func readFirstLSPClientMessage(conn *websocket.Conn, cancel context.CancelFunc) <-chan lspClientRead { result := make(chan lspClientRead, 1) go func() { _, message, err := conn.ReadMessage() cancel() result <- lspClientRead{message: message, err: err} }() return result } func (s *Server) handleLSPBridge( conn *websocket.Conn, language string, binaryPath string, firstClientRead <-chan lspClientRead, ) { server, err := s.startLSPServer(language, binaryPath) if err != nil { s.logger.Error("LSP: failed to start language server", zap.String("language", language), zap.Error(err)) _ = writeLSPMessage( conn, websocket.CloseMessage, websocket.FormatCloseMessage(lspCloseStartFailed, ""), ) _ = conn.Close() return } ready := map[string]any{ lspStatusKey: lspStatusReady, lspWorkspacePathJSONKey: s.cfg.WorkDir, lspWorkspaceURIJSONKey: workspaceFileURI(s.cfg.WorkDir), lspRepoSubpathsJSONKey: s.procMgr.RepoSubpaths(), } if err := writeLSPJSONMessage(conn, ready); err != nil { s.stopLSPServer(server) _ = conn.Close() return } s.runLSPBridge(conn, language, server, firstClientRead) } // workspaceFileURI converts the task host's native workspace path into the // canonical file URI consumed by both the language server and browser editor. // Detecting drive and UNC forms here keeps path semantics on the task host // instead of accidentally applying the browser machine's operating system. func workspaceFileURI(path string) string { normalized := path isDrivePath := len(path) >= 3 && path[1] == ':' && (path[2] == '\\' || path[2] == '/') isUNCPath := strings.HasPrefix(path, `\\`) if isDrivePath || isUNCPath { normalized = strings.ReplaceAll(path, `\`, "/") } if strings.HasPrefix(normalized, "//") { parts := strings.Split(strings.TrimPrefix(normalized, "//"), "/") if len(parts) >= 2 && parts[0] != "" { return strictFileURL(parts[0], "/"+strings.Join(parts[1:], "/"), false) } } isDriveURI := len(normalized) >= 3 && normalized[1] == ':' && normalized[2] == '/' if isDriveURI { normalized = "/" + normalized } return strictFileURL("", normalized, isDriveURI) } func strictFileURL(host, filePath string, preserveDriveColon bool) string { segments := strings.Split(filePath, "/") encoded := make([]string, len(segments)) for i, segment := range segments { encoded[i] = strictURISegment(segment) } if preserveDriveColon && len(segments) > 1 { encoded[1] = segments[1] } return (&url.URL{ Scheme: "file", Host: host, Path: filePath, RawPath: strings.Join(encoded, "/"), }).String() } func strictURISegment(segment string) string { const hex = "0123456789ABCDEF" var encoded strings.Builder for _, value := range []byte(segment) { if (value >= 'a' && value <= 'z') || (value >= 'A' && value <= 'Z') || (value >= '0' && value <= '9') || strings.ContainsRune("-._~", rune(value)) { encoded.WriteByte(value) continue } encoded.WriteByte('%') encoded.WriteByte(hex[value>>4]) encoded.WriteByte(hex[value&0x0f]) } return encoded.String() } func (s *Server) startLSPServer(language, binaryPath string) (*lspServerProcess, error) { binary, args := installer.LspCommand(language) if binaryPath != "" { binary = binaryPath } sessionID := s.cfg.SessionID if sessionID == "" { sessionID = s.cfg.InstanceID } if sessionID == "" { sessionID = "lsp" } proc, err := s.procMgr.StartPipedProcess(process.PipedStartRequest{ SessionID: sessionID, Kind: types.ProcessKindCustom, ScriptName: "lsp-" + language, Command: binary, Args: args, WorkingDir: s.cfg.WorkDir, }) if err != nil { return nil, fmt.Errorf("failed to start %s: %w", binary, err) } return &lspServerProcess{id: proc.ID, stdin: proc.Stdin, stdout: proc.Stdout, done: proc.Done}, nil } func (s *Server) stopLSPServer(server *lspServerProcess) { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() s.stopLSPServerWithContext(ctx, server) } func (s *Server) stopLSPServerWithContext(ctx context.Context, server *lspServerProcess) { _ = server.stdin.Close() if err := s.procMgr.StopProcess(ctx, process.StopProcessRequest{ProcessID: server.id}); err != nil { s.logger.Debug("LSP process already stopped", zap.String("process_id", server.id), zap.Error(err)) } timedOut := false select { case <-server.done: case <-ctx.Done(): timedOut = true s.logger.Warn("timed out waiting for LSP process teardown", zap.String("process_id", server.id)) } if timedOut { _ = server.stdout.Close() } if server.forwarderDone != nil { <-server.forwarderDone } if !timedOut { _ = server.stdout.Close() } } func (s *Server) runLSPBridge( conn *websocket.Conn, language string, server *lspServerProcess, firstClientRead <-chan lspClientRead, ) { done := make(chan struct{}) server.forwarderDone = done go func() { defer close(done) defer func() { _ = conn.Close() }() defer func() { _ = server.stdin.Close() }() reader := bufio.NewReader(server.stdout) for { msg, err := protocol.ReadMessage(reader) if err != nil { if err != io.EOF { s.logger.Debug("LSP stdout read error", zap.String("language", language), zap.Error(err)) } _ = writeLSPMessage( conn, websocket.CloseMessage, websocket.FormatCloseMessage(lspCloseServerExited, ""), ) return } if wErr := writeLSPMessage(conn, websocket.TextMessage, msg); wErr != nil { s.logger.Debug("LSP WebSocket write error", zap.String("language", language), zap.Error(wErr)) return } } }() for { var msg []byte var err error if firstClientRead != nil { result := <-firstClientRead firstClientRead = nil msg, err = result.message, result.err } else { _, msg, err = conn.ReadMessage() } if err != nil { if !websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) { s.logger.Debug("LSP WebSocket read error", zap.String("language", language), zap.Error(err)) } break } if err := writeLSPStdinFrame(server.stdin, msg); err != nil { s.logger.Debug("LSP stdin write error", zap.String("language", language), zap.Error(err)) break } } _ = conn.Close() s.stopLSPServer(server) } func writeLSPStdinFrame(stdin io.WriteCloser, msg []byte) error { header := fmt.Sprintf("Content-Length: %d\r\n\r\n", len(msg)) frame := make([]byte, 0, len(header)+len(msg)) frame = append(frame, header...) frame = append(frame, msg...) return writeLSPStdinWithTimeout(stdin, frame, lspStdinWriteTimeout) } func writeLSPStdinWithTimeout(stdin io.WriteCloser, data []byte, timeout time.Duration) error { closeResult := make(chan error, 1) timer := time.AfterFunc(timeout, func() { closeResult <- stdin.Close() }) written, writeErr := stdin.Write(data) if !timer.Stop() { return errors.Join(errLSPStdinWriteTimeout, writeErr, <-closeResult) } if writeErr != nil { return writeErr } if written != len(data) { return io.ErrShortWrite } return nil } func writeLSPMessage(conn *websocket.Conn, messageType int, data []byte) error { if err := conn.SetWriteDeadline(time.Now().Add(lspWebSocketWriteTimeout)); err != nil { return err } return conn.WriteMessage(messageType, data) } func (s *Server) awaitOrInstallLSP(ctx context.Context, language string) (string, error) { installCtx, release, err := s.procMgr.BeginOwnedOperation(ctx) if err != nil { return "", err } defer release() return sharedLSPInstallCoordinator.run(installCtx, lspInstallMutationKey(language), func() (string, error) { if binaryPath, err := s.lspInstaller.BinaryPath(language); err == nil { return binaryPath, nil } strategy, err := s.lspInstaller.StrategyFor(language) if err != nil { return "", err } result, err := strategy.Install(installCtx) if err != nil { return "", err } return result.BinaryPath, nil }) } func writeLSPJSONMessage(conn *websocket.Conn, data any) error { msg, err := json.Marshal(data) if err != nil { return err } return writeLSPMessage(conn, websocket.TextMessage, msg) }