upload: add support for oauth based sessions when app password is not supplied

upload/src/main.rs

···
 use clap::{ArgAction, Parser};
-use jacquard::api::com_atproto::repo::apply_writes::{self, ApplyWrites, ApplyWritesWritesItem};
-use jacquard::atproto;
+use jacquard::api::com_atproto::repo::apply_writes::{
+  self, ApplyWrites, ApplyWritesOutput, ApplyWritesWritesItem,
+};
 use jacquard::client::MemorySessionStore;
-use jacquard::prelude::XrpcClient;
+use jacquard::client::{AgentSessionExt};
+use jacquard::oauth::loopback::LoopbackConfig;
+use jacquard::oauth::types::AuthorizeOptions;
 use jacquard::types::string::{AtStrError, RecordKey, Rkey};
+use jacquard::{atproto, oauth};
 use jacquard::{
   Data,
   api::com_atproto::{self, repo::list_records::ListRecords},
···
   types::{ident::AtIdentifier, nsid::Nsid, string::AtprotoStr, uri::Uri},
   xrpc::XrpcExt,
 };
-use miette::{ErrReport, IntoDiagnostic, Result};
+use miette::{IntoDiagnostic, Result};
 use std::{collections::HashMap, fs, path::PathBuf};
 
 use crate::sitemap::{BlobRef, Sitemap, SitemapNode};
···
 mod sitemap;
 mod utils;
 
-#[derive(Parser, Debug)]
+#[derive(Parser, Debug, Clone)]
 #[command(version, about, long_about = None)]
 struct Config {
   /// Handle or DID to authenticate
-  #[arg(verbatim_doc_comment, short, long)]
+  #[arg(verbatim_doc_comment)]
   user: String,
+
   /// App password to authenticate the client
   /// Normal passwords also work but are not advised
-  #[arg(verbatim_doc_comment, short, long)]
-  password: String,
+  /// If ommited, oauth will be used instead
+  /// Oauth is reccomended where possible.
+  #[arg(verbatim_doc_comment, short = 'p', long = "password")]
+  password: Option<String>,
 
   /// Include dotfiles in upload
   /// Default: false
···
   dir: PathBuf,
 }
 
-#[tokio::main]
-async fn main() -> Result<(), miette::Error> {
-  env_logger::init();
-  // get config items
-  let config = Config::parse();
-
-  // get local site info
-  let local_sitemap = sitemap::local_sitemap(config.dir, config.all_files, config.git_ignore)?;
-
-  // create session
-  let client = JacquardResolver::default();
-  let store = MemorySessionStore::default();
-  let session = CredentialSession::new(store.into(), client.into());
-
-  let auth = session
-    .login(config.user.into(), config.password.into(), None, None, None)
-    .await?;
-  println!("Authenticated as {}", auth.did);
-
-
-  let agent = Agent::from(session);
-
+async fn live_records(agent: &impl AgentSessionExt, config: Config) -> Result<Vec<String>> {
   // find live site records
   let mut cursor = None;
   let mut remote_records = Vec::new();
+  let user = config.user.clone();
+  let user = if user.contains(":") {
+    AtIdentifier::Did(user.into())
+  } else {
+    AtIdentifier::Handle(user.into())
+  };
   loop {
     let req = com_atproto::repo::list_records::ListRecords::new()
       .collection(
         Nsid::new("dev.atcities.route").expect("failed to generate dev.atcities.route nsid"),
       )
-      .repo(AtIdentifier::Did(auth.did.clone()))
+      .repo(user.clone())
       .limit(100)
       .maybe_cursor(cursor)
       .build();
···
       break;
     }
   }
+  Ok(remote_records)
+}
 
+async fn upload_site_blobs(
+  agent: &impl AgentSessionExt,
+  _config: Config,
+  local_sitemap: Sitemap,
+) -> Result<Sitemap> {
   // upload local site blobs
   let mut new_sitemap: Sitemap = HashMap::new();
   for (k, v) in local_sitemap {
···
       }
     };
     let blob = fs::read(blob).into_diagnostic()?;
-    // let res = agent
-    //   .upload_blob(blob, v.mime_type.clone().into())
-    //   .await?;
 
     let req = com_atproto::repo::upload_blob::UploadBlob::new()
       .body(blob.into())
···
     );
   }
 
+  Ok(new_sitemap)
+}
+
+async fn update_remote_site(
+  agent: &impl AgentSessionExt,
+  config: Config,
+  remote_records: Vec<String>,
+  new_sitemap: Sitemap,
+) -> Result<ApplyWritesOutput<'static>> {
   // batch delete/upload records
   let mut writes = Vec::new();
   let mut delete_records = remote_records
···
   writes.append(&mut create_records);
 
   let req = com_atproto::repo::apply_writes::ApplyWrites::new()
-    .repo(AtIdentifier::Did(auth.did.clone()))
+    .repo(AtIdentifier::Did(config.user.into()))
     .writes(writes)
     .build();
 
···
     .await?
     .into_output()?;
 
-  println!("res: {res:#?}");
+  Ok(res)
+}
+
+#[tokio::main]
+async fn main() -> Result<(), miette::Error> {
+  env_logger::init();
+  // get config items
+  let config = Config::parse();
+
+  // get local site info
+  let local_sitemap =
+    sitemap::local_sitemap(config.dir.clone(), config.all_files, config.git_ignore)?;
+
+  // create session
+  if let Some(password) = config.password.clone() {
+    let password = password.into();
+    let client = JacquardResolver::default();
+    let store = MemorySessionStore::default();
+    let session = CredentialSession::new(store.into(), client.into());
+
+    let _ = session
+      .login(config.user.clone().into(), password, None, None, None)
+      .await?;
+
+    let agent = Agent::from(session);
+
+    let remote_sitemap = live_records(&agent, config.clone()).await?;
+    let new_sitemap = upload_site_blobs(&agent, config.clone(), local_sitemap).await?;
+    let writes_output =
+      update_remote_site(&agent, config.clone(), remote_sitemap, new_sitemap).await?;
+    println!("{writes_output:#?}");
+  } else {
+    let oauth = oauth::client::OAuthClient::with_memory_store();
+    let session = oauth
+      .login_with_local_server(
+        config.user.clone(),
+        AuthorizeOptions::default(),
+        LoopbackConfig::default(),
+      )
+      .await?;
+
+    let agent = Agent::from(session);
+
+    let remote_sitemap = live_records(&agent, config.clone()).await?;
+    let new_sitemap = upload_site_blobs(&agent, config.clone(), local_sitemap).await?;
+    let writes_output =
+      update_remote_site(&agent, config.clone(), remote_sitemap, new_sitemap).await?;
+    println!("{writes_output:#?}");
+  };
 
   Ok(())
 }