refactor(server): replace custom remote clients with macro-based implementation

- Replaced manual remote client functions with remote_client! macro for archive, blame, branch, commit, and diff services
- Simplified remote client creation logic using declarative macro approach
- Maintained same functionality while reducing code duplication across services

security(bare): enhance path traversal protection with comprehensive validation

- Added early relative_path validation to prevent path traversal attacks
- Implemented unified path validation to avoid TOCTOU race conditions
- Enhanced canonicalization checks for both existing and non-existent paths
- Added detailed logging for path traversal detection attempts

feat(cache): migrate from CLruCache to Moka with TTL and invalidation support

- Replaced clru dependency with moka for improved caching capabilities
- Added 300-second time-to-live for cache entries
- Implemented repository-specific cache invalidation mechanism
- Enhanced cache operations with thread-safe async support

refactor(commit): improve security validation for commit operations

- Added ref name validation to prevent command injection in cherry_pick_commit
- Implemented revision validation for commit selectors
- Added comprehensive input validation for create_commit parameters
- Enhanced file path validation to prevent traversal

tests/macro_test.rs

@@ -0,0 +1,184 @@
+use gitks::error::GitResult;
+use gitks::pb::object_selector::Selector;
+use gitks::pb::{ObjectName, ObjectSelector};
+
+fn test_macro(selector: Option<ObjectSelector>) -> GitResult<String> {
+    let result = gitks::resolve_revision!(selector);
+    Ok(result)
+}
+
+fn test_macro_with_default(selector: Option<ObjectSelector>, default: &str) -> GitResult<String> {
+    let result = gitks::resolve_revision!(selector, default);
+    Ok(result)
+}
+
+#[test]
+fn test_resolve_revision_with_oid() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Oid(gitks::pb::Oid {
+            hex: "abc1234567890123456789012345678901234567".to_string(),
+            value: vec![],
+            format: gitks::pb::ObjectFormat::Sha1 as i32,
+        })),
+    });
+
+    let result = test_macro(selector).unwrap();
+    assert_eq!(result, "abc1234567890123456789012345678901234567");
+}
+
+#[test]
+fn test_resolve_revision_with_valid_revision() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "main".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector).unwrap();
+    assert_eq!(result, "main");
+}
+
+#[test]
+fn test_resolve_revision_with_valid_branch() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "feature/new-api".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector).unwrap();
+    assert_eq!(result, "feature/new-api");
+}
+
+#[test]
+fn test_resolve_revision_with_head() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "HEAD".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector).unwrap();
+    assert_eq!(result, "HEAD");
+}
+
+#[test]
+fn test_resolve_revision_with_ancestry() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "main~3".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector).unwrap();
+    assert_eq!(result, "main~3");
+}
+
+#[test]
+fn test_resolve_revision_none_defaults_to_head() {
+    let result = test_macro(None).unwrap();
+    assert_eq!(result, "HEAD");
+}
+
+#[test]
+fn test_resolve_revision_with_custom_default() {
+    let result = test_macro_with_default(None, "develop").unwrap();
+    assert_eq!(result, "develop");
+}
+
+#[test]
+fn test_resolve_revision_empty_selector() {
+    let selector = Some(ObjectSelector { selector: None });
+    let result = test_macro(selector).unwrap();
+    assert_eq!(result, "HEAD");
+}
+
+#[test]
+fn test_resolve_revision_empty_with_custom_default() {
+    let selector = Some(ObjectSelector { selector: None });
+    let result = test_macro_with_default(selector, "custom-branch").unwrap();
+    assert_eq!(result, "custom-branch");
+}
+
+#[test]
+fn test_resolve_revision_rejects_dangerous() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "branch;rm -rf /".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_resolve_revision_rejects_traversal() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "../etc/passwd".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_resolve_revision_rejects_excessive_depth() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "main~99999".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_resolve_revision_rejects_too_long() {
+    let long_rev = "a".repeat(300);
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName { revision: long_rev })),
+    });
+
+    let result = test_macro(selector);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_resolve_revision_accepts_valid_hex() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "deadbeef1234567890abcdef".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector).unwrap();
+    assert_eq!(result, "deadbeef1234567890abcdef");
+}
+
+#[test]
+fn test_resolve_revision_accepts_ref_prefix() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "ref:refs/heads/main".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector).unwrap();
+    assert_eq!(result, "ref:refs/heads/main");
+}
+
+#[test]
+fn test_resolve_revision_accepts_tree_suffix() {
+    let selector = Some(ObjectSelector {
+        selector: Some(Selector::Revision(ObjectName {
+            revision: "main^{tree}".to_string(),
+        })),
+    });
+
+    let result = test_macro(selector).unwrap();
+    assert_eq!(result, "main^{tree}");
+}