refactor: rename directive_{sink,source} to command_{sink,source}

Aligns channel names with the NodeCommand type they carry.

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

Author: maxholman

crates/core/src/control/handler.rs

@@ -159,10 +159,10 @@ pub struct Handler {
     config: HandlerConfig,
     /// Command channel to the mode task. Carries role changes, connect,
     /// listen, and disconnect commands.
-    directive_source: mpsc::Sender<NodeCommand>,
+    command_source: mpsc::Sender<NodeCommand>,
     /// Receiver side of the command channel. Extracted once by the daemon
     /// before wrapping Handler in `Arc<dyn NodeApi>`.
-    directive_sink: std::sync::Mutex<Option<mpsc::Receiver<NodeCommand>>>,
+    command_sink: std::sync::Mutex<Option<mpsc::Receiver<NodeCommand>>>,
     log_buffer: LogBuffer,
     metrics: SharedMetrics,
     peers: SharedRegistry,
@@ -188,11 +188,11 @@ impl Handler {
         log_buffer: Option<LogBuffer>,
     ) -> Self {
         let state = SharedNodeState::new(config.node_role);
-        let (directive_source, directive_sink) = mpsc::channel(8);
+        let (command_source, command_sink) = mpsc::channel(8);
         Self {
             config,
-            directive_source,
-            directive_sink: std::sync::Mutex::new(Some(directive_sink)),
+            command_source,
+            command_sink: std::sync::Mutex::new(Some(command_sink)),
             log_buffer: log_buffer.unwrap_or_default(),
             metrics,
             peers,
@@ -220,12 +220,12 @@ impl Handler {
     ///
     /// Panics if the mutex is poisoned or if called more than once.
     #[must_use]
-    pub fn directive_sink(&self) -> mpsc::Receiver<NodeCommand> {
-        self.directive_sink
+    pub fn command_sink(&self) -> mpsc::Receiver<NodeCommand> {
+        self.command_sink
             .lock()
-            .expect("directive_sink mutex poisoned")
+            .expect("command_sink mutex poisoned")
             .take()
-            .expect("directive_sink already taken")
+            .expect("command_sink already taken")
     }
 
     /// Handles a control request and returns a response.
@@ -479,7 +479,7 @@ impl crate::node_api::NodeApi for Handler {
 
     fn connect(&self, addr: &str) -> crate::node_api::Result<crate::node_api::ConnectInfo> {
         let (reply_sender, reply_receiver) = reply_channel();
-        self.directive_source
+        self.command_source
             .try_send(NodeCommand::Connect {
                 addr: addr.to_string(),
                 reply: reply_sender,
@@ -499,7 +499,7 @@ impl crate::node_api::NodeApi for Handler {
         addr: std::net::SocketAddr,
     ) -> crate::node_api::Result<crate::node_api::ListenInfo> {
         let (reply_sender, reply_receiver) = reply_channel();
-        self.directive_source
+        self.command_source
             .try_send(NodeCommand::Listen {
                 addr,
                 reply: reply_sender,
@@ -516,7 +516,7 @@ impl crate::node_api::NodeApi for Handler {
 
     fn disconnect(&self) -> crate::node_api::Result<()> {
         let (reply_sender, reply_receiver) = reply_channel();
-        self.directive_source
+        self.command_source
             .try_send(NodeCommand::Disconnect {
                 reply: reply_sender,
             })
@@ -600,14 +600,14 @@ impl crate::node_api::NodeApi for Handler {
 
     fn hint_set(&self, hint: RoleHint) -> crate::node_api::Result<()> {
         let _ = self
-            .directive_source
+            .command_source
             .try_send(NodeCommand::Role { hint: Some(hint) });
         Ok(())
     }
 
     fn hint_set_auto(&self) -> crate::node_api::Result<()> {
         let _ = self
-            .directive_source
+            .command_source
             .try_send(NodeCommand::Role { hint: None });
         Ok(())
     }

crates/daemon/src/lib.rs

@@ -164,7 +164,7 @@ pub fn start_node(
         log_buffer,
     );
     let node_state = handler.node_state();
-    let directive_sink = handler.directive_sink();
+    let command_sink = handler.command_sink();
     let node_api: Arc<dyn NodeApi> = Arc::new(handler);
 
     let (shutdown_tx, _shutdown_rx) = watch::channel(());
@@ -178,7 +178,7 @@ pub fn start_node(
         route_updates: route_update_rx,
         route_updates_tx: route_update_tx,
         node_state,
-        directive_sink,
+        command_sink,
     };
     let task = tokio::spawn(async move { mode::run(&config, resources).await.map_err(Into::into) });
 

crates/daemon/src/mode/auto.rs

@@ -73,7 +73,7 @@ impl AutoContext {
 /// # Errors
 ///
 /// Returns error if the connection setup fails non-retryably.
-// REASON: threading metrics, peers, routes, route_updates_tx, directive_sink, node_state through mode dispatch
+// REASON: threading metrics, peers, routes, route_updates_tx, command_sink, node_state through mode dispatch
 #[allow(clippy::too_many_arguments)]
 pub(crate) async fn run(
     global: &GlobalConfig,
@@ -82,7 +82,7 @@ pub(crate) async fn run(
     peers: Arc<Registry>,
     routes: SharedRouteTable,
     route_updates_tx: tokio::sync::broadcast::Sender<RouteUpdate>,
-    directive_sink: tokio::sync::mpsc::Receiver<wallhack_core::control::handler::NodeCommand>,
+    command_sink: tokio::sync::mpsc::Receiver<wallhack_core::control::handler::NodeCommand>,
     node_state: SharedNodeState,
 ) -> Result<(), NodeError> {
     let tun_capable = detect_tun_capable();
@@ -144,13 +144,13 @@ pub(crate) async fn run(
         }
         (Some(connect), None) => {
             // Connector-only path: run the connector as a task and poll
-            // directive_sink for dynamic listen/disconnect commands.
-            run_auto_connector_with_commands(Arc::clone(&ctx), connect, directive_sink).await
+            // command_sink for dynamic listen/disconnect commands.
+            run_auto_connector_with_commands(Arc::clone(&ctx), connect, command_sink).await
         }
         (None, Some(listen)) => {
             // Listener-only path: run the listener as a task and poll
-            // directive_sink for dynamic connect/disconnect commands.
-            run_auto_listener_with_commands(Arc::clone(&ctx), listen, directive_sink).await
+            // command_sink for dynamic connect/disconnect commands.
+            run_auto_listener_with_commands(Arc::clone(&ctx), listen, command_sink).await
         }
         (None, None) => Err(NodeError::Config(
             "auto mode requires a connect or listen address".into(),
@@ -160,15 +160,15 @@ pub(crate) async fn run(
 
 /// Connector-only path with command integration.
 ///
-/// Spawns the connector as a task, then polls `directive_sink` for dynamic
+/// Spawns the connector as a task, then polls `command_sink` for dynamic
 /// commands. `Listen` commands start a listener task alongside the
 /// connector. `Disconnect` commands abort the active connector.
 // REASON: too_many_lines: symmetric listen/connect/disconnect command arms with distinct spawn logic
 #[allow(clippy::too_many_lines)]
 async fn run_auto_connector_with_commands(
     ctx: Arc<AutoContext>,
     connect: &AddressSpec,
-    mut directive_sink: tokio::sync::mpsc::Receiver<wallhack_core::control::handler::NodeCommand>,
+    mut command_sink: tokio::sync::mpsc::Receiver<wallhack_core::control::handler::NodeCommand>,
 ) -> Result<(), NodeError> {
     use wallhack_core::{control::handler::NodeCommand, node_api::NodeApiError};
 
@@ -203,7 +203,7 @@ async fn run_auto_connector_with_commands(
                 }
                 return result?;
             }
-            Some(cmd) = directive_sink.recv() => {
+            Some(cmd) = command_sink.recv() => {
                 match cmd {
                     NodeCommand::Role { .. } => {
                         // Role changes not yet handled in connector path.
@@ -248,15 +248,15 @@ async fn run_auto_connector_with_commands(
 
 /// Listener-only path with command integration.
 ///
-/// Spawns the listener as a task, then polls `directive_sink` for dynamic
+/// Spawns the listener as a task, then polls `command_sink` for dynamic
 /// commands. `Connect` commands spawn a connector task alongside the
 /// listener. `Disconnect` commands abort the active connector.
 // REASON: too_many_lines: symmetric connect/listen/disconnect command arms with distinct spawn logic
 #[allow(clippy::too_many_lines)]
 async fn run_auto_listener_with_commands(
     ctx: Arc<AutoContext>,
     listen: &AddressSpec,
-    mut directive_sink: tokio::sync::mpsc::Receiver<wallhack_core::control::handler::NodeCommand>,
+    mut command_sink: tokio::sync::mpsc::Receiver<wallhack_core::control::handler::NodeCommand>,
 ) -> Result<(), NodeError> {
     use wallhack_core::{control::handler::NodeCommand, node_api::NodeApiError};
 
@@ -291,7 +291,7 @@ async fn run_auto_listener_with_commands(
                 }
                 return result?;
             }
-            Some(cmd) = directive_sink.recv() => {
+            Some(cmd) = command_sink.recv() => {
                 match cmd {
                     NodeCommand::Role { .. } => {
                         // Role changes not yet handled in listener path.

crates/daemon/src/mode/mod.rs

@@ -32,7 +32,7 @@ pub(crate) struct NodeResources {
     pub node_state: SharedNodeState,
     /// Receiver for commands (role, connect, listen, disconnect) from the
     /// control API. Only auto mode consumes this.
-    pub directive_sink: tokio::sync::mpsc::Receiver<wallhack_core::control::handler::NodeCommand>,
+    pub command_sink: tokio::sync::mpsc::Receiver<wallhack_core::control::handler::NodeCommand>,
 }
 
 /// Derive a peer's role from its advertised capabilities.
@@ -163,7 +163,7 @@ pub(crate) async fn run(config: &DaemonConfig, resources: NodeResources) -> Resu
                 resources.peers,
                 resources.routes,
                 resources.route_updates_tx,
-                resources.directive_sink,
+                resources.command_sink,
                 resources.node_state,
             )
             .await