Skip to content

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.

fix: secure language server websocket listeners (#10979)

Myles Scolnick48eb3f83ee88
diff --git a/marimo/_server/_pylsp.py b/marimo/_server/_pylsp.py
new file mode 100644
index 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.py
index 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 = app
self.path = proxy_path.rstrip("/")
self.target_url = target_url
self.path_rewrite = path_rewrite
self.require_auth = require_auth
+ self.websocket_headers = websocket_headers
self.connection_error_handler = (
connection_error_handler
if 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_client
except Exception as e:
diff --git a/marimo/_server/lsp.py b/marimo/_server/lsp.py
index e51d2d4c46..394e5d9c1d 100644
--- a/marimo/_server/lsp.py
+++ b/marimo/_server/lsp.py
@@ -3,11 +3,13 @@ from __future__ import annotations
import asyncio
import os
+import secrets
import signal
import socket
import subprocess
import time
from abc import ABC, abstractmethod
+from functools import cached_property
from pathlib import Path
from typing import Any, Literal, cast
@@ -37,6 +39,11 @@ class LspServer(ABC):
port: int
id: str
+ @cached_property
+ def auth_token(self) -> str:
+ # This credential stays between the proxy and its child process.
+ return secrets.token_urlsafe(32)
+
@abstractmethod
async 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 == 0
except 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.py
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.py
index addd7bfc47..5526f9234b 100644
--- a/tests/_server/api/test_middleware.py
+++ b/tests/_server/api/test_middleware.py
@@ -9,6 +9,7 @@ import sys
import time
from multiprocessing import Process
from typing import TYPE_CHECKING, Any
+from unittest.mock import AsyncMock
from urllib.parse import quote
import pytest
@@ -23,6 +24,7 @@ from starlette.websockets import WebSocket, WebSocketDisconnect
from uvicorn import Config, Server
from marimo._config.manager import MarimoConfigManager, UserConfigManager
+from marimo._server._pylsp import create_server
from marimo._server.api.auth import TOKEN_QUERY_PARAM
from marimo._server.api.middleware import (
ProxyMiddleware,
@@ -39,7 +41,7 @@ from marimo._server.main import (
from marimo._server.session_manager import SessionManager
from marimo._server.tokens import AuthToken
from 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_thread
from tests._server.mocks import get_mock_session_manager, token_header
if TYPE_CHECKING:
@@ -825,7 +827,7 @@ class TestLspProxyMiddleware:
assert len(middlewares) == 1
assert 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) == 1
assert 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) == 2
assert 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:
pass
assert 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: Send
diff --git a/tests/_server/conftest.py b/tests/_server/conftest.py
index ae7c186a3e..24c977e3bf 100644
--- a/tests/_server/conftest.py
+++ b/tests/_server/conftest.py
@@ -4,6 +4,7 @@ from __future__ import annotations
import asyncio
import sys
import threading
+from contextlib import contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import TYPE_CHECKING
@@ -26,10 +27,39 @@ from tests._server.mocks import get_mock_session_manager
if 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.py
index 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 None
mock_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.py
new file mode 100644
index 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.py
new file mode 100644
index 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()