feat: openrouter out of the box experience for goose installations

crates/goose-cli/src/cli.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use clap::{Args, Parser, Subcommand};
 
-use goose::config::{Config, ExtensionConfig};
+use goose::config::Config;
 
 use crate::commands::bench::agent_generator;
 use crate::commands::configure::handle_configure;
@@ -273,7 +273,7 @@ enum RecipeCommand {
 enum Command {
     /// Configure Goose settings
     #[command(about = "Configure Goose settings")]
-    Configure {},
+    Configure,
 
     /// Display Goose configuration information
     #[command(about = "Display Goose information")]
@@ -681,7 +681,7 @@ enum CliProviderVariant {
 #[derive(Debug)]
 pub struct InputConfig {
     pub contents: Option<String>,
-    pub extensions_override: Option<Vec<ExtensionConfig>>,
+    pub extensions_override: Option<Vec<goose::config::ExtensionConfig>>,
     pub additional_system_prompt: Option<String>,
 }
 
@@ -702,7 +702,7 @@ pub async fn cli() -> Result<()> {
     }
 
     match cli.command {
-        Some(Command::Configure {}) => {
+        Some(Command::Configure) => {
             let _ = handle_configure().await;
             return Ok(());
         }

crates/goose-server/src/routes/mod.rs

@@ -10,6 +10,7 @@ pub mod recipe;
 pub mod reply;
 pub mod schedule;
 pub mod session;
+pub mod setup;
 pub mod utils;
 use std::sync::Arc;
 
@@ -29,4 +30,5 @@ pub fn configure(state: Arc<crate::state::AppState>) -> Router {
         .merge(session::routes(state.clone()))
         .merge(schedule::routes(state.clone()))
         .merge(project::routes(state.clone()))
+        .merge(setup::routes(state.clone()))
 }

crates/goose-server/src/routes/setup.rs

@@ -0,0 +1,122 @@
+use crate::state::AppState;
+use axum::{extract::State, http::StatusCode, routing::post, Json, Router};
+use goose::config::signup_openrouter::OpenRouterAuth;
+use goose::config::{configure_openrouter, Config};
+use once_cell::sync::Lazy;
+use serde::Serialize;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+// Global mutex to ensure only one OAuth flow at a time
+static OAUTH_FLOW_MUTEX: Lazy<Arc<Mutex<()>>> = Lazy::new(|| Arc::new(Mutex::new(())));
+
+#[derive(Serialize)]
+pub struct SetupResponse {
+    pub success: bool,
+    pub message: String,
+}
+
+pub fn routes(state: Arc<AppState>) -> Router {
+    Router::new()
+        .route("/setup/openrouter/start", post(start_openrouter_setup))
+        .with_state(state)
+}
+
+async fn start_openrouter_setup(
+    State(_state): State<Arc<AppState>>,
+) -> Result<Json<SetupResponse>, StatusCode> {
+    tracing::info!("Starting OpenRouter setup flow");
+
+    // Try to acquire the mutex with a timeout to prevent concurrent OAuth flows
+    let _lock = match tokio::time::timeout(
+        std::time::Duration::from_secs(1),
+        OAUTH_FLOW_MUTEX.lock(),
+    )
+    .await
+    {
+        Ok(lock) => lock,
+        Err(_) => {
+            tracing::warn!("OAuth flow is already in progress");
+            return Ok(Json(SetupResponse {
+                success: false,
+                message: "Authentication flow is already in progress. Please wait.".to_string(),
+            }));
+        }
+    };
+
+    tracing::info!("Acquired OAuth flow lock");
+
+    // Run the existing PKCE flow
+    let mut auth_flow = OpenRouterAuth::new().map_err(|e| {
+        tracing::error!("Failed to initialize auth flow: {}", e);
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    tracing::info!("Auth flow initialized, starting complete_flow");
+
+    match auth_flow.complete_flow().await {
+        Ok(api_key) => {
+            // The complete_flow only returns the API key, we need to save the configuration
+            tracing::info!("Got API key, configuring OpenRouter...");
+
+            // Configure everything using the common function
+            let config = Config::global();
+
+            // Use the common configuration function
+            if let Err(e) = configure_openrouter(config, api_key) {
+                tracing::error!("Failed to configure OpenRouter: {}", e);
+                return Ok(Json(SetupResponse {
+                    success: false,
+                    message: format!("Failed to configure OpenRouter: {}", e),
+                }));
+            }
+
+            tracing::info!("OpenRouter setup completed successfully");
+            Ok(Json(SetupResponse {
+                success: true,
+                message: "OpenRouter setup completed successfully".to_string(),
+            }))
+        }
+        Err(e) => {
+            tracing::error!("OpenRouter setup failed: {}", e);
+            Ok(Json(SetupResponse {
+                success: false,
+                message: format!("Setup failed: {}", e),
+            }))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_oauth_flow_mutex() {
+        // Test that the OAuth flow mutex is properly initialized and prevents concurrent flows
+        let lock1 = OAUTH_FLOW_MUTEX.try_lock();
+        assert!(lock1.is_ok(), "First lock should succeed");
+
+        // Try to acquire second lock while first is held
+        let lock2_result = tokio::time::timeout(
+            std::time::Duration::from_millis(100),
+            OAUTH_FLOW_MUTEX.lock(),
+        )
+        .await;
+
+        assert!(
+            lock2_result.is_err(),
+            "Second lock should timeout while first is held"
+        );
+
+        // Drop first lock
+        drop(lock1);
+
+        // Now second lock should succeed
+        let lock2 = OAUTH_FLOW_MUTEX.try_lock();
+        assert!(
+            lock2.is_ok(),
+            "Second lock should succeed after first is dropped"
+        );
+    }
+}

crates/goose/Cargo.toml

@@ -53,7 +53,6 @@ nanoid = "0.4"
 sha2 = "0.10"
 base64 = "0.21"
 url = "2.5"
-urlencoding = "2.1"
 axum = "0.8.1"
 webbrowser = "0.8"
 lazy_static = "1.5.0"
@@ -66,6 +65,8 @@ etcetera = "0.8.0"
 rand = "0.8.5"
 utoipa = { version = "4.1", features = ["chrono"] }
 tokio-cron-scheduler = "0.14.0"
+urlencoding = "2.1"
+html-escape = "0.2"
 
 # For Bedrock provider
 aws-config = { version = "1.5.16", features = ["behavior-version-latest"] }

crates/goose/src/config/mod.rs

@@ -2,12 +2,14 @@ pub mod base;
 mod experiments;
 pub mod extensions;
 pub mod permission;
+pub mod signup_openrouter;
 
 pub use crate::agents::ExtensionConfig;
 pub use base::{Config, ConfigError, APP_STRATEGY};
 pub use experiments::ExperimentManager;
 pub use extensions::{ExtensionConfigManager, ExtensionEntry};
 pub use permission::PermissionManager;
+pub use signup_openrouter::configure_openrouter;
 
 pub use extensions::DEFAULT_DISPLAY_NAME;
 pub use extensions::DEFAULT_EXTENSION;