openclaw-cli 0.1.0

Command-line interface for OpenClaw
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Gateway command - start and manage the gateway server.

use crate::ui;
use anyhow::Result;
use openclaw_core::config::BindMode;

/// Gateway command arguments.
#[derive(Debug, Clone)]
pub struct GatewayArgs {
    /// Subcommand.
    pub action: GatewayAction,
}

/// Gateway actions.
#[derive(Debug, Clone)]
pub enum GatewayAction {
    Run {
        /// Port to listen on.
        port: Option<u16>,
        /// Bind address.
        bind: Option<String>,
        /// Force start even if another instance is running.
        force: bool,
    },
    Status,
}

impl Default for GatewayArgs {
    fn default() -> Self {
        Self {
            action: GatewayAction::Status,
        }
    }
}

/// Run the gateway command.
pub async fn run_gateway(args: GatewayArgs) -> Result<()> {
    match args.action {
        GatewayAction::Run { port, bind, force } => run_gateway_server(port, bind, force).await,
        GatewayAction::Status => gateway_status().await,
    }
}

/// Start the gateway server.
async fn run_gateway_server(port: Option<u16>, bind: Option<String>, force: bool) -> Result<()> {
    // Load configuration
    let config = if let Ok(c) = openclaw_core::Config::load_default() {
        c
    } else {
        ui::warning("No configuration found, using defaults");
        ui::info("Run 'openclaw onboard' for full setup");
        openclaw_core::Config::default()
    };

    // Determine port and bind address
    let server_port = port.unwrap_or(config.gateway.port);
    let bind_address = bind.unwrap_or_else(|| match &config.gateway.mode {
        BindMode::Local => "127.0.0.1".to_string(),
        BindMode::Public => "0.0.0.0".to_string(),
        BindMode::Custom(addr) => addr.clone(),
    });

    // Check if port is already in use
    if !force {
        if let Ok(listener) = std::net::TcpListener::bind(format!("{bind_address}:{server_port}")) {
            drop(listener);
        } else {
            ui::error(&format!(
                "Port {server_port} is already in use. Use --force to override."
            ));
            return Ok(());
        }
    }

    ui::header("Starting OpenClaw Gateway");
    ui::kv("Address", &format!("{bind_address}:{server_port}"));
    let mode_str = match &config.gateway.mode {
        BindMode::Local => "local",
        BindMode::Public => "public",
        BindMode::Custom(_) => "custom",
    };
    ui::kv("Mode", mode_str);
    println!();

    let gateway_config = openclaw_gateway::GatewayConfig {
        port: server_port,
        bind_address,
        cors: true,
        ..Default::default()
    };

    ui::info("Gateway is starting...");
    ui::info("Press Ctrl+C to stop");
    println!();

    // Start the gateway
    openclaw_gateway::start(gateway_config).await?;

    Ok(())
}

/// Check gateway status.
async fn gateway_status() -> Result<()> {
    ui::header("Gateway Status");

    // Get configured port
    let port = match openclaw_core::Config::load_default() {
        Ok(c) => c.gateway.port,
        Err(_) => 18789,
    };

    // Try to connect
    if let Ok(_) = tokio::net::TcpStream::connect(format!("127.0.0.1:{port}")).await {
        ui::success(&format!("Gateway is running on port {port}"));

        // Try health check
        let client = reqwest::Client::new();
        match client
            .get(format!("http://127.0.0.1:{port}/health"))
            .timeout(std::time::Duration::from_secs(2))
            .send()
            .await
        {
            Ok(resp) => {
                if resp.status().is_success() {
                    if let Ok(body) = resp.json::<serde_json::Value>().await {
                        if let Some(version) = body.get("version").and_then(|v| v.as_str()) {
                            ui::kv("Version", version);
                        }
                        if let Some(status) = body.get("status").and_then(|v| v.as_str()) {
                            ui::kv("Status", status);
                        }
                    }
                }
            }
            Err(_) => {
                ui::warning("Health check failed");
            }
        }
    } else {
        ui::warning(&format!("Gateway is not running on port {port}"));
        ui::info("Start with: openclaw gateway run");
    }

    Ok(())
}