refactor: remove redundant ping command — info provides the same data

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: maxholman

crates/api/src/handlers.rs

@@ -11,7 +11,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use wallhack_wire::management::{
     ConnectRequest, DisconnectRequest, HintLevel, HintSetAutoRequest, HintSetRequest, InfoRequest,
-    ListenRequest, NodeRole, PeerDisconnectRequest, PeersRequest, PingRequest,
+    ListenRequest, NodeRole, PeerDisconnectRequest, PeersRequest,
     RouteAddRequest as ProtoRouteAddRequest, RouteDelRequest, RoutesRequest, ShutdownRequest,
     StatsRequest, management_request, management_response,
 };
@@ -125,14 +125,6 @@ pub struct ListenResponse {
     pub fingerprint: String,
 }
 
-/// Ping response.
-#[derive(Debug, Serialize)]
-pub struct PingResponseBody {
-    pub uptime_ms: u64,
-    pub version: String,
-    pub role: String,
-}
-
 /// Hint set request body.
 #[derive(Debug, Deserialize)]
 pub struct HintSetRequestBody {
@@ -624,64 +616,6 @@ pub async fn disconnect(State(state): State<ApiState>) -> (StatusCode, Json<Succ
     }
 }
 
-pub async fn ping(State(state): State<ApiState>) -> Result<Json<PingResponseBody>, StatusCode> {
-    let resp = state
-        .ipc
-        .lock()
-        .await
-        .request(management_request::Request::Ping(PingRequest {
-            peer: String::new(),
-        }))
-        .await
-        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-
-    match resp.response {
-        Some(management_response::Response::Ping(ping)) => {
-            let role = NodeRole::try_from(ping.node_role).unwrap_or(NodeRole::Unspecified);
-            Ok(Json(PingResponseBody {
-                uptime_ms: ping.uptime_ms,
-                version: ping.version,
-                role: role.to_string(),
-            }))
-        }
-        _ => Err(StatusCode::INTERNAL_SERVER_ERROR),
-    }
-}
-
-pub async fn peer_ping(
-    State(state): State<ApiState>,
-    Path(peer): Path<String>,
-) -> Result<Json<PingResponseBody>, StatusCode> {
-    let resp = state
-        .ipc
-        .lock()
-        .await
-        .request(management_request::Request::Ping(PingRequest { peer }))
-        .await
-        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-
-    match resp.response {
-        Some(management_response::Response::Ping(ping)) => {
-            let role = NodeRole::try_from(ping.node_role).unwrap_or(NodeRole::Unspecified);
-            Ok(Json(PingResponseBody {
-                uptime_ms: ping.uptime_ms,
-                version: ping.version,
-                role: role.to_string(),
-            }))
-        }
-        Some(management_response::Response::Error(e)) => {
-            let not_supported: i32 = wallhack_wire::management::ErrorCode::NotSupported.into();
-            if e.code == not_supported {
-                Err(StatusCode::NOT_IMPLEMENTED)
-            } else {
-                tracing::warn!("Ping peer failed: {}", e.message);
-                Err(StatusCode::NOT_FOUND)
-            }
-        }
-        _ => Err(StatusCode::INTERNAL_SERVER_ERROR),
-    }
-}
-
 pub async fn shutdown(State(state): State<ApiState>) -> (StatusCode, Json<SuccessResponse>) {
     let resp = state
         .ipc

crates/api/src/lib.rs

@@ -75,8 +75,6 @@ pub fn router(state: State) -> Router {
         .route("/connect", post(handlers::connect))
         .route("/listen", post(handlers::listen))
         .route("/disconnect", post(handlers::disconnect))
-        .route("/ping", get(handlers::ping))
-        .route("/ping/{peer}", get(handlers::peer_ping))
         .route("/shutdown", post(handlers::shutdown))
         .route(
             "/hints",

crates/cli/src/bin/wallhack.rs

@@ -15,16 +15,16 @@
 //!
 //! The dispatch heuristic: if the first argument starts with `-` it is a flag
 //! destined for the daemon CLI (auto-negotiation or global options). Control
-//! client subcommands are always bare words (`route`, `peers`, `ping`, etc.).
+//! client subcommands are always bare words (`route`, `peers`, `info`, etc.).
 
 use wallhack_cli::{
     cli::{CtlCommand, RouteAction},
     ipc, output,
 };
 use wallhack_wire::management::{
     ConnectRequest, DisconnectRequest, HintLevel, HintSetAutoRequest, HintSetRequest, InfoRequest,
-    ListenRequest, NodeRole, PeerDisconnectRequest, PeersRequest, PingRequest, RouteAddRequest,
-    RouteDelRequest, RoutesRequest, ShutdownRequest, StatsRequest, management_request,
+    ListenRequest, NodeRole, PeerDisconnectRequest, PeersRequest, RouteAddRequest, RouteDelRequest,
+    RoutesRequest, ShutdownRequest, StatsRequest, management_request,
 };
 
 const DAEMON_BIN_NAME: &str = "wallhackd";
@@ -312,9 +312,6 @@ async fn run_ctl_async(cli: wallhack_cli::cli::Cli) -> Result<(), output::CtlErr
         std::process::exit(1);
     };
     let request = match command {
-        CtlCommand::Ping(cmd) => management_request::Request::Ping(PingRequest {
-            peer: cmd.peer.unwrap_or_default(),
-        }),
         CtlCommand::Info(_) => management_request::Request::Info(InfoRequest {}),
         CtlCommand::Stats(_) => management_request::Request::Stats(StatsRequest {}),
         #[cfg(feature = "json")]

crates/cli/src/cli.rs

@@ -21,7 +21,6 @@ pub struct Cli {
 #[derive(FromArgs, Debug)]
 #[argh(subcommand)]
 pub enum CtlCommand {
-    Ping(PingCmd),
     Info(InfoCmd),
     Stats(StatsCmd),
     Peers(PeersCmd),
@@ -34,15 +33,6 @@ pub enum CtlCommand {
     Shutdown(ShutdownCmd),
 }
 
-/// Ping a peer.
-#[derive(FromArgs, Debug)]
-#[argh(subcommand, name = "ping")]
-pub struct PingCmd {
-    /// peer name prefix to ping (auto-selects sole peer if omitted)
-    #[argh(positional)]
-    pub peer: Option<String>,
-}
-
 /// Show daemon info.
 #[derive(FromArgs, Debug)]
 #[argh(subcommand, name = "info")]

crates/cli/src/output.rs

@@ -166,12 +166,6 @@ pub fn print_response(resp: &ManagementResponse) -> Result<(), CtlError> {
         Some(management_response::Response::Error(e)) => {
             return Err(CtlError::Daemon(e.message.clone()));
         }
-        Some(management_response::Response::Ping(_)) => {
-            // Ping response is handled by daemon; not used by CLI currently.
-            return Err(CtlError::Daemon(
-                "unexpected ping response from daemon".to_string(),
-            ));
-        }
         None => {
             return Err(CtlError::EmptyResponse);
         }

crates/cli/src/repl.rs

@@ -106,15 +106,6 @@ fn parse_command(line: &str) -> Option<management_request::Request> {
     let cmd = *parts.first()?;
 
     match cmd {
-        "ping" => {
-            let peer = parts
-                .get(1)
-                .map(std::string::ToString::to_string)
-                .unwrap_or_default();
-            Some(management_request::Request::Ping(
-                wallhack_wire::management::PingRequest { peer },
-            ))
-        }
         "info" => Some(management_request::Request::Info(
             wallhack_wire::management::InfoRequest {},
         )),
@@ -255,7 +246,6 @@ fn print_help() {
 
     let mut tw = TabWriter::new(std::io::stdout());
     let _ = writeln!(tw, "Commands:");
-    let _ = writeln!(tw, "  ping\tPing the daemon (peer ping not yet supported)");
     let _ = writeln!(tw, "  info\tShow daemon info");
     let _ = writeln!(tw, "  version\tShow version");
     let _ = writeln!(tw, "  stats\tShow traffic statistics");

crates/core/src/ipc.rs

@@ -18,7 +18,7 @@ use wallhack_transport::TransportError;
 use wallhack_wire::management::{
     self, ConnectResponse, DaemonMessage, DaemonNotification, ErrorCode, ErrorResponse,
     InfoResponse, ListenResponse, ManagementRequest, ManagementResponse, OkResponse, PeerConnected,
-    PeerDisconnected, PeersResponse, PingResponse, RoutesResponse, StatsResponse, daemon_message,
+    PeerDisconnected, PeersResponse, RoutesResponse, StatsResponse, daemon_message,
     daemon_notification, management_request, management_response,
 };
 
@@ -287,27 +287,6 @@ fn dispatch_request(request: &ManagementRequest, api: &dyn NodeApi) -> Managemen
     let request_id = request.request_id;
 
     let response = match &request.request {
-        Some(management_request::Request::Ping(req)) => {
-            if req.peer.is_empty() {
-                // Ping the daemon itself
-                let status = api.info();
-                management_response::Response::Ping(PingResponse {
-                    uptime_ms: status.uptime_ms,
-                    version: status.version,
-                    node_role: management::NodeRole::from(status.role).into(),
-                })
-            } else {
-                // Peer pinging is not yet implemented
-                return ManagementResponse {
-                    request_id,
-                    response: Some(management_response::Response::Error(ErrorResponse {
-                        code: ErrorCode::NotSupported.into(),
-                        message: "peer ping not yet implemented".to_string(),
-                    })),
-                };
-            }
-        }
-
         Some(management_request::Request::Info(_)) => {
             let s = api.info();
             management_response::Response::Info(InfoResponse {

crates/mcp/src/convert.rs

@@ -27,14 +27,6 @@ pub fn format_response(resp: &ManagementResponse) -> Result<String, String> {
             let _ = writeln!(out, "uptime: {}", format_uptime(s.uptime_ms));
             Ok(out)
         }
-        Some(management_response::Response::Ping(p)) => {
-            let role = p.node_role().to_string();
-            Ok(format!(
-                "pong — role: {role}, version: {}, uptime: {}",
-                p.version,
-                format_uptime(p.uptime_ms),
-            ))
-        }
         Some(management_response::Response::Stats(s)) => Ok(format!(
             "bytes in: {}\nbytes out: {}\npackets in: {}\npackets out: {}\n\
              connections: {}\nflows: {}\ndropped: {}",

crates/mcp/src/tools.rs

@@ -3,18 +3,12 @@
 use rmcp::{handler::server::wrapper::Parameters, schemars, tool};
 use wallhack_wire::management::{
     ConnectRequest, DisconnectRequest, HintLevel, HintSetAutoRequest, HintSetRequest, InfoRequest,
-    ListenRequest, NodeRole, PeerDisconnectRequest, PeersRequest, PingRequest, RouteAddRequest,
-    RouteDelRequest, RoutesRequest, ShutdownRequest, StatsRequest, management_request,
+    ListenRequest, NodeRole, PeerDisconnectRequest, PeersRequest, RouteAddRequest, RouteDelRequest,
+    RoutesRequest, ShutdownRequest, StatsRequest, management_request,
 };
 
 use crate::convert;
 
-#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
-pub struct PingParams {
-    /// Reserved — peer-specific ping is not yet supported. Leave empty.
-    pub peer: Option<String>,
-}
-
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
 pub struct AddRouteParams {
     /// CIDR range, e.g. "10.0.0.0/8"
@@ -75,19 +69,6 @@ impl WallhackServer {
         ipc_call(management_request::Request::Info(InfoRequest {})).await
     }
 
-    #[tool(
-        description = "Ping the daemon to check liveness. Returns role, version, and uptime. (Peer-specific ping is not yet supported.)"
-    )]
-    async fn ping(
-        &self,
-        Parameters(params): Parameters<PingParams>,
-    ) -> Result<String, rmcp::ErrorData> {
-        ipc_call(management_request::Request::Ping(PingRequest {
-            peer: params.peer.unwrap_or_default(),
-        }))
-        .await
-    }
-
     #[tool(
         description = "Get traffic statistics: bytes/packets in/out, active connections and flows"
     )]

crates/wire/proto/management.proto

@@ -10,7 +10,6 @@ package wallhack.management;
 message ManagementRequest {
   uint64 request_id = 1; // assigned by sender, echoed in response
   oneof request {
-    PingRequest ping = 2;
     InfoRequest info = 3;
     StatsRequest stats = 4;
     PeersRequest peers = 5;
@@ -38,7 +37,6 @@ message DaemonMessage {
 message ManagementResponse {
   uint64 request_id = 1; // echoes the request
   oneof response {
-    PingResponse ping = 2;
     InfoResponse info = 3;
     StatsResponse stats = 4;
     PeersResponse peers = 5;
@@ -64,10 +62,6 @@ message DaemonNotification {
 
 // ── Request messages ────────────────────────────────────────────────
 
-message PingRequest {
-  string peer = 1;  // prefix to match; empty = auto-select sole peer
-}
-
 message InfoRequest {}
 
 message StatsRequest {}
@@ -134,12 +128,6 @@ enum PeerStatus {
 }
 
 
-message PingResponse {
-  uint64 uptime_ms = 1;
-  string version = 2;
-  NodeRole node_role = 3;
-}
-
 message InfoResponse {
   NodeRole role = 1;
   bool connected = 2;