repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
plugins/oauth/src/lib.rs
Raw//! Declarative public-client login (`SMH-SPEC-PLUG0001`, `SMH-SPEC-SPEC0001`).
#![deny(unsafe_code)]
#[expect(clippy::pedantic, reason = "wit-bindgen generates component ABI glue")]
#[allow(
unsafe_code,
reason = "wit-bindgen owns component ABI glue; no authored unsafe code"
)]
mod bindings {
wit_bindgen::generate!({ path: "../../wit/smith-plugin.wit", world: "oauth-world" });
use super::OAuth;
export!(OAuth with_types_in self);
}
use bindings::exports::smith::plugin::credential_source_v1::{
Guest as CredentialModuleGuest, GuestCredentialSource,
};
use bindings::exports::smith::plugin::plugin::{Guest as PluginGuest, ToolDeclaration};
use bindings::exports::smith::plugin::provider::{
CatalogSnapshot, DecodeStep, Guest as ProviderGuest, ProviderRequest, ProviderSettings,
RequestTemplate, SettingsProvenance,
};
use bindings::exports::smith::plugin::registration::{
CredentialSource, Guest as RegistrationGuest, Registrations,
};
use bindings::smith::plugin::secret_proxy::{self, LoginPolicy};
struct OAuth;
struct SelectedProfile {
profile: secret_proxy::ProfileRef,
policy: LoginPolicy,
}
impl CredentialModuleGuest for OAuth {
type CredentialSource = SelectedProfile;
}
impl GuestCredentialSource for SelectedProfile {
fn new(
profile: secret_proxy::ProfileRef,
fixture_issuer: Option<String>,
connection_id: String,
) -> Self {
Self {
profile,
policy: policy(fixture_issuer.as_deref(), &connection_id),
}
}
fn renew(&self) -> Result<secret_proxy::SecretRef, secret_proxy::AuthorizationFault> {
secret_proxy::renew(&self.profile, &self.policy)
}
}
fn policy(fixture_issuer: Option<&str>, connection_id: &str) -> LoginPolicy {
if connection_id == "google-gemini-cli-plan" {
return google_policy(fixture_issuer);
}
if connection_id == "anthropic-claude-plan" {
return LoginPolicy {
flow: secret_proxy::LoginFlow::FixedClientPkceOpaque,
connection_id: connection_id.into(),
issuer: fixture_issuer.unwrap_or("https://claude.ai").into(),
token_origin: fixture_issuer
.unwrap_or("https://platform.claude.com")
.into(),
audience: fixture_issuer.map_or_else(
|| "https://api.anthropic.com/v1".into(),
|issuer| format!("{issuer}/v1"),
),
initial_client: "9d1c250a-e61b-44d9-88ed-5944d1962f5e".into(),
issued_prefix: String::new(),
authorization_path: if fixture_issuer.is_some() {
"/authorize"
} else {
"/oauth/authorize"
}
.into(),
token_path: if fixture_issuer.is_some() {
"/token"
} else {
"/v1/oauth/token"
}
.into(),
agent_name: "Smith".into(),
scopes: [
"org:create_api_key",
"user:profile",
"user:inference",
"user:sessions:claude_code",
"user:mcp_servers",
"user:file_upload",
]
.into_iter()
.map(str::to_string)
.collect(),
required_scopes: vec!["user:inference".into()],
};
}
let (issuer, resource) = fixture_issuer.map_or_else(
|| {
(
"https://auth.openai.com".into(),
"https://api.openai.com/v1".into(),
)
},
|issuer| (issuer.to_string(), format!("{issuer}/v1")),
);
LoginPolicy {
flow: secret_proxy::LoginFlow::DynamicOidc,
connection_id: connection_id.into(),
token_origin: issuer.clone(),
issuer,
audience: resource,
initial_client: "dynamic_agent_client".into(),
issued_prefix: "oaiapp_".into(),
authorization_path: if fixture_issuer.is_some() {
"/authorize"
} else {
"/api/accounts/authorize"
}
.into(),
token_path: if fixture_issuer.is_some() {
"/token"
} else {
"/api/accounts/oauth/token"
}
.into(),
agent_name: "Smith".into(),
required_scopes: ["openid", "chatgpt.tokens.use.direct"]
.into_iter()
.map(str::to_string)
.collect(),
scopes: [
"openid",
"profile",
"email",
"offline_access",
"resource.invoke",
"chatgpt.tokens.use.direct",
]
.into_iter()
.map(str::to_string)
.collect(),
}
}
impl PluginGuest for OAuth {
fn declare_tools() -> Vec<ToolDeclaration> {
vec![ToolDeclaration {
name: "login".into(), description: "Continue with ChatGPT; host owns every credential".into(),
input_schema_json: r#"{"type":"object","properties":{"fixture_issuer":{"type":"string"},"provider":{"enum":["openai-chatgpt-plan","anthropic-claude-plan","google-gemini-cli-plan"]}},"additionalProperties":false}"#.into(),
}, ToolDeclaration {
name: "logout".into(), description: "End selected ChatGPT session; clear local tokens even if remote revocation is unconfirmed".into(),
input_schema_json: r#"{"type":"object","properties":{"profile":{"type":"string"}},"required":["profile"],"additionalProperties":false}"#.into(),
}]
}
fn invoke(name: String, input_json: String) -> Result<String, String> {
if !matches!(name.as_str(), "login" | "logout") || input_json.len() > 2048 {
return Err("invalid OAuth invocation".into());
}
let input: serde_json::Value =
serde_json::from_str(&input_json).map_err(|_| "invalid OAuth input")?;
if name == "logout" {
let profile = input["profile"]
.as_str()
.ok_or("logout requires an explicit profile")?;
return secret_proxy::end_session(&secret_proxy::ProfileRef { id: profile.into() })
.map(|confirmed| if confirmed { "remote revocation confirmed; local tokens cleared" } else { "remote revocation unconfirmed; local tokens cleared; disconnect the app in vendor account settings" }.into())
.map_err(|_| "OAuth session end failed".into());
}
let fixture_issuer = input
.get("fixture_issuer")
.filter(|issuer| !issuer.is_null())
.map(|issuer| issuer.as_str().ok_or("invalid fixture issuer"))
.transpose()?;
let connection_id = input
.get("provider")
.and_then(serde_json::Value::as_str)
.unwrap_or("openai-chatgpt-plan");
if !matches!(
connection_id,
"openai-chatgpt-plan" | "anthropic-claude-plan" | "google-gemini-cli-plan"
) {
return Err("unknown subscription connection".into());
}
secret_proxy::authorize(&policy(fixture_issuer, connection_id))
.map(|profile| profile.id)
.map_err(|_| "OAuth authorization failed".into())
}
}
impl RegistrationGuest for OAuth {
fn declare() -> Registrations {
Registrations {
credential_sources: vec![
CredentialSource {
id: "google-gemini-cli-plan@1".into(),
},
CredentialSource {
id: "openai-chatgpt-plan@1".into(),
},
CredentialSource {
id: "anthropic-claude-plan@1".into(),
},
],
providers: Vec::new(),
models: Vec::new(),
}
}
}
impl ProviderGuest for OAuth {
fn declare_settings() -> ProviderSettings {
ProviderSettings {
include_usage: true,
subscription: false,
provenance: SettingsProvenance::BuiltIn,
}
}
fn validate_settings(settings: ProviderSettings) -> Result<ProviderSettings, String> {
Ok(settings)
}
fn build_request(
_: String,
_: ProviderRequest,
_: ProviderSettings,
_: CatalogSnapshot,
) -> Result<RequestTemplate, String> {
Err("OAuth declares no provider codec".into())
}
fn decode_response(_: Vec<u8>, _: Vec<u8>, _: bool) -> Result<DecodeStep, String> {
Err("OAuth declares no provider codec".into())
}
}
fn google_policy(fixture_issuer: Option<&str>) -> LoginPolicy {
LoginPolicy {
flow: secret_proxy::LoginFlow::GoogleInstalledPkce,
connection_id: "google-gemini-cli-plan".into(),
issuer: fixture_issuer
.unwrap_or("https://accounts.google.com")
.into(),
token_origin: fixture_issuer
.unwrap_or("https://oauth2.googleapis.com")
.into(),
audience: fixture_issuer.map_or_else(
|| "https://cloudcode-pa.googleapis.com/v1internal".into(),
|issuer| format!("{issuer}/v1internal"),
),
initial_client: "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com"
.into(),
issued_prefix: String::new(),
authorization_path: if fixture_issuer.is_some() {
"/authorize"
} else {
"/o/oauth2/v2/auth"
}
.into(),
token_path: "/token".into(),
agent_name: "Smith".into(),
scopes: [
"https://www.googleapis.com/auth/cloud-platform",
"https://www.googleapis.com/auth/userinfo.email",
"https://www.googleapis.com/auth/userinfo.profile",
]
.into_iter()
.map(str::to_string)
.collect(),
required_scopes: vec!["https://www.googleapis.com/auth/cloud-platform".into()],
}
}