尝试用用看Zed

// Zed settings
//
// For information on how to configure Zed, see the Zed
// documentation: https://zed.dev/docs/configuring-zed
//
// To see all of Zed's default settings without changing your
// custom settings, run `zed: open default settings` from the
// command palette (cmd-shift-p / ctrl-shift-p)
{
  // 其他配置略...
  "lsp": {
    "jdtls": {
      "settings": {
        "java_home": "/opt/homebrew/opt/openjdk@25/",
        "lombok_support": true,
        "java": {
          "contentProvider": {
            "preferred": "fernflower",
          },
        },
      },
    },
  },
}

Language server kotlin-lsp:

from extension "Kotlin" version 0.2.1: download failed with status 404 Not Found

ls -l ~/kotlin-lsp

total 32
drwxr-xr-x@   3 tdiant  staff     96 Apr 30 04:51 jre
-rwxr-xr-x@   1 tdiant  staff   7707 Apr 30 23:57 kotlin-lsp-proxy.py
-rw-r--r--@   1 tdiant  staff   3405 Nov 30  1979 kotlin-lsp.cmd
-rwxr-xr-x@   1 tdiant  staff   4093 Nov 30  1979 kotlin-lsp.sh
drwxr-xr-x@ 645 tdiant  staff  20640 Apr 30 04:51 lib
drwxr-xr-x@   4 tdiant  staff    128 Apr 30 04:51 native

// Zed settings
//
// For information on how to configure Zed, see the Zed
// documentation: https://zed.dev/docs/configuring-zed
//
// To see all of Zed's default settings without changing your
// custom settings, run `zed: open default settings` from the
// command palette (cmd-shift-p / ctrl-shift-p)
{
  // 其他配置略...
  "languages": {
    "Kotlin": {
      "language_servers": ["kotlin-lsp"],
    },
  },
  "lsp": {
    "kotlin-lsp": {
      "binary": { // 这里其实后面还要改
        "path": "/Users/tdiant/kotlin-lsp/kotlin-lsp.sh",
        "arguments": ["--stdio"],
      },
    },
    "kotlin-language-server": {
      "binary": {
        "env": {
          "JAVA_HOME": "/opt/homebrew/opt/openjdk@25/",
        },
      },
    },
}

#!/usr/bin/env python3
import json
import os
import signal
import subprocess
import sys
import tempfile
import threading
import zipfile
from pathlib import Path

SOURCE_CACHE_DIR = Path(
    os.environ.get("KOTLIN_LSP_SOURCE_CACHE")
    or os.path.join(tempfile.gettempdir(), "kotlin-lsp-sources")
)
ZIP_LOCK = threading.Lock()


def read_message(f):
    headers = {}
    while True:
        line = f.readline()
        if not line:
            return None
        line = line.decode("utf-8").strip()
        if line == "":
            break
        if ":" not in line:
            continue
        key, value = line.split(":", 1)
        headers[key.strip().lower()] = value.strip()

    if "content-length" not in headers:
        return None

    length = int(headers["content-length"])
    body = b""
    while len(body) < length:
        chunk = f.read(length - len(body))
        if not chunk:
            return None
        body += chunk
    return body.decode("utf-8")


def write_message(f, payload_bytes):
    header = f"Content-Length: {len(payload_bytes)}\r\n\r\n".encode("utf-8")
    f.write(header + payload_bytes)
    f.flush()


def resolve_zip_uri(uri: str) -> str:
    if not uri or not isinstance(uri, str):
        return uri

    original = uri

    if uri.startswith("jar:"):
        uri = uri[4:]
    if uri.startswith("file://"):
        uri = uri[7:]
    elif uri.startswith("file:"):
        uri = uri[5:]

    lower = uri.lower()
    for ext in (".zip", ".jar"):
        idx = lower.rfind(ext + "!/")
        if idx == -1:
            continue

        zip_path = uri[: idx + len(ext)]
        internal_path = uri[idx + len(ext) + 2 :]

        if not os.path.isabs(zip_path):
            return original
        if not os.path.isfile(zip_path):
            return original

        cache_root = SOURCE_CACHE_DIR / Path(zip_path).name
        cache_file = cache_root / internal_path

        if cache_file.exists():
            return "file://" + str(cache_file)

        with ZIP_LOCK:
            if cache_file.exists():
                return "file://" + str(cache_file)

            try:
                with zipfile.ZipFile(zip_path, "r") as zf:
                    names = set(zf.namelist())
                    candidates = [
                        internal_path,
                        internal_path.lstrip("/"),
                        "/" + internal_path,
                    ]
                    target = None
                    for cand in candidates:
                        if cand in names:
                            target = cand
                            break

                    if target is None:
                        return original

                    cache_root.mkdir(parents=True, exist_ok=True)
                    zf.extract(target, cache_root)

                    extracted = cache_root / target
                    if extracted.exists():
                        return "file://" + str(extracted)
                    if cache_file.exists():
                        return "file://" + str(cache_file)
                    return original
            except Exception:
                return original

    return original


def replace_zip_uris(obj):
    if isinstance(obj, dict):
        for key, value in obj.items():
            if key in ("uri", "targetUri") and isinstance(value, str):
                obj[key] = resolve_zip_uri(value)
            else:
                replace_zip_uris(value)
    elif isinstance(obj, list):
        for item in obj:
            replace_zip_uris(item)


def forward_client_to_server(client_in, server_out, lock):
    try:
        while True:
            msg = read_message(client_in)
            if msg is None:
                break
            payload = msg.encode("utf-8")
            with lock:
                write_message(server_out, payload)
    except Exception as e:
        print(f"[proxy] client->server error: {e}", file=sys.stderr, flush=True)


def forward_server_to_client(server_in, client_out, server_out, lock):
    try:
        while True:
            msg = read_message(server_in)
            if msg is None:
                break

            try:
                data = json.loads(msg)

                if data.get("method") == "window/showDocument":
                    msg_id = data.get("id")
                    if msg_id is not None:
                        response = {
                            "jsonrpc": "2.0",
                            "id": msg_id,
                            "result": {"success": True},
                        }
                        response_bytes = json.dumps(
                            response, separators=(",", ":")
                        ).encode("utf-8")
                        with lock:
                            write_message(server_out, response_bytes)
                    continue

                replace_zip_uris(data)
                msg = json.dumps(data, separators=(",", ":"))

            except (json.JSONDecodeError, KeyError):
                pass

            payload = msg.encode("utf-8")
            write_message(client_out, payload)
    except Exception as e:
        print(f"[proxy] server->client error: {e}", file=sys.stderr, flush=True)


def forward_stderr(server_err):
    try:
        while True:
            line = server_err.readline()
            if not line:
                break
            sys.stderr.buffer.write(b"[lsp-stderr] " + line)
            sys.stderr.buffer.flush()
    except Exception as e:
        print(f"[proxy] stderr error: {e}", file=sys.stderr, flush=True)


def main():
    script_dir = os.path.dirname(os.path.abspath(__file__))
    lsp_script = os.path.join(script_dir, "kotlin-lsp.sh")
    cache_dir = os.path.expanduser("~/.cache/kotlin-lsp")
    os.makedirs(cache_dir, exist_ok=True)
    os.makedirs(SOURCE_CACHE_DIR, exist_ok=True)

    proc = subprocess.Popen(
        [lsp_script, "--stdio", "--system-path", cache_dir],
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        cwd=script_dir,
        bufsize=0,
    )

    # Ensure Java child is killed when proxy exits (SIGTERM, SIGINT, etc.)
    def cleanup(signum, frame):
        print(f"[proxy] caught signal {signum}, terminating child...", file=sys.stderr, flush=True)
        try:
            proc.terminate()
            proc.wait(timeout=5)
        except Exception:
            proc.kill()
        sys.exit(0)

    signal.signal(signal.SIGTERM, cleanup)
    signal.signal(signal.SIGINT, cleanup)

    server_lock = threading.Lock()

    t_client = threading.Thread(
        target=forward_client_to_server,
        args=(sys.stdin.buffer, proc.stdin, server_lock),
        daemon=True,
    )
    t_server = threading.Thread(
        target=forward_server_to_client,
        args=(proc.stdout, sys.stdout.buffer, proc.stdin, server_lock),
        daemon=True,
    )
    t_stderr = threading.Thread(
        target=forward_stderr,
        args=(proc.stderr,),
        daemon=True,
    )

    t_client.start()
    t_server.start()
    t_stderr.start()

    t_client.join()
    t_server.join()
    t_stderr.join()

    print("[proxy] stdin closed, shutting down child...", file=sys.stderr, flush=True)
    try:
        proc.terminate()
        proc.wait(timeout=10)
    except Exception:
        proc.kill()
        proc.wait()


if __name__ == "__main__":
    main()

{
  // ...
  "lsp": {
    "kotlin-lsp": {
      "binary": {
        // 把下面的这些刚才做的配置：
        // "path": "/Users/tdiant/kotlin-lsp/kotlin-lsp.sh",
        // "arguments": ["--stdio"],
        // 入口改成我们刚才的这个python脚本：
        "path": "/Users/tdiant/kotlin-lsp/kotlin-lsp-proxy.py",
        "arguments": [],
      },
    },
  }
  //...
}