A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
fix: secure language server websocket listeners (#10979)
Myles Scolnick48eb3f83ee88
diff --git a/marimo/_server/_pylsp.py b/marimo/_server/_pylsp.pynew file mode 100644index 0000000000..3ee3294d7a--- /dev/null+++ b/marimo/_server/_pylsp.py@@ -0,0 +1,80 @@+# Copyright 2026 Marimo. All rights reserved.+from __future__ import annotations++import argparse+import json+import logging+import os+import secrets+from http import HTTPStatus+from typing import TYPE_CHECKING, Any++from websockets.sync.server import Server, ServerConnection, serve++if TYPE_CHECKING:+ from websockets.http11 import Request, Response+++def pylsp_connection(websocket: ServerConnection) -> None:+ # pylsp's own WebSocket launcher cannot restrict its host or handshake.+ from pylsp.python_lsp import PythonLSPServer # type: ignore[import-not-found,import-untyped]++ def consume(message: Any) -> None:+ websocket.send(json.dumps(message, ensure_ascii=False))++ handler = PythonLSPServer(+ rx=None, tx=None, consumer=consume, check_parent_process=True+ )++ try:+ for message in websocket:+ handler.consume(json.loads(message))+ finally:+ # Release worker threads and file watchers when a client disconnects.+ try:+ if handler.config is not None and not handler._shutdown:+ handler.m_shutdown()+ finally:+ handler.m_exit()+++def create_server(port: int, token: str) -> Server:+ if not token:+ raise ValueError("MARIMO_LSP_TOKEN must be set")++ def authenticate(+ connection: ServerConnection, request: Request+ ) -> Response | None:+ tokens = request.headers.get_all("Marimo-LSP-Token")+ if (+ len(tokens) != 1+ or not tokens[0].isascii()+ or not secrets.compare_digest(tokens[0].encode(), token.encode())+ ):+ return connection.respond(HTTPStatus.FORBIDDEN, "Forbidden\n")+ return None++ return serve(+ pylsp_connection,+ host="127.0.0.1",+ port=port,+ origins=[None],+ process_request=authenticate,+ )+++def main() -> None:+ parser = argparse.ArgumentParser()+ parser.add_argument("--port", type=int, required=True)+ parser.add_argument("--log-file", required=True)+ args = parser.parse_args()+ # WebSocket debug logging includes the private handshake credential.+ logging.basicConfig(filename=args.log_file, level=logging.INFO)+ with create_server(+ args.port, os.environ.get("MARIMO_LSP_TOKEN", "")+ ) as server:+ server.serve_forever()+++if __name__ == "__main__":+ main()diff --git a/marimo/_server/api/middleware.py b/marimo/_server/api/middleware.pyindex 26f38566fb..e9659cc625 100644--- a/marimo/_server/api/middleware.py+++ b/marimo/_server/api/middleware.py@@ -373,12 +373,14 @@ class ProxyMiddleware:| None = None,*,require_auth: bool = True,+ websocket_headers: dict[str, str] | None = None,) -> None:self.app = appself.path = proxy_path.rstrip("/")self.target_url = target_urlself.path_rewrite = path_rewriteself.require_auth = require_auth+ self.websocket_headers = websocket_headersself.connection_error_handler = (connection_error_handlerif connection_error_handler@@ -576,7 +578,9 @@ class ProxyMiddleware:for attempt in range(max_retries):try:- ws_client = await connect(ws_url)+ ws_client = await connect(+ ws_url, additional_headers=self.websocket_headers+ )LOGGER.debug(f"Successfully connected to {ws_url}")return ws_clientexcept Exception as e:diff --git a/marimo/_server/lsp.py b/marimo/_server/lsp.pyindex e51d2d4c46..394e5d9c1d 100644--- a/marimo/_server/lsp.py+++ b/marimo/_server/lsp.py@@ -3,11 +3,13 @@ from __future__ import annotationsimport asyncioimport os+import secretsimport signalimport socketimport subprocessimport timefrom abc import ABC, abstractmethod+from functools import cached_propertyfrom pathlib import Pathfrom typing import Any, Literal, cast@@ -37,6 +39,11 @@ class LspServer(ABC):port: intid: str+ @cached_property+ def auth_token(self) -> str:+ # This credential stays between the proxy and its child process.+ return secrets.token_urlsafe(32)+@abstractmethodasync def start(self) -> AlertNotification | None:pass@@ -111,6 +118,7 @@ class BaseLspServer(LspServer):stderr=subprocess.DEVNULL if is_windows() else subprocess.PIPE,stdin=None,text=True,+ env={**os.environ, "MARIMO_LSP_TOKEN": self.auth_token},# Create a new process group so we can kill the entire# tree (parent + children) on shutdown. Without this,# child processes (e.g. copilot language-server.cjs)@@ -260,7 +268,7 @@ class BaseLspServer(LspServer):try:sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)sock.settimeout(timeout_ms / 1000)- result = sock.connect_ex(("localhost", self.port))+ result = sock.connect_ex(("127.0.0.1", self.port))sock.close()return result == 0except Exception:@@ -619,12 +627,9 @@ class PyLspServer(BaseLspServer):return [sys.executable,"-m",- "pylsp",- "--ws",- "-v",+ "marimo._server._pylsp","--port",str(self.port),- "--check-parent-process","--log-file",str(self.log_file),]diff --git a/marimo/_server/main.py b/marimo/_server/main.pyindex bc6029dfcb..f78f38852b 100644--- a/marimo/_server/main.py+++ b/marimo/_server/main.py@@ -141,7 +141,8 @@ def _create_lsps_proxy_middleware(Middleware(ProxyMiddleware,proxy_path=f"{base_url}/lsp/{server.id}",- target_url=f"http://localhost:{server.port}",+ target_url=f"http://127.0.0.1:{server.port}",+ websocket_headers={"Marimo-LSP-Token": server.auth_token},)for server in servers)diff --git a/packages/lsp/index.test.ts b/packages/lsp/index.test.tsindex 4334f4a201..2dce5b2032 100644--- a/packages/lsp/index.test.ts+++ b/packages/lsp/index.test.ts@@ -69,14 +69,37 @@ describe("parseTypedCommand", () => {});describe("LSP Server Integration", () => {+ it.each([undefined, ""])("fails closed without a token: %s", (token) => {+ const result = childProcess.spawnSync(+ process.execPath,+ [+ "./dist/index.cjs",+ "--log-file",+ path.join(os.tmpdir(), "lsp-server-missing-token-test.log"),+ ],+ {+ env: { ...process.env, MARIMO_LSP_TOKEN: token },+ encoding: "utf8",+ timeout: 5000,+ },+ );+ expect(result.error).toBeUndefined();+ expect(result.status).toBe(1);+ expect(result.stderr).toContain("MARIMO_LSP_TOKEN must be set");+ });+it("should start and be killable", async () => {- const proc = childProcess.spawn("node", [- "./dist/index.cjs",- "--lsp",- "echo hello",- "--log-file",- path.join(os.tmpdir(), "lsp-server-test.log"),- ]);+ const proc = childProcess.spawn(+ "node",+ [+ "./dist/index.cjs",+ "--lsp",+ "echo hello",+ "--log-file",+ path.join(os.tmpdir(), "lsp-server-test.log"),+ ],+ { env: { ...process.env, MARIMO_LSP_TOKEN: "test-token" } },+ );// Register the exit listener BEFORE sending the signal to avoid// a race where the process exits before the listener is attached.@@ -98,13 +121,17 @@ describe("LSP Server Integration", () => {});it("should start with typed copilot command", async () => {- const proc = childProcess.spawn("node", [- "./dist/index.cjs",- "--lsp",- "copilot:echo copilot-test",- "--log-file",- path.join(os.tmpdir(), "lsp-server-copilot-test.log"),- ]);+ const proc = childProcess.spawn(+ "node",+ [+ "./dist/index.cjs",+ "--lsp",+ "copilot:echo copilot-test",+ "--log-file",+ path.join(os.tmpdir(), "lsp-server-copilot-test.log"),+ ],+ { env: { ...process.env, MARIMO_LSP_TOKEN: "test-token" } },+ );const exitCode = new Promise<number | null>((resolve) => {proc.on("exit", (code) => resolve(code));diff --git a/packages/lsp/index.ts b/packages/lsp/index.tsindex 6538a4d3fa..45531e4f43 100644--- a/packages/lsp/index.ts+++ b/packages/lsp/index.ts@@ -1,4 +1,5 @@/* oxlint-disable no-console -- LSP server uses console for logging */+import { timingSafeEqual } from "node:crypto";import { appendFile, mkdir, writeFile } from "node:fs/promises";import type { IncomingMessage } from "node:http";import { dirname } from "node:path";@@ -138,10 +139,14 @@ function handleWebSocketConnection(return;}+ // The bridge authenticates connections; the stdio server needs no credential.+ const env = { ...process.env };+ delete env.MARIMO_LSP_TOKEN;const jsonRpcConnection = createServerProcess(languageServerCommand.join(" "),languageServerCommand[0],languageServerCommand.slice(1),+ { env },);if (!jsonRpcConnection) {@@ -163,15 +168,41 @@ function handleWebSocketConnection(});}+export function createWebSocketServer(+ port: number,+ token: string,+): WebSocketServer {+ if (!token) {+ throw new Error("MARIMO_LSP_TOKEN must be set");+ }+ const expectedToken = Buffer.from(token);+ return new WebSocketServer({+ host: "127.0.0.1",+ port,+ perMessageDeflate: false,+ // Only marimo's authenticated proxy may connect. Browsers cannot supply+ // this private credential, including from a DNS-rebound origin.+ verifyClient: ({ req }, done) => {+ const value = req.headers["marimo-lsp-token"];+ const suppliedToken = Buffer.from(typeof value === "string" ? value : "");+ const authorized =+ req.headers.origin === undefined &&+ suppliedToken.length === expectedToken.length &&+ timingSafeEqual(suppliedToken, expectedToken);+ done(authorized, 403, "Forbidden");+ },+ });+}+function startWebSocketServer(port: number,languageServerCommand: string[],logger: Logger,): void {- const webSocketServer = new WebSocketServer({+ const webSocketServer = createWebSocketServer(port,- perMessageDeflate: false,- });+ process.env.MARIMO_LSP_TOKEN || "",+ );webSocketServer.on("error", (error) => {logger.error("WebSocket server error:", error);@@ -253,4 +284,6 @@ async function main(): Promise<void> {startWebSocketServer(serverPort, languageServerCommand, logger);}-void main();+if (require.main === module) {+ void main();+}diff --git a/packages/lsp/websocket-server.test.ts b/packages/lsp/websocket-server.test.tsnew file mode 100644index 0000000000..7eb13a5a05--- /dev/null+++ b/packages/lsp/websocket-server.test.ts@@ -0,0 +1,202 @@+import { spawn } from "node:child_process";+import { once } from "node:events";+import { existsSync } from "node:fs";+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";+import { createServer } from "node:net";+import type { AddressInfo } from "node:net";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { describe, expect, it, vi } from "vitest";+import WebSocket from "ws";+import { createWebSocketServer } from "./index";++describe("LSP WebSocket security", () => {+ it("requires a private token before listening", () => {+ expect(() => createWebSocketServer(0, "")).toThrow("MARIMO_LSP_TOKEN");+ });++ it.each([+ {},+ { "Marimo-LSP-Token": "" },+ { "Marimo-LSP-Token": "wrong" },+ { "Marimo-LSP-Token": "xxxxxxxxxx" },+ { "Marimo-LSP-Token": "test-token-extra" },+ { "Marimo-LSP-Token": "tést-token" },+ { "Marimo-LSP-Token": "test-token, test-token" },+ { Origin: "https://attacker.test" },+ { "Marimo-LSP-Token": "test-token", Origin: "http://evil.example.com" },+ { "Marimo-LSP-Token": "test-token", Origin: "https://attacker.test" },+ { "Marimo-LSP-Token": "test-token", Origin: "null" },+ { "Marimo-LSP-Token": "test-token", Origin: "http://127.0.0.1" },+ { "Marimo-LSP-Token": "test-token", Origin: "" },+ { "Marimo-LSP-Token": ["test-token", "test-token"] },+ { "Marimo-LSP-Token": ["wrong", "test-token"] },+ { "Marimo-LSP-Token": ["test-token", "wrong"] },+ ])("rejects direct connections: %j", async (headers) => {+ const server = createWebSocketServer(0, "test-token");+ await once(server, "listening");+ const address = server.address() as AddressInfo;+ expect(address.address).toBe("127.0.0.1");+ let connections = 0;+ server.on("connection", () => connections++);+ const client = new WebSocket(`ws://127.0.0.1:${address.port}`, { headers });+ try {+ const [error] = await once(client, "error");+ expect(error.message).toContain("403");+ // Rejected handshakes must not emit a connection event.+ expect(connections).toBe(0);+ // Rejection must leave the listener usable, including with lowercase headers.+ const validClient = new WebSocket(`ws://127.0.0.1:${address.port}`, {+ headers: { "marimo-lsp-token": "test-token" },+ });+ try {+ await once(validClient, "open");+ expect(connections).toBe(1);+ } finally {+ validClient.terminate();+ }+ } finally {+ client.terminate();+ await new Promise<void>((resolve) => server.close(() => resolve()));+ }+ });++ it("authenticates before spawning through the production bridge", async () => {+ const directory = await mkdtemp(join(tmpdir(), "marimo-lsp-security-"));+ const marker = join(directory, "spawned.json");+ const script = join(directory, "language-server.cjs");+ const recorder = join(directory, "record-spawns.cjs");+ await writeFile(script, "process.stdin.resume();");+ // Record at the actual spawn boundary so even short-lived children count.+ await writeFile(+ recorder,+ `+ const cp = require("node:child_process");+ const originalSpawn = cp.spawn;+ cp.spawn = (command, args, options) => {+ const env = options?.env ?? process.env;+ require("node:fs").appendFileSync(${JSON.stringify(marker)}, JSON.stringify({+ hasToken: Object.hasOwn(env, "MARIMO_LSP_TOKEN"),+ otherEnv: env.MARIMO_LSP_TEST,+ }) + "\\n");+ return originalSpawn(command, args, options);+ };+ `,+ );+ const reservation = createServer();+ reservation.listen(0, "127.0.0.1");+ await once(reservation, "listening");+ const { port } = reservation.address() as AddressInfo;+ await new Promise<void>((resolve) => reservation.close(() => resolve()));++ const bridge = spawn(+ process.execPath,+ [+ "--require",+ recorder,+ "./dist/index.cjs",+ "--port",+ String(port),+ "--lsp",+ `copilot:${script}`,+ "--log-file",+ join(directory, "bridge.log"),+ ],+ {+ env: {+ ...process.env,+ MARIMO_LSP_TOKEN: "test-token",+ MARIMO_LSP_TEST: "preserved",+ },+ stdio: "ignore",+ },+ );+ const exited = once(bridge, "exit");+ let validClient: WebSocket | undefined;+ try {+ for (const headers of [+ {},+ { "Marimo-LSP-Token": "wrong" },+ { "Marimo-LSP-Token": "test-token", Origin: "https://attacker.test" },+ ]) {+ await vi.waitFor(async () => {+ expect(bridge.exitCode).toBeNull();+ const client = new WebSocket(`ws://127.0.0.1:${port}`, { headers });+ try {+ const [error] = await once(client, "error");+ expect(error.message).toContain("403");+ } finally {+ client.terminate();+ }+ });+ expect(existsSync(marker)).toBe(false);+ }++ validClient = new WebSocket(`ws://127.0.0.1:${port}`, {+ headers: { "Marimo-LSP-Token": "test-token" },+ });+ await once(validClient, "open");+ await vi.waitFor(async () => {+ const spawns = (await readFile(marker, "utf8"))+ .trim()+ .split("\n")+ .map((line) => JSON.parse(line));+ expect(spawns).toEqual([{ hasToken: false, otherEnv: "preserved" }]);+ });+ } finally {+ validClient?.terminate();+ bridge.kill();+ await exited;+ await rm(directory, { recursive: true, force: true });+ }+ });++ it("isolates an abruptly disconnected client", async () => {+ const server = createWebSocketServer(0, "test-token");+ await once(server, "listening");+ const address = server.address() as AddressInfo;+ server.on("connection", (socket) => {+ socket.on("message", (data) => socket.send(data));+ });+ const clients = Array.from(+ { length: 2 },+ () =>+ new WebSocket(`ws://127.0.0.1:${address.port}`, {+ headers: { "Marimo-LSP-Token": "test-token" },+ }),+ );+ try {+ await Promise.all(clients.map((client) => once(client, "open")));+ const closed = once(clients[0], "close");+ clients[0].terminate();+ await closed;+ clients[1].send("still available");+ const [message] = await once(clients[1], "message");+ expect(message.toString()).toBe("still available");+ } finally {+ for (const client of clients) client.terminate();+ await new Promise<void>((resolve) => server.close(() => resolve()));+ }+ });++ it("allows the authenticated proxy to exchange messages", async () => {+ const server = createWebSocketServer(0, "test-token");+ await once(server, "listening");+ const address = server.address() as AddressInfo;+ server.on("connection", (socket) => {+ socket.on("message", (data) => socket.send(data));+ });+ const client = new WebSocket(`ws://127.0.0.1:${address.port}/lsp/ty`, {+ headers: { "Marimo-LSP-Token": "test-token" },+ });+ try {+ await once(client, "open");+ client.send("hello");+ const [message] = await once(client, "message");+ expect(message.toString()).toBe("hello");+ } finally {+ client.close();+ await new Promise<void>((resolve) => server.close(() => resolve()));+ }+ });+});diff --git a/tests/_server/api/test_middleware.py b/tests/_server/api/test_middleware.pyindex addd7bfc47..5526f9234b 100644--- a/tests/_server/api/test_middleware.py+++ b/tests/_server/api/test_middleware.py@@ -9,6 +9,7 @@ import sysimport timefrom multiprocessing import Processfrom typing import TYPE_CHECKING, Any+from unittest.mock import AsyncMockfrom urllib.parse import quoteimport pytest@@ -23,6 +24,7 @@ from starlette.websockets import WebSocket, WebSocketDisconnectfrom uvicorn import Config, Serverfrom marimo._config.manager import MarimoConfigManager, UserConfigManager+from marimo._server._pylsp import create_serverfrom marimo._server.api.auth import TOKEN_QUERY_PARAMfrom marimo._server.api.middleware import (ProxyMiddleware,@@ -39,7 +41,7 @@ from marimo._server.main import (from marimo._server.session_manager import SessionManagerfrom marimo._server.tokens import AuthTokenfrom marimo._session.model import SessionMode-from tests._server.conftest import join_kernel_thread_tasks+from tests._server.conftest import join_kernel_thread_tasks, serve_in_threadfrom tests._server.mocks import get_mock_session_manager, token_headerif TYPE_CHECKING:@@ -825,7 +827,7 @@ class TestLspProxyMiddleware:assert len(middlewares) == 1assert middlewares[0].kwargs["proxy_path"] == "/lsp/test-lsp"- assert middlewares[0].kwargs["target_url"] == "http://localhost:8888"+ assert middlewares[0].kwargs["target_url"] == "http://127.0.0.1:8888"def test_lsp_proxy_with_base_url(self) -> None:middlewares = list(@@ -836,7 +838,7 @@ class TestLspProxyMiddleware:assert len(middlewares) == 1assert middlewares[0].kwargs["proxy_path"] == "/foo/lsp/test-lsp"- assert middlewares[0].kwargs["target_url"] == "http://localhost:8888"+ assert middlewares[0].kwargs["target_url"] == "http://127.0.0.1:8888"def test_lsp_proxy_multiple_servers(self) -> None:middlewares = list(@@ -851,9 +853,9 @@ class TestLspProxyMiddleware:assert len(middlewares) == 2assert middlewares[0].kwargs["proxy_path"] == "/app/lsp/pylsp"- assert middlewares[0].kwargs["target_url"] == "http://localhost:8888"+ assert middlewares[0].kwargs["target_url"] == "http://127.0.0.1:8888"assert middlewares[1].kwargs["proxy_path"] == "/app/lsp/copilot"- assert middlewares[1].kwargs["target_url"] == "http://localhost:8889"+ assert middlewares[1].kwargs["target_url"] == "http://127.0.0.1:8889"def test_lsp_proxy_integration(self) -> None:"""Verify LSP proxy works with create_starlette_app."""@@ -870,7 +872,7 @@ class TestLspProxyMiddleware:]assert len(proxy_mw) == 1- assert proxy_mw[0].kwargs["target_url"] == "http://localhost:8888"+ assert proxy_mw[0].kwargs["target_url"] == "http://127.0.0.1:8888"class TestLspProxyAuth:@@ -934,6 +936,25 @@ class TestLspProxyAuth:passassert exc_info.value.code == WebSocketCodes.UNAUTHORIZED+ def test_private_lsp_token_cannot_bypass_marimo_auth(+ self, lsp_app: Starlette, monkeypatch: pytest.MonkeyPatch+ ) -> None:+ proxy = next(+ mw for mw in lsp_app.user_middleware if mw.cls == ProxyMiddleware+ )+ connect = AsyncMock()+ monkeypatch.setattr("marimo._server.api.middleware.connect", connect)+ client = TestClient(lsp_app)+ with pytest.raises(WebSocketDisconnect) as exc:+ with client.websocket_connect(+ "/lsp/test-lsp/ws", headers=proxy.kwargs["websocket_headers"]+ ):+ pytest.fail(+ "Private upstream token bypassed marimo authentication"+ )+ assert exc.value.code == WebSocketCodes.UNAUTHORIZED+ connect.assert_not_called()+def test_http_authenticated_is_forwarded(self, lsp_app: Starlette) -> None:# The mock LSP server points at an unused port, so the upstream# connection fails with 503. We only care that auth let the@@ -945,6 +966,49 @@ class TestLspProxyAuth:)assert response.status_code != 401, response.text+ async def test_websocket_injects_private_credential(+ self, monkeypatch: pytest.MonkeyPatch+ ) -> None:+ lsp = _mock_lsp_server("test-lsp", 0)+ assert lsp.auth_token != _mock_lsp_server("other-lsp", 0).auth_token++ def echo(websocket):+ for message in websocket:+ websocket.send(message)++ monkeypatch.setattr("marimo._server._pylsp.pylsp_connection", echo)+ with (+ create_server(0, lsp.auth_token) as upstream,+ serve_in_thread(upstream),+ ):+ lsp.port = upstream.socket.getsockname()[1]+ app = create_starlette_app(+ base_url="/notebook", lsp_servers=[lsp], skew_protection=False+ )+ with_server(app)+ init_state(+ session_manager=get_mock_session_manager(+ mode=SessionMode.EDIT+ ),+ skew_protection=False,+ base_url="/notebook",+ ).apply(app.state)++ def exchange():+ client = TestClient(app)+ with client.websocket_connect(+ "/notebook/lsp/test-lsp/ws",+ headers={+ **token_header("fake-token"),+ "Marimo-LSP-Token": "client-cannot-override-this",+ "Origin": "http://testserver",+ },+ ) as websocket:+ websocket.send_text("LSP message")+ assert websocket.receive_text() == "LSP message"++ await asyncio.wait_for(asyncio.to_thread(exchange), timeout=10)+def test_proxy_middleware_defaults_require_auth(self) -> None:async def _noop_app(scope: Scope, receive: Receive, send: Senddiff --git a/tests/_server/conftest.py b/tests/_server/conftest.pyindex ae7c186a3e..24c977e3bf 100644--- a/tests/_server/conftest.py+++ b/tests/_server/conftest.py@@ -4,6 +4,7 @@ from __future__ import annotationsimport asyncioimport sysimport threading+from contextlib import contextmanagerfrom pathlib import Pathfrom tempfile import TemporaryDirectoryfrom typing import TYPE_CHECKING@@ -26,10 +27,39 @@ from tests._server.mocks import get_mock_session_managerif TYPE_CHECKING:from collections.abc import Generator, Iterator+ from websockets.sync.server import Server as WebSocketServer+# Module-level app only for client_with_lifespans fixture_module_app = create_starlette_app(base_url="", enable_auth=True)+@contextmanager+def serve_in_thread(server: WebSocketServer) -> Iterator[None]:+ error: BaseException | None = None++ def serve() -> None:+ nonlocal error+ try:+ server.serve_forever()+ except BaseException as exc:+ error = exc++ thread = threading.Thread(target=serve)+ thread.start()+ try:+ yield+ finally:+ try:+ server.shutdown()+ finally:+ thread.join(timeout=5)+ assert not thread.is_alive(), (+ "WebSocket server thread did not stop"+ )+ if error is not None:+ raise error++def get_kernel_tasks(session_manager: SessionManager,) -> list[threading.Thread | ProcessLike]:diff --git a/tests/_server/test_lsp.py b/tests/_server/test_lsp.pyindex ddeba2f03f..ae6a4c219e 100644--- a/tests/_server/test_lsp.py+++ b/tests/_server/test_lsp.py@@ -90,6 +90,10 @@ async def test_base_lsp_server_start_stop(alert = await server.start()assert alert is Nonemock_popen.assert_called_once()+ assert (+ mock_popen.call_args.kwargs["env"]["MARIMO_LSP_TOKEN"]+ == server.auth_token+ )assert (server.is_running() is True) # Process exists and is running (returncode is None)@@ -112,6 +116,59 @@ async def test_base_lsp_server_start_stop(assert server.process is None+ "server_type",+ [+ PyLspServer,+ CopilotLspServer,+ BasedpyrightServer,+ TyServer,+ PyreflyServer,+ ],+)+async def test_lsp_launch_keeps_token_out_of_argv(+ server_type: type[BaseLspServer],+ tmp_path: Path,+ mock_popen: mock.MagicMock,+):+ server = server_type(port=8000)+ lsp_dir = tmp_path / "_lsp"+ lsp_dir.mkdir()+ (lsp_dir / "index.cjs").touch()+ ty_module = mock.MagicMock()+ ty_module.find_ty_bin.return_value = "/path/to/ty"+ pyrefly_module = mock.MagicMock()+ pyrefly_module.get_pyrefly_bin.return_value = "/path/to/pyrefly"++ # Stub installed dependencies, but exercise each real get_command()+ # and the actual argv passed to Popen.+ with (+ mock.patch("marimo._server.lsp.DependencyManager"),+ mock.patch(+ "marimo._server.lsp.marimo_package_path", return_value=tmp_path+ ),+ mock.patch.dict(+ "sys.modules",+ {"ty.__main__": ty_module, "pyrefly.__main__": pyrefly_module},+ ),+ mock.patch.object(server, "validate_requirements", return_value=True),+ mock.patch.object(server, "_wait_until_ready", return_value=True),+ mock.patch.object(server, "_signal_process_tree"),+ ):+ try:+ assert await server.start() is None+ mock_popen.assert_called_once()+ command = mock_popen.call_args.args[0]+ assert command+ assert all(server.auth_token not in arg for arg in command)+ assert (+ mock_popen.call_args.kwargs["env"]["MARIMO_LSP_TOKEN"]+ == server.auth_token+ )+ finally:+ server.stop()++async def test_base_lsp_server_stop_force_kill_on_timeout(mock_popen: mock.MagicMock,mock_process: mock.MagicMock,@@ -222,12 +279,9 @@ async def test_pylsp_server():assert server.get_command() == [sys.executable,"-m",- "pylsp",- "--ws",- "-v",+ "marimo._server._pylsp","--port","8000",- "--check-parent-process","--log-file",str(get_log_directory() / "pylsp.log"),]diff --git a/tests/_server/test_pylsp.py b/tests/_server/test_pylsp.pynew file mode 100644index 0000000000..0862962a46--- /dev/null+++ b/tests/_server/test_pylsp.py@@ -0,0 +1,261 @@+# Copyright 2026 Marimo. All rights reserved.+from __future__ import annotations++import asyncio+import json+import os+import subprocess+from typing import TYPE_CHECKING+from unittest.mock import MagicMock, Mock++import pytest+from websockets.asyncio.client import connect+from websockets.exceptions import ConnectionClosedError, InvalidStatus++from marimo._server._pylsp import create_server, pylsp_connection+from marimo._server.lsp import PyLspServer+from marimo._utils.net import find_free_port+from tests._server.conftest import serve_in_thread++if TYPE_CHECKING:+ from pathlib import Path+++ ("headers", "origin"),+ [+ ({}, None),+ ({"Marimo-LSP-Token": ""}, None),+ ({"Marimo-LSP-Token": "wrong"}, None),+ ({"Marimo-LSP-Token": "x" * len("test-token")}, None),+ ({"Marimo-LSP-Token": "test-token-extra"}, None),+ ({"Marimo-LSP-Token": "tést-token"}, None),+ ({"Marimo-LSP-Token": "test-token, test-token"}, None),+ ({}, "https://attacker.test"),+ ({"Marimo-LSP-Token": "test-token"}, "https://attacker.test"),+ ({"Marimo-LSP-Token": "test-token"}, "http://evil.example.com"),+ ({"Marimo-LSP-Token": "test-token"}, "null"),+ ({"Marimo-LSP-Token": "test-token"}, "http://127.0.0.1"),+ ({"Marimo-LSP-Token": "test-token"}, ""),+ (+ [+ ("Marimo-LSP-Token", "test-token"),+ ("Marimo-LSP-Token", "test-token"),+ ],+ None,+ ),+ (+ [+ ("Marimo-LSP-Token", "wrong"),+ ("Marimo-LSP-Token", "test-token"),+ ],+ None,+ ),+ (+ [+ ("Marimo-LSP-Token", "test-token"),+ ("Marimo-LSP-Token", "wrong"),+ ],+ None,+ ),+ ],+)+async def test_rejects_direct_connections(monkeypatch, headers, origin):+ handler = Mock(side_effect=lambda ws: ws.send(ws.recv()))+ monkeypatch.setattr("marimo._server._pylsp.pylsp_connection", handler)+ with create_server(0, "test-token") as server, serve_in_thread(server):+ host, port = server.socket.getsockname()+ assert host == "127.0.0.1"+ with pytest.raises(InvalidStatus) as exc:+ async with connect(+ f"ws://{host}:{port}",+ additional_headers=headers,+ origin=origin,+ ):+ pytest.fail("Unauthorized connection accepted")+ assert exc.value.response.status_code == 403+ handler.assert_not_called()+ # A rejected handshake must not poison subsequent valid connections.+ async with connect(+ f"ws://{host}:{port}",+ additional_headers={"marimo-lsp-token": "test-token"},+ ) as websocket:+ await websocket.send("still available")+ assert (+ await asyncio.wait_for(websocket.recv(), 5)+ == "still available"+ )+ handler.assert_called_once()+++def test_requires_token():+ with pytest.raises(ValueError, match="MARIMO_LSP_TOKEN"):+ create_server(0, "")++[email protected]("token", [None, ""])+def test_launcher_fails_closed_without_token(tmp_path: Path, token):+ server = PyLspServer(0)+ server.log_file = tmp_path / "pylsp.log"+ env = dict(os.environ)+ env.pop("MARIMO_LSP_TOKEN", None)+ if token is not None:+ env["MARIMO_LSP_TOKEN"] = token+ result = subprocess.run(+ server.get_command(),+ env=env,+ capture_output=True,+ text=True,+ timeout=5,+ )+ assert result.returncode != 0+ assert "MARIMO_LSP_TOKEN must be set" in result.stderr+++ "failure", ["receive", "decode", "consume", "send", "shutdown"]+)+def test_handler_releases_resources_on_failure(monkeypatch, failure):+ pylsp = pytest.importorskip("pylsp.python_lsp")+ handler = Mock(config=Mock(), _shutdown=False)+ factory = Mock(return_value=handler)+ monkeypatch.setattr(pylsp, "PythonLSPServer", factory)+ websocket = MagicMock()+ websocket.__iter__.return_value = iter(+ ['{"jsonrpc":"2.0","method":"example"}']+ )+ error = RuntimeError(f"{failure} failed")+ expected_error = RuntimeError+ if failure == "receive":+ websocket.__iter__.side_effect = error+ elif failure == "decode":+ websocket.__iter__.return_value = iter(["invalid JSON"])+ expected_error = json.JSONDecodeError+ elif failure == "consume":+ handler.consume.side_effect = error+ elif failure == "send":+ websocket.send.side_effect = error+ handler.consume.side_effect = lambda _: factory.call_args.kwargs[+ "consumer"+ ]({})+ else:+ handler.m_shutdown.side_effect = error++ with pytest.raises(expected_error):+ pylsp_connection(websocket)+ handler.m_shutdown.assert_called_once()+ handler.m_exit.assert_called_once()+++ ("initialized", "shutdown"), [(False, False), (True, False), (True, True)]+)+def test_handler_disconnect_cleanup(monkeypatch, initialized, shutdown):+ pylsp = pytest.importorskip("pylsp.python_lsp")+ handler = Mock(config=Mock() if initialized else None, _shutdown=shutdown)+ monkeypatch.setattr(pylsp, "PythonLSPServer", Mock(return_value=handler))+ websocket = MagicMock()+ websocket.__iter__.return_value = iter([])++ pylsp_connection(websocket)++ assert handler.m_shutdown.call_count == int(initialized and not shutdown)+ handler.m_exit.assert_called_once()+++ "failure", ["invalid-json", "invalid-utf8", "disconnect"]+)+async def test_bad_client_does_not_stop_server(failure):+ pytest.importorskip("pylsp")+ with create_server(0, "test-token") as server, serve_in_thread(server):+ host, port = server.socket.getsockname()+ url = f"ws://{host}:{port}"+ headers = {"Marimo-LSP-Token": "test-token"}+ async with connect(url, additional_headers=headers) as websocket:+ if failure == "disconnect":+ websocket.transport.abort()+ else:+ await websocket.send(+ "invalid JSON" if failure == "invalid-json" else b"\xff"+ )+ with pytest.raises(ConnectionClosedError) as exc:+ await asyncio.wait_for(websocket.recv(), 5)+ assert exc.value.rcvd.code == 1011++ async with connect(url, additional_headers=headers) as websocket:+ await websocket.send('{"jsonrpc":"2.0","id":1,"method":"unknown"}')+ response = json.loads(await asyncio.wait_for(websocket.recv(), 5))+ assert response["error"]["code"] == -32601+++async def test_pylsp_launcher(tmp_path: Path):+ pytest.importorskip("pylsp")+ server = PyLspServer(find_free_port(23100))+ server.log_file = tmp_path / "pylsp.log"+ try:+ assert await server.start() is None+ assert server.is_running()+ with pytest.raises(InvalidStatus):+ async with connect(f"ws://127.0.0.1:{server.port}"):+ pytest.fail("Unauthorized connection accepted")+ async with connect(+ f"ws://127.0.0.1:{server.port}",+ additional_headers={"Marimo-LSP-Token": server.auth_token},+ ) as websocket:+ await websocket.send(+ json.dumps({"jsonrpc": "2.0", "id": 1, "method": "unknown"})+ )+ response = json.loads(await asyncio.wait_for(websocket.recv(), 10))+ assert response["error"]["code"] == -32601+ finally:+ server.stop()+ assert server.auth_token not in server.log_file.read_text()+++async def test_authenticated_pylsp(tmp_path: Path):+ pytest.importorskip("pylsp")+ target = tmp_path / "fixture.py"+ target.write_text("def example():\n return 42\n")+ with create_server(0, "test-token") as server, serve_in_thread(server):+ host, port = server.socket.getsockname()+ # Reconnection must still work after the first handler is disposed.+ for _ in range(2):+ async with connect(+ f"ws://{host}:{port}/lsp/pylsp",+ additional_headers={"Marimo-LSP-Token": "test-token"},+ ) as websocket:+ await websocket.send(+ json.dumps(+ {+ "jsonrpc": "2.0",+ "id": 1,+ "method": "initialize",+ "params": {+ "processId": None,+ "rootUri": tmp_path.as_uri(),+ "capabilities": {},+ },+ }+ )+ )+ response = json.loads(+ await asyncio.wait_for(websocket.recv(), 10)+ )+ assert "capabilities" in response["result"]+ await websocket.send(+ json.dumps(+ {+ "jsonrpc": "2.0",+ "id": 2,+ "method": "textDocument/documentSymbol",+ "params": {+ "textDocument": {"uri": target.as_uri()}+ },+ }+ )+ )+ response = json.loads(+ await asyncio.wait_for(websocket.recv(), 10)+ )+ assert response["result"][0]["name"] == "example"diff --git a/tests/_server/test_serve_in_thread.py b/tests/_server/test_serve_in_thread.pynew file mode 100644index 0000000000..fefe576f47--- /dev/null+++ b/tests/_server/test_serve_in_thread.py@@ -0,0 +1,104 @@+# Copyright 2026 Marimo. All rights reserved.+from __future__ import annotations++import threading+from unittest.mock import Mock++import pytest++from tests._server.conftest import serve_in_thread+++ "failure", [RuntimeError("listener failed"), SystemExit(1)]+)[email protected]("body_fails", [False, True])[email protected]("shutdown_fails", [False, True])+def test_surfaces_worker_failure(+ monkeypatch, failure, body_fails, shutdown_fails+):+ started = threading.Event()+ worker = None+ body_error = ConnectionError("connection failed")++ def serve():+ nonlocal worker+ worker = threading.current_thread()+ started.set()+ raise failure++ shutdown_error = (+ RuntimeError("shutdown failed") if shutdown_fails else None+ )+ server = Mock(+ serve_forever=Mock(side_effect=serve),+ shutdown=Mock(side_effect=shutdown_error),+ )+ with pytest.raises(type(failure)) as exc: # noqa: PT012+ with serve_in_thread(server):+ assert started.wait(timeout=5)+ assert worker is not None+ join = Mock(wraps=worker.join)+ monkeypatch.setattr(worker, "join", join)+ if body_fails:+ raise body_error++ assert exc.value is failure+ if shutdown_fails:+ assert exc.value.__context__ is shutdown_error+ if body_fails:+ assert shutdown_error.__context__ is body_error+ elif body_fails:+ assert exc.value.__context__ is body_error+ server.shutdown.assert_called_once_with()+ join.assert_called_once_with(timeout=5)+ assert not worker.is_alive()++[email protected]("body_fails", [False, True])[email protected]("shutdown_fails", [False, True])+def test_joins_worker_on_exit(monkeypatch, body_fails, shutdown_fails):+ started = threading.Event()+ stopped = threading.Event()+ worker = None+ body_error = ValueError("test body failed")+ shutdown_error = RuntimeError("shutdown failed")++ def serve():+ nonlocal worker+ worker = threading.current_thread()+ started.set()+ assert stopped.wait(timeout=5)++ def shutdown():+ stopped.set()+ if shutdown_fails:+ raise shutdown_error++ server = Mock(+ serve_forever=Mock(side_effect=serve),+ shutdown=Mock(side_effect=shutdown),+ )+ caught = None+ try:+ with serve_in_thread(server):+ assert started.wait(timeout=5)+ assert worker is not None+ join = Mock(wraps=worker.join)+ monkeypatch.setattr(worker, "join", join)+ if body_fails:+ raise body_error+ except (ValueError, RuntimeError) as exc:+ caught = exc++ if shutdown_fails:+ assert caught is shutdown_error+ if body_fails:+ assert caught.__context__ is body_error+ elif body_fails:+ assert caught is body_error+ else:+ assert caught is None+ server.shutdown.assert_called_once_with()+ join.assert_called_once_with(timeout=5)+ assert not worker.is_alive()