opencode-cloud 25.1.3

CLI for managing opencode as a persistent cloud service
Documentation 
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! occ host list - List all configured hosts

use anyhow::Result;
use clap::Args;
use comfy_table::{Cell, Color, Table};
use console::style;
use opencode_cloud_core::{get_hosts_path, load_hosts};

/// Arguments for host list command
#[derive(Args)]
pub struct HostListArgs {
    /// Filter by group
    #[arg(short, long)]
    pub group: Option<String>,

    /// Show only host names (for scripting)
    #[arg(long)]
    pub names_only: bool,
}

pub async fn cmd_host_list(args: &HostListArgs, quiet: bool, _verbose: u8) -> Result<()> {
    let hosts = load_hosts()?;

    if hosts.hosts.is_empty() {
        if !quiet && !args.names_only {
            println!("No hosts configured.");
            println!();
            println!(
                "  {} {}",
                style("Add one with:").dim(),
                style("occ host add <name> <hostname>").yellow()
            );
        }
        return Ok(());
    }

    // Filter by group if specified
    let filtered: Vec<_> = hosts
        .hosts
        .iter()
        .filter(|(_, config)| {
            args.group
                .as_ref()
                .map(|g| config.groups.contains(g))
                .unwrap_or(true)
        })
        .collect();

    if filtered.is_empty() {
        if !quiet && !args.names_only {
            println!(
                "No hosts found in group '{}'.",
                args.group.as_deref().unwrap_or("")
            );
        }
        return Ok(());
    }

    // Names only mode (for scripting)
    if args.names_only || quiet {
        for (name, _) in &filtered {
            println!("{name}");
        }
        return Ok(());
    }

    // Build table
    let mut table = Table::new();
    table.set_header(vec![
        "Name", "Hostname", "User", "Port", "Groups", "Default",
    ]);

    for (name, config) in filtered {
        let is_default = hosts.default_host.as_deref() == Some(name.as_str());

        let name_cell = if is_default {
            Cell::new(name).fg(Color::Cyan)
        } else {
            Cell::new(name)
        };

        let port_str = config
            .port
            .map(|p| p.to_string())
            .unwrap_or_else(|| "22".to_string());
        let groups_str = if config.groups.is_empty() {
            "-".to_string()
        } else {
            config.groups.join(", ")
        };
        let default_str = if is_default { "*" } else { "" };

        table.add_row(vec![
            name_cell,
            Cell::new(&config.hostname),
            Cell::new(&config.user),
            Cell::new(port_str),
            Cell::new(groups_str),
            Cell::new(default_str),
        ]);
    }

    println!("{table}");

    if let Some(default) = &hosts.default_host {
        println!();
        println!(
            "  {} {}",
            style("Default host:").dim(),
            style(default).cyan()
        );
    }

    // Show the file path
    if let Some(path) = get_hosts_path() {
        println!();
        println!(
            "  {} {}",
            style("Config file:").dim(),
            style(path.display()).dim()
        );
    }

    Ok(())
}