feat(gateway): operator allowlist for who can pair (#11979)

This commit is contained in:
Luki Zainur
2026-09-10 18:10:27 +00:00
committed by GitHub
parent 618d41ee2e
commit b795eb8fa7
3 changed files with 134 additions and 2 deletions
+4 -1
View File
@@ -2345,7 +2345,10 @@ async fn handle_gateway_command(command: GatewayCommand) -> Result<()> {
gateway_type,
bot_token,
} => {
let platform_config = serde_json::json!({ "bot_token": bot_token });
let mut platform_config = serde_json::json!({ "bot_token": bot_token });
if let Some(ids) = goose::gateway::manager::saved_allowed_user_ids(&gateway_type) {
platform_config["allowed_user_ids"] = serde_json::json!(ids);
}
gateway::handle_gateway_start(gateway_type, platform_config).await
}
GatewayCommand::Stop { gateway_type } => gateway::handle_gateway_stop(gateway_type).await,
+91 -1
View File
@@ -1,4 +1,4 @@
use std::collections::{HashMap, VecDeque};
use std::collections::{HashMap, HashSet, VecDeque};
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
@@ -60,6 +60,8 @@ pub struct GatewayHandler {
turn_locks: PerUserLocks,
/// Serializes confirmation replies without waiting for the active turn to finish.
confirmation_reply_locks: PerUserLocks,
/// When set, only platform user IDs in this list may enter the pairing flow.
allowed_user_ids: Option<HashSet<String>>,
}
impl GatewayHandler {
@@ -69,6 +71,7 @@ impl GatewayHandler {
gateway: Arc<dyn Gateway>,
config: GatewayConfig,
) -> Self {
let allowed_user_ids = allowed_user_ids_from_config(&config);
Self {
agent_manager,
pairing_store,
@@ -77,6 +80,7 @@ impl GatewayHandler {
pending_confirmations: Arc::new(Mutex::new(HashMap::new())),
turn_locks: Arc::new(Mutex::new(HashMap::new())),
confirmation_reply_locks: Arc::new(Mutex::new(HashMap::new())),
allowed_user_ids,
}
}
@@ -121,6 +125,15 @@ impl GatewayHandler {
}
pub async fn handle_message(&self, message: IncomingMessage) -> anyhow::Result<()> {
if !is_user_allowed(&self.allowed_user_ids, &message.user) {
tracing::info!(
platform = %message.user.platform,
user_id = %message.user.user_id,
"gateway allowlist denied unlisted user"
);
return Ok(());
}
let pairing = self.pairing_store.get(&message.user).await?;
match pairing {
@@ -825,6 +838,34 @@ fn gateway_working_dir(platform: &str, user_id: &str) -> PathBuf {
.join(user_id)
}
/// Operator-configured list of platform user IDs that may pair with the gateway,
/// read from `platform_config.allowed_user_ids`. An absent or empty list keeps
/// the default behavior of letting anyone attempt pairing.
fn allowed_user_ids_from_config(config: &GatewayConfig) -> Option<HashSet<String>> {
let ids: HashSet<String> = config.platform_config["allowed_user_ids"]
.as_array()
.into_iter()
.flatten()
.filter_map(|id| {
id.as_str()
.map(ToOwned::to_owned)
.or_else(|| id.as_u64().map(|n| n.to_string()))
})
.collect();
if ids.is_empty() {
None
} else {
Some(ids)
}
}
fn is_user_allowed(allowed: &Option<HashSet<String>>, user: &PlatformUser) -> bool {
match allowed {
None => true,
Some(ids) => ids.contains(&user.user_id),
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -851,4 +892,53 @@ mod tests {
fn gateway_override_used_when_global_unset() {
assert_eq!(resolve_gateway_max_turns(Some(25), None), 25);
}
fn platform_user(user_id: &str) -> PlatformUser {
PlatformUser {
platform: "telegram".to_string(),
user_id: user_id.to_string(),
display_name: None,
}
}
fn config_with_platform(platform_config: serde_json::Value) -> GatewayConfig {
GatewayConfig {
gateway_type: "telegram".to_string(),
platform_config,
max_sessions: 1,
}
}
#[test]
fn allowlist_absent_or_empty_allows_everyone() {
for platform_config in [
serde_json::json!({}),
serde_json::json!({"allowed_user_ids": []}),
] {
let allowed = allowed_user_ids_from_config(&config_with_platform(platform_config));
assert!(allowed.is_none());
assert!(is_user_allowed(&allowed, &platform_user("999999")));
}
}
#[test]
fn allowlist_admits_listed_and_blocks_unlisted_users() {
let config = config_with_platform(serde_json::json!({"allowed_user_ids": ["111", 222]}));
let allowed = allowed_user_ids_from_config(&config).expect("allowlist should be set");
assert_eq!(allowed.len(), 2);
assert!(is_user_allowed(
&Some(allowed.clone()),
&platform_user("111")
));
assert!(is_user_allowed(&Some(allowed), &platform_user("222")));
let allowed = allowed_user_ids_from_config(&config).expect("allowlist should be set");
assert!(!is_user_allowed(&Some(allowed), &platform_user("333")));
}
#[test]
fn allowlist_ignores_non_id_values() {
let config = config_with_platform(serde_json::json!({"allowed_user_ids": [true, null]}));
assert!(allowed_user_ids_from_config(&config).is_none());
}
}
+39
View File
@@ -23,6 +23,39 @@ fn secret_key_for(gateway_type: &str) -> String {
struct SavedGatewayEntry {
gateway_type: String,
max_sessions: usize,
#[serde(default)]
allowed_user_ids: Option<Vec<String>>,
}
/// Extract the operator allowlist from a platform_config value, if present.
fn allowed_user_ids_from_platform_config(
platform_config: &serde_json::Value,
) -> Option<Vec<String>> {
platform_config
.get("allowed_user_ids")
.and_then(|v| v.as_array())
.map(|ids| {
ids.iter()
.filter_map(|id| {
id.as_str()
.map(ToOwned::to_owned)
.or_else(|| id.as_u64().map(|n| n.to_string()))
})
.collect()
})
.filter(|ids: &Vec<String>| !ids.is_empty())
}
/// Operator allowlist saved for a gateway type, if any.
pub fn saved_allowed_user_ids(gateway_type: &str) -> Option<Vec<String>> {
let entries: Vec<SavedGatewayEntry> = match Config::global().get_param(GATEWAY_CONFIGS_KEY) {
Ok(entries) => entries,
Err(_) => return None,
};
entries
.into_iter()
.find(|entry| entry.gateway_type == gateway_type)
.and_then(|entry| entry.allowed_user_ids)
}
#[allow(dead_code)]
@@ -344,6 +377,11 @@ impl GatewayManager {
}
};
let mut platform_config = platform_config;
if let Some(ids) = &entry.allowed_user_ids {
platform_config["allowed_user_ids"] = serde_json::json!(ids);
}
configs.push(GatewayConfig {
gateway_type: entry.gateway_type,
platform_config,
@@ -372,6 +410,7 @@ impl GatewayManager {
entries.push(SavedGatewayEntry {
gateway_type: gw_config.gateway_type.clone(),
max_sessions: gw_config.max_sessions,
allowed_user_ids: allowed_user_ids_from_platform_config(&gw_config.platform_config),
});
config