feat(cli): Support Basic authentication in DENO_AUTH_TOKENS (#11910)

2 files changed, 99 insertions, 4 deletions

diff --git a/cli/auth_tokens.rs b/cli/auth_tokens.rs
index 83c97e641..c81c296f3 100644
--- a/cli/auth_tokens.rs
+++ b/cli/auth_tokens.rs
@@ -6,14 +6,26 @@ use log::error;
 use std::fmt;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AuthTokenData {
+  Bearer(String),
+  Basic { username: String, password: String },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct AuthToken {
   host: String,
-  token: String,
+  token: AuthTokenData,
 }
 
 impl fmt::Display for AuthToken {
   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "Bearer {}", self.token)
+    match &self.token {
+      AuthTokenData::Bearer(token) => write!(f, "Bearer {}", token),
+      AuthTokenData::Basic { username, password } => {
+        let credentials = format!("{}:{}", username, password);
+        write!(f, "Basic {}", base64::encode(credentials))
+      }
+    }
   }
 }
 
@@ -34,9 +46,22 @@ impl AuthTokens {
       for token_str in tokens_str.split(';') {
         if token_str.contains('@') {
           let pair: Vec<&str> = token_str.rsplitn(2, '@').collect();
-          let token = pair[1].to_string();
+          let token = pair[1];
           let host = pair[0].to_lowercase();
-          tokens.push(AuthToken { host, token });
+          if token.contains(':') {
+            let pair: Vec<&str> = token.rsplitn(2, ':').collect();
+            let username = pair[1].to_string();
+            let password = pair[0].to_string();
+            tokens.push(AuthToken {
+              host,
+              token: AuthTokenData::Basic { username, password },
+            })
+          } else {
+            tokens.push(AuthToken {
+              host,
+              token: AuthTokenData::Bearer(token.to_string()),
+            });
+          }
         } else {
           error!("Badly formed auth token discarded.");
         }
@@ -133,4 +158,26 @@ mod tests {
       "Bearer abc@123".to_string()
     );
   }
+
+  #[test]
+  fn test_auth_token_basic() {
+    let auth_tokens = AuthTokens::new(Some("abc:123@deno.land".to_string()));
+    let fixture = resolve_url("https://deno.land/x/mod.ts").unwrap();
+    assert_eq!(
+      auth_tokens.get(&fixture).unwrap().to_string(),
+      "Basic YWJjOjEyMw=="
+    );
+    let fixture = resolve_url("https://www.deno.land/x/mod.ts").unwrap();
+    assert_eq!(
+      auth_tokens.get(&fixture).unwrap().to_string(),
+      "Basic YWJjOjEyMw==".to_string()
+    );
+    let fixture = resolve_url("http://127.0.0.1:8080/x/mod.ts").unwrap();
+    assert_eq!(auth_tokens.get(&fixture), None);
+    let fixture =
+      resolve_url("https://deno.land.example.com/x/mod.ts").unwrap();
+    assert_eq!(auth_tokens.get(&fixture), None);
+    let fixture = resolve_url("https://deno.land:8080/x/mod.ts").unwrap();
+    assert_eq!(auth_tokens.get(&fixture), None);
+  }
 }
diff --git a/cli/tests/integration/mod.rs b/cli/tests/integration/mod.rs
index 7d13c7831..4ada4ef54 100644
--- a/cli/tests/integration/mod.rs
+++ b/cli/tests/integration/mod.rs
@@ -1077,6 +1077,54 @@ fn js_unit_tests() {
   assert!(status.success());
 }
 
+#[test]
+fn basic_auth_tokens() {
+  let _g = util::http_server();
+
+  let output = util::deno_cmd()
+    .current_dir(util::root_path())
+    .arg("run")
+    .arg("http://127.0.0.1:4554/001_hello.js")
+    .stdout(std::process::Stdio::piped())
+    .stderr(std::process::Stdio::piped())
+    .spawn()
+    .unwrap()
+    .wait_with_output()
+    .unwrap();
+
+  assert!(!output.status.success());
+
+  let stdout_str = std::str::from_utf8(&output.stdout).unwrap().trim();
+  assert!(stdout_str.is_empty());
+
+  let stderr_str = std::str::from_utf8(&output.stderr).unwrap().trim();
+  eprintln!("{}", stderr_str);
+
+  assert!(stderr_str.contains(
+    "Import 'http://127.0.0.1:4554/001_hello.js' failed: 404 Not Found"
+  ));
+
+  let output = util::deno_cmd()
+    .current_dir(util::root_path())
+    .arg("run")
+    .arg("http://127.0.0.1:4554/001_hello.js")
+    .env("DENO_AUTH_TOKENS", "testuser123:testpassabc@127.0.0.1:4554")
+    .stdout(std::process::Stdio::piped())
+    .stderr(std::process::Stdio::piped())
+    .spawn()
+    .unwrap()
+    .wait_with_output()
+    .unwrap();
+
+  let stderr_str = std::str::from_utf8(&output.stderr).unwrap().trim();
+  eprintln!("{}", stderr_str);
+
+  assert!(output.status.success());
+
+  let stdout_str = std::str::from_utf8(&output.stdout).unwrap().trim();
+  assert_eq!(util::strip_ansi_codes(stdout_str), "Hello World");
+}
+
 #[tokio::test]
 async fn listen_tls_alpn() {
   // TLS streams require the presence of an ambient local task set to gracefully