byokey 1.0.0

Bring Your Own Keys — AI subscription-to-API proxy gateway
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

use anyhow::Result;
use clap::Subcommand;

use crate::DaemonArgs;

#[derive(Subcommand, Debug)]
pub enum ServiceAction {
    /// Install byokey as an OS-managed service and start it.
    Install {
        #[command(flatten)]
        daemon: DaemonArgs,
    },
    /// Uninstall the OS-managed service.
    Uninstall,
    /// Start the installed service.
    Start,
    /// Stop the installed service.
    Stop,
    /// Show the OS-managed service's registration and running state.
    Status,
}

pub fn cmd_service(action: ServiceAction) -> Result<()> {
    match action {
        ServiceAction::Install { daemon } => cmd_service_install(daemon),
        ServiceAction::Uninstall => cmd_service_uninstall(),
        ServiceAction::Start => cmd_service_start(),
        ServiceAction::Stop => cmd_service_stop(),
        ServiceAction::Status => cmd_service_status(),
    }
}

fn start_opts(args: DaemonArgs) -> byokey_daemon::process::StartOptions {
    byokey_daemon::process::StartOptions {
        exe: None,
        config: args.server.config,
        port: args.server.port,
        host: args.server.host,
        db: args.server.db,
        log_file: args.server.log_file,
        pid_file: None,
    }
}

fn service_opts(args: DaemonArgs) -> byokey_daemon::service::ServiceOptions {
    byokey_daemon::service::ServiceOptions {
        exe: None,
        config: args.server.config,
        port: args.server.port,
        host: args.server.host,
        db: args.server.db,
        log_file: args.server.log_file,
    }
}

pub fn cmd_start(args: DaemonArgs) -> Result<()> {
    let result = byokey_daemon::process::start(start_opts(args))?;
    println!("byokey started (pid {})", result.pid);
    println!("logs: {}", result.log_path.display());
    Ok(())
}

pub fn cmd_stop() -> Result<()> {
    let result = byokey_daemon::process::stop()?;
    match result.pid {
        Some(pid) => println!("byokey stopped (pid {pid})"),
        None => println!("byokey stopped"),
    }
    Ok(())
}

pub fn cmd_restart(args: DaemonArgs) -> Result<()> {
    let result = byokey_daemon::process::restart(start_opts(args))?;
    println!("byokey started (pid {})", result.pid);
    println!("logs: {}", result.log_path.display());
    Ok(())
}

pub fn cmd_reload() -> Result<()> {
    byokey_daemon::control::reload()?;
    println!("configuration reloaded");
    Ok(())
}

// ── Service (OS-managed) ─────────────────────────────────────────────────────

fn cmd_service_install(args: DaemonArgs) -> Result<()> {
    let result = byokey_daemon::service::install(service_opts(args))?;
    println!("service installed ({})", result.backend);
    println!("label:   {}", result.label);
    // Installing via `service-manager` sets autostart=true but does not start
    // the service immediately on all backends. Start it now for convenience.
    byokey_daemon::service::start()?;
    println!("service started");
    Ok(())
}

fn cmd_service_uninstall() -> Result<()> {
    byokey_daemon::service::uninstall()?;
    println!("service uninstalled");
    Ok(())
}

fn cmd_service_start() -> Result<()> {
    byokey_daemon::service::start()?;
    println!("service started");
    Ok(())
}

fn cmd_service_stop() -> Result<()> {
    byokey_daemon::service::stop()?;
    println!("service stopped");
    Ok(())
}

fn cmd_service_status() -> Result<()> {
    let st = byokey_daemon::service::status()?;
    println!("backend:   {}", st.backend);
    println!("installed: {}", if st.installed { "yes" } else { "no" });
    println!("running:   {}", if st.running { "yes" } else { "no" });
    Ok(())
}