stout 0.2.0

A fast, Rust-based Homebrew-compatible package manager
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

//! Home command - open the homepage of a package in the browser

use anyhow::{bail, Context, Result};
use stout_index::{Database, IndexSync};
use stout_state::{Config, Paths};
use clap::Args as ClapArgs;
use console::style;
use tracing::warn;

#[derive(ClapArgs)]
pub struct Args {
    /// Formula or cask to open homepage for
    pub formula: Option<String>,
}

pub async fn run(args: Args) -> Result<()> {
    let paths = Paths::default();
    let config = Config::load(&paths)?;

    // If no formula specified, open stout/homebrew homepage
    let url = if let Some(ref name) = args.formula {
        let db = Database::open(paths.index_db())
            .context("Failed to open index. Run 'stout update' first.")?;

        if !db.is_initialized()? {
            bail!("Index not initialized. Run 'stout update' first.");
        }

        // Try to get formula info
        let sync = IndexSync::with_security_policy(
            Some(&config.index.base_url),
            &paths.stout_dir,
            config.security.to_security_policy(),
        )?;

        // Try as formula first
        if let Ok(formula) = sync.fetch_formula_cached(name, None).await {
            if let Some(homepage) = formula.homepage {
                homepage
            } else {
                bail!("Formula '{}' has no homepage", name);
            }
        } else if let Ok(cask) = sync.fetch_cask_cached(name, None).await {
            // Try as cask
            if let Some(homepage) = cask.homepage {
                homepage
            } else {
                bail!("Cask '{}' has no homepage", name);
            }
        } else {
            bail!("Formula or cask '{}' not found", name);
        }
    } else {
        // Default to Homebrew homepage
        "https://brew.sh".to_string()
    };

    println!(
        "{} Opening {}",
        style("==>").blue().bold(),
        style(&url).cyan().underlined()
    );

    open_url(&url)?;

    Ok(())
}

/// Open a URL in the default browser
fn open_url(url: &str) -> Result<()> {
    #[cfg(target_os = "macos")]
    {
        std::process::Command::new("open")
            .arg(url)
            .spawn()
            .context("Failed to open URL")?;
    }

    #[cfg(target_os = "linux")]
    {
        // Try xdg-open first, then common browsers
        if let Err(e) = std::process::Command::new("xdg-open")
            .arg(url)
            .spawn()
        {
            warn!("Failed to open URL with xdg-open: {}", e);
            // Fallback to common browsers
            for browser in &["firefox", "chromium", "google-chrome", "brave"] {
                if std::process::Command::new(browser)
                    .arg(url)
                    .spawn()
                    .is_ok()
                {
                    return Ok(());
                }
            }
            bail!("Could not find a browser to open URL. Install xdg-utils or a web browser.");
        }
    }

    #[cfg(target_os = "windows")]
    {
        std::process::Command::new("cmd")
            .args(["/C", "start", url])
            .spawn()
            .context("Failed to open URL")?;
    }

    Ok(())
}