refactor(#2352): re-home host-control wire types into hive-host-sock crate

hive-c0re/src/bin/hivectl.rs

@@ -277,7 +277,7 @@ enum OpenTarget {
 /// additively.
 // One bool per selectable container class, each mapping 1:1 to a clap flag;
 // orthogonal toggles, not a state machine — hence the bools allow (mirrors
-// `hive_sh4re::LifecycleScope`).
+// `hive_host_sock::LifecycleScope`).
 #[allow(clippy::struct_excessive_bools)]
 #[derive(Args)]
 struct ScopeArgs {
@@ -302,8 +302,8 @@ struct ScopeArgs {
 }
 
 impl ScopeArgs {
-    fn to_scope(&self) -> hive_sh4re::LifecycleScope {
-        hive_sh4re::LifecycleScope {
+    fn to_scope(&self) -> hive_host_sock::LifecycleScope {
+        hive_host_sock::LifecycleScope {
             agents: self.agents,
             agent_names: self.agent.clone(),
             ci: self.ci,
@@ -794,8 +794,8 @@ async fn query_hive_domain(socket: &Path) -> Option<String> {
 
 /// Best-effort query for this hive's domain + browser-facing web URLs
 /// (`HostRequest::Urls`). `None` when the daemon is unreachable.
-async fn query_hive_urls(socket: &Path) -> Option<hive_sh4re::HiveUrls> {
-    hive_c0re::client::request(socket, hive_sh4re::HostRequest::Urls)
+async fn query_hive_urls(socket: &Path) -> Option<hive_host_sock::HiveUrls> {
+    hive_c0re::client::request(socket, hive_host_sock::HostRequest::Urls)
         .await
         .ok()
         .and_then(|r| r.urls)
@@ -1514,7 +1514,7 @@ fn gateway_list_users(file: &Path) -> Result<()> {
 async fn agents_restart(socket: &Path, name: &str, no_wait: bool) -> Result<()> {
     let resp = hive_c0re::client::request(
         socket,
-        hive_sh4re::HostRequest::Restart {
+        hive_host_sock::HostRequest::Restart {
             name: name.to_owned(),
         },
     )
@@ -1536,7 +1536,7 @@ async fn agents_restart(socket: &Path, name: &str, no_wait: bool) -> Result<()>
 /// or the raw JSON rows with `--json`. Reuses the dashboard's
 /// `ContainerView` aggregation, so the CLI and the web UI never drift.
 async fn agents_list(socket: &Path, json: bool) -> Result<()> {
-    let resp = hive_c0re::client::request(socket, hive_sh4re::HostRequest::AgentStatus)
+    let resp = hive_c0re::client::request(socket, hive_host_sock::HostRequest::AgentStatus)
         .await
         .with_context(|| format!("connect to daemon socket {}", socket.display()))?;
     if !resp.ok {
@@ -1608,7 +1608,7 @@ async fn agents_list(socket: &Path, json: bool) -> Result<()> {
 }
 
 async fn agents_restart_all(socket: &Path, no_wait: bool) -> Result<()> {
-    let resp = hive_c0re::client::request(socket, hive_sh4re::HostRequest::RestartAll)
+    let resp = hive_c0re::client::request(socket, hive_host_sock::HostRequest::RestartAll)
         .await
         .with_context(|| format!("connect to daemon socket {}", socket.display()))?;
     let agents = resp.agents.as_deref().unwrap_or(&[]);
@@ -1630,14 +1630,16 @@ async fn agents_restart_all(socket: &Path, no_wait: bool) -> Result<()> {
 
 async fn stop(
     socket: &Path,
-    scope: hive_sh4re::LifecycleScope,
+    scope: hive_host_sock::LifecycleScope,
     graceful: bool,
     no_wait: bool,
 ) -> Result<()> {
-    let resp =
-        hive_c0re::client::request(socket, hive_sh4re::HostRequest::Stop { scope, graceful })
-            .await
-            .with_context(|| format!("connect to daemon socket {}", socket.display()))?;
+    let resp = hive_c0re::client::request(
+        socket,
+        hive_host_sock::HostRequest::Stop { scope, graceful },
+    )
+    .await
+    .with_context(|| format!("connect to daemon socket {}", socket.display()))?;
     // Render first, but even when an infra failure makes it bail,
     // watch the already-queued agent DAGs before surfacing the error —
     // they run regardless.
@@ -1646,8 +1648,8 @@ async fn stop(
     rendered
 }
 
-async fn start(socket: &Path, scope: hive_sh4re::LifecycleScope, no_wait: bool) -> Result<()> {
-    let resp = hive_c0re::client::request(socket, hive_sh4re::HostRequest::Start { scope })
+async fn start(socket: &Path, scope: hive_host_sock::LifecycleScope, no_wait: bool) -> Result<()> {
+    let resp = hive_c0re::client::request(socket, hive_host_sock::HostRequest::Start { scope })
         .await
         .with_context(|| format!("connect to daemon socket {}", socket.display()))?;
     let rendered = render_lifecycle(&resp, "start queued");
@@ -1664,15 +1666,19 @@ async fn start(socket: &Path, scope: hive_sh4re::LifecycleScope, no_wait: bool)
 /// No `--no-wait` here on purpose: the stop DAGs must complete before
 /// the start submits, otherwise the start's `wanted = Up` write would
 /// land before the queued stops execute and turn them into noops.
-async fn restart(socket: &Path, scope: hive_sh4re::LifecycleScope, graceful: bool) -> Result<()> {
+async fn restart(
+    socket: &Path,
+    scope: hive_host_sock::LifecycleScope,
+    graceful: bool,
+) -> Result<()> {
     stop(socket, scope.clone(), graceful, false).await?;
     start(socket, scope, false).await
 }
 
-/// A [`LifecycleScope`](hive_sh4re::LifecycleScope) targeting exactly one
+/// A [`LifecycleScope`](hive_host_sock::LifecycleScope) targeting exactly one
 /// agent by name (no infra containers, no all-agents flag).
-fn single_agent_scope(name: &str) -> hive_sh4re::LifecycleScope {
-    hive_sh4re::LifecycleScope {
+fn single_agent_scope(name: &str) -> hive_host_sock::LifecycleScope {
+    hive_host_sock::LifecycleScope {
         agents: false,
         agent_names: vec![name.to_owned()],
         ci: false,
@@ -1702,7 +1708,7 @@ async fn subvol_upgrade(socket: &Path, name: &str, yes: bool) -> Result<()> {
     println!("stopping {name} (releasing its state bind-mount)…");
     let stop_resp = hive_c0re::client::request(
         socket,
-        hive_sh4re::HostRequest::Stop {
+        hive_host_sock::HostRequest::Stop {
             scope: single_agent_scope(name),
             graceful: false,
         },
@@ -1732,7 +1738,7 @@ async fn subvol_upgrade(socket: &Path, name: &str, yes: bool) -> Result<()> {
     println!("starting {name}…");
     let start_result = hive_c0re::client::request(
         socket,
-        hive_sh4re::HostRequest::Start {
+        hive_host_sock::HostRequest::Start {
             scope: single_agent_scope(name),
         },
     )
@@ -1776,7 +1782,7 @@ async fn subvol_upgrade(socket: &Path, name: &str, yes: bool) -> Result<()> {
 /// touched container, then surface any aggregated per-target failure as a
 /// non-zero exit. `verb` is the past-tense word printed per item
 /// (`stopped` / `started`).
-fn render_lifecycle(resp: &hive_sh4re::HostResponse, verb: &str) -> Result<()> {
+fn render_lifecycle(resp: &hive_host_sock::HostResponse, verb: &str) -> Result<()> {
     let items = resp.agents.as_deref().unwrap_or(&[]);
     if items.is_empty() {
         println!("{verb}: nothing matched the requested scope");

hive-c0re/src/bin/hivectl/dag_progress.rs

@@ -42,9 +42,10 @@ async fn wait_for_dags_plain(socket: &Path, ids: Vec<u64>) -> Result<()> {
     let mut failed: Vec<String> = Vec::new();
     while !pending.is_empty() {
         for id in pending.clone() {
-            let resp = hive_c0re::client::request(socket, hive_sh4re::HostRequest::QueueDag { id })
-                .await
-                .with_context(|| format!("connect to daemon socket {}", socket.display()))?;
+            let resp =
+                hive_c0re::client::request(socket, hive_host_sock::HostRequest::QueueDag { id })
+                    .await
+                    .with_context(|| format!("connect to daemon socket {}", socket.display()))?;
             let dags = resp.dags.unwrap_or_default();
             if dags.is_empty() {
                 // Evicted from the queue's history tail — it finished a
@@ -115,9 +116,10 @@ async fn wait_for_dags_animated(socket: &Path, ids: Vec<u64>) -> Result<()> {
     while !pending.is_empty() {
         let now = now_unix();
         for id in pending.clone() {
-            let resp = hive_c0re::client::request(socket, hive_sh4re::HostRequest::QueueDag { id })
-                .await
-                .with_context(|| format!("connect to daemon socket {}", socket.display()))?;
+            let resp =
+                hive_c0re::client::request(socket, hive_host_sock::HostRequest::QueueDag { id })
+                    .await
+                    .with_context(|| format!("connect to daemon socket {}", socket.display()))?;
             let dags = resp.dags.unwrap_or_default();
             if dags.is_empty() {
                 mp.println(format!("job #{id}: gone from queue history"))

hive-c0re/src/client.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use anyhow::{Context, Result, bail};
-use hive_sh4re::{HostRequest, HostResponse};
+use hive_host_sock::{HostRequest, HostResponse};
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::net::UnixStream;
 

hive-c0re/src/main.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 
 use anyhow::{Context as _, Result, bail};
 use clap::{Parser, Subcommand};
-use hive_sh4re::{HostRequest, HostResponse};
+use hive_host_sock::{HostRequest, HostResponse};
 
 // Every module hangs off the `hive_c0re` library (see `src/lib.rs`).
 // The daemon and the `hivectl` sibling binary share the same module

hive-c0re/src/server.rs

@@ -2,8 +2,8 @@ use std::path::Path;
 use std::sync::Arc;
 
 use anyhow::{Context, Result};
+use hive_host_sock::{HostRequest, HostResponse, LifecycleScope};
 use hive_sh4re::priv_proto::{InfraAction, InfraContainer};
-use hive_sh4re::{HostRequest, HostResponse, LifecycleScope};
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::net::{UnixListener, UnixStream};
 
@@ -480,12 +480,12 @@ fn is_broad_scope(scope: &LifecycleScope) -> bool {
 /// gateway, matrix GUI off), so the CLI can hint precisely instead of
 /// opening a dead link. Scheme matches the existing `HIVE_FORGE_PUBLIC_URL`
 /// convention (gateway terminates TLS, so https).
-fn hive_urls() -> hive_sh4re::HiveUrls {
+fn hive_urls() -> hive_host_sock::HiveUrls {
     // Treat an empty env value as unset everywhere — an empty domain would
     // otherwise render `swarm.peers."" = …` (invalid nix) and `https:///`.
     let env = |k: &str| std::env::var(k).ok().filter(|v| !v.is_empty());
     let domain = env("HYPERHIVE_HIVE_DOMAIN");
-    hive_sh4re::HiveUrls {
+    hive_host_sock::HiveUrls {
         home: domain.as_ref().map(|d| format!("https://{d}/")),
         forge: env("HIVE_FORGE_PUBLIC_URL"),
         matrix: env("HIVE_MATRIX_PUBLIC_URL"),