proxctl 0.2.2__tar.gz → 0.2.4__tar.gz

{proxctl-0.2.2 → proxctl-0.2.4}/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 
 
 
+
+
+## [0.2.4](https://github.com/rvben/proxctl/compare/v0.2.3...v0.2.4) - 2026-04-03
+
+### Added
+
+- **init**: add API docs URL, colored output, and next steps to config init ([53e3ca9](https://github.com/rvben/proxctl/commit/53e3ca91dfd0f448205afb8da4902ace2c98880f))
+
+## [0.2.3](https://github.com/rvben/proxctl/compare/v0.2.2...v0.2.3) - 2026-04-03
+
 ## [0.2.2](https://github.com/rvben/proxctl/compare/v0.2.1...v0.2.2) - 2026-04-03
 
 ### Added

{proxctl-0.2.2 → proxctl-0.2.4}/Cargo.lock

@@ -955,7 +955,7 @@ dependencies = [
 
 [[package]]
 name = "proxctl"
-version = "0.2.2"
+version = "0.2.4"
 dependencies = [
  "clap",
  "clap_complete",

{proxctl-0.2.2 → proxctl-0.2.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "proxctl"
-version = "0.2.2"
+version = "0.2.4"
 edition = "2024"
 rust-version = "1.90"
 description = "CLI for Proxmox VE"

{proxctl-0.2.2 → proxctl-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proxctl
-Version: 0.2.2
+Version: 0.2.4
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: System Administrators

{proxctl-0.2.2 → proxctl-0.2.4}/src/commands/firewall.rs

@@ -1,4 +1,4 @@
-use clap::Subcommand;
+use clap::{Args, Subcommand};
 use owo_colors::OwoColorize;
 use serde_json::json;
 
@@ -6,6 +6,40 @@ use crate::api::Error;
 use crate::api::client::ProxmoxClient;
 use crate::output::{OutputConfig, use_color};
 
+#[derive(Args)]
+pub struct FirewallRuleArgs {
+    /// Rule action (ACCEPT, DROP, REJECT)
+    #[arg(long)]
+    pub action: String,
+    /// Rule type (in, out, group)
+    #[arg(long, rename_all = "kebab-case")]
+    pub r#type: String,
+    /// Enable the rule
+    #[arg(long)]
+    pub enable: Option<bool>,
+    /// Network interface (e.g. vmbr0, vmbr0v30)
+    #[arg(long)]
+    pub iface: Option<String>,
+    /// Source address
+    #[arg(long)]
+    pub source: Option<String>,
+    /// Destination address
+    #[arg(long)]
+    pub dest: Option<String>,
+    /// Destination port
+    #[arg(long)]
+    pub dport: Option<String>,
+    /// Protocol
+    #[arg(long)]
+    pub proto: Option<String>,
+    /// Macro (e.g. SSH, HTTP, HTTPS)
+    #[arg(long, rename_all = "kebab-case")]
+    pub r#macro: Option<String>,
+    /// Comment
+    #[arg(long)]
+    pub comment: Option<String>,
+}
+
 fn require_node<'a>(node: Option<&'a str>, global_node: Option<&'a str>) -> Result<&'a str, Error> {
     node.or(global_node)
         .ok_or_else(|| Error::Config("node name required (use --node or PROXMOX_NODE)".to_string()))
@@ -33,36 +67,8 @@ pub enum ClusterFirewallCommand {
     Rules,
     /// Add a cluster firewall rule
     Add {
-        /// Rule action (ACCEPT, DROP, REJECT)
-        #[arg(long)]
-        action: String,
-        /// Rule type (in, out, group)
-        #[arg(long, rename_all = "kebab-case")]
-        r#type: String,
-        /// Enable the rule
-        #[arg(long)]
-        enable: Option<bool>,
-        /// Network interface (e.g. vmbr0, vmbr0v30)
-        #[arg(long)]
-        iface: Option<String>,
-        /// Source address
-        #[arg(long)]
-        source: Option<String>,
-        /// Destination address
-        #[arg(long)]
-        dest: Option<String>,
-        /// Destination port
-        #[arg(long)]
-        dport: Option<String>,
-        /// Protocol
-        #[arg(long)]
-        proto: Option<String>,
-        /// Macro (e.g. SSH, HTTP, HTTPS)
-        #[arg(long, rename_all = "kebab-case")]
-        r#macro: Option<String>,
-        /// Comment
-        #[arg(long)]
-        comment: Option<String>,
+        #[command(flatten)]
+        rule: Box<FirewallRuleArgs>,
     },
     /// Delete a cluster firewall rule
     Delete {
@@ -88,36 +94,8 @@ pub enum NodeFirewallCommand {
         /// Node name
         #[arg(long)]
         node: Option<String>,
-        /// Rule action (ACCEPT, DROP, REJECT)
-        #[arg(long)]
-        action: String,
-        /// Rule type (in, out, group)
-        #[arg(long, rename_all = "kebab-case")]
-        r#type: String,
-        /// Enable the rule
-        #[arg(long)]
-        enable: Option<bool>,
-        /// Network interface (e.g. vmbr0, vmbr0v30)
-        #[arg(long)]
-        iface: Option<String>,
-        /// Source address
-        #[arg(long)]
-        source: Option<String>,
-        /// Destination address
-        #[arg(long)]
-        dest: Option<String>,
-        /// Destination port
-        #[arg(long)]
-        dport: Option<String>,
-        /// Protocol
-        #[arg(long)]
-        proto: Option<String>,
-        /// Macro (e.g. SSH, HTTP, HTTPS)
-        #[arg(long, rename_all = "kebab-case")]
-        r#macro: Option<String>,
-        /// Comment
-        #[arg(long)]
-        comment: Option<String>,
+        #[command(flatten)]
+        rule: Box<FirewallRuleArgs>,
     },
     /// Delete a node firewall rule
     Delete {
@@ -214,33 +192,19 @@ pub async fn run(
     match cmd {
         FirewallCommand::Cluster(sub) => match sub {
             ClusterFirewallCommand::Rules => cluster_rules(client, out).await,
-            ClusterFirewallCommand::Add {
-                action,
-                r#type,
-                enable,
-                iface,
-                source,
-                dest,
-                dport,
-                proto,
-                r#macro,
-                comment,
-            } => {
-                cluster_add_rule(
-                    client,
-                    out,
-                    &action,
-                    &r#type,
-                    enable,
-                    iface.as_deref(),
-                    source.as_deref(),
-                    dest.as_deref(),
-                    dport.as_deref(),
-                    proto.as_deref(),
-                    r#macro.as_deref(),
-                    comment.as_deref(),
-                )
-                .await
+            ClusterFirewallCommand::Add { rule } => {
+                let params = build_rule_params(&rule);
+                let param_refs: Vec<(&str, &str)> = params
+                    .iter()
+                    .map(|(k, v)| (k.as_str(), v.as_str()))
+                    .collect();
+                let _: serde_json::Value =
+                    client.post("/cluster/firewall/rules", &param_refs).await?;
+                out.print_result(
+                    &json!({"status": "rule added", "scope": "cluster"}),
+                    "Cluster firewall rule added",
+                );
+                Ok(())
             }
             ClusterFirewallCommand::Delete { pos, yes } => {
                 cluster_delete_rule(client, out, pos, yes).await
@@ -251,36 +215,20 @@ pub async fn run(
                 let n = require_node(node.as_deref(), global_node)?;
                 node_rules(client, out, n).await
             }
-            NodeFirewallCommand::Add {
-                node,
-                action,
-                r#type,
-                enable,
-                iface,
-                source,
-                dest,
-                dport,
-                proto,
-                r#macro,
-                comment,
-            } => {
+            NodeFirewallCommand::Add { node, rule } => {
                 let n = require_node(node.as_deref(), global_node)?;
-                node_add_rule(
-                    client,
-                    out,
-                    n,
-                    &action,
-                    &r#type,
-                    enable,
-                    iface.as_deref(),
-                    source.as_deref(),
-                    dest.as_deref(),
-                    dport.as_deref(),
-                    proto.as_deref(),
-                    r#macro.as_deref(),
-                    comment.as_deref(),
-                )
-                .await
+                let params = build_rule_params(&rule);
+                let param_refs: Vec<(&str, &str)> = params
+                    .iter()
+                    .map(|(k, v)| (k.as_str(), v.as_str()))
+                    .collect();
+                let path = format!("/nodes/{n}/firewall/rules");
+                let _: serde_json::Value = client.post(&path, &param_refs).await?;
+                out.print_result(
+                    &json!({"status": "rule added", "scope": "node", "node": n}),
+                    &format!("Node {n} firewall rule added"),
+                );
+                Ok(())
             }
             NodeFirewallCommand::Delete { node, pos, yes } => {
                 let n = require_node(node.as_deref(), global_node)?;
@@ -351,46 +299,34 @@ fn print_rules(data: &[serde_json::Value]) {
     }
 }
 
-#[allow(clippy::too_many_arguments)]
-fn build_rule_params(
-    action: &str,
-    rule_type: &str,
-    enable: Option<bool>,
-    iface: Option<&str>,
-    source: Option<&str>,
-    dest: Option<&str>,
-    dport: Option<&str>,
-    proto: Option<&str>,
-    r#macro: Option<&str>,
-    comment: Option<&str>,
-) -> Vec<(String, String)> {
+fn build_rule_params(rule: &FirewallRuleArgs) -> Vec<(String, String)> {
     let mut params: Vec<(String, String)> = vec![
-        ("action".to_string(), action.to_string()),
-        ("type".to_string(), rule_type.to_string()),
+        ("action".to_string(), rule.action.clone()),
+        ("type".to_string(), rule.r#type.clone()),
     ];
-    if let Some(e) = enable {
+    if let Some(e) = rule.enable {
         params.push(("enable".to_string(), if e { "1" } else { "0" }.to_string()));
     }
-    if let Some(i) = iface {
-        params.push(("iface".to_string(), i.to_string()));
+    if let Some(ref i) = rule.iface {
+        params.push(("iface".to_string(), i.clone()));
     }
-    if let Some(s) = source {
-        params.push(("source".to_string(), s.to_string()));
+    if let Some(ref s) = rule.source {
+        params.push(("source".to_string(), s.clone()));
     }
-    if let Some(d) = dest {
-        params.push(("dest".to_string(), d.to_string()));
+    if let Some(ref d) = rule.dest {
+        params.push(("dest".to_string(), d.clone()));
     }
-    if let Some(dp) = dport {
-        params.push(("dport".to_string(), dp.to_string()));
+    if let Some(ref dp) = rule.dport {
+        params.push(("dport".to_string(), dp.clone()));
     }
-    if let Some(p) = proto {
-        params.push(("proto".to_string(), p.to_string()));
+    if let Some(ref p) = rule.proto {
+        params.push(("proto".to_string(), p.clone()));
     }
-    if let Some(m) = r#macro {
-        params.push(("macro".to_string(), m.to_string()));
+    if let Some(ref m) = rule.r#macro {
+        params.push(("macro".to_string(), m.clone()));
     }
-    if let Some(c) = comment {
-        params.push(("comment".to_string(), c.to_string()));
+    if let Some(ref c) = rule.comment {
+        params.push(("comment".to_string(), c.clone()));
     }
     params
 }
@@ -412,37 +348,6 @@ async fn cluster_rules(client: &ProxmoxClient, out: OutputConfig) -> Result<(),
     Ok(())
 }
 
-#[allow(clippy::too_many_arguments)]
-async fn cluster_add_rule(
-    client: &ProxmoxClient,
-    out: OutputConfig,
-    action: &str,
-    rule_type: &str,
-    enable: Option<bool>,
-    iface: Option<&str>,
-    source: Option<&str>,
-    dest: Option<&str>,
-    dport: Option<&str>,
-    proto: Option<&str>,
-    r#macro: Option<&str>,
-    comment: Option<&str>,
-) -> Result<(), Error> {
-    let params = build_rule_params(
-        action, rule_type, enable, iface, source, dest, dport, proto, r#macro, comment,
-    );
-    let param_refs: Vec<(&str, &str)> = params
-        .iter()
-        .map(|(k, v)| (k.as_str(), v.as_str()))
-        .collect();
-    let _: serde_json::Value = client.post("/cluster/firewall/rules", &param_refs).await?;
-
-    out.print_result(
-        &json!({"status": "rule added", "scope": "cluster"}),
-        "Cluster firewall rule added",
-    );
-    Ok(())
-}
-
 async fn cluster_delete_rule(
     client: &ProxmoxClient,
     out: OutputConfig,
@@ -481,39 +386,6 @@ async fn node_rules(client: &ProxmoxClient, out: OutputConfig, node: &str) -> Re
     Ok(())
 }
 
-#[allow(clippy::too_many_arguments)]
-async fn node_add_rule(
-    client: &ProxmoxClient,
-    out: OutputConfig,
-    node: &str,
-    action: &str,
-    rule_type: &str,
-    enable: Option<bool>,
-    iface: Option<&str>,
-    source: Option<&str>,
-    dest: Option<&str>,
-    dport: Option<&str>,
-    proto: Option<&str>,
-    r#macro: Option<&str>,
-    comment: Option<&str>,
-) -> Result<(), Error> {
-    let params = build_rule_params(
-        action, rule_type, enable, iface, source, dest, dport, proto, r#macro, comment,
-    );
-    let param_refs: Vec<(&str, &str)> = params
-        .iter()
-        .map(|(k, v)| (k.as_str(), v.as_str()))
-        .collect();
-    let path = format!("/nodes/{node}/firewall/rules");
-    let _: serde_json::Value = client.post(&path, &param_refs).await?;
-
-    out.print_result(
-        &json!({"status": "rule added", "scope": "node", "node": node}),
-        &format!("Node {node} firewall rule added"),
-    );
-    Ok(())
-}
-
 async fn node_delete_rule(
     client: &ProxmoxClient,
     out: OutputConfig,

{proxctl-0.2.2 → proxctl-0.2.4}/src/main.rs

@@ -537,6 +537,24 @@ fn normalize_host(host: &str) -> String {
     }
 }
 
+fn sym_ok() -> String {
+    use owo_colors::OwoColorize;
+    if proxctl::output::use_color() {
+        "✔".green().to_string()
+    } else {
+        "✔".to_owned()
+    }
+}
+
+fn sym_dim(s: &str) -> String {
+    use owo_colors::OwoColorize;
+    if proxctl::output::use_color() {
+        s.dimmed().to_string()
+    } else {
+        s.to_owned()
+    }
+}
+
 async fn run_config_init() -> Result<(), Error> {
     use dialoguer::{Confirm, Input};
 
@@ -589,7 +607,9 @@ async fn run_config_init() -> Result<(), Error> {
         .map_err(|e| Error::Other(format!("failed to read password: {e}")))?;
 
     // Step 6: Verify credentials — POST to /api2/json/access/ticket
-    println!("Connecting to {base_url} ...");
+    let sep = sym_dim("──────────────");
+    eprintln!();
+    eprintln!("  Connecting to {base_url} ...");
 
     let http = reqwest::Client::builder()
         .danger_accept_invalid_certs(insecure)
@@ -627,7 +647,16 @@ async fn run_config_init() -> Result<(), Error> {
         .ok_or_else(|| Error::Auth("ticket response missing data.CSRFPreventionToken".to_string()))?
         .to_string();
 
-    println!("Authenticated. Creating API token ...");
+    eprintln!("  {} Authenticated", sym_ok());
+    eprintln!();
+    eprintln!(
+        "  {}",
+        sym_dim(&format!(
+            "API docs: {base_url}/pve-docs/api-viewer/index.html"
+        ))
+    );
+    eprintln!();
+    eprintln!("  Creating API token ...");
 
     // Step 7: Create API token
     let token_id = "proxctl";
@@ -644,7 +673,7 @@ async fn run_config_init() -> Result<(), Error> {
 
     let token_json: serde_json::Value = if create_resp.status().as_u16() == 400 {
         // Token already exists — delete it and recreate
-        println!("Token already exists, recreating ...");
+        eprintln!("  Token already exists, recreating ...");
 
         let del_resp = http
             .delete(&token_url)
@@ -705,8 +734,28 @@ async fn run_config_init() -> Result<(), Error> {
         insecure,
     )?;
 
-    println!("Config saved to {}", config_path.display());
-    println!("Run `proxctl health` to verify connectivity.");
+    eprintln!();
+    eprintln!(
+        "  {} Configuration saved to {}",
+        sym_ok(),
+        config_path.display()
+    );
+    eprintln!();
+    eprintln!("{sep}");
+    eprintln!("  Next steps:");
+    eprintln!(
+        "    {}",
+        sym_dim("proxctl health          # verify connectivity")
+    );
+    eprintln!(
+        "    {}",
+        sym_dim("proxctl vm list         # list virtual machines")
+    );
+    eprintln!(
+        "    {}",
+        sym_dim("proxctl completions zsh # shell completions")
+    );
+    eprintln!("{sep}");
 
     Ok(())
 }