Merge pull request #144 from hyperware-ai/develop

develop 1.1.0

Author: nick1udwig

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "hyperware_process_lib"
 authors = ["Sybil Technologies AG"]
-version = "1.0.6"
+version = "1.1.0"
 edition = "2021"
 description = "A library for writing Hyperware processes in Rust."
 homepage = "https://hyperware.ai"
@@ -22,6 +22,7 @@ alloy = { version = "0.8.1", features = [
     "rpc-types",
 ] }
 anyhow = "1.0"
+base64 = "0.22.1"
 bincode = "1.3.3"
 color-eyre = { version = "0.6", features = ["capture-spantrace"], optional = true }
 http = "1.0.0"

Cargo.toml

@@ -77,7 +77,7 @@ pub use types::{
     address::{Address, AddressParseError},
     capability::Capability,
     lazy_load_blob::LazyLoadBlob,
-    message::{Message, _wit_message_to_message},
+    message::{BuildError, Message, _wit_message_to_message},
     on_exit::OnExit,
     package_id::PackageId,
     process_id::{ProcessId, ProcessIdParseError},

src/lib.rs

@@ -42,7 +42,14 @@ pub struct TerminalWriterMaker {
 
 impl std::io::Write for RemoteWriter {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        let body = serde_json::json!({"Log": buf});
+        let log = if let Ok(json_log) = serde_json::from_slice::<serde_json::Value>(buf) {
+            serde_json::to_string(&json_log).unwrap()
+        } else {
+            let string = String::from_utf8(buf.to_vec())
+                .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
+            string
+        };
+        let body = serde_json::json!({"Log": log});
         let body = serde_json::to_vec(&body).unwrap();
         Request::to(&self.target).body(body).send().unwrap();
         Ok(buf.len())

src/logging.rs

@@ -1,3 +1,10 @@
+use std::fmt;
+use std::marker::PhantomData;
+
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
+use serde::de::{self, Visitor};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
 pub use crate::LazyLoadBlob;
 
 /// `LazyLoadBlob` is defined in the wit bindings, but constructors and methods here.
@@ -42,3 +49,94 @@ impl std::cmp::PartialEq for LazyLoadBlob {
         self.mime == other.mime && self.bytes == other.bytes
     }
 }
+
+impl Serialize for LazyLoadBlob {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        // Create a struct with 2 fields
+        use serde::ser::SerializeStruct;
+        let mut state = serializer.serialize_struct("LazyLoadBlob", 2)?;
+
+        // Serialize mime normally (serde handles Option automatically)
+        state.serialize_field("mime", &self.mime)?;
+
+        let base64_data = BASE64.encode(&self.bytes);
+        state.serialize_field("bytes", &base64_data)?;
+
+        state.end()
+    }
+}
+
+// Custom visitor for deserialization
+struct LazyLoadBlobVisitor {
+    marker: PhantomData<fn() -> LazyLoadBlob>,
+}
+
+impl LazyLoadBlobVisitor {
+    fn new() -> Self {
+        LazyLoadBlobVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'de> Visitor<'de> for LazyLoadBlobVisitor {
+    type Value = LazyLoadBlob;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a struct with mime and bytes fields")
+    }
+
+    fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+    where
+        M: de::MapAccess<'de>,
+    {
+        let mut mime = None;
+        let mut bytes_base64 = None;
+
+        // Extract each field from the map
+        while let Some(key) = map.next_key::<String>()? {
+            match key.as_str() {
+                "mime" => {
+                    if mime.is_some() {
+                        return Err(de::Error::duplicate_field("mime"));
+                    }
+                    mime = map.next_value()?;
+                }
+                "bytes" => {
+                    if bytes_base64.is_some() {
+                        return Err(de::Error::duplicate_field("bytes"));
+                    }
+                    bytes_base64 = Some(map.next_value::<String>()?);
+                }
+                _ => {
+                    // Skip unknown fields
+                    let _ = map.next_value::<de::IgnoredAny>()?;
+                }
+            }
+        }
+
+        let bytes_base64 = bytes_base64.ok_or_else(|| de::Error::missing_field("bytes"))?;
+
+        let bytes = BASE64
+            .decode(bytes_base64.as_bytes())
+            .map_err(|err| de::Error::custom(format!("Invalid base64: {}", err)))?;
+
+        Ok(LazyLoadBlob { mime, bytes })
+    }
+}
+
+impl<'de> Deserialize<'de> for LazyLoadBlob {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_struct(
+            "LazyLoadBlob",
+            &["mime", "bytes"],
+            LazyLoadBlobVisitor::new(),
+        )
+    }
+}

src/types/lazy_load_blob.rs

@@ -27,7 +27,7 @@ pub enum Message {
     },
 }
 
-#[derive(Debug, Error, Serialize, Deserialize)]
+#[derive(Clone, Debug, Error, Serialize, Deserialize)]
 pub enum BuildError {
     #[error("no body set for message")]
     NoBody,

src/types/message.rs

@@ -1,7 +1,7 @@
 use crate::{Address, LazyLoadBlob, Message, _wit_message_to_message};
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct SendError {
     pub kind: SendErrorKind,
     pub target: Address,

src/types/send_error.rs

@@ -6,6 +6,7 @@ use crate::{get_blob, PackageId};
 /// VFS (Virtual File System) helper struct for a file.
 /// Opening or creating a `File` will give you a `Result<File, VfsError>`.
 /// You can call its impl functions to interact with it.
+#[derive(serde::Deserialize, serde::Serialize)]
 pub struct File {
     pub path: String,
     pub timeout: u64,