Function load_plugin_auth_store

crates/opencode-server/src/server.rs:343–418

(server_url: &str, auth_manager: Arc<AuthManager>)

}

async fn load_plugin_auth_store(server_url: &str, auth_manager: Arc<AuthManager>) {
    let cwd = match std::env::current_dir() {
        Ok(cwd) => cwd,
        Err(error) => {
            tracing::warn!(%error, "failed to get current directory for plugin bootstrap");
            return;
        }
    };

    let config = match load_config(&cwd) {
        Ok(config) => config,
        Err(error) => {
            tracing::warn!(%error, "failed to load config for plugin bootstrap");
            return;
        }
    };

    let loader = match PluginLoader::new() {
        Ok(loader) => Arc::new(loader),
        Err(error) => {
            tracing::warn!(%error, "failed to initialize plugin loader");
            return;
        }
    };
    init_global(loader.hook_system());

    let directory = cwd.to_string_lossy().to_string();
    let context = PluginContext {
        worktree: directory.clone(),
        directory,
        server_url: server_url.to_string(),
    };

    if let Err(error) = loader.load_builtins(&context).await {
        tracing::warn!(%error, "failed to load builtin auth plugins");
    }

    if !config.plugin.is_empty() {
        if let Err(error) = loader.load_all(&config.plugin, &context).await {
            tracing::warn!(%error, "failed to load configured plugins");
            return;
        }
    }

    routes::set_plugin_loader(loader.clone());

    let bridges = loader.auth_bridges().await;
    for (provider_id, bridge) in bridges {
        match bridge.load().await {
            Ok(result) => {
                sync_custom_fetch_proxy(&provider_id, bridge.clone(), result.has_custom_fetch);

                if let Some(api_key) = result.api_key {
                    auth_manager
                        .set(
                            &provider_id,
                            AuthInfo::Api {
                                key: api_key.clone(),