Add overlay planning commands

crates/geth-crypto/src/lib.rs

@@ -39,9 +39,18 @@ impl AgentKey {
     }
 
     pub fn load(path: &Path) -> Result<Self, CryptoError> {
-        let hex_key = std::fs::read_to_string(path)?;
-        let bytes = hex::decode(hex_key.trim())?;
-        let key_bytes: [u8; 32] = bytes.try_into().map_err(|_| CryptoError::InvalidKey)?;
+        let key_file = std::fs::read(path)?;
+        let bytes = if let Ok(hex_key) = std::str::from_utf8(&key_file) {
+            let trimmed = hex_key.trim();
+            if trimmed.len() == 64 && trimmed.bytes().all(|byte| byte.is_ascii_hexdigit()) {
+                hex::decode(trimmed)?
+            } else {
+                key_file
+            }
+        } else {
+            key_file
+        };
+        let key_bytes = signing_key_bytes_from_file(bytes)?;
         Ok(Self {
             signing_key: SigningKey::from_bytes(&key_bytes),
         })
@@ -86,6 +95,14 @@ impl AgentKey {
     }
 }
 
+fn signing_key_bytes_from_file(bytes: Vec<u8>) -> Result<[u8; 32], CryptoError> {
+    match bytes.len() {
+        32 => bytes.try_into().map_err(|_| CryptoError::InvalidKey),
+        64 => bytes[..32].try_into().map_err(|_| CryptoError::InvalidKey),
+        _ => Err(CryptoError::InvalidKey),
+    }
+}
+
 pub fn verify(public_key: &[u8], message: &[u8], signature: &[u8]) -> Result<(), CryptoError> {
     let key_bytes: [u8; 32] = public_key.try_into().map_err(|_| CryptoError::InvalidKey)?;
     let verifying_key =
@@ -132,6 +149,35 @@ mod tests {
         assert_eq!(first.agent_id(), second.agent_id());
     }
 
+    #[test]
+    fn agent_identity_loads_raw_32_byte_key_material() {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let path = dir.path().join("agent.ed25519");
+        std::fs::write(&path, [0_u8; 32]).expect("write raw key");
+
+        let loaded = AgentKey::load(&path).expect("load raw key");
+
+        assert_eq!(
+            loaded.signing_key.to_bytes(),
+            [0_u8; 32],
+            "raw binary keys can contain bytes that are valid UTF-8 but not hex text"
+        );
+    }
+
+    #[test]
+    fn agent_identity_loads_raw_64_byte_keypair_material() {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let path = dir.path().join("agent.ed25519");
+        let key = AgentKey::generate();
+        let mut keypair = key.signing_key.to_bytes().to_vec();
+        keypair.extend_from_slice(&key.verifying_key().to_bytes());
+        std::fs::write(&path, keypair).expect("write raw keypair");
+
+        let loaded = AgentKey::load(&path).expect("load raw keypair");
+
+        assert_eq!(key.agent_id(), loaded.agent_id());
+    }
+
     #[test]
     fn blake3_helper_matches_known_hash() {
         assert_eq!(