Use git to clone projects

This makes use of our askpass and should hopfully have better forge 
configuration

Author: Caleb-T-Owens

Cargo.lock

@@ -37,6 +37,7 @@ legacy = [
     "dep:gitbutler-operating-modes",
     "dep:gitbutler-sync",
     "dep:gitbutler-oplog",
+    "dep:gitbutler-git",
     "dep:but-action",
     "dep:but-hunk-assignment",
     "dep:but-hunk-dependency",
@@ -96,6 +97,7 @@ gitbutler-edit-mode = {workspace = true, optional = true}
 gitbutler-operating-modes = {workspace = true, optional = true}
 gitbutler-sync = {workspace = true, optional = true}
 gitbutler-oplog = {workspace = true, optional = true}
+gitbutler-git = {workspace = true, optional = true}
 
 tauri = { version = "^2.9.3", features = ["unstable"], optional = true } # For the #[tauri::command(async)] macro only
 

crates/but-api/Cargo.toml

@@ -1,4 +1,4 @@
-use std::{path::PathBuf, sync::atomic::AtomicBool};
+use std::path::PathBuf;
 
 use anyhow::{Context as _, Result};
 use but_api_macros::api_cmd_tauri;
@@ -12,6 +12,7 @@ use gitbutler_repo::{
     FileInfo, RepoCommands,
     hooks::{HookResult, MessageHookResult},
 };
+use gitbutler_repo_actions::askpass;
 use tracing::instrument;
 
 #[api_cmd_tauri]
@@ -38,13 +39,29 @@ pub fn check_signing_settings(project_id: ProjectId) -> Result<bool> {
 #[api_cmd_tauri]
 #[instrument(err(Debug))]
 pub fn git_clone_repository(repository_url: String, target_dir: PathBuf) -> Result<()> {
-    let should_interrupt = AtomicBool::new(false);
+    let url_for_context = repository_url.clone();
+
+    std::thread::spawn(move || {
+        tokio::runtime::Runtime::new()
+            .unwrap()
+            .block_on(gitbutler_git::clone(
+                &repository_url,
+                &target_dir,
+                gitbutler_git::tokio::TokioExecutor,
+                handle_git_prompt_clone,
+                url_for_context,
+            ))
+    })
+    .join()
+    .unwrap()
+    .map_err(|e| anyhow::anyhow!("{e}"))
+}
 
-    gix::prepare_clone(repository_url.as_str(), &target_dir)?
-        .fetch_then_checkout(gix::progress::Discard, &should_interrupt)
-        .map(|(checkout, _outcome)| checkout)?
-        .main_worktree(gix::progress::Discard, &should_interrupt)?;
-    Ok(())
+async fn handle_git_prompt_clone(prompt: String, url: String) -> Option<String> {
+    tracing::info!("received prompt for clone of {url}: {prompt:?}");
+    askpass::get_broker()
+        .submit_prompt(prompt, askpass::Context::Clone { url })
+        .await
 }
 
 #[api_cmd_tauri]

crates/but-api/src/legacy/repo.rs

@@ -28,5 +28,5 @@ pub use self::executor::tokio;
 pub use self::{
     error::Error,
     refspec::{Error as RefSpecError, RefSpec},
-    repository::{fetch, push, sign_commit},
+    repository::{clone, fetch, push, sign_commit},
 };

crates/gitbutler-git/src/lib.rs

@@ -1,6 +1,7 @@
 use std::{collections::HashMap, path::Path, time::Duration};
 
 use futures::{FutureExt, select};
+use gix::{bstr::ByteSlice, config::tree::Key};
 use rand::Rng;
 
 use super::executor::{AskpassServer, GitExecutor, Pid, Socket};
@@ -62,9 +63,16 @@ pub type Error<E> = RepositoryError<
     <<<E as GitExecutor>::ServerHandle as AskpassServer>::SocketHandle as Socket>::Error,
 >;
 
+enum HarnessEnv<P: AsRef<Path>> {
+    /// The contained P is the repo's path
+    Repo(P),
+    /// The contained P is the path that the command should be executed in
+    Global(P),
+}
+
 #[cold]
 async fn execute_with_auth_harness<P, F, Fut, E, Extra>(
-    repo_path: P,
+    harness_env: HarnessEnv<P>,
     executor: &E,
     args: &[&str],
     envs: Option<HashMap<String, String>>,
@@ -180,7 +188,7 @@ where
         .or_else(|| std::env::var("GIT_SSH").ok())
     {
         Some(v) => v,
-        None => get_core_sshcommand(&repo_path)
+        None => get_core_sshcommand(&harness_env)
             .ok()
             .flatten()
             .unwrap_or_else(|| "ssh".into()),
@@ -215,10 +223,13 @@ where
         ),
     );
 
+    let cwd = match harness_env {
+        HarnessEnv::Repo(p) | HarnessEnv::Global(p) => p,
+    };
     let mut child_process = core::pin::pin! {
         async {
             executor
-                .execute(args, repo_path, Some(envs))
+                .execute(args, cwd, Some(envs))
                 .await
                 .map_err(Error::<E>::Exec)
         }.fuse()
@@ -324,8 +335,15 @@ where
     args.push(remote);
     args.push(&refspec);
 
-    let (status, stdout, stderr) =
-        execute_with_auth_harness(repo_path, &executor, &args, None, on_prompt, extra).await?;
+    let (status, stdout, stderr) = execute_with_auth_harness(
+        HarnessEnv::Repo(repo_path),
+        &executor,
+        &args,
+        None,
+        on_prompt,
+        extra,
+    )
+    .await?;
 
     if status == 0 {
         Ok(())
@@ -399,8 +417,15 @@ where
         args.push(opt.as_str());
     }
 
-    let (status, stdout, stderr) =
-        execute_with_auth_harness(repo_path, &executor, &args, None, on_prompt, extra).await?;
+    let (status, stdout, stderr) = execute_with_auth_harness(
+        HarnessEnv::Repo(repo_path),
+        &executor,
+        &args,
+        None,
+        on_prompt,
+        extra,
+    )
+    .await?;
 
     if status == 0 {
         return Ok(stderr);
@@ -498,8 +523,15 @@ where
         "--allow-empty",
         "--allow-empty-message",
     ];
-    let (status, stdout, stderr) =
-        execute_with_auth_harness(&worktree_path, &executor, &args, None, on_prompt, extra).await?;
+    let (status, stdout, stderr) = execute_with_auth_harness(
+        HarnessEnv::Repo(&worktree_path),
+        &executor,
+        &args,
+        None,
+        on_prompt,
+        extra,
+    )
+    .await?;
     if status != 0 {
         return Err(Error::<E>::Failed {
             status,
@@ -549,9 +581,88 @@ where
     Ok(commit_hash)
 }
 
-fn get_core_sshcommand(cwd: impl AsRef<Path>) -> anyhow::Result<Option<String>> {
-    Ok(gix::open(cwd.as_ref())?
-        .config_snapshot()
-        .trusted_program(&gix::config::tree::Core::SSH_COMMAND)
-        .map(|program| program.to_string_lossy().into_owned()))
+fn get_core_sshcommand<P>(harness_env: &HarnessEnv<P>) -> anyhow::Result<Option<String>>
+where
+    P: AsRef<Path>,
+{
+    match harness_env {
+        HarnessEnv::Repo(repo_path) => Ok(gix::open(repo_path.as_ref())?
+            .config_snapshot()
+            .trusted_program(&gix::config::tree::Core::SSH_COMMAND)
+            .map(|program| program.to_string_lossy().into_owned())),
+        HarnessEnv::Global(_) => Ok(gix::config::File::from_globals()?
+            .string(gix::config::tree::Core::SSH_COMMAND.logical_name())
+            .map(|program| program.to_str_lossy().into_owned())),
+    }
+}
+
+/// Clones the given repository URL to the target directory.
+/// Any prompts for the user are passed to the asynchronous callback `on_prompt`,
+/// which should return the user's response or `None` if the operation should be
+/// aborted, in which case an `Err` value is returned from this function.
+///
+/// Unlike fetch/push, this function always uses the Git CLI regardless of any
+/// backend selection, as it needs to work before a repository exists.
+pub async fn clone<P, F, Fut, E, Extra>(
+    repository_url: &str,
+    target_dir: P,
+    executor: E,
+    on_prompt: F,
+    extra: Extra,
+) -> Result<(), crate::Error<Error<E>>>
+where
+    P: AsRef<Path>,
+    E: GitExecutor,
+    F: FnMut(String, Extra) -> Fut,
+    Fut: std::future::Future<Output = Option<String>>,
+    Extra: Send + Clone,
+{
+    let target_dir = target_dir.as_ref();
+
+    // For clone, we run from the parent directory of the target
+    let work_dir = target_dir.parent().unwrap_or(Path::new("."));
+
+    let target_dir_str = target_dir.to_string_lossy();
+    let args = vec!["clone", "--", repository_url, &target_dir_str];
+
+    let (status, stdout, stderr) = execute_with_auth_harness(
+        HarnessEnv::Global(work_dir),
+        &executor,
+        &args,
+        None,
+        on_prompt,
+        extra,
+    )
+    .await?;
+
+    if status == 0 {
+        Ok(())
+    } else if stderr.to_lowercase().contains("permission denied") {
+        Err(crate::Error::AuthorizationFailed(Error::<E>::Failed {
+            status,
+            args: args.into_iter().map(Into::into).collect(),
+            stdout,
+            stderr,
+        }))?
+    } else if stderr
+        .to_lowercase()
+        .contains("already exists and is not an empty directory")
+    {
+        Err(crate::Error::RemoteExists(
+            target_dir.display().to_string(),
+            Error::<E>::Failed {
+                status,
+                args: args.into_iter().map(Into::into).collect(),
+                stdout,
+                stderr,
+            },
+        ))?
+    } else {
+        Err(Error::<E>::Failed {
+            status,
+            args: args.into_iter().map(Into::into).collect(),
+            stdout,
+            stderr,
+        })?
+    }
 }

crates/gitbutler-git/src/repository.rs

@@ -47,6 +47,7 @@ pub enum Context {
     Push { branch_id: Option<StackId> },
     Fetch { action: String },
     SignedCommit { branch_id: Option<StackId> },
+    Clone { url: String },
 }
 
 #[derive(Clone)]