@vscjava/java-language-server 0.1.0

package/README.md

@@ -0,0 +1,102 @@
+# @vscjava/java-language-server
+
+Java Language Server (Eclipse JDT LS wrapper) distributed via npm, designed for integration with GitHub Copilot CLI.
+
+## Overview
+
+This package wraps [Eclipse JDT Language Server](https://github.com/eclipse-jdtls/eclipse.jdt.ls) and distributes it via npm following the same platform-specific pattern used by `@vscjava/cpp-language-server`.
+
+## Installation
+
+```bash
+npm install -g @vscjava/java-language-server
+```
+
+The installation automatically downloads the correct platform configuration for your OS.
+To bundle a JRE (no separate Java install needed):
+
+```bash
+npm install -g @vscjava/java-language-server @vscjava/java-ls-jre-win32-x64
+```
+
+## Prerequisites
+
+- **Node.js** >= 16
+- **Java 21+** (unless using the bundled JRE package)
+
+## Usage
+
+### Standalone
+
+```bash
+jdtls --stdio
+```
+
+### With Copilot CLI
+
+Add to `~/.copilot/lsp-config.json`:
+
+```json
+{
+  "lspServers": {
+    "java": {
+      "command": "jdtls",
+      "args": ["--stdio"],
+      "fileExtensions": {
+        ".java": "java"
+      }
+    }
+  }
+}
+```
+
+### Project Configuration
+
+Create `java-lsp.json` in your project root:
+
+```json
+{
+  "repositoryPath": "/path/to/project",
+  "java": {
+    "home": null,
+    "vmargs": ["-Xmx2G"]
+  },
+  "project": {
+    "type": "auto",
+    "importOnStartup": true
+  }
+}
+```
+
+## Java Runtime Resolution Order
+
+1. Bundled JRE (optional `@vscjava/java-ls-jre-*` package)
+2. `java.home` in `java-lsp.json`
+3. `JAVA_HOME` environment variable
+4. `java` on system PATH
+
+## Architecture
+
+```
+@vscjava/java-language-server          (main package - Node.js shell + shared JARs)
+├── bin/jdtls.js                       (entry point)
+├── lib/install.js                     (platform detection, JVM resolution)
+├── lib/detect.js                      (Maven/Gradle project detection)
+├── server/plugins/                    (Eclipse JDT LS jars - cross-platform)
+└── optionalDependencies:
+    ├── @vscjava/java-ls-config-*      (platform-specific launcher config)
+    └── @vscjava/java-ls-jre-*         (optional bundled JRE)
+```
+
+## Server Files
+
+After installing, place the jdtls server files in `server/`:
+
+```bash
+# Download jdtls
+curl -L https://download.eclipse.org/jdtls/milestones/1.40.0/jdt-language-server-1.40.0-202410311350.tar.gz | tar xz -C node_modules/@vscjava/java-language-server/server/
+```
+
+## License
+
+EPL-2.0 (Eclipse JDT LS), see individual packages for details.

package/bin/jdtls.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { findJava, findConfigDir, findLauncherJar, getWorkspaceDir } = require('../lib/install');
+const { detectProject } = require('../lib/detect');
+
+const SERVER_DIR = path.join(__dirname, '..', 'server');
+
+function loadConfig() {
+  let dir = process.cwd();
+  while (dir) {
+    const configPath = path.join(dir, 'java-lsp.json');
+    if (fs.existsSync(configPath)) {
+      try {
+        return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      } catch (e) {
+        console.error(`Warning: Failed to parse ${configPath}: ${e.message}`);
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return {};
+}
+
+function buildArgs(config) {
+  const javaExe = findJava(config);
+  if (!javaExe) {
+    console.error('ERROR: Java 21+ runtime not found.');
+    console.error('Install Java 21+ and set JAVA_HOME, or install the optional JRE package:');
+    console.error(`  npm install @vscjava/java-ls-jre-${process.platform}-${process.arch}`);
+    process.exit(1);
+  }
+
+  const configDir = findConfigDir();
+  if (!configDir) {
+    console.error(`ERROR: No platform configuration found for ${process.platform}.`);
+    console.error('Supported platforms: win32, linux, darwin');
+    process.exit(1);
+  }
+
+  const launcher = findLauncherJar(SERVER_DIR);
+  if (!launcher) {
+    console.error('ERROR: Eclipse Equinox launcher jar not found in server/plugins/.');
+    console.error('The package may be corrupted. Try reinstalling.');
+    process.exit(1);
+  }
+
+  const workspaceDir = getWorkspaceDir(config);
+  const vmargs = (config.java && config.java.vmargs) || ['-Xmx1G'];
+
+  const args = [
+    ...vmargs,
+    '-Declipse.application=org.eclipse.jdt.ls.core.id1',
+    '-Dosgi.bundles.defaultStartLevel=4',
+    '-Dosgi.checkConfiguration=true',
+    '-Declipse.product=org.eclipse.jdt.ls.core.product',
+    '-Dlog.level=ALL',
+    '--add-modules=ALL-SYSTEM',
+    '--add-opens', 'java.base/java.util=ALL-UNNAMED',
+    '--add-opens', 'java.base/java.lang=ALL-UNNAMED',
+    '-jar', launcher,
+    '-configuration', configDir,
+    '-data', workspaceDir,
+  ];
+
+  args.push(...process.argv.slice(2));
+
+  return { javaExe, args };
+}
+
+/**
+ * Encode a JSON-RPC message with Content-Length header for LSP protocol.
+ */
+function encodeLspMessage(msg) {
+  const json = JSON.stringify(msg);
+  const byteLength = Buffer.byteLength(json, 'utf8');
+  return `Content-Length: ${byteLength}\r\n\r\n${json}`;
+}
+
+/**
+ * Fix malformed file:// URIs.
+ * Copilot CLI sends "file://C:\path" but LSP spec requires "file:///C:/path".
+ */
+function fixFileUri(uri) {
+  if (!uri || !uri.startsWith('file://')) return uri;
+  // Remove the file:// prefix
+  let path = uri.substring(7);
+  // Replace backslashes with forward slashes
+  path = path.replace(/\\/g, '/');
+  // Ensure leading slash for absolute paths (e.g., "C:/..." → "/C:/...")
+  if (path.match(/^[A-Za-z]:/)) {
+    path = '/' + path;
+  }
+  // Ensure it doesn't already have the triple slash
+  if (!path.startsWith('/')) {
+    path = '/' + path;
+  }
+  return 'file://' + path;
+}
+
+/**
+ * Fix rootUri and workspaceFolders in an initialize request message.
+ */
+function fixInitializeRequest(text) {
+  const headerEnd = text.indexOf('\r\n\r\n');
+  if (headerEnd === -1) return text;
+
+  const header = text.substring(0, headerEnd);
+  const body = text.substring(headerEnd + 4);
+
+  try {
+    const msg = JSON.parse(body);
+    if (!msg.params) return text;
+
+    let modified = false;
+
+    if (msg.params.rootUri) {
+      const fixed = fixFileUri(msg.params.rootUri);
+      if (fixed !== msg.params.rootUri) {
+        console.error(`[jdtls-proxy] Fixed rootUri: ${msg.params.rootUri} → ${fixed}`);
+        msg.params.rootUri = fixed;
+        modified = true;
+      }
+    }
+
+    if (msg.params.rootPath) {
+      msg.params.rootPath = msg.params.rootPath.replace(/\\/g, '/');
+    }
+
+    if (Array.isArray(msg.params.workspaceFolders)) {
+      for (const folder of msg.params.workspaceFolders) {
+        if (folder.uri) {
+          const fixed = fixFileUri(folder.uri);
+          if (fixed !== folder.uri) {
+            console.error(`[jdtls-proxy] Fixed workspace folder URI: ${folder.uri} → ${fixed}`);
+            folder.uri = fixed;
+            modified = true;
+          }
+        }
+      }
+    }
+
+    if (modified) {
+      return encodeLspMessage(msg);
+    }
+  } catch {
+    // Not valid JSON, return as-is
+  }
+
+  return text;
+}
+
+/**
+ * Lightweight LSP proxy that:
+ * 1. Fixes malformed file:// URIs in initialize requests
+ * 2. Automatically sends 'initialized' notification to jdtls
+ */
+function createLspProxy(child) {
+  let sentInitialized = false;
+  let clientBuffer = '';
+  let buffering = true;
+
+  // Client → Server: intercept initialize request to fix URIs
+  process.stdin.on('data', (chunk) => {
+    if (!buffering) {
+      // After init handshake, direct passthrough
+      child.stdin.write(chunk);
+      return;
+    }
+
+    clientBuffer += chunk.toString('utf8');
+
+    // Check if we have a complete initialize request
+    if (clientBuffer.includes('"method":"initialize"') || clientBuffer.includes('"method": "initialize"')) {
+      const headerEnd = clientBuffer.indexOf('\r\n\r\n');
+      if (headerEnd !== -1) {
+        const header = clientBuffer.substring(0, headerEnd);
+        const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+        if (lengthMatch) {
+          const contentLength = parseInt(lengthMatch[1], 10);
+          const bodyStart = headerEnd + 4;
+          if (clientBuffer.length >= bodyStart + contentLength) {
+            // We have the complete initialize message
+            const fullMessage = clientBuffer.substring(0, bodyStart + contentLength);
+            const remaining = clientBuffer.substring(bodyStart + contentLength);
+
+            // Fix URIs and forward
+            const fixed = fixInitializeRequest(fullMessage);
+            child.stdin.write(fixed);
+
+            // Forward any remaining data
+            if (remaining.length > 0) {
+              child.stdin.write(remaining);
+            }
+
+            buffering = false;
+            sentInitialized = true;
+            clientBuffer = '';
+
+            // Send initialized notification after server processes initialize
+            setTimeout(() => {
+              console.error('[jdtls-proxy] Sending initialized notification to server');
+              const initialized = encodeLspMessage({ jsonrpc: '2.0', method: 'initialized', params: {} });
+              child.stdin.write(initialized);
+            }, 3000);
+
+            // Switch to direct piping
+            process.stdin.removeAllListeners('data');
+            process.stdin.pipe(child.stdin);
+            return;
+          }
+        }
+      }
+    }
+
+    // If buffer gets too big without finding initialize, flush and passthrough
+    if (clientBuffer.length > 50000) {
+      child.stdin.write(clientBuffer);
+      clientBuffer = '';
+      buffering = false;
+      process.stdin.removeAllListeners('data');
+      process.stdin.pipe(child.stdin);
+    }
+  });
+
+  // Server → Client: direct passthrough (no interception needed)
+  child.stdout.pipe(process.stdout);
+
+  // Forward server stderr to our stderr
+  child.stderr.pipe(process.stderr);
+}
+
+function main() {
+  const config = loadConfig();
+
+  const projectInfo = detectProject(config.repositoryPath || process.cwd());
+  if (projectInfo.type !== 'unknown') {
+    console.error(`Detected ${projectInfo.type} project: ${projectInfo.buildFile}`);
+  }
+
+  const { javaExe, args } = buildArgs(config);
+
+  console.error(`Starting jdtls with: ${javaExe}`);
+
+  const child = spawn(javaExe, args, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    windowsHide: false,
+    env: { ...process.env },
+  });
+
+  // Set up the LSP proxy to inject 'initialized' notification
+  createLspProxy(child);
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code || 0);
+    }
+  });
+
+  child.on('error', (err) => {
+    console.error(`Failed to start jdtls: ${err.message}`);
+    if (err.code === 'ENOENT') {
+      console.error(`Java executable not found at: ${javaExe}`);
+      console.error('Ensure Java 21+ is installed and JAVA_HOME is set correctly.');
+    }
+    process.exit(1);
+  });
+
+  // Handle parent process signals
+  process.on('SIGTERM', () => child.kill('SIGTERM'));
+  process.on('SIGINT', () => child.kill('SIGINT'));
+}
+
+main();

package/lib/detect.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+const PROJECT_TYPES = {
+  MAVEN: 'maven',
+  GRADLE: 'gradle',
+  UNKNOWN: 'unknown',
+};
+
+const BUILD_FILES = {
+  [PROJECT_TYPES.MAVEN]: ['pom.xml'],
+  [PROJECT_TYPES.GRADLE]: ['build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts'],
+};
+
+/**
+ * Detect the Java project type by looking for build files.
+ * Searches from the given directory upward to the filesystem root.
+ */
+function detectProject(startDir) {
+  let dir = startDir || process.cwd();
+
+  while (dir) {
+    // Check Maven
+    for (const buildFile of BUILD_FILES[PROJECT_TYPES.MAVEN]) {
+      const fullPath = path.join(dir, buildFile);
+      if (fs.existsSync(fullPath)) {
+        return {
+          type: PROJECT_TYPES.MAVEN,
+          buildFile: fullPath,
+          projectRoot: dir,
+          settings: detectMavenSettings(dir),
+        };
+      }
+    }
+
+    // Check Gradle
+    for (const buildFile of BUILD_FILES[PROJECT_TYPES.GRADLE]) {
+      const fullPath = path.join(dir, buildFile);
+      if (fs.existsSync(fullPath)) {
+        return {
+          type: PROJECT_TYPES.GRADLE,
+          buildFile: fullPath,
+          projectRoot: dir,
+          settings: detectGradleSettings(dir),
+        };
+      }
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return {
+    type: PROJECT_TYPES.UNKNOWN,
+    buildFile: null,
+    projectRoot: startDir,
+    settings: {},
+  };
+}
+
+/**
+ * Detect Maven-specific settings.
+ */
+function detectMavenSettings(projectRoot) {
+  const settings = {
+    hasWrapper: false,
+    isMultiModule: false,
+  };
+
+  // Check for Maven wrapper
+  const wrapperScript = process.platform === 'win32' ? 'mvnw.cmd' : 'mvnw';
+  settings.hasWrapper = fs.existsSync(path.join(projectRoot, wrapperScript));
+
+  // Check for multi-module (look for <modules> in pom.xml)
+  try {
+    const pomContent = fs.readFileSync(path.join(projectRoot, 'pom.xml'), 'utf8');
+    settings.isMultiModule = /<modules>/.test(pomContent);
+  } catch {
+    // Ignore read errors
+  }
+
+  return settings;
+}
+
+/**
+ * Detect Gradle-specific settings.
+ */
+function detectGradleSettings(projectRoot) {
+  const settings = {
+    hasWrapper: false,
+    isKotlinDsl: false,
+    isMultiProject: false,
+  };
+
+  // Check for Gradle wrapper
+  const wrapperScript = process.platform === 'win32' ? 'gradlew.bat' : 'gradlew';
+  settings.hasWrapper = fs.existsSync(path.join(projectRoot, wrapperScript));
+
+  // Check for Kotlin DSL
+  settings.isKotlinDsl = fs.existsSync(path.join(projectRoot, 'build.gradle.kts'))
+    || fs.existsSync(path.join(projectRoot, 'settings.gradle.kts'));
+
+  // Check for multi-project (settings.gradle exists with include)
+  const settingsFile = settings.isKotlinDsl ? 'settings.gradle.kts' : 'settings.gradle';
+  try {
+    const content = fs.readFileSync(path.join(projectRoot, settingsFile), 'utf8');
+    settings.isMultiProject = /include\s*[("']/.test(content);
+  } catch {
+    // Ignore read errors
+  }
+
+  return settings;
+}
+
+module.exports = {
+  detectProject,
+  PROJECT_TYPES,
+};

package/lib/install.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+const PLATFORM_CONFIG_MAP = {
+  win32: 'config_win',
+  linux: 'config_linux',
+  darwin: 'config_mac',
+};
+
+const PLATFORM_PKG_MAP = {
+  win32: '@vscjava/java-ls-config-win32',
+  linux: '@vscjava/java-ls-config-linux',
+  darwin: '@vscjava/java-ls-config-darwin',
+};
+
+/**
+ * Find a Java executable. Priority:
+ * 1. Bundled JRE (optional npm package)
+ * 2. Config-specified java.home
+ * 3. JAVA_HOME environment variable
+ * 4. 'java' on PATH
+ */
+function findJava(config) {
+  const javaExeName = process.platform === 'win32' ? 'java.exe' : 'java';
+
+  // 1. Check bundled JRE package
+  const jrePkg = `@vscjava/java-ls-jre-${process.platform}-${process.arch}`;
+  try {
+    const jrePkgDir = path.dirname(require.resolve(`${jrePkg}/package.json`));
+    const bundledJava = path.join(jrePkgDir, 'jre', 'bin', javaExeName);
+    if (fs.existsSync(bundledJava)) {
+      return bundledJava;
+    }
+  } catch {
+    // Package not installed, continue
+  }
+
+  // 2. Check config-specified java.home
+  if (config && config.java && config.java.home) {
+    const configJava = path.join(config.java.home, 'bin', javaExeName);
+    if (fs.existsSync(configJava)) {
+      return configJava;
+    }
+    console.error(`Warning: java.home in config points to ${config.java.home} but java not found there.`);
+  }
+
+  // 3. Check JAVA_HOME
+  if (process.env.JAVA_HOME) {
+    const javaHome = path.join(process.env.JAVA_HOME, 'bin', javaExeName);
+    if (fs.existsSync(javaHome)) {
+      return javaHome;
+    }
+    console.error(`Warning: JAVA_HOME is set to ${process.env.JAVA_HOME} but java not found there.`);
+  }
+
+  // 4. Fallback to PATH
+  return javaExeName;
+}
+
+/**
+ * Find the platform-specific configuration directory.
+ * Looks for the optional platform config npm package first,
+ * then falls back to a local config directory in the server folder.
+ */
+function findConfigDir() {
+  const platform = process.platform;
+  const configPkg = PLATFORM_PKG_MAP[platform];
+
+  if (!configPkg) {
+    return null;
+  }
+
+  // Try optional platform package
+  try {
+    const pkgDir = path.dirname(require.resolve(`${configPkg}/package.json`));
+    const configDirName = PLATFORM_CONFIG_MAP[platform];
+    const configDir = path.join(pkgDir, configDirName);
+    if (fs.existsSync(configDir)) {
+      return configDir;
+    }
+  } catch {
+    // Package not installed
+  }
+
+  // Fallback: look in server/ directory (for manual installs)
+  const serverDir = path.join(__dirname, '..', 'server');
+  const configDirName = PLATFORM_CONFIG_MAP[platform];
+  const localConfig = path.join(serverDir, configDirName);
+  if (fs.existsSync(localConfig)) {
+    return localConfig;
+  }
+
+  return null;
+}
+
+/**
+ * Find the Eclipse Equinox launcher jar in the plugins directory.
+ */
+function findLauncherJar(serverDir) {
+  const pluginsDir = path.join(serverDir, 'plugins');
+  if (!fs.existsSync(pluginsDir)) {
+    return null;
+  }
+
+  const files = fs.readdirSync(pluginsDir);
+  const launcher = files.find(f => f.startsWith('org.eclipse.equinox.launcher_') && f.endsWith('.jar'));
+  if (launcher) {
+    return path.join(pluginsDir, launcher);
+  }
+
+  return null;
+}
+
+/**
+ * Get or create the workspace data directory.
+ * Each project gets its own workspace to avoid conflicts.
+ */
+function getWorkspaceDir(config) {
+  if (config && config.workspace && config.workspace.dataDir) {
+    return config.workspace.dataDir;
+  }
+
+  // Create a unique workspace per project based on cwd hash
+  const crypto = require('crypto');
+  const cwd = config && config.repositoryPath ? config.repositoryPath : process.cwd();
+  const hash = crypto.createHash('md5').update(cwd).digest('hex').substring(0, 8);
+  const projectName = path.basename(cwd);
+
+  const dataDir = path.join(
+    process.env.HOME || process.env.USERPROFILE || '/tmp',
+    '.jdtls-workspace',
+    `${projectName}-${hash}`
+  );
+
+  if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true });
+  }
+
+  return dataDir;
+}
+
+/**
+ * Get the path to the platform-specific native binary (if any).
+ */
+function getBinaryPath() {
+  // For Java LS, the "binary" is the java executable
+  return findJava({});
+}
+
+module.exports = {
+  findJava,
+  findConfigDir,
+  findLauncherJar,
+  getWorkspaceDir,
+  getBinaryPath,
+  PLATFORM_CONFIG_MAP,
+  PLATFORM_PKG_MAP,
+};