use serde::Deserialize;
use serde::Serialize;
use url::Url;
use crate::error::Error;
use crate::error::Result;
const BUILTIN_REGISTRY_TOML: &str = include_str!("../rules/providers.toml");
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "flow", rename_all = "snake_case")]
pub enum AuthMethod {
Oauth(OAuthConfig),
Device(DeviceCodeConfig),
ApiKey(ApiKeyConfig),
}
impl AuthMethod {
pub fn kind(&self) -> &'static str {
match self {
AuthMethod::Oauth(_) => "oauth",
AuthMethod::Device(_) => "device",
AuthMethod::ApiKey(_) => "api_key",
}
}
pub fn label(&self) -> &str {
match self {
AuthMethod::Oauth(c) => c.label.as_deref().unwrap_or("Sign in with browser"),
AuthMethod::Device(c) => c.label.as_deref().unwrap_or("Sign in with a device code"),
AuthMethod::ApiKey(c) => c.label.as_deref().unwrap_or("Paste an API key"),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct OAuthConfig {
pub authorize_url: String,
pub token_url: String,
pub client_id: String,
#[serde(default)]
pub scopes: Vec<String>,
#[serde(default)]
pub redirect_uri: Option<String>,
#[serde(default)]
pub loopback_port: Option<u16>,
#[serde(default)]
pub audience: Option<String>,
#[serde(default)]
pub prompt: Option<String>,
#[serde(default)]
pub login_hint: Option<String>,
#[serde(default)]
pub extra_authorize_params: Vec<(String, String)>,
#[serde(default)]
pub label: Option<String>,
}
impl OAuthConfig {
pub fn new(
authorize_url: impl Into<String>,
token_url: impl Into<String>,
client_id: impl Into<String>,
) -> Self {
Self {
authorize_url: authorize_url.into(),
token_url: token_url.into(),
client_id: client_id.into(),
..Self::default()
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct DeviceCodeConfig {
pub device_authorization_url: String,
pub token_url: String,
pub client_id: String,
#[serde(default)]
pub scopes: Vec<String>,
#[serde(default)]
pub label: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ApiKeyConfig {
#[serde(default)]
pub env_var: Option<String>,
#[serde(default)]
pub console_url: Option<String>,
#[serde(default)]
pub key_prefix: Option<String>,
#[serde(default)]
pub label: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Provider {
pub id: String,
pub display_name: String,
pub methods: Vec<AuthMethod>,
#[serde(default)]
pub note: Option<String>,
}
impl Provider {
pub fn oauth(&self) -> Option<&OAuthConfig> {
self.methods.iter().find_map(|m| match m {
AuthMethod::Oauth(c) => Some(c),
_ => None,
})
}
pub fn device(&self) -> Option<&DeviceCodeConfig> {
self.methods.iter().find_map(|m| match m {
AuthMethod::Device(c) => Some(c),
_ => None,
})
}
pub fn api_key(&self) -> Option<&ApiKeyConfig> {
self.methods.iter().find_map(|m| match m {
AuthMethod::ApiKey(c) => Some(c),
_ => None,
})
}
}
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct Registry {
#[serde(default, rename = "provider")]
providers: Vec<Provider>,
}
impl Registry {
pub fn builtin() -> Result<Self> {
Self::from_toml(BUILTIN_REGISTRY_TOML)
}
pub fn from_toml(toml_str: &str) -> Result<Self> {
let registry: Registry =
toml::from_str(toml_str).map_err(|e| Error::Registry(e.to_string()))?;
registry.validate()?;
Ok(registry)
}
pub fn merge(&mut self, other: Registry) {
for provider in other.providers {
if let Some(existing) = self.providers.iter_mut().find(|p| p.id == provider.id) {
*existing = provider;
} else {
self.providers.push(provider);
}
}
}
pub fn providers(&self) -> &[Provider] {
&self.providers
}
pub fn get(&self, id: &str) -> Option<&Provider> {
self.providers.iter().find(|p| p.id == id)
}
pub fn require(&self, id: &str) -> Result<&Provider> {
self.get(id)
.ok_or_else(|| Error::UnknownProvider(id.to_string()))
}
fn validate(&self) -> Result<()> {
let mut seen = std::collections::BTreeSet::new();
for provider in &self.providers {
if provider.id.trim().is_empty() {
return Err(Error::Registry("a provider has an empty id".into()));
}
if !seen.insert(provider.id.as_str()) {
return Err(Error::Registry(format!(
"duplicate provider id `{}`",
provider.id
)));
}
if provider.methods.is_empty() {
return Err(Error::Registry(format!(
"provider `{}` defines no auth methods",
provider.id
)));
}
let mut seen_kinds = std::collections::BTreeSet::new();
for method in &provider.methods {
let kind = method.kind();
if !seen_kinds.insert(kind) {
return Err(Error::Registry(format!(
"provider `{}` defines more than one `{}` method",
provider.id, kind
)));
}
match method {
AuthMethod::Oauth(c) => {
if c.authorize_url.is_empty()
|| c.token_url.is_empty()
|| c.client_id.is_empty()
{
return Err(Error::Registry(format!(
"provider `{}` oauth method is missing authorize_url/token_url/client_id",
provider.id
)));
}
validate_url(&c.authorize_url, &provider.id, "authorize_url")?;
validate_url(&c.token_url, &provider.id, "token_url")?;
if c.redirect_uri.is_some() && c.loopback_port.is_some() {
return Err(Error::Registry(format!(
"provider `{}` oauth method sets both redirect_uri and loopback_port",
provider.id
)));
}
if let Some(redirect_uri) = &c.redirect_uri {
validate_loopback_redirect_uri(redirect_uri, &provider.id)?;
}
}
AuthMethod::Device(c) => {
if c.device_authorization_url.is_empty()
|| c.token_url.is_empty()
|| c.client_id.is_empty()
{
return Err(Error::Registry(format!(
"provider `{}` device method is missing device_authorization_url/token_url/client_id",
provider.id
)));
}
validate_url(
&c.device_authorization_url,
&provider.id,
"device_authorization_url",
)?;
validate_url(&c.token_url, &provider.id, "token_url")?;
}
AuthMethod::ApiKey(_) => {}
}
}
}
Ok(())
}
}
pub(crate) fn validate_url(url: &str, provider_id: &str, field: &str) -> Result<()> {
let parsed = Url::parse(url).map_err(|e| {
Error::Registry(format!(
"provider `{provider_id}` {field} is not a valid URL: {e}"
))
})?;
if parsed.scheme() != "http" && parsed.scheme() != "https" {
return Err(Error::Registry(format!(
"provider `{provider_id}` {field} must use http or https, got `{}`",
parsed.scheme()
)));
}
if parsed.scheme() == "http" {
match parsed.host_str() {
Some("127.0.0.1" | "localhost" | "::1") => {}
other => {
return Err(Error::Registry(format!(
"provider `{provider_id}` {field} must use https (http is allowed only to loopback hosts, got {other:?})"
)));
}
}
}
Ok(())
}
fn validate_loopback_redirect_uri(redirect_uri: &str, provider_id: &str) -> Result<()> {
let parsed = Url::parse(redirect_uri).map_err(|e| {
Error::Registry(format!(
"provider `{provider_id}` redirect_uri is not a valid URL: {e}"
))
})?;
if parsed.scheme() != "http" {
return Err(Error::Registry(format!(
"provider `{provider_id}` redirect_uri must use http, got `{}`",
parsed.scheme()
)));
}
match parsed.host_str() {
Some("127.0.0.1") | Some("localhost") | Some("::1") | Some("[::1]") => {}
other => {
return Err(Error::Registry(format!(
"provider `{provider_id}` redirect_uri must point to 127.0.0.1, localhost, or [::1], got {other:?}"
)));
}
}
if parsed.port().is_none() {
return Err(Error::Registry(format!(
"provider `{provider_id}` redirect_uri must include an explicit port"
)));
}
Ok(())
}