redesign shared and imported agent cards

src-tauri/src/commands/avatars.rs

@@ -137,6 +137,15 @@ pub struct CachedAvatar {
     pub asset: CachedAvatarAsset,
 }
 
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CachedAvatarAnimation {
+    pub bytes: Vec<u8>,
+    pub mime_type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub alpha_mode: Option<String>,
+}
+
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct AvatarCacheWarmedPayload {
@@ -364,6 +373,46 @@ pub async fn get_avatar_library_snapshot(
     })
 }
 
+#[tauri::command]
+pub async fn read_cached_avatar_animation(
+    app: AppHandle,
+    avatar_ref: String,
+) -> Result<Option<CachedAvatarAnimation>, String> {
+    let cached = get_cached_avatar_for_ref(app, avatar_ref).await?;
+    let Some(cached) = cached else {
+        return Ok(None);
+    };
+    read_cached_avatar_animation_asset(cached.asset)
+}
+
+fn read_cached_avatar_animation_asset(
+    asset: CachedAvatarAsset,
+) -> Result<Option<CachedAvatarAnimation>, String> {
+    if !matches!(asset.mime_type.as_str(), "video/webm" | "video/mp4") {
+        return Ok(None);
+    }
+    let metadata = fs::metadata(&asset.path)
+        .map_err(|error| format!("Failed to inspect cached avatar animation: {error}"))?;
+    if metadata.len() == 0 || metadata.len() > MAX_IMPORTED_AVATAR_BYTES as u64 {
+        return Ok(None);
+    }
+    let bytes = fs::read(&asset.path)
+        .map_err(|error| format!("Failed to read cached avatar animation: {error}"))?;
+    // Recheck the actual payload after reading; metadata is only an early exit
+    // and the cache file could be replaced between the stat and read calls.
+    if bytes.is_empty() || bytes.len() > MAX_IMPORTED_AVATAR_BYTES {
+        return Ok(None);
+    }
+    if validate_imported_avatar_signature(&bytes, &asset.mime_type).is_err() {
+        return Ok(None);
+    }
+    Ok(Some(CachedAvatarAnimation {
+        bytes,
+        mime_type: asset.mime_type,
+        alpha_mode: asset.alpha_mode,
+    }))
+}
+
 #[tauri::command]
 pub async fn get_cached_avatar_for_ref(
     app: AppHandle,
@@ -2493,6 +2542,43 @@ mod tests {
         format!("data:video/webm;base64,{}", BASE64.encode(bytes))
     }
 
+    #[test]
+    fn cached_animation_reader_enforces_type_and_payload_bounds() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("avatar.webm");
+        fs::write(&path, WEBM_SIGNATURE).unwrap();
+        let asset = |mime_type: &str| CachedAvatarAsset {
+            id: "gloopy-1".to_string(),
+            path: path.to_string_lossy().into_owned(),
+            mime_type: mime_type.to_string(),
+            alpha_mode: Some("stacked".to_string()),
+            poster_path: None,
+        };
+
+        let animation = read_cached_avatar_animation_asset(asset("video/webm"))
+            .unwrap()
+            .unwrap();
+        assert_eq!(animation.bytes, WEBM_SIGNATURE);
+        assert_eq!(animation.mime_type, "video/webm");
+        assert_eq!(animation.alpha_mode.as_deref(), Some("stacked"));
+
+        assert!(read_cached_avatar_animation_asset(asset("image/png"))
+            .unwrap()
+            .is_none());
+        fs::write(&path, b"not webm").unwrap();
+        assert!(read_cached_avatar_animation_asset(asset("video/webm"))
+            .unwrap()
+            .is_none());
+        fs::write(&path, []).unwrap();
+        assert!(read_cached_avatar_animation_asset(asset("video/webm"))
+            .unwrap()
+            .is_none());
+        fs::write(&path, vec![0; MAX_IMPORTED_AVATAR_BYTES + 1]).unwrap();
+        assert!(read_cached_avatar_animation_asset(asset("video/webm"))
+            .unwrap()
+            .is_none());
+    }
+
     #[test]
     fn imported_avatar_limit_accounts_for_base64_padding_exactly() {
         for size in [MAX_IMPORTED_AVATAR_BYTES - 1, MAX_IMPORTED_AVATAR_BYTES] {

src-tauri/src/lib.rs

@@ -433,6 +433,7 @@ pub fn run() {
             commands::avatars::refresh_avatar_cache,
             commands::avatars::get_cached_avatar_for_ref,
             commands::avatars::get_cached_avatars_for_refs,
+            commands::avatars::read_cached_avatar_animation,
             commands::avatars::import_user_avatar_data_url,
             commands::avatars::delete_user_avatar,
             commands::cache::clear_local_media_caches,

src/features/agents/agent-snapshot/pngCodec.test.ts

@@ -5,6 +5,7 @@ import {
   decodeAgentImage,
   decodeAvatarAnimation,
   encodeAgentImage,
+  getPngDimensions,
 } from "./pngCodec";
 import {
   AgentSnapshotError,
@@ -112,6 +113,15 @@ function expectCode(
 }
 
 describe("buzz-agent-snapshot PNG codec", () => {
+  it("returns dimensions from a fully validated PNG", () => {
+    expect(getPngDimensions(pngWithDimensions(321, 654))).toEqual({
+      width: 321,
+      height: 654,
+    });
+    expect(() => getPngDimensions(Uint8Array.from([1, 2, 3]))).toThrow(
+      "Invalid PNG signature",
+    );
+  });
   it("round trips animated avatar bytes outside snapshot JSON", () => {
     const animation = {
       bytes: Uint8Array.from([26, 69, 223, 163]),

src/features/agents/agent-snapshot/pngCodec.ts

@@ -60,6 +60,21 @@ function crc32(bytes: Uint8Array): number {
   return (crc ^ 0xffffffff) >>> 0;
 }
 
+export function getPngDimensions(bytes: Uint8Array): {
+  width: number;
+  height: number;
+} {
+  const chunks = parseChunks(bytes);
+  const ihdr = chunks[0];
+  if (!ihdr || ihdr.type !== "IHDR") {
+    throw new AgentSnapshotError("PNG must begin with IHDR", "invalid-png");
+  }
+  return {
+    width: readU32(ihdr.data, 0),
+    height: readU32(ihdr.data, 4),
+  };
+}
+
 function parseChunks(bytes: Uint8Array): Chunk[] {
   if (bytes.length > MAX_SNAPSHOT_PNG_BYTES) {
     throw new AgentSnapshotError(

src/features/agents/ui/AgentImageImportDialog.tsx

@@ -237,7 +237,7 @@ export function AgentImageImportDialog({
       <DialogContent
         size="lg"
         surface="solid"
-        className="bg-card"
+        className="bg-card [&_[data-slot=dialog-close]]:z-20"
         aria-describedby={undefined}
       >
         <DialogHeader