//! 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}")),
}
}