@rsvelte/language-server 0.3.0 → 0.4.0

package/README.md

@@ -81,6 +81,18 @@ Most users won't run this directly — the
 bundles and launches it. For other editors, point your LSP client at the
 `rsvelte-language-server` binary with the `--stdio` transport.
 
+## Native server
+
+`rsvelte-language-server` is a launcher. It prefers the prebuilt native (Rust)
+server shipped in the optional `@rsvelte/language-server-<platform>` packages
+and falls back to the bundled JS server when no platform package is installed
+(unsupported platform, or an install that skipped optional dependencies).
+
+| Environment variable | Effect |
+| --- | --- |
+| `RSVELTE_LANGUAGE_SERVER_BIN` | Run this binary instead of the resolved one. |
+| `RSVELTE_LANGUAGE_SERVER_JS=1` | Force the bundled JS server. |
+
 ## License
 
 MIT

package/bin/rsvelte-language-server.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// Launcher for `rsvelte-language-server`.
+//
+// It prefers the native Rust server shipped in the optional
+// `@rsvelte/language-server-<triple>` packages and falls back to the bundled
+// JS server (`dist/server.mjs`) when no platform package is installed — so an
+// unsupported platform, or an install that skipped optional dependencies,
+// keeps the capabilities it has today instead of failing outright.
+//
+// Like the @rsvelte/fmt and @rsvelte/lint launchers, this file is never
+// rewritten in place: pnpm bakes a shim interpreter from this file's shebang at
+// link time, so swapping it for a native binary post-install would make that
+// shim feed Mach-O/ELF bytes to Node.
+
+import { spawnSync } from 'node:child_process';
+import { constants as osConstants } from 'node:os';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+	ensureExecutable,
+	platformPackage,
+	resolvePlatformBinary,
+} from '../lib/resolve.mjs';
+
+const pkgRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const argv = process.argv.slice(2);
+
+// Escape hatches for editors and debugging: point at a locally built server, or
+// force the JS implementation when the native one misbehaves.
+const override = process.env.RSVELTE_LANGUAGE_SERVER_BIN;
+const forceJs = process.env.RSVELTE_LANGUAGE_SERVER_JS === '1';
+
+let command;
+let args;
+if (override) {
+	command = override;
+	args = argv;
+} else {
+	const native = forceJs ? null : resolvePlatformBinary();
+	if (native) {
+		ensureExecutable(native);
+		command = native;
+		args = argv;
+	} else {
+		const jsServer = join(pkgRoot, 'dist', 'server.mjs');
+		if (!existsSync(jsServer)) {
+			const { triple, pkgName } = platformPackage();
+			const why = forceJs
+				? 'RSVELTE_LANGUAGE_SERVER_JS=1 forced it.'
+				: triple
+					? `the native package "${pkgName}" isn't installed.\nTry reinstalling: npm install --include=optional ${pkgName}`
+					: `platform ${process.platform}-${process.arch} has no prebuilt binary.`;
+			console.error(
+				`[@rsvelte/language-server] No server to run: the JS fallback (${jsServer}) is missing and ${why}`,
+			);
+			process.exit(1);
+		}
+		command = process.execPath;
+		args = [jsServer, ...argv];
+	}
+}
+
+const result = spawnSync(command, args, { stdio: 'inherit', windowsHide: true });
+
+if (result.error) {
+	console.error(
+		`[@rsvelte/language-server] Failed to exec ${command}: ${result.error.message}`,
+	);
+	process.exit(1);
+}
+
+// A signal termination leaves `status` null; returning `status ?? 0` would mask
+// the crash as a clean exit.
+if (result.signal) {
+	const signum = osConstants.signals[result.signal];
+	console.error(`[@rsvelte/language-server] ${command} was terminated by ${result.signal}.`);
+	process.exit(typeof signum === 'number' ? 128 + signum : 1);
+}
+process.exit(result.status ?? 0);

package/lib/resolve.mjs

@@ -0,0 +1,74 @@
+// Resolution helpers for the @rsvelte/language-server launcher: they find the
+// platform-native `rsvelte-language-server` binary shipped in the optional
+// `@rsvelte/language-server-<triple>` packages.
+//
+// ESM (not `.cjs` like the @rsvelte/fmt / @rsvelte/lint siblings) because this
+// package is `"type": "module"`; the resolution logic itself is identical.
+
+import { chmodSync, constants, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+/// Map the current platform/arch to a `@rsvelte/language-server-<triple>`
+/// suffix, or `null` when unsupported. Mirrors the release build matrix.
+export function resolveTriple() {
+	const { platform, arch } = process;
+	if (platform === 'darwin') {
+		if (arch === 'arm64') return 'darwin-arm64';
+		if (arch === 'x64') return 'darwin-x64';
+	} else if (platform === 'linux') {
+		// Node 18+ exposes the runtime glibc version; an empty value means musl.
+		let isMusl = false;
+		try {
+			const header = process.report.getReport().header;
+			isMusl = !header.glibcVersionRuntime;
+		} catch {
+			isMusl = false;
+		}
+		const libc = isMusl ? 'musl' : 'gnu';
+		if (arch === 'x64') return `linux-x64-${libc}`;
+		if (arch === 'arm64') return `linux-arm64-${libc}`;
+	} else if (platform === 'win32') {
+		if (arch === 'x64') return 'win32-x64-msvc';
+	}
+	return null;
+}
+
+/// The platform package name + binary basename for the current platform.
+/// `triple` is `null` when the platform is unsupported.
+export function platformPackage() {
+	const triple = resolveTriple();
+	if (!triple) return { triple: null, pkgName: null, binName: null };
+	const pkgName = `@rsvelte/language-server-${triple}`;
+	const binName =
+		process.platform === 'win32'
+			? 'rsvelte-language-server.exe'
+			: 'rsvelte-language-server';
+	return { triple, pkgName, binName };
+}
+
+/// Resolve the absolute path to the prebuilt native server for this platform,
+/// or `null` when the optional platform package isn't installed.
+export function resolvePlatformBinary() {
+	const { pkgName, binName } = platformPackage();
+	if (!pkgName) return null;
+	try {
+		return require.resolve(`${pkgName}/${binName}`);
+	} catch {
+		return null;
+	}
+}
+
+/// Best-effort `chmod +x` on a POSIX file. No-op on Windows / read-only FS.
+export function ensureExecutable(binPath) {
+	if (process.platform === 'win32') return;
+	try {
+		const mode = statSync(binPath).mode;
+		if (!(mode & constants.S_IXUSR)) {
+			chmodSync(binPath, (mode & 0o777) | 0o111);
+		}
+	} catch {
+		// Not fatal — a later spawn surfaces a clear error if it really can't run.
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsvelte/language-server",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Language Server for rsvelte — formatting (native rsvelte-fmt) and linting (bundled rsvelte_lint wasm)",
   "license": "MIT",
   "repository": {
@@ -22,13 +22,22 @@
   ],
   "type": "module",
   "bin": {
-    "rsvelte-language-server": "dist/server.mjs"
+    "rsvelte-language-server": "bin/rsvelte-language-server.mjs"
   },
   "files": [
+    "bin/rsvelte-language-server.mjs",
+    "lib/resolve.mjs",
     "dist/server.mjs",
     "dist/vendor/rsvelte_lint.cjs",
     "dist/vendor/rsvelte_lint_bg.wasm"
   ],
+  "optionalDependencies": {
+    "@rsvelte/language-server-darwin-arm64": "^0.4.0",
+    "@rsvelte/language-server-darwin-x64": "^0.4.0",
+    "@rsvelte/language-server-linux-arm64-gnu": "^0.4.0",
+    "@rsvelte/language-server-linux-x64-gnu": "^0.4.0",
+    "@rsvelte/language-server-win32-x64-msvc": "^0.4.0"
+  },
   "dependencies": {
     "vscode-languageserver": "^10.0.0",
     "vscode-languageserver-textdocument": "^1.0.12"