feat: improve CAS commands to handle both UTF-8 and binary data

Author: cablehead

src/commands/serve.rs

@@ -146,7 +146,7 @@ async fn execute_command(command: Command, frame: Frame, store: &Store) -> Resul
             Ok(pipeline_data) => {
                 // Process each value as a .recv event
                 for value in pipeline_data {
-                    let hash = store.cas_insert_sync(&value_to_json(&value).to_string())?;
+                    let hash = store.cas_insert_sync(value_to_json(&value).to_string())?;
                     let _ = store.append(
                         Frame::builder(
                             format!("{}.recv", frame.topic.strip_suffix(".call").unwrap()),

src/nu/commands/cas_command.rs

@@ -54,19 +54,24 @@ impl Command for CasCommand {
             .store
             .cas_reader_sync(hash)
             .map_err(|e| ShellError::IOError { msg: e.to_string() })?;
+
         let mut contents = Vec::new();
         reader
             .read_to_end(&mut contents)
             .map_err(|e| ShellError::IOError { msg: e.to_string() })?;
-        let contents =
-            String::from_utf8(contents).map_err(|e| ShellError::IOError { msg: e.to_string() })?;
 
-        Ok(PipelineData::Value(
-            Value::String {
+        // Try to convert to string if valid UTF-8, otherwise return as binary
+        let value = match String::from_utf8(contents.clone()) {
+            Ok(string) => Value::String {
+                val: string,
+                internal_span: span,
+            },
+            Err(_) => Value::Binary {
                 val: contents,
                 internal_span: span,
             },
-            None,
-        ))
+        };
+
+        Ok(PipelineData::Value(value, None))
     }
 }

src/nu/test_commands.rs

@@ -96,7 +96,7 @@ mod tests {
     }
 
     #[test]
-    fn test_cas_command() {
+    fn test_cas_command_string() {
         let (store, mut engine, _ctx) = setup_test_env();
         engine
             .add_commands(vec![Box::new(commands::cas_command::CasCommand::new(
@@ -112,6 +112,27 @@ mod tests {
         assert_eq!(content, "test content");
     }
 
+    #[test]
+    fn test_cas_command_binary() {
+        let (store, mut engine, _ctx) = setup_test_env();
+        engine
+            .add_commands(vec![Box::new(commands::cas_command::CasCommand::new(
+                store.clone(),
+            ))])
+            .unwrap();
+
+        // Test binary data retrieval
+        let binary_data = vec![0, 159, 146, 150]; // Non-UTF8 bytes
+        let hash = store.cas_insert_sync(&binary_data).unwrap();
+
+        let value = nu_eval(&engine, PipelineData::empty(), format!(".cas {}", hash));
+
+        // The value should be returned as binary
+        assert!(matches!(value, Value::Binary { .. }));
+        let retrieved_data = value.as_binary().unwrap();
+        assert_eq!(retrieved_data, &binary_data);
+    }
+
     #[test]
     fn test_head_command() -> Result<(), Error> {
         let (store, mut engine, ctx) = setup_test_env();

src/store/mod.rs

@@ -452,11 +452,11 @@ impl Store {
         cacache::WriteOpts::new().open_hash_sync(self.path.join("cacache"))
     }
 
-    pub async fn cas_insert(&self, content: &str) -> cacache::Result<ssri::Integrity> {
+    pub async fn cas_insert(&self, content: impl AsRef<[u8]>) -> cacache::Result<ssri::Integrity> {
         cacache::write_hash(&self.path.join("cacache"), content).await
     }
 
-    pub fn cas_insert_sync(&self, content: &str) -> cacache::Result<ssri::Integrity> {
+    pub fn cas_insert_sync(&self, content: impl AsRef<[u8]>) -> cacache::Result<ssri::Integrity> {
         cacache::write_hash_sync(self.path.join("cacache"), content)
     }