nekolas note

毎日書くことを目指しているけど全然達成できてないブログ

12.9 KB Raw
//! MCP "ide" WebSocket サーバ + ロックファイル(T027/T028/T031/T032/T033)。
//! 参照: contracts/zed-ide-bridge.md
//!
//!  - ~/.claude/ide/<port>.lock を生成(dir 0700 / file 0600, T027)
//!  - localhost WebSocket を待受、auth ヘッダ x-claude-code-ide-authorization 検証(T028)
//!  - MCP: initialize / tools/list / tools/call(getCurrentSelection 等, T031, getDiagnostics 空 T033)
//!  - push: selection_changed をブロードキャスト(T030 配線)
//!  - 接続成功/失敗/切断で Zed 通知(T032, FR-028/029)

use crate::notify::{selection_changed_payload, Notifier};
use crate::protocol::{
    mcp_text_content, rpc_error, rpc_notification, rpc_result, RpcMessage, MCP_PROTOCOL_VERSION,
};
use crate::state::SharedState;
use anyhow::{anyhow, Result};
use futures_util::{SinkExt, StreamExt};
use serde_json::{json, Value};
use std::sync::Arc;
use tokio::net::{TcpListener, TcpStream};
use tokio_tungstenite::tungstenite::handshake::server::{ErrorResponse, Request, Response};
use tokio_tungstenite::tungstenite::http::{Response as HttpResponse, StatusCode};
use tokio_tungstenite::tungstenite::Message;

const AUTH_HEADER: &str = "x-claude-code-ide-authorization";

/// WS サーバを起動する。ポート範囲内で空きを探し、ロックファイルを書き、accept ループへ。
pub async fn serve(
    state: Arc<SharedState>,
    notifier: Notifier,
    port_min: u16,
    port_max: u16,
) -> Result<()> {
    let auth_token = uuid::Uuid::new_v4().to_string();

    // ポート確保。
    let (listener, port) = match bind_in_range(port_min, port_max).await {
        Ok(v) => v,
        Err(e) => {
            notifier.connect_failed(&format!("待受ポートを確保できませんでした: {e}"));
            return Err(e);
        }
    };
    tracing::info!("MCP ide WS listening on 127.0.0.1:{port}");

    // ロックファイル生成(失敗しても接続自体は試せるが、Claude が発見できないので警告)。
    // プロセス生存中は保持する(後始末は OS / 次回起動時の掃除に委ねる)。
    let _lock_path = match write_lockfile(port, &auth_token) {
        Ok(p) => Some(p),
        Err(e) => {
            tracing::warn!("ロックファイル生成失敗: {e}");
            notifier.connect_failed(&format!("ロックファイル生成に失敗: {e}"));
            None
        }
    };

    // accept ループ(プロセス終了まで継続)。
    loop {
        let (stream, _peer) = match listener.accept().await {
            Ok(v) => v,
            Err(e) => {
                tracing::warn!("accept 失敗: {e}");
                continue;
            }
        };
        let state = state.clone();
        let notifier = notifier.clone();
        let token = auth_token.clone();
        tokio::spawn(async move {
            if let Err(e) = handle_conn(stream, state, notifier.clone(), token).await {
                tracing::warn!("接続処理終了: {e}");
            }
        });
    }
}

/// ポート範囲内で bind を試みる。
async fn bind_in_range(min: u16, max: u16) -> Result<(TcpListener, u16)> {
    // まず OS 任せ(0)で素早く確保し、範囲内なら採用。範囲指定が狭い場合は線形探索。
    for port in min..=max.min(min.saturating_add(200)) {
        if let Ok(l) = TcpListener::bind(("127.0.0.1", port)).await {
            return Ok((l, port));
        }
    }
    // フォールバック: OS 割当。
    let l = TcpListener::bind(("127.0.0.1", 0)).await?;
    let port = l.local_addr()?.port();
    if port < min || port > max {
        // 範囲外でも動作はするが、契約上は範囲内が望ましい。警告のみ。
        tracing::warn!("確保ポート {port} は要求範囲 [{min},{max}] 外");
    }
    Ok((l, port))
}

/// ~/.claude/ide/<port>.lock を VSCode 互換 JSON で書く(T027)。
fn write_lockfile(port: u16, auth_token: &str) -> Result<std::path::PathBuf> {
    use std::io::Write;
    let home = dirs::home_dir().ok_or_else(|| anyhow!("HOME 不明"))?;
    let dir = home.join(".claude").join("ide");
    std::fs::create_dir_all(&dir)?;
    set_permissions(&dir, 0o700)?;

    let pid = std::process::id();
    let workspace = std::env::current_dir()
        .map(|p| p.to_string_lossy().to_string())
        .unwrap_or_default();
    let body = json!({
        "pid": pid,
        "workspaceFolders": [ workspace ],
        "ideName": "Zed",
        "transport": "ws",
        "runningInWindows": false,
        "authToken": auth_token,
    });

    let path = dir.join(format!("{port}.lock"));
    let mut f = std::fs::File::create(&path)?;
    f.write_all(serde_json::to_string_pretty(&body)?.as_bytes())?;
    f.flush()?;
    set_permissions(&path, 0o600)?;
    Ok(path)
}

#[cfg(unix)]
fn set_permissions(path: &std::path::Path, mode: u32) -> Result<()> {
    use std::os::unix::fs::PermissionsExt;
    std::fs::set_permissions(path, std::fs::Permissions::from_mode(mode))?;
    Ok(())
}
#[cfg(not(unix))]
fn set_permissions(_path: &std::path::Path, _mode: u32) -> Result<()> {
    Ok(())
}

/// 1 接続を処理: auth 検証 → MCP ループ → push タスク。
async fn handle_conn(
    stream: TcpStream,
    state: Arc<SharedState>,
    notifier: Notifier,
    expected_token: String,
) -> Result<()> {
    // ハンドシェイクで auth ヘッダを検証する(不一致は 401 で拒否)。
    let ws =
        match tokio_tungstenite::accept_hdr_async(stream, |req: &Request, mut resp: Response| {
            let ok = req
                .headers()
                .get(AUTH_HEADER)
                .and_then(|v| v.to_str().ok())
                .map(|v| v == expected_token)
                .unwrap_or(false);
            if ok {
                // Claude Code の WS クライアントは Sec-WebSocket-Protocol を要求し、
                // サーバがエコーしないとハンドシェイクを失敗扱いにする(claudecode.nvim 準拠)。
                // クライアントが提示したサブプロトコルの先頭1つをそのまま返す。
                if let Some(proto) = req
                    .headers()
                    .get("sec-websocket-protocol")
                    .and_then(|v| v.to_str().ok())
                    .and_then(|s| s.split(',').next())
                    .map(|s| s.trim().to_string())
                {
                    if let Ok(val) = proto.parse() {
                        resp.headers_mut().insert("sec-websocket-protocol", val);
                    }
                }
                Ok(resp)
            } else {
                let deny: ErrorResponse = HttpResponse::builder()
                    .status(StatusCode::UNAUTHORIZED)
                    .body(Some("unauthorized".to_string()))
                    .expect("build error response");
                Err(deny)
            }
        })
        .await
        {
            Ok(ws) => ws,
            Err(e) => {
                // 認証失敗を含む(FR-028: 失敗通知)。
                notifier.connect_failed("認証または WebSocket ハンドシェイクに失敗しました");
                return Err(anyhow!("handshake: {e}"));
            }
        };

    // ここまで来たら接続成立。
    notifier.connected();

    let (mut write, mut read) = ws.split();
    let (out_tx, mut out_rx) = tokio::sync::mpsc::unbounded_channel::<Value>();

    // 送信タスク: out_rx を WS へ流す。
    let send_task = tokio::spawn(async move {
        while let Some(v) = out_rx.recv().await {
            let txt = serde_json::to_string(&v).unwrap_or_else(|_| "{}".into());
            if write.send(Message::Text(txt)).await.is_err() {
                break;
            }
        }
        let _ = write.close().await;
    });

    // push タスク: SharedState の変化を selection_changed として配信(T030)。
    let push_out = out_tx.clone();
    let push_state = state.clone();
    let push_task = tokio::spawn(async move {
        let mut rx = push_state.subscribe();
        while let Ok(ctx) = rx.recv().await {
            let n = rpc_notification("selection_changed", selection_changed_payload(&ctx));
            if push_out.send(n).is_err() {
                break;
            }
        }
    });

    // 受信ループ: MCP リクエストを処理。
    let recv_result: Result<()> = async {
        while let Some(msg) = read.next().await {
            let msg = msg?;
            match msg {
                Message::Text(txt) => {
                    if let Ok(rpc) = serde_json::from_str::<RpcMessage>(&txt) {
                        handle_mcp(rpc, &out_tx, &state).await;
                    }
                }
                Message::Binary(_) => { /* 未使用 */ }
                Message::Ping(p) => {
                    let _ = out_tx.send(json!({"__ping_pong__": true})); // no-op marker
                    let _ = p; // tungstenite が自動 Pong する設定もあるが明示はしない
                }
                Message::Close(_) => break,
                _ => {}
            }
        }
        Ok(())
    }
    .await;

    // 後始末。
    push_task.abort();
    drop(out_tx);
    let _ = send_task.await;
    notifier.disconnected();
    recv_result
}

/// MCP メッセージ処理(initialize / tools/list / tools/call)。
async fn handle_mcp(
    msg: RpcMessage,
    out: &tokio::sync::mpsc::UnboundedSender<Value>,
    state: &Arc<SharedState>,
) {
    let method = match &msg.method {
        Some(m) => m.as_str(),
        None => return, // レスポンス/不明は無視
    };
    let id = msg.id.clone();

    match method {
        "initialize" => {
            // クライアントの protocolVersion をエコー(無ければ既定)。
            let pv = msg
                .params
                .as_ref()
                .and_then(|p| p.get("protocolVersion"))
                .and_then(|v| v.as_str())
                .unwrap_or(MCP_PROTOCOL_VERSION)
                .to_string();
            reply(
                out,
                id,
                json!({
                    "protocolVersion": pv,
                    "capabilities": { "tools": {} },
                    "serverInfo": { "name": "cc-ide-server", "version": env!("CARGO_PKG_VERSION") }
                }),
            );
        }
        "notifications/initialized" => { /* 通知 */ }
        "tools/list" => {
            reply(out, id, json!({ "tools": tool_list() }));
        }
        "tools/call" => {
            let name = msg
                .params
                .as_ref()
                .and_then(|p| p.get("name"))
                .and_then(|v| v.as_str())
                .unwrap_or("");
            let result = call_tool(name, state).await;
            match result {
                Ok(v) => reply(out, id, v),
                Err(e) => {
                    if let Some(idv) = id {
                        let _ = out.send(rpc_error(idv, -32603, &e.to_string()));
                    }
                }
            }
        }
        _ => {
            // 未知メソッドにはエラー(id があれば)。
            if let Some(idv) = id {
                let _ = out.send(rpc_error(idv, -32601, "method not found"));
            }
        }
    }
}

fn reply(out: &tokio::sync::mpsc::UnboundedSender<Value>, id: Option<Value>, result: Value) {
    if let Some(idv) = id {
        let _ = out.send(rpc_result(idv, result));
    }
}

/// 公開ツール一覧(T031/T033)。
fn tool_list() -> Value {
    json!([
        { "name": "getCurrentSelection", "description": "現在の選択/カーソルを返す", "inputSchema": { "type": "object", "properties": {} } },
        { "name": "getLatestSelection",  "description": "最新の選択/カーソルを返す", "inputSchema": { "type": "object", "properties": {} } },
        { "name": "getOpenEditors",      "description": "開いているアクティブファイルを返す", "inputSchema": { "type": "object", "properties": {} } },
        { "name": "getDiagnostics",      "description": "診断(初版スコープ外: 常に空)", "inputSchema": { "type": "object", "properties": {} } }
    ])
}

/// ツール実行。pull 経路で現在状態を返す(FR-026)。診断は空(FR-022/T033)。
async fn call_tool(name: &str, state: &Arc<SharedState>) -> Result<Value> {
    match name {
        "getCurrentSelection" | "getLatestSelection" => {
            let ctx = state.snapshot().await;
            Ok(mcp_text_content(&selection_changed_payload(&ctx)))
        }
        "getOpenEditors" => {
            let ctx = state.snapshot().await;
            let editors = match ctx.file_path {
                Some(ref p) => json!([{ "filePath": p, "active": true }]),
                None => json!([]),
            };
            Ok(mcp_text_content(&editors))
        }
        "getDiagnostics" => {
            // 初版スコープ外: 常に空配列(FR-022)。
            Ok(mcp_text_content(&json!([])))
        }
        other => Err(anyhow!("unknown tool: {other}")),
    }
}