Lightweight coding agent that runs in your terminal
Rust
Make Windows path URI comparisons ASCII-case-insensitive (#37129)
iceweasel-oai4cb8676d3a41
diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zstindex 9b0b5678b3..8bab8a2234 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst differdiff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zstindex f4cdfa1bf8..d0f47dfbae 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst differdiff --git a/codex-rs/app-server-protocol/schema/typescript/PathUri.ts b/codex-rs/app-server-protocol/schema/typescript/PathUri.tsindex b3923cfdb9..ba11296ea0 100644--- a/codex-rs/app-server-protocol/schema/typescript/PathUri.ts+++ b/codex-rs/app-server-protocol/schema/typescript/PathUri.ts@@ -18,9 +18,10 @@** Like [VS Code resources], path operations use `/` URI separators on every* host. Lexical path operations preserve a URL authority without interpreting- * Windows drive or UNC roots from path text. Native path normalization,- * filesystem aliases, symlinks, case sensitivity, and Unicode normalization- * are not resolved.+ * Windows drive or UNC roots from path text. Windows path equality and hashing+ * ignore ASCII case, while POSIX paths remain case-sensitive. Native path+ * normalization, filesystem aliases, symlinks, and Unicode normalization are+ * not resolved.** Serde represents a `PathUri` as its canonical URI string. Deserialization* accepts only valid `file:` URI strings. These strings round-trip throughdiff --git a/codex-rs/utils/path-uri/src/lib.rs b/codex-rs/utils/path-uri/src/lib.rsindex e4bb02ce33..51590b568e 100644--- a/codex-rs/utils/path-uri/src/lib.rs+++ b/codex-rs/utils/path-uri/src/lib.rs@@ -10,7 +10,10 @@ use serde::Deserialize;use serde::Deserializer;use serde::Serialize;use serde::Serializer;+use std::borrow::Cow;use std::fmt;+use std::hash::Hash;+use std::hash::Hasher;use std::io;use std::path::Path;use std::path::PathBuf;@@ -45,19 +48,53 @@ const BAD_PATH_URI_PREFIX: &str = "file:///%00/bad/path/";////// Like [VS Code resources], path operations use `/` URI separators on every/// host. Lexical path operations preserve a URL authority without interpreting-/// Windows drive or UNC roots from path text. Native path normalization,-/// filesystem aliases, symlinks, case sensitivity, and Unicode normalization-/// are not resolved.+/// Windows drive or UNC roots from path text. Windows path equality and hashing+/// ignore ASCII case, while POSIX paths remain case-sensitive. Native path+/// normalization, filesystem aliases, symlinks, and Unicode normalization are+/// not resolved.////// Serde represents a `PathUri` as its canonical URI string. Deserialization/// accepts only valid `file:` URI strings. These strings round-trip through/// their canonical URL form, including encoded non-UTF-8 path bytes.////// [VS Code resources]: https://github.com/microsoft/vscode/blob/main/src/vs/base/common/resources.ts-#[derive(Clone, Debug, PartialEq, Eq, Hash, TS)]+#[derive(Clone, Debug, TS)]#[ts(type = "string")]pub struct PathUri(Url);+impl PartialEq for PathUri {+ fn eq(&self, other: &Self) -> bool {+ if self.0 == other.0 {+ return true;+ }+ let (Some(path), Some(other_path)) = (+ self.windows_identity_path_bytes(),+ other.windows_identity_path_bytes(),+ ) else {+ return false;+ };+ self.0.host_str() == other.0.host_str() && path.eq_ignore_ascii_case(&other_path)+ }+}++impl Eq for PathUri {}++impl Hash for PathUri {+ fn hash<H: Hasher>(&self, state: &mut H) {+ // Preserve URL hashing for POSIX paths; Windows paths must hash the+ // same decoded, ASCII-folded identity that `PartialEq` compares.+ let Some(path) = self.windows_identity_path_bytes() else {+ self.0.hash(state);+ return;+ };+ self.0.host_str().hash(state);+ path.len().hash(state);+ for byte in path.as_ref() {+ byte.to_ascii_lowercase().hash(state);+ }+ }+}+impl PathUri {/// Parses and validates a `file:` URI.pub fn parse(uri: &str) -> Result<Self, PathUriParseError> {@@ -136,6 +173,22 @@ impl PathUri {self.0.path()}+ fn windows_identity_path_bytes(&self) -> Option<Cow<'_, [u8]>> {+ if self.infer_path_convention() != Some(PathConvention::Windows)+ || self.opaque_fallback_bytes().is_some()+ || self.0.path_segments()?.any(|segment| {+ urlencoding::decode_binary(segment.as_bytes())+ .iter()+ .any(|byte| matches!(byte, b'/' | b'\\'))+ })+ {+ return None;+ }+ // Decode equivalent URI spellings here; comparisons and hashing apply+ // ASCII case folding to these shared Windows identity bytes.+ Some(urlencoding::decode_binary(self.0.path().as_bytes()))+ }+fn opaque_fallback_bytes(&self) -> Option<Vec<u8>> {decode_bad_path_uri(&self.0)}@@ -251,10 +304,11 @@ impl PathUri {/// Returns true when this URI is lexically equal to or below `base`.////// Containment is computed using URI authority and path-segment boundaries,- /// without consulting the host filesystem. Percent-encoded native path- /// separators fail closed because native path conversion may interpret them- /// as segment boundaries. Opaque fallback URIs created by- /// [`Self::from_abs_path`] only contain themselves.+ /// without consulting the host filesystem. Windows path segments are+ /// compared ASCII-case-insensitively; POSIX path segments remain case-sensitive.+ /// Percent-encoded native path separators fail closed because native path+ /// conversion may interpret them as segment boundaries. Opaque fallback+ /// URIs created by [`Self::from_abs_path`] only contain themselves.pub fn starts_with(&self, base: &Self) -> bool {if self == base {return true;@@ -266,29 +320,27 @@ impl PathUri {return false;}- let Some(path_segments) = containment_path_segments(- &self.0,- self.infer_path_convention()- .unwrap_or(PathConvention::Posix),- ) else {+ let convention = self.infer_path_convention();+ if convention != base.infer_path_convention() {+ return false;+ }+ let convention = convention.unwrap_or(PathConvention::Posix);+ let Some(path_segments) = containment_path_segments(&self.0, convention) else {return false;};- let Some(base_segments) = containment_path_segments(- &base.0,- base.infer_path_convention()- .unwrap_or(PathConvention::Posix),- ) else {+ let Some(base_segments) = containment_path_segments(&base.0, convention) else {return false;};- path_segments.starts_with(&base_segments)+ native_path_segments_start_with(&path_segments, &base_segments, convention)}/// Returns the decoded relative path from `base` to this URI.////// The result uses the separators of the inferred path convention,/// independently of the current host. Both URIs must use the same inferred- /// path convention and authority, and this URI must be lexically equal to- /// or below `base`. Percent-encoded native path separators fail closed.+ /// path convention and authority, and this URI must be equal to or below+ /// `base` under that convention's case sensitivity. Percent-encoded native+ /// path separators fail closed./// Opaque fallback URIs created by [`Self::from_abs_path`] are only relative/// to themselves.pub fn relative_path_from(&self, base: &Self) -> Option<String> {@@ -306,7 +358,10 @@ impl PathUri {let convention = self.infer_path_convention()?;let path_segments = containment_path_segments(&self.0, convention)?;let base_segments = containment_path_segments(&base.0, convention)?;- let relative_segments = path_segments.strip_prefix(base_segments.as_slice())?;+ if !native_path_segments_start_with(&path_segments, &base_segments, convention) {+ return None;+ }+ let relative_segments = &path_segments[base_segments.len()..];let separator = match convention {PathConvention::Posix => "/",PathConvention::Windows => "\\",@@ -648,6 +703,23 @@ fn containment_path_segments(url: &Url, convention: PathConvention) -> Option<Ve.then_some(segments)}+fn native_path_segments_start_with(+ path_segments: &[&str],+ base_segments: &[&str],+ convention: PathConvention,+) -> bool {+ match convention {+ PathConvention::Posix => path_segments.starts_with(base_segments),+ PathConvention::Windows => {+ path_segments.len() >= base_segments.len()+ && path_segments.iter().zip(base_segments).all(|(path, base)| {+ path.eq_ignore_ascii_case(base)+ || decode_uri_path(path).eq_ignore_ascii_case(&decode_uri_path(base))+ })+ }+ }+}+fn infer_opaque_path_convention(path_bytes: &[u8]) -> Option<PathConvention> {if path_bytes.starts_with(b"/") {return Some(PathConvention::Posix);diff --git a/codex-rs/utils/path-uri/src/tests.rs b/codex-rs/utils/path-uri/src/tests.rsindex 941f434bc2..7117a0c3bc 100644--- a/codex-rs/utils/path-uri/src/tests.rs+++ b/codex-rs/utils/path-uri/src/tests.rs@@ -80,6 +80,35 @@ fn file_uri_normalizes_windows_drive_letter_case() {);}+#[test]+fn path_uri_equality_and_hashing_follow_path_convention() {+ for (left, right, expected) in [+ ("file:///C:/Users/Alice", "file:///c:/users/ALICE", true),+ (+ "file://SERVER/SHARE/Project",+ "file://server/share/project",+ true,+ ),+ ("file:///home/Alice", "file:///home/alice", false),+ ("file:///C:/plugins/Lj", "file:///C:/plugins/LJ", false),+ ("file:///C:/plugins/%41", "file:///C:/plugins/a", true),+ ("file:///C:/plugins/a%2Fb", "file:///C:/plugins/a/b", false),+ ("file:///%00/bad/path/YQ", "file:///%00/bad/path/yQ", false),+ ] {+ let left = PathUri::parse(left).expect("valid left URI");+ let right = PathUri::parse(right).expect("valid right URI");++ assert_eq!(+ (+ left == right,+ std::collections::HashSet::from([left]).contains(&right),+ ),+ (expected, expected),+ "comparing {right}"+ );+ }+}+#[test]fn infers_path_conventions_from_uri_shape() {for (uri, expected) in [@@ -187,11 +216,21 @@ fn relative_path_from_is_host_independent() {"file:///C:/Users/Alice/project",Some(r"src\main.rs"),),+ (+ "file:///C:/USERS/%C3%84/PROJECT/src/main.rs",+ "file:///c:/users/%C3%A4/project",+ None,+ ),("file://server/share/project/src/main.rs","file://server/share/project",Some(r"src\main.rs"),),+ (+ "file://SERVER/SHARE/PROJECT/src/main.rs",+ "file://server/share/project",+ Some(r"src\main.rs"),+ ),("file:///home/alice/project","file:///home/alice/project/",@@ -202,6 +241,7 @@ fn relative_path_from_is_host_independent() {"file:///home/alice/project",None,),+ ("file:///HOME/alice/project", "file:///home", None),("file://other/share/project/main.rs","file://server/share/project",@@ -1008,6 +1048,17 @@ fn starts_with_uses_uri_segment_boundaries() {"file:///C:/plugins/foo",true,),+ ("file:///C:/project/secret", "file:///%63%3A/project", false),+ (+ "file:///C:/PLUGINS/%C3%84/assets/icon.svg",+ "file:///c:/plugins/%C3%A4",+ false,+ ),+ (+ "file:///C:/plugins/Lj/assets/icon.svg",+ "file:///C:/plugins/LJ",+ false,+ ),("file:///C:/plugins/foo2/assets/icon.svg","file:///C:/plugins/foo",@@ -1018,6 +1069,12 @@ fn starts_with_uses_uri_segment_boundaries() {"file://server/share/plugins/foo",true,),+ (+ "file://SERVER/SHARE/PLUGINS/FOO/icon.svg",+ "file://server/share/plugins/foo",+ true,+ ),+ ("file:///WORKSPACE/plugin", "file:///workspace", false),("file://other/share/plugins/foo/icon.svg","file://server/share/plugins/foo",