void-cli 0.0.4

CLI for void — anonymous encrypted source control
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//! Unified backend selection for all network commands.
//!
//! Provides a single `resolve_backend()` function that all network commands
//! (push, pull, clone, fork, pull-request) use to select and initialize
//! the transport backend.

use std::path::Path;
use std::sync::Arc;
use std::time::Duration;

use void_core::store::{IpfsBackend, IpfsStore, RemoteStore};

use crate::output::CliError;

/// Resolved backend — either a daemon-backed remote store or an IpfsStore.
pub struct ResolvedBackend {
    /// The IpfsBackend enum (used by core options structs that still need it).
    pub ipfs_backend: IpfsBackend,
    /// The remote store (daemon or IpfsStore). Use this for operations.
    pub remote: Arc<dyn RemoteStore>,
    /// Tokio runtime kept alive for daemon mode (dropped = daemon stops).
    pub _runtime: Option<tokio::runtime::Runtime>,
}

/// Resolve the network backend from CLI arguments.
///
/// All network commands should call this instead of parsing backends locally.
///
/// - `"daemon"` (default): starts or connects to an embedded void daemon.
///   No external dependencies. Uses bitswap + DHT.
/// - `"kubo"`: connects to a local Kubo node via HTTP API.
/// - `"gateway"`: fetches from a public IPFS gateway (read-only).
pub fn resolve_backend(
    backend_type: Option<&str>,
    kubo_url: &str,
    gateway_url: &Option<String>,
    void_dir: Option<&Path>,
    timeout: Duration,
) -> Result<ResolvedBackend, CliError> {
    match backend_type.unwrap_or("daemon") {
        "daemon" => {
            let dir = void_dir.ok_or_else(|| {
                CliError::internal("daemon backend requires a void directory")
            })?;
            let (remote, rt) = crate::daemon::start_daemon(dir)
                .map_err(|e| CliError::internal(e))?;
            Ok(ResolvedBackend {
                ipfs_backend: IpfsBackend::Kubo { api: "daemon".to_string() },
                remote,
                _runtime: Some(rt),
            })
        }
        "kubo" => {
            let backend = IpfsBackend::Kubo { api: kubo_url.to_string() };
            let store = Arc::new(IpfsStore::new(backend.clone(), timeout));
            Ok(ResolvedBackend {
                ipfs_backend: backend,
                remote: store,
                _runtime: None,
            })
        }
        "gateway" => {
            let url = gateway_url.as_ref().ok_or_else(|| {
                CliError::invalid_args("--gateway <url> is required when backend is gateway")
            })?;
            let backend = IpfsBackend::Gateway { base: url.clone() };
            let store = Arc::new(IpfsStore::new(backend.clone(), timeout));
            Ok(ResolvedBackend {
                ipfs_backend: backend,
                remote: store,
                _runtime: None,
            })
        }
        other => Err(CliError::invalid_args(format!(
            "invalid backend '{other}': expected daemon, kubo, or gateway"
        ))),
    }
}