//! Durable CLI login through the sealed public credential effect (`SMH-SPEC-PLUG0001`). use super::{LoginAuthority, LoginFlow, LoginPolicy, ProfileStore}; use crate::plugins::{Capability, PluginManifest}; use crate::storage::StorageWorker; use crate::wasm::{PluginEngine, PluginGeneration, PluginRegistry}; use smith::config::Config; use smith::error::{Result, SmithError}; use smith::structured::ToolArguments; use smith_core::tools::{ToolDispatcher, ToolEffectContext, ToolSession}; use std::path::{Path, PathBuf}; use std::sync::Arc; use std::sync::mpsc::Receiver; /// Explicit subscription connection; never an API-key billing mode. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum SubscriptionProvider { /// Verified dynamic `OpenAI` registration. OpenAi, /// Fixed-client Claude subscription with local opaque profile identity. Anthropic, /// Google installed-app OAuth and Code Assist project admission. Google, } impl SubscriptionProvider { /// Stable host connection namespace. #[must_use] pub const fn connection_id(self) -> &'static str { match self { Self::OpenAi => "openai-chatgpt-plan", Self::Anthropic => "anthropic-claude-plan", Self::Google => "google-gemini-cli-plan", } } pub(crate) const fn source(self) -> &'static str { match self { Self::OpenAi => "openai-chatgpt-plan@1", Self::Anthropic => "anthropic-claude-plan@1", Self::Google => "google-gemini-cli-plan@1", } } pub(crate) const fn consumer(self) -> &'static str { match self { Self::OpenAi => "smith:protocol-openai-responses/openai-chatgpt-plan", Self::Anthropic => "smith:protocol-anthropic/anthropic-claude-plan", Self::Google => "smith:protocol-google/google-gemini-cli-plan", } } pub(super) const fn endpoint(self) -> &'static str { match self { Self::OpenAi => "https://api.openai.com", Self::Anthropic => "https://api.anthropic.com", Self::Google => "https://cloudcode-pa.googleapis.com", } } } impl ToolDispatcher for PluginRegistry { fn begin_provider_round(&mut self) -> Result { self.snapshot() } fn invoke( &mut self, name: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { let input = serde_json::to_string(input).map_err(|_| fault("OAuth input serialization failed"))?; self.invoke_with_effects(name, &input, effects) } } /// Select an isolated profile namespace; fixture issuers can never open production profiles. /// /// # Errors /// Rejects fixture authorities except literal `127.0.0.1` HTTP origins. pub fn profile_store(fixture_issuer: Option<&str>) -> Result { profile_store_for(SubscriptionProvider::OpenAi, fixture_issuer) } /// Open only the selected subscription connection's isolated profile namespace. /// # Errors /// Rejects non-loopback fixture authorities. pub fn profile_store_for( provider: SubscriptionProvider, fixture_issuer: Option<&str>, ) -> Result { let root = store_root(fixture_issuer)?; Ok(ProfileStore::at(match provider { SubscriptionProvider::OpenAi => root, SubscriptionProvider::Anthropic | SubscriptionProvider::Google => { root.join(provider.connection_id()) } })) } fn store_root(fixture_issuer: Option<&str>) -> Result { let root = smith::config::auth_dir(); match fixture_issuer { None => Ok(root.join("oauth")), Some(issuer) => { super::validate_origin(issuer).map_err(fault)?; if !issuer.starts_with("http://127.0.0.1:") { return Err(fault("fixture issuer must be literal HTTP IPv4 loopback")); } Ok(root .join("oauth-fixtures") .join(smith::sha256::digest_hex(issuer.as_bytes()))) } } } pub(super) fn authority_for( provider: SubscriptionProvider, fixture_issuer: Option<&str>, profile: Option<&str>, ) -> Result { authority_at_for( provider, fixture_issuer, profile, profile_store_for(provider, fixture_issuer)?, ) } pub(super) fn authority_at_for( provider: SubscriptionProvider, fixture_issuer: Option<&str>, profile: Option<&str>, store: ProfileStore, ) -> Result { if provider == SubscriptionProvider::Google { let policy = google_policy(fixture_issuer); return selected_authority(policy, store, profile); } if provider == SubscriptionProvider::Anthropic { let policy = LoginPolicy { flow: LoginFlow::FixedClientPkceOpaque, connection_id: provider.connection_id().into(), issuer: fixture_issuer.unwrap_or("https://claude.ai").into(), token_origin: fixture_issuer .unwrap_or("https://platform.claude.com") .into(), resource: 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()], }; return selected_authority(policy, store, profile); } let issuer = fixture_issuer.unwrap_or("https://auth.openai.com"); let resource = fixture_issuer.map_or_else( || "https://api.openai.com/v1".to_string(), |issuer| format!("{issuer}/v1"), ); let policy = LoginPolicy { flow: super::LoginFlow::DynamicOidc, connection_id: "openai-chatgpt-plan".into(), token_origin: issuer.to_string(), issuer: issuer.to_string(), 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(), }; selected_authority(policy, store, profile) } fn selected_authority( policy: LoginPolicy, store: ProfileStore, profile: Option<&str>, ) -> Result { let authority = LoginAuthority::new(policy, store).map_err(fault)?; match profile { Some(id) => authority.select_profile(id).map_err(fault), None => Ok(authority), } } /// Continue with `ChatGPT` through the sealed guest and durable admission. /// # Errors /// Rejects invalid authority, component, storage, or authorization outcomes. pub fn run( provider: SubscriptionProvider, journal: &Path, fixture_issuer: Option<&str>, profile: Option<&str>, project: Option<&str>, interrupt: Receiver<()>, stop_interrupt: impl FnOnce() -> Result<()>, ) -> Result { let authority = authority_for(provider, fixture_issuer, profile)?; let authority = match project { Some(project) => authority.with_google_project(project).map_err(fault)?, None => authority, }; let mut interrupt_worker = None; let result = run_operation( provider, journal, fixture_issuer, authority, "login", Some(interrupt), &mut interrupt_worker, ); let stopped = stop_interrupt(); let joined = interrupt_worker.map_or(Ok(()), |worker| { worker .join() .map_err(|_| fault("OAuth interrupt worker failed")) }); let output = result?; stopped?; joined?; Ok(output) } /// End one explicitly selected session through the public OAuth guest effect. /// # Errors /// Rejects missing profile, failed durable admission, or failed local token clearing. pub fn end_session( provider: SubscriptionProvider, journal: &Path, fixture_issuer: Option<&str>, profile: &str, ) -> Result { let mut interrupt_worker = None; run_operation( provider, journal, fixture_issuer, authority_for(provider, fixture_issuer, Some(profile))?, "logout", None, &mut interrupt_worker, ) } fn run_operation( provider: SubscriptionProvider, journal: &Path, fixture_issuer: Option<&str>, authority: LoginAuthority, operation: &str, interrupt: Option>, interrupt_worker: &mut Option>, ) -> Result { let profile = authority .selected .as_ref() .map(|profile| profile.id.clone()); let engine = PluginEngine::new()?; let manifest = PluginManifest::parse( "id \"smith:oauth\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_oauth.wasm\"\ncapability \"secret-proxy\"", )?; let mut generation = PluginGeneration::load_embedded( &engine, manifest, include_bytes!(concat!(env!("OUT_DIR"), "/smith_plugin_oauth.wasm")), &[Capability::SecretProxy], )?; generation.configure_login_authority(authority); let mut registry = PluginRegistry::default(); registry.publish_all(vec![generation])?; let storage = Arc::new(StorageWorker::start(journal.to_path_buf())); storage.open(Config::default_valid())?; let description = format!("{operation} {}", provider.connection_id()); let admission = storage.admit_foreground(&description, None)?; let root = admission.work.receipt.submission_id; let session = storage.claim(root)?; let append = Arc::clone(&storage); let completion = Arc::clone(&storage); let working_dir = journal .parent() .ok_or_else(|| fault("OAuth journal parent missing"))?; let mut tools = ToolSession::with_persist(working_dir, session, move |entry, bytes| { append.append(smith_core::session::EntryFrame { id: entry.id, parent: entry.parent, timestamp_ms: entry.timestamp_ms, kind: entry.kind, content: bytes.to_vec(), }) }) .with_completion_boundary(root, move |frame| completion.commit_completion(frame)); tools.set_dispatcher(Box::new(registry)); storage.register_cancel(root, tools.cancel_handle())?; if let Some(interrupt) = interrupt { let cancellation = Arc::clone(&storage); *interrupt_worker = Some(std::thread::spawn(move || { if interrupt.recv().is_ok() { let _abort = cancellation.abort(Some(root)); } })); } tools.begin_provider_round()?; let input = if operation == "logout" { serde_json::json!({"profile":profile}) } else { let mut input = serde_json::json!({"provider":provider.connection_id()}); if let Some(issuer) = fixture_issuer { input["fixture_issuer"] = serde_json::json!(issuer); } input }; let arguments = ToolArguments::from_serializable(&input).map_err(|_| fault("OAuth arguments invalid"))?; let result = tools.invoke(&format!("smith:oauth/{operation}"), &arguments); let reason = result .as_ref() .ok() .map(|_| smith::stream::StopReason::EndTurn); storage.settle(smith_core::frame::Frame::Settlement { submission_id: root, reason, output: None, })?; result.map(|outcome| outcome.output) } fn fault(message: &str) -> SmithError { SmithError::Config { field: "oauth".into(), message: message.into(), } } fn google_policy(fixture_issuer: Option<&str>) -> LoginPolicy { LoginPolicy { flow: 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(), resource: 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()], } }