remote tasks

codex-rs/cloud-tasks/src/bin/envcheck.rs

@@ -0,0 +1,141 @@
+#![deny(clippy::unwrap_used, clippy::expect_used)]
+
+use base64::Engine;
+use clap::Parser;
+use codex_core::config::find_codex_home;
+use codex_core::default_client::get_codex_user_agent;
+use codex_login::AuthManager;
+use codex_login::AuthMode;
+use reqwest::header::AUTHORIZATION;
+use reqwest::header::HeaderMap;
+use reqwest::header::HeaderName;
+use reqwest::header::HeaderValue;
+
+#[derive(Debug, Parser)]
+#[command(version, about = "Resolve Codex environment id (debug helper)")]
+struct Args {
+    /// Optional override for environment id; if present we just echo it.
+    #[arg(long = "env-id")]
+    environment_id: Option<String>,
+    /// Optional label to select a matching environment (case-insensitive exact match).
+    #[arg(long = "env-label")]
+    environment_label: Option<String>,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let args = Args::parse();
+
+    // Base URL (default to ChatGPT backend API) with normalization
+    let mut base_url = std::env::var("CODEX_CLOUD_TASKS_BASE_URL")
+        .unwrap_or_else(|_| "https://chatgpt.com/backend-api".to_string());
+    while base_url.ends_with('/') {
+        base_url.pop();
+    }
+    if (base_url.starts_with("https://chatgpt.com")
+        || base_url.starts_with("https://chat.openai.com"))
+        && !base_url.contains("/backend-api")
+    {
+        base_url = format!("{}/backend-api", base_url);
+    }
+    println!("base_url: {base_url}");
+    println!(
+        "path_style: {}",
+        if base_url.contains("/backend-api") {
+            "wham"
+        } else {
+            "codex-api"
+        }
+    );
+
+    // Build headers: UA + ChatGPT auth if available
+    let ua = get_codex_user_agent(Some("codex_cloud_tasks_envcheck"));
+    let mut headers = HeaderMap::new();
+    headers.insert(
+        reqwest::header::USER_AGENT,
+        HeaderValue::from_str(&ua).unwrap_or(HeaderValue::from_static("codex-cli")),
+    );
+
+    // Locate CODEX_HOME and try to load ChatGPT auth
+    if let Ok(home) = find_codex_home() {
+        println!("codex_home: {}", home.display());
+        let authm = AuthManager::new(
+            home,
+            AuthMode::ChatGPT,
+            "codex_cloud_tasks_envcheck".to_string(),
+        );
+        if let Some(auth) = authm.auth() {
+            match auth.get_token().await {
+                Ok(token) if !token.is_empty() => {
+                    println!("auth: ChatGPT token present ({} chars)", token.len());
+                    let value = format!("Bearer {}", token);
+                    if let Ok(hv) = HeaderValue::from_str(&value) {
+                        headers.insert(AUTHORIZATION, hv);
+                    }
+                    if let Some(account_id) = auth
+                        .get_account_id()
+                        .or_else(|| extract_chatgpt_account_id(&token))
+                    {
+                        println!("auth: ChatGPT-Account-Id: {account_id}");
+                        if let Ok(name) = HeaderName::from_bytes(b"ChatGPT-Account-Id") {
+                            if let Ok(hv) = HeaderValue::from_str(&account_id) {
+                                headers.insert(name, hv);
+                            }
+                        }
+                    }
+                }
+                Ok(_) => println!("auth: ChatGPT token empty"),
+                Err(e) => println!("auth: failed to load ChatGPT token: {e}"),
+            }
+        } else {
+            println!("auth: no ChatGPT auth.json");
+        }
+    } else {
+        println!("codex_home: <not found>");
+    }
+
+    // If user supplied an environment id, just echo it and exit.
+    if let Some(id) = args.environment_id {
+        println!("env: provided env-id={id}");
+        return Ok(());
+    }
+
+    // Auto-detect environment id using shared env_detect
+    match codex_cloud_tasks::env_detect::autodetect_environment_id(
+        &base_url,
+        &headers,
+        args.environment_label,
+    )
+    .await
+    {
+        Ok(sel) => {
+            println!(
+                "env: selected environment_id={} label={}",
+                sel.id,
+                sel.label.unwrap_or_else(|| "<none>".to_string())
+            );
+            Ok(())
+        }
+        Err(e) => {
+            println!("env: failed: {e}");
+            std::process::exit(2)
+        }
+    }
+}
+
+fn extract_chatgpt_account_id(token: &str) -> Option<String> {
+    // JWT: header.payload.signature
+    let mut parts = token.split('.');
+    let (_h, payload_b64, _s) = match (parts.next(), parts.next(), parts.next()) {
+        (Some(h), Some(p), Some(s)) if !h.is_empty() && !p.is_empty() && !s.is_empty() => (h, p, s),
+        _ => return None,
+    };
+    let payload_bytes = base64::engine::general_purpose::URL_SAFE_NO_PAD
+        .decode(payload_b64)
+        .ok()?;
+    let v: serde_json::Value = serde_json::from_slice(&payload_bytes).ok()?;
+    v.get("https://api.openai.com/auth")
+        .and_then(|auth| auth.get("chatgpt_account_id"))
+        .and_then(|id| id.as_str())
+        .map(|s| s.to_string())
+}