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.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.tsindex 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.tsxindex 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.tsxindex 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.tsindex 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.tsindex 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.tsindex 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.jsonindex 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": "记住此主机"}