Skip to main content

aster_server/routes/
setup.rs

1use crate::state::AppState;
2use aster::config::signup_openrouter::OpenRouterAuth;
3use aster::config::signup_tetrate::{configure_tetrate, TetrateAuth};
4use aster::config::{configure_openrouter, Config};
5use axum::{http::StatusCode, routing::post, Json, Router};
6use serde::Serialize;
7use std::sync::Arc;
8use utoipa::ToSchema;
9
10#[derive(Serialize, ToSchema)]
11pub struct SetupResponse {
12    pub success: bool,
13    pub message: String,
14}
15
16pub fn routes(state: Arc<AppState>) -> Router {
17    Router::new()
18        .route("/handle_openrouter", post(start_openrouter_setup))
19        .route("/handle_tetrate", post(start_tetrate_setup))
20        .with_state(state)
21}
22
23#[utoipa::path(
24    post,
25    path = "/handle_openrouter",
26    responses(
27        (status = 200, body=SetupResponse)
28    ),
29)]
30async fn start_openrouter_setup() -> Result<Json<SetupResponse>, StatusCode> {
31    tracing::info!("Starting OpenRouter setup flow");
32
33    let mut auth_flow = OpenRouterAuth::new().map_err(|e| {
34        tracing::error!("Failed to initialize auth flow: {}", e);
35        StatusCode::INTERNAL_SERVER_ERROR
36    })?;
37
38    tracing::info!("Auth flow initialized, starting complete_flow");
39
40    match auth_flow.complete_flow().await {
41        Ok(api_key) => {
42            tracing::info!("Got API key, configuring OpenRouter...");
43
44            let config = Config::global();
45
46            if let Err(e) = configure_openrouter(config, api_key) {
47                tracing::error!("Failed to configure OpenRouter: {}", e);
48                return Ok(Json(SetupResponse {
49                    success: false,
50                    message: format!("Failed to configure OpenRouter: {}", e),
51                }));
52            }
53
54            tracing::info!("OpenRouter setup completed successfully");
55            Ok(Json(SetupResponse {
56                success: true,
57                message: "OpenRouter setup completed successfully".to_string(),
58            }))
59        }
60        Err(e) => {
61            tracing::error!("OpenRouter setup failed: {}", e);
62            Ok(Json(SetupResponse {
63                success: false,
64                message: format!("Setup failed: {}", e),
65            }))
66        }
67    }
68}
69
70#[utoipa::path(
71    post,
72    path = "/handle_tetrate",
73    responses(
74        (status = 200, body=SetupResponse)
75    ),
76)]
77async fn start_tetrate_setup() -> Result<Json<SetupResponse>, StatusCode> {
78    tracing::info!("Starting Tetrate Agent Router Service setup flow");
79
80    let mut auth_flow = TetrateAuth::new().map_err(|e| {
81        tracing::error!("Failed to initialize auth flow: {}", e);
82        StatusCode::INTERNAL_SERVER_ERROR
83    })?;
84
85    tracing::info!("Auth flow initialized, starting complete_flow");
86
87    match auth_flow.complete_flow().await {
88        Ok(api_key) => {
89            tracing::info!("Got API key, configuring Tetrate Agent Router Service...");
90
91            let config = Config::global();
92
93            if let Err(e) = configure_tetrate(config, api_key) {
94                tracing::error!("Failed to configure Tetrate Agent Router Service: {}", e);
95                return Ok(Json(SetupResponse {
96                    success: false,
97                    message: format!("Failed to configure Tetrate Agent Router Service: {}", e),
98                }));
99            }
100
101            tracing::info!("Tetrate Agent Router Service setup completed successfully");
102            Ok(Json(SetupResponse {
103                success: true,
104                message: "Tetrate Agent Router Service setup completed successfully".to_string(),
105            }))
106        }
107        Err(e) => {
108            tracing::error!("Tetrate Agent Router Service setup failed: {}", e);
109            Ok(Json(SetupResponse {
110                success: false,
111                message: format!("Setup failed: {}", e),
112            }))
113        }
114    }
115}