Zed Extension API: Rust WASM으로 커스텀 LSP와 슬래시 커맨드를 에디터에 심는 법

rustup target add wasm32-wasip2

my-extension/
├── extension.toml          # 메타데이터, LSP·슬래시 커맨드 선언
├── Cargo.toml
├── src/
│   └── lib.rs              # Extension 트레이트 구현
└── languages/
    └── my-lang/
        ├── config.toml     # 언어 정의
        └── highlights.scm  # Tree-sitter 구문 강조 쿼리

[lib]
crate-type = ["cdylib"]
 
[dependencies]
zed_extension_api = "0.5"

id = "my-extension"
name = "My Extension"
version = "0.1.0"
schema_version = 1
authors = ["Your Name <you@example.com>"]
description = "Custom LSP and slash commands"
 
[language_servers.my-lsp]
name = "My Language Server"
language = "my-lang"
 
[[slash_commands]]
name = "my-command"
description = "Does something useful"
requires_argument = false

// 개념적 예시. 실제 트레이트 시그니처는 zed_extension_api 버전별 docs.rs 참조.
use zed_extension_api::{self as zed, LanguageServerId, Worktree, Command, Result};
 
struct MyExtension;
 
impl zed::Extension for MyExtension {
    fn new() -> Self {
        MyExtension
    }
 
    fn language_server_command(
        &mut self,
        _language_server_id: &LanguageServerId,
        worktree: &Worktree,
    ) -> Result<Command> {
        let binary_path = worktree
            .which("my-lsp")
            .ok_or("my-lsp binary not found in PATH")?;
 
        Ok(Command {
            command: binary_path,
            args: vec!["--stdio".to_string()],
            env: vec![],
        })
    }
}
 
zed::register_extension!(MyExtension);

// 개념적 예시(pseudocode에 가깝습니다).
// 함수명·필드명·enum variant는 zed_extension_api 버전에 따라 다르므로
// docs.rs에서 실제 시그니처와 사용 가능한 옵션을 확인하세요.
fn language_server_command(
    &mut self,
    _language_server_id: &LanguageServerId,
    _worktree: &Worktree,
) -> Result<Command> {
    // 필드명은 예: require_assets / requires_assets, pre_release / prerelease
    // 등 버전 간 차이가 있을 수 있음
    let release = zed::latest_github_release(
        "my-org/my-lsp",
        zed::GithubReleaseOptions { /* docs.rs 참조 */ },
    )?;
 
    let platform = zed::current_platform();
    let asset_name = format!("my-lsp-{}-{}.tar.gz", release.version, platform);
 
    let asset = release
        .assets
        .iter()
        .find(|a| a.name == asset_name)
        .ok_or_else(|| format!("no asset for platform: {platform}"))?;
 
    // 다운로드 대상 경로는 익스텐션 작업 디렉터리 기준 상대 경로로 지정합니다.
    // 호스트(Zed)는 이 경로를 익스텐션별 격리된 디렉터리로 매핑해 실제 파일
    // 시스템 경로를 프로세스 exec 시점에 resolve합니다. 즉 WASM 안에서 만든
    // 상대 경로가 그대로 native 커맨드로 넘어가는 것이 아니라, 호스트가
    // 자기 저장 위치를 붙여 실행합니다. 정확한 매핑 규칙은 공식 문서 확인.
    let binary_path = format!("my-lsp-{}/bin/my-lsp", release.version);
 
    if !std::fs::metadata(&binary_path).map_or(false, |m| m.is_file()) {
        zed::download_file(
            &asset.download_url,
            &binary_path,
            zed::DownloadedFileType::GzipTar,
        )
        .map_err(|e| format!("failed to download: {e}"))?;
    }
 
    Ok(Command {
        command: binary_path,
        args: vec!["--stdio".to_string()],
        env: vec![],
    })
}

// 개념적 예시. SlashCommandOutputSection의 실제 필드 구성은
// docs.rs에서 확인 후 조정 필요.
use zed_extension_api::{
    self as zed, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
    Worktree, Result,
};
 
impl zed::Extension for MyExtension {
    // ... new, language_server_command 등
 
    fn run_slash_command(
        &self,
        command: SlashCommand,
        args: Vec<String>,
        _worktree: Option<&Worktree>,
    ) -> Result<SlashCommandOutput, String> {
        match command.name.as_str() {
            "my-command" => {
                let label = args.first().cloned().unwrap_or_default();
                let text = format!("# {label}\n\n여기에 컨텍스트 내용이 들어갑니다.");
                Ok(SlashCommandOutput {
                    sections: vec![SlashCommandOutputSection {
                        range: (0..label.len()).into(),
                        label: label.clone(),
                        // 아이콘 관련 필드는 API 버전에 따라 존재/이름/타입이
                        // 다르므로 docs.rs를 확인하고 필요한 필드만 채우세요.
                    }],
                    text,
                })
            }
            _ => Err(format!("unknown command: {}", command.name)),
        }
    }
 
    fn complete_slash_command_argument(
        &self,
        command: SlashCommand,
        _args: Vec<String>,
    ) -> Result<Vec<zed::SlashCommandArgumentCompletion>, String> {
        match command.name.as_str() {
            "my-command" => Ok(vec![
                zed::SlashCommandArgumentCompletion {
                    label: "option-one".to_string(),
                    new_text: "option-one".to_string(),
                    run_command: true,
                },
                zed::SlashCommandArgumentCompletion {
                    label: "option-two".to_string(),
                    new_text: "option-two".to_string(),
                    run_command: true,
                },
            ]),
            _ => Err(format!("unknown command: {}", command.name)),
        }
    }
}

cargo build --release --target wasm32-wasip2

{
  "dev_extensions": ["/path/to/my-extension"]
}