Lightweight coding agent that runs in your terminal
Rust
Sanitize credentials from Git remote metadata (#40713)
Adam Perry @ OpenAI1bc02aea5065
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex dcd85231bd..b212fb7a5b 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -3967,6 +3967,7 @@ dependencies = ["codex-utils-redacted-string","codex-utils-string","encoding_rs",+ "gix-url","globset","http 1.4.0","icu_decimal",diff --git a/codex-rs/Cargo.toml b/codex-rs/Cargo.tomlindex 45bbc3642c..f992ac7814 100644--- a/codex-rs/Cargo.toml+++ b/codex-rs/Cargo.toml@@ -339,6 +339,7 @@ flate2 = "1.1.8"futures = { version = "0.3", default-features = false }gethostname = "1.1.0"gix = { version = "0.81.0", default-features = false, features = ["sha1"] }+gix-url = "0.35.2"glob = "0.3"globset = "0.4"hmac = "0.12.1"diff --git a/codex-rs/analytics/src/accepted_lines.rs b/codex-rs/analytics/src/accepted_lines.rsindex f858df8199..8bb9185963 100644--- a/codex-rs/analytics/src/accepted_lines.rs+++ b/codex-rs/analytics/src/accepted_lines.rs@@ -109,8 +109,8 @@ pub async fn accepted_line_repo_hash_for_cwd(cwd: &Path) -> Option<String> {.get("origin").or_else(|| remotes.values().next()).map(|remote_url| {- let canonical_remote_url =- canonicalize_git_remote_url(remote_url).unwrap_or_else(|| remote_url.to_string());+ let canonical_remote_url = canonicalize_git_remote_url(remote_url.as_str())+ .unwrap_or_else(|| remote_url.to_string());fingerprint_hash("repo", &canonical_remote_url)})}diff --git a/codex-rs/analytics/src/reducer.rs b/codex-rs/analytics/src/reducer.rsindex c86f7f5939..1ab0d9843a 100644--- a/codex-rs/analytics/src/reducer.rs+++ b/codex-rs/analytics/src/reducer.rs@@ -148,6 +148,7 @@ use codex_app_server_protocol::ThreadItem;use codex_app_server_protocol::TurnSteerResponse;use codex_app_server_protocol::UserInput;use codex_app_server_protocol::WebSearchAction;+use codex_git_utils::SanitizedGitUrl;use codex_git_utils::collect_git_info;use codex_git_utils::get_git_repo_root;use codex_login::default_client::originator;@@ -1228,7 +1229,7 @@ impl AnalyticsReducer {None};let skill_id = skill_id_for_local_skill(- repo_url.as_deref(),+ repo_url.as_ref().map(SanitizedGitUrl::as_str),repo_root.as_deref(),path.as_path(),invocation.skill_name.as_str(),@@ -1270,7 +1271,7 @@ impl AnalyticsReducer {invoke_type: Some(invocation.invocation_type),model_slug: Some(tracking.model_slug.clone()),product_client_id: Some(tracking.product_client_id.clone()),- repo_url,+ repo_url: repo_url.map(String::from),skill_scope,plugin_id: invocation.plugin_id,remote_plugin_id: invocation.remote_plugin_id,diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rsindex 49cd2677d9..c2b2a8fa55 100644--- a/codex-rs/app-server/src/request_processors/thread_processor.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs@@ -17,6 +17,7 @@ use codex_app_server_protocol::ThreadSectionMoveParams;use codex_app_server_protocol::ThreadSectionMoveResponse;use codex_extension_api::ExtensionDataInit;use codex_extension_api::ThreadIdleCause;+use codex_protocol::SanitizedGitUrl;use codex_protocol::config_types::MultiAgentMode;use codex_protocol::error::CodexErrorDetails;use codex_protocol::mcp::ClientMcpExtensions;@@ -1901,16 +1902,25 @@ impl ThreadRequestProcessor {return Err(invalid_request("gitInfo must include at least one field"));}+ let origin_url =+ Self::normalize_thread_metadata_git_field(origin_url, "gitInfo.originUrl")?;+ let origin_url = match origin_url {+ Some(Some(origin_url)) => {+ Some(Some(SanitizedGitUrl::try_from(origin_url).map_err(+ |_| invalid_request("gitInfo.originUrl must be a valid Git remote"),+ )?))+ }+ Some(None) => Some(None),+ None => None,+ };+Ok(StoreGitInfoPatch {sha: Self::normalize_thread_metadata_git_field(sha, "gitInfo.sha")?,branch: Self::normalize_thread_metadata_git_field(branch,"gitInfo.branch",)?,- origin_url: Self::normalize_thread_metadata_git_field(- origin_url,- "gitInfo.originUrl",- )?,+ origin_url,})},)@@ -5840,7 +5850,7 @@ pub(crate) fn thread_from_stored_thread(let git_info = thread.git_info.map(|info| ApiGitInfo {sha: info.commit_hash.map(|sha| sha.0),branch: info.branch,- origin_url: info.repository_url,+ origin_url: info.repository_url.map(String::from),});let cwd = AbsolutePathBuf::relative_to_current_dir(path_utils::normalize_for_native_workdir(thread.cwd,@@ -5916,7 +5926,7 @@ fn summary_from_stored_thread(let git_info = thread.git_info.map(|git| ConversationGitInfo {sha: git.commit_hash.map(|sha| sha.0),branch: git.branch,- origin_url: git.repository_url,+ origin_url: git.repository_url.map(String::from),});ConversationSummary {conversation_id: thread.thread_id,@@ -6016,7 +6026,7 @@ fn summary_from_thread_metadata(metadata: &ThreadMetadata) -> ConversationSummarmetadata.agent_role.clone(),metadata.git_sha.clone(),metadata.git_branch.clone(),- metadata.git_origin_url.clone(),+ metadata.git_origin_url.clone().map(String::from),)}diff --git a/codex-rs/app-server/src/request_processors/thread_summary.rs b/codex-rs/app-server/src/request_processors/thread_summary.rsindex 422867f20a..5dacd34643 100644--- a/codex-rs/app-server/src/request_processors/thread_summary.rs+++ b/codex-rs/app-server/src/request_processors/thread_summary.rs@@ -131,7 +131,7 @@ fn map_git_info(git_info: &CoreGitInfo) -> ConversationGitInfo {ConversationGitInfo {sha: git_info.commit_hash.as_ref().map(|sha| sha.0.clone()),branch: git_info.branch.clone(),- origin_url: git_info.repository_url.clone(),+ origin_url: git_info.repository_url.clone().map(String::from),}}diff --git a/codex-rs/app-server/tests/suite/v2/thread_list.rs b/codex-rs/app-server/tests/suite/v2/thread_list.rsindex 32af51abdb..202bbbe82c 100644--- a/codex-rs/app-server/tests/suite/v2/thread_list.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_list.rs@@ -37,6 +37,7 @@ use codex_app_server_protocol::UserInput;use codex_core::ARCHIVED_SESSIONS_SUBDIR;use codex_features::Feature;use codex_git_utils::GitSha;+use codex_protocol::SanitizedGitUrl;use codex_protocol::ThreadId;use codex_protocol::protocol::GitInfo as CoreGitInfo;use codex_protocol::protocol::MultiAgentVersion;@@ -1886,7 +1887,10 @@ async fn thread_list_includes_git_info() -> Result<()> {let git_info = CoreGitInfo {commit_hash: Some(GitSha::new("abc123")),branch: Some("main".to_string()),- repository_url: Some("https://example.com/repo.git".to_string()),+ repository_url: Some(+ SanitizedGitUrl::try_from("https://example.com/repo.git")+ .expect("repository URL should be valid"),+ ),};let conversation_id = create_fake_rollout(codex_home.path(),@@ -1926,6 +1930,65 @@ async fn thread_list_includes_git_info() -> Result<()> {Ok(())}+/// Legacy rollout credentials must be sanitized before thread/list returns Git metadata.+#[tokio::test]+async fn thread_list_sanitizes_git_info_from_existing_rollouts() -> Result<()> {+ let codex_home = TempDir::new()?;+ create_minimal_config(codex_home.path())?;++ let git_info = CoreGitInfo {+ commit_hash: Some(GitSha::new("abc123")),+ branch: Some("main".to_string()),+ repository_url: Some(+ SanitizedGitUrl::try_from("https://example.com/repo.git")+ .expect("repository URL should be valid"),+ ),+ };+ let conversation_id = create_fake_rollout(+ codex_home.path(),+ "2025-02-01T09-00-00",+ "2025-02-01T09:00:00Z",+ "Git info preview",+ Some("mock_provider"),+ Some(git_info),+ )?;+ let path = rollout_path(codex_home.path(), "2025-02-01T09-00-00", &conversation_id);+ let rollout = fs::read_to_string(&path)?;+ fs::write(+ path,+ rollout.replace(+ "https://example.com/repo.git",+ "https://alice:[email protected]/repo.git",+ ),+ )?;++ let mut mcp = init_mcp(codex_home.path()).await?;+ let ThreadListResponse { data, .. } = list_threads(+ &mut mcp,+ /*cursor*/ None,+ Some(10),+ Some(vec!["mock_provider".to_string()]),+ /*source_kinds*/ None,+ /*archived*/ None,+ )+ .await?;+ let thread = data+ .iter()+ .find(|thread| thread.id == conversation_id)+ .expect("expected thread for created rollout");++ assert_eq!(+ thread.git_info,+ Some(ApiGitInfo {+ sha: Some("abc123".to_string()),+ branch: Some("main".to_string()),+ origin_url: Some("https://example.com/repo.git".to_string()),+ })+ );++ Ok(())+}+#[tokio::test]async fn thread_list_default_sorts_by_created_at() -> Result<()> {let codex_home = TempDir::new()?;diff --git a/codex-rs/app-server/tests/suite/v2/thread_metadata_update.rs b/codex-rs/app-server/tests/suite/v2/thread_metadata_update.rsindex d82ed2c4f8..f4fce236f1 100644--- a/codex-rs/app-server/tests/suite/v2/thread_metadata_update.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_metadata_update.rs@@ -9,6 +9,7 @@ use codex_app_server_protocol::GitInfo;use codex_app_server_protocol::JSONRPCError;use codex_app_server_protocol::JSONRPCResponse;use codex_app_server_protocol::RequestId;+use codex_app_server_protocol::ThreadHistoryMode;use codex_app_server_protocol::ThreadListParams;use codex_app_server_protocol::ThreadListResponse;use codex_app_server_protocol::ThreadMetadataGitInfoUpdateParams;@@ -30,6 +31,7 @@ use codex_app_server_protocol::ThreadStatus;use codex_core::ARCHIVED_SESSIONS_SUBDIR;use codex_features::Feature;use codex_git_utils::GitSha;+use codex_protocol::SanitizedGitUrl;use codex_protocol::ThreadId;use codex_protocol::protocol::GitInfo as RolloutGitInfo;use codex_rollout::state_db::reconcile_rollout;@@ -651,6 +653,90 @@ async fn thread_metadata_update_patches_git_branch_and_returns_updated_thread()Ok(())}+/// Client-provided Git credentials must not reach API responses, SQLite, or rollout files.+#[tokio::test]+async fn thread_metadata_update_sanitizes_git_origin_before_persisting() -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;+ let codex_home = TempDir::new()?;+ mock_responses_config(&server.uri()).write(codex_home.path())?;+ let state_db = init_state_db(codex_home.path()).await?;++ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .build()+ .await?;+ timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;++ let start_id = mcp+ .send_thread_start_request_with_auto_env(ThreadStartParams {+ model: Some("mock-model".to_string()),+ history_mode: Some(ThreadHistoryMode::Legacy),+ ..Default::default()+ })+ .await?;+ let start_resp: JSONRPCResponse = timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.read_stream_until_response_message(RequestId::Integer(start_id)),+ )+ .await??;+ let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(start_resp)?;++ let update_id = mcp+ .send_thread_metadata_update_request(ThreadMetadataUpdateParams {+ thread_id: thread.id.clone(),+ project_id: None,+ git_info: Some(ThreadMetadataGitInfoUpdateParams {+ sha: None,+ branch: None,+ origin_url: Some(Some(+ "https://alice:[email protected]/org/repo.git".to_string(),+ )),+ }),+ })+ .await?;+ let update_resp: JSONRPCResponse = timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.read_stream_until_response_message(RequestId::Integer(update_id)),+ )+ .await??;+ let ThreadMetadataUpdateResponse { thread: updated } =+ to_response::<ThreadMetadataUpdateResponse>(update_resp)?;+ let expected_git_info = Some(GitInfo {+ sha: None,+ branch: None,+ origin_url: Some("https://example.invalid/org/repo.git".to_string()),+ });+ assert_eq!(updated.git_info, expected_git_info);++ let persisted = state_db+ .get_thread(ThreadId::from_string(&thread.id)?)+ .await?+ .expect("updated thread must be persisted");+ assert_eq!(+ persisted.git_origin_url.as_deref(),+ Some("https://example.invalid/org/repo.git")+ );+ let rollout = fs::read_to_string(persisted.rollout_path)?;+ assert!(!rollout.contains("synthetic-git-secret"));+ assert!(rollout.contains("https://example.invalid/org/repo.git"));++ let read_id = mcp+ .send_thread_read_request(ThreadReadParams {+ thread_id: thread.id,+ include_turns: false,+ })+ .await?;+ let read_resp: JSONRPCResponse = timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.read_stream_until_response_message(RequestId::Integer(read_id)),+ )+ .await??;+ let ThreadReadResponse { thread: read, .. } = to_response::<ThreadReadResponse>(read_resp)?;+ assert_eq!(read.git_info, expected_git_info);++ Ok(())+}+#[tokio::test]async fn thread_metadata_update_rejects_empty_git_info_patch() -> Result<()> {let server = create_mock_responses_server_repeating_assistant("Done").await;@@ -1004,7 +1090,10 @@ async fn thread_metadata_update_can_clear_stored_git_fields() -> Result<()> {Some(RolloutGitInfo {commit_hash: Some(GitSha::new("abc123")),branch: Some("feature/sidebar-pr".to_string()),- repository_url: Some("[email protected]:openai/codex.git".to_string()),+ repository_url: Some(+ SanitizedGitUrl::try_from("[email protected]:openai/codex.git")+ .expect("repository URL should be valid"),+ ),}),)?;let _state_db = init_state_db(codex_home.path()).await?;diff --git a/codex-rs/cloud-tasks/src/env_detect.rs b/codex-rs/cloud-tasks/src/env_detect.rsindex 36907cab59..31fbc99e2f 100644--- a/codex-rs/cloud-tasks/src/env_detect.rs+++ b/codex-rs/cloud-tasks/src/env_detect.rs@@ -1,3 +1,4 @@+use codex_git_utils::SanitizedGitUrl;use codex_http_client::RouteAwareClientPool;use http::StatusCode;use http::header::CONTENT_TYPE;@@ -44,13 +45,13 @@ async fn autodetect_environment_id_with_origins(base_url: &str,headers: &HeaderMap,desired_label: Option<String>,- origins: &[String],+ origins: &[SanitizedGitUrl],) -> anyhow::Result<AutodetectSelection> {// 1) Try repo-specific environments based on local git origins (GitHub only, like VSCode)crate::append_error_log(format!("env: git origins: {origins:?}"));let mut by_repo_envs: Vec<CodeEnvironment> = Vec::new();for origin in origins {- if let Some((owner, repo)) = parse_owner_repo(origin) {+ if let Some((owner, repo)) = parse_owner_repo(origin.as_str()) {let url = if base_url.contains("/backend-api") {format!("{}/wham/environments/by-repo/{}/{}/{}",@@ -213,7 +214,7 @@ impl EnvironmentHttp for RouteAwareClientPool {}}-fn get_git_origins() -> Vec<String> {+fn get_git_origins() -> Vec<SanitizedGitUrl> {// Prefer: git config --get-regexp remote\..*\.urllet out = std::process::Command::new("git").args(["-c", codex_git_utils::SAFE_BARE_REPOSITORY_CONFIG])@@ -225,8 +226,10 @@ fn get_git_origins() -> Vec<String> {let s = String::from_utf8_lossy(&ok.stdout);let mut urls = Vec::new();for line in s.lines() {- if let Some((_, url)) = line.split_once(' ') {- urls.push(url.trim().to_string());+ if let Some((_, url)) = line.split_once(' ')+ && let Ok(url) = SanitizedGitUrl::try_from(url.trim())+ {+ urls.push(url);}}if !urls.is_empty() {@@ -245,8 +248,10 @@ fn get_git_origins() -> Vec<String> {let mut urls = Vec::new();for line in s.lines() {let parts: Vec<&str> = line.split_whitespace().collect();- if parts.len() >= 2 {- urls.push(parts[1].to_string());+ if parts.len() >= 2+ && let Ok(url) = SanitizedGitUrl::try_from(parts[1])+ {+ urls.push(url);}}if !urls.is_empty() {@@ -256,7 +261,7 @@ fn get_git_origins() -> Vec<String> {Vec::new()}-fn uniq(mut v: Vec<String>) -> Vec<String> {+fn uniq(mut v: Vec<SanitizedGitUrl>) -> Vec<SanitizedGitUrl> {v.sort();v.dedup();v@@ -285,6 +290,7 @@ fn parse_owner_repo(url: &str) -> Option<(String, String)> {"http://github.com/","git://github.com/","github.com/",+ "github.com:",] {if let Some(rest) = s.strip_prefix(prefix) {let rest = rest.trim_start_matches('/').trim_end_matches(".git");@@ -312,13 +318,13 @@ async fn list_environments_with_origins(http: &impl EnvironmentHttp,base_url: &str,headers: &HeaderMap,- origins: &[String],+ origins: &[SanitizedGitUrl],) -> anyhow::Result<Vec<crate::app::EnvironmentRow>> {let mut map: HashMap<String, crate::app::EnvironmentRow> = HashMap::new();// 1) By-repo lookup for each parsed GitHub originfor origin in origins {- if let Some((owner, repo)) = parse_owner_repo(origin) {+ if let Some((owner, repo)) = parse_owner_repo(origin.as_str()) {let url = if base_url.contains("/backend-api") {format!("{}/wham/environments/by-repo/{}/{}/{}",diff --git a/codex-rs/cloud-tasks/src/env_detect_tests.rs b/codex-rs/cloud-tasks/src/env_detect_tests.rsindex 6032806f07..3299ff87f3 100644--- a/codex-rs/cloud-tasks/src/env_detect_tests.rs+++ b/codex-rs/cloud-tasks/src/env_detect_tests.rs@@ -133,7 +133,7 @@ async fn autodetect_requests_exact_repository_endpoint_and_decodes_selection() {BASE_URL,&headers,Some("Repository".to_string()),- &["[email protected]:openai/codex.git".to_string()],+ &[SanitizedGitUrl::try_from("[email protected]:openai/codex.git").expect("valid Git remote")],).await.expect("repository environment should be selected");@@ -154,6 +154,68 @@ async fn autodetect_requests_exact_repository_endpoint_and_decodes_selection() {);}+/// Repository discovery must accept credential-bearing origins without exposing credentials.+#[tokio::test]+async fn autodetect_sanitizes_credential_bearing_git_origins() {+ let http = FakeHttp::new(HashMap::from([(+ BY_REPO_URL.to_string(),+ json_response(r#"[{"id":"env-repo","label":"Repository"}]"#),+ )]));++ let selection = autodetect_environment_id_with_origins(+ &http,+ BASE_URL,+ &HeaderMap::new(),+ /*desired_label*/ None,+ &[SanitizedGitUrl::try_from(+ "https://alice:[email protected]/openai/codex.git",+ )+ .expect("valid Git remote")],+ )+ .await+ .expect("repository environment should be selected");++ assert_eq!(+ selection,+ AutodetectSelection {+ id: "env-repo".to_string(),+ label: Some("Repository".to_string()),+ }+ );+ assert_eq!(http.requested_urls(), vec![BY_REPO_URL.to_string()]);+}++/// Removing an SCP remote username must not prevent repository-specific discovery.+#[tokio::test]+async fn autodetect_recognizes_sanitized_scp_git_origins() {+ let http = FakeHttp::new(HashMap::from([(+ BY_REPO_URL.to_string(),+ json_response(r#"[{"id":"env-repo","label":"Repository"}]"#),+ )]));++ let selection = autodetect_environment_id_with_origins(+ &http,+ BASE_URL,+ &HeaderMap::new(),+ /*desired_label*/ None,+ &[+ SanitizedGitUrl::try_from("[email protected]:openai/codex.git")+ .expect("valid Git remote"),+ ],+ )+ .await+ .expect("repository environment should be selected");++ assert_eq!(+ selection,+ AutodetectSelection {+ id: "env-repo".to_string(),+ label: Some("Repository".to_string()),+ }+ );+ assert_eq!(http.requested_urls(), vec![BY_REPO_URL.to_string()]);+}+#[tokio::test]async fn autodetect_falls_back_to_exact_global_endpoint_and_decodes_selection() {let http = FakeHttp::new(HashMap::from([@@ -169,7 +231,7 @@ async fn autodetect_falls_back_to_exact_global_endpoint_and_decodes_selection()BASE_URL,&HeaderMap::new(),/*desired_label*/ None,- &["[email protected]:openai/codex.git".to_string()],+ &[SanitizedGitUrl::try_from("[email protected]:openai/codex.git").expect("valid Git remote")],).await.expect("global environment should be selected");@@ -206,7 +268,10 @@ async fn list_requests_exact_repository_and_global_endpoints_and_merges_results(&http,BASE_URL,&HeaderMap::new(),- &["https://github.com/openai/codex.git".to_string()],+ &[+ SanitizedGitUrl::try_from("https://github.com/openai/codex.git")+ .expect("valid Git remote"),+ ],).await.expect("environment list should decode");diff --git a/codex-rs/core/src/git_info_tests.rs b/codex-rs/core/src/git_info_tests.rsindex 05bc54a9ad..8cadb3b7ba 100644--- a/codex-rs/core/src/git_info_tests.rs+++ b/codex-rs/core/src/git_info_tests.rs@@ -16,6 +16,7 @@ use codex_exec_server::WalkOutcome;use codex_exec_server::WriteFileOptions;use codex_git_utils::GitInfo;use codex_git_utils::GitSha;+use codex_git_utils::SanitizedGitUrl;use codex_git_utils::collect_git_info;use codex_git_utils::get_git_repo_root;use codex_git_utils::get_has_changes_in_repo;@@ -406,7 +407,10 @@ async fn test_collect_git_info_with_remote() {.to_string();// Should have repository URL- assert_eq!(git_info.repository_url, Some(expected_remote));+ assert_eq!(+ git_info.repository_url,+ Some(SanitizedGitUrl::try_from(expected_remote.as_str()).unwrap())+ );}#[tokio::test]@@ -966,7 +970,9 @@ fn test_git_info_serialization() {let git_info = GitInfo {commit_hash: Some(GitSha::new("abc123def456")),branch: Some("main".to_string()),- repository_url: Some("https://github.com/example/repo.git".to_string()),+ repository_url: Some(+ SanitizedGitUrl::try_from("https://github.com/example/repo.git").unwrap(),+ ),};let json = serde_json::to_string(&git_info).expect("Should serialize GitInfo");diff --git a/codex-rs/core/src/responses_metadata.rs b/codex-rs/core/src/responses_metadata.rsindex a520072975..61d67d3dfd 100644--- a/codex-rs/core/src/responses_metadata.rs+++ b/codex-rs/core/src/responses_metadata.rs@@ -6,6 +6,7 @@ use codex_analytics::CompactionPhase;use codex_analytics::CompactionReason;use codex_analytics::CompactionStrategy;use codex_analytics::CompactionTrigger;+use codex_git_utils::SanitizedGitUrl;use codex_protocol::ThreadId;use codex_protocol::protocol::SessionSource;use codex_protocol::protocol::SubAgentSource;@@ -163,7 +164,7 @@ impl CodexResponsesRequestKind {#[derive(Clone, Debug, Serialize, Default)]pub(crate) struct TurnMetadataWorkspace {#[serde(default, skip_serializing_if = "Option::is_none")]- pub(crate) associated_remote_urls: Option<BTreeMap<String, String>>,+ pub(crate) associated_remote_urls: Option<BTreeMap<String, SanitizedGitUrl>>,#[serde(default, skip_serializing_if = "Option::is_none")]pub(crate) latest_git_commit_hash: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]diff --git a/codex-rs/core/src/turn_metadata.rs b/codex-rs/core/src/turn_metadata.rsindex 05b50f1894..388417ca29 100644--- a/codex-rs/core/src/turn_metadata.rs+++ b/codex-rs/core/src/turn_metadata.rs@@ -25,6 +25,7 @@ use crate::responses_metadata::subagent_header_value;use crate::responses_metadata::subagent_metadata_kind;use crate::sandbox_tags::permission_profile_policy_tag;use crate::sandbox_tags::permission_profile_sandbox_tag;+use codex_git_utils::SanitizedGitUrl;use codex_git_utils::get_git_remote_urls_assume_git_repo;use codex_git_utils::get_git_repo_root;use codex_git_utils::get_has_changes_in_repo;@@ -51,7 +52,7 @@ pub(crate) struct McpTurnMetadataContext<'a> {#[derive(Clone, Debug, Default)]struct WorkspaceGitMetadata {- associated_remote_urls: Option<BTreeMap<String, String>>,+ associated_remote_urls: Option<BTreeMap<String, SanitizedGitUrl>>,latest_git_commit_hash: Option<String>,has_changes: Option<bool>,}diff --git a/codex-rs/core/tests/responses_headers.rs b/codex-rs/core/tests/responses_headers.rsindex ff15c541c3..9beca451bd 100644--- a/codex-rs/core/tests/responses_headers.rs+++ b/codex-rs/core/tests/responses_headers.rs@@ -686,3 +686,96 @@ async fn responses_stream_includes_turn_metadata_header_for_git_workspace_e2e()Some(false));}++/// Credential-bearing Git remotes must be redacted from both metadata transports.+#[tokio::test]+async fn responses_stream_redacts_git_remote_credentials_from_turn_metadata() {+ core_test_support::skip_if_no_network!();++ let server = responses::start_mock_server().await;+ let test = test_codex()+ .with_model("test-gpt-5.1-codex")+ .build(&server)+ .await+ .expect("build test codex");+ let cwd = test.cwd_path();+ let remote_token = "test-git-secret-token";+ let credential_bearing_origin =+ "https://alice:[email protected]/openai/codex.git";++ for args in [+ ["init"].as_slice(),+ ["remote", "add", "origin", credential_bearing_origin].as_slice(),+ ] {+ let output = Command::new("git")+ .args(args)+ .current_dir(cwd)+ .output()+ .expect("git command should run");+ assert!(+ output.status.success(),+ "git {args:?} failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );+ }++ let first_response = responses::sse(vec![+ responses::ev_response_created("resp-1"),+ responses::ev_function_call(+ "wait-for-git",+ "test_sync_tool",+ r#"{"wait_for_git_enrichment":true}"#,+ ),+ responses::ev_completed("resp-1"),+ ]);+ let follow_up_response = responses::sse(vec![+ responses::ev_response_created("resp-2"),+ responses::ev_assistant_message("msg-1", "done"),+ responses::ev_completed("resp-2"),+ ]);+ let request_log = responses::mount_response_sequence(+ &server,+ vec![+ responses::sse_response(first_response),+ responses::sse_response(follow_up_response),+ ],+ )+ .await;++ test.submit_turn("inspect the workspace")+ .await+ .expect("submit turn prompt");++ let requests = request_log.requests();+ assert_eq!(requests.len(), 2, "expected a follow-up model request");+ let header_metadata = requests[1]+ .header("x-codex-turn-metadata")+ .expect("request header should include turn metadata");+ let request_body = requests[1].body_json();+ let body_metadata = request_body["client_metadata"]["x-codex-turn-metadata"]+ .as_str()+ .expect("request body should include turn metadata");++ for (location, metadata) in [+ ("request header", header_metadata.as_str()),+ ("request body", body_metadata),+ ] {+ assert!(+ !metadata.contains(remote_token),+ "{location} should not expose git remote credentials"+ );+ let metadata: serde_json::Value =+ serde_json::from_str(metadata).expect("turn metadata should be valid JSON");+ let remotes = metadata+ .get("workspaces")+ .and_then(serde_json::Value::as_object)+ .and_then(|workspaces| workspaces.values().next())+ .and_then(|workspace| workspace.get("associated_remote_urls"))+ .expect("turn metadata should include git remote URLs");+ assert_eq!(+ remotes,+ &serde_json::json!({ "origin": "https://example.invalid/openai/codex.git" }),+ "{location} should contain the sanitized remote"+ );+ }+}diff --git a/codex-rs/core/tests/suite/cli_stream.rs b/codex-rs/core/tests/suite/cli_stream.rsindex 81f635214f..715da9dc5b 100644--- a/codex-rs/core/tests/suite/cli_stream.rs+++ b/codex-rs/core/tests/suite/cli_stream.rs@@ -1,3 +1,4 @@+use codex_git_utils::SanitizedGitUrl;use codex_git_utils::collect_git_info;use codex_login::CODEX_ACCESS_TOKEN_ENV_VAR;use codex_login::CODEX_API_KEY_ENV_VAR;@@ -769,6 +770,7 @@ async fn integration_git_info_unit_test() {.unwrap().trim().to_string();+ let expected_remote_url = SanitizedGitUrl::try_from(expected_remote_url.as_str()).unwrap();assert_eq!(repo_url, &expected_remote_url,"Repository URL should match git remote get-url output"@@ -785,7 +787,13 @@ async fn integration_git_info_unit_test() {assert_eq!(git_info.commit_hash, deserialized.commit_hash);assert_eq!(git_info.branch, deserialized.branch);- assert_eq!(git_info.repository_url, deserialized.repository_url);+ assert_eq!(+ git_info+ .repository_url+ .as_ref()+ .map(SanitizedGitUrl::as_str),+ deserialized.repository_url.as_deref()+ );println!("✅ Git info serialization test passed!");}diff --git a/codex-rs/core/tests/suite/git_enrichment.rs b/codex-rs/core/tests/suite/git_enrichment.rsindex 206f775fa7..0bad1eb28b 100644--- a/codex-rs/core/tests/suite/git_enrichment.rs+++ b/codex-rs/core/tests/suite/git_enrichment.rs@@ -148,6 +148,66 @@ async fn startup_prewarm_skips_git_enrichment_and_user_turn_observes_fresh_stateOk(())}+/// Repository credentials must never cross the outbound model-request boundary.+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn user_turn_git_enrichment_redacts_remote_credentials() -> Result<()> {+ skip_if_no_network!(Ok(()));++ let (repo, head) = create_git_repo()?;+ run_git(+ repo.path(),+ &[+ "remote",+ "set-url",+ "origin",+ "https://git-user:[email protected]/cxa5426/repo.git",+ ],+ )?;+ let server = start_websocket_server(vec![vec![+ vec![ev_response_created("warm-1"), ev_completed("warm-1")],+ vec![+ ev_response_created("resp-1"),+ ev_function_call(+ "wait-for-git",+ "test_sync_tool",+ r#"{"wait_for_git_enrichment":true}"#,+ ),+ ev_completed("resp-1"),+ ],+ vec![+ ev_response_created("resp-2"),+ ev_assistant_message("msg-2", "done"),+ ev_completed("resp-2"),+ ],+ ]])+ .await;+ let cwd = repo.path().to_path_buf();+ let mut builder = test_codex()+ .with_model("test-gpt-5.1-codex")+ .with_config(move |config| {+ config.cwd = cwd.abs();+ });+ let test = builder.build_with_websocket_server(&server).await?;++ test.submit_turn("inspect the workspace").await?;+ let turn = server+ .single_connection()+ .get(2)+ .context("turn follow-up request")?+ .body_json();+ let serialized_turn = serde_json::to_string(&turn)?;+ assert!(!serialized_turn.contains("git-user"));+ assert!(!serialized_turn.contains("git-secret-token"));+ assert_eq!(+ turn_metadata(&turn)?["workspaces"],+ expected_workspace(repo.path(), &head, /*has_changes*/ false)+ );++ test.codex.shutdown_and_wait().await?;+ server.shutdown().await;+ Ok(())+}+#[cfg(not(target_os = "windows"))]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn guardian_prewarm_and_review_skip_redundant_git_enrichment() -> Result<()> {diff --git a/codex-rs/git-utils/src/info.rs b/codex-rs/git-utils/src/info.rsindex be5c6680f3..092acd0dab 100644--- a/codex-rs/git-utils/src/info.rs+++ b/codex-rs/git-utils/src/info.rs@@ -12,6 +12,7 @@ use tokio::time::Duration as TokioDuration;use ts_rs::TS;use crate::GitSha;+use crate::SanitizedGitUrl;use crate::git_process::run_git_command_with_timeout_output;/// Return `true` if the project folder specified by the `Config` is inside a@@ -49,7 +50,7 @@ pub struct GitInfo {pub branch: Option<String>,/// Repository URL (if available from remote)#[serde(skip_serializing_if = "Option::is_none")]- pub repository_url: Option<String>,+ pub repository_url: Option<SanitizedGitUrl>,}#[derive(Serialize, Deserialize, Clone, Debug)]@@ -110,14 +111,14 @@ pub async fn collect_git_info(cwd: &Path) -> Option<GitInfo> {&& output.status.success()&& let Ok(url) = String::from_utf8(output.stdout){- git_info.repository_url = Some(url.trim().to_string());+ git_info.repository_url = SanitizedGitUrl::try_from(url.trim()).ok();}Some(git_info)}/// Collect fetch remotes in a multi-root-friendly format: {"origin": "https://..."}.-pub async fn get_git_remote_urls(cwd: &Path) -> Option<BTreeMap<String, String>> {+pub async fn get_git_remote_urls(cwd: &Path) -> Option<BTreeMap<String, SanitizedGitUrl>> {let is_git_repo = run_git_command_with_timeout(&["rev-parse", "--git-dir"], cwd).await?.status@@ -130,7 +131,9 @@ pub async fn get_git_remote_urls(cwd: &Path) -> Option<BTreeMap<String, String>>}/// Collect fetch remotes without checking whether `cwd` is in a git repo.-pub async fn get_git_remote_urls_assume_git_repo(cwd: &Path) -> Option<BTreeMap<String, String>> {+pub async fn get_git_remote_urls_assume_git_repo(+ cwd: &Path,+) -> Option<BTreeMap<String, SanitizedGitUrl>> {let output = run_git_command_with_timeout(&["remote", "-v"], cwd).await?;if !output.status.success() {return None;@@ -258,7 +261,7 @@ fn trim_git_suffix(value: &str) -> &str {value.strip_suffix(".git").unwrap_or(value)}-fn parse_git_remote_urls(stdout: &str) -> Option<BTreeMap<String, String>> {+fn parse_git_remote_urls(stdout: &str) -> Option<BTreeMap<String, SanitizedGitUrl>> {let mut remotes = BTreeMap::new();for line in stdout.lines() {let Some(fetch_line) = line.strip_suffix(" (fetch)") else {@@ -273,8 +276,10 @@ fn parse_git_remote_urls(stdout: &str) -> Option<BTreeMap<String, String>> {};let url = url_part.trim_start();- if !url.is_empty() {- remotes.insert(name.to_string(), url.to_string());+ if !url.is_empty()+ && let Ok(url) = SanitizedGitUrl::try_from(url)+ {+ remotes.insert(name.to_string(), url);}}@@ -921,6 +926,103 @@ mod tests {}}+ /// Fetch remotes must be sanitized before they enter workspace metadata.+ #[test]+ fn parse_git_remote_urls_sanitizes_fetch_credentials() {+ let remotes = parse_git_remote_urls(+ "origin\thttps://alice:[email protected]/org/repo.git (fetch)\n\+ origin\thttps://alice:[email protected]/org/repo.git (push)\n\+ upstream\[email protected]:org/upstream.git (fetch)\n",+ );++ assert_eq!(+ remotes,+ Some(BTreeMap::from([+ (+ "origin".to_string(),+ SanitizedGitUrl::try_from("https://github.com/org/repo.git")+ .expect("parse expected remote URL"),+ ),+ (+ "upstream".to_string(),+ SanitizedGitUrl::try_from("[email protected]:org/upstream.git")+ .expect("parse expected remote URL"),+ ),+ ]))+ );+ }++ /// Malformed remote entries are omitted instead of leaking their raw contents.+ #[test]+ fn parse_git_remote_urls_skips_malformed_entries() {+ let remotes = parse_git_remote_urls(+ "bad\thttps://alice:secret@[invalid (fetch)\n\+ origin\thttps://github.com/org/repo.git (fetch)\n",+ );++ assert_eq!(+ remotes,+ Some(BTreeMap::from([(+ "origin".to_string(),+ SanitizedGitUrl::try_from("https://github.com/org/repo.git")+ .expect("parse expected remote URL"),+ )]))+ );+ }++ /// Both metadata collection paths must sanitize credentials introduced by `insteadOf`.+ #[tokio::test]+ async fn git_metadata_collection_sanitizes_rewritten_remote_credentials() {+ let temp_dir = tempfile::tempdir().expect("create temp dir");+ let repo = temp_dir.path();++ let status = std::process::Command::new("git")+ .args(["init", "-q"])+ .current_dir(repo)+ .status()+ .expect("initialize test repository");+ assert!(status.success(), "initialize test repository");++ let status = std::process::Command::new("git")+ .args([+ "config",+ "url.https://alice:[email protected]/.insteadOf",+ "https://short.invalid/",+ ])+ .current_dir(repo)+ .status()+ .expect("configure credential-bearing remote rewrite");+ assert!(+ status.success(),+ "configure credential-bearing remote rewrite"+ );++ let status = std::process::Command::new("git")+ .args([+ "remote",+ "add",+ "origin",+ "https://short.invalid/org/repo.git",+ ])+ .current_dir(repo)+ .status()+ .expect("configure rewritten remote");+ assert!(status.success(), "configure rewritten remote");++ let git_info = collect_git_info(repo).await.expect("collect git info");+ let remotes = get_git_remote_urls_assume_git_repo(repo).await;+ let expected = SanitizedGitUrl::try_from("https://example.invalid/org/repo.git")+ .expect("parse expected remote URL");++ assert_eq!(+ (git_info.repository_url, remotes),+ (+ Some(expected.clone()),+ Some(BTreeMap::from([("origin".to_string(), expected)])),+ )+ );+ }+#[tokio::test]async fn local_git_branches_excludes_detached_head_entry() {let temp_dir = tempfile::tempdir().expect("create temp dir");diff --git a/codex-rs/git-utils/src/lib.rs b/codex-rs/git-utils/src/lib.rsindex 74f811d41f..ec02057ce9 100644--- a/codex-rs/git-utils/src/lib.rs+++ b/codex-rs/git-utils/src/lib.rs@@ -27,6 +27,7 @@ pub use baseline::diff_since_latest_init;pub use baseline::ensure_git_baseline_repository;pub use baseline::reset_git_repository;pub use branch::merge_base_with_head;+pub use codex_protocol::SanitizedGitUrl;pub use codex_protocol::protocol::GitSha;pub use errors::GitToolingError;pub use fsmonitor::FsmonitorOverride;diff --git a/codex-rs/protocol/Cargo.toml b/codex-rs/protocol/Cargo.tomlindex f7f4b779d5..4e2bf12aa5 100644--- a/codex-rs/protocol/Cargo.toml+++ b/codex-rs/protocol/Cargo.toml@@ -26,6 +26,7 @@ codex-utils-path-uri = { workspace = true }codex-utils-redacted-string = { workspace = true }codex-utils-string = { workspace = true }encoding_rs = { workspace = true }+gix-url = { workspace = true }globset = { workspace = true }http = { workspace = true }icu_decimal = { workspace = true }diff --git a/codex-rs/protocol/src/lib.rs b/codex-rs/protocol/src/lib.rsindex f52dbe0cdc..efdfda6eba 100644--- a/codex-rs/protocol/src/lib.rs+++ b/codex-rs/protocol/src/lib.rs@@ -2,6 +2,7 @@ pub mod account;mod agent_path;pub mod auth;mod response_item_id;+mod sanitized_git_url;mod session_id;mod thread_id;mod tool_name;@@ -9,6 +10,7 @@ pub use agent_path::AgentPath;pub use permission_profile_intersection::PermissionIntersectionError;pub use permission_profile_intersection::intersect_effective_permission_profiles;pub use response_item_id::ResponseItemId;+pub use sanitized_git_url::SanitizedGitUrl;pub use session_id::SessionId;pub use thread_id::RolloutId;pub use thread_id::ThreadId;diff --git a/codex-rs/protocol/src/protocol.rs b/codex-rs/protocol/src/protocol.rsindex f76267a233..55b319f781 100644--- a/codex-rs/protocol/src/protocol.rs+++ b/codex-rs/protocol/src/protocol.rs@@ -16,6 +16,7 @@ use strum_macros::EnumIter;use crate::AgentPath;use crate::ResponseItemId;+use crate::SanitizedGitUrl;use crate::SessionId;use crate::ThreadId;use crate::approvals::ElicitationRequestEvent;@@ -3212,8 +3213,13 @@ pub struct GitInfo {#[serde(skip_serializing_if = "Option::is_none")]pub branch: Option<String>,/// Repository URL (if available from remote)- #[serde(skip_serializing_if = "Option::is_none")]- pub repository_url: Option<String>,+ #[serde(+ default,+ deserialize_with = "crate::sanitized_git_url::deserialize_optional_sanitized_git_url",+ skip_serializing_if = "Option::is_none"+ )]+ #[schemars(with = "Option<String>")]+ pub repository_url: Option<SanitizedGitUrl>,}#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq, JsonSchema, TS)]diff --git a/codex-rs/protocol/src/sanitized_git_url.rs b/codex-rs/protocol/src/sanitized_git_url.rsnew file mode 100644index 0000000000..daf6345d8b--- /dev/null+++ b/codex-rs/protocol/src/sanitized_git_url.rs@@ -0,0 +1,159 @@+use std::fmt;+use std::ops::Deref;++use gix_url::Scheme;+use gix_url::Url;+use schemars::JsonSchema;+use serde::Deserialize;+use serde::Serialize;+use ts_rs::TS;++/// A git remote URL with authentication credentials removed.+#[derive(+ Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, JsonSchema, TS,+)]+#[serde(try_from = "String", into = "String")]+#[schemars(with = "String")]+#[ts(type = "string")]+pub struct SanitizedGitUrl(String);++impl SanitizedGitUrl {+ pub fn as_str(&self) -> &str {+ self.0.as_str()+ }+}++impl TryFrom<&str> for SanitizedGitUrl {+ type Error = &'static str;++ fn try_from(value: &str) -> Result<Self, Self::Error> {+ // Remote helpers wrap another remote, so peel off their prefixes+ // without recursion before passing the address to the Git URL parser.+ let mut address = value;+ while let Some((transport, nested_address)) = address.split_once("::")+ && !transport.is_empty()+ && transport.chars().all(|character| {+ character.is_ascii_alphanumeric() || matches!(character, '+' | '-' | '.')+ })+ {+ // Helpers can also receive executable command lines containing+ // arbitrary secrets; scan the whole payload once and reject those.+ if address.len() == value.len() && nested_address.chars().any(char::is_whitespace) {+ return Err("invalid git remote URL");+ }+ address = nested_address;+ }+ let helper_prefix = &value[..value.len() - address.len()];+ let original = value;+ let value = address;++ // Parse first to recognize both URL and SCP-style remotes and reject+ // malformed inputs before reconstructing the original text.+ let url = match Url::try_from(value) {+ Ok(url) => url,+ Err(_) => {+ // gix mistakes an IPv6 address's first colon for the SCP path+ // separator when a username comes before the bracketed host.+ let (user, host_and_path) =+ value.split_once('@').ok_or("invalid git remote URL")?;+ let (host, path) = host_and_path+ .strip_prefix('[')+ .and_then(|host_and_path| host_and_path.split_once("]:"))+ .ok_or("invalid git remote URL")?;+ if user.is_empty() || path.is_empty() {+ return Err("invalid git remote URL");+ }+ // SCP paths are opaque and can contain characters that URL parsing rejects.+ let ssh_url = format!("ssh://{user}@[{host}]/");+ Url::try_from(ssh_url.as_str()).map_err(|_| "invalid git remote URL")?+ }+ };++ // SSH's conventional `git` user is a transport identity, not a secret;+ // every other username and all passwords must be removed.+ let preserve_ssh_git_user = url.scheme == Scheme::Ssh && url.user() == Some("git");++ // Inspect the authority directly because gix treats the complete+ // `file://` authority as its host and does not expose its userinfo.+ // Rebuilding only this part also preserves escaped repository paths.+ if let Some((scheme, authority_and_path)) = value.split_once("://") {+ let authority_end = authority_and_path+ .find('/')+ .unwrap_or(authority_and_path.len());+ let (authority, path) = authority_and_path.split_at(authority_end);+ let Some((_, host)) = authority.rsplit_once('@') else {+ return Ok(Self(original.to_owned()));+ };+ if preserve_ssh_git_user && url.password().is_none() {+ return Ok(Self(original.to_owned()));+ }+ let user = if preserve_ssh_git_user { "git@" } else { "" };+ return Ok(Self(format!(+ "{helper_prefix}{scheme}://{user}{host}{path}"+ )));+ }++ // Parsed serialization can alter Git paths, so preserve the exact+ // original representation whenever no credential needs removal.+ if url.password().is_none() && (url.user().is_none() || preserve_ssh_git_user) {+ return Ok(Self(original.to_owned()));+ }++ // SCP-style remotes have no URL authority; remove only `user@` and+ // leave the original `host:path` untouched.+ let authority_end = value.find(':').unwrap_or(value.len());+ let user_end = value[..authority_end]+ .rfind('@')+ .ok_or("invalid git remote URL")?;+ Ok(Self(format!("{helper_prefix}{}", &value[user_end + 1..])))+ }+}++impl TryFrom<String> for SanitizedGitUrl {+ type Error = &'static str;++ fn try_from(value: String) -> Result<Self, Self::Error> {+ Self::try_from(value.as_str())+ }+}++impl From<SanitizedGitUrl> for String {+ fn from(value: SanitizedGitUrl) -> Self {+ value.0+ }+}++impl AsRef<str> for SanitizedGitUrl {+ fn as_ref(&self) -> &str {+ self.as_str()+ }+}++impl Deref for SanitizedGitUrl {+ type Target = str;++ fn deref(&self) -> &Self::Target {+ self.as_str()+ }+}++impl fmt::Display for SanitizedGitUrl {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ f.write_str(self.as_str())+ }+}++pub(crate) fn deserialize_optional_sanitized_git_url<'de, D>(+ deserializer: D,+) -> Result<Option<SanitizedGitUrl>, D::Error>+where+ D: serde::Deserializer<'de>,+{+ // Malformed legacy origins must not prevent the rest of a rollout from loading.+ Ok(Option::<String>::deserialize(deserializer)?+ .and_then(|value| SanitizedGitUrl::try_from(value).ok()))+}++#[cfg(test)]+#[path = "sanitized_git_url_tests.rs"]+mod tests;diff --git a/codex-rs/protocol/src/sanitized_git_url_tests.rs b/codex-rs/protocol/src/sanitized_git_url_tests.rsnew file mode 100644index 0000000000..dc02f22d8a--- /dev/null+++ b/codex-rs/protocol/src/sanitized_git_url_tests.rs@@ -0,0 +1,281 @@+use super::SanitizedGitUrl;+use crate::protocol::GitInfo;+use pretty_assertions::assert_eq;+use serde::Deserialize;+use serde::de::value::Error;+use serde::de::value::StrDeserializer;+use serde_json::json;++/// HTTPS usernames and passwords must never survive construction.+#[test]+fn removes_https_username_and_password() {+ let url = SanitizedGitUrl::try_from("https://alice:[email protected]/org/repo.git")+ .expect("parse remote URL");++ assert_eq!(url.as_str(), "https://github.com/org/repo.git");+}++/// Tokens placed in the username field are credentials too.+#[test]+fn removes_https_username_without_password() {+ let url = SanitizedGitUrl::try_from("https://[email protected]/org/repo.git")+ .expect("parse remote URL");++ assert_eq!(url.as_str(), "https://github.com/org/repo.git");+}++/// Percent-encoded credentials must not bypass git-aware URL parsing.+#[test]+fn removes_percent_encoded_credentials() {+ let url = SanitizedGitUrl::try_from(+ "https://alice%40example.com:secret%[email protected]/org/repo.git",+ )+ .expect("parse remote URL");++ assert_eq!(url.as_str(), "https://github.com/org/repo.git");+}++/// File URLs must lose credentials even though gix stores their userinfo as host text.+#[test]+fn removes_file_url_credentials() {+ for (remote, expected) in [+ (+ "file://alice:secret@localhost/repo.git",+ "file://localhost/repo.git",+ ),+ (+ "file://secret-token@server/share/a%2Fb.git",+ "file://server/share/a%2Fb.git",+ ),+ (+ "file://git:secret@server/share/repo.git",+ "file://server/share/repo.git",+ ),+ ] {+ let url = SanitizedGitUrl::try_from(remote).expect("parse file remote URL");++ assert_eq!(url.as_str(), expected);+ }+}++/// Git remote-helper transports preserve their prefix and sanitize nested URLs.+#[test]+fn sanitizes_remote_helper_urls() {+ for (remote, expected) in [+ (+ "hg::https://example.invalid/org/repo.git",+ "hg::https://example.invalid/org/repo.git",+ ),+ (+ "hg::https://alice:[email protected]/org/repo.git",+ "hg::https://example.invalid/org/repo.git",+ ),+ (+ "remote-hg::[email protected]:org/repo.git",+ "remote-hg::[email protected]:org/repo.git",+ ),+ (+ "remote-hg::file://alice:secret@server/share/repo.git",+ "remote-hg::file://server/share/repo.git",+ ),+ ] {+ let url = SanitizedGitUrl::try_from(remote).expect("parse remote helper URL");++ assert_eq!(url.as_str(), expected);+ }+}++/// Nested helper prefixes must not overflow the stack or repeatedly rebuild the remote.+#[test]+fn sanitizes_deeply_nested_remote_helpers_without_recursion() {+ let prefix = "hg::".repeat(4_096);+ let remote = format!("{prefix}https://alice:[email protected]/org/repo.git");+ let expected = format!("{prefix}https://example.invalid/org/repo.git");++ let url = SanitizedGitUrl::try_from(remote.as_str()).expect("parse nested remote helper URL");++ assert_eq!(url.as_str(), expected);+}++/// Opaque helper command lines can hide credentials that Git URL parsing cannot identify.+#[test]+fn rejects_remote_helper_command_payloads() {+ for remote in [+ "ext::sshpass -p secret-token ssh [email protected] git-upload-pack /repo",+ "ext::ssh alice:[email protected] git-upload-pack /repo",+ ] {+ let error = SanitizedGitUrl::try_from(remote).expect_err("reject helper command payload");++ assert_eq!(error, "invalid git remote URL");+ }+}++/// Removing credentials must not decode reserved characters in repository paths.+#[test]+fn preserves_percent_encoded_path_delimiters() {+ for (remote, expected) in [+ (+ "https://example.invalid/org/a%2Fb%3Fc%23d.git",+ "https://example.invalid/org/a%2Fb%3Fc%23d.git",+ ),+ (+ "https://alice:[email protected]/org/a%2Fb%3Fc%23d.git",+ "https://example.invalid/org/a%2Fb%3Fc%23d.git",+ ),+ (+ "hg::https://alice:[email protected]/org/a%2Fb.git",+ "hg::https://example.invalid/org/a%2Fb.git",+ ),+ ] {+ let url = SanitizedGitUrl::try_from(remote).expect("parse percent-encoded remote URL");++ assert_eq!(url.as_str(), expected);+ }+}++/// The conventional non-secret SSH username is preserved in both Git URL forms.+#[test]+fn preserves_git_ssh_username() {+ for remote in [+ "[email protected]:org/repo.git",+ "ssh://[email protected]/org/repo.git",+ ] {+ let url = SanitizedGitUrl::try_from(remote).expect("parse remote URL");++ assert_eq!(url.as_str(), remote);+ }+}++/// SSH passwords are always removed even for the preserved `git` username.+#[test]+fn removes_ssh_password_for_git_username() {+ let url = SanitizedGitUrl::try_from("ssh://git:[email protected]/org/repo.git")+ .expect("parse remote URL");++ assert_eq!(url.as_str(), "ssh://[email protected]/org/repo.git");+}++/// Only the exact SSH username `git` is exempt from credential removal.+#[test]+fn removes_other_ssh_usernames() {+ for (remote, expected) in [+ ("[email protected]:org/repo.git", "github.com:org/repo.git"),+ (+ "ssh://[email protected]/org/repo.git",+ "ssh://github.com/org/repo.git",+ ),+ (+ "https://[email protected]/org/repo.git",+ "https://github.com/org/repo.git",+ ),+ ] {+ let url = SanitizedGitUrl::try_from(remote).expect("parse remote URL");++ assert_eq!(url.as_str(), expected);+ }+}++/// gix-url misidentifies an IPv6 colon as the SCP path separator when a user precedes the host.+#[test]+fn sanitizes_scp_style_ipv6_remotes_with_usernames() {+ for (remote, expected) in [+ (+ "git@[2001:db8::1]:org/repo.git",+ "git@[2001:db8::1]:org/repo.git",+ ),+ (+ "alice@[2001:db8::1]:org/repo.git",+ "[2001:db8::1]:org/repo.git",+ ),+ ] {+ let url = SanitizedGitUrl::try_from(remote).expect("parse SCP-style IPv6 remote URL");++ assert_eq!(url.as_str(), expected);+ }+}++/// IPv6 fallback validation must not interpret opaque SCP paths as URL paths.+#[test]+fn preserves_opaque_scp_style_ipv6_paths() {+ for (remote, expected) in [+ ("alice@[::1]:dir name/repo", "[::1]:dir name/repo"),+ ("alice@[::1]:repo%FF.git", "[::1]:repo%FF.git"),+ ("git@[::1]:dir name/repo", "git@[::1]:dir name/repo"),+ ] {+ let url = SanitizedGitUrl::try_from(remote).expect("parse opaque SCP-style IPv6 path");++ assert_eq!(url.as_str(), expected);+ }+}++/// Invalid remotes fail closed without including their embedded secret in errors.+#[test]+fn rejects_malformed_urls_without_exposing_input() {+ let error = SanitizedGitUrl::try_from("https://alice:secret-token@[invalid")+ .expect_err("reject malformed remote URL");++ assert_eq!(error, "invalid git remote URL");+ assert!(!error.contains("secret-token"));+}++/// Deserializing persisted metadata must enforce the constructor invariant.+#[test]+fn deserialization_sanitizes_credentials() {+ let deserializer =+ StrDeserializer::<Error>::new("https://alice:[email protected]/org/repo.git");+ let url = SanitizedGitUrl::deserialize(deserializer).expect("deserialize remote URL");++ assert_eq!(url.as_str(), "https://github.com/org/repo.git");+}++/// Ordinary HTTPS remotes retain their existing wire representation.+#[test]+fn preserves_https_remote_without_credentials() {+ let remote = "https://github.com/org/repo.git";+ let url = SanitizedGitUrl::try_from(remote.to_string()).expect("parse remote URL");++ assert_eq!(String::from(url), remote);+}++/// Legacy rollout origins must be sanitized as soon as their protocol metadata is parsed.+#[test]+fn git_info_deserialization_sanitizes_legacy_remote_credentials() {+ let info: GitInfo = serde_json::from_value(json!({+ "repository_url": "https://alice:[email protected]/org/repo.git",+ }))+ .expect("deserialize legacy Git metadata");++ assert_eq!(+ info.repository_url.as_deref(),+ Some("https://github.com/org/repo.git")+ );+}++/// An invalid historical remote must not make its entire rollout impossible to resume.+#[test]+fn git_info_deserialization_discards_malformed_legacy_remote() {+ let info: GitInfo = serde_json::from_value(json!({+ "repository_url": "https://alice:secret-token@[invalid",+ }))+ .expect("deserialize Git metadata despite malformed legacy remote");++ assert_eq!(info.repository_url, None);+}++/// Older rollout metadata may omit repository URLs entirely.+#[test]+fn git_info_deserialization_accepts_missing_repository_url() {+ let info: GitInfo = serde_json::from_value(json!({}))+ .expect("deserialize legacy Git metadata without a repository URL");++ assert_eq!(info.repository_url, None);+}++/// Explicitly absent repository URLs retain their existing protocol representation.+#[test]+fn git_info_deserialization_accepts_null_repository_url() {+ let info: GitInfo = serde_json::from_value(json!({ "repository_url": null }))+ .expect("deserialize legacy Git metadata with a null repository URL");++ assert_eq!(info.repository_url, None);+}diff --git a/codex-rs/rollout/src/list.rs b/codex-rs/rollout/src/list.rsindex f75622fced..3c775e3124 100644--- a/codex-rs/rollout/src/list.rs+++ b/codex-rs/rollout/src/list.rs@@ -25,6 +25,7 @@ use crate::protocol::EventMsg;use crate::state_db;use codex_file_search as file_search;use codex_protocol::RolloutId;+use codex_protocol::SanitizedGitUrl;use codex_protocol::ThreadId;use codex_protocol::items::TurnItem;use codex_protocol::protocol::SessionMetaLine;@@ -68,7 +69,7 @@ pub struct ThreadItem {/// Git commit SHA from session metadata.pub git_sha: Option<String>,/// Git origin URL from session metadata.- pub git_origin_url: Option<String>,+ pub git_origin_url: Option<SanitizedGitUrl>,/// Session source from session metadata.pub source: Option<SessionSource>,/// Persisted thread history contract selected when this thread was created.@@ -108,7 +109,7 @@ struct HeadTailSummary {cwd: Option<PathBuf>,git_branch: Option<String>,git_sha: Option<String>,- git_origin_url: Option<String>,+ git_origin_url: Option<SanitizedGitUrl>,source: Option<SessionSource>,history_mode: ThreadHistoryMode,parent_thread_id: Option<ThreadId>,diff --git a/codex-rs/rollout/src/metadata_tests.rs b/codex-rs/rollout/src/metadata_tests.rsindex 28a14eb2d6..afea81849f 100644--- a/codex-rs/rollout/src/metadata_tests.rs+++ b/codex-rs/rollout/src/metadata_tests.rs@@ -8,6 +8,7 @@ use chrono::DateTime;use chrono::NaiveDateTime;use chrono::Timelike;use chrono::Utc;+use codex_protocol::SanitizedGitUrl;use codex_protocol::ThreadId;use codex_protocol::protocol::GitInfo;use codex_protocol::protocol::SessionMeta;@@ -315,7 +316,10 @@ async fn backfill_sessions_preserves_existing_git_branch_and_fills_missing_git_fSome(GitInfo {commit_hash: Some(codex_git_utils::GitSha::new("rollout-sha")),branch: Some("rollout-branch".to_string()),- repository_url: Some("[email protected]:openai/codex.git".to_string()),+ repository_url: Some(+ SanitizedGitUrl::try_from("[email protected]:openai/codex.git")+ .expect("valid git remote URL"),+ ),}),);diff --git a/codex-rs/rollout/src/recorder_tests.rs b/codex-rs/rollout/src/recorder_tests.rsindex 22cbcf5dee..42cf907028 100644--- a/codex-rs/rollout/src/recorder_tests.rs+++ b/codex-rs/rollout/src/recorder_tests.rs@@ -6,6 +6,7 @@ use crate::RolloutItem;use crate::RolloutLine;use crate::config::RolloutConfig;use chrono::TimeZone;+use codex_protocol::SanitizedGitUrl;use codex_protocol::SessionId;use codex_protocol::ThreadId;use codex_protocol::models::ResponseItem;@@ -1471,7 +1472,9 @@ async fn list_threads_metadata_filter_overlays_state_db_list_metadata() -> std::builder.cwd = home.path().to_path_buf();builder.git_branch = Some("sqlite-branch".to_string());builder.git_sha = Some("sqlite-sha".to_string());- builder.git_origin_url = Some("https://example.com/repo.git".to_string());+ builder.git_origin_url = Some(+ SanitizedGitUrl::try_from("https://example.com/repo.git").expect("valid git remote URL"),+ );let mut metadata = builder.build(config.model_provider_id.as_str());metadata.first_user_message = Some("Hello from user".to_string());metadata.preview = metadata.first_user_message.clone();@@ -1521,7 +1524,10 @@ fn fill_missing_thread_item_metadata_preserves_identity_and_prefers_state_git_ficwd: None,git_branch: Some("filesystem-branch".to_string()),git_sha: Some("filesystem-sha".to_string()),- git_origin_url: Some("https://example.com/filesystem.git".to_string()),+ git_origin_url: Some(+ SanitizedGitUrl::try_from("https://example.com/filesystem.git")+ .expect("valid git remote URL"),+ ),source: None,history_mode: Default::default(),parent_thread_id: None,@@ -1547,7 +1553,10 @@ fn fill_missing_thread_item_metadata_preserves_identity_and_prefers_state_git_ficwd: Some(PathBuf::from("/tmp/state-cwd")),git_branch: Some("state-branch".to_string()),git_sha: Some("state-sha".to_string()),- git_origin_url: Some("https://example.com/state.git".to_string()),+ git_origin_url: Some(+ SanitizedGitUrl::try_from("https://example.com/state.git")+ .expect("valid git remote URL"),+ ),source: Some(SessionSource::Exec),history_mode: Default::default(),parent_thread_id: None,diff --git a/codex-rs/state/src/model/thread_metadata.rs b/codex-rs/state/src/model/thread_metadata.rsindex c032ff118f..1e2da1c843 100644--- a/codex-rs/state/src/model/thread_metadata.rs+++ b/codex-rs/state/src/model/thread_metadata.rs@@ -1,6 +1,7 @@use anyhow::Result;use chrono::DateTime;use chrono::Utc;+use codex_protocol::SanitizedGitUrl;use codex_protocol::ThreadId;use codex_protocol::openai_models::ReasoningEffort;use codex_protocol::protocol::AskForApproval;@@ -183,7 +184,7 @@ pub struct ThreadMetadata {/// The git branch name, if known.pub git_branch: Option<String>,/// The git origin URL, if known.- pub git_origin_url: Option<String>,+ pub git_origin_url: Option<SanitizedGitUrl>,}/// Builder data required to construct [`ThreadMetadata`] without parsing filenames.@@ -228,7 +229,7 @@ pub struct ThreadMetadataBuilder {/// The git branch name, if known.pub git_branch: Option<String>,/// The git origin URL, if known.- pub git_origin_url: Option<String>,+ pub git_origin_url: Option<SanitizedGitUrl>,}impl ThreadMetadataBuilder {@@ -626,7 +627,8 @@ impl TryFrom<ThreadRow> for ThreadMetadata {project_id,git_sha,git_branch,- git_origin_url,+ git_origin_url: git_origin_url+ .and_then(|origin_url| SanitizedGitUrl::try_from(origin_url).ok()),})}}@@ -693,6 +695,7 @@ mod tests {use super::ThreadRow;use chrono::DateTime;use chrono::Utc;+ use codex_protocol::SanitizedGitUrl;use codex_protocol::ThreadId;use codex_protocol::openai_models::ReasoningEffort;use codex_protocol::protocol::ThreadHistoryMode;@@ -810,7 +813,10 @@ mod tests {reconciled.history_mode = ThreadHistoryMode::Paginated;reconciled.git_sha = Some("rollout-sha".to_string());reconciled.git_branch = Some("rollout-branch".to_string());- reconciled.git_origin_url = Some("rollout-origin".to_string());+ reconciled.git_origin_url = Some(+ SanitizedGitUrl::try_from("https://example.com/rollout-origin")+ .expect("valid git remote URL"),+ );let existing = expected_thread_metadata(/*reasoning_effort*/ None);let expected = reconciled.clone();diff --git a/codex-rs/state/src/runtime/threads.rs b/codex-rs/state/src/runtime/threads.rsindex 237cc3b08b..86200c59ca 100644--- a/codex-rs/state/src/runtime/threads.rs+++ b/codex-rs/state/src/runtime/threads.rs@@ -1,5 +1,6 @@use super::*;use crate::SortDirection;+use codex_protocol::SanitizedGitUrl;use codex_protocol::protocol::SessionSource;use std::sync::atomic::AtomicI64;use std::sync::atomic::Ordering;@@ -847,7 +848,7 @@ impl StateRuntime {thread_id: ThreadId,git_sha: Option<Option<&str>>,git_branch: Option<Option<&str>>,- git_origin_url: Option<Option<&str>>,+ git_origin_url: Option<Option<&SanitizedGitUrl>>,) -> anyhow::Result<bool> {let result = sqlx::query(r#"@@ -864,7 +865,7 @@ WHERE id = ?.bind(git_branch.is_some()).bind(git_branch.flatten()).bind(git_origin_url.is_some())- .bind(git_origin_url.flatten())+ .bind(git_origin_url.flatten().map(SanitizedGitUrl::as_str)).bind(thread_id.to_string()).execute(self.pool.as_ref()).await?;@@ -2661,7 +2662,10 @@ mod tests {git: Some(GitInfo {commit_hash: Some(codex_git_utils::GitSha::new("rollout-sha")),branch: Some("rollout-branch".to_string()),- repository_url: Some("[email protected]:openai/codex.git".to_string()),+ repository_url: Some(+ SanitizedGitUrl::try_from("[email protected]:openai/codex.git")+ .expect("valid git remote URL"),+ ),}),})];@@ -2700,7 +2704,10 @@ mod tests {let mut metadata = test_thread_metadata(&codex_home, thread_id, codex_home.clone());metadata.git_sha = Some("sqlite-sha".to_string());metadata.git_branch = Some("sqlite-branch".to_string());- metadata.git_origin_url = Some("[email protected]:openai/codex.git".to_string());+ metadata.git_origin_url = Some(+ SanitizedGitUrl::try_from("[email protected]:openai/codex.git")+ .expect("valid git remote URL"),+ );runtime.upsert_thread(&metadata)@@ -2710,7 +2717,10 @@ mod tests {let mut rollout_metadata = metadata.clone();rollout_metadata.git_sha = Some("rollout-sha".to_string());rollout_metadata.git_branch = Some("rollout-branch".to_string());- rollout_metadata.git_origin_url = Some("https://example.com/repo.git".to_string());+ rollout_metadata.git_origin_url = Some(+ SanitizedGitUrl::try_from("https://example.com/repo.git")+ .expect("valid git remote URL"),+ );runtime.upsert_thread(&rollout_metadata)@@ -2849,7 +2859,10 @@ mod tests {thread_id,Some(Some("abc123")),Some(Some("feature/branch")),- Some(Some("[email protected]:openai/codex.git")),+ Some(Some(+ &SanitizedGitUrl::try_from("[email protected]:openai/codex.git")+ .expect("valid git remote URL"),+ )),).await.expect("git info update should succeed");@@ -2940,7 +2953,10 @@ mod tests {let mut metadata = test_thread_metadata(&codex_home, thread_id, codex_home.clone());metadata.git_sha = Some("abc123".to_string());metadata.git_branch = Some("feature/branch".to_string());- metadata.git_origin_url = Some("[email protected]:openai/codex.git".to_string());+ metadata.git_origin_url = Some(+ SanitizedGitUrl::try_from("[email protected]:openai/codex.git")+ .expect("valid git remote URL"),+ );runtime.upsert_thread(&metadata)diff --git a/codex-rs/thread-store/src/local/helpers.rs b/codex-rs/thread-store/src/local/helpers.rsindex 1323252e82..a4f638945d 100644--- a/codex-rs/thread-store/src/local/helpers.rs+++ b/codex-rs/thread-store/src/local/helpers.rs@@ -10,6 +10,7 @@ use std::time::SystemTime;use chrono::DateTime;use chrono::Utc;use codex_git_utils::GitSha;+use codex_protocol::SanitizedGitUrl;use codex_protocol::ThreadId;use codex_protocol::models::PermissionProfile;use codex_protocol::protocol::AskForApproval;@@ -309,7 +310,7 @@ fn parse_legacy_sandbox_policy(value: &str) -> serde_json::Result<SandboxPolicy>pub(super) fn git_info_from_parts(sha: Option<String>,branch: Option<String>,- origin_url: Option<String>,+ origin_url: Option<SanitizedGitUrl>,) -> Option<GitInfo> {if sha.is_none() && branch.is_none() && origin_url.is_none() {return None;diff --git a/codex-rs/thread-store/src/local/update_thread_metadata.rs b/codex-rs/thread-store/src/local/update_thread_metadata.rsindex b4812cb2c7..3ec6f4d680 100644--- a/codex-rs/thread-store/src/local/update_thread_metadata.rs+++ b/codex-rs/thread-store/src/local/update_thread_metadata.rs@@ -2,6 +2,7 @@ use std::path::Path;use std::path::PathBuf;use chrono::Utc;+use codex_protocol::SanitizedGitUrl;use codex_protocol::ThreadId;use codex_protocol::protocol::GitInfo;use codex_protocol::protocol::SessionSource;@@ -708,7 +709,7 @@ async fn apply_thread_git_info_patch(git_info.origin_url.as_ref()- .map(|origin_url| origin_url.as_deref()),+ .map(|origin_url| origin_url.as_ref()),).await.map_err(|err| ThreadStoreError::Internal {@@ -728,7 +729,7 @@ async fn apply_thread_git_info(thread_id: ThreadId,sha: &Option<String>,branch: &Option<String>,- origin_url: &Option<String>,+ origin_url: &Option<SanitizedGitUrl>,) -> ThreadStoreResult<()> {let Some(state_db) = store.state_db().await else {return Err(ThreadStoreError::Internal {@@ -740,7 +741,7 @@ async fn apply_thread_git_info(thread_id,Some(sha.as_deref()),Some(branch.as_deref()),- Some(origin_url.as_deref()),+ Some(origin_url.as_ref()),).await.map_err(|err| ThreadStoreError::Internal {@@ -758,7 +759,7 @@ async fn apply_thread_git_info(fn resolve_git_info_patch(existing: Option<GitInfo>,git_info: GitInfoPatch,-) -> (Option<String>, Option<String>, Option<String>) {+) -> (Option<String>, Option<String>, Option<SanitizedGitUrl>) {let (existing_sha, existing_branch, existing_origin_url) = match existing {Some(info) => (info.commit_hash.map(|sha| sha.0),@@ -778,7 +779,7 @@ async fn apply_thread_git_info_to_rollout(thread_id: ThreadId,sha: &Option<String>,branch: &Option<String>,- origin_url: &Option<String>,+ origin_url: &Option<SanitizedGitUrl>,memory_mode: Option<&str>,) -> ThreadStoreResult<()> {let mut session_meta =@@ -1435,7 +1436,10 @@ mod tests {git_info: Some(GitInfoPatch {sha: Some(Some("abc123".to_string())),branch: Some(Some("main".to_string())),- origin_url: Some(Some("https://github.com/openai/codex".to_string())),+ origin_url: Some(Some(+ SanitizedGitUrl::try_from("https://github.com/openai/codex")+ .expect("valid git remote URL"),+ )),}),..Default::default()},@@ -1536,7 +1540,10 @@ mod tests {git_info: Some(GitInfoPatch {sha: Some(Some("abc123".to_string())),branch: Some(Some("main".to_string())),- origin_url: Some(Some("https://github.com/openai/codex".to_string())),+ origin_url: Some(Some(+ SanitizedGitUrl::try_from("https://github.com/openai/codex")+ .expect("valid git remote URL"),+ )),}),..Default::default()},@@ -1596,7 +1603,10 @@ mod tests {git_info: Some(GitInfoPatch {sha: Some(Some("abc123".to_string())),branch: Some(Some("main".to_string())),- origin_url: Some(Some("https://github.com/openai/codex".to_string())),+ origin_url: Some(Some(+ SanitizedGitUrl::try_from("https://github.com/openai/codex")+ .expect("valid git remote URL"),+ )),}),..Default::default()},diff --git a/codex-rs/thread-store/src/types.rs b/codex-rs/thread-store/src/types.rsindex 496a076478..5cedf0be09 100644--- a/codex-rs/thread-store/src/types.rs+++ b/codex-rs/thread-store/src/types.rs@@ -5,6 +5,7 @@ use chrono::DateTime;use chrono::Utc;use codex_app_server_protocol::CodexErrorInfo;use codex_app_server_protocol::ThreadTimelineEntry;+use codex_protocol::SanitizedGitUrl;use codex_protocol::SessionId;use codex_protocol::ThreadId;use codex_protocol::capabilities::SelectedCapabilityRoot;@@ -663,7 +664,7 @@ pub struct GitInfoPatch {skip_serializing_if = "Option::is_none",with = "optional_option")]- pub origin_url: ClearableField<String>,+ pub origin_url: ClearableField<SanitizedGitUrl>,}impl GitInfoPatch {