forklaunch 1.18.0

Launch faster with forklaunch
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

use std::io::Write;

use anyhow::{Context, Result, bail};
use clap::{Arg, ArgMatches, Command};
use serde::Deserialize;
use termcolor::{Color, ColorChoice, StandardStream, WriteColor};

use crate::{
    CliCommand,
    constants::get_platform_management_api_url,
    core::{
        command::command,
        http_client,
        validate::{require_auth, require_manifest},
    },
};

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct AppStatusResponse {
    installed: bool,
    installation_id: Option<String>,
    account_login: Option<String>,
    account_type: Option<String>,
}

#[derive(Debug)]
pub(crate) struct StatusCommand;

impl StatusCommand {
    pub(crate) fn new() -> Self {
        Self {}
    }
}

impl CliCommand for StatusCommand {
    fn command(&self) -> Command {
        command(
            "status",
            "Show GitHub App installation status and this app's repository connection",
        )
        .arg(
            Arg::new("base_path")
                .long("path")
                .short('p')
                .help("Path to application root (optional)"),
        )
    }

    fn handler(&self, matches: &ArgMatches) -> Result<()> {
        let mut stdout = StandardStream::stdout(ColorChoice::Always);
        require_auth()?;

        let url = format!("{}/github-app/status", get_platform_management_api_url());
        let response = http_client::get(&url)?;
        if !response.status().is_success() {
            bail!(
                "Failed to fetch GitHub App status (Status: {})",
                response.status()
            );
        }
        let status: AppStatusResponse = response
            .json()
            .with_context(|| "Failed to parse GitHub App status response")?;

        if status.installed {
            log_ok!(
                stdout,
                "GitHub App installed for {} ({})",
                status.account_login.as_deref().unwrap_or("unknown"),
                status.account_type.as_deref().unwrap_or("unknown")
            );
            if let Some(id) = &status.installation_id {
                log_info!(stdout, "Installation ID: {}", id);
            }
        } else {
            log_warn!(
                stdout,
                "GitHub App is not installed for this organization. Run `forklaunch github install` to get the installation link."
            );
        }

        // Per-application connection settings when run inside an integrated app
        let Ok((_, manifest)) = require_manifest(matches) else {
            return Ok(());
        };
        let Some(app_id) = &manifest.platform_application_id else {
            return Ok(());
        };
        let settings_url = format!(
            "{}/applications/{}/github/settings",
            get_platform_management_api_url(),
            app_id
        );
        let Ok(resp) = http_client::get(&settings_url) else {
            return Ok(());
        };
        if !resp.status().is_success() {
            return Ok(());
        }
        let body: serde_json::Value = resp
            .json()
            .with_context(|| "Failed to parse application settings")?;
        log_header!(stdout, Color::Cyan, "\nApplication repository settings:");
        writeln!(stdout, "{}", serde_json::to_string_pretty(&body)?)?;

        Ok(())
    }
}