Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(git): remember HTTPS credentials in the app secret store (#321)

arookieofce85ffa2ae8e7
diff --git a/crates/ide-core/src/event.rs b/crates/ide-core/src/event.rs
index 95fcca2c7..1261a0774 100644
--- a/crates/ide-core/src/event.rs
+++ b/crates/ide-core/src/event.rs
@@ -115,6 +115,8 @@ pub enum IdeEvent {
id: u64,
prompt: String,
kind: AskpassKind,
+ /// The dialog offers "Remember" for the answer (git HTTPS passwords).
+ remember: bool,
},
/// Prompt `id` was answered (in any window) or gave up.
AskpassDone {
diff --git a/crates/ide-ssh/src/askpass.rs b/crates/ide-ssh/src/askpass.rs
index 8e84d7d3e..e5414f3de 100644
--- a/crates/ide-ssh/src/askpass.rs
+++ b/crates/ide-ssh/src/askpass.rs
@@ -16,6 +16,7 @@ use std::sync::mpsc;
use std::time::Duration;
pub const PORT_ENV: &str = "OPENIDEA_ASKPASS_PORT";
+pub const COMMAND_ENV: &str = "OPENIDEA_GIT_COMMAND_ID";
pub const TOKEN_ENV: &str = "OPENIDEA_ASKPASS_TOKEN";
/// An unanswered prompt fails after this long.
const ANSWER_TIMEOUT: Duration = Duration::from_secs(300);
@@ -40,8 +41,16 @@ pub fn classify(prompt: &str) -> AskpassKind {
}
}
+/// Whether the UI's credential dialog should offer to remember the answer:
+/// git's HTTPS password prompts only (the user name travels inside them).
+pub fn remembers(prompt: &str) -> bool {
+ crate::git_creds::prompt_key(prompt).is_some() && classify(prompt) == AskpassKind::Secret
+}
+
#[derive(Serialize, Deserialize)]
struct Request {
+ #[serde(default)]
+ command_id: Option<u64>,
token: String,
prompt: String,
}
@@ -51,7 +60,13 @@ struct Response {
answer: Option<String>,
}
-type Pending = Arc<Mutex<HashMap<u64, mpsc::Sender<Option<String>>>>>;
+type Pending = Arc<Mutex<HashMap<u64, PendingPrompt>>>;
+
+struct PendingPrompt {
+ command_id: Option<u64>,
+ prompt: String,
+ tx: mpsc::Sender<Option<String>>,
+}
/// Serves prompts to `on_prompt`; answers come back through [`AskpassServer::answer`].
pub struct AskpassServer {
@@ -85,10 +100,17 @@ impl AskpassServer {
Ok(Self { port, token, exe, pending })
}
- /// Answers prompt `id` (`None`: cancelled).
- pub fn answer(&self, id: u64, answer: Option<String>) {
- if let Some(tx) = self.pending.lock().remove(&id) {
- let _ = tx.send(answer);
+ /// Answers prompt `id` (`None`: cancelled). `remember` asks the git
+ /// credential store to keep the answer once the command succeeds.
+ pub fn answer(&self, id: u64, answer: Option<String>, remember: bool) {
+ if let Some(p) = self.pending.lock().remove(&id) {
+ if let Some(a) = answer.as_deref()
+ && let Some(command_id) = p.command_id
+ && let Some(store) = crate::git_creds::get()
+ {
+ store.answered(command_id, &p.prompt, a, remember);
+ }
+ let _ = p.tx.send(answer);
}
}
@@ -123,9 +145,20 @@ fn serve(
let answer = if req.token != token {
None
} else {
- let (tx, rx) = mpsc::channel();
- pending.lock().insert(id, tx);
let prompt = req.prompt.trim().to_owned();
+ // A saved git HTTPS credential answers silently; a rejected one is
+ // forgotten by `git_creds::command_finished`, not here (the command
+ // may still be running and could retry).
+ if let Some(command_id) = req.command_id
+ && let Some(store) = crate::git_creds::get()
+ && let Some(answer) = store.answer_saved(command_id, &prompt)
+ {
+ let mut out = stream;
+ let _ = writeln!(out, "{}", serde_json::to_string(&Response { answer: Some(answer) }).unwrap_or_default());
+ return;
+ }
+ let (tx, rx) = mpsc::channel();
+ pending.lock().insert(id, PendingPrompt { command_id: req.command_id, prompt: prompt.clone(), tx });
on_prompt(AskpassPrompt { id, kind: classify(&prompt), prompt });
let answer = rx.recv_timeout(ANSWER_TIMEOUT).ok().flatten();
pending.lock().remove(&id);
@@ -156,9 +189,10 @@ pub fn run_helper() -> Option<i32> {
let port: u16 = std::env::var(PORT_ENV).ok()?.parse().ok()?;
let token = std::env::var(TOKEN_ENV).unwrap_or_default();
let prompt = std::env::args().nth(1).unwrap_or_else(|| "Password:".into());
+ let command_id = std::env::var(COMMAND_ENV).ok().and_then(|id| id.parse().ok());
let ask = || -> std::io::Result<Option<String>> {
let mut stream = TcpStream::connect(("127.0.0.1", port))?;
- writeln!(stream, "{}", serde_json::to_string(&Request { token, prompt }).unwrap_or_default())?;
+ writeln!(stream, "{}", serde_json::to_string(&Request { command_id, token, prompt }).unwrap_or_default())?;
let mut line = String::new();
BufReader::new(stream).read_line(&mut line)?;
Ok(serde_json::from_str::<Response>(&line).ok().and_then(|r| r.answer))
@@ -196,8 +230,12 @@ mod tests {
let token = server.token.clone();
let client = std::thread::spawn(move || {
let mut stream = TcpStream::connect(("127.0.0.1", port)).unwrap();
- writeln!(stream, "{}", serde_json::to_string(&Request { token, prompt: "Password: ".into() }).unwrap())
- .unwrap();
+ writeln!(
+ stream,
+ "{}",
+ serde_json::to_string(&Request { command_id: Some(42), token, prompt: "Password: ".into() }).unwrap()
+ )
+ .unwrap();
let mut line = String::new();
BufReader::new(stream).read_line(&mut line).unwrap();
serde_json::from_str::<Response>(&line).unwrap().answer
@@ -209,7 +247,8 @@ mod tests {
}
std::thread::sleep(Duration::from_millis(5));
};
- server.answer(id, Some("hunter2".into()));
+ assert_eq!(server.pending.lock().get(&id).unwrap().command_id, Some(42));
+ server.answer(id, Some("hunter2".into()), false);
assert_eq!(client.join().unwrap().as_deref(), Some("hunter2"));
assert!(server.env().iter().any(|(k, v)| k == "SSH_ASKPASS" && v == "helper"));
}
diff --git a/crates/ide-ssh/src/git_creds.rs b/crates/ide-ssh/src/git_creds.rs
new file mode 100644
index 000000000..bdc818e13
--- /dev/null
+++ b/crates/ide-ssh/src/git_creds.rs
@@ -0,0 +1,379 @@
+//! Saved git HTTPS credentials, in the app's own secret store (next to the SSH
+//! passwords), never in git's global configuration. Answers to askpass prompts
+//! are remembered only after the git command that used them succeeded, and a
+//! stored credential that fails authentication is forgotten so the next command
+//! asks again.
+
+use crate::secrets::SecretFile;
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+/// A stored credential: `user` answered `Username for …`, `secret` the password.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GitCredential {
+ pub user: String,
+ pub secret: String,
+}
+
+/// What [`GitCredentials::lookup`] decided for a prompt.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum GitAnswer {
+ /// Answer the prompt with this text without asking the user.
+ Auto(String),
+ /// Nothing stored; the dialog may offer to remember a new credential.
+ PromptNew,
+}
+
+/// Shared store: a [`SecretFile`] of `scheme://host[:port]` → `user\nsecret`, plus the
+/// state of each git command currently running (credentials it consumed and
+/// answers to save when it succeeds).
+#[derive(Clone)]
+pub struct GitCredentials {
+ saved: Arc<SecretFile>,
+ sessions: Arc<Mutex<HashMap<u64, Session>>>,
+}
+
+#[derive(Default)]
+struct Session {
+ /// Stored credentials this command used (possibly wrong): forgotten if the
+ /// command fails with an authentication error.
+ used: HashMap<String, GitCredential>,
+ /// `scheme://host[:port]` → credential the user asked to remember: written when the
+ /// command succeeds.
+ pending: HashMap<String, GitCredential>,
+}
+
+/// Global instance: the askpass server and every `git` child process agree on it.
+static INSTANCE: Mutex<Option<GitCredentials>> = Mutex::new(None);
+
+/// Installs the store of `path` (the app's data directory). Called once at
+/// start-up; git prompts before that are simply not remembered.
+pub fn init(path: PathBuf) {
+ *INSTANCE.lock() = Some(GitCredentials { saved: Arc::new(SecretFile::new(path)), sessions: Arc::default() });
+}
+
+/// The installed store, if start-up got that far.
+pub fn get() -> Option<GitCredentials> {
+ INSTANCE.lock().clone()
+}
+
+/// `scheme://host[:port]` of an HTTPS prompt (`Username for 'https://host'` /
+/// `Password for 'https://user@host'`); `None` for anything else (SSH prompts,
+/// passphrases, host-key questions — none of git's business here).
+pub fn prompt_key(prompt: &str) -> Option<String> {
+ let quoted = prompt.split('\'').nth(1)?;
+ let (scheme, rest) = quoted.split_once("://")?;
+ if !matches!(scheme, "http" | "https") {
+ return None;
+ }
+ let authority = rest.split('/').next()?;
+ // `user@host` (possibly with a password): keep the host part only.
+ let host = authority.rsplit('@').next()?;
+ if host.is_empty() {
+ return None;
+ }
+ Some(format!("{scheme}://{host}"))
+}
+
+/// The user name embedded in a password prompt (`https://user@host`), if any.
+/// Git URL-encodes it (`%40` for `@`), which a lookup must match.
+fn prompt_user(prompt: &str) -> Option<String> {
+ let quoted = prompt.split('\'').nth(1)?;
+ let authority = quoted.split_once("://")?.1.split('/').next()?;
+ let (user, _) = authority.rsplit_once('@')?;
+ let user = user.split(':').next()?;
+ (!user.is_empty()).then(|| user.to_owned())
+}
+
+/// `stderr` of a failed git command says the stored credential was rejected.
+fn is_auth_failure(stderr: &str) -> bool {
+ let s = stderr.to_ascii_lowercase();
+ s.contains("authentication failed")
+ || s.contains("authentication unsuccessful")
+ || s.contains("invalid username or password")
+ || s.contains("access denied")
+ || s.contains("authorization failed")
+ || s.contains("could not read username")
+ || s.contains("could not read password")
+ || s.contains("the requested url returned error: 403")
+ || s.contains("the requested url returned error: 401")
+}
+
+impl GitCredentials {
+ /// The stored credential for `key` (`scheme://host[:port]`).
+ pub fn credential(&self, key: &str) -> Option<GitCredential> {
+ let raw = self.saved.get(key)?;
+ let (user, secret) = raw.split_once('\n')?;
+ Some(GitCredential { user: user.to_owned(), secret: secret.to_owned() })
+ }
+
+ /// What to do with a git HTTPS `prompt`: answer it from the store or show
+ /// the dialog.
+ /// `None`: not a git HTTPS credential prompt.
+ pub fn lookup(&self, prompt: &str) -> Option<GitAnswer> {
+ let key = prompt_key(prompt)?;
+ let wants_user = prompt.to_ascii_lowercase().starts_with("username");
+ match self.credential(&key) {
+ Some(c) => {
+ // The password prompt carries the user name git will send: a
+ // mismatch means the stored entry belongs to another account.
+ let answer = if wants_user {
+ Some(c.user)
+ } else {
+ prompt_user(prompt).is_none_or(|u| u == c.user).then_some(c.secret)
+ };
+ Some(answer.map_or(GitAnswer::PromptNew, GitAnswer::Auto))
+ }
+ None => Some(GitAnswer::PromptNew),
+ }
+ }
+
+ /// The stored answer to `prompt`; `None` falls through to the UI prompt.
+ /// Only a consumed *password* marks `key` as used — a stored user name
+ /// alone proves nothing about the credential's validity.
+ pub fn answer_saved(&self, command_id: u64, prompt: &str) -> Option<String> {
+ let key = prompt_key(prompt)?;
+ let mut sessions = self.sessions.lock();
+ let credential = self.credential(&key)?;
+ if prompt.to_ascii_lowercase().starts_with("username") {
+ return Some(credential.user);
+ }
+ if prompt_user(prompt).is_some_and(|user| user != credential.user) {
+ return None;
+ }
+ let answer = credential.secret.clone();
+ sessions.entry(command_id).or_default().used.insert(key, credential);
+ Some(answer)
+ }
+
+ /// The user's `answer` to `prompt`, remembered when the current git command
+ /// succeeds (`remember` = the dialog's "Remember" checkbox). Records the
+ /// key only for pending saves: a re-typed answer does not consume the
+ /// stored credential, so an auth failure must not delete it.
+ pub fn answered(&self, command_id: u64, prompt: &str, answer: &str, remember: bool) {
+ if !remember {
+ return;
+ }
+ let Some(key) = prompt_key(prompt) else { return };
+ let mut sessions = self.sessions.lock();
+ let s = sessions.entry(command_id).or_default();
+ let wants_user = prompt.to_ascii_lowercase().starts_with("username");
+ let entry = s.pending.entry(key).or_insert(GitCredential { user: String::new(), secret: String::new() });
+ if wants_user {
+ entry.user = answer.to_owned();
+ } else {
+ entry.secret = answer.to_owned();
+ // The password prompt carries the user name git will send.
+ if entry.user.is_empty()
+ && let Some(u) = prompt_user(prompt)
+ {
+ entry.user = u;
+ }
+ }
+ }
+
+ /// Called when a git child process exits: on success, writes the remembered
+ /// credentials and marks used ones as verified; on an authentication
+ /// failure, forgets every credential the command consumed so the next run
+ /// asks again instead of looping on a wrong password.
+ pub fn command_finished(&self, command_id: u64, success: bool, stderr: &str) {
+ let mut sessions = self.sessions.lock();
+ let Some(session) = sessions.remove(&command_id) else { return };
+ if success {
+ for (key, c) in session.pending {
+ if c.secret.is_empty() {
+ continue; // a lone user name is not a credential
+ }
+ if let Err(e) = self.saved.set(&key, &format!("{}\n{}", c.user, c.secret)) {
+ tracing::warn!("git credentials: {}", e.message);
+ }
+ }
+ } else if is_auth_failure(stderr) {
+ // `used` holds exactly the keys whose stored password was sent.
+ for (key, used) in session.used {
+ if self.credential(&key).as_ref() == Some(&used) {
+ self.saved.delete(&key);
+ }
+ }
+ }
+ }
+
+ /// Settings › Git: `scheme://host[:port]` entries with a saved credential.
+ pub fn list(&self) -> Vec<String> {
+ self.saved.keys()
+ }
+
+ /// Forgets the credential of `key` (Settings › Git › Clear, or a remote edit).
+ pub fn forget(&self, key: &str) {
+ self.saved.delete(key);
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn store() -> (tempfile::TempDir, GitCredentials) {
+ let tmp = tempfile::tempdir().unwrap();
+ let path = tmp.path().join("git-credentials.json");
+ (tmp, GitCredentials { saved: Arc::new(SecretFile::new(path)), sessions: Arc::default() })
+ }
+
+ #[test]
+ fn parses_https_prompts() {
+ assert_eq!(prompt_key("Username for 'https://github.com': ").as_deref(), Some("https://github.com"));
+ assert_eq!(prompt_key("Password for 'https://[email protected]': ").as_deref(), Some("https://github.com"));
+ assert_eq!(
+ prompt_key("Password for 'https://user%[email protected]:8443/x': ").as_deref(),
+ Some("https://example.com:8443")
+ );
+ assert_eq!(prompt_key("[email protected]'s password: "), None);
+ assert_eq!(prompt_key("Enter passphrase for key '/u/.ssh/id_ed25519': "), None);
+ }
+
+ #[test]
+ fn saves_only_after_success_and_answers_silently() {
+ let (_t, c) = store();
+ // First run: prompts the user, who checks "remember".
+ assert_eq!(c.lookup("Username for 'https://github.com': "), Some(GitAnswer::PromptNew));
+ c.answered(1, "Username for 'https://github.com': ", "me", true);
+ c.answered(1, "Password for 'https://[email protected]': ", "secret", true);
+ // A failure before the password is verified saves nothing.
+ c.command_finished(1, false, "fatal: some other error");
+ assert_eq!(c.lookup("Username for 'https://github.com': "), Some(GitAnswer::PromptNew));
+
+ c.answered(1, "Username for 'https://github.com': ", "me", true);
+ c.answered(1, "Password for 'https://[email protected]': ", "secret", true);
+ c.command_finished(1, true, "");
+ // Second run: no prompts at all.
+ assert_eq!(c.lookup("Username for 'https://github.com': "), Some(GitAnswer::Auto("me".into())));
+ assert_eq!(c.lookup("Password for 'https://[email protected]': "), Some(GitAnswer::Auto("secret".into())));
+ }
+
+ #[test]
+ fn forgets_a_rejected_credential() {
+ let (_t, c) = store();
+ c.answered(1, "Username for 'https://github.com': ", "me", true);
+ c.answered(1, "Password for 'https://[email protected]': ", "wrong", true);
+ c.command_finished(1, true, "");
+ // The next command consumes the stored credential silently.
+ assert_eq!(c.answer_saved(1, "Username for 'https://github.com': ").as_deref(), Some("me"));
+ assert_eq!(c.answer_saved(1, "Password for 'https://[email protected]': ").as_deref(), Some("wrong"));
+ c.command_finished(
+ 1,
+ false,
+ "remote: Invalid username or password.\nfatal: Authentication failed for 'https://github.com/x.git/'",
+ );
+ assert_eq!(c.lookup("Username for 'https://github.com': "), Some(GitAnswer::PromptNew));
+ }
+
+ #[test]
+ fn lists_and_forgets() {
+ let (_t, c) = store();
+ c.answered(1, "Username for 'https://a.example.com': ", "u", true);
+ c.answered(1, "Password for 'https://[email protected]': ", "p", true);
+ c.answered(1, "Username for 'https://b.example.com': ", "u", true);
+ c.answered(1, "Password for 'https://[email protected]': ", "p", true);
+ c.command_finished(1, true, "");
+ assert_eq!(c.list(), vec!["https://a.example.com", "https://b.example.com"]);
+ c.forget("https://a.example.com");
+ assert_eq!(c.list(), vec!["https://b.example.com"]);
+ }
+ #[test]
+ fn interleaved_commands_do_not_share_pending_or_used_credentials() {
+ for failure_first in [false, true] {
+ let (_t, c) = store();
+ let old = "Password for 'https://[email protected]:8443': ";
+ let new = "Password for 'https://[email protected]:8443': ";
+ c.answered(1, old, "rejected", true);
+ c.command_finished(1, true, "");
+
+ assert_eq!(c.answer_saved(2, old).as_deref(), Some("rejected"));
+ c.answered(3, new, "verified", true);
+ c.command_finished(4, true, "");
+ assert!(c.credential("https://new.example:8443").is_none());
+ assert!(c.credential("https://old.example:8443").is_some());
+ if failure_first {
+ c.command_finished(2, false, "fatal: Authentication failed");
+ assert!(c.credential("https://new.example:8443").is_none());
+ c.command_finished(3, true, "");
+ } else {
+ c.command_finished(3, true, "");
+ assert!(c.credential("https://old.example:8443").is_some());
+ c.command_finished(2, false, "fatal: Authentication failed");
+ }
+ assert!(c.credential("https://old.example:8443").is_none());
+ assert_eq!(c.credential("https://new.example:8443").unwrap().secret, "verified");
+ assert!(c.sessions.lock().is_empty());
+ }
+ }
+
+ #[test]
+ fn unrelated_success_does_not_save_an_unverified_password() {
+ let (_t, c) = store();
+ c.answered(1, "Password for 'https://[email protected]': ", "wrong", true);
+ c.command_finished(2, true, "");
+ assert!(c.list().is_empty());
+ c.command_finished(1, false, "HTTP Basic: Access denied");
+ assert!(c.list().is_empty());
+ assert!(c.sessions.lock().is_empty());
+ }
+
+ #[test]
+ fn stale_failure_does_not_delete_a_newly_verified_password() {
+ let (_t, c) = store();
+ let prompt = "Password for 'https://[email protected]': ";
+ c.answered(1, prompt, "old", true);
+ c.command_finished(1, true, "");
+ c.answer_saved(2, prompt).unwrap();
+ c.answered(3, prompt, "new", true);
+ c.command_finished(3, true, "");
+ c.command_finished(2, false, "Authentication failed");
+ assert_eq!(c.answer_saved(4, prompt).as_deref(), Some("new"));
+ }
+
+ #[test]
+ fn ports_and_ipv6_are_distinct_credential_keys() {
+ for (url, key) in [
+ ("http://[email protected]:8080/repo", "http://example.com:8080"),
+ ("https://[email protected]:8443/repo", "https://example.com:8443"),
+ ("https://me@[::1]:8443/repo", "https://[::1]:8443"),
+ ("https://[::1]/repo", "https://[::1]"),
+ ] {
+ assert_eq!(prompt_key(&format!("Password for '{url}': ")).as_deref(), Some(key));
+ }
+ let (_t, c) = store();
+ c.answered(1, "Password for 'https://[email protected]:8443': ", "secret", true);
+ c.command_finished(1, true, "");
+ assert!(c.answer_saved(2, "Password for 'https://[email protected]:9443': ").is_none());
+ assert!(c.answer_saved(2, "Password for 'https://[email protected]': ").is_none());
+ }
+
+ #[test]
+ fn recognizes_auth_errors_without_matching_arbitrary_numbers() {
+ for message in [
+ "fatal: Authentication failed",
+ "Authentication unsuccessful",
+ "Invalid username or password",
+ "HTTP Basic: Access denied",
+ "Authorization failed",
+ "fatal: could not read Username for 'https://example.com'",
+ "fatal: could not read Password for 'https://example.com'",
+ "fatal: unable to access: The requested URL returned error: 401",
+ "fatal: unable to access: The requested URL returned error: 403",
+ ] {
+ assert!(is_auth_failure(message), "{message}");
+ }
+ for message in [
+ "Failed to connect to example.com port 4010",
+ "Could not resolve host: server403.example",
+ "fatal: repository '/repo/401' does not exist",
+ "remote: error in commit abc403def",
+ "The requested URL returned error: 500",
+ ] {
+ assert!(!is_auth_failure(message), "{message}");
+ }
+ }
+}
diff --git a/crates/ide-ssh/src/lib.rs b/crates/ide-ssh/src/lib.rs
index ec8627011..1ab25a185 100644
--- a/crates/ide-ssh/src/lib.rs
+++ b/crates/ide-ssh/src/lib.rs
@@ -3,6 +3,7 @@
//! processes, SFTP, local port forwarding, and askpass for `ssh` / `git`.
pub mod askpass;
+pub mod git_creds;
pub mod manager;
pub mod secrets;
pub mod session;
diff --git a/crates/ide-ssh/src/secrets.rs b/crates/ide-ssh/src/secrets.rs
index 0e869dfaa..4cd6a9cb8 100644
--- a/crates/ide-ssh/src/secrets.rs
+++ b/crates/ide-ssh/src/secrets.rs
@@ -39,6 +39,12 @@ impl SecretFile {
}
}
+ /// Every stored key, sorted (the secrets themselves stay private).
+ pub fn keys(&self) -> Vec<String> {
+ let _g = self.lock.lock();
+ self.read().into_keys().collect()
+ }
+
fn read(&self) -> BTreeMap<String, String> {
match std::fs::read(&self.path) {
Ok(bytes) => serde_json::from_slice(&bytes).unwrap_or_else(|e| {
diff --git a/crates/ide-vcs/src/cli.rs b/crates/ide-vcs/src/cli.rs
index 1f2e9f08a..1ff173dc6 100644
--- a/crates/ide-vcs/src/cli.rs
+++ b/crates/ide-vcs/src/cli.rs
@@ -27,6 +27,48 @@ pub fn set_askpass_env(env: Vec<(String, String)>) {
*ASKPASS.write().unwrap_or_else(|e| e.into_inner()) = env;
}
+/// Called once per git child with its id, success flag, and stderr.
+pub type GitCommandObserver = std::sync::Arc<dyn Fn(u64, bool, &str) + Send + Sync>;
+
+static COMMAND_OBSERVER: std::sync::RwLock<Option<(&'static str, GitCommandObserver)>> = std::sync::RwLock::new(None);
+
+/// Installs the completion observer and the environment variable carrying each
+/// child's unique id to its credential helper.
+pub fn set_git_command_observer(env_name: &'static str, observer: GitCommandObserver) {
+ *COMMAND_OBSERVER.write().unwrap_or_else(|e| e.into_inner()) = Some((env_name, observer));
+}
+
+struct CommandSession {
+ id: u64,
+ observer: Option<GitCommandObserver>,
+}
+
+impl CommandSession {
+ fn start(cmd: &mut Command) -> Self {
+ static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+ let id = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+ let hook = COMMAND_OBSERVER.read().unwrap_or_else(|e| e.into_inner()).clone();
+ let observer = hook.map(|(env_name, observer)| {
+ cmd.env(env_name, id.to_string());
+ observer
+ });
+ Self { id, observer }
+ }
+
+ fn finish(&mut self, success: bool, stderr: &str) {
+ if let Some(observer) = self.observer.take() {
+ observer(self.id, success, stderr);
+ }
+ }
+}
+
+impl Drop for CommandSession {
+ fn drop(&mut self) {
+ // Cancellation or an I/O error discards only this child's pending answers.
+ self.finish(false, "");
+ }
+}
+
/// Locates the auto-detected git executable once per process.
///
/// GUI apps on macOS start with a minimal `PATH`, so a few well-known install
@@ -143,6 +185,7 @@ pub(crate) fn run_raw_env(
.stdout(Stdio::piped())
.stderr(Stdio::piped());
tracing::debug!(?args, "git");
+ let mut session = CommandSession::start(&mut cmd);
let mut child = cmd.spawn().map_err(spawn_error)?;
let writer = match (stdin, child.stdin.take()) {
(Some(data), Some(mut pipe)) => {
@@ -158,6 +201,7 @@ pub(crate) fn run_raw_env(
if let Some(w) = writer {
let _ = w.join();
}
+ session.finish(out.status.success(), &String::from_utf8_lossy(&out.stderr));
Ok(Output { stdout: out.stdout, stderr: out.stderr, code: out.status.code() })
}
@@ -274,6 +318,7 @@ pub(crate) fn run_streaming_env(
cmd.process_group(0);
}
tracing::debug!(?args, "git (streaming)");
+ let mut session = CommandSession::start(&mut cmd);
let mut child = cmd.spawn().map_err(spawn_error)?;
let (tx, rx) = mpsc::channel::<Event>();
@@ -332,11 +377,13 @@ pub(crate) fn run_streaming_env(
let _ = r.join();
}
if status.success() {
+ session.finish(true, &stderr_tail.join("\n"));
return Ok(());
}
let relevant: Vec<&str> =
conflicts.iter().chain(stderr_tail.iter()).map(String::as_str).filter(|l| !is_progress_line(l)).collect();
let msg = relevant.join("\n");
+ session.finish(false, &stderr_tail.join("\n"));
Err(failure(args, msg.as_bytes(), b"", status.code()))
}
@@ -420,3 +467,36 @@ fn kill(child: &mut Child) {
}
let _ = child.kill();
}
+
+#[cfg(test)]
+mod command_session_tests {
+ use super::*;
+
+ #[test]
+ fn command_ids_reach_children_and_completion_is_once_per_session() {
+ let events = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
+ let seen = events.clone();
+ set_git_command_observer(
+ "OPENIDEA_TEST_COMMAND_ID",
+ std::sync::Arc::new(move |id, success, stderr| {
+ seen.lock().unwrap().push((id, success, stderr.to_owned()));
+ }),
+ );
+ let mut first_cmd = Command::new("git");
+ let mut second_cmd = Command::new("git");
+ let mut first = CommandSession::start(&mut first_cmd);
+ let second = CommandSession::start(&mut second_cmd);
+ let (first_id, second_id) = (first.id, second.id);
+ assert_ne!(first_id, second_id);
+ for (cmd, id) in [(&first_cmd, first_id), (&second_cmd, second_id)] {
+ let value = cmd.get_envs().find(|(key, _)| *key == "OPENIDEA_TEST_COMMAND_ID").unwrap().1.unwrap();
+ assert_eq!(value, std::ffi::OsStr::new(&id.to_string()));
+ }
+ drop(second); // cancellation discards this command's state
+ first.finish(true, "done");
+ drop(first);
+ let events = events.lock().unwrap();
+ let ours: Vec<_> = events.iter().filter(|(id, _, _)| *id == first_id || *id == second_id).cloned().collect();
+ assert_eq!(ours, vec![(second_id, false, String::new()), (first_id, true, "done".into())]);
+ }
+}
diff --git a/crates/ide-vcs/src/lib.rs b/crates/ide-vcs/src/lib.rs
index aa16e84f6..bb25f4d54 100644
--- a/crates/ide-vcs/src/lib.rs
+++ b/crates/ide-vcs/src/lib.rs
@@ -455,7 +455,10 @@ mod status;
mod text_encoding;
mod write;
-pub use cli::{detected_git_executable, git_version, set_askpass_env, set_git_executable};
+pub use cli::{
+ GitCommandObserver, detected_git_executable, git_version, set_askpass_env, set_git_command_observer,
+ set_git_executable,
+};
pub use diff::build_partial_patch;
pub use ignore::{IgnoreDestination, add_to_ignore};
pub use manage::{MergeOptions, RebaseOptions, RemoteEdit, Worktree};
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index ac8dd1554..fe9264ef9 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -424,6 +424,8 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
ssh::ssh_connected,
ssh::ssh_disconnect,
ssh::ssh_askpass_answer,
+ ssh::git_credentials,
+ ssh::git_credential_forget,
ssh::ssh_terminal_command,
deploy::deploy_upload,
deploy::deploy_download,
diff --git a/src-tauri/src/commands/ssh.rs b/src-tauri/src/commands/ssh.rs
index 0c58ebc75..390c31fc1 100644
--- a/src-tauri/src/commands/ssh.rs
+++ b/src-tauri/src/commands/ssh.rs
@@ -61,13 +61,29 @@ pub fn ssh_disconnect(state: State<'_, AppState>, id: String) {
/// Answers an `IdeEvent::Askpass` prompt (`None`: cancelled); every window drops it.
#[tauri::command]
#[specta::specta]
-pub fn ssh_askpass_answer(state: State<'_, AppState>, id: u64, answer: Option<String>) {
+pub fn ssh_askpass_answer(state: State<'_, AppState>, id: u64, answer: Option<String>, remember: bool) {
if let Some(server) = &state.askpass {
- server.answer(id, answer);
+ server.answer(id, answer, remember);
}
state.sink.emit(IdeEvent::AskpassDone { id });
}
+/// Settings › Git › Saved credentials: `scheme://host` of every saved entry.
+#[tauri::command]
+#[specta::specta]
+pub fn git_credentials(_state: State<'_, AppState>) -> Vec<String> {
+ ide_ssh::git_creds::get().map(|s| s.list()).unwrap_or_default()
+}
+
+/// Forgets the credential of `key` (a `git_credentials` entry).
+#[tauri::command]
+#[specta::specta]
+pub fn git_credential_forget(_state: State<'_, AppState>, key: String) {
+ if let Some(store) = ide_ssh::git_creds::get() {
+ store.forget(&key);
+ }
+}
+
#[derive(Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SshTerminalCommand {
diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs
index 29f5ffb30..7f265e729 100644
--- a/src-tauri/src/state.rs
+++ b/src-tauri/src/state.rs
@@ -66,6 +66,8 @@ impl AppState {
let data_dir = app.path().app_data_dir()?;
std::fs::create_dir_all(&config_dir)?;
std::fs::create_dir_all(&data_dir)?;
+ // Saved git HTTPS credentials (askpass answers them silently).
+ ide_ssh::git_creds::init(data_dir.join("git-credentials.json"));
// File › Invalidate Caches… requested at the last run.
let removed = ide_workspace::caches::apply_pending(&data_dir);
if !removed.is_empty() {
@@ -158,10 +160,24 @@ fn start_askpass(app: &AppHandle) -> Option<ide_ssh::askpass::AskpassServer> {
let on_prompt = Arc::new(move |p: ide_ssh::askpass::AskpassPrompt| {
// A focused Settings window hands the prompt to its project window.
let window = crate::windows::target_window(&handle).map(|w| AppState::owner_window(w.label()).to_owned());
- TauriSink { app: handle.clone(), window }.emit(IdeEvent::Askpass { id: p.id, prompt: p.prompt, kind: p.kind });
+ let remember = ide_ssh::askpass::remembers(&p.prompt);
+ TauriSink { app: handle.clone(), window }.emit(IdeEvent::Askpass {
+ id: p.id,
+ prompt: p.prompt,
+ kind: p.kind,
+ remember,
+ });
});
match ide_ssh::askpass::AskpassServer::start(exe, on_prompt) {
Ok(server) => {
+ ide_vcs::set_git_command_observer(
+ ide_ssh::askpass::COMMAND_ENV,
+ Arc::new(|id, success, stderr| {
+ if let Some(store) = ide_ssh::git_creds::get() {
+ store.command_finished(id, success, stderr);
+ }
+ }),
+ );
ide_vcs::set_askpass_env(server.env());
Some(server)
}
diff --git a/src/bindings.ts b/src/bindings.ts
index 224083722..401a6f5d7 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -909,7 +909,11 @@ export const commands = {
sshConnected: () => __TAURI_INVOKE<string[]>("ssh_connected"),
sshDisconnect: (id: string) => __TAURI_INVOKE<void>("ssh_disconnect", { id }),
/** Answers an `IdeEvent::Askpass` prompt (`None`: cancelled); every window drops it. */
- sshAskpassAnswer: (id: number, answer: string | null) => __TAURI_INVOKE<void>("ssh_askpass_answer", { id, answer }),
+ sshAskpassAnswer: (id: number, answer: string | null, remember: boolean) => __TAURI_INVOKE<void>("ssh_askpass_answer", { id, answer, remember }),
+ /** Settings › Git › Saved credentials: `scheme://host` of every saved entry. */
+ gitCredentials: () => __TAURI_INVOKE<string[]>("git_credentials"),
+ /** Forgets the credential of `key` (a `git_credentials` entry). */
+ gitCredentialForget: (key: string) => __TAURI_INVOKE<void>("git_credential_forget", { key }),
/**
* Tools › Start SSH Session: the system `ssh` command line for configuration `id`
* (run in a terminal tab, so prompts and host-key questions are answered there).
@@ -3368,7 +3372,9 @@ cancellable: boolean } |
*/
{ type: "projectRootsChanged"; root: IpcPath } |
/** A child process (`ssh`, `git`) asks for a credential; answered with `ssh_askpass_answer`. */
-{ type: "askpass"; id: number; prompt: string; kind: AskpassKind } |
+{ type: "askpass"; id: number; prompt: string; kind: AskpassKind;
+/** The dialog offers "Remember" for the answer (git HTTPS passwords). */
+remember: boolean } |
/** Prompt `id` was answered (in any window) or gave up. */
{ type: "askpassDone"; id: number } |
/**
diff --git a/src/features/settings/pages/vcs.tsx b/src/features/settings/pages/vcs.tsx
index 9bb511d1f..225095a0e 100644
--- a/src/features/settings/pages/vcs.tsx
+++ b/src/features/settings/pages/vcs.tsx
@@ -139,6 +139,58 @@ function ProtectedBranchesRow() {
);
}
+/** Saved git HTTPS credentials (Settings › Git › Passwords): list and forget. */
+function GitCredentialsRow() {
+ const [hosts, setHosts] = useState<string[]>([]);
+ useEffect(() => {
+ if (!isTauri()) return;
+ void commands.gitCredentials().then(setHosts, () => undefined);
+ }, []);
+ const forget = async (key: string) => {
+ await commands.gitCredentialForget(key);
+ setHosts((h) => h.filter((k) => k !== key));
+ };
+ if (hosts.length === 0)
+ return (
+ <Row
+ label="Passwords"
+ hint={
+ 'Credentials the IDE answers git\'s HTTPS prompts with. Saved after a successful fetch / pull / push when "Remember for this host" was checked.'
+ }
+ >
+ <span className={styles.empty}>
+ <T>No saved credentials</T>
+ </span>
+ </Row>
+ );
+ return (
+ <Row
+ label="Passwords"
+ stacked
+ hint={
+ "Credentials the IDE answers git's HTTPS prompts with, stored in the app's own secret file (not git's credential.helper). A rejected credential is forgotten automatically."
+ }
+ >
+ <div className={styles.tableBox}>
+ <table className={styles.table} aria-label={tx("Saved git credentials")}>
+ <tbody>
+ {hosts.map((h) => (
+ <tr key={h}>
+ <td className={styles.mono}>{h}</td>
+ <td style={{ width: 90 }}>
+ <Button size="small" onClick={() => void forget(h)}>
+ <T>Forget</T>
+ </Button>
+ </td>
+ </tr>
+ ))}
+ </tbody>
+ </table>
+ </div>
+ </Row>
+ );
+}
+
function LargeFilesRow() {
return (
<ToggleNumber
@@ -520,6 +572,17 @@ export const VCS_PAGES: PageSpec[] = [
},
],
},
+ {
+ title: "Passwords",
+ options: [
+ {
+ kind: "custom",
+ label: "Passwords",
+ keywords: ["credentials", "remember", "forget", "https"],
+ component: GitCredentialsRow,
+ },
+ ],
+ },
{
title: "Stash",
options: [
diff --git a/src/features/ssh/AskpassDialog.tsx b/src/features/ssh/AskpassDialog.tsx
index 0edf58baf..d5d18b98a 100644
--- a/src/features/ssh/AskpassDialog.tsx
+++ b/src/features/ssh/AskpassDialog.tsx
@@ -1,7 +1,7 @@
/** The oldest pending askpass prompt as a modal: password / text field, or Yes / No for a host key. */
import { useState } from "react";
import { useTx } from "@/platform/i18n";
-import { Dialog, Input } from "@/ui";
+import { Checkbox, Dialog, Input } from "@/ui";
import { answerAskpass, askpassAnswer, useAskpass, type AskpassPrompt } from "./askpass";
import styles from "./Ssh.module.css";
@@ -13,7 +13,9 @@ export function AskpassHost() {
function AskpassDialog({ prompt: p }: { prompt: AskpassPrompt }) {
const tx = useTx();
const [text, setText] = useState("");
- const done = (choice: Parameters<typeof askpassAnswer>[1]) => answerAskpass(p.id, askpassAnswer(p.kind, choice));
+ const [remember, setRemember] = useState(true);
+ const done = (choice: Parameters<typeof askpassAnswer>[1]) =>
+ answerAskpass(p, askpassAnswer(p.kind, choice), remember);
const cancel = () => done(null);
if (p.kind === "confirm")
@@ -62,6 +64,7 @@ function AskpassDialog({ prompt: p }: { prompt: AskpassPrompt }) {
value={text}
onChange={(e) => setText(e.target.value)}
/>
+ {p.remember && <Checkbox checked={remember} onChange={setRemember} label={tx("Remember for this host")} />}
</form>
</Dialog>
);
diff --git a/src/features/ssh/askpass.ts b/src/features/ssh/askpass.ts
index 2f5b22489..6069870dc 100644
--- a/src/features/ssh/askpass.ts
+++ b/src/features/ssh/askpass.ts
@@ -9,6 +9,8 @@ export interface AskpassPrompt {
id: number;
prompt: string;
kind: AskpassKind;
+ /** The dialog offers "Remember" (git HTTPS passwords). */
+ remember: boolean;
}
export const useAskpass = create<{ queue: AskpassPrompt[] }>(() => ({ queue: [] }));
@@ -32,7 +34,14 @@ export function askpassAnswer(
return kind === "confirm" ? null : choice.text;
}
-export function answerAskpass(id: number, answer: string | null, send = commands.sshAskpassAnswer) {
- dropAskpass(id);
- void send(id, answer).catch(() => {});
+export function answerAskpass(
+ p: AskpassPrompt,
+ answer: string | null,
+ remember: boolean,
+ send = commands.sshAskpassAnswer,
+) {
+ dropAskpass(p.id);
+ // The backend ties `remember` to this prompt; the git command saves it only
+ // on success and drops it again when authentication fails.
+ void send(p.id, answer, remember).catch(() => {});
}
diff --git a/src/features/ssh/index.ts b/src/features/ssh/index.ts
index 7de79f9c1..38c7e12f7 100644
--- a/src/features/ssh/index.ts
+++ b/src/features/ssh/index.ts
@@ -13,7 +13,7 @@ import { chooseSshSession, SSH_SETTINGS_PAGE, startSshSession } from "./session"
export function activate(): () => void {
const disposers = [
registerOverlay({ id: "ssh.askpass", component: AskpassHost }),
- onIdeEvent("askpass", (e) => enqueueAskpass({ id: e.id, prompt: e.prompt, kind: e.kind })),
+ onIdeEvent("askpass", (e) => enqueueAskpass({ id: e.id, prompt: e.prompt, kind: e.kind, remember: e.remember })),
onIdeEvent("askpassDone", (e) => dropAskpass(e.id)),
registerActions([
{
diff --git a/src/features/ssh/ssh.test.ts b/src/features/ssh/ssh.test.ts
index a72852cfd..190608c11 100644
--- a/src/features/ssh/ssh.test.ts
+++ b/src/features/ssh/ssh.test.ts
@@ -7,26 +7,26 @@ describe("askpass queue", () => {
beforeEach(() => useAskpass.setState({ queue: [] }));
it("queues prompts in arrival order, once each", () => {
- enqueueAskpass({ id: 1, prompt: "Password:", kind: "secret" });
- enqueueAskpass({ id: 2, prompt: "Continue connecting (yes/no)?", kind: "confirm" });
- enqueueAskpass({ id: 1, prompt: "Password:", kind: "secret" });
+ enqueueAskpass({ id: 1, prompt: "Password:", kind: "secret", remember: false });
+ enqueueAskpass({ id: 2, prompt: "Continue connecting (yes/no)?", kind: "confirm", remember: false });
+ enqueueAskpass({ id: 1, prompt: "Password:", kind: "secret", remember: false });
expect(useAskpass.getState().queue.map((p) => p.id)).toEqual([1, 2]);
});
it("drops a prompt answered elsewhere", () => {
- enqueueAskpass({ id: 1, prompt: "a", kind: "text" });
- enqueueAskpass({ id: 2, prompt: "b", kind: "text" });
+ enqueueAskpass({ id: 1, prompt: "a", kind: "text", remember: false });
+ enqueueAskpass({ id: 2, prompt: "b", kind: "text", remember: false });
dropAskpass(1);
dropAskpass(9);
expect(useAskpass.getState().queue.map((p) => p.id)).toEqual([2]);
});
it("answers the backend and shows the next prompt", () => {
- const send = vi.fn((_id: number, _answer: string | null) => Promise.resolve());
- enqueueAskpass({ id: 1, prompt: "a", kind: "secret" });
- enqueueAskpass({ id: 2, prompt: "b", kind: "secret" });
- answerAskpass(1, "hunter2", send);
- expect(send).toHaveBeenCalledWith(1, "hunter2");
+ const send = vi.fn((_id: number, _answer: string | null, _remember: boolean) => Promise.resolve());
+ enqueueAskpass({ id: 1, prompt: "a", kind: "secret", remember: true });
+ enqueueAskpass({ id: 2, prompt: "b", kind: "secret", remember: false });
+ answerAskpass({ id: 1, prompt: "a", kind: "secret", remember: true }, "hunter2", true, send);
+ expect(send).toHaveBeenCalledWith(1, "hunter2", true);
expect(useAskpass.getState().queue.map((p) => p.id)).toEqual([2]);
});
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 0adc22a3e..62a3bfc50 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -4829,5 +4829,12 @@
"JDK used for Gradle sync, tasks, run configurations and tests. An explicit JAVA_HOME in a run configuration takes precedence.": "用于 Gradle 同步、任务、运行配置和测试的 JDK。运行配置中显式设置的 JAVA_HOME 优先。",
"Uses the Gradle wrapper when present, otherwise the project-pinned mise/asdf Gradle, then Gradle on PATH.": "优先使用 Gradle 包装器,否则使用项目通过 mise/asdf 固定的 Gradle,最后使用 PATH 中的 Gradle。",
"Uses bin/gradle (bin/gradle.bat on Windows) instead of the wrapper or pinned toolchain.": "使用 bin/gradle(Windows 上为 bin/gradle.bat),覆盖包装器或固定的工具链。",
- "Sets GRADLE_USER_HOME. Empty uses Gradle's default.": "设置 GRADLE_USER_HOME。留空则使用 Gradle 默认值。"
+ "Sets GRADLE_USER_HOME. Empty uses Gradle's default.": "设置 GRADLE_USER_HOME。留空则使用 Gradle 默认值。",
+ "Passwords": "密码",
+ "Credentials the IDE answers git's HTTPS prompts with. Saved after a successful fetch / pull / push when \"Remember for this host\" was checked.": "IDE 用于应答 git HTTPS 提示的凭据。勾选「记住此主机」后,在 fetch / pull / push 成功时保存。",
+ "No saved credentials": "没有已保存的凭据",
+ "Credentials the IDE answers git's HTTPS prompts with, stored in the app's own secret file (not git's credential.helper). A rejected credential is forgotten automatically.": "IDE 用于应答 git HTTPS 提示的凭据,存储在应用自己的密钥文件中(而非 git 的 credential.helper)。被拒绝的凭据会自动删除。",
+ "Saved git credentials": "已保存的 git 凭据",
+ "Forget": "忘记",
+ "Remember for this host": "记住此主机"
}