ttsc 0.21.0 → 0.22.0

package/cmd/ttscserver/main.go

@@ -1,8 +1,9 @@
 // Command ttscserver is the Go LSP host shipped by ttsc. It wraps the
 // project-selected TypeScript-Go LSP server process and proxies traffic
 // between the editor and that server. The JavaScript launcher resolves project
-// plugins first and passes an LSP manifest so this command can merge plugin
-// diagnostics, code actions, and ttsc-owned executeCommand handling.
+// plugins first and passes a private LSP manifest file so this command can
+// merge plugin diagnostics, code actions, and ttsc-owned executeCommand
+// handling.
 //
 // The JavaScript launcher (`packages/ttsc/src/launcher/ttscserver.ts`)
 // resolves the native binary and forwards stdio so editors can spawn
@@ -29,6 +30,8 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
 )
 
+const lspPluginManifestMaxBytes = 64 * 1024 * 1024
+
 // Build metadata; overwritten via -ldflags in release builds.
 var (
   version = "0.0.0-dev"
@@ -94,6 +97,12 @@ func runLSP(args []string) int {
   suppressExecuteCommandProviderFlag := fs.Bool("suppress-execute-command-provider", false, "do not advertise ttsc executeCommand ids during initialize")
   suppressExecuteCommandIDsFlag := fs.String("suppress-execute-command-ids", "", "comma-separated ttsc executeCommand ids to omit during initialize")
   executeCommandIDPrefixFlag := fs.String("execute-command-id-prefix", "", "prefix to apply to advertised executeCommand ids")
+  // The launcher passes this flag only when it actually resolved LSP-capable
+  // plugins, so a host too old to know it refuses to start instead of running
+  // silently without every plugin the project declared. Version skew between
+  // the launcher and a TTSCSERVER_BINARY override is therefore visible at the
+  // first request rather than diagnosed from missing diagnostics.
+  lspPluginsFileFlag := fs.String("lsp-plugins-file", "", "path to the private LSP plugin manifest written by the ttsc launcher")
   _ = fs.String("clientProcessId", "", "ignored VSCode language-client compatibility flag")
   if err := fs.Parse(args); err != nil {
     return 2
@@ -121,10 +130,15 @@ func runLSP(args []string) int {
     tsgoBinary = strings.TrimSpace(os.Getenv("TTSC_TSGO_BINARY"))
   }
 
+  manifestJSON, err := lspPluginManifestJSON(strings.TrimSpace(*lspPluginsFileFlag))
+  if err != nil {
+    fmt.Fprintf(stderr, "ttscserver: %v\n", err)
+    return 2
+  }
   source, err := lspserver.NewNativePluginSource(lspserver.NativePluginSourceOptions{
     Cwd:          cwd,
     Err:          stderr,
-    ManifestJSON: os.Getenv("TTSC_LSP_PLUGINS_JSON"),
+    ManifestJSON: manifestJSON,
     Tsconfig:     strings.TrimSpace(*tsconfigFlag),
   })
   if err != nil {
@@ -160,6 +174,63 @@ func runLSP(args []string) int {
   return 0
 }
 
+// lspPluginManifestJSON reads the private plugin manifest prepared for this
+// process and takes ownership of it.
+//
+// The manifest names every resolved project plugin and its launch context, so
+// the copy this process was given to own is consumed exactly once: the file the
+// launcher named with the flag is removed as soon as it has been read, which
+// means a forcibly terminated launcher cannot leave the payload on disk. Both
+// transport variables are cleared from this process either way, so no plugin
+// sidecar spawned later inherits the payload or a path to it. The environment
+// forms remain accepted because an editor pointed straight at a native binary
+// has no launcher to pass the flag, and a manifest supplied that way is read
+// without being removed, because it belongs to whoever wrote it.
+func lspPluginManifestJSON(flagLocation string) (string, error) {
+  defer func() {
+    os.Unsetenv("TTSC_LSP_PLUGINS_FILE")
+    os.Unsetenv("TTSC_LSP_PLUGINS_JSON")
+  }()
+  if flagLocation != "" {
+    body, err := readLSPPluginManifestFile("--lsp-plugins-file", flagLocation)
+    if err != nil {
+      return "", err
+    }
+    // Only the flag names a file the launcher created for this process, so
+    // only that one is consumed here. Removing it is what keeps a forcibly
+    // terminated launcher from leaving the payload on disk. A path supplied
+    // out of band belongs to whoever wrote it and must survive the read, or
+    // the next session would start without the plugins it declared.
+    os.Remove(flagLocation)
+    return body, nil
+  }
+  location := strings.TrimSpace(os.Getenv("TTSC_LSP_PLUGINS_FILE"))
+  if location == "" {
+    return os.Getenv("TTSC_LSP_PLUGINS_JSON"), nil
+  }
+  return readLSPPluginManifestFile("TTSC_LSP_PLUGINS_FILE", location)
+}
+
+func readLSPPluginManifestFile(source, location string) (string, error) {
+  input, err := os.Open(location)
+  if err != nil {
+    return "", fmt.Errorf("read %s: %w", source, err)
+  }
+  defer input.Close()
+  body, err := io.ReadAll(io.LimitReader(input, lspPluginManifestMaxBytes+1))
+  if err != nil {
+    return "", fmt.Errorf("read %s: %w", source, err)
+  }
+  if len(body) > lspPluginManifestMaxBytes {
+    return "", fmt.Errorf(
+      "%s exceeds %d bytes",
+      source,
+      lspPluginManifestMaxBytes,
+    )
+  }
+  return string(body), nil
+}
+
 func printVersion(w io.Writer) {
   fmt.Fprintf(
     w,
@@ -187,6 +258,11 @@ Options:
   --cwd <dir>          Project root used as the tsgo server working directory.
   --tsconfig <path>    Project config path used by ttsc plugin sidecars.
   --tsgo <path>        Absolute tsgo binary path (defaults to TTSC_TSGO_BINARY).
+  --lsp-plugins-file <path>
+                       Private plugin manifest written by the ttsc launcher; it is
+                       consumed and deleted at startup. Editors that spawn this
+                       binary directly supply their own manifest through
+                       TTSC_LSP_PLUGINS_FILE instead, which is never deleted.
   --suppress-execute-command-provider
                        Do not advertise ttsc executeCommand ids during initialize.
   --suppress-execute-command-ids <ids>

package/cmd/ttscserver/run_lsp_uses_native_plugin_manifest_source_test.go

@@ -3,25 +3,39 @@ package main
 import (
   "bytes"
   "context"
+  "os"
+  "path/filepath"
+  "strings"
   "testing"
 
   "github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
 )
 
 // TestRunLSPUsesNativePluginManifestSource verifies the command wires the
-// launcher-provided plugin manifest into the proxy source.
+// launcher-provided plugin manifest into the proxy source and then owns it.
 //
 // A previous implementation always passed NullPluginSource, so editor sessions
-// could never receive ttsc plugin diagnostics or commands. This test pins the
-// command-level seam without starting tsgo: the JavaScript launcher owns plugin
-// discovery, and the Go command must turn its manifest into a NativePluginSource.
+// could never receive ttsc plugin diagnostics or commands. The manifest also
+// names every resolved plugin and its launch context, so leaving it readable
+// for the process lifetime exposes it to any sidecar this host later spawns.
+// This test pins both halves of that seam without starting tsgo.
 //
-// 1. Set TTSC_LSP_PLUGINS_JSON to an empty but valid manifest.
-// 2. Substitute runLSPServer and capture its LSPServerOptions.
-// 3. Run `ttscserver --stdio` against a temp cwd.
-// 4. Assert Source is the native sidecar-backed implementation.
+//  1. Set the legacy TTSC_LSP_PLUGINS_JSON fallback to a valid manifest.
+//  2. Substitute runLSPServer and capture its LSPServerOptions.
+//  3. Run `ttscserver --stdio` and assert the native source is selected, and
+//     that the legacy payload no longer reaches a spawned sidecar.
+//  4. Put a valid manifest in TTSC_LSP_PLUGINS_FILE while making the legacy
+//     environment payload invalid, and prove the bounded file transport wins,
+//     leaves neither variable behind, and survives the read because an editor
+//     that supplies it out of band must be able to launch twice.
+//  5. Pass a manifest through --lsp-plugins-file while both environment forms
+//     are invalid, and prove the flag transport takes precedence and is
+//     consumed, because the launcher created that file for this process alone.
+//  6. Point the flag at a missing manifest and prove the command fails instead
+//     of silently serving a project without its declared plugins.
 func TestRunLSPUsesNativePluginManifestSource(t *testing.T) {
   t.Setenv("TTSC_LSP_PLUGINS_JSON", `{"plugins":[],"lspPlugins":[]}`)
+  t.Setenv("TTSC_LSP_PLUGINS_FILE", "")
 
   prev := runLSPServer
   var captured lspserver.LSPServerOptions
@@ -31,15 +45,81 @@ func TestRunLSPUsesNativePluginManifestSource(t *testing.T) {
   }
   defer func() { runLSPServer = prev }()
 
-  outBuf := &bytes.Buffer{}
-  errBuf := &bytes.Buffer{}
-  withIO(t, outBuf, errBuf, nil, func() {
-    if code := runLSP([]string{"--stdio", "--cwd", t.TempDir(), "--tsconfig", "tsconfig.app.json"}); code != 0 {
-      t.Fatalf("expected exit 0, got %d (stderr=%q)", code, errBuf.String())
+  invoke := func(extra ...string) (int, string) {
+    t.Helper()
+    outBuf := &bytes.Buffer{}
+    errBuf := &bytes.Buffer{}
+    code := 0
+    withIO(t, outBuf, errBuf, nil, func() {
+      code = runLSP(append(append([]string{}, extra...), []string{
+        "--stdio",
+        "--cwd",
+        t.TempDir(),
+        "--tsconfig",
+        "tsconfig.app.json",
+      }...))
+    })
+    return code, errBuf.String()
+  }
+  run := func(label string, extra ...string) {
+    t.Helper()
+    code, stderrText := invoke(extra...)
+    if code != 0 {
+      t.Fatalf("%s: expected exit 0, got %d (stderr=%q)", label, code, stderrText)
+    }
+    if _, ok := captured.Source.(*lspserver.NativePluginSource); !ok {
+      t.Fatalf("%s: expected NativePluginSource, got %T", label, captured.Source)
     }
-  })
+    for _, name := range []string{
+      "TTSC_LSP_PLUGINS_FILE",
+      "TTSC_LSP_PLUGINS_JSON",
+    } {
+      if value := os.Getenv(name); value != "" {
+        t.Fatalf("%s: %s survived startup as %q", label, name, value)
+      }
+    }
+  }
+  writeManifest := func() string {
+    t.Helper()
+    location := filepath.Join(t.TempDir(), "plugins.json")
+    if err := os.WriteFile(
+      location,
+      []byte(`{"plugins":[],"lspPlugins":[]}`),
+      0o600,
+    ); err != nil {
+      t.Fatal(err)
+    }
+    return location
+  }
+
+  run("legacy JSON")
 
-  if _, ok := captured.Source.(*lspserver.NativePluginSource); !ok {
-    t.Fatalf("expected NativePluginSource, got %T", captured.Source)
+  environmentManifest := writeManifest()
+  t.Setenv("TTSC_LSP_PLUGINS_JSON", "{invalid")
+  t.Setenv("TTSC_LSP_PLUGINS_FILE", environmentManifest)
+  run("manifest file")
+  if _, err := os.Stat(environmentManifest); err != nil {
+    t.Fatalf("out-of-band manifest was consumed by its reader: %v", err)
+  }
+
+  flagManifest := writeManifest()
+  t.Setenv("TTSC_LSP_PLUGINS_JSON", "{invalid")
+  t.Setenv("TTSC_LSP_PLUGINS_FILE", filepath.Join(t.TempDir(), "absent.json"))
+  run("manifest flag", "--lsp-plugins-file", flagManifest)
+  if _, err := os.Stat(flagManifest); !os.IsNotExist(err) {
+    t.Fatalf("flag manifest survived startup: %v", err)
+  }
+
+  t.Setenv("TTSC_LSP_PLUGINS_JSON", `{"plugins":[],"lspPlugins":[]}`)
+  t.Setenv("TTSC_LSP_PLUGINS_FILE", "")
+  code, stderrText := invoke(
+    "--lsp-plugins-file",
+    filepath.Join(t.TempDir(), "absent.json"),
+  )
+  if code == 0 {
+    t.Fatal("a missing manifest must not start the host")
+  }
+  if !strings.Contains(stderrText, "--lsp-plugins-file") {
+    t.Fatalf("expected the failing transport to be named, got %q", stderrText)
   }
 }

package/driver/lsp.go

@@ -52,6 +52,10 @@ type LSPDocumentVersion = lspserver.LSPDocumentVersion
 // LSPProjectDiagnostics is the driver-level alias for a project publication.
 type LSPProjectDiagnostics = lspserver.LSPProjectDiagnostics
 
+// LSPProjectInputSnapshot is the driver-level alias for the set of paths a
+// producer declares its answers depend on.
+type LSPProjectInputSnapshot = lspserver.LSPProjectInputSnapshot
+
 // LSPDiagnosticsResult separates document and project plugin diagnostics.
 type LSPDiagnosticsResult = lspserver.LSPDiagnosticsResult
 

package/internal/lspserver/lsp_document_diagnostics_omits_cached_project_when_current_result_has_none_test.go

@@ -0,0 +1,48 @@
+package lspserver
+
+import "testing"
+
+// TestLSPDocumentDiagnosticsOmitsCachedProjectWhenCurrentResultHasNone
+// verifies last-good cache state is not presented as a current document-cycle
+// project result.
+//
+// A parse failure can make lsp-diagnostics omit project data. Returning the
+// prior cache in that response lets the proxy complete a newer pending external
+// refresh with stale evidence.
+//
+//  1. Seed one producer's last-good project publication.
+//  2. Make the current document diagnostic invocation fail before publication.
+//  3. Assert document diagnostics omit Project while the cache remains intact.
+func TestLSPDocumentDiagnosticsOmitsCachedProjectWhenCurrentResultHasNone(
+  t *testing.T,
+) {
+  plugin := NativeLSPPluginEntry{
+    Binary: "ttsc-no-such-document-diagnostics-sidecar",
+    Name:   "@ttsc/cached",
+  }
+  source := &NativePluginSource{plugins: []NativeLSPPluginEntry{plugin}}
+  source.storeProjectDiagnostics(
+    plugin,
+    1,
+    &LSPProjectDiagnostics{
+      URI: "file:///project/tsconfig.json",
+      Diagnostics: []LSPDiagnostic{{
+        Code:    "stale",
+        Message: "stale",
+      }},
+    },
+  )
+
+  got := source.Diagnostics(LSPDocumentVersion{
+    URI: "file:///project/src/main.ts",
+  })
+
+  if got.Project != nil {
+    t.Fatalf("current omitted project result reused cache: %#v", got.Project)
+  }
+  cached := source.projectDiagnosticsSnapshot()
+  if cached == nil || len(cached.Diagnostics) != 1 ||
+    cached.Diagnostics[0].Code != "stale" {
+    t.Fatalf("last-good cache was not retained: %#v", cached)
+  }
+}

package/internal/lspserver/lsp_executable_project_input_change_requests_launcher_restart_test.go

@@ -0,0 +1,98 @@
+package lspserver
+
+import (
+  "bytes"
+  "encoding/json"
+  "errors"
+  "io"
+  "testing"
+)
+
+type executableProjectInputSource struct {
+  NullPluginSource
+  reloadURI string
+}
+
+func (s executableProjectInputSource) ProjectInputReloadMatchesChange(
+  uri string,
+  _ *int,
+) bool {
+  return uri == s.reloadURI
+}
+
+// TestLSPExecutableProjectInputChangeRequestsLauncherRestart verifies an input
+// that can alter the descriptor's contributor set cannot be handled as an
+// ordinary native resident-program refresh.
+//
+// The JavaScript launcher owns descriptor evaluation and native contributor
+// compilation, so the already-running Go process cannot safely mutate this
+// selection in place.
+//
+//  1. Send a watched change for the source's executable reload URI.
+//  2. Assert the proxy announces the expected lifecycle transition, then
+//     returns its stable restart sentinel before forwarding.
+//  3. Send an unrelated change and assert it follows the ordinary forwarded
+//     invalidation path without another lifecycle notification.
+func TestLSPExecutableProjectInputChangeRequestsLauncherRestart(t *testing.T) {
+  reloadURI := "file:///project/lint.config.ts"
+  var editor bytes.Buffer
+  proxy := NewProxy(ProxyOptions{
+    EditorOut:  &editor,
+    UpstreamIn: io.Discard,
+    Source: executableProjectInputSource{
+      reloadURI: reloadURI,
+    },
+  })
+  handled, err := proxy.handleEditorEnvelope(
+    watchedFilesEnvelope(
+      t,
+      `{"changes":[{"uri":"`+reloadURI+`","type":2}]}`,
+    ),
+    nil,
+  )
+  if handled {
+    t.Fatal("executable reload notification was marked locally handled")
+  }
+  if !errors.Is(err, ErrLSPPluginSelectionChanged) {
+    t.Fatalf("reload error = %v, want %v", err, ErrLSPPluginSelectionChanged)
+  }
+  _, body, err := NewFrameReader(&editor).Read()
+  if err != nil {
+    t.Fatalf("read plugin-selection notification: %v", err)
+  }
+  notification, err := ParseEnvelope(body)
+  if err != nil {
+    t.Fatalf("parse plugin-selection notification: %v", err)
+  }
+  if notification.Method != methodPluginSelectionChanged {
+    t.Fatalf(
+      "notification method = %q, want %q",
+      notification.Method,
+      methodPluginSelectionChanged,
+    )
+  }
+  var params map[string]string
+  if err := json.Unmarshal(notification.Params, &params); err != nil {
+    t.Fatalf("parse plugin-selection notification params: %v", err)
+  }
+  if params["reason"] != "projectInputChanged" {
+    t.Fatalf("notification params = %#v", params)
+  }
+
+  handled, err = proxy.handleEditorEnvelope(
+    watchedFilesEnvelope(
+      t,
+      `{"changes":[{"uri":"file:///project/src/main.ts","type":2}]}`,
+    ),
+    nil,
+  )
+  if err != nil {
+    t.Fatalf("ordinary watched change: %v", err)
+  }
+  if handled {
+    t.Fatal("ordinary watched change was swallowed instead of forwarded")
+  }
+  if editor.Len() != 0 {
+    t.Fatalf("ordinary change wrote an unexpected editor frame: %q", editor.String())
+  }
+}

package/internal/lspserver/lsp_external_watched_change_retains_program_test.go

@@ -0,0 +1,53 @@
+package lspserver
+
+import "testing"
+
+// TestExternalWatchedChangeRetainsProgram verifies external data events preserve
+// the warm Program without hiding TypeScript root-set changes.
+//
+// Project-input globs may overlap source files even though Markdown and
+// OpenAPI are the common case, but a JSON path may also be a resolveJsonModule
+// source. JSON create/delete changes possible Program topology, while in-place
+// JSON edits and data-only reference topology preserve the current root graph,
+// except package metadata whose content participates in module resolution.
+//
+//  1. Retain changed Markdown and Swagger inputs.
+//  2. Retain an in-place TypeScript edit for incremental Program update.
+//  3. Reload package metadata, created/deleted modules, and project configs.
+func TestExternalWatchedChangeRetainsProgram(t *testing.T) {
+  changed := fileChangeTypeChanged
+  created := fileChangeTypeCreated
+  deleted := fileChangeTypeDeleted
+  cases := []struct {
+    uri        string
+    changeType *int
+    want       bool
+  }{
+    {uri: "file:///project/docs/spec.md", changeType: &changed, want: true},
+    {uri: "file:///project/api/openapi.json", changeType: &changed, want: true},
+    {uri: "file:///project/package.json", changeType: &changed, want: false},
+    {uri: "file:///project/PACKAGE.JSON", changeType: &changed, want: false},
+    {uri: "file:///project/api/openapi.json", changeType: &created, want: false},
+    {uri: "file:///project/api/openapi.json", changeType: &deleted, want: false},
+    {uri: "file:///project/api/openapi.JSON", changeType: &created, want: false},
+    {uri: "file:///project/api/openapi.yaml", changeType: &deleted, want: true},
+    {uri: "file:///project/src/main.ts", changeType: &changed, want: true},
+    {uri: "file:///project/src/main.ts", changeType: &created, want: false},
+    {uri: "file:///project/src/main.ts", changeType: &deleted, want: false},
+    {uri: "file:///project/tsconfig.json", changeType: &changed, want: false},
+    {uri: "https://example.com/openapi.json", changeType: &changed, want: false},
+    {uri: "", changeType: &changed, want: false},
+    {uri: "file:///project/docs/spec.md", changeType: nil, want: false},
+  }
+  for _, tc := range cases {
+    if got := externalWatchedChangeRetainsProgram(tc.uri, tc.changeType); got != tc.want {
+      t.Fatalf(
+        "externalWatchedChangeRetainsProgram(%q, %v) = %v, want %v",
+        tc.uri,
+        tc.changeType,
+        got,
+        tc.want,
+      )
+    }
+  }
+}

package/internal/lspserver/lsp_hints_refresh_scheduled_by_editor_events_test.go

@@ -44,6 +44,15 @@ func TestLSPHintsRefreshScheduledByEditorEvents(t *testing.T) {
     `{"jsonrpc":"2.0","method":"textDocument/didSave","params":{"textDocument":{"uri":"file:///a.ts"}}}`,
     `{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{}}}`,
     `{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///lint.config.ts","type":2}]}}`,
+    // JSON can be a resolveJsonModule source even when no ProjectRule declares
+    // it. Content and membership changes therefore invalidate the Program-wide
+    // hint corpus just like TypeScript changes do.
+    `{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///src/data.json","type":1}]}}`,
+    `{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///src/data.json","type":2}]}}`,
+    `{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///src/data.json","type":3}]}}`,
+    // Package metadata participates in module resolution independently of
+    // ProjectRule ownership.
+    `{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///package.json","type":2}]}}`,
     // Params the proxy cannot read take the conservative branch: it cannot tell
     // which inputs changed, so it assumes they all did — the same answer it
     // gives the resident daemon there.