Function completion_grpc_client

crates/openshell-cli/src/completers.rs:88–131

(
    server: &str,
    gateway_name: &str,
)

}

async fn completion_grpc_client(
    server: &str,
    gateway_name: &str,
) -> Option<OpenShellClient<InterceptedService<Channel, EdgeAuthInterceptor>>> {
    let mut tls_opts = TlsOptions::default().with_gateway_name(gateway_name);
    tls_opts.gateway_insecure = std::env::var("OPENSHELL_GATEWAY_INSECURE")
        .is_ok_and(|v| !v.is_empty() && v != "0" && v != "false");

    if let Ok(meta) = load_gateway_metadata(gateway_name) {
        match meta.auth_mode.as_deref() {
            Some("oidc") => {
                if let Some(bundle) = load_oidc_token(gateway_name) {
                    if is_token_expired(&bundle) {
                        match oidc_refresh_token(&bundle, tls_opts.gateway_insecure).await {
                            Ok(refreshed) => {
                                let _ = store_oidc_token(gateway_name, &refreshed);
                                tls_opts.oidc_token = Some(refreshed.access_token);
                            }
                            Err(_) => {
                                tls_opts.oidc_token = Some(bundle.access_token);
                            }
                        }
                    } else {
                        tls_opts.oidc_token = Some(bundle.access_token);
                    }
                }
            }
            Some("cloudflare_jwt") => {
                if let Some(token) = load_edge_token(gateway_name) {
                    tls_opts.edge_token = Some(token);
                }
            }
            _ => {}
        }
    }

    let channel = build_channel(server, &tls_opts).await.ok()?;
    let interceptor = EdgeAuthInterceptor::new(
        tls_opts.oidc_token.as_deref(),
        tls_opts.edge_token.as_deref(),
    )
    .ok()?;
    Some(OpenShellClient::with_interceptor(channel, interceptor))
}

/// Run an async future on a dedicated thread to avoid nested tokio runtime panics.
///