package p.studio.app.lsp; import com.fasterxml.jackson.databind.ObjectMapper; import org.eclipse.lsp4j.*; import org.eclipse.lsp4j.jsonrpc.json.MessageJsonHandler; import org.eclipse.lsp4j.jsonrpc.messages.Either; import org.eclipse.lsp4j.launch.LSPLauncher; import org.eclipse.lsp4j.services.*; import p.studio.api.automation.*; import p.studio.api.project.ProjectCatalog; import p.studio.core.language.LanguageQueryPort; import p.studio.core.language.LanguageQueryExecution; import p.studio.utilities.json.*; import p.studio.lsp.api.LspServerLifecycle; import p.studio.lsp.services.protocol.ExternalSourceLanguageServer; import org.eclipse.lsp4j.jsonrpc.Launcher; import java.net.*; import java.nio.file.*; import java.util.*; import java.util.concurrent.*; /** A real client of the already-running project LSP. Each query owns and closes its connection. */ public final class AutomationLspQueries implements LanguageQueryPort { private final LspServerLifecycle lifecycle; private final ProjectCatalog projects; private final ProjectKnowledge knowledge; private final ObjectMapper mapper; private final com.google.gson.Gson gson = new MessageJsonHandler(Map.of()).getGson(); private final Map> items = new ConcurrentHashMap<>(); private static final Set OPERATIONS = Set.of("readExternalSource", "diagnostics", "completion", "hover", "signatureHelp", "definition", "references", "documentSymbols", "workspaceSymbols", "prepareRename", "rename", "codeActions", "formatting", "documentLinks", "foldingRanges", "selectionRanges", "prepareCallHierarchy", "incomingCalls", "outgoingCalls", "semanticTokens"); private static final Set EDITS = Set.of("completion", "prepareRename", "rename", "codeActions", "formatting"); public AutomationLspQueries(LspServerLifecycle lifecycle, ProjectCatalog projects, ProjectKnowledge knowledge, ObjectMapper mapper) { this.lifecycle = lifecycle; this.projects = projects; this.knowledge = knowledge; this.mapper = mapper; } private record ExternalTask(String consumer, p.studio.lsp.messages.LspServerEndpoint endpoint, p.studio.lsp.messages.LspProjectContext binding, Set uris) {} private final Map externalTasks = new ConcurrentHashMap<>(); @Override public void endTask(TaskIdentity task) { items.remove(task); final var state = externalTasks.get(task); if (state == null) return; final var workers = Executors.newCachedThreadPool(); try (var socket = new Socket()) { socket.connect(new InetSocketAddress(state.endpoint().host(), state.endpoint().port()), 2000); final var client = new QuietClient(); final var launcher = new Launcher.Builder().setLocalService(client) .setRemoteInterface(ExternalSourceLanguageServer.class).setInput(socket.getInputStream()) .setOutput(socket.getOutputStream()).setExecutorService(workers).create(); final var listening = launcher.startListening(); try { final var server = launcher.getRemoteProxy(); final var init = new InitializeParams(); init.setRootUri(state.binding().projectRoot().toUri().toString()); init.setCapabilities(new ClientCapabilities()); init.getCapabilities().setExperimental(Map.of("prometeuExternalSources", true)); init.setInitializationOptions(Map.of("prometeuExternalConsumerId", state.consumer())); server.initialize(init).get(2, TimeUnit.SECONDS); server.releaseExternalSource(new ExternalSourceLanguageServer.Request(state.consumer(), null)).get(2, TimeUnit.SECONDS); externalTasks.remove(task, state); } finally { listening.cancel(true); } } catch (Exception failure) { // A closed project host has already released its registry. Other cleanup // failures are surfaced instead of silently reporting a successful task end. if (lifecycle.endpoint(state.binding()).isPresent()) throw new IllegalStateException("Could not release task external sources", failure); externalTasks.remove(task, state); } finally { new LanguageQueryExecution("endTask", 10_000, 2_000).finishWorkers(workers); } } private static class QuietClient implements LanguageClient { public void telemetryEvent(Object event) {} public void publishDiagnostics(PublishDiagnosticsParams event) {} public void showMessage(MessageParams message) {} public CompletableFuture showMessageRequest(ShowMessageRequestParams request) { return CompletableFuture.completedFuture(null); } public void logMessage(MessageParams message) {} } @Override public Map query(TaskIdentity task, String operation, Map parameters) throws Exception { return query(task, operation, parameters, new LanguageQueryExecution(operation, 10_000, 2_000)); } @Override public Map query(TaskIdentity task, String operation, Map parameters, LanguageQueryExecution execution) throws Exception { try { var result = performQuery(task, operation, parameters, execution); if (execution.hasFailure()) throw execution.exception(AutomationFailure.Code.LANGUAGE_QUERY_CLEANUP_FAILED, "Language query cleanup failed", true); return result; } catch (IllegalArgumentException | ControlDeniedException failure) { throw failure; } catch (Exception failure) { recordFailure(execution, failure); throw execution.exception(AutomationFailure.Code.LANGUAGE_QUERY_INTERNAL_FAILURE, "Language query failed", true); } } private Map performQuery(TaskIdentity task, String operation, Map parameters, LanguageQueryExecution execution) throws Exception { if (!OPERATIONS.contains(operation)) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "Unsupported language operation: " + operation); var context = knowledge.context(task.projectRoot()); var primary = context.languages().stream().filter(ProjectKnowledge.Language::primary).findFirst().orElseThrow(); if (primary.capabilities().stream().anyMatch(cap -> cap.name().equals("lsp") && cap.support() != ProjectKnowledge.Support.SUPPORTED)) throw failure(AutomationFailure.Code.UNSUPPORTED_LANGUAGE, "Project language has no available LSP"); var project = projects.openProject(context.projectRoot()); var binding = LspLifecycleAdapter.context(project); var endpoint = lifecycle.endpoint(binding).orElseThrow(() -> failure(AutomationFailure.Code.LANGUAGE_SERVER_UNAVAILABLE, "Project LSP is not running; reopen the project if its language changed")); var params = mapper.valueToTree(parameters); CallHierarchyItem item = null; String uri = null; if (operation.equals("incomingCalls") || operation.equals("outgoingCalls")) { item = items.getOrDefault(task, Map.of()).get(params.path("itemId").asText()); if (item == null) throw new IllegalArgumentException("Unknown task-local hierarchy itemId"); uri = item.getUri(); } else if (!operation.equals("workspaceSymbols")) { uri = params.path("uri").asText(null); if (uri == null) throw new IllegalArgumentException("uri is required"); } final boolean external = uri != null && uri.startsWith("prometeu-source:"); if (external) { final var state = externalTasks.get(task); if (state == null || !state.uris().contains(uri)) throw failure(AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, "Unknown task-owned external source"); if (EDITS.contains(operation)) throw failure(AutomationFailure.Code.READ_ONLY_SCOPE, "External sources are read-only"); if (!Set.of("readExternalSource", "hover", "definition").contains(operation)) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "Operation is unavailable for external documents"); } else if (operation.equals("readExternalSource")) throw new IllegalArgumentException("An external source URI is required"); Path document = uri == null || external ? null : sourcePath(context, uri); if (document != null && EDITS.contains(operation)) requireEditable(context, document.toUri().toString()); String source = null; if (document != null) { try (var input = Files.newInputStream(document)) { var bytes = input.readNBytes(4 * 1024 * 1024 + 1); if (bytes.length > 4 * 1024 * 1024) throw failure(AutomationFailure.Code.LIMIT_EXCEEDED, "Source document exceeds 4 MiB"); source = java.nio.charset.StandardCharsets.UTF_8.newDecoder().decode(java.nio.ByteBuffer.wrap(bytes)).toString(); } uri = document.toUri().toString(); } long deadline = execution.deadlineNanos(); if (System.nanoTime() >= deadline) throw new TimeoutException("Language query admission budget expired"); var workers = Executors.newCachedThreadPool(r -> { var thread = new Thread(r, "studio-automation-lsp"); thread.setDaemon(true); return thread; }); try (var socket = new Socket()) { execution.own(() -> { try { socket.close(); } catch (java.io.IOException ignored) {} }); execution.own(workers::shutdownNow); if (!InetAddress.getByName(endpoint.host()).isLoopbackAddress()) throw failure(AutomationFailure.Code.LANGUAGE_SERVER_UNAVAILABLE, "Project LSP endpoint is not local"); socket.connect(new InetSocketAddress(endpoint.host(), endpoint.port()), (int)Math.max(1, Math.min(2000, TimeUnit.NANOSECONDS.toMillis(deadline - System.nanoTime())))); var diagnostics = new CompletableFuture>(); String expectedUri = uri; LanguageClient client = new LanguageClient() { public void telemetryEvent(Object event) {} public void publishDiagnostics(PublishDiagnosticsParams event) { if (Objects.equals(event.getUri(), expectedUri)) diagnostics.complete(List.copyOf(event.getDiagnostics())); } public void showMessage(MessageParams message) {} public CompletableFuture showMessageRequest(ShowMessageRequestParams request) { return CompletableFuture.completedFuture(null); } public void logMessage(MessageParams message) {} @Override public CompletableFuture applyEdit(ApplyWorkspaceEditParams edit) { return CompletableFuture.completedFuture(new ApplyWorkspaceEditResponse(false)); } }; var launcher = new Launcher.Builder().setLocalService(client) .setRemoteInterface(ExternalSourceLanguageServer.class).setInput(socket.getInputStream()) .setOutput(socket.getOutputStream()).setExecutorService(workers).create(); var listening = launcher.startListening(); execution.own(() -> listening.cancel(true)); final var server = launcher.getRemoteProxy(); final var acquired = new HashSet(); boolean succeeded = false; try { var initialize = new InitializeParams(); initialize.setRootUri(binding.projectRoot().toUri().toString()); initialize.setCapabilities(new ClientCapabilities()); initialize.getCapabilities().setExperimental(Map.of("prometeuExternalSources", true, "prometeuDiagnosticAnalysis", Map.of("version", 1))); final var previous = externalTasks.get(task); initialize.setInitializationOptions(previous == null ? Map.of("prometeuExternalPersistentConsumer", true) : Map.of("prometeuExternalConsumerId", previous.consumer(), "prometeuExternalPersistentConsumer", true)); execution.method("initialize"); var capabilities = await(server.initialize(initialize), deadline, execution).getCapabilities(); final var experimental = gson.toJsonTree(capabilities.getExperimental()); if (experimental.isJsonObject() && experimental.getAsJsonObject().has("prometeuExternalConsumerId")) { final String consumer = experimental.getAsJsonObject().get("prometeuExternalConsumerId").getAsString(); externalTasks.putIfAbsent(task, new ExternalTask(consumer, endpoint, binding, ConcurrentHashMap.newKeySet())); } server.initialized(new InitializedParams()); requireCapability(operation, capabilities); List currentDiagnostics = List.of(); Map analysis = Map.of(); var rich = experimental.isJsonObject() ? experimental.getAsJsonObject().get("prometeuDiagnosticAnalysis") : null; boolean richAnalysis = rich != null && rich.isJsonObject() && rich.getAsJsonObject().has("version") && rich.getAsJsonObject().get("version").getAsInt() == 1; String digest = source == null ? null : sha256(source); if (document != null) { // Fresh client overlay contains exactly the saved UTF-8 file. Wait for analysis before querying. server.getTextDocumentService().didOpen(new DidOpenTextDocumentParams(new TextDocumentItem(uri, primary.id(), 1, source))); if (richAnalysis) { execution.method("prometeu/documentAnalysis"); var retained = await(server.documentAnalysis(new ExternalSourceLanguageServer.DiagnosticAnalysisRequest( new VersionedTextDocumentIdentifier(uri, 1), digest)), deadline, execution); analysis = mapper.convertValue(mapper.readTree(gson.toJson(retained)), Map.class); } currentDiagnostics = await(diagnostics, deadline, execution); } Map externalRevision = Map.of(); if (external) { final var request = new ExternalSourceLanguageServer.Request(externalTasks.get(task).consumer(), uri); var content = await(server.revalidateExternalSource(request), deadline, execution); source = content.text(); externalRevision = mapper.convertValue(mapper.readTree(gson.toJson(content)), Map.class); externalRevision = new LinkedHashMap<>(externalRevision); externalRevision.remove("text"); if (source.getBytes(java.nio.charset.StandardCharsets.UTF_8).length > 4 * 1024 * 1024) throw failure(AutomationFailure.Code.LIMIT_EXCEEDED, "External source exceeds 4 MiB"); } execution.method(operation); var text = server.getTextDocumentService(); var id = uri == null ? null : new TextDocumentIdentifier(uri); Object result = switch (operation) { case "readExternalSource" -> await(server.readExternalSource( new ExternalSourceLanguageServer.Request(externalTasks.get(task).consumer(), uri)), deadline, execution); case "diagnostics" -> currentDiagnostics; case "hover" -> await(text.hover(new HoverParams(id, position(params.path("position"), source))), deadline, execution); case "completion" -> await(text.completion(new CompletionParams(id, position(params.path("position"), source))), deadline, execution); case "signatureHelp" -> await(text.signatureHelp(new SignatureHelpParams(id, position(params.path("position"), source))), deadline, execution); case "definition" -> await(text.definition(new DefinitionParams(id, position(params.path("position"), source))), deadline, execution); case "references" -> await(text.references(new ReferenceParams(id, position(params.path("position"), source), new ReferenceContext(params.path("includeDeclaration").asBoolean(false)))), deadline, execution); case "documentSymbols" -> await(text.documentSymbol(new DocumentSymbolParams(id)), deadline, execution); case "workspaceSymbols" -> await(server.getWorkspaceService().symbol(new WorkspaceSymbolParams(params.path("query").asText(""))), deadline, execution); case "prepareRename" -> await(text.prepareRename(new PrepareRenameParams(id, position(params.path("position"), source))), deadline, execution); case "rename" -> { String name = params.path("newName").asText(""); if (name.isBlank()) throw new IllegalArgumentException("newName is required"); yield await(text.rename(new RenameParams(id, position(params.path("position"), source), name)), deadline, execution); } case "formatting" -> await(text.formatting(new DocumentFormattingParams(id, new FormattingOptions(4, true))), deadline, execution); case "codeActions" -> await(text.codeAction(new CodeActionParams(id, range(params.path("range"), source), new CodeActionContext(currentDiagnostics))), deadline, execution); case "documentLinks" -> await(text.documentLink(new DocumentLinkParams(id)), deadline, execution); case "foldingRanges" -> await(text.foldingRange(new FoldingRangeRequestParams(id)), deadline, execution); case "selectionRanges" -> { if (!params.path("positions").isArray() || params.path("positions").isEmpty()) throw new IllegalArgumentException("positions are required"); var positions = new ArrayList(); for (var p : params.path("positions")) positions.add(position(p, source)); yield await(text.selectionRange(new SelectionRangeParams(id, positions)), deadline, execution); } case "prepareCallHierarchy" -> await(text.prepareCallHierarchy(new CallHierarchyPrepareParams(id, position(params.path("position"), source))), deadline, execution); case "incomingCalls" -> await(text.callHierarchyIncomingCalls(new CallHierarchyIncomingCallsParams(item)), deadline, execution); case "outgoingCalls" -> await(text.callHierarchyOutgoingCalls(new CallHierarchyOutgoingCallsParams(item)), deadline, execution); case "semanticTokens" -> await(text.semanticTokensFull(new SemanticTokensParams(id)), deadline, execution); default -> throw new IllegalArgumentException("Unsupported operation"); }; var wire = mapper.readTree(gson.toJson(result)); validateEdits(context, wire); if (operation.equals("definition") && externalTasks.containsKey(task)) { final var returned = new HashSet(); rememberExternalUris(returned, wire); acquired.addAll(returned); acquired.removeAll(externalTasks.get(task).uris()); for (String externalUri : returned) { await(server.retainExternalSource(new ExternalSourceLanguageServer.Request( externalTasks.get(task).consumer(), externalUri)), deadline, execution); externalTasks.get(task).uris().add(externalUri); } } var limitations = new ArrayList(); if (operation.equals("codeActions") && wire.isArray()) { for (var action : wire) if (action.has("command")) { ((com.fasterxml.jackson.databind.node.ObjectNode) action).remove("command"); limitations.add("Executable LSP commands are not exposed; only edit proposals are returned"); } } if (operation.equals("prepareCallHierarchy") || operation.equals("incomingCalls") || operation.equals("outgoingCalls")) addItemIds(task, wire); var output = new LinkedHashMap(); output.put("operation", operation); output.put("result", mapper.convertValue(wire, Object.class)); if (document != null && !richAnalysis) { limitations.add("ANALYSIS_DETAILS_UNAVAILABLE"); analysis = ImmutableJson.fields("analysisId", null, "issues", List.of(), "summary", DiagnosticPayloads.legacySummary("document")); } output.put("limitations", limitations); output.put("analysis", analysis); output.put("context", ImmutableJson.fields("projectRoot", context.projectRoot().toString(), "taskId", task.value(), "clientRequestId", null, "buildId", null, "queryId", execution.queryId(), "analysisId", analysis.get("analysisId"), "document", document == null ? null : ImmutableJson.fields("uri", uri, "version", 1, "sha256", digest), "inputs", analysis.getOrDefault("inputs", List.of()), "externalRevision", externalRevision, "inputCoverage", "partial", "configuration", analysis.getOrDefault("configuration", Map.of()))); succeeded = true; return Collections.unmodifiableMap(output); } catch (Exception failure) { recordFailure(execution, failure); throw failure; } finally { if (!succeeded && !acquired.isEmpty() && externalTasks.containsKey(task)) { final var state = externalTasks.get(task); final boolean interrupted = Thread.interrupted(); try { for (String acquiredUri : acquired) { state.uris().remove(acquiredUri); server.releaseExternalSource(new ExternalSourceLanguageServer.Request(state.consumer(), acquiredUri)) .get(500, TimeUnit.MILLISECONDS); } } catch (Exception cleanupFailure) { execution.record(AutomationFailure.Code.LANGUAGE_QUERY_CLEANUP_FAILED, "Could not release query external sources", Map.of()); } finally { if (interrupted) Thread.currentThread().interrupt(); } } listening.cancel(true); } } finally { execution.finishWorkers(workers); } } private static String sha256(String text) throws java.security.NoSuchAlgorithmException { return HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256") .digest(text.getBytes(java.nio.charset.StandardCharsets.UTF_8))); } private static void recordFailure(LanguageQueryExecution execution, Exception failure) { if (failure instanceof AutomationException domain) { execution.record(domain.failure()); return; } if (failure instanceof IllegalArgumentException || failure instanceof ControlDeniedException) return; var cause = failure instanceof ExecutionException && failure.getCause() != null ? failure.getCause() : failure; AutomationFailure.Code code; Map details = Map.of(); if (cause instanceof TimeoutException || cause instanceof SocketTimeoutException) code = AutomationFailure.Code.LANGUAGE_QUERY_TIMEOUT; else if (cause instanceof InterruptedException || cause instanceof CancellationException) code = AutomationFailure.Code.LANGUAGE_QUERY_CANCELLED; else if (cause instanceof ConnectException || cause instanceof SocketException) code = AutomationFailure.Code.LANGUAGE_SERVER_UNAVAILABLE; else if (cause instanceof org.eclipse.lsp4j.jsonrpc.ResponseErrorException response) { int rpc = response.getResponseError().getCode(); details = ImmutableJson.fields("protocolCode", rpc, "reason", rpc == -32020 ? "ANALYSIS_REVISION_MISMATCH" : rpc == -32021 ? "ANALYSIS_UNAVAILABLE" : null); code = rpc == -32020 ? AutomationFailure.Code.LANGUAGE_QUERY_REVISION_MISMATCH : rpc == -32021 || rpc == -32603 ? AutomationFailure.Code.LANGUAGE_QUERY_INTERNAL_FAILURE : AutomationFailure.Code.LANGUAGE_QUERY_PROTOCOL_FAILURE; } else if (cause instanceof org.eclipse.lsp4j.jsonrpc.JsonRpcException || cause instanceof com.google.gson.JsonParseException || cause instanceof com.fasterxml.jackson.core.JsonProcessingException) code = AutomationFailure.Code.LANGUAGE_QUERY_PROTOCOL_FAILURE; else code = AutomationFailure.Code.LANGUAGE_QUERY_INTERNAL_FAILURE; execution.record(code, "Language query failed: " + code.name(), details); } private void rememberExternalUris(Set uris, com.fasterxml.jackson.databind.JsonNode node) { if (node.isObject() && node.path("uri").asText().startsWith("prometeu-source:")) uris.add(node.path("uri").asText()); if (node.isContainerNode()) node.forEach(child -> rememberExternalUris(uris, child)); } private void addItemIds(TaskIdentity task, com.fasterxml.jackson.databind.JsonNode node) { if (node.isObject() && node.has("uri") && node.has("selectionRange") && node.has("name") && node.has("kind")) { var stored = items.computeIfAbsent(task, ignored -> new ConcurrentHashMap<>()); if (stored.size() >= 1024) throw failure(AutomationFailure.Code.LIMIT_EXCEEDED, "Too many hierarchy items for this task"); String key = UUID.randomUUID().toString(); stored.put(key, gson.fromJson(node.toString(), CallHierarchyItem.class)); ((com.fasterxml.jackson.databind.node.ObjectNode) node).put("itemId", key); } else if (node.isContainerNode()) node.forEach(child -> addItemIds(task, child)); } private static void requireCapability(String operation, ServerCapabilities caps) { if (operation.equals("readExternalSource")) { final var raw = new com.google.gson.Gson().toJsonTree(caps.getExperimental()); if (!raw.isJsonObject() || !raw.getAsJsonObject().has("prometeuExternalSources")) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "LSP does not advertise external sources"); return; } Object capability = switch (operation) { case "diagnostics" -> caps.getTextDocumentSync(); case "hover" -> caps.getHoverProvider(); case "completion" -> caps.getCompletionProvider(); case "signatureHelp" -> caps.getSignatureHelpProvider(); case "definition" -> caps.getDefinitionProvider(); case "references" -> caps.getReferencesProvider(); case "documentSymbols" -> caps.getDocumentSymbolProvider(); case "workspaceSymbols" -> caps.getWorkspaceSymbolProvider(); case "rename", "prepareRename" -> caps.getRenameProvider(); case "codeActions" -> caps.getCodeActionProvider(); case "formatting" -> caps.getDocumentFormattingProvider(); case "documentLinks" -> caps.getDocumentLinkProvider(); case "foldingRanges" -> caps.getFoldingRangeProvider(); case "selectionRanges" -> caps.getSelectionRangeProvider(); case "prepareCallHierarchy", "incomingCalls", "outgoingCalls" -> caps.getCallHierarchyProvider(); case "semanticTokens" -> caps.getSemanticTokensProvider(); default -> null; }; if (capability instanceof Either either) capability = either.isLeft() ? either.getLeft() : either.getRight(); if (operation.equals("prepareRename") && (!(capability instanceof RenameOptions options) || !Boolean.TRUE.equals(options.getPrepareProvider()))) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "LSP does not advertise prepareRename"); if (capability == null || Boolean.FALSE.equals(capability)) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "LSP does not advertise " + operation); } private static Position position(com.fasterxml.jackson.databind.JsonNode node, String text) { if (!node.path("line").isIntegralNumber() || !node.path("character").isIntegralNumber() || !node.path("line").canConvertToInt() || !node.path("character").canConvertToInt()) throw new IllegalArgumentException("UTF-16 position is required"); int line = node.path("line").intValue(), character = node.path("character").intValue(); String[] lines = text.split("\\r\\n|\\n|\\r", -1); if (line < 0 || line >= lines.length || character < 0 || character > lines[line].length() || character > 0 && character < lines[line].length() && Character.isHighSurrogate(lines[line].charAt(character - 1)) && Character.isLowSurrogate(lines[line].charAt(character))) throw new IllegalArgumentException("Position is outside the saved document or splits a UTF-16 pair"); return new Position(line, character); } private static Range range(com.fasterxml.jackson.databind.JsonNode node, String text) { var start = position(node.path("start"), text); var end = position(node.path("end"), text); if (start.getLine() > end.getLine() || start.getLine() == end.getLine() && start.getCharacter() > end.getCharacter()) throw new IllegalArgumentException("Range end precedes its start"); return new Range(start, end); } private static Path sourcePath(ProjectKnowledge.Context context, String uri) throws Exception { final Path path; try { path = Path.of(URI.create(uri)).toRealPath(); } catch (RuntimeException | java.io.IOException invalid) { throw failure(AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, "Source URI is not an accessible local project/dependency file"); } boolean scope = path.startsWith(context.projectRoot()) || context.readOnlyRoots().stream().anyMatch(path::startsWith) || context.libraries().stream().flatMap(lib -> lib.roots().stream()).anyMatch(path::startsWith); boolean source = context.languages().stream().flatMap(lang -> lang.extensions().stream()).anyMatch(extension -> path.getFileName().toString().endsWith("." + extension)); if (!scope || !source || !Files.isRegularFile(path)) throw failure(AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, "URI is outside the known source scope"); return path; } private static void requireEditable(ProjectKnowledge.Context context, String uri) throws Exception { Path path = sourcePath(context, uri); if (!path.startsWith(context.projectRoot()) || context.readOnlyRoots().stream().anyMatch(path::startsWith)) throw failure(AutomationFailure.Code.READ_ONLY_SCOPE, "LSP edit proposal targets a read-only SDK/dependency"); } private static void validateEdits(ProjectKnowledge.Context context, com.fasterxml.jackson.databind.JsonNode node) throws Exception { if (node.isObject()) { if (node.has("changes")) { var fields = node.path("changes").fieldNames(); while (fields.hasNext()) requireEditable(context, fields.next()); } if (node.has("textDocument") && node.has("edits")) requireEditable(context, node.path("textDocument").path("uri").asText()); if (node.has("kind") && Set.of("create", "rename", "delete").contains(node.path("kind").asText())) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "LSP file operations are not exposed"); } if (node.isContainerNode()) for (var child : node) validateEdits(context, child); } private static T await(CompletableFuture future, long deadline, LanguageQueryExecution execution) throws Exception { execution.own(() -> future.cancel(true)); try { return future.get(Math.max(1, deadline - System.nanoTime()), TimeUnit.NANOSECONDS); } catch (ExecutionException failure) { if (failure.getCause() instanceof org.eclipse.lsp4j.jsonrpc.ResponseErrorException response) { int code = response.getResponseError().getCode(); if (code == -32010) throw failure(AutomationFailure.Code.READ_ONLY_SCOPE, response.getResponseError().getMessage()); if (code == -32602) throw new IllegalArgumentException("LSP rejected query parameters"); if (code == -32601 || code == -32600) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, response.getResponseError().getMessage()); } throw failure; } catch (Exception failure) { future.cancel(true); throw failure; } } private static AutomationException failure(AutomationFailure.Code code, String message) { return new AutomationException(code, message); } }