ttsc 0.10.2 → 0.11.0-dev.20260517

package/cmd/ttscserver/main.go

@@ -0,0 +1,154 @@
+// Command ttscserver is the Go LSP host shipped by ttsc. It embeds
+// TypeScript-Go's LSP server unmodified and proxies traffic between the
+// editor and that server, splicing ttsc-plugin diagnostics, code actions,
+// and ttsc-owned executeCommand handling into the same stream.
+//
+// The JavaScript launcher (`packages/ttsc/src/launcher/ttscserver.ts`)
+// resolves the native binary and forwards stdio so editors can spawn
+// `ttscserver --stdio` without worrying about platform helper packages.
+//
+// Everything here is deliberately small: flag parsing, version metadata,
+// and a single delegation to driver.RunLSPServer.
+package main
+
+import (
+  "context"
+  "errors"
+  "flag"
+  "fmt"
+  "io"
+  "os"
+  "os/signal"
+  "runtime"
+  "strings"
+  "syscall"
+  "time"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// Build metadata; overwritten via -ldflags in release builds.
+var (
+  version = "0.0.0-dev"
+  commit  = "dev"
+  date    = "unknown"
+)
+
+// Package-level writers so command tests can capture output without
+// patching os.Stdout / os.Stderr globally.
+var (
+  stdout io.Writer = os.Stdout
+  stderr io.Writer = os.Stderr
+  stdin  io.Reader = os.Stdin
+)
+
+// runLSPServer is the seam command tests use to substitute a fake LSP
+// host. Production wires it to driver.RunLSPServer.
+var runLSPServer = driver.RunLSPServer
+
+// notifyContext is the seam command tests use to substitute a
+// deterministic context (no signal hookup) for the signal-aware default.
+var notifyContext = signal.NotifyContext
+
+// getwd is the seam command tests use to simulate os.Getwd failures
+// (deleted working directory, sandbox restrictions, etc.) without
+// modifying the test process cwd.
+var getwd = os.Getwd
+
+func main() {
+  os.Exit(run(os.Args[1:]))
+}
+
+func run(args []string) int {
+  if len(args) == 0 {
+    printHelp(stdout)
+    return 0
+  }
+  switch args[0] {
+  case "-h", "--help", "help":
+    printHelp(stdout)
+    return 0
+  case "-v", "--version", "version":
+    printVersion(stdout)
+    return 0
+  }
+  return runLSP(args)
+}
+
+func runLSP(args []string) int {
+  fs := flag.NewFlagSet("ttscserver", flag.ContinueOnError)
+  fs.SetOutput(stderr)
+  stdioFlag := fs.Bool("stdio", false, "communicate with the editor over stdin/stdout")
+  cwdFlag := fs.String("cwd", "", "project root (defaults to process cwd)")
+  progressDelayFlag := fs.Duration("progress-delay", 250*time.Millisecond, "delay before showing tsgo's progress UI")
+  if err := fs.Parse(args); err != nil {
+    return 2
+  }
+  if !*stdioFlag {
+    fmt.Fprintln(stderr, "ttscserver: only --stdio transport is supported")
+    return 2
+  }
+
+  cwd := strings.TrimSpace(*cwdFlag)
+  if cwd == "" {
+    resolved, err := getwd()
+    if err != nil {
+      fmt.Fprintf(stderr, "ttscserver: could not resolve working directory: %v\n", err)
+      return 2
+    }
+    cwd = resolved
+  }
+
+  ctx, stop := notifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+  defer stop()
+
+  err := runLSPServer(ctx, driver.LSPServerOptions{
+    In:            stdin,
+    Out:           stdout,
+    Err:           stderr,
+    Cwd:           cwd,
+    Source:        driver.NullPluginSource{},
+    ProgressDelay: *progressDelayFlag,
+  })
+  if err != nil && !errors.Is(err, context.Canceled) {
+    fmt.Fprintf(stderr, "ttscserver: %v\n", err)
+    return 1
+  }
+  return 0
+}
+
+func printVersion(w io.Writer) {
+  fmt.Fprintf(
+    w,
+    "ttscserver %s (commit %s, built %s, %s/%s, go %s)\n",
+    version,
+    commit,
+    date,
+    runtime.GOOS,
+    runtime.GOARCH,
+    runtime.Version(),
+  )
+}
+
+func printHelp(w io.Writer) {
+  fmt.Fprintln(w, strings.TrimSpace(`
+ttscserver — Language Server Protocol host for ttsc.
+
+Usage:
+  ttscserver --stdio
+  ttscserver --version
+  ttscserver --help
+
+Options:
+  --stdio              Communicate with the editor over stdin/stdout.
+  --cwd <dir>          Project root passed to the embedded tsgo server.
+  --progress-delay D   Delay before tsgo shows its progress UI (default 250ms).
+
+Typical embedding:
+  Editors spawn ttscserver via the JavaScript launcher (resolves the
+  per-platform native binary) and exchange LSP messages over stdio. The
+  embedded tsgo server provides hover/completion/definitions/diagnostics;
+  ttsc merges plugin (lint/format) diagnostics, code actions, and ttsc-
+  owned executeCommand handlers into the same stream.
+`))
+}

package/cmd/ttscserver/run_lsp_reports_getwd_error_test.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+  "bytes"
+  "errors"
+  "strings"
+  "testing"
+)
+
+// TestRunLSPReportsGetwdError pins the defensive Getwd error path. The
+// host runs with an inherited working directory; if Getwd fails (e.g.
+// the directory was removed mid-session) the launcher must surface a
+// clean message and exit 2 instead of panicking inside tsgo.
+//
+// 1. Substitute the getwd seam to return an error.
+// 2. Run runLSP with --stdio (no explicit --cwd).
+// 3. Assert exit 2 and a stderr message mentioning the working directory.
+func TestRunLSPReportsGetwdError(t *testing.T) {
+  prev := getwd
+  getwd = func() (string, error) { return "", errors.New("synthetic getwd failure") }
+  defer func() { getwd = prev }()
+
+  outBuf := &bytes.Buffer{}
+  errBuf := &bytes.Buffer{}
+  withIO(t, outBuf, errBuf, nil, func() {
+    if code := runLSP([]string{"--stdio"}); code != 2 {
+      t.Fatalf("expected exit 2, got %d", code)
+    }
+  })
+
+  if !strings.Contains(errBuf.String(), "could not resolve working directory") {
+    t.Fatalf("expected getwd error message, got: %q", errBuf.String())
+  }
+}

package/cmd/ttscserver/run_lsp_reports_server_error_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+  "bytes"
+  "context"
+  "errors"
+  "io"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestRunLSPReportsServerError pins the non-cancellation error path in
+// runLSP. When RunLSPServer reports a real failure (the embedded server
+// crashed, an unrecoverable IO error, etc.) the launcher must exit 1
+// and copy the error message to stderr.
+//
+// 1. Substitute the runLSPServer seam to return a sentinel error.
+// 2. Run runLSP with --stdio --cwd <tempdir>.
+// 3. Assert exit 1 and the sentinel text on stderr.
+func TestRunLSPReportsServerError(t *testing.T) {
+  sentinel := errors.New("lsp host blew up")
+  prev := runLSPServer
+  runLSPServer = func(_ context.Context, _ driver.LSPServerOptions) error {
+    return sentinel
+  }
+  defer func() { runLSPServer = prev }()
+
+  outBuf := &bytes.Buffer{}
+  errBuf := &bytes.Buffer{}
+  withIO(t, outBuf, errBuf, nil, func() {
+    if code := runLSP([]string{"--stdio", "--cwd", t.TempDir()}); code != 1 {
+      t.Fatalf("expected exit 1, got %d", code)
+    }
+  })
+
+  if !strings.Contains(errBuf.String(), sentinel.Error()) {
+    t.Fatalf("expected sentinel on stderr, got: %q", errBuf.String())
+  }
+  _ = io.Discard
+}

package/driver/lsp_envelope.go

@@ -0,0 +1,136 @@
+package driver
+
+import (
+  "bytes"
+  "encoding/json"
+  "errors"
+  "fmt"
+  "strconv"
+  "strings"
+)
+
+// ErrInvalidJSONRPC is returned by ParseEnvelope when the body has a
+// `jsonrpc` field present and not equal to "2.0". A missing field is
+// tolerated to stay compatible with editors that omit it.
+var ErrInvalidJSONRPC = errors.New("lsp: jsonrpc field must be \"2.0\"")
+
+// Envelope is the minimal JSON-RPC view ttscserver needs to dispatch
+// messages without re-serializing them. id is decoded as json.RawMessage
+// because LSP allows both numbers and strings and we must round-trip
+// whichever shape the editor used in correlating responses.
+type Envelope struct {
+  JSONRPC string          `json:"jsonrpc,omitempty"`
+  ID      json.RawMessage `json:"id,omitempty"`
+  Method  string          `json:"method,omitempty"`
+  Params  json.RawMessage `json:"params,omitempty"`
+  Result  json.RawMessage `json:"result,omitempty"`
+  Error   json.RawMessage `json:"error,omitempty"`
+}
+
+// ParseEnvelope decodes the JSON-RPC envelope without consuming the
+// inner params/result/error payloads. Unknown fields are ignored, which
+// matches the LSP base protocol's forward-compatibility expectation. A
+// non-empty `jsonrpc` value other than "2.0" is rejected.
+func ParseEnvelope(body []byte) (Envelope, error) {
+  var env Envelope
+  if err := json.Unmarshal(body, &env); err != nil {
+    return Envelope{}, fmt.Errorf("lsp: envelope decode: %w", err)
+  }
+  if env.JSONRPC != "" && env.JSONRPC != "2.0" {
+    return Envelope{}, fmt.Errorf("%w (got %q)", ErrInvalidJSONRPC, env.JSONRPC)
+  }
+  return env, nil
+}
+
+// IsRequest reports whether the envelope represents a request expecting
+// a response (id present, method present).
+func (e Envelope) IsRequest() bool {
+  return len(e.ID) > 0 && e.Method != ""
+}
+
+// IsNotification reports whether the envelope is a one-way notification.
+func (e Envelope) IsNotification() bool {
+  return len(e.ID) == 0 && e.Method != ""
+}
+
+// IsResponse reports whether the envelope is a response (id present,
+// method absent — either result or error will be set).
+func (e Envelope) IsResponse() bool {
+  return len(e.ID) > 0 && e.Method == ""
+}
+
+// IsErrorResponse reports whether a response envelope carries an error
+// object. JSON-RPC §5.1 forbids `result` and `error` both being present
+// on the same response, so the proxy uses this to skip merging plugin
+// contributions into upstream failures.
+func (e Envelope) IsErrorResponse() bool {
+  return e.IsResponse() && len(e.Error) > 0 && !bytes.Equal(bytes.TrimSpace(e.Error), []byte("null"))
+}
+
+// IDKey returns a stable string key for matching request and response
+// envelopes. LSP allows integer or string ids, and peers sometimes
+// disagree on the numeric encoding — `1` vs `1.0` is semantically the
+// same id. The key normalizes both forms so the proxy correlates them.
+// Strings remain quoted so a numeric id `42` never collides with a
+// string id `"42"`. Ids whose JSON value is not a number or string
+// (LSP forbids these as request ids) produce the empty key, which
+// callers treat as "no entry".
+func (e Envelope) IDKey() string {
+  return idKeyFromRaw(e.ID)
+}
+
+// idKeyFromRaw normalizes a raw id payload the same way IDKey does so
+// every call site keyed on json.RawMessage produces a consistent key.
+// Without this shared helper, $/cancelRequest handling and pending
+// request bookkeeping would disagree on numeric form and the proxy
+// would fail to correlate them.
+//
+// Numbers are decoded via json.Decoder.UseNumber() so the full int64
+// range round-trips exactly: decoding into `any` would produce float64
+// and any id past 2^53 would silently collide with its neighbor. LSP
+// places no upper bound on numeric ids, so the helper preserves the
+// high-bit fidelity peers may rely on. Strings are quoted so the proxy
+// never confuses a numeric id `42` with a string id `"42"`. Anything
+// the type switch below does not recognize as a JSON-RPC id shape
+// (boolean, null, array, object — none of which LSP allows for ids)
+// falls through to the empty key, which callers treat as "no entry".
+func idKeyFromRaw(raw json.RawMessage) string {
+  if len(raw) == 0 {
+    return ""
+  }
+  dec := json.NewDecoder(bytes.NewReader(raw))
+  dec.UseNumber()
+  var decoded any
+  if err := dec.Decode(&decoded); err != nil {
+    return ""
+  }
+  switch v := decoded.(type) {
+  case json.Number:
+    lit := v.String()
+    if !strings.ContainsAny(lit, ".eE") {
+      // Integer-shaped literal. Use int64 when it fits so leading
+      // zeros and minus signs canonicalize, but preserve the literal
+      // for past-int64 ids — Float64 normalization would silently
+      // round 9999999999999999998 and 9999999999999999999 to the
+      // same key.
+      if n, err := v.Int64(); err == nil {
+        return strconv.FormatInt(n, 10)
+      }
+      return lit
+    }
+    // Float-shaped literal (`1.0`, `1.5`, `1e2`). Collapse to integer
+    // form only when the value is exactly representable as int64;
+    // 2^53 bounds the safe range because float64 loses unit precision
+    // past that magnitude.
+    if f, err := v.Float64(); err == nil {
+      const maxSafeFloat = float64(int64(1) << 53)
+      if f >= -maxSafeFloat && f <= maxSafeFloat && f == float64(int64(f)) {
+        return strconv.FormatInt(int64(f), 10)
+      }
+    }
+    return lit
+  case string:
+    return strconv.Quote(v)
+  }
+  return ""
+}

package/driver/lsp_frame.go

@@ -0,0 +1,121 @@
+// JSON-RPC Content-Length framing as used by LSP over stdio. ttscserver
+// embeds tsgo's LSP server but sits between it and the editor so it can
+// merge plugin diagnostics into outgoing publishDiagnostics and inject
+// ttsc-owned code actions. Both legs of the proxy work on raw bytes.
+//
+// Headers are preserved when read so callers that inspect Content-Type
+// or vendor-specific headers can react to them; outgoing frames written
+// by WriteFrame include only Content-Length. That is intentional — the
+// LSP base protocol marks every other header optional and editors in
+// the wild do not require them on server output.
+package driver
+
+import (
+  "bufio"
+  "errors"
+  "fmt"
+  "io"
+  "strconv"
+  "strings"
+)
+
+// ErrFrameClosed reports a clean EOF between frames. Callers use it to
+// shut down a pump loop without surfacing an error to the editor.
+var ErrFrameClosed = errors.New("lsp: frame stream closed")
+
+// ErrFrameTooLarge reports that a peer announced a Content-Length above
+// the safety cap. ttscserver bounds the value defensively so a confused
+// editor or compromised pipe cannot drive the proxy OOM with a single
+// gigabyte-scale header.
+var ErrFrameTooLarge = errors.New("lsp: frame body exceeds maximum size")
+
+// MaxFrameBytes caps Content-Length to 64 MiB. The largest payload the
+// LSP base protocol routinely produces is workspace symbol responses
+// for very large monorepos; 64 MiB leaves a wide margin over any real
+// editor traffic while still capping attacker-supplied lengths.
+const MaxFrameBytes = 64 << 20
+
+// FrameReader decodes Content-Length-framed JSON-RPC messages from r. It
+// is intentionally permissive about extra headers (we forward whatever the
+// peer sent) and strict about the Content-Length value because tsgo's
+// upstream writer always emits one.
+type FrameReader struct {
+  br *bufio.Reader
+}
+
+// NewFrameReader wraps r with an internal buffered reader. r is consumed
+// lazily; the underlying reader is never closed by the FrameReader.
+func NewFrameReader(r io.Reader) *FrameReader {
+  return &FrameReader{br: bufio.NewReader(r)}
+}
+
+// Read returns the next message body together with the raw header block
+// (without trailing CRLFCRLF). The header block is preserved so callers
+// that proxy traffic verbatim do not lose Content-Type or vendor headers.
+func (fr *FrameReader) Read() (headers string, body []byte, err error) {
+  var headerBuf strings.Builder
+  contentLength := -1
+  for {
+    line, lineErr := fr.br.ReadString('\n')
+    if lineErr != nil {
+      if lineErr == io.EOF && headerBuf.Len() == 0 && line == "" {
+        return "", nil, ErrFrameClosed
+      }
+      return "", nil, fmt.Errorf("lsp: header read: %w", lineErr)
+    }
+    trimmed := strings.TrimRight(line, "\r\n")
+    if trimmed == "" {
+      break
+    }
+    headerBuf.WriteString(line)
+    if value, ok := parseContentLength(trimmed); ok {
+      contentLength = value
+    }
+  }
+  if contentLength < 0 {
+    return "", nil, errors.New("lsp: missing Content-Length header")
+  }
+  if contentLength > MaxFrameBytes {
+    return "", nil, fmt.Errorf("%w (got %d, max %d)", ErrFrameTooLarge, contentLength, MaxFrameBytes)
+  }
+  body = make([]byte, contentLength)
+  if _, err := io.ReadFull(fr.br, body); err != nil {
+    return "", nil, fmt.Errorf("lsp: body read: %w", err)
+  }
+  return headerBuf.String(), body, nil
+}
+
+// parseContentLength extracts the integer value of a Content-Length header.
+// Header names are case-insensitive per the LSP base protocol; tsgo emits
+// "Content-Length" but some clients downcase, so we normalize here.
+func parseContentLength(line string) (int, bool) {
+  colon := strings.IndexByte(line, ':')
+  if colon < 0 {
+    return 0, false
+  }
+  name := strings.TrimSpace(line[:colon])
+  if !strings.EqualFold(name, "Content-Length") {
+    return 0, false
+  }
+  value := strings.TrimSpace(line[colon+1:])
+  n, err := strconv.Atoi(value)
+  if err != nil || n < 0 {
+    return 0, false
+  }
+  return n, true
+}
+
+// WriteFrame serializes body with a Content-Length header to w. The header
+// uses CRLF line endings to match the LSP base protocol exactly so editors
+// that strict-parse the header block (notably VSCode's client) accept the
+// message without warnings.
+func WriteFrame(w io.Writer, body []byte) error {
+  header := fmt.Sprintf("Content-Length: %d\r\n\r\n", len(body))
+  if _, err := io.WriteString(w, header); err != nil {
+    return fmt.Errorf("lsp: header write: %w", err)
+  }
+  if _, err := w.Write(body); err != nil {
+    return fmt.Errorf("lsp: body write: %w", err)
+  }
+  return nil
+}

package/driver/lsp_plugin.go

@@ -0,0 +1,150 @@
+package driver
+
+import "encoding/json"
+
+// LSPRange / LSPPosition mirror the wire shape of LSP Range/Position. The
+// proxy keeps these local rather than importing lsproto so the shim
+// surface stays narrow; the merger marshals them straight into the array
+// the editor already expects.
+type LSPPosition struct {
+  Line      int `json:"line"`
+  Character int `json:"character"`
+}
+
+// LSPRange is the closed-open [start, end) interval LSP uses for ranges.
+type LSPRange struct {
+  Start LSPPosition `json:"start"`
+  End   LSPPosition `json:"end"`
+}
+
+// LSPDiagnosticSeverity values match the LSP enum exactly so editors
+// pick the right color/icon without translation.
+type LSPDiagnosticSeverity int
+
+const (
+  // LSPDiagnosticSeverityError is the most prominent severity; ttsc maps
+  // build-blocking findings (lint errors, parse errors) to it.
+  LSPDiagnosticSeverityError LSPDiagnosticSeverity = 1
+  // LSPDiagnosticSeverityWarning is rendered as a yellow squiggle in
+  // typical editor themes; ttsc maps lint warnings to it.
+  LSPDiagnosticSeverityWarning LSPDiagnosticSeverity = 2
+  // LSPDiagnosticSeverityInformation is rendered as a blue squiggle.
+  LSPDiagnosticSeverityInformation LSPDiagnosticSeverity = 3
+  // LSPDiagnosticSeverityHint is rendered as a faint underline or dots.
+  LSPDiagnosticSeverityHint LSPDiagnosticSeverity = 4
+)
+
+// LSPDiagnostic is the minimal subset of the LSP Diagnostic type
+// ttscserver injects into outgoing publishDiagnostics. omitempty is set
+// on optional fields so the merged JSON stays close to what tsgo emits.
+type LSPDiagnostic struct {
+  Range    LSPRange              `json:"range"`
+  Severity LSPDiagnosticSeverity `json:"severity,omitempty"`
+  Code     any                   `json:"code,omitempty"`
+  Source   string                `json:"source,omitempty"`
+  Message  string                `json:"message"`
+}
+
+// LSPCodeAction is the minimal Code Action shape ttscserver returns from
+// the textDocument/codeAction handler. ttsc actions are always command-
+// driven (the server side does the heavy lifting) so Edit stays nil.
+type LSPCodeAction struct {
+  Title     string          `json:"title"`
+  Kind      string          `json:"kind,omitempty"`
+  Command   *LSPCommand     `json:"command,omitempty"`
+  Edit      json.RawMessage `json:"edit,omitempty"`
+  IsPreferred bool          `json:"isPreferred,omitempty"`
+}
+
+// LSPCommand is the wire shape of a workspace/executeCommand target.
+type LSPCommand struct {
+  Title     string            `json:"title"`
+  Command   string            `json:"command"`
+  Arguments []json.RawMessage `json:"arguments,omitempty"`
+}
+
+// LSPCodeActionContext mirrors the context object the editor sends with
+// textDocument/codeAction. Only the diagnostics slice is consumed by
+// ttsc; the rest is opaque and forwarded by Proxy verbatim.
+type LSPCodeActionContext struct {
+  Diagnostics []json.RawMessage `json:"diagnostics,omitempty"`
+  Only        []string          `json:"only,omitempty"`
+  TriggerKind int               `json:"triggerKind,omitempty"`
+}
+
+// LSPWorkspaceEdit is the wire shape ttscserver returns from custom
+// executeCommand handlers. It maps URIs to ordered text edits.
+type LSPWorkspaceEdit struct {
+  Changes map[string][]LSPTextEdit `json:"changes,omitempty"`
+}
+
+// LSPTextEdit is a single text edit in a workspace edit.
+type LSPTextEdit struct {
+  Range   LSPRange `json:"range"`
+  NewText string   `json:"newText"`
+}
+
+// LSPDocumentVersion carries the LSP textDocument version associated
+// with a publishDiagnostics notification. Plugin sources use it to drop
+// stale findings (LSP guarantees that diagnostics whose version does
+// not match the current document are discarded by the editor anyway,
+// but plugins that cache work-in-progress benefit from seeing it).
+//
+// Version is nil when upstream omitted the field — that is legal in
+// LSP and the plugin source should treat it as "version unknown".
+type LSPDocumentVersion struct {
+  URI     string
+  Version *int
+}
+
+// PluginSource is the seam between the LSP proxy and ttsc's plugin
+// pipeline. Returning empty slices/nil is a valid "no contribution"
+// answer; ttscserver still forwards the upstream tsgo response verbatim.
+//
+// The proxy never holds a PluginSource lock across upstream traffic, so
+// implementations must be safe to call from multiple goroutines.
+type PluginSource interface {
+  // Diagnostics returns ttsc plugin diagnostics for the document the
+  // proxy is about to publish. doc.Version is nil when upstream omitted
+  // the field. The proxy appends these to whatever upstream tsgo
+  // published, so duplicates between ttsc and tsgo must be deduplicated
+  // on the source side.
+  Diagnostics(doc LSPDocumentVersion) []LSPDiagnostic
+
+  // CodeActions contributes additional actions for the given range. The
+  // proxy appends them to the upstream tsgo response.
+  CodeActions(uri string, rng LSPRange, ctx LSPCodeActionContext) []LSPCodeAction
+
+  // ExecuteCommand handles workspace/executeCommand requests whose
+  // command id ttsc owns (CommandIDs reports the prefix). A nil edit
+  // means the command ran but produced no workspace changes; a non-nil
+  // error surfaces as an LSP error response.
+  ExecuteCommand(command string, args []json.RawMessage) (*LSPWorkspaceEdit, error)
+
+  // CommandIDs lists the workspace command ids ttsc handles locally so
+  // the proxy never forwards them to upstream tsgo.
+  CommandIDs() []string
+}
+
+// NullPluginSource is the zero-contribution PluginSource used when the
+// LSP server is hosted without any ttsc plugin pipeline (smoke tests,
+// docs build). Every method returns an empty result so the proxy still
+// exercises its merge paths even with no plugin activity.
+type NullPluginSource struct{}
+
+// Diagnostics returns no plugin diagnostics.
+func (NullPluginSource) Diagnostics(LSPDocumentVersion) []LSPDiagnostic { return nil }
+
+// CodeActions returns no plugin code actions.
+func (NullPluginSource) CodeActions(string, LSPRange, LSPCodeActionContext) []LSPCodeAction {
+  return nil
+}
+
+// ExecuteCommand reports that the command is not handled.
+func (NullPluginSource) ExecuteCommand(string, []json.RawMessage) (*LSPWorkspaceEdit, error) {
+  return nil, ErrCommandNotHandled
+}
+
+// CommandIDs returns an empty slice so the proxy forwards every command
+// to upstream tsgo.
+func (NullPluginSource) CommandIDs() []string { return nil }