Luigit
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()],
    }
}