Add Java hosting integration

Aspire-Core.slnf

@@ -29,6 +29,7 @@
       "src\\Aspire.Hosting.EntityFrameworkCore\\Aspire.Hosting.EntityFrameworkCore.csproj",
       "src\\Aspire.Hosting.Go\\Aspire.Hosting.Go.csproj",
       "src\\Aspire.Hosting.Integration.Analyzers\\Aspire.Hosting.Integration.Analyzers.csproj",
+      "src\\Aspire.Hosting.Java\\Aspire.Hosting.Java.csproj",
       "src\\Aspire.Hosting.JavaScript\\Aspire.Hosting.JavaScript.csproj",
       "src\\Aspire.Hosting.PostgreSQL\\Aspire.Hosting.PostgreSQL.csproj",
       "src\\Aspire.Hosting.Python\\Aspire.Hosting.Python.csproj",
@@ -57,6 +58,7 @@
       "tests\\Aspire.Hosting.Analyzers.Tests\\Aspire.Hosting.Analyzers.Tests.csproj",
       "tests\\Aspire.Hosting.Containers.Tests\\Aspire.Hosting.Containers.Tests.csproj",
       "tests\\Aspire.Hosting.EntityFrameworkCore.Tests\\Aspire.Hosting.EntityFrameworkCore.Tests.csproj",
+      "tests\\Aspire.Hosting.Java.Tests\\Aspire.Hosting.Java.Tests.csproj",
       "tests\\Aspire.Hosting.Rust.Tests\\Aspire.Hosting.Rust.Tests.csproj",
       "tests\\Aspire.Hosting.Testing.Tests\\Aspire.Hosting.Testing.Tests.csproj",
       "tests\\Aspire.Hosting.Tests\\Aspire.Hosting.Tests.csproj",

Aspire.slnx

@@ -59,6 +59,7 @@
     <Project Path="src/Aspire.Hosting.GitHub.Models/Aspire.Hosting.GitHub.Models.csproj" />
     <Project Path="src/Aspire.Hosting.Go/Aspire.Hosting.Go.csproj" />
     <Project Path="src/Aspire.Hosting.Integration.Analyzers/Aspire.Hosting.Integration.Analyzers.csproj" />
+    <Project Path="src/Aspire.Hosting.Java/Aspire.Hosting.Java.csproj" />
     <Project Path="src/Aspire.Hosting.JavaScript/Aspire.Hosting.JavaScript.csproj" />
     <Project Path="src/Aspire.Hosting.Kafka/Aspire.Hosting.Kafka.csproj" />
     <Project Path="src/Aspire.Hosting.Keycloak/Aspire.Hosting.Keycloak.csproj" />
@@ -368,6 +369,9 @@
     <Project Path="playground/Redis/Redis.ApiService/Redis.ApiService.csproj" />
     <Project Path="playground/Redis/Redis.AppHost/Redis.AppHost.csproj" />
   </Folder>
+  <Folder Name="/playground/JavaSpringBoot/">
+    <Project Path="playground/JavaSpringBoot/JavaSpringBoot.AppHost/JavaSpringBoot.AppHost.csproj" />
+  </Folder>
   <Folder Name="/playground/rust/">
     <Project Path="playground/rust/Rust.AppHost/Rust.AppHost.csproj" />
   </Folder>
@@ -538,6 +542,7 @@
     <Project Path="tests/Aspire.Hosting.Garnet.Tests/Aspire.Hosting.Garnet.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.GitHub.Models.Tests/Aspire.Hosting.GitHub.Models.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.Go.Tests/Aspire.Hosting.Go.Tests.csproj" />
+    <Project Path="tests/Aspire.Hosting.Java.Tests/Aspire.Hosting.Java.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.JavaScript.Tests/Aspire.Hosting.JavaScript.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.Kafka.Tests/Aspire.Hosting.Kafka.Tests.csproj" />
     <Project Path="tests/Aspire.Hosting.Keycloak.Tests/Aspire.Hosting.Keycloak.Tests.csproj" />

eng/github-ci/test-trigger-map.yml

@@ -343,6 +343,7 @@ affected_project_rules:
       - Aspire.AppHost.Sdk
       - Aspire.Hosting.CodeGeneration.*
       - Aspire.Hosting.Go
+      - Aspire.Hosting.Java
       - Aspire.Hosting.JavaScript
       - Aspire.Hosting.Python
       - Aspire.Hosting.Rust

extension/package.nls.json

@@ -302,6 +302,8 @@
   "aspire-vscode.strings.rustLaunchConfigurationMissingExecutable": "The Aspire app host did not report which executable the Rust app in {0} produces, so there is nothing to debug.",
   "aspire-vscode.strings.rustWindowsGnuDebuggerUnsupported": "The cppvsdbg debugger cannot debug Rust target {0} because GNU Windows targets use DWARF symbols. Install CodeLLDB or build an MSVC Rust target such as x86_64-pc-windows-msvc.",
   "aspire-vscode.strings.rustDebuggerExtensionNotInstalled": "Rust AppHosts are launched through a native debugger extension. Install {0} from the Extensions view, then start the AppHost again.",
+  "aspire-vscode.strings.javaDisplayName": "Java: {0}",
+  "aspire-vscode.strings.javaLabel": "Java",
   "aspire-vscode.strings.appHostLifecycleStartConfirmationTitle": "Start Aspire AppHost",
   "aspire-vscode.strings.appHostLifecycleStopConfirmationTitle": "Stop Aspire AppHost",
   "aspire-vscode.strings.appHostLifecycleStartConfirmationMessage": "Start the Aspire AppHost {0} in {1} mode?",

extension/src/capabilities.ts

@@ -24,6 +24,8 @@ export type Capability =
     | 'browser' // Support for browser debugging (built-in to VS Code via js-debug)
     | 'maui' // Support for running .NET MAUI projects
     | 'ms-dotnettools.dotnet-maui' // MAUI debug adapter extension identifier
+    | 'java' // Support for running Java projects
+    | 'vscjava.vscode-java-debug' // Java debug adapter extension identifier
     | 'azure-functions'; // Support for running Azure Functions projects
 
 export type Capabilities = Capability[];
@@ -88,6 +90,19 @@ export function isBunInstalled() {
     return isExtensionInstalled("oven.bun-vscode");
 }
 
+// The Java debug adapter cannot launch anything on its own: it resolves main classes, the
+// classpath and project metadata through the redhat.java language server, which is why
+// vscjava.vscode-java-debug declares redhat.java as an extension dependency and both ship together
+// in the "Extension Pack for Java". java.ts also calls the redhat.java API directly to refresh the
+// project configuration, so advertise Java support only when both are present.
+// https://github.com/microsoft/vscode-java-debug#requirements
+export const javaLanguageExtensionId = 'redhat.java';
+export const javaDebugExtensionId = 'vscjava.vscode-java-debug';
+
+export function isJavaInstalled(extensionInstalled: (extensionId: string) => boolean = isExtensionInstalled) {
+    return extensionInstalled(javaLanguageExtensionId) && extensionInstalled(javaDebugExtensionId);
+}
+
 export function getSupportedCapabilities(platform: NodeJS.Platform = process.platform): Capabilities {
     const capabilities: Capabilities = ['prompting', 'baseline.v1', 'secret-prompts.v1', 'file-pickers.v1', 'build-dotnet-using-cli'];
 
@@ -138,6 +153,11 @@ export function getSupportedCapabilities(platform: NodeJS.Platform = process.pla
         capabilities.push("ms-dotnettools.dotnet-maui");
     }
 
+    if (isJavaInstalled()) {
+        capabilities.push("java");
+        capabilities.push(javaDebugExtensionId);
+    }
+
     return capabilities;
 }
 

extension/src/dcp/types.ts

@@ -134,6 +134,23 @@ export function isMauiLaunchConfiguration(obj: any): obj is MauiLaunchConfigurat
     return obj && obj.type === 'maui';
 }
 
+export interface JavaLaunchConfiguration extends ExecutableLaunchConfiguration {
+    type: "java";
+    request?: "launch" | "attach";
+    working_directory?: string;
+    // Either a fully qualified class name (com.example.Api), or the absolute path to an executable
+    // JAR whose manifest declares Main-Class. Absent when the IDE should resolve the entry point
+    // from the project's build files. See src/Aspire.Hosting.Java/JavaLaunchConfiguration.cs.
+    main_class?: string;
+    // "maven" or "gradle", or absent when the resource runs a prebuilt JAR and therefore has no
+    // build files whose classpath the Java language server could refresh.
+    build_tool?: string;
+}
+
+export function isJavaLaunchConfiguration(obj: any): obj is JavaLaunchConfiguration {
+    return obj && obj.type === 'java';
+}
+
 export interface EnvVar {
     name: string;
     value: string;

extension/src/debugger/debuggerExtensions.ts

@@ -4,14 +4,15 @@ import { debugProject, runProject } from "../loc/strings";
 import { getEnvironmentWithoutE2EBridgeVariables, mergeEnvs } from "../utils/environment";
 import { extensionLogOutputChannel } from "../utils/logging";
 import { projectDebuggerExtension } from "./languages/dotnet";
-import { isAzureFunctionsExtensionInstalled, isBunInstalled, isCsharpInstalled, isGoInstalled, isMauiInstalled, isPythonInstalled, isRustInstalled } from '../capabilities';
+import { isAzureFunctionsExtensionInstalled, isBunInstalled, isCsharpInstalled, isGoInstalled, isJavaInstalled, isMauiInstalled, isPythonInstalled, isRustInstalled } from '../capabilities';
 import { pythonDebuggerExtension } from "./languages/python";
 import { nodeDebuggerExtension } from "./languages/node";
 import { browserDebuggerExtension } from "./languages/browser";
 import { azureFunctionsDebuggerExtension } from "./languages/azureFunctions";
 import { goDebuggerExtension } from "./languages/go";
 import { createDefaultRustDebuggerExtension } from "./languages/rust";
 import { bunDebuggerExtension } from "./languages/bun";
+import { javaDebuggerExtension } from "./languages/java";
 import { mauiDebuggerExtension } from "./languages/maui";
 import { isDirectory } from "../utils/io";
 import { waitForRunStartIdle } from "./runStartRegistry";
@@ -114,6 +115,10 @@ export function getResourceDebuggerExtensions(platform: NodeJS.Platform = proces
         extensions.push(createDefaultRustDebuggerExtension(platform));
     }
 
+    if (isJavaInstalled()) {
+        extensions.push(javaDebuggerExtension);
+    }
+
     extensions.push(nodeDebuggerExtension);
     extensions.push(browserDebuggerExtension);
 

extension/src/debugger/languages/java.ts

@@ -0,0 +1,202 @@
+import * as path from 'path';
+import * as vscode from 'vscode';
+import { javaDebugExtensionId, javaLanguageExtensionId } from '../../capabilities';
+import { AspireResourceExtendedDebugConfiguration, ExecutableLaunchConfiguration, isJavaLaunchConfiguration, JavaLaunchConfiguration } from "../../dcp/types";
+import { invalidLaunchConfiguration, javaDisplayName, javaLabel } from "../../loc/strings";
+import { extensionLogOutputChannel } from "../../utils/logging";
+import { ResourceDebuggerExtension } from "../debuggerExtensions";
+
+// Commands contributed by redhat.java. They only exist once the language server has activated, so
+// every call site has to tolerate them being missing.
+const JAVA_EXECUTE_WORKSPACE_COMMAND = 'java.execute.workspaceCommand';
+const JAVA_RESOLVE_BUILD_FILES_COMMAND = 'vscode.java.resolveBuildFiles';
+const JAVA_PROJECT_CONFIGURATION_UPDATE_COMMAND = 'java.projectConfiguration.update';
+
+// Subset of the redhat.java extension API surface we use.
+// https://github.com/redhat-developer/vscode-java#extension-api
+interface JavaExtensionApi {
+    serverMode: string;
+    serverReady: () => Promise<boolean>;
+}
+
+async function getJavaExtensionApi(): Promise<JavaExtensionApi | null> {
+    const extension = vscode.extensions.getExtension<JavaExtensionApi>(javaLanguageExtensionId);
+
+    if (!extension) {
+        return null;
+    }
+
+    if (!extension.isActive) {
+        // Activation can fail (no JDK, corrupt workspace metadata, ...). Treat that the same as the
+        // extension being absent so the launch can still proceed without classpath refresh.
+        await extension.activate();
+    }
+
+    return extension.exports ?? null;
+}
+
+async function waitForJavaLanguageServerReady(): Promise<boolean> {
+    try {
+        const api = await getJavaExtensionApi();
+
+        if (!api) {
+            extensionLogOutputChannel.warn(`The Java language server (${javaLanguageExtensionId}) is not installed or exposes no API.`);
+            return false;
+        }
+
+        extensionLogOutputChannel.info(`Java language server is in ${api.serverMode} mode, waiting for readiness...`);
+
+        return await api.serverReady();
+    } catch (e) {
+        extensionLogOutputChannel.warn(`Error waiting for Java language server readiness: ${e}`);
+    }
+
+    return false;
+}
+
+async function updateJavaProjectConfiguration(buildTool: string): Promise<void> {
+    const buildFiles = await vscode.commands.executeCommand<string[]>(
+        JAVA_EXECUTE_WORKSPACE_COMMAND,
+        JAVA_RESOLVE_BUILD_FILES_COMMAND
+    );
+
+    if (!buildFiles?.length) {
+        extensionLogOutputChannel.info(`The Java language server reported no ${buildTool} build files to refresh.`);
+        return;
+    }
+
+    extensionLogOutputChannel.info(`Updating ${buildTool} project configuration for ${buildFiles.length} build file(s)...`);
+
+    for (const buildFile of buildFiles) {
+        await vscode.commands.executeCommand(JAVA_PROJECT_CONFIGURATION_UPDATE_COMMAND, vscode.Uri.parse(buildFile));
+    }
+}
+
+// Refreshing the classpath is a convenience for fresh clones and for projects whose build files
+// changed since the language server last imported them; nothing about launching depends on it.
+// redhat.java is therefore treated as optional at runtime: when it is missing or still starting, its
+// commands are not registered and executeCommand rejects with "command not found", which would
+// otherwise surface as an opaque failure that aborts the whole resource launch.
+async function tryRefreshJavaProjectConfiguration(launchConfig: JavaLaunchConfiguration): Promise<void> {
+    // A null build_tool means the resource runs a prebuilt JAR, so there are no build files to
+    // reimport and no reason to pay for language server startup.
+    if (!launchConfig.build_tool) {
+        extensionLogOutputChannel.info('Skipping Java project configuration refresh because the resource does not declare a build tool.');
+        return;
+    }
+
+    if (!await waitForJavaLanguageServerReady()) {
+        extensionLogOutputChannel.warn(`Skipping the ${launchConfig.build_tool} project configuration refresh because the Java language server is unavailable. Launching anyway.`);
+        return;
+    }
+
+    try {
+        await updateJavaProjectConfiguration(launchConfig.build_tool);
+    } catch (e) {
+        extensionLogOutputChannel.warn(`Failed to refresh the ${launchConfig.build_tool} project configuration: ${e}. Launching anyway.`);
+    }
+}
+
+// path.isAbsolute resolves against the *host* platform, but the app host can hand us a Windows path
+// while the extension runs on POSIX (remote/WSL/container scenarios), so check both flavours.
+// path.win32.isAbsolute also accepts POSIX-rooted paths, but being explicit keeps the intent clear.
+function isAbsolutePath(value: string): boolean {
+    return path.win32.isAbsolute(value) || path.posix.isAbsolute(value);
+}
+
+// main_class is either a fully qualified class name (com.example.Api) or the absolute path of an
+// executable JAR whose manifest declares Main-Class (/workspace/api/target/api.jar). Only the class
+// name is worth showing in the Call Stack view; the JAR path is less specific than the project
+// directory the user recognises.
+function isFullyQualifiedClassName(mainClass: string): boolean {
+    return mainClass.includes('.')
+        && !mainClass.toLowerCase().endsWith('.jar')
+        && !isAbsolutePath(mainClass);
+}
+
+function getProjectFile(launchConfig: ExecutableLaunchConfiguration): string {
+    if (isJavaLaunchConfiguration(launchConfig)) {
+        // The Java project directory is the only path the app host sends. It also feeds the central
+        // cwd derivation in prepareDebugSession, which the callback below then overrides explicitly.
+        return launchConfig.working_directory || '';
+    }
+
+    throw new Error(invalidLaunchConfiguration(JSON.stringify(launchConfig)));
+}
+
+export const javaDebuggerExtension: ResourceDebuggerExtension = {
+    resourceType: 'java',
+    debugAdapter: 'java',
+    extensionId: javaDebugExtensionId,
+
+    getDisplayName: (launchConfig: ExecutableLaunchConfiguration) => {
+        if (!isJavaLaunchConfiguration(launchConfig)) {
+            return javaLabel;
+        }
+
+        const mainClass = launchConfig.main_class;
+        if (mainClass && isFullyQualifiedClassName(mainClass)) {
+            return javaDisplayName(mainClass);
+        }
+
+        // asRelativePath keeps the Call Stack view readable. Rendering the directory through
+        // vscode.Uri.file(...).toString() instead produces a percent-encoded URI such as
+        // "Java: file:///c%3A/repo/api".
+        const workingDirectory = launchConfig.working_directory;
+
+        return workingDirectory ? javaDisplayName(vscode.workspace.asRelativePath(workingDirectory)) : javaLabel;
+    },
+
+    getSupportedFileTypes: () => ['.java'],
+
+    getProjectFile: (launchConfig) => getProjectFile(launchConfig),
+
+    createDebugSessionConfigurationCallback: async (
+        launchConfig: ExecutableLaunchConfiguration,
+        args: string[] | undefined,
+        _env: { name: string; value: string }[],
+        launchOptions: { debug: boolean;[key: string]: any },
+        debugConfiguration: AspireResourceExtendedDebugConfiguration
+    ): Promise<void> => {
+        if (!isJavaLaunchConfiguration(launchConfig)) {
+            extensionLogOutputChannel.info(`The resource type was not java for ${JSON.stringify(launchConfig)}`);
+            throw new Error(invalidLaunchConfiguration(JSON.stringify(launchConfig)));
+        }
+
+        await tryRefreshJavaProjectConfiguration(launchConfig);
+
+        debugConfiguration.type = 'java';
+        // The app host always sends "launch" today, but the wire schema allows "attach", so honour
+        // whatever it sends rather than hard-coding the current behaviour.
+        debugConfiguration.request = launchConfig.request ?? 'launch';
+        debugConfiguration.noDebug = !launchOptions.debug;
+
+        if (launchConfig.working_directory) {
+            debugConfiguration.cwd = launchConfig.working_directory;
+        }
+
+        // vscjava.vscode-java-debug requires mainClass to start a launch session, and accepts either
+        // a fully qualified class name or the absolute path of an executable JAR. When the app host
+        // omits it, leaving the attribute unset lets the adapter resolve the entry point from the
+        // project instead of failing on an empty value.
+        // https://github.com/microsoft/vscode-java-debug/blob/main/Configuration.md#main
+        //
+        // projectName is intentionally not set: the adapter defines it as the Maven artifactId or
+        // the Gradle baseName, neither of which can be derived from working_directory, and guessing
+        // it would scope class resolution to a project that may not exist.
+        if (launchConfig.main_class) {
+            debugConfiguration.mainClass = launchConfig.main_class;
+        }
+
+        // These are the application's own arguments. The app host strips the mvnw/gradlew wrapper
+        // arguments for java launch configurations (the wrappers fork a second JVM that a debugger
+        // attached to the wrapper would never see), so everything left here belongs to main(String[]).
+        // https://github.com/microsoft/vscode-java-debug/blob/main/Configuration.md#arguments
+        debugConfiguration.args = args ?? [];
+
+        // `env` is deliberately left alone. prepareDebugSession already set it to
+        // mergeEnvs(getEnvironmentWithoutE2EBridgeVariables(), env), i.e. the full inherited
+        // environment with the resource's variables layered on top. Reassigning it from `env` alone
+        // would launch the JVM without PATH or JAVA_HOME, so the adapter could not find `java`.
+    }
+};

extension/src/loc/strings.ts

@@ -185,6 +185,8 @@ export const bunDisplayName = (script: string) => `Bun: ${script}`;
 export const bunLabel = 'Bun';
 export const nodeDisplayName = (script: string) => `Node.js: ${script}`;
 export const nodeLabel = 'Node.js';
+export const javaDisplayName = (mainClass: string) => vscode.l10n.t('Java: {0}', mainClass);
+export const javaLabel = vscode.l10n.t('Java');
 export const dontShowAgainLabel = vscode.l10n.t("Don't Show Again");
 export const doYouWantToSetDefaultApphost = (appHost: string) => vscode.l10n.t('Do you want to set {0} as the default AppHost for this workspace?', appHost);
 export const doYouWantToSelectDefaultApphost = vscode.l10n.t('Do you want to select the default AppHost for this workspace?');