From c1834bad1f68fc4a4236d2770f4ce977d5270ef4 Mon Sep 17 00:00:00 2001 From: bQUARKz Date: Tue, 29 Sep 2026 09:21:59 +0100 Subject: [PATCH] connect MCP language queries to project LSP --- ...CP Tools and Project Knowledge Contract.md | 66 ++++- prometeu-app/build.gradle.kts | 1 + .../app/StudioApplicationConfiguration.java | 21 +- .../compiler/CompilerProjectKnowledge.java | 2 + .../studio/app/lsp/AutomationLspQueries.java | 245 ++++++++++++++++++ .../p/studio/app/lsp/LspLifecycleAdapter.java | 18 +- .../p/studio/app/mcp/McpLanguageTools.java | 18 ++ .../main/resources/mcp/studio-tools-v1.json | 2 +- .../StudioApplicationConfigurationTest.java | 3 +- .../app/lsp/AutomationLspQueriesTest.java | 210 +++++++++++++++ .../architecture/StudioBoundaryArchTest.java | 2 +- .../p/studio/lsp/api/LspServerLifecycle.java | 4 + .../lsp/services/LspServerLifecycleImpl.java | 6 + .../studio/lsp/services/TcpLspServerHost.java | 18 +- .../lsp/services/LspServerLifecycleTest.java | 37 +++ .../api/automation/AutomationSession.java | 2 + .../api/automation/LanguageQueries.java | 9 + .../core/language/LanguageQueryPort.java | 10 + .../core/language/TaskLanguageQueries.java | 55 ++++ .../core/project/ProjectAccessRegistry.java | 19 +- .../session/DefaultAutomationSession.java | 9 + .../session/DefaultProjectSessionFactory.java | 2 +- .../p/studio/core/StudioModularityTest.java | 2 +- .../session/DefaultAutomationSessionTest.java | 17 ++ 24 files changed, 757 insertions(+), 21 deletions(-) create mode 100644 prometeu-app/src/main/java/p/studio/app/lsp/AutomationLspQueries.java create mode 100644 prometeu-app/src/main/java/p/studio/app/mcp/McpLanguageTools.java create mode 100644 prometeu-app/src/test/java/p/studio/app/lsp/AutomationLspQueriesTest.java create mode 100644 prometeu-lsp/prometeu-lsp-v1/src/test/java/p/studio/lsp/services/LspServerLifecycleTest.java create mode 100644 prometeu-studio-api/src/main/java/p/studio/api/automation/LanguageQueries.java create mode 100644 prometeu-studio-core/src/main/java/p/studio/core/language/LanguageQueryPort.java create mode 100644 prometeu-studio-core/src/main/java/p/studio/core/language/TaskLanguageQueries.java diff --git a/docs/specs/studio/11. MCP Tools and Project Knowledge Contract.md b/docs/specs/studio/11. MCP Tools and Project Knowledge Contract.md index 137b4d8a..4a5c5e9b 100644 --- a/docs/specs/studio/11. MCP Tools and Project Knowledge Contract.md +++ b/docs/specs/studio/11. MCP Tools and Project Knowledge Contract.md @@ -125,6 +125,68 @@ symbols reuse the existing project LSP. Other queries/refactoring proposals are exposed only when supported; returned edits MUST respect project versus read-only SDK/library scope. No query applies filesystem edits. +### 3.1 Language Query Operations + +`studio_language_query` uses the existing project's LSP server via a real client, +not a parallel language implementation or a direct call into compiler semantics. +Its successful value is `{operation, result, limitations}`. `result` is the JSON +projection of the existing LSP response (including null or an empty list when +appropriate); LSP union wrappers are unwrapped. Provider classes remain inside +the application adapter. Studio API/Core use maps, lists and scalar values only. + +| Operation | Required parameters beyond projectRoot/taskId | +| --- | --- | +| `diagnostics`, `documentSymbols`, `documentLinks`, `foldingRanges`, `formatting`, `semanticTokens` | `parameters.uri` | +| `hover`, `completion`, `signatureHelp`, `definition`, `references`, `prepareRename`, `prepareCallHierarchy` | `uri`, `position`; references optionally accepts `includeDeclaration` | +| `rename` | `uri`, `position`, `newName` | +| `workspaceSymbols` | optional `query`; no document URI is needed | +| `selectionRanges` | `uri`, nonempty `positions` | +| `codeActions` | `uri`, ordered `range`; diagnostics are obtained from the current saved file | +| `incomingCalls`, `outgoingCalls` | task-local `itemId` from a hierarchy result | + +Support MUST be checked against the running server's initialize response before +dispatch. Unknown operations, including currently unsupported type hierarchy, +return `UNSUPPORTED_CAPABILITY`. Context publishes the installed provider's +capabilities, including semantic tokens; hierarchy and rename preparations use +their corresponding server capability. Positions are zero-based UTF-16 offsets, +must fit the saved file and must not split surrogate pairs. Reversed ranges and +missing operation-specific parameters are rejected. + +The application lifecycle supplies each open project's bound loopback LSP +endpoint. Studio uses OS-assigned ports so different open projects do not compete +for one fixed port. The public LSP configuration default remains unchanged for +other hosts. A manifest language change requires reopening that project's server; +the adapter MUST NOT send queries to a server bound to another language/root. + +Each query uses a short-lived client connection. For document requests, the +adapter opens exactly the saved UTF-8 text and waits for that connection's +published diagnostics before issuing the semantic query. Other dependency files +are read from disk by the existing compiler bridge. A fresh connection prevents +reuse of stale overlays from previous requests or the human editor. Unsaved or +concurrent external writes remain the developer's responsibility. + +Queries require the current task, share the project's work admission/cancellation +and DEV operation observation, and do not silently queue behind conflicting work. +Return/reclaim invalidates the task immediately, waits for worker termination, +then clears task-local hierarchy items before manual control is restored. Item +IDs from another task or project cannot be used. Client sockets/listeners close +on success, failure, timeout or cancellation; project-server shutdown closes its +accepted sockets and executor. A lost client does not independently grant control. + +The adapter bounds connect time to 2 seconds and the LSP exchange to 10 seconds; +Core bounds the request worker wait to 12 seconds. Documents are limited to 4 MiB +of UTF-8 and task-local hierarchy state to 1024 items. These are adapter resource +guards, unrelated to the runtime's deterministic frame/watchdog semantics. + +Document URIs must resolve to known physical project/dependency source files. +Symlink targets are canonicalized before admission. External sources may be +queried, but edit-producing queries on read-only roots are rejected. Every URI in +returned workspace-edit proposals is checked against the same editable/read-only +scope; an unsafe proposal is rejected as a whole. File-operation edits and +executable commands are not offered; `workspace/applyEdit` is always refused. +No query writes a file. Virtual SDK declarations may not have physical definition +locations in the existing LSP; indexed SDK references remain available instead. + ## 4. Result, Error and Operation Contracts Successful tools return `isError:false` with structuredContent @@ -294,8 +356,8 @@ authentication, Origin, endpoint/method/version handling, tool dispatch, malform or oversized input, closure, restart and old-token rejection. Provider doubles exist only in tests. Composition starts/closes transport with Studio. -The production registry composes `studio_project_context` and `studio_reference_read` -as of step 18; other +The production registry composes `studio_project_context`, `studio_reference_read` +and `studio_language_query` as of step 19; other tools are advertised only when their functional handlers are connected. DEV configuration-copy stays unavailable until step 21. Passing this transport gate is not the phase 3 or final external-agent acceptance gate. API/Core and diff --git a/prometeu-app/build.gradle.kts b/prometeu-app/build.gradle.kts index 6989992f..1e2ad67e 100644 --- a/prometeu-app/build.gradle.kts +++ b/prometeu-app/build.gradle.kts @@ -17,6 +17,7 @@ dependencies { implementation(project(":prometeu-studio-core")) implementation(project(":prometeu-studio-ui-javafx")) implementation(libs.spring.boot) + implementation(libs.lsp4j) implementation(libs.javafx.controls) implementation(libs.javafx.fxml) } diff --git a/prometeu-app/src/main/java/p/studio/app/StudioApplicationConfiguration.java b/prometeu-app/src/main/java/p/studio/app/StudioApplicationConfiguration.java index f083c0f7..f19dbae9 100644 --- a/prometeu-app/src/main/java/p/studio/app/StudioApplicationConfiguration.java +++ b/prometeu-app/src/main/java/p/studio/app/StudioApplicationConfiguration.java @@ -301,12 +301,25 @@ public class StudioApplicationConfiguration { return new p.studio.app.compiler.CompilerProjectKnowledge(projects, catalog, mapper); } + @Bean + p.studio.core.language.LanguageQueryPort automationLanguagePort(LspServerLifecycle lifecycle, ProjectCatalog catalog, + p.studio.api.automation.ProjectKnowledge knowledge, ObjectMapper mapper) { + return new p.studio.app.lsp.AutomationLspQueries(lifecycle, catalog, knowledge, mapper); + } + + @Bean + p.studio.api.automation.LanguageQueries languageQueries(p.studio.core.project.ProjectAccessRegistry projects, + p.studio.core.language.LanguageQueryPort language) { + return new p.studio.core.language.TaskLanguageQueries(projects, language); + } + @Bean p.studio.app.mcp.McpToolRegistry mcpToolRegistry(p.studio.app.mcp.McpToolCatalog catalog, ObjectMapper mapper, - p.studio.api.automation.ProjectKnowledge knowledge) { - // Further providers are connected in PLN-0139 steps 19–20. Never advertise placeholders. - return new p.studio.app.mcp.McpToolRegistry(catalog, mapper, - p.studio.app.mcp.McpProjectKnowledgeTools.handlers(knowledge, mapper)); + p.studio.api.automation.ProjectKnowledge knowledge, p.studio.api.automation.LanguageQueries language) { + // Control/build/runtime/operation providers are connected in PLN-0139 step 20. + var handlers = new java.util.LinkedHashMap<>(p.studio.app.mcp.McpProjectKnowledgeTools.handlers(knowledge, mapper)); + handlers.putAll(p.studio.app.mcp.McpLanguageTools.handlers(language, mapper)); + return new p.studio.app.mcp.McpToolRegistry(catalog, mapper, handlers); } @Bean(initMethod = "start", destroyMethod = "close") diff --git a/prometeu-app/src/main/java/p/studio/app/compiler/CompilerProjectKnowledge.java b/prometeu-app/src/main/java/p/studio/app/compiler/CompilerProjectKnowledge.java index e3fb0e6b..f5013a0a 100644 --- a/prometeu-app/src/main/java/p/studio/app/compiler/CompilerProjectKnowledge.java +++ b/prometeu-app/src/main/java/p/studio/app/compiler/CompilerProjectKnowledge.java @@ -153,6 +153,7 @@ public final class CompilerProjectKnowledge implements ProjectKnowledge { } } limitations.add("SDK resources are provider-owned, read-only resources, not editable project files"); + limitations.add("Virtual SDK symbols may have no physical LSP definition location; consult indexed SDK references"); // Closing a project during discovery must not publish a successful context for that closed project. openProjects.requireOpenRoot(root); var descriptors = references.values().stream().map(owned -> { @@ -232,6 +233,7 @@ public final class CompilerProjectKnowledge implements ProjectKnowledge { } capabilities.add(capability("lsp", true)); capabilities.add(capability("diagnostics", true)); + capabilities.add(capability("semanticTokens", true)); capabilities.add(capability("hover", server.hoverSupported())); capabilities.add(capability("completion", server.completionSupported())); capabilities.add(capability("signatureHelp", server.signatureHelpSupported())); diff --git a/prometeu-app/src/main/java/p/studio/app/lsp/AutomationLspQueries.java b/prometeu-app/src/main/java/p/studio/app/lsp/AutomationLspQueries.java new file mode 100644 index 00000000..a6da7ee9 --- /dev/null +++ b/prometeu-app/src/main/java/p/studio/app/lsp/AutomationLspQueries.java @@ -0,0 +1,245 @@ +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.lsp.api.LspServerLifecycle; + +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("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; + } + + @Override public void endTask(TaskIdentity task) { items.remove(task); } + + @Override public Map query(TaskIdentity task, String operation, Map parameters) 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.INFRASTRUCTURE_FAILURE, "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"); + } + Path document = uri == null ? 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 = System.nanoTime() + TimeUnit.SECONDS.toNanos(10); + var workers = Executors.newCachedThreadPool(r -> { var thread = new Thread(r, "studio-automation-lsp"); thread.setDaemon(true); return thread; }); + try (var socket = new Socket()) { + if (!InetAddress.getByName(endpoint.host()).isLoopbackAddress()) throw failure(AutomationFailure.Code.INFRASTRUCTURE_FAILURE, "Project LSP endpoint is not local"); + socket.connect(new InetSocketAddress(endpoint.host(), endpoint.port()), 2000); + 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 = LSPLauncher.createClientLauncher(client, socket.getInputStream(), socket.getOutputStream(), workers, consumer -> consumer); + var listening = launcher.startListening(); + try { + var server = launcher.getRemoteProxy(); + var initialize = new InitializeParams(); + initialize.setRootUri(binding.projectRoot().toUri().toString()); + initialize.setCapabilities(new ClientCapabilities()); + var capabilities = await(server.initialize(initialize), deadline).getCapabilities(); + server.initialized(new InitializedParams()); + requireCapability(operation, capabilities); + List currentDiagnostics = List.of(); + 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))); + currentDiagnostics = await(diagnostics, deadline); + } + var text = server.getTextDocumentService(); + var id = uri == null ? null : new TextDocumentIdentifier(uri); + Object result = switch (operation) { + case "diagnostics" -> currentDiagnostics; + case "hover" -> await(text.hover(new HoverParams(id, position(params.path("position"), source))), deadline); + case "completion" -> await(text.completion(new CompletionParams(id, position(params.path("position"), source))), deadline); + case "signatureHelp" -> await(text.signatureHelp(new SignatureHelpParams(id, position(params.path("position"), source))), deadline); + case "definition" -> await(text.definition(new DefinitionParams(id, position(params.path("position"), source))), deadline); + case "references" -> await(text.references(new ReferenceParams(id, position(params.path("position"), source), new ReferenceContext(params.path("includeDeclaration").asBoolean(false)))), deadline); + case "documentSymbols" -> await(text.documentSymbol(new DocumentSymbolParams(id)), deadline); + case "workspaceSymbols" -> await(server.getWorkspaceService().symbol(new WorkspaceSymbolParams(params.path("query").asText(""))), deadline); + case "prepareRename" -> await(text.prepareRename(new PrepareRenameParams(id, position(params.path("position"), source))), deadline); + 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); + } + case "formatting" -> await(text.formatting(new DocumentFormattingParams(id, new FormattingOptions(4, true))), deadline); + case "codeActions" -> await(text.codeAction(new CodeActionParams(id, + range(params.path("range"), source), + new CodeActionContext(currentDiagnostics))), deadline); + case "documentLinks" -> await(text.documentLink(new DocumentLinkParams(id)), deadline); + case "foldingRanges" -> await(text.foldingRange(new FoldingRangeRequestParams(id)), deadline); + 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); + } + case "prepareCallHierarchy" -> await(text.prepareCallHierarchy(new CallHierarchyPrepareParams(id, position(params.path("position"), source))), deadline); + case "incomingCalls" -> await(text.callHierarchyIncomingCalls(new CallHierarchyIncomingCallsParams(item)), deadline); + case "outgoingCalls" -> await(text.callHierarchyOutgoingCalls(new CallHierarchyOutgoingCallsParams(item)), deadline); + case "semanticTokens" -> await(text.semanticTokensFull(new SemanticTokensParams(id)), deadline); + default -> throw new IllegalArgumentException("Unsupported operation"); + }; + var wire = mapper.readTree(gson.toJson(result)); + validateEdits(context, wire); + 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)); + output.put("limitations", limitations); + return Collections.unmodifiableMap(output); + } finally { listening.cancel(true); } + } finally { workers.shutdownNow(); } + } + + 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) { + 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) throws Exception { + 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 == -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); } +} diff --git a/prometeu-app/src/main/java/p/studio/app/lsp/LspLifecycleAdapter.java b/prometeu-app/src/main/java/p/studio/app/lsp/LspLifecycleAdapter.java index a1aef156..5065659f 100644 --- a/prometeu-app/src/main/java/p/studio/app/lsp/LspLifecycleAdapter.java +++ b/prometeu-app/src/main/java/p/studio/app/lsp/LspLifecycleAdapter.java @@ -10,6 +10,7 @@ import java.util.Objects; public final class LspLifecycleAdapter implements LspLifecyclePort { private final LspServerLifecycle lifecycle; + private final java.util.Map bindings = new java.util.concurrent.ConcurrentHashMap<>(); public LspLifecycleAdapter(LspServerLifecycle lifecycle) { this.lifecycle = Objects.requireNonNull(lifecycle, "lifecycle"); @@ -17,19 +18,26 @@ public final class LspLifecycleAdapter implements LspLifecyclePort { @Override public void boot(ProjectReference project) { - lifecycle.bootServer(LspServerConfiguration.defaults(), context(project)); + var binding = context(project); + lifecycle.bootServer(LspServerConfiguration.builder().endpoint( + new p.studio.lsp.messages.LspServerEndpoint("127.0.0.1", 0)).build(), binding); + bindings.put(project.rootPath().toAbsolutePath().normalize(), binding); } @Override public void shutdown(ProjectReference project) { - lifecycle.shutdownServer(context(project)); + var binding = bindings.remove(project.rootPath().toAbsolutePath().normalize()); + if (binding != null) lifecycle.shutdownServer(binding); } - private static LspProjectContext context(ProjectReference project) { + static LspProjectContext context(ProjectReference project) { final var safeProject = Objects.requireNonNull(project, "project"); + final java.nio.file.Path root; + try { root = safeProject.rootPath().toRealPath(); } + catch (java.io.IOException failure) { throw new IllegalStateException("Project root unavailable", failure); } return new LspProjectContext( - safeProject.rootPath().toAbsolutePath().normalize().toString(), + root.toString(), safeProject.languageId(), - safeProject.rootPath()); + root); } } diff --git a/prometeu-app/src/main/java/p/studio/app/mcp/McpLanguageTools.java b/prometeu-app/src/main/java/p/studio/app/mcp/McpLanguageTools.java new file mode 100644 index 00000000..1a81f030 --- /dev/null +++ b/prometeu-app/src/main/java/p/studio/app/mcp/McpLanguageTools.java @@ -0,0 +1,18 @@ +package p.studio.app.mcp; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import p.studio.api.automation.LanguageQueries; +import java.nio.file.Path; +import java.util.Map; +import java.util.function.Function; + +public final class McpLanguageTools { + private McpLanguageTools() {} + public static Map> handlers(LanguageQueries language, ObjectMapper mapper) { + return Map.of("studio_language_query", arguments -> McpToolResult.success(mapper, mapper.valueToTree( + language.query(Path.of(arguments.path("projectRoot").asText()), arguments.path("taskId").asText(), + arguments.path("operation").asText(), mapper.convertValue(arguments.path("parameters"), + new com.fasterxml.jackson.core.type.TypeReference>() {}))))); + } +} diff --git a/prometeu-app/src/main/resources/mcp/studio-tools-v1.json b/prometeu-app/src/main/resources/mcp/studio-tools-v1.json index 276b109e..9e5bb926 100644 --- a/prometeu-app/src/main/resources/mcp/studio-tools-v1.json +++ b/prometeu-app/src/main/resources/mcp/studio-tools-v1.json @@ -573,7 +573,7 @@ }, "exampleValue": { "operation": "definition", - "locations": [], + "result": [], "limitations": [] } }, diff --git a/prometeu-app/src/test/java/p/studio/app/StudioApplicationConfigurationTest.java b/prometeu-app/src/test/java/p/studio/app/StudioApplicationConfigurationTest.java index dc6a5dad..f0f6ded7 100644 --- a/prometeu-app/src/test/java/p/studio/app/StudioApplicationConfigurationTest.java +++ b/prometeu-app/src/test/java/p/studio/app/StudioApplicationConfigurationTest.java @@ -30,9 +30,10 @@ class StudioApplicationConfigurationTest { assertFalse(executor.isShutdown()); assertTrue(mcp.isRunning()); var tools = context.getBean(p.studio.app.mcp.McpToolRegistry.class).descriptors(); - org.junit.jupiter.api.Assertions.assertEquals(2, tools.size()); + org.junit.jupiter.api.Assertions.assertEquals(3, tools.size()); org.junit.jupiter.api.Assertions.assertEquals("studio_project_context", tools.get(0).path("name").asText()); org.junit.jupiter.api.Assertions.assertEquals("studio_reference_read", tools.get(1).path("name").asText()); + org.junit.jupiter.api.Assertions.assertEquals("studio_language_query", tools.get(2).path("name").asText()); } assertTrue(executor.isShutdown()); assertFalse(mcp.isRunning()); diff --git a/prometeu-app/src/test/java/p/studio/app/lsp/AutomationLspQueriesTest.java b/prometeu-app/src/test/java/p/studio/app/lsp/AutomationLspQueriesTest.java new file mode 100644 index 00000000..ea648396 --- /dev/null +++ b/prometeu-app/src/test/java/p/studio/app/lsp/AutomationLspQueriesTest.java @@ -0,0 +1,210 @@ +package p.studio.app.lsp; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.io.TempDir; +import p.studio.api.automation.*; +import p.studio.api.session.ProjectSession; +import p.studio.app.compiler.CompilerProjectKnowledge; +import p.studio.app.operation.ExecutorOperationExecutor; +import p.studio.core.language.TaskLanguageQueries; +import p.studio.core.project.*; +import p.studio.core.session.DefaultProjectSessionFactory; +import p.studio.lsp.services.LspServerLifecycleImpl; +import java.nio.file.*; +import java.util.*; +import java.util.concurrent.*; +import static org.junit.jupiter.api.Assertions.*; + +class AutomationLspQueriesTest { + @TempDir Path temporary; + final ObjectMapper mapper = new ObjectMapper(); + final ExecutorService workers = Executors.newCachedThreadPool(); + final LspServerLifecycleImpl lifecycle = new LspServerLifecycleImpl(); + ProjectSession session; + TaskLanguageQueries queries; + final ProjectAccessRegistry access = new ProjectAccessRegistry(); + Path root, source; + String task; + static final String CODE = "fn helper() -> int { return 1; }\nfn main() -> int { return helper(); }\n"; + + @BeforeEach void open() throws Exception { + root = Files.createDirectory(temporary.resolve("app")).toRealPath(); + source = Files.createDirectories(root.resolve("src")).resolve("main.pbs"); + manifest(root, "app", List.of()); + Files.writeString(source, CODE); + Files.writeString(source.resolveSibling("mod.barrel"), "pub fn helper() -> int;\npub fn main() -> int;\n"); + var setup = new ProjectLocalStudioSetupStore(mapper); + var catalog = new ProjectCatalogService(temporary, mapper, setup); + session = new DefaultProjectSessionFactory(new ProjectLocalStudioStateStore(mapper), setup, + new LspLifecycleAdapter(lifecycle), access, new ExecutorOperationExecutor(workers)).open(catalog.openProject(root)); + var knowledge = new CompilerProjectKnowledge(access, catalog, mapper); + queries = new TaskLanguageQueries(access, new AutomationLspQueries(lifecycle, catalog, knowledge, mapper)); + } + @AfterEach void close() { if (session != null) session.close(); workers.shutdownNow(); } + void acquire() { + assertTrue(session.automation().grant(false).toCompletableFuture().join().success()); + task = session.automation().acquire().task().value(); + } + JsonNode query(String operation, Map parameters) { + return mapper.valueToTree(queries.query(root, task, operation, parameters)); + } + Map at(int line, int character) { + return Map.of("uri", source.toUri().toString(), "position", Map.of("line", line, "character", character)); + } + @Test void diagnosticsAndNavigationSeeSavedChangesOverTheActualServer() throws Exception { + acquire(); + assertTrue(query("diagnostics", at(0, 0)).path("result").isArray()); + var definition = query("definition", at(1, 26)).path("result"); + assertFalse(definition.isEmpty(), definition.toString()); + assertEquals(source.toUri().toString(), definition.get(0).path("uri").asText()); + Files.writeString(source, "fn main( {"); + assertFalse(query("diagnostics", at(0, 0)).path("result").isEmpty()); + Files.writeString(source, CODE.replace("helper", "renamed")); + Files.writeString(source.resolveSibling("mod.barrel"), "pub fn renamed() -> int;\npub fn main() -> int;\n"); + var symbols = query("documentSymbols", at(0, 0)).path("result"); + assertTrue(symbols.toString().contains("renamed"), symbols.toString()); + assertFalse(symbols.toString().contains("helper"), symbols.toString()); + } + @Test void proposalsDoNotWriteFilesAndQueriesCoverAdvertisedOperations() throws Exception { + acquire(); + for (String operation : List.of("hover", "completion", "signatureHelp", "references", "prepareRename", "semanticTokens")) + assertEquals(operation, query(operation, at(1, 26)).path("operation").asText()); + for (String operation : List.of("documentLinks", "foldingRanges", "formatting")) + assertEquals(operation, query(operation, at(0, 0)).path("operation").asText()); + assertEquals("workspaceSymbols", query("workspaceSymbols", Map.of("query", "helper")).path("operation").asText()); + var rename = new HashMap<>(at(1, 26)); rename.put("newName", "renamed"); + assertTrue(query("rename", rename).path("result").has("changes")); + assertEquals(CODE, Files.readString(source)); + var selections = Map.of("uri", source.toUri().toString(), "positions", List.of(Map.of("line", 0, "character", 4))); + assertEquals("selectionRanges", query("selectionRanges", selections).path("operation").asText()); + var actions = Map.of("uri", source.toUri().toString(), "range", Map.of("start", Map.of("line", 0, "character", 0), "end", Map.of("line", 0, "character", 10))); + assertEquals("codeActions", query("codeActions", actions).path("operation").asText()); + } + @Test void hierarchyIdsBelongToTheTaskAndDisappearOnReturn() { + acquire(); + var prepared = query("prepareCallHierarchy", at(0, 4)).path("result"); + assertFalse(prepared.isEmpty(), prepared.toString()); + String id = prepared.get(0).path("itemId").asText(); + assertFalse(id.isBlank()); + assertFalse(query("incomingCalls", Map.of("itemId", id)).path("result").isEmpty()); + assertEquals("outgoingCalls", query("outgoingCalls", Map.of("itemId", id)).path("operation").asText()); + session.automation().reclaim().toCompletableFuture().join(); + acquire(); + assertThrows(IllegalArgumentException.class, () -> query("incomingCalls", Map.of("itemId", id))); + } + @Test void admissionUnsupportedOperationsAndSourceScopeAreExplicit() throws Exception { + assertThrows(ControlDeniedException.class, () -> queries.query(root, "ungranted", "diagnostics", at(0, 0))); + acquire(); + assertThrows(ControlDeniedException.class, () -> queries.query(root, "wrong-task", "diagnostics", at(0, 0))); + assertEquals(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, assertThrows(AutomationException.class, + () -> query("typeHierarchy", at(0, 0))).failure().code()); + Path outside = temporary.resolve("outside.pbs"); Files.writeString(outside, CODE); + assertEquals(AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, assertThrows(AutomationException.class, + () -> query("diagnostics", Map.of("uri", outside.toUri().toString()))).failure().code()); + assertThrows(IllegalArgumentException.class, () -> query("definition", at(999, 0))); + var context = LspLifecycleAdapter.context(session.projectReference()); + var endpoint = lifecycle.endpoint(context).orElseThrow(); + session.close(); session = null; + assertTrue(lifecycle.endpoint(context).isEmpty()); + assertThrows(java.io.IOException.class, () -> new java.net.Socket(endpoint.host(), endpoint.port())); + assertEquals(AutomationFailure.Code.PROJECT_NOT_OPEN, assertThrows(AutomationException.class, + () -> query("diagnostics", at(0, 0))).failure().code()); + } + + @Test void mcpDispatchPreservesTaskFailuresAndReturnsNeutralLspResults() { + var tools = new p.studio.app.mcp.McpToolRegistry(new p.studio.app.mcp.McpToolCatalog(mapper), mapper, + p.studio.app.mcp.McpLanguageTools.handlers(queries, mapper)); + var arguments = mapper.createObjectNode().put("projectRoot", root.toString()).put("taskId", "missing").put("operation", "diagnostics"); + arguments.putObject("parameters").put("uri", source.toUri().toString()); + var denied = tools.call("studio_language_query", arguments).wire(); + assertEquals("INVALID_TASK", denied.path("structuredContent").path("error").path("code").asText()); + acquire(); arguments.put("taskId", task); + var success = tools.call("studio_language_query", arguments).wire(); + assertFalse(success.path("isError").asBoolean(), success.toString()); + assertTrue(success.path("structuredContent").path("value").path("result").isArray()); + session.automation().reclaim().toCompletableFuture().join(); + assertEquals("INVALID_TASK", tools.call("studio_language_query", arguments).wire().path("structuredContent").path("error").path("code").asText()); + } + + @Test void authenticatedHttpToolUsesTheRealLspButDoesNotGrantTaskAuthority() throws Exception { + var tools = new p.studio.app.mcp.McpToolRegistry(new p.studio.app.mcp.McpToolCatalog(mapper), mapper, + p.studio.app.mcp.McpLanguageTools.handlers(queries, mapper)); + try (var server = new p.studio.app.mcp.LocalMcpServer(mapper, tools); + var client = java.net.http.HttpClient.newHttpClient()) { + server.start(); + var initialize = mapper.createObjectNode().put("jsonrpc", "2.0").put("id", 1).put("method", "initialize"); + var setup = initialize.putObject("params").put("protocolVersion", "2025-06-18"); + setup.putObject("capabilities"); setup.putObject("clientInfo").put("name", "language-test").put("version", "1"); + String connection = post(client, server, null, initialize).headers().firstValue("Mcp-Session-Id").orElseThrow(); + post(client, server, connection, mapper.createObjectNode().put("jsonrpc", "2.0").put("method", "notifications/initialized")); + var request = mapper.createObjectNode().put("jsonrpc", "2.0").put("id", 2).put("method", "tools/call"); + var args = request.putObject("params").put("name", "studio_language_query").putObject("arguments") + .put("projectRoot", root.toString()).put("taskId", "ungranted").put("operation", "documentSymbols"); + args.putObject("parameters").put("uri", source.toUri().toString()); + var denied = mapper.readTree(post(client, server, connection, request).body()).path("result"); + assertEquals("INVALID_TASK", denied.path("structuredContent").path("error").path("code").asText()); + acquire(); args.put("taskId", task); + var result = mapper.readTree(post(client, server, connection, request).body()).path("result"); + assertFalse(result.path("isError").asBoolean(), result.toString()); + assertTrue(result.path("structuredContent").path("value").path("result").toString().contains("helper")); + } + } + + private java.net.http.HttpResponse post(java.net.http.HttpClient client, p.studio.app.mcp.LocalMcpServer server, + String connection, JsonNode body) throws Exception { + var request = java.net.http.HttpRequest.newBuilder(server.connection().endpoint()).timeout(java.time.Duration.ofSeconds(15)) + .header("Authorization", server.connection().authorizationHeader()).header("Content-Type", "application/json") + .header("Accept", "application/json, text/event-stream").header("MCP-Protocol-Version", "2025-06-18"); + if (connection != null) request.header("Mcp-Session-Id", connection); + return client.send(request.POST(java.net.http.HttpRequest.BodyPublishers.ofString(body.toString())).build(), java.net.http.HttpResponse.BodyHandlers.ofString()); + } + + @Test void reclaimCancelsTheQueryAndEndsTaskResourcesAfterTheWorkerStops() throws Exception { + var entered = new CountDownLatch(1); + var stopped = new CountDownLatch(1); + var cleaned = new java.util.concurrent.atomic.AtomicBoolean(); + var slow = new TaskLanguageQueries(access, new p.studio.core.language.LanguageQueryPort() { + @Override public Map query(TaskIdentity task, String operation, Map params) throws Exception { + entered.countDown(); + try { new CountDownLatch(1).await(); return Map.of(); } + finally { stopped.countDown(); } + } + @Override public void endTask(TaskIdentity task) { assertEquals(0, stopped.getCount()); cleaned.set(true); } + }); + acquire(); + var pending = workers.submit(() -> slow.query(root, task, "diagnostics", at(0, 0))); + assertTrue(entered.await(2, TimeUnit.SECONDS)); + assertEquals(ControlResult.Status.BUSY, assertThrows(ControlDeniedException.class, + () -> queries.query(root, task, "diagnostics", at(0, 0))).status()); + assertTrue(session.automation().reclaim().toCompletableFuture().get(2, TimeUnit.SECONDS).success()); + assertThrows(ExecutionException.class, () -> pending.get(2, TimeUnit.SECONDS)); + assertTrue(cleaned.get()); + assertEquals(ControlState.MANUAL, session.automation().snapshot().state()); + } + @Test void externalDependencyNavigationIsReadableButRefactoringIsReadOnly() throws Exception { + Path lib = Files.createDirectories(temporary.resolve("lib")).toRealPath(); + manifest(lib, "lib", List.of()); + Path module = Files.createDirectories(lib.resolve("src/shared")); + Path declaration = module.resolve("main.pbs"); + Files.writeString(declaration, "fn answer() -> int { return 42; }\n"); + Files.writeString(module.resolve("mod.barrel"), "pub fn answer() -> int;\n"); + manifest(root, "app", List.of(Map.of("path", "../lib"))); + Files.createDirectories(root.resolve(".workspace/repos")); Files.writeString(root.resolve(".workspace/repos/registry.json"), "{}"); + Files.writeString(source, "import { answer } from @lib:shared;\nfn main() -> int { return answer(); }\n"); + Files.writeString(source.resolveSibling("mod.barrel"), "pub fn main() -> int;\n"); + acquire(); + var locations = query("definition", at(1, 26)).path("result"); + assertFalse(locations.isEmpty(), locations.toString()); + assertEquals(declaration.toUri().toString(), locations.get(0).path("uri").asText()); + assertEquals("documentSymbols", query("documentSymbols", Map.of("uri", declaration.toUri().toString())).path("operation").asText()); + assertEquals(AutomationFailure.Code.READ_ONLY_SCOPE, assertThrows(AutomationException.class, + () -> query("formatting", Map.of("uri", declaration.toUri().toString()))).failure().code()); + var rename = new HashMap<>(at(1, 26)); rename.put("newName", "renamed"); + assertEquals(AutomationFailure.Code.READ_ONLY_SCOPE, assertThrows(AutomationException.class, () -> query("rename", rename)).failure().code()); + } + private void manifest(Path path, String name, List dependencies) throws Exception { + mapper.writeValue(path.resolve("prometeu.json").toFile(), Map.of("name", name, "version", "1.0.0", "language", "pbs", "stdlib", "1", "target", "Game", "dependencies", dependencies)); + } +} diff --git a/prometeu-architecture-tests/src/test/java/p/studio/architecture/StudioBoundaryArchTest.java b/prometeu-architecture-tests/src/test/java/p/studio/architecture/StudioBoundaryArchTest.java index fbbaa1b1..8ef66c98 100644 --- a/prometeu-architecture-tests/src/test/java/p/studio/architecture/StudioBoundaryArchTest.java +++ b/prometeu-architecture-tests/src/test/java/p/studio/architecture/StudioBoundaryArchTest.java @@ -13,7 +13,7 @@ class StudioBoundaryArchTest { static final ArchRule automationTransportStaysInTheApp = noClasses() .that().resideInAnyPackage("p.studio.api..", "p.studio.core..", "p.studio.ui..") .should().dependOnClassesThat().resideInAnyPackage( - "p.studio.app.mcp..", "com.sun.net.httpserver..", "io.modelcontextprotocol..") + "p.studio.app.mcp..", "p.studio.app.lsp..", "org.eclipse.lsp4j..", "com.sun.net.httpserver..", "io.modelcontextprotocol..") .because("DEC-0060 confines MCP and HTTP transport to application adapters"); @ArchTest diff --git a/prometeu-lsp/prometeu-lsp-api/src/main/java/p/studio/lsp/api/LspServerLifecycle.java b/prometeu-lsp/prometeu-lsp-api/src/main/java/p/studio/lsp/api/LspServerLifecycle.java index 564020b8..81a02ea1 100644 --- a/prometeu-lsp/prometeu-lsp-api/src/main/java/p/studio/lsp/api/LspServerLifecycle.java +++ b/prometeu-lsp/prometeu-lsp-api/src/main/java/p/studio/lsp/api/LspServerLifecycle.java @@ -7,4 +7,8 @@ public interface LspServerLifecycle { void bootServer(LspServerConfiguration serverConfiguration, LspProjectContext context); void shutdownServer(LspProjectContext context); + + default java.util.Optional endpoint(LspProjectContext context) { + return java.util.Optional.empty(); + } } diff --git a/prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/LspServerLifecycleImpl.java b/prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/LspServerLifecycleImpl.java index 9a85283d..4e629f9a 100644 --- a/prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/LspServerLifecycleImpl.java +++ b/prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/LspServerLifecycleImpl.java @@ -47,6 +47,12 @@ public final class LspServerLifecycleImpl implements LspServerLifecycle { closeQuietly(host); } + @Override + public java.util.Optional endpoint(LspProjectContext context) { + var host = activeServers.get(context.projectKey()); + return host == null || !host.matches(context) ? java.util.Optional.empty() : host.endpoint(); + } + private static void closeQuietly(final TcpLspServerHost host) { try { host.close(); diff --git a/prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/TcpLspServerHost.java b/prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/TcpLspServerHost.java index 0f7edc60..d79ed593 100644 --- a/prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/TcpLspServerHost.java +++ b/prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/TcpLspServerHost.java @@ -24,6 +24,7 @@ public final class TcpLspServerHost { private volatile boolean closed; private volatile ServerSocket serverSocket; private volatile Thread acceptThread; + private final java.util.Set clients = java.util.concurrent.ConcurrentHashMap.newKeySet(); public TcpLspServerHost( final LspServerConfiguration serverConfiguration, @@ -59,6 +60,8 @@ public final class TcpLspServerHost { while (!closed) { try { final Socket socket = serverSocket.accept(); + clients.add(socket); + if (closed) { clients.remove(socket); socket.close(); break; } clientExecutor.submit(() -> handleClient(socket)); } catch (IOException exception) { if (!closed) { @@ -74,14 +77,21 @@ public final class TcpLspServerHost { final Launcher launcher = LSPLauncher.createServerLauncher( server, socket.getInputStream(), - socket.getOutputStream()); + socket.getOutputStream(), clientExecutor, consumer -> consumer); server.connect(launcher.getRemoteProxy()); launcher.startListening().get(); } catch (Exception exception) { - throw new IllegalStateException("LSP client failed", exception); - } + if (!closed && !socket.isClosed()) throw new IllegalStateException("LSP client failed", exception); + } finally { clients.remove(socket); } } + public synchronized java.util.Optional endpoint() { + return closed || serverSocket == null ? java.util.Optional.empty() : java.util.Optional.of( + new p.studio.lsp.messages.LspServerEndpoint(serverSocket.getInetAddress().getHostAddress(), serverSocket.getLocalPort())); + } + + public boolean matches(LspProjectContext project) { return context.equals(project); } + public synchronized void close() throws Exception { if (closed) { return; @@ -93,6 +103,8 @@ public final class TcpLspServerHost { if (acceptThread != null) { acceptThread.interrupt(); } + for (var socket : clients) { try { socket.close(); } catch (IOException ignored) {} } + clients.clear(); clientExecutor.shutdownNow(); } } diff --git a/prometeu-lsp/prometeu-lsp-v1/src/test/java/p/studio/lsp/services/LspServerLifecycleTest.java b/prometeu-lsp/prometeu-lsp-v1/src/test/java/p/studio/lsp/services/LspServerLifecycleTest.java new file mode 100644 index 00000000..9e8ba13d --- /dev/null +++ b/prometeu-lsp/prometeu-lsp-v1/src/test/java/p/studio/lsp/services/LspServerLifecycleTest.java @@ -0,0 +1,37 @@ +package p.studio.lsp.services; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import p.studio.lsp.messages.*; +import java.nio.file.Path; +import java.net.Socket; +import static org.junit.jupiter.api.Assertions.*; + +class LspServerLifecycleTest { + @TempDir Path temporary; + + @Test void projectEndpointsAreIndependentAndShutdownClosesConnectedSockets() throws Exception { + var lifecycle = new LspServerLifecycleImpl(); + var first = new LspProjectContext("first", "pbs", temporary); + var second = new LspProjectContext("second", "pbs", temporary.resolve("second")); + var configuration = LspServerConfiguration.builder().endpoint(new LspServerEndpoint("127.0.0.1", 0)).build(); + lifecycle.bootServer(configuration, first); lifecycle.bootServer(configuration, second); + try { + var endpoint = lifecycle.endpoint(first).orElseThrow(); + assertNotEquals(endpoint.port(), lifecycle.endpoint(second).orElseThrow().port()); + assertTrue(lifecycle.endpoint(new LspProjectContext("first", "other-language", temporary)).isEmpty()); + try (var socket = new Socket(endpoint.host(), endpoint.port())) { + socket.setSoTimeout(2000); + String request = "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"initialize\",\"params\":{\"rootUri\":\"" + temporary.toUri() + "\",\"capabilities\":{}}}"; + byte[] body = request.getBytes(java.nio.charset.StandardCharsets.UTF_8); + socket.getOutputStream().write(("Content-Length: " + body.length + "\r\n\r\n").getBytes(java.nio.charset.StandardCharsets.US_ASCII)); + socket.getOutputStream().write(body); socket.getOutputStream().flush(); + assertNotEquals(-1, socket.getInputStream().read()); + lifecycle.shutdownServer(first); + socket.getInputStream().readAllBytes(); // Buffered reply drains, then EOF; no abandoned client connection. + assertTrue(lifecycle.endpoint(first).isEmpty()); + assertTrue(lifecycle.endpoint(second).isPresent()); + } + } finally { lifecycle.shutdownServer(first); lifecycle.shutdownServer(second); } + } +} diff --git a/prometeu-studio-api/src/main/java/p/studio/api/automation/AutomationSession.java b/prometeu-studio-api/src/main/java/p/studio/api/automation/AutomationSession.java index dc46493b..45474d50 100644 --- a/prometeu-studio-api/src/main/java/p/studio/api/automation/AutomationSession.java +++ b/prometeu-studio-api/src/main/java/p/studio/api/automation/AutomationSession.java @@ -17,4 +17,6 @@ public interface AutomationSession { OperationHandle submit(TaskIdentity task, String summary, Callable work); void attachRuntime(TaskIdentity task, ManagedHeadlessSession runtime); void markCaptureStale(); + /** Cleanup runs after workers stop and before returning manual control. */ + void onTaskEnd(TaskIdentity task, Runnable cleanup); } diff --git a/prometeu-studio-api/src/main/java/p/studio/api/automation/LanguageQueries.java b/prometeu-studio-api/src/main/java/p/studio/api/automation/LanguageQueries.java new file mode 100644 index 00000000..1d9bbbcc --- /dev/null +++ b/prometeu-studio-api/src/main/java/p/studio/api/automation/LanguageQueries.java @@ -0,0 +1,9 @@ +package p.studio.api.automation; + +import java.nio.file.Path; +import java.util.Map; + +/** Neutral language query boundary. Values contain only JSON-compatible maps, lists and scalars. */ +public interface LanguageQueries { + Map query(Path projectRoot, String taskId, String operation, Map parameters); +} diff --git a/prometeu-studio-core/src/main/java/p/studio/core/language/LanguageQueryPort.java b/prometeu-studio-core/src/main/java/p/studio/core/language/LanguageQueryPort.java new file mode 100644 index 00000000..cb066a75 --- /dev/null +++ b/prometeu-studio-core/src/main/java/p/studio/core/language/LanguageQueryPort.java @@ -0,0 +1,10 @@ +package p.studio.core.language; + +import p.studio.api.automation.TaskIdentity; +import java.util.Map; + +/** Application adapter to the existing language server; never a replacement compiler. */ +public interface LanguageQueryPort { + Map query(TaskIdentity task, String operation, Map parameters) throws Exception; + void endTask(TaskIdentity task); +} diff --git a/prometeu-studio-core/src/main/java/p/studio/core/language/TaskLanguageQueries.java b/prometeu-studio-core/src/main/java/p/studio/core/language/TaskLanguageQueries.java new file mode 100644 index 00000000..01b4cd9e --- /dev/null +++ b/prometeu-studio-core/src/main/java/p/studio/core/language/TaskLanguageQueries.java @@ -0,0 +1,55 @@ +package p.studio.core.language; + +import p.studio.api.automation.*; +import p.studio.core.project.ProjectAccessRegistry; +import java.nio.file.Path; +import java.util.*; +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicReference; + +/** Shares project admission, cancellation and DEV observation with other agent work. */ +public final class TaskLanguageQueries implements LanguageQueries { + private final ProjectAccessRegistry projects; + private final LanguageQueryPort language; + private final Set registered = ConcurrentHashMap.newKeySet(); + + public TaskLanguageQueries(ProjectAccessRegistry projects, LanguageQueryPort language) { + this.projects = Objects.requireNonNull(projects); this.language = Objects.requireNonNull(language); + } + + @Override public Map query(Path root, String taskId, String operation, Map parameters) { + var session = projects.requireAutomation(root); + var task = requireTask(session, taskId); + if (registered.add(task)) { + try { session.onTaskEnd(task, () -> { try { language.endTask(task); } finally { registered.remove(task); } }); } + catch (RuntimeException failure) { registered.remove(task); throw failure; } + } + var result = new AtomicReference>(); + var handle = session.submit(task, "LSP " + operation, () -> { + result.set(language.query(task, operation, parameters)); + return new AutomationOutcome(AutomationOutcome.Kind.SUCCEEDED, 0, 0, List.of(), null); + }); + try { + handle.completion().toCompletableFuture().get(12, TimeUnit.SECONDS); + handle.termination().toCompletableFuture().get(1, TimeUnit.SECONDS); + requireTask(session, taskId); + return Objects.requireNonNull(result.get()); + } catch (ExecutionException failure) { + if (failure.getCause() instanceof RuntimeException cause) throw cause; + throw new AutomationException(AutomationFailure.Code.INFRASTRUCTURE_FAILURE, "LSP query failed"); + } catch (InterruptedException failure) { + handle.cancel(); Thread.currentThread().interrupt(); + throw new AutomationException(AutomationFailure.Code.INFRASTRUCTURE_FAILURE, "LSP query interrupted"); + } catch (TimeoutException | CancellationException failure) { + handle.cancel(); + throw new AutomationException(AutomationFailure.Code.INFRASTRUCTURE_FAILURE, "LSP query cancelled or timed out"); + } + } + + private static TaskIdentity requireTask(AutomationSession session, String id) { + var snapshot = session.snapshot(); + if (snapshot.closed() || snapshot.state() != ControlState.AGENT_WORKING || snapshot.task() == null || !snapshot.task().value().equals(id)) + throw new ControlDeniedException(ControlResult.Status.INVALID_TASK); + return snapshot.task(); + } +} diff --git a/prometeu-studio-core/src/main/java/p/studio/core/project/ProjectAccessRegistry.java b/prometeu-studio-core/src/main/java/p/studio/core/project/ProjectAccessRegistry.java index 555e5f0c..0f9cc1ad 100644 --- a/prometeu-studio-core/src/main/java/p/studio/core/project/ProjectAccessRegistry.java +++ b/prometeu-studio-core/src/main/java/p/studio/core/project/ProjectAccessRegistry.java @@ -14,7 +14,7 @@ import p.studio.api.automation.AutomationFailure; /** Application-composed routing only; authority is owned by each project session. */ public final class ProjectAccessRegistry implements ProjectAccess { - private record Entry(Supplier authority, BooleanSupplier available) {} + private record Entry(Supplier authority, BooleanSupplier available, p.studio.api.automation.AutomationSession automation) {} private final Map projects = new HashMap<>(); public OperationSubscription register(Path root, Supplier authority) { @@ -22,12 +22,27 @@ public final class ProjectAccessRegistry implements ProjectAccess { } public synchronized OperationSubscription register(Path root, Supplier authority, BooleanSupplier available) { + return register(root, authority, available, null); + } + + public synchronized OperationSubscription register(Path root, Supplier authority, BooleanSupplier available, + p.studio.api.automation.AutomationSession automation) { Path key = canonical(root); - var entry = new Entry(java.util.Objects.requireNonNull(authority), java.util.Objects.requireNonNull(available)); + var entry = new Entry(java.util.Objects.requireNonNull(authority), java.util.Objects.requireNonNull(available), automation); if (projects.putIfAbsent(key, entry) != null) throw new IllegalStateException("Project already open: " + key); return () -> { synchronized (this) { projects.remove(key, entry); } }; } + public p.studio.api.automation.AutomationSession requireAutomation(Path root) { + Path key = requireOpenRoot(root); + synchronized (this) { + var entry = projects.get(key); + if (entry == null || entry.automation() == null) + throw new AutomationException(AutomationFailure.Code.PROJECT_NOT_OPEN, "No open project automation session"); + return entry.automation(); + } + } + /** Exact root lookup, never focus-based or a descendant-path admission. No grant is needed. */ public Path requireOpenRoot(Path root) { Path key = canonical(root); diff --git a/prometeu-studio-core/src/main/java/p/studio/core/session/DefaultAutomationSession.java b/prometeu-studio-core/src/main/java/p/studio/core/session/DefaultAutomationSession.java index 9b1a3544..6a85eb47 100644 --- a/prometeu-studio-core/src/main/java/p/studio/core/session/DefaultAutomationSession.java +++ b/prometeu-studio-core/src/main/java/p/studio/core/session/DefaultAutomationSession.java @@ -25,6 +25,12 @@ public final class DefaultAutomationSession implements AutomationSession { private List diagnostics = List.of(); private CompletableFuture returning; private final List manualCancellation = new ArrayList<>(); + private final List taskCleanup = new ArrayList<>(); + + @Override public synchronized void onTaskEnd(TaskIdentity identity, Runnable cleanup) { + requireTask(identity); + taskCleanup.add(Objects.requireNonNull(cleanup)); + } private CompletableFuture manualIdle = CompletableFuture.completedFuture(null); public DefaultAutomationSession(Path root, OperationExecutor executor) { @@ -150,6 +156,7 @@ public final class DefaultAutomationSession implements AutomationSession { final List cancellations; final List participants; final CompletableFuture idle; + final List cleanups; synchronized (this) { if (requireIdentity && !valid(identity)) return result(ControlResult.Status.INVALID_TASK, "Task identity is not current"); if (closing) closed = true; @@ -161,6 +168,7 @@ public final class DefaultAutomationSession implements AutomationSession { operation = active; ownedRuntime = runtime; idle = manualIdle; cancellations = closing ? List.copyOf(manualCancellation) : List.of(); participants = closing ? List.of() : List.copyOf(documents); + cleanups = List.copyOf(taskCleanup); taskCleanup.clear(); publish(); } // Never call another service while holding the authority monitor: Debug owns its own lock. @@ -172,6 +180,7 @@ public final class DefaultAutomationSession implements AutomationSession { CompletionStage shutdown = CompletableFuture.completedFuture(null); if (ownedRuntime != null) { ownedRuntime.cancel(); shutdown = ownedRuntime.shutdown(); } cleanup = CompletableFuture.allOf(stopped.toCompletableFuture(), shutdown.toCompletableFuture(), idle); + cleanup = cleanup.thenRun(() -> cleanups.forEach(Runnable::run)); // Closing disposes documents; an explicit return must refresh them before unlocking. for (var p : participants) cleanup = cleanup.thenCompose(v -> { synchronized (this) { if (closed) return CompletableFuture.completedFuture(null); } diff --git a/prometeu-studio-core/src/main/java/p/studio/core/session/DefaultProjectSessionFactory.java b/prometeu-studio-core/src/main/java/p/studio/core/session/DefaultProjectSessionFactory.java index 3cf66f3d..4d4e76dd 100644 --- a/prometeu-studio-core/src/main/java/p/studio/core/session/DefaultProjectSessionFactory.java +++ b/prometeu-studio-core/src/main/java/p/studio/core/session/DefaultProjectSessionFactory.java @@ -34,7 +34,7 @@ public final class DefaultProjectSessionFactory implements ProjectSessionFactory var automation = new DefaultAutomationSession(project.rootPath(), operations); var ready = new java.util.concurrent.atomic.AtomicBoolean(); var registration = access.register(project.rootPath(), automation::enterManual, - () -> ready.get() && !automation.snapshot().closed()); + () -> ready.get() && !automation.snapshot().closed(), automation); try { lsp.boot(project); } catch (RuntimeException failure) { registration.unsubscribe(); throw failure; } ready.set(true); diff --git a/prometeu-studio-core/src/test/java/p/studio/core/StudioModularityTest.java b/prometeu-studio-core/src/test/java/p/studio/core/StudioModularityTest.java index 306731fd..6c82e0ea 100644 --- a/prometeu-studio-core/src/test/java/p/studio/core/StudioModularityTest.java +++ b/prometeu-studio-core/src/test/java/p/studio/core/StudioModularityTest.java @@ -15,7 +15,7 @@ class StudioModularityTest { void verifiesStudioCoreApplicationModules() { modules.verify(); assertEquals( - Set.of("project", "session", "assets", "shipper", "runtime", "execution"), + Set.of("project", "session", "assets", "shipper", "runtime", "execution", "language"), modules.stream().map(module -> module.getIdentifier().toString()).collect(java.util.stream.Collectors.toSet())); } diff --git a/prometeu-studio-core/src/test/java/p/studio/core/session/DefaultAutomationSessionTest.java b/prometeu-studio-core/src/test/java/p/studio/core/session/DefaultAutomationSessionTest.java index b1533bc1..a48470ae 100644 --- a/prometeu-studio-core/src/test/java/p/studio/core/session/DefaultAutomationSessionTest.java +++ b/prometeu-studio-core/src/test/java/p/studio/core/session/DefaultAutomationSessionTest.java @@ -18,6 +18,23 @@ class DefaultAutomationSessionTest { ControlResult await(CompletionStage result) { return result.toCompletableFuture().join(); } TaskIdentity start(DefaultAutomationSession s) { assertEquals(GRANTED, await(s.grant(false)).status()); return s.acquire().task(); } + @Test void taskCleanupRunsAfterWorkerTerminationAndBeforeManualControl() { + var s = session(); var task = start(s); + var cleaned = new java.util.concurrent.atomic.AtomicInteger(); + s.onTaskEnd(task, () -> { + assertTrue(operations.last.stopped.isDone()); + assertFalse(s.snapshot().manualAllowed()); + cleaned.incrementAndGet(); + }); + s.submit(task, "language query", () -> new AutomationOutcome(AutomationOutcome.Kind.SUCCEEDED, 0, 0, List.of(), null)); + var returning = s.reclaim().toCompletableFuture(); + assertTrue(operations.last.cancelled); assertEquals(0, cleaned.get()); assertFalse(returning.isDone()); + operations.last.finish(); + assertEquals(RETURNED, returning.join().status()); assertEquals(1, cleaned.get()); + s.closeAsync().toCompletableFuture().join(); assertEquals(1, cleaned.get()); + assertThrows(ControlDeniedException.class, () -> s.onTaskEnd(task, () -> {})); + } + @Test void explicitGrantAndProjectScopedIdentityAreRequired() { var s = session(); assertEquals(NOT_GRANTED, s.acquire().status());