move code around

Author: michaelneale

Cargo.lock

@@ -592,6 +592,37 @@ enum SchedulerCommand {
     CronHelp {},
 }
 
+#[derive(Subcommand)]
+enum GatewayCommand {
+    #[command(about = "Show gateway status")]
+    Status {},
+
+    #[command(about = "Start a gateway")]
+    Start {
+        #[arg(help = "Gateway type (e.g., 'telegram')")]
+        gateway_type: String,
+
+        #[arg(
+            long = "bot-token",
+            help = "Bot token for the gateway platform",
+            long_help = "Authentication token for the gateway platform (e.g., Telegram bot token)"
+        )]
+        bot_token: String,
+    },
+
+    #[command(about = "Stop a running gateway")]
+    Stop {
+        #[arg(help = "Gateway type to stop (e.g., 'telegram')")]
+        gateway_type: String,
+    },
+
+    #[command(about = "Generate a pairing code for a gateway")]
+    Pair {
+        #[arg(help = "Gateway type to generate pairing code for")]
+        gateway_type: String,
+    },
+}
+
 #[derive(Subcommand)]
 enum RecipeCommand {
     /// Validate a recipe file
@@ -785,6 +816,16 @@ enum Command {
         command: SchedulerCommand,
     },
 
+    /// Manage gateways for external platform integrations (e.g., Telegram)
+    #[command(
+        about = "Manage gateways for external platform integrations",
+        visible_alias = "gw"
+    )]
+    Gateway {
+        #[command(subcommand)]
+        command: GatewayCommand,
+    },
+
     /// Update the goose CLI version
     #[command(about = "Update the goose CLI version")]
     Update {
@@ -959,6 +1000,7 @@ fn get_command_name(command: &Option<Command>) -> &'static str {
         Some(Command::Project {}) => "project",
         Some(Command::Projects) => "projects",
         Some(Command::Run { .. }) => "run",
+        Some(Command::Gateway { .. }) => "gateway",
         Some(Command::Schedule { .. }) => "schedule",
         Some(Command::Update { .. }) => "update",
         Some(Command::Recipe { .. }) => "recipe",
@@ -1350,6 +1392,23 @@ async fn handle_run_command(
     }
 }
 
+async fn handle_gateway_command(command: GatewayCommand) -> Result<()> {
+    use crate::commands::gateway;
+
+    match command {
+        GatewayCommand::Status {} => gateway::handle_gateway_status().await,
+        GatewayCommand::Start {
+            gateway_type,
+            bot_token,
+        } => {
+            let platform_config = serde_json::json!({ "bot_token": bot_token });
+            gateway::handle_gateway_start(gateway_type, platform_config).await
+        }
+        GatewayCommand::Stop { gateway_type } => gateway::handle_gateway_stop(gateway_type).await,
+        GatewayCommand::Pair { gateway_type } => gateway::handle_gateway_pair(gateway_type).await,
+    }
+}
+
 async fn handle_schedule_command(command: SchedulerCommand) -> Result<()> {
     match command {
         SchedulerCommand::Add {
@@ -1513,6 +1572,7 @@ pub async fn cli() -> anyhow::Result<()> {
             )
             .await
         }
+        Some(Command::Gateway { command }) => handle_gateway_command(command).await,
         Some(Command::Schedule { command }) => handle_schedule_command(command).await,
         Some(Command::Update {
             canary,

crates/goose-cli/src/cli.rs

@@ -0,0 +1,82 @@
+use anyhow::Result;
+use goose::execution::manager::AgentManager;
+use goose::gateway::manager::GatewayManager;
+use std::sync::Arc;
+
+pub async fn handle_gateway_status() -> Result<()> {
+    let agent_manager = AgentManager::instance().await?;
+    let gateway_manager = Arc::new(GatewayManager::new(agent_manager));
+    let statuses = gateway_manager.status().await;
+
+    if statuses.is_empty() {
+        println!("No gateways configured.");
+        return Ok(());
+    }
+
+    for status in statuses {
+        let state = if status.running { "running" } else { "stopped" };
+        println!(
+            "{}: {} ({} paired users)",
+            status.gateway_type,
+            state,
+            status.paired_users.len()
+        );
+        for user in &status.paired_users {
+            println!(
+                "  - {}/{} (session: {})",
+                user.platform,
+                user.display_name.as_deref().unwrap_or(&user.user_id),
+                user.session_id
+            );
+        }
+    }
+
+    Ok(())
+}
+
+pub async fn handle_gateway_start(
+    gateway_type: String,
+    platform_config: serde_json::Value,
+) -> Result<()> {
+    let agent_manager = AgentManager::instance().await?;
+    let gateway_manager = Arc::new(GatewayManager::new(agent_manager));
+
+    let mut config = goose::gateway::GatewayConfig {
+        gateway_type,
+        platform_config,
+        max_sessions: 0,
+    };
+
+    let gw = goose::gateway::create_gateway(&mut config)?;
+    gateway_manager.start_gateway(config, gw).await?;
+
+    println!("Gateway started. Press Ctrl+C to stop.");
+
+    tokio::signal::ctrl_c().await?;
+    gateway_manager.stop_all().await;
+
+    Ok(())
+}
+
+pub async fn handle_gateway_stop(gateway_type: String) -> Result<()> {
+    let agent_manager = AgentManager::instance().await?;
+    let gateway_manager = Arc::new(GatewayManager::new(agent_manager));
+    gateway_manager.stop_gateway(&gateway_type).await?;
+    println!("Gateway '{}' stopped.", gateway_type);
+    Ok(())
+}
+
+pub async fn handle_gateway_pair(gateway_type: String) -> Result<()> {
+    let agent_manager = AgentManager::instance().await?;
+    let gateway_manager = Arc::new(GatewayManager::new(agent_manager));
+    let (code, expires_at) = gateway_manager.generate_pairing_code(&gateway_type).await?;
+
+    let expires = chrono::DateTime::from_timestamp(expires_at, 0)
+        .map(|dt| dt.format("%H:%M:%S").to_string())
+        .unwrap_or_else(|| "unknown".to_string());
+
+    println!("Pairing code: {}", code);
+    println!("Expires at: {}", expires);
+
+    Ok(())
+}

crates/goose-cli/src/commands/gateway.rs

@@ -1,4 +1,5 @@
 pub mod configure;
+pub mod gateway;
 pub mod info;
 pub mod project;
 pub mod recipe;

crates/goose-cli/src/commands/mod.rs

@@ -51,9 +51,6 @@ rustls = { version = "0.23", features = ["ring"] }
 uuid = { workspace = true }
 once_cell = { workspace = true }
 dirs = { workspace = true }
-sqlx = { version = "0.8.6", features = ["runtime-tokio", "sqlite"] }
-async-trait.workspace = true
-pulldown-cmark = "0.13.0"
 
 [target.'cfg(windows)'.dependencies]
 winreg = { version = "0.55.0" }

crates/goose-server/Cargo.toml

@@ -1,7 +1,6 @@
 pub mod auth;
 pub mod configuration;
 pub mod error;
-pub mod gateway;
 pub mod openapi;
 pub mod routes;
 pub mod state;

crates/goose-server/src/lib.rs

@@ -1,7 +1,6 @@
 mod commands;
 mod configuration;
 mod error;
-mod gateway;
 mod logging;
 mod openapi;
 mod routes;

crates/goose-server/src/main.rs

@@ -1,5 +1,3 @@
-use crate::gateway::manager::GatewayStatus;
-use crate::gateway::{self, GatewayConfig};
 use crate::routes::errors::ErrorResponse;
 use crate::state::AppState;
 use axum::{
@@ -9,6 +7,8 @@ use axum::{
     routing::{delete, get, post},
     Json, Router,
 };
+use goose::gateway::manager::GatewayStatus;
+use goose::gateway::GatewayConfig;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use utoipa::ToSchema;
@@ -67,7 +67,7 @@ pub async fn start_gateway(
         max_sessions: request.max_sessions,
     };
 
-    let gw = match gateway::create_gateway(&mut config) {
+    let gw = match goose::gateway::create_gateway(&mut config) {
         Ok(gw) => gw,
         Err(e) => return ErrorResponse::bad_request(e.to_string()).into_response(),
     };

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

@@ -12,9 +12,9 @@ use std::sync::Arc;
 use tokio::sync::Mutex;
 use tokio::task::JoinHandle;
 
-use crate::gateway::manager::GatewayManager;
 use crate::tunnel::TunnelManager;
 use goose::agents::ExtensionLoadResult;
+use goose::gateway::manager::GatewayManager;
 
 type ExtensionLoadingTasks =
     Arc<Mutex<HashMap<String, Arc<Mutex<Option<JoinHandle<Vec<ExtensionLoadResult>>>>>>>>;

crates/goose-server/src/state.rs

@@ -126,6 +126,7 @@ ignore = { workspace = true }
 which = { workspace = true }
 pctx_code_mode = "^0.2.3"
 unbinder = "0.1.7"
+pulldown-cmark = "0.13.0"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { version = "0.3", features = ["wincred"] }