//! 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, connection_id: String, ) -> Self { Self { profile, policy: policy(fixture_issuer.as_deref(), &connection_id), } } fn renew(&self) -> Result { 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 { 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 { 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 { Ok(settings) } fn build_request( _: String, _: ProviderRequest, _: ProviderSettings, _: CatalogSnapshot, ) -> Result { Err("OAuth declares no provider codec".into()) } fn decode_response(_: Vec, _: Vec, _: bool) -> Result { 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()], } }