stop/start/remove lifecycle for gateways

Stop now keeps the saved config (bot token) so the gateway can be
restarted without re-entering credentials. Pairings are still cleared
on stop so users must re-pair.

Three states in the UI:
- Unconfigured: shows token input + Start
- Configured + stopped: shows Start button + trash to remove
- Running: shows Pair Device + Stop

New API endpoints:
- POST /gateway/restart - restart a stopped gateway from saved config
- POST /gateway/remove - stop + delete saved config entirely

Status endpoint now includes configured-but-stopped gateways.

Author: michaelneale

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

@@ -48,6 +48,7 @@ pub struct PairedUserInfo {
 pub struct GatewayStatus {
     pub gateway_type: String,
     pub running: bool,
+    pub configured: bool,
     pub paired_users: Vec<PairedUserInfo>,
     #[serde(skip_serializing_if = "HashMap::is_empty")]
     pub info: HashMap<String, String>,
@@ -122,7 +123,7 @@ impl GatewayManager {
         Ok(())
     }
 
-    /// Stop a gateway, clear its pairings, and remove its persisted config.
+    /// Stop a gateway and clear its pairings. Config is kept so it can be restarted.
     pub async fn stop_gateway(&self, gateway_type: &str) -> anyhow::Result<()> {
         let instance = self
             .gateways
@@ -148,11 +149,49 @@ impl GatewayManager {
             _ => {}
         }
 
-        Self::remove_saved_config(gateway_type);
         tracing::info!(gateway = %gateway_type, "gateway stopped");
         Ok(())
     }
 
+    /// Stop a gateway (if running), clear pairings, and remove its saved config entirely.
+    pub async fn remove_gateway(&self, gateway_type: &str) -> anyhow::Result<()> {
+        // Stop if running (ignore error if not running).
+        if let Some(instance) = self.gateways.write().await.remove(gateway_type) {
+            instance.cancel.cancel();
+            let _ = instance.handle.await;
+        }
+
+        if let Err(e) = self
+            .pairing_store
+            .remove_all_for_platform(gateway_type)
+            .await
+        {
+            tracing::warn!(gateway = %gateway_type, error = %e, "failed to clear pairings on remove");
+        }
+
+        Self::remove_saved_config(gateway_type);
+        tracing::info!(gateway = %gateway_type, "gateway removed");
+        Ok(())
+    }
+
+    /// Restart a stopped gateway using its saved config.
+    pub async fn restart_gateway(&self, gateway_type: &str) -> anyhow::Result<()> {
+        if self.gateways.read().await.contains_key(gateway_type) {
+            anyhow::bail!("Gateway '{}' is already running", gateway_type);
+        }
+
+        let configs = Self::load_saved_configs()?;
+        let mut config = configs
+            .into_iter()
+            .find(|c| c.gateway_type == gateway_type)
+            .ok_or_else(|| anyhow::anyhow!("No saved config for gateway '{}'", gateway_type))?;
+
+        let gateway = super::create_gateway(&mut config)?;
+        self.start_gateway_internal(config, gateway).await?;
+        tracing::info!(gateway = %gateway_type, "gateway restarted");
+        Ok(())
+    }
+
     async fn start_gateway_internal(
         &self,
         config: GatewayConfig,
@@ -226,8 +265,10 @@ impl GatewayManager {
     pub async fn status(&self) -> Vec<GatewayStatus> {
         let running = self.gateways.read().await;
         let mut statuses = Vec::new();
+        let mut seen = std::collections::HashSet::new();
 
         for (gw_type, instance) in running.iter() {
+            seen.insert(gw_type.clone());
             let paired_users = self
                 .pairing_store
                 .list_paired_users(gw_type)
@@ -246,11 +287,28 @@ impl GatewayManager {
             statuses.push(GatewayStatus {
                 gateway_type: gw_type.clone(),
                 running: true,
+                configured: true,
                 paired_users,
                 info: instance.gateway.info(),
             });
         }
 
+        // Include configured-but-stopped gateways.
+        if let Ok(saved) = Self::load_saved_configs() {
+            for config in saved {
+                if seen.contains(&config.gateway_type) {
+                    continue;
+                }
+                statuses.push(GatewayStatus {
+                    gateway_type: config.gateway_type,
+                    running: false,
+                    configured: true,
+                    paired_users: Vec::new(),
+                    info: HashMap::new(),
+                });
+            }
+        }
+
         statuses.sort_by(|a, b| a.gateway_type.cmp(&b.gateway_type));
         statuses
     }

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

@@ -26,6 +26,16 @@ pub struct StopGatewayRequest {
     pub gateway_type: String,
 }
 
+#[derive(Deserialize, ToSchema)]
+pub struct RestartGatewayRequest {
+    pub gateway_type: String,
+}
+
+#[derive(Deserialize, ToSchema)]
+pub struct RemoveGatewayRequest {
+    pub gateway_type: String,
+}
+
 #[derive(Deserialize, ToSchema)]
 pub struct CreatePairingRequest {
     pub gateway_type: String,
@@ -91,6 +101,53 @@ pub async fn stop_gateway(
     }
 }
 
+#[utoipa::path(
+    post,
+    path = "/gateway/restart",
+    request_body = RestartGatewayRequest,
+    responses(
+        (status = 200, description = "Gateway restarted"),
+        (status = 400, description = "Bad request", body = ErrorResponse),
+        (status = 404, description = "No saved config", body = ErrorResponse)
+    )
+)]
+pub async fn restart_gateway(
+    State(state): State<Arc<AppState>>,
+    Json(request): Json<RestartGatewayRequest>,
+) -> Response {
+    match state
+        .gateway_manager
+        .restart_gateway(&request.gateway_type)
+        .await
+    {
+        Ok(()) => StatusCode::OK.into_response(),
+        Err(e) => ErrorResponse::bad_request(e.to_string()).into_response(),
+    }
+}
+
+#[utoipa::path(
+    post,
+    path = "/gateway/remove",
+    request_body = RemoveGatewayRequest,
+    responses(
+        (status = 200, description = "Gateway removed"),
+        (status = 500, description = "Internal server error", body = ErrorResponse)
+    )
+)]
+pub async fn remove_gateway(
+    State(state): State<Arc<AppState>>,
+    Json(request): Json<RemoveGatewayRequest>,
+) -> Response {
+    match state
+        .gateway_manager
+        .remove_gateway(&request.gateway_type)
+        .await
+    {
+        Ok(()) => StatusCode::OK.into_response(),
+        Err(e) => ErrorResponse::internal(e.to_string()).into_response(),
+    }
+}
+
 #[utoipa::path(
     get,
     path = "/gateway/status",
@@ -159,6 +216,8 @@ pub fn routes(state: Arc<AppState>) -> Router {
     Router::new()
         .route("/gateway/start", post(start_gateway))
         .route("/gateway/stop", post(stop_gateway))
+        .route("/gateway/restart", post(restart_gateway))
+        .route("/gateway/remove", post(remove_gateway))
         .route("/gateway/status", get(gateway_status))
         .route("/gateway/pair", post(create_pairing_code))
         .route("/gateway/pair/{platform}/{user_id}", delete(unpair_user))

ui/desktop/src/components/settings/gateways/GatewaySettingsSection.tsx

@@ -23,6 +23,7 @@ interface PairedUserInfo {
 interface GatewayStatus {
   gateway_type: string;
   running: boolean;
+  configured: boolean;
   paired_users: PairedUserInfo[];
   info?: Record<string, string>;
 }
@@ -117,6 +118,40 @@ export default function GatewaySettingsSection() {
     }
   };
 
+  const handleRestartGateway = async (gatewayType: string) => {
+    setError(null);
+    try {
+      const response = await gatewayFetch('/gateway/restart', {
+        method: 'POST',
+        body: JSON.stringify({ gateway_type: gatewayType }),
+      });
+      if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.message || 'Failed to restart gateway');
+      }
+      await fetchStatus();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to restart gateway');
+    }
+  };
+
+  const handleRemoveGateway = async (gatewayType: string) => {
+    setError(null);
+    try {
+      const response = await gatewayFetch('/gateway/remove', {
+        method: 'POST',
+        body: JSON.stringify({ gateway_type: gatewayType }),
+      });
+      if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.message || 'Failed to remove gateway');
+      }
+      await fetchStatus();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to remove gateway');
+    }
+  };
+
   const handleGeneratePairingCode = async (gatewayType: string) => {
     setError(null);
     try {
@@ -183,6 +218,8 @@ export default function GatewaySettingsSection() {
         status={findGateway('telegram')}
         onStart={(config) => handleStartGateway('telegram', config)}
         onStop={() => handleStopGateway('telegram')}
+        onRestart={() => handleRestartGateway('telegram')}
+        onRemove={() => handleRemoveGateway('telegram')}
         onGenerateCode={() => handleGeneratePairingCode('telegram')}
         onUnpairUser={handleUnpairUser}
       />
@@ -245,22 +282,35 @@ function RunningBadge() {
   );
 }
 
+function StoppedBadge() {
+  return (
+    <span className="inline-flex items-center gap-1 text-xs text-yellow-700 dark:text-yellow-400 bg-yellow-100 dark:bg-yellow-900/30 px-2 py-0.5 rounded-full">
+      Stopped
+    </span>
+  );
+}
+
 function TelegramGatewayCard({
   status,
   onStart,
   onStop,
+  onRestart,
+  onRemove,
   onGenerateCode,
   onUnpairUser,
 }: {
   status: GatewayStatus | undefined;
   onStart: (config: Record<string, unknown>) => Promise<void>;
   onStop: () => void;
+  onRestart: () => void;
+  onRemove: () => void;
   onGenerateCode: () => void;
   onUnpairUser: (platform: string, userId: string) => void;
 }) {
   const [botToken, setBotToken] = useState('');
   const [starting, setStarting] = useState(false);
   const running = status?.running ?? false;
+  const configured = status?.configured ?? false;
 
   const handleStart = async () => {
     if (!botToken.trim()) return;
@@ -277,6 +327,7 @@ function TelegramGatewayCard({
           <CardTitle className="flex items-center gap-2">
             Telegram
             {running && <RunningBadge />}
+            {!running && configured && <StoppedBadge />}
           </CardTitle>
           {running && (
             <div className="flex items-center gap-2">
@@ -289,10 +340,25 @@ function TelegramGatewayCard({
               </Button>
             </div>
           )}
+          {!running && configured && (
+            <div className="flex items-center gap-2">
+              <Button size="sm" onClick={onRestart}>
+                Start
+              </Button>
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={onRemove}
+                className="text-text-muted hover:text-red-600"
+              >
+                <Trash2 className="h-3 w-3" />
+              </Button>
+            </div>
+          )}
         </div>
       </CardHeader>
       <CardContent className="pt-3 space-y-2">
-        {!running && (
+        {!running && !configured && (
           <>
             <div className="flex items-center gap-2">
               <Input