Skip to main content

hyprstream_core/cli/
remote_handlers.rs

1//! Handlers for remote management commands
2// CLI handlers intentionally print to stdout/stderr for user interaction
3#![allow(clippy::print_stdout, clippy::print_stderr)]
4
5use anyhow::Result;
6use hyprstream_rpc_std::registry_client::RegistryClient;
7use hyprstream_rpc_std::registry_client::{
8    AddRemoteRequest, RemoveRemoteRequest, RenameRemoteRequest, SetRemoteUrlRequest,
9};
10use tracing::info;
11
12/// Handle remote add command - add a new remote to a model
13pub async fn handle_remote_add(
14    registry: &RegistryClient,
15    model: &str,
16    name: &str,
17    url: &str,
18) -> Result<()> {
19    info!("Adding remote '{}' to model {}", name, model);
20
21    let tracked = registry
22        .get_by_name(model)
23        .await
24        .map_err(|e| anyhow::anyhow!("Failed to get repository client: {}", e))?;
25    let repo_client = registry.repo(&tracked.id);
26
27    repo_client
28        .add_remote(&AddRemoteRequest {
29            name: name.to_owned(),
30            url: url.to_owned(),
31        })
32        .await
33        .map_err(|e| anyhow::anyhow!("Failed to add remote '{}': {}", name, e))?;
34
35    println!("Added remote '{name}': {url}");
36    Ok(())
37}
38
39/// Handle remote list command - list all remotes for a model
40pub async fn handle_remote_list(
41    registry: &RegistryClient,
42    model: &str,
43    verbose: bool,
44) -> Result<()> {
45    info!("Listing remotes for model {}", model);
46
47    let tracked = registry
48        .get_by_name(model)
49        .await
50        .map_err(|e| anyhow::anyhow!("Failed to get repository client: {}", e))?;
51    let repo_client = registry.repo(&tracked.id);
52
53    let remotes = repo_client
54        .list_remotes()
55        .await
56        .map_err(|e| anyhow::anyhow!("Failed to list remotes: {}", e))?;
57
58    if remotes.is_empty() {
59        println!("No remotes configured for {model}");
60        println!("\nAdd a remote with:");
61        println!("  hyprstream remote add {model} <name> <url>");
62        return Ok(());
63    }
64
65    println!("Remotes for {model}:\n");
66    for remote in remotes {
67        if verbose {
68            println!("  {} (fetch): {}", remote.name, remote.url);
69            if !remote.push_url.is_empty() {
70                println!("  {} (push):  {}", remote.name, remote.push_url);
71            }
72        } else {
73            println!("  {}\t{}", remote.name, remote.url);
74        }
75    }
76
77    Ok(())
78}
79
80/// Handle remote remove command - remove a remote from a model
81pub async fn handle_remote_remove(
82    registry: &RegistryClient,
83    model: &str,
84    name: &str,
85) -> Result<()> {
86    info!("Removing remote '{}' from model {}", name, model);
87
88    let tracked = registry
89        .get_by_name(model)
90        .await
91        .map_err(|e| anyhow::anyhow!("Failed to get repository client: {}", e))?;
92    let repo_client = registry.repo(&tracked.id);
93
94    repo_client
95        .remove_remote(&RemoveRemoteRequest {
96            name: name.to_owned(),
97        })
98        .await
99        .map_err(|e| anyhow::anyhow!("Failed to remove remote '{}': {}", name, e))?;
100
101    println!("Removed remote '{name}'");
102    Ok(())
103}
104
105/// Handle remote set-url command - change a remote's URL
106pub async fn handle_remote_set_url(
107    registry: &RegistryClient,
108    model: &str,
109    name: &str,
110    url: &str,
111) -> Result<()> {
112    info!("Setting URL for remote '{}' in model {}", name, model);
113
114    let tracked = registry
115        .get_by_name(model)
116        .await
117        .map_err(|e| anyhow::anyhow!("Failed to get repository client: {}", e))?;
118    let repo_client = registry.repo(&tracked.id);
119
120    repo_client
121        .set_remote_url(&SetRemoteUrlRequest {
122            name: name.to_owned(),
123            url: url.to_owned(),
124        })
125        .await
126        .map_err(|e| anyhow::anyhow!("Failed to set URL for remote '{}': {}", name, e))?;
127
128    println!("Updated remote '{name}': {url}");
129    Ok(())
130}
131
132/// Handle remote rename command - rename a remote
133pub async fn handle_remote_rename(
134    registry: &RegistryClient,
135    model: &str,
136    old_name: &str,
137    new_name: &str,
138) -> Result<()> {
139    info!(
140        "Renaming remote '{}' to '{}' in model {}",
141        old_name, new_name, model
142    );
143
144    let tracked = registry
145        .get_by_name(model)
146        .await
147        .map_err(|e| anyhow::anyhow!("Failed to get repository client: {}", e))?;
148    let repo_client = registry.repo(&tracked.id);
149
150    repo_client
151        .rename_remote(&RenameRemoteRequest {
152            old_name: old_name.to_owned(),
153            new_name: new_name.to_owned(),
154        })
155        .await
156        .map_err(|e| {
157            anyhow::anyhow!(
158                "Failed to rename remote '{}' to '{}': {}",
159                old_name,
160                new_name,
161                e
162            )
163        })?;
164
165    println!("Renamed remote '{old_name}' to '{new_name}'");
166    Ok(())
167}