Remove gitbutler-git based signing

It's not used and creates a new worktree just to sign a single commit.
If we need proper askpass support, we can implement it differently.

And as a matter of fact, we do need it, but when we do that we might
want to overhaul/port the whole system.

Author: Byron

crates/gitbutler-git/src/executor/tokio/mod.rs

@@ -75,16 +75,6 @@ unsafe impl super::GitExecutor for TokioExecutor {
 
         debug_log_sanitised_git_cmd(&mut cmd);
 
-        #[cfg(test)]
-        {
-            eprintln!(
-                "\n\n GIT STDOUT:\n\n{}\n\nGIT STDERR:\n\n{}\n\nGIT EXIT CODE: {}\n",
-                String::from_utf8_lossy(&output.stdout),
-                String::from_utf8_lossy(&output.stderr),
-                output.status.code().unwrap_or(127) as usize
-            );
-        }
-
         if !output.status.success() {
             tracing::error!(
                 ?cmd,

crates/gitbutler-git/src/lib.rs

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

crates/gitbutler-git/src/repository.rs

@@ -87,7 +87,6 @@ where
 {
     let mut current_exe = std::env::current_exe().map_err(Error::<E>::NoSelfExe)?;
     current_exe = current_exe.canonicalize().unwrap_or(current_exe);
-    tracing::trace!(?current_exe);
 
     // TODO(qix-): Get parent PID of connecting processes to make sure they're us.
     //let our_pid = std::process::id();
@@ -461,125 +460,6 @@ where
     Err(base_error.into())
 }
 
-/// Signs the given commit-ish in the repository at the given path.
-/// Returns the newly signed commit SHA.
-///
-/// 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.
-pub async fn sign_commit<P, E, F, Extra, Fut>(
-    repo_path: P,
-    executor: E,
-    base_commitish: String,
-    on_prompt: F,
-    extra: Extra,
-) -> Result<String, 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 repo_path = repo_path.as_ref();
-
-    // First, create a worktree to perform the commit.
-    let worktree_path = repo_path
-        .join(".git")
-        .join("gitbutler")
-        .join(".wt")
-        .join(uuid::Uuid::new_v4().to_string());
-    let args = [
-        "worktree",
-        "add",
-        "--detach",
-        "--no-checkout",
-        worktree_path.to_str().unwrap(),
-        base_commitish.as_str(),
-    ];
-    let (status, stdout, stderr) = executor
-        .execute(&args, repo_path, None)
-        .await
-        .map_err(Error::<E>::Exec)?;
-    if status != 0 {
-        return Err(Error::<E>::Failed {
-            status,
-            args: args.into_iter().map(Into::into).collect(),
-            stdout,
-            stderr,
-        })?;
-    }
-
-    // Now, perform the commit.
-    let args = [
-        "commit",
-        "--amend",
-        "-S",
-        "-o",
-        "--no-edit",
-        "--no-verify",
-        "--no-post-rewrite",
-        "--allow-empty",
-        "--allow-empty-message",
-    ];
-    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,
-            args: args.into_iter().map(Into::into).collect(),
-            stdout,
-            stderr,
-        })?;
-    }
-
-    // Get the commit hash that was generated
-    let args = ["rev-parse", "--verify", "HEAD"];
-    let (status, stdout, stderr) = executor
-        .execute(&args, &worktree_path, None)
-        .await
-        .map_err(Error::<E>::Exec)?;
-    if status != 0 {
-        return Err(Error::<E>::Failed {
-            status,
-            args: args.into_iter().map(Into::into).collect(),
-            stdout,
-            stderr,
-        })?;
-    }
-
-    let commit_hash = stdout.trim().to_string();
-
-    // Finally, remove the worktree
-    let args = [
-        "worktree",
-        "remove",
-        "--force",
-        worktree_path.to_str().unwrap(),
-    ];
-    let (status, stdout, stderr) = executor
-        .execute(&args, repo_path, None)
-        .await
-        .map_err(Error::<E>::Exec)?;
-    if status != 0 {
-        return Err(Error::<E>::Failed {
-            status,
-            args: args.into_iter().map(Into::into).collect(),
-            stdout,
-            stderr,
-        })?;
-    }
-
-    Ok(commit_hash)
-}
-
 fn get_core_sshcommand<P>(harness_env: &HarnessEnv<P>) -> anyhow::Result<Option<String>>
 where
     P: AsRef<Path>,

crates/gitbutler-repo-actions/src/askpass.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, path::Path, sync::Arc};
+use std::{collections::HashMap, sync::Arc};
 
 use gitbutler_stack::StackId;
 use serde::Serialize;
@@ -93,43 +93,3 @@ impl AskpassBroker {
         }
     }
 }
-
-async fn handle_git_prompt_commit_sign_sync(
-    prompt: String,
-    branch_id: Option<StackId>,
-) -> Option<String> {
-    tracing::info!("received prompt for synchronous signed commit {branch_id:?}: {prompt:?}");
-    get_broker()
-        .submit_prompt(prompt, Context::SignedCommit { branch_id })
-        .await
-}
-
-/// Utility to synchronously sign a commit.
-/// Uses the Tokio runner to run the async function,
-/// and the global askpass broker to handle any prompts.
-pub fn sign_commit_sync(
-    repo_path: impl AsRef<Path>,
-    base_commitish: impl AsRef<str>,
-    branch_id: Option<StackId>,
-) -> Result<String, impl std::error::Error> {
-    let repo_path = repo_path.as_ref().to_path_buf();
-    let base_commitish: &str = base_commitish.as_ref();
-    let base_commitish = base_commitish.to_string();
-
-    // Run as sync
-    let handle = std::thread::spawn(move || {
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()
-            .unwrap()
-            .block_on(gitbutler_git::sign_commit(
-                &repo_path,
-                gitbutler_git::tokio::TokioExecutor,
-                base_commitish,
-                handle_git_prompt_commit_sign_sync,
-                branch_id,
-            ))
-    });
-
-    tokio::task::block_in_place(|| handle.join().unwrap())
-}