macltok

public

Star0

Fork 0

Watch0

47 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `fa51490b6ae9`

tarball

atagen <boss@atagen.co>2026-10-24 08:47 UTC

10 files changed+1148-48

packs: send stickers, edit msc2545 packs and clone them onto your homeserver

Every edit reads the server's copy and rewrites only the keys it owns, because the store lags a sync behind and malice doesn't model info, attribution or unknown fields. Edits run in order per pack on the mutation scheduler, but rehosting stays off it and only queues for the final write, so a long clone_pack doesn't block other edits to the same pack. Emptied packs are still the only ones dropped from image_packs, which lets a fresh pack show up before it has images.

Modified file: src/engine/media.rs+13 additions@@ -353,6 +353,19 @@ fn too_large(message: &'static str) -> Error {
     Error::new(ErrorKind::MediaTooLarge, message)
 }
 
+pub(crate) async fn download_file(
+    client: &Client,
+    source: MediaSource,
+    mimetype: Option<String>,
+    max_bytes: usize,
+) -> Result<Media, Error> {
+    let request = MediaRequestParameters {
+        source,
+        format: MediaFormat::File,
+    };
+    fetch(client.clone(), request, mimetype, max_bytes).await
+}
+
 async fn fetch(
     client: Client,
     request: MediaRequestParameters,

Modified file: src/engine/mod.rs+82 additions−2 deletions@@ -2,6 +2,7 @@ mod commands;
 pub(crate) mod executor;
 mod media;
 mod mutations;
+mod packs;
 mod prepare;
 mod room;
 mod session;
@@ -35,13 +36,15 @@ use self::{
     commands::Job,
     executor::{EngineBoxFuture, TaskSet},
     mutations::{Mutation, MutationJob},
+    packs::PackEdit,
     room::{ActorNote, ActorRequest, RoomActor},
     timeline::{SessionContext, Supervisor},
 };
 use crate::{
     AccountCommand, ClientHandle, Command, CommandOutput, ConnectionState, EncryptionCommand,
-    EngineErrorKind, EngineFailure, Error, ErrorKind, Event, EventStream, LifecycleCommand,
-    MediaCommand, NotificationCommand, RoomCommand, Termination, TimelineCommand,
+    EngineErrorKind, EngineFailure, Error, ErrorKind, Event, EventStream, ImagePackSource,
+    LifecycleCommand, MediaCommand, NotificationCommand, PackCommand, RoomCommand, Termination,
+    TimelineCommand,
     normalise::{ROOM_PACKS, ROOM_PREVIEW_URLS},
     transport::{DriverPort, Request, Responder, transport_pair},
 };
@@ -744,6 +747,7 @@ impl Engine {
             Command::Notification(command) => {
                 enqueue(&self.notifications, Job { command, reply });
             }
+            Command::Pack(command) => self.pack(command, reply),
         }
         None
     }
@@ -767,6 +771,82 @@ impl Engine {
             });
     }
 
+    fn pack(&mut self, command: PackCommand, reply: Responder) {
+        let edit = |pack, edit| Mutation::Pack { pack, edit };
+        let mutation = match command {
+            PackCommand::CreateRoomPack {
+                room_id,
+                state_key,
+                display_name,
+            } => edit(
+                ImagePackSource::Room { room_id, state_key },
+                PackEdit::Create { display_name },
+            ),
+            PackCommand::Delete(pack) => edit(pack, PackEdit::Delete),
+            PackCommand::SetMeta {
+                pack,
+                display_name,
+                avatar,
+                usage,
+            } => edit(
+                pack,
+                PackEdit::Meta {
+                    display_name,
+                    avatar,
+                    usage,
+                },
+            ),
+            PackCommand::PutImage {
+                pack,
+                shortcode,
+                mxc,
+                body,
+                usage,
+                info,
+            } => edit(
+                pack,
+                PackEdit::Put {
+                    shortcode,
+                    mxc,
+                    body,
+                    usage,
+                    info,
+                },
+            ),
+            PackCommand::RenameImage { pack, from, to } => {
+                edit(pack, PackEdit::Rename { from, to })
+            }
+            PackCommand::RemoveImage { pack, shortcode } => {
+                edit(pack, PackEdit::Remove { shortcode })
+            }
+            PackCommand::SetEnabledEverywhere {
+                room_id,
+                state_key,
+                enabled,
+            } => Mutation::PackEnabledEverywhere {
+                room_id,
+                state_key,
+                enabled,
+            },
+            command => {
+                let client = self.client.clone();
+                let mutations = self.mutations.clone();
+                let max_bytes = self.config.max_media_bytes;
+                self.tasks.spawn(TaskContext::Command("pack"), async move {
+                    reply.send(packs::run_detached(client, mutations, max_bytes, command).await);
+                });
+                return;
+            }
+        };
+        enqueue(
+            &self.mutations,
+            Job {
+                command: mutation,
+                reply,
+            },
+        );
+    }
+
     fn upload(&mut self, upload: crate::AttachmentUpload, reply: Responder) {
         let Some(room) = self.client.get_room(upload.timeline_id.room_id()) else {
             return reply.done(Err(Error::room_unknown()));

Modified file: src/engine/mutations.rs+35 additions−2 deletions@@ -30,9 +30,12 @@ use tokio::sync::mpsc;
 
 use super::commands::{Job, guarded};
 use super::executor::TaskSet;
+use super::packs::{self, PackEdit};
 use crate::{
-    CommandOutput, CreateRoomOptions, Error, ErrorKind, PowerLevelChanges, RoomCommand, RoomPreset,
-    RoomVisibility, normalise::stored_space_order, space_order,
+    CommandOutput, CreateRoomOptions, Error, ErrorKind, ImagePackSource, PowerLevelChanges,
+    RoomCommand, RoomPreset, RoomVisibility,
+    normalise::{ENABLED_ROOMS, USER_PACK, stored_space_order},
+    space_order,
 };
 
 /// state changes that must not race each other. same room, same alias, same dm
@@ -48,6 +51,15 @@ pub(super) enum Mutation {
         ignored: bool,
     },
     ReorderSpaces(Vec<OwnedRoomId>),
+    Pack {
+        pack: ImagePackSource,
+        edit: PackEdit,
+    },
+    PackEnabledEverywhere {
+        room_id: OwnedRoomId,
+        state_key: String,
+        enabled: bool,
+    },
 }
 
 pub(super) type MutationJob = Job<Mutation>;
@@ -132,6 +144,17 @@ fn key(mutation: &Mutation, server: Option<&ruma::ServerName>) -> Option<Key> {
         Mutation::ReorderSpaces(_) => {
             return Some(Key::AccountData(space_order::EVENT_TYPE.to_owned()));
         }
+        Mutation::Pack {
+            pack: ImagePackSource::User,
+            ..
+        } => return Some(Key::AccountData(USER_PACK.to_owned())),
+        Mutation::Pack {
+            pack: ImagePackSource::Room { room_id, .. },
+            ..
+        } => room_id,
+        Mutation::PackEnabledEverywhere { .. } => {
+            return Some(Key::AccountData(ENABLED_ROOMS.to_owned()));
+        }
         Mutation::Room(RoomCommand::Join { room, .. }) => {
             return Some(match OwnedRoomId::try_from(room.clone()) {
                 Ok(room_id) => Key::Room(room_id),
@@ -216,6 +239,16 @@ async fn execute(
         Mutation::ReorderSpaces(order) => {
             return reorder_spaces(client, &fresh.orders, order).await.map(done);
         }
+        Mutation::Pack { pack, edit } => return packs::edit_pack(client, &pack, edit).await,
+        Mutation::PackEnabledEverywhere {
+            room_id,
+            state_key,
+            enabled,
+        } => {
+            return packs::set_enabled_everywhere(client, room_id, state_key, enabled)
+                .await
+                .map(done);
+        }
         Mutation::Room(command) => command,
     };
     let fresh_dms = &fresh.dms;

Added file: src/engine/packs.rs+585 additions@@ -0,0 +1,585 @@
+use futures_util::{StreamExt, stream};
+use matrix_sdk::{
+    Client,
+    ruma::{
+        api::{client::state::get_state_event_for_key, error::ErrorKind as ApiErrorKind},
+        events::{GlobalAccountDataEventType, StateEventType, room::MediaSource},
+        serde::{JsonObject, Raw},
+    },
+};
+use ruma::{OwnedEventId, OwnedMxcUri, OwnedRoomId};
+use serde_json::{Value as JsonValue, json};
+use tokio::sync::mpsc;
+
+use super::{
+    commands::{self, Job},
+    enqueue, media,
+    mutations::{Mutation, MutationJob},
+};
+use crate::{
+    CommandOutput, Error, ErrorKind, ImagePackSource, PackCommand, PackImageInfo, PackUsage, Patch,
+    normalise::{ENABLED_ROOMS, ROOM_PACKS, USER_PACK, resolve_pack_id, stored_pack},
+    transport::Responder,
+};
+
+/// read-modify-writes of one pack, which run in order per pack
+pub(super) enum PackEdit {
+    Create {
+        display_name: String,
+    },
+    Delete,
+    Meta {
+        display_name: Patch<String>,
+        avatar: Patch<OwnedMxcUri>,
+        usage: Patch<Vec<PackUsage>>,
+    },
+    Put {
+        shortcode: String,
+        mxc: OwnedMxcUri,
+        body: Option<String>,
+        usage: Option<Vec<PackUsage>>,
+        info: Option<PackImageInfo>,
+    },
+    Rename {
+        from: String,
+        to: String,
+    },
+    Remove {
+        shortcode: String,
+    },
+    /// copies already on our homeserver. `create` is the pack meta for a room pack that doesn't exist yet
+    Insert {
+        images: Vec<(String, JsonObject)>,
+        create: Option<JsonObject>,
+    },
+}
+
+pub(super) async fn edit_pack(
+    client: &Client,
+    pack: &ImagePackSource,
+    edit: PackEdit,
+) -> Result<CommandOutput, Error> {
+    let current = fetch_pack(client, pack).await?;
+    let mut content = current.clone().unwrap_or_default();
+    let mut output = CommandOutput::Done;
+    match edit {
+        PackEdit::Create { display_name } => {
+            if !content.is_empty() {
+                return Err(Error::new(
+                    ErrorKind::Invalid,
+                    "that state key already holds a pack",
+                ));
+            }
+            content = object(json!({ "pack": { "display_name": display_name }, "images": {} }));
+        }
+        PackEdit::Delete => content.clear(),
+        PackEdit::Meta {
+            display_name,
+            avatar,
+            usage,
+        } => {
+            let meta = child(&mut content, "pack");
+            patch(meta, "display_name", display_name, JsonValue::String);
+            patch(meta, "avatar_url", avatar, |uri| uri.to_string().into());
+            patch(meta, "usage", usage, usage_json);
+        }
+        PackEdit::Put {
+            shortcode,
+            mxc,
+            body,
+            usage,
+            info,
+        } => {
+            let images = child(&mut content, "images");
+            let mut image = match images.remove(&shortcode) {
+                Some(JsonValue::Object(image)) => image,
+                _ => JsonObject::new(),
+            };
+            let same_media = image.get("url").and_then(JsonValue::as_str) == Some(mxc.as_str());
+            image.insert("url".to_owned(), mxc.to_string().into());
+            if let Some(body) = body {
+                image.insert("body".to_owned(), body.into());
+            }
+            if let Some(usage) = usage {
+                image.insert("usage".to_owned(), usage_json(usage));
+            }
+            match info {
+                Some(info) => {
+                    image.insert("info".to_owned(), info_json(info));
+                }
+                None if !same_media => {
+                    image.remove("info");
+                }
+                None => {}
+            }
+            images.insert(shortcode, image.into());
+        }
+        PackEdit::Rename { from, to } => {
+            let images = child(&mut content, "images");
+            if images.contains_key(&to) {
+                return Err(Error::new(ErrorKind::Invalid, "that shortcode is taken"));
+            }
+            let image = images
+                .remove(&from)
+                .ok_or_else(|| Error::new(ErrorKind::Invalid, "no image has that shortcode"))?;
+            images.insert(to, image);
+        }
+        PackEdit::Remove { shortcode } => {
+            child(&mut content, "images").remove(&shortcode);
+        }
+        PackEdit::Insert { images, create } => {
+            if content.is_empty() {
+                match (create, pack) {
+                    (Some(meta), _) => {
+                        content.insert("pack".to_owned(), meta.into());
+                    }
+                    (None, ImagePackSource::Room { .. }) => {
+                        return Err(Error::new(
+                            ErrorKind::Invalid,
+                            "there's no pack there to copy into",
+                        ));
+                    }
+                    (None, ImagePackSource::User) => {}
+                }
+            }
+            let target = child(&mut content, "images");
+            let shortcodes = images
+                .into_iter()
+                .map(|(shortcode, image)| {
+                    let free = free_shortcode(target, &shortcode);
+                    target.insert(free.clone(), image.into());
+                    free
+                })
+                .collect();
+            output = CommandOutput::Cloned {
+                shortcodes,
+                skipped: Vec::new(),
+            };
+        }
+    }
+    if current.as_ref() != Some(&content) {
+        write_pack(client, pack, content).await?;
+    }
+    Ok(output)
+}
+
+pub(super) async fn set_enabled_everywhere(
+    client: &Client,
+    room_id: OwnedRoomId,
+    state_key: String,
+    enabled: bool,
+) -> Result<(), Error> {
+    let account = client.account();
+    let current = account
+        .fetch_account_data(GlobalAccountDataEventType::from(ENABLED_ROOMS))
+        .await
+        .map_err(|source| Error::from_sdk("reading enabled packs failed", source))?
+        .map(|raw| parse(raw.json().get()))
+        .transpose()?;
+    let mut content = current.clone().unwrap_or_default();
+    let rooms = child(&mut content, "rooms");
+    if enabled {
+        child(rooms, room_id.as_str()).insert(state_key, JsonObject::new().into());
+    } else {
+        let state_keys = child(rooms, room_id.as_str());
+        state_keys.remove(&state_key);
+        if state_keys.is_empty() {
+            rooms.remove(room_id.as_str());
+        }
+    }
+    if current.as_ref() == Some(&content) {
+        return Ok(());
+    }
+    account
+        .set_account_data_raw(ENABLED_ROOMS.into(), raw(&content))
+        .await
+        .map(drop)
+        .map_err(|source| Error::from_sdk("writing enabled packs failed", source))
+}
+
+/// the commands that download, upload or send, so they stay off the per-pack queue and only
+/// take their turn for the final write
+pub(super) async fn run_detached(
+    client: Client,
+    mutations: mpsc::Sender<MutationJob>,
+    max_bytes: usize,
+    command: PackCommand,
+) -> Result<CommandOutput, Error> {
+    match command {
+        PackCommand::SendSticker {
+            room_id,
+            pack_id,
+            shortcode,
+        } => send_sticker(&client, room_id, &pack_id, &shortcode)
+            .await
+            .map(|()| CommandOutput::Done),
+        PackCommand::Rehost(mxc) => rehost(&client, mxc, None, max_bytes)
+            .await
+            .map(CommandOutput::Mxc),
+        PackCommand::CloneImage {
+            from_pack,
+            shortcode,
+            to,
+        } => {
+            let image = pack_image(&client, &from_pack, &shortcode).await?;
+            let image = rehost_image(&client, image, max_bytes).await?;
+            insert(&mutations, to, vec![(shortcode, image)], None, Vec::new()).await
+        }
+        PackCommand::CloneSticker {
+            room_id,
+            event_id,
+            to,
+            shortcode,
+        } => {
+            let image = sticker_image(&client, room_id, event_id).await?;
+            let image = rehost_image(&client, image, max_bytes).await?;
+            insert(&mutations, to, vec![(shortcode, image)], None, Vec::new()).await
+        }
+        PackCommand::ClonePack {
+            from_pack,
+            to,
+            display_name,
+        } => clone_pack(&client, &mutations, max_bytes, &from_pack, to, display_name).await,
+        _ => Err(Error::new(ErrorKind::Other, "pack command was misrouted")),
+    }
+}
+
+async fn clone_pack(
+    client: &Client,
+    mutations: &mpsc::Sender<MutationJob>,
+    max_bytes: usize,
+    from_pack: &str,
+    to: ImagePackSource,
+    display_name: Option<String>,
+) -> Result<CommandOutput, Error> {
+    let source = resolve_pack_id(client, from_pack)
+        .ok_or_else(|| Error::new(ErrorKind::Invalid, "no pack has that id"))?;
+    let content = stored_pack(client, &source)
+        .await?
+        .ok_or_else(|| Error::new(ErrorKind::Invalid, "that pack is empty"))?;
+    let mut meta = match content.get("pack") {
+        Some(JsonValue::Object(meta)) => meta.clone(),
+        _ => JsonObject::new(),
+    };
+    let images: Vec<(String, JsonObject)> = match content.get("images") {
+        Some(JsonValue::Object(images)) => images
+            .iter()
+            .filter_map(|(shortcode, image)| {
+                let image = with_pack_usage(image.as_object()?.clone(), &meta);
+                Some((shortcode.clone(), image))
+            })
+            .collect(),
+        _ => Vec::new(),
+    };
+    let results: Vec<_> = stream::iter(images)
+        .map(|(shortcode, image)| async move {
+            match rehost_image(client, image, max_bytes).await {
+                Ok(image) => Ok((shortcode, image)),
+                Err(error) => {
+                    tracing::debug!(%error, shortcode, "skipping an image that wouldn't rehost");
+                    Err(shortcode)
+                }
+            }
+        })
+        .buffered(4)
+        .collect()
+        .await;
+    let (copies, skipped): (Vec<_>, Vec<_>) = results.into_iter().partition(Result::is_ok);
+    let copies = copies.into_iter().filter_map(Result::ok).collect();
+    let skipped = skipped.into_iter().filter_map(Result::err).collect();
+    let create = match to {
+        ImagePackSource::User => None,
+        ImagePackSource::Room { .. } => {
+            if let Some(display_name) = display_name {
+                meta.insert("display_name".to_owned(), display_name.into());
+            }
+            meta.remove("usage");
+            if let Some(avatar) = meta.remove("avatar_url").and_then(|uri| mxc(&uri))
+                && let Ok(avatar) = rehost(client, avatar, None, max_bytes).await
+            {
+                meta.insert("avatar_url".to_owned(), avatar.to_string().into());
+            }
+            Some(meta)
+        }
+    };
+    insert(mutations, to, copies, create, skipped).await
+}
+
+async fn insert(
+    mutations: &mpsc::Sender<MutationJob>,
+    pack: ImagePackSource,
+    images: Vec<(String, JsonObject)>,
+    create: Option<JsonObject>,
+    skipped: Vec<String>,
+) -> Result<CommandOutput, Error> {
+    let (reply, answer) = Responder::channel();
+    let command = Mutation::Pack {
+        pack,
+        edit: PackEdit::Insert { images, create },
+    };
+    enqueue(mutations, Job { command, reply });
+    match answer.await? {
+        CommandOutput::Cloned { shortcodes, .. } => Ok(CommandOutput::Cloned {
+            shortcodes,
+            skipped,
+        }),
+        output => Ok(output),
+    }
+}
+
+async fn send_sticker(
+    client: &Client,
+    room_id: OwnedRoomId,
+    pack_id: &str,
+    shortcode: &str,
+) -> Result<(), Error> {
+    let room = client.get_room(&room_id).ok_or_else(Error::room_unknown)?;
+    let image = pack_image(client, pack_id, shortcode).await?;
+    let url = image
+        .get("url")
+        .and_then(mxc)
+        .ok_or_else(|| Error::new(ErrorKind::Invalid, "that image has no usable url"))?;
+    let content = json!({
+        "body": image.get("body").and_then(JsonValue::as_str).unwrap_or(shortcode),
+        "url": url,
+        "info": image.get("info").cloned().unwrap_or_else(|| json!({})),
+    });
+    room.send_queue()
+        .send_raw(raw(&object(content)), "m.sticker".to_owned())
+        .await
+        .map(drop)
+        .map_err(|source| {
+            Error::with_source(ErrorKind::Store, "queueing the sticker failed", source)
+        })
+}
+
+/// the image with its pack's usage folded in, so it means the same once it leaves the pack
+async fn pack_image(client: &Client, pack_id: &str, shortcode: &str) -> Result<JsonObject, Error> {
+    let source = resolve_pack_id(client, pack_id)
+        .ok_or_else(|| Error::new(ErrorKind::Invalid, "no pack has that id"))?;
+    let content = stored_pack(client, &source).await?.unwrap_or_default();
+    let image = content
+        .get("images")
+        .and_then(|images| images.get(shortcode))
+        .and_then(JsonValue::as_object)
+        .ok_or_else(|| Error::new(ErrorKind::Invalid, "no image has that shortcode"))?
+        .clone();
+    let meta = content
+        .get("pack")
+        .and_then(JsonValue::as_object)
+        .cloned()
+        .unwrap_or_default();
+    Ok(with_pack_usage(image, &meta))
+}
+
+async fn sticker_image(
+    client: &Client,
+    room_id: OwnedRoomId,
+    event_id: OwnedEventId,
+) -> Result<JsonObject, Error> {
+    let room = client.get_room(&room_id).ok_or_else(Error::room_unknown)?;
+    let event = room
+        .load_or_fetch_event(&event_id, None)
+        .await
+        .map_err(|source| Error::from_sdk("loading the sticker failed", source))?;
+    let raw = event.raw();
+    if raw.get_field::<String>("type").ok().flatten().as_deref() != Some("m.sticker") {
+        return Err(Error::new(ErrorKind::Invalid, "that event isn't a sticker"));
+    }
+    let content = raw
+        .get_field::<JsonObject>("content")
+        .ok()
+        .flatten()
+        .unwrap_or_default();
+    let mut image = JsonObject::new();
+    for key in ["url", "body", "info"] {
+        if let Some(value) = content.get(key) {
+            image.insert(key.to_owned(), value.clone());
+        }
+    }
+    image.insert("usage".to_owned(), usage_json(vec![PackUsage::Sticker]));
+    Ok(image)
+}
+
+async fn rehost_image(
+    client: &Client,
+    mut image: JsonObject,
+    max_bytes: usize,
+) -> Result<JsonObject, Error> {
+    let url = image
+        .get("url")
+        .and_then(mxc)
+        .ok_or_else(|| Error::new(ErrorKind::Invalid, "that image has no usable url"))?;
+    let mimetype = image
+        .get("info")
+        .and_then(|info| info.get("mimetype"))
+        .and_then(JsonValue::as_str)
+        .map(str::to_owned);
+    let url = rehost(client, url, mimetype, max_bytes).await?;
+    image.insert("url".to_owned(), url.to_string().into());
+    Ok(image)
+}
+
+pub(super) async fn rehost(
+    client: &Client,
+    mxc: OwnedMxcUri,
+    mimetype: Option<String>,
+    max_bytes: usize,
+) -> Result<OwnedMxcUri, Error> {
+    let homeserver = client.user_id().map(ruma::UserId::server_name);
+    if mxc
+        .server_name()
+        .ok()
+        .is_some_and(|server| Some(server) == homeserver)
+    {
+        return Ok(mxc);
+    }
+    let media = media::download_file(client, MediaSource::Plain(mxc), mimetype, max_bytes).await?;
+    commands::upload_media(client, &media.mimetype, media.bytes.to_vec(), max_bytes).await
+}
+
+/// the server's copy, since the store lags a sync behind and an edit made just before would be lost
+async fn fetch_pack(client: &Client, pack: &ImagePackSource) -> Result<Option<JsonObject>, Error> {
+    match pack {
+        ImagePackSource::User => client
+            .account()
+            .fetch_account_data(GlobalAccountDataEventType::from(USER_PACK))
+            .await
+            .map_err(|source| Error::from_sdk("reading the pack failed", source))?
+            .map(|raw| parse(raw.json().get()))
+            .transpose(),
+        ImagePackSource::Room { room_id, state_key } => {
+            let request = get_state_event_for_key::v3::Request::new(
+                room_id.clone(),
+                StateEventType::from(ROOM_PACKS),
+                state_key.clone(),
+            );
+            match client.send(request).await {
+                Ok(response) => parse(response.event_or_content.get()).map(Some),
+                Err(error) if error.client_api_error_kind() == Some(&ApiErrorKind::NotFound) => {
+                    Ok(None)
+                }
+                Err(source) => Err(Error::from_http("reading the pack failed", source)),
+            }
+        }
+    }
+}
+
+async fn write_pack(
+    client: &Client,
+    pack: &ImagePackSource,
+    content: JsonObject,
+) -> Result<(), Error> {
+    let written = match pack {
+        ImagePackSource::User => client
+            .account()
+            .set_account_data_raw(USER_PACK.into(), raw(&content))
+            .await
+            .map(drop),
+        ImagePackSource::Room { room_id, state_key } => client
+            .get_room(room_id)
+            .ok_or_else(Error::room_unknown)?
+            .send_state_event_raw(ROOM_PACKS, state_key, JsonValue::Object(content))
+            .await
+            .map(drop),
+    };
+    written.map_err(|source| Error::from_sdk("writing the pack failed", source))
+}
+
+fn with_pack_usage(mut image: JsonObject, meta: &JsonObject) -> JsonObject {
+    if !image.contains_key("usage")
+        && let Some(usage) = meta.get("usage")
+    {
+        image.insert("usage".to_owned(), usage.clone());
+    }
+    image
+}
+
+fn free_shortcode(images: &JsonObject, wanted: &str) -> String {
+    if !images.contains_key(wanted) {
+        return wanted.to_owned();
+    }
+    (2..)
+        .map(|n| format!("{wanted}-{n}"))
+        .find(|candidate| !images.contains_key(candidate))
+        .expect("an unbounded range finds a free name")
+}
+
+/// the object at `key`, made or replaced if it was missing or malformed
+fn child<'a>(parent: &'a mut JsonObject, key: &str) -> &'a mut JsonObject {
+    let slot = parent
+        .entry(key.to_owned())
+        .or_insert_with(|| JsonObject::new().into());
+    if !slot.is_object() {
+        *slot = JsonObject::new().into();
+    }
+    slot.as_object_mut().expect("just made it an object")
+}
+
+fn patch<T>(
+    meta: &mut JsonObject,
+    key: &str,
+    change: Patch<T>,
+    to_json: impl FnOnce(T) -> JsonValue,
+) {
+    match change {
+        Patch::Keep => {}
+        Patch::Clear => {
+            meta.remove(key);
+        }
+        Patch::Set(value) => {
+            meta.insert(key.to_owned(), to_json(value));
+        }
+    }
+}
+
+fn usage_json(usage: Vec<PackUsage>) -> JsonValue {
+    usage
+        .into_iter()
+        .map(|usage| match usage {
+            PackUsage::Emoticon => "emoticon",
+            PackUsage::Sticker => "sticker",
+        })
+        .collect::<Vec<_>>()
+        .into()
+}
+
+fn info_json(info: PackImageInfo) -> JsonValue {
+    let mut out = JsonObject::new();
+    if let Some(mimetype) = info.mimetype {
+        out.insert("mimetype".to_owned(), mimetype.into());
+    }
+    for (key, value) in [
+        ("size", info.size_bytes),
+        ("w", info.width),
+        ("h", info.height),
+    ] {
+        if let Some(value) = value {
+            out.insert(key.to_owned(), value.into());
+        }
+    }
+    out.into()
+}
+
+fn mxc(value: &JsonValue) -> Option<OwnedMxcUri> {
+    let uri = OwnedMxcUri::from(value.as_str()?);
+    uri.is_valid().then_some(uri)
+}
+
+fn object(value: JsonValue) -> JsonObject {
+    match value {
+        JsonValue::Object(object) => object,
+        _ => JsonObject::new(),
+    }
+}
+
+fn parse(json: &str) -> Result<JsonObject, Error> {
+    serde_json::from_str(json)
+        .map_err(|source| Error::with_source(ErrorKind::Server, "the pack is malformed", source))
+}
+
+fn raw<T>(content: &JsonObject) -> Raw<T> {
+    Raw::new(content)
+        .expect("a json object always serialises")
+        .cast_unchecked()
+}

Modified file: src/lib.rs+10 additions−10 deletions@@ -53,16 +53,16 @@ pub use model::{
     KeyBackupState, LatestEvent, LifecycleCommand, LinkPreview, LinkPreviewImage, Media,
     MediaCommand, MediaDescriptor, MediaFile, MediaId, MediaKind, MediaLocation, MediaSize,
     MemberFilter, MemberMembership, MemberSummary, MembershipChange, Message, MessageContent,
-    MessageEditContent, MessageKind, MessageMentions, NotificationCommand, OwnDevice, PackImage,
-    PackUsage, PowerLevelChanges, Profile, PushNotification, PushNotificationEvent,
-    PushNotificationRoom, PushNotificationSender, PushNotificationStatus, Reaction, RecoveryState,
-    ReplyDetails, ReplyReference, Retain, RichText, RoomCategory, RoomCommand, RoomHero,
-    RoomListFilter, RoomMatcher, RoomMembership, RoomNotificationMode, RoomNotificationSettings,
-    RoomPowerLevels, RoomPreset, RoomSummary, RoomVisibility, SendState, Sender, SpaceChild,
-    Termination, ThreadSummary, TimelineCommand, TimelineContent, TimelineDiff, TimelineDiffError,
-    TimelineEvent, TimelineId, TimelineItem, TimelineItemId, TypingState, UploadDetails,
-    UploadOutcome, UploadThumbnail, UtdCause, VerificationAction, VerificationFailure,
-    VerificationState, VerificationTarget,
+    MessageEditContent, MessageKind, MessageMentions, NotificationCommand, OwnDevice, PackCommand,
+    PackImage, PackImageInfo, PackUsage, Patch, PowerLevelChanges, Profile, PushNotification,
+    PushNotificationEvent, PushNotificationRoom, PushNotificationSender, PushNotificationStatus,
+    Reaction, RecoveryState, ReplyDetails, ReplyReference, Retain, RichText, RoomCategory,
+    RoomCommand, RoomHero, RoomListFilter, RoomMatcher, RoomMembership, RoomNotificationMode,
+    RoomNotificationSettings, RoomPowerLevels, RoomPreset, RoomSummary, RoomVisibility, SendState,
+    Sender, SpaceChild, Termination, ThreadSummary, TimelineCommand, TimelineContent, TimelineDiff,
+    TimelineDiffError, TimelineEvent, TimelineId, TimelineItem, TimelineItemId, TypingState,
+    UploadDetails, UploadOutcome, UploadThumbnail, UtdCause, VerificationAction,
+    VerificationFailure, VerificationState, VerificationTarget,
 };
 pub use ruma;
 pub use transport::{ClientHandle, EventStream, Pending, SpaceHierarchy};

Modified file: src/model.rs+120 additions@@ -27,6 +27,7 @@ pub enum Command {
     Encryption(EncryptionCommand),
     Notification(NotificationCommand),
     Lifecycle(LifecycleCommand),
+    Pack(PackCommand),
 }
 
 #[derive(Debug)]
@@ -357,6 +358,114 @@ pub enum MediaCommand {
     Upload(AttachmentUpload),
 }
 
+/// msc2545 pack editing. edits read the server's copy and keep keys macltok doesn't model
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub enum PackCommand {
+    /// body defaults to the shortcode
+    SendSticker {
+        room_id: OwnedRoomId,
+        pack_id: String,
+        shortcode: String,
+    },
+    /// fails if the state key already holds a pack
+    CreateRoomPack {
+        room_id: OwnedRoomId,
+        state_key: String,
+        display_name: String,
+    },
+    /// empties the content, which is all deleting a pack can mean
+    Delete(ImagePackSource),
+    SetMeta {
+        pack: ImagePackSource,
+        display_name: Patch<String>,
+        avatar: Patch<OwnedMxcUri>,
+        usage: Patch<Vec<PackUsage>>,
+    },
+    /// adds or replaces by shortcode. a replaced image keeps its info unless the url changed
+    PutImage {
+        pack: ImagePackSource,
+        shortcode: String,
+        mxc: OwnedMxcUri,
+        body: Option<String>,
+        usage: Option<Vec<PackUsage>>,
+        info: Option<PackImageInfo>,
+    },
+    /// fails if `to` is taken
+    RenameImage {
+        pack: ImagePackSource,
+        from: String,
+        to: String,
+    },
+    RemoveImage {
+        pack: ImagePackSource,
+        shortcode: String,
+    },
+    SetEnabledEverywhere {
+        room_id: OwnedRoomId,
+        state_key: String,
+        enabled: bool,
+    },
+    /// answers with `CommandOutput::Mxc`, the same uri when it already lives on your homeserver
+    Rehost(OwnedMxcUri),
+    /// the rest answer with `CommandOutput::Cloned`. clashes get `-2`, `-3` and so on
+    CloneImage {
+        from_pack: String,
+        shortcode: String,
+        to: ImagePackSource,
+    },
+    CloneSticker {
+        room_id: OwnedRoomId,
+        event_id: OwnedEventId,
+        to: ImagePackSource,
+        shortcode: String,
+    },
+    /// makes the room pack if its state key is free, else merges. images that can't be
+    /// fetched are skipped and listed, the rest are written
+    ClonePack {
+        from_pack: String,
+        to: ImagePackSource,
+        display_name: Option<String>,
+    },
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum Patch<T> {
+    #[default]
+    Keep,
+    Clear,
+    Set(T),
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct PackImageInfo {
+    pub mimetype: Option<String>,
+    pub size_bytes: Option<u64>,
+    pub width: Option<u64>,
+    pub height: Option<u64>,
+}
+
+impl PackImageInfo {
+    #[must_use]
+    pub fn new(
+        mimetype: Option<String>,
+        size_bytes: Option<u64>,
+        width: Option<u64>,
+        height: Option<u64>,
+    ) -> Self {
+        Self {
+            mimetype,
+            size_bytes,
+            width,
+            height,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[non_exhaustive]
@@ -511,6 +620,11 @@ pub enum CommandOutput {
     Done,
     Room(OwnedRoomId),
     Mxc(OwnedMxcUri),
+    /// the shortcodes the copies ended up under, and the ones that couldn't be fetched
+    Cloned {
+        shortcodes: Vec<String>,
+        skipped: Vec<String>,
+    },
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -858,6 +972,8 @@ pub struct RoomSummary {
     pub children: Vec<OwnedRoomId>,
     /// a space's msc3230 order. ordered spaces sort first by (order, room id), the rest by room id
     pub space_order: Option<String>,
+    /// you can send im.ponies.room_emotes here, so you can make and edit its packs
+    pub can_edit_packs: bool,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1737,6 +1853,10 @@ pub struct ImagePack {
     pub attribution: Option<String>,
     pub source: ImagePackSource,
     pub images: Vec<PackImage>,
+    /// your own pack, or a room pack whose state you're allowed to send
+    pub editable: bool,
+    /// listed in im.ponies.emote_rooms. always true for your own pack
+    pub enabled_everywhere: bool,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]

Modified file: src/normalise/image_pack.rs+97 additions−26 deletions@@ -1,6 +1,6 @@
 use std::collections::{BTreeMap, BTreeSet};
 
-use matrix_sdk::{Client, Room, deserialized_responses::RawAnySyncOrStrippedState};
+use matrix_sdk::{Client, Room, RoomState, deserialized_responses::RawAnySyncOrStrippedState};
 use ruma::{
     OwnedRoomId,
     events::{
@@ -18,41 +18,94 @@ pub(crate) const ENABLED_ROOMS: &str = "im.ponies.emote_rooms";
 
 /// rooms enabled everywhere that the user hasn't joined are skipped, we hold no state for them
 pub(crate) async fn image_packs(client: &Client) -> Result<ImagePacks, Error> {
+    let enabled = match account_data(client, ENABLED_ROOMS).await? {
+        Some(content) => content
+            .get_field::<EnabledRooms>("rooms")
+            .ok()
+            .flatten()
+            .unwrap_or_default(),
+        None => EnabledRooms::new(),
+    };
     let mut rooms = imbl::HashMap::new();
     for room in client.joined_rooms() {
-        let packs = room_packs(&room).await?;
+        let packs = room_packs(&room, enabled.get(room.room_id())).await?;
         if !packs.is_empty() {
             rooms.insert(room.room_id().to_owned(), packs);
         }
     }
     let mut global = Vec::new();
     if let Some(content) = account_data(client, USER_PACK).await? {
-        global.extend(pack("user".to_owned(), ImagePackSource::User, &content));
+        global.extend(pack(
+            "user".to_owned(),
+            ImagePackSource::User,
+            &content,
+            true,
+            true,
+        ));
     }
-    if let Some(content) = account_data(client, ENABLED_ROOMS).await? {
-        let enabled = content
-            .get_field::<BTreeMap<OwnedRoomId, BTreeMap<String, Raw<JsonObject>>>>("rooms")
-            .ok()
-            .flatten()
-            .unwrap_or_default();
-        for (room_id, state_keys) in enabled {
-            let packs = rooms.get(&room_id).into_iter().flatten();
-            global.extend(
-                packs
-                    .filter(|pack| match &pack.source {
-                        ImagePackSource::Room { state_key, .. } => {
-                            state_keys.contains_key(state_key)
-                        }
-                        ImagePackSource::User => false,
-                    })
-                    .cloned(),
-            );
-        }
+    for room_id in enabled.keys() {
+        let packs = rooms.get(room_id).into_iter().flatten();
+        global.extend(packs.filter(|pack| pack.enabled_everywhere).cloned());
     }
     Ok(ImagePacks { global, rooms })
 }
 
-async fn room_packs(room: &Room) -> Result<Vec<ImagePack>, Error> {
+type EnabledRooms = BTreeMap<OwnedRoomId, BTreeMap<String, Raw<JsonObject>>>;
+
+pub(crate) async fn can_edit_packs(room: &Room) -> bool {
+    room.state() == RoomState::Joined
+        && room.power_levels().await.is_ok_and(|levels| {
+            levels.user_can_send_state(room.own_user_id(), StateEventType::from(ROOM_PACKS))
+        })
+}
+
+/// what an id from `ImagePack::id` points at. room ids hold colons, so it's matched
+/// against the rooms we know rather than split
+pub(crate) fn resolve_pack_id(client: &Client, id: &str) -> Option<ImagePackSource> {
+    if id == "user" {
+        return Some(ImagePackSource::User);
+    }
+    let rest = id.strip_prefix("room:")?;
+    client.joined_rooms().into_iter().find_map(|room| {
+        let state_key = rest
+            .strip_prefix(room.room_id().as_str())?
+            .strip_prefix(':')?;
+        Some(ImagePackSource::Room {
+            room_id: room.room_id().to_owned(),
+            state_key: state_key.to_owned(),
+        })
+    })
+}
+
+/// the pack's raw content as the store has it, for reading. edits fetch the server's copy
+pub(crate) async fn stored_pack(
+    client: &Client,
+    source: &ImagePackSource,
+) -> Result<Option<JsonObject>, Error> {
+    let content = match source {
+        ImagePackSource::User => account_data(client, USER_PACK).await?,
+        ImagePackSource::Room { room_id, state_key } => {
+            let room = client.get_room(room_id).ok_or_else(Error::room_unknown)?;
+            match room
+                .get_state_event(StateEventType::from(ROOM_PACKS), state_key)
+                .await
+                .map_err(|source| Error::from_sdk("reading image packs failed", source))?
+            {
+                Some(RawAnySyncOrStrippedState::Sync(event)) => {
+                    event.get_field::<Raw<JsonObject>>("content").ok().flatten()
+                }
+                _ => None,
+            }
+        }
+    };
+    Ok(content.and_then(|content| content.deserialize().ok()))
+}
+
+async fn room_packs(
+    room: &Room,
+    enabled: Option<&BTreeMap<String, Raw<JsonObject>>>,
+) -> Result<Vec<ImagePack>, Error> {
+    let editable = can_edit_packs(room).await;
     let events = room
         .get_state_events(StateEventType::from(ROOM_PACKS))
         .await
@@ -74,10 +127,14 @@ async fn room_packs(room: &Room) -> Result<Vec<ImagePack>, Error> {
                 room_id: room.room_id().to_owned(),
                 state_key: state_key.clone(),
             };
+            let enabled_everywhere =
+                enabled.is_some_and(|enabled| enabled.contains_key(&state_key));
             pack(
                 format!("room:{}:{state_key}", room.room_id()),
                 source,
                 &content,
+                editable,
+                enabled_everywhere,
             )
         })
         .collect())
@@ -92,8 +149,15 @@ async fn account_data(client: &Client, event_type: &str) -> Result<Option<Raw<Js
         .map(|content| content.cast_unchecked()))
 }
 
-/// one bad image costs that image, not its pack. a pack with nothing usable left is dropped
-fn pack(id: String, source: ImagePackSource, content: &Raw<JsonObject>) -> Option<ImagePack> {
+/// one bad image costs that image, not its pack. only an emptied pack, which is how packs
+/// get deleted, is dropped, so a fresh one shows up in a pack manager before it has images
+fn pack(
+    id: String,
+    source: ImagePackSource,
+    content: &Raw<JsonObject>,
+    editable: bool,
+    enabled_everywhere: bool,
+) -> Option<ImagePack> {
     let info = content
         .get_field::<PackInfo>("pack")
         .ok()
@@ -126,7 +190,12 @@ fn pack(id: String, source: ImagePackSource, content: &Raw<JsonObject>) -> Optio
             })
         })
         .collect();
-    (!images.is_empty()).then(|| ImagePack {
+    let has_meta = content
+        .get_field::<JsonObject>("pack")
+        .ok()
+        .flatten()
+        .is_some();
+    (has_meta || !images.is_empty()).then(|| ImagePack {
         id,
         display_name: info.display_name,
         avatar: info
@@ -136,6 +205,8 @@ fn pack(id: String, source: ImagePackSource, content: &Raw<JsonObject>) -> Optio
         attribution: info.attribution,
         source,
         images,
+        editable,
+        enabled_everywhere,
     })
 }
 

Modified file: src/normalise/mod.rs+3 additions−1 deletions@@ -5,7 +5,9 @@ mod member;
 mod room;
 mod timeline;
 
-pub(crate) use image_pack::{ENABLED_ROOMS, ROOM_PACKS, USER_PACK, image_packs};
+pub(crate) use image_pack::{
+    ENABLED_ROOMS, ROOM_PACKS, USER_PACK, can_edit_packs, image_packs, resolve_pack_id, stored_pack,
+};
 pub(crate) use link_preview::{ROOM_PREVIEW_URLS, server_preview, url_previews_allowed};
 pub(crate) use media::{MediaRegistration, MediaScope, MediaSourceInfo};
 pub(crate) use member::member_summary;

Modified file: src/normalise/room.rs+1

@@ -107,6 +107,7 @@ async fn room_summary(room: &Room, spaces: &SpaceService) -> RoomSummary {

107107 } else {

108108 None

109109 },

110+ can_edit_packs: super::can_edit_packs(room).await,

110111 }

111112 }

112113

Modified file: src/transport.rs+202 additions−7 deletions@@ -28,13 +28,14 @@ use tokio::sync::{OnceCell, mpsc, oneshot, watch};
 
 use crate::{
     AccountCommand, AttachmentUpload, Command, CommandOutput, ConnectionState, CreateRoomOptions,
-    EncryptionCommand, EncryptionState, Error, ErrorKind, Event, EventRef, ImagePacks,
-    InteractiveAuth, InteractiveAuthOutcome, LifecycleCommand, LinkPreview, Media, MediaCommand,
-    MediaId, MediaLocation, MediaSize, MemberFilter, MemberSummary, MessageContent,
-    MessageEditContent, NotificationCommand, OwnDevice, PowerLevelChanges, Profile,
-    PushNotification, PushNotificationEvent, PushNotificationStatus, RoomCommand, RoomListFilter,
-    RoomNotificationMode, RoomNotificationSettings, RoomPowerLevels, RoomSummary, SpaceChild,
-    TimelineCommand, TimelineId, VerificationAction, VerificationTarget,
+    EncryptionCommand, EncryptionState, Error, ErrorKind, Event, EventRef, ImagePackSource,
+    ImagePacks, InteractiveAuth, InteractiveAuthOutcome, LifecycleCommand, LinkPreview, Media,
+    MediaCommand, MediaId, MediaLocation, MediaSize, MemberFilter, MemberSummary, MessageContent,
+    MessageEditContent, NotificationCommand, OwnDevice, PackCommand, PackImageInfo, PackUsage,
+    Patch, PowerLevelChanges, Profile, PushNotification, PushNotificationEvent,
+    PushNotificationStatus, RoomCommand, RoomListFilter, RoomNotificationMode,
+    RoomNotificationSettings, RoomPowerLevels, RoomSummary, SpaceChild, TimelineCommand,
+    TimelineId, VerificationAction, VerificationTarget,
     encryption::encryption_state,
     engine::{MediaService, StoreLock},
     model::{PushNotificationRoom, PushNotificationSender},
@@ -736,6 +737,188 @@ impl ClientHandle {
         .await
     }
 
+    /// body defaults to the shortcode
+    pub async fn send_sticker(
+        &self,
+        room_id: OwnedRoomId,
+        pack_id: String,
+        shortcode: String,
+    ) -> Result<(), Error> {
+        self.run(Command::Pack(PackCommand::SendSticker {
+            room_id,
+            pack_id,
+            shortcode,
+        }))
+        .await
+    }
+
+    /// fails if the state key already holds a pack
+    pub async fn create_room_pack(
+        &self,
+        room_id: OwnedRoomId,
+        state_key: String,
+        display_name: String,
+    ) -> Result<(), Error> {
+        self.run(Command::Pack(PackCommand::CreateRoomPack {
+            room_id,
+            state_key,
+            display_name,
+        }))
+        .await
+    }
+
+    pub async fn delete_pack(&self, pack: ImagePackSource) -> Result<(), Error> {
+        self.run(Command::Pack(PackCommand::Delete(pack))).await
+    }
+
+    pub async fn set_pack_meta(
+        &self,
+        pack: ImagePackSource,
+        display_name: Patch<String>,
+        avatar: Patch<OwnedMxcUri>,
+        usage: Patch<Vec<PackUsage>>,
+    ) -> Result<(), Error> {
+        self.run(Command::Pack(PackCommand::SetMeta {
+            pack,
+            display_name,
+            avatar,
+            usage,
+        }))
+        .await
+    }
+
+    /// adds or replaces by shortcode. a replaced image keeps its info unless the url changed
+    pub async fn put_pack_image(
+        &self,
+        pack: ImagePackSource,
+        shortcode: String,
+        mxc: OwnedMxcUri,
+        body: Option<String>,
+        usage: Option<Vec<PackUsage>>,
+        info: Option<PackImageInfo>,
+    ) -> Result<(), Error> {
+        self.run(Command::Pack(PackCommand::PutImage {
+            pack,
+            shortcode,
+            mxc,
+            body,
+            usage,
+            info,
+        }))
+        .await
+    }
+
+    pub async fn rename_pack_image(
+        &self,
+        pack: ImagePackSource,
+        from: String,
+        to: String,
+    ) -> Result<(), Error> {
+        self.run(Command::Pack(PackCommand::RenameImage { pack, from, to }))
+            .await
+    }
+
+    pub async fn remove_pack_image(
+        &self,
+        pack: ImagePackSource,
+        shortcode: String,
+    ) -> Result<(), Error> {
+        self.run(Command::Pack(PackCommand::RemoveImage { pack, shortcode }))
+            .await
+    }
+
+    pub async fn set_pack_enabled_everywhere(
+        &self,
+        room_id: OwnedRoomId,
+        state_key: String,
+        enabled: bool,
+    ) -> Result<(), Error> {
+        self.run(Command::Pack(PackCommand::SetEnabledEverywhere {
+            room_id,
+            state_key,
+            enabled,
+        }))
+        .await
+    }
+
+    /// the same uri when it already lives on your homeserver
+    pub async fn rehost_media(&self, mxc: OwnedMxcUri) -> Result<OwnedMxcUri, Error> {
+        match self
+            .execute(Command::Pack(PackCommand::Rehost(mxc)))
+            .await?
+        {
+            CommandOutput::Mxc(uri) => Ok(uri),
+            output => Err(unexpected("an mxc", &output)),
+        }
+    }
+
+    /// hands back the shortcode it ended up under
+    pub async fn clone_pack_image(
+        &self,
+        from_pack: String,
+        shortcode: String,
+        to: ImagePackSource,
+    ) -> Result<String, Error> {
+        let (mut shortcodes, _) = self
+            .run_clone(PackCommand::CloneImage {
+                from_pack,
+                shortcode,
+                to,
+            })
+            .await?;
+        shortcodes
+            .pop()
+            .ok_or_else(|| unexpected("a shortcode", &CommandOutput::Done))
+    }
+
+    /// hands back the shortcode it ended up under
+    pub async fn clone_sticker(
+        &self,
+        room_id: OwnedRoomId,
+        event_id: OwnedEventId,
+        to: ImagePackSource,
+        shortcode: String,
+    ) -> Result<String, Error> {
+        let (mut shortcodes, _) = self
+            .run_clone(PackCommand::CloneSticker {
+                room_id,
+                event_id,
+                to,
+                shortcode,
+            })
+            .await?;
+        shortcodes
+            .pop()
+            .ok_or_else(|| unexpected("a shortcode", &CommandOutput::Done))
+    }
+
+    /// hands back the shortcodes that couldn't be fetched, everything else is written
+    pub async fn clone_pack(
+        &self,
+        from_pack: String,
+        to: ImagePackSource,
+        display_name: Option<String>,
+    ) -> Result<Vec<String>, Error> {
+        let (_, skipped) = self
+            .run_clone(PackCommand::ClonePack {
+                from_pack,
+                to,
+                display_name,
+            })
+            .await?;
+        Ok(skipped)
+    }
+
+    async fn run_clone(&self, command: PackCommand) -> Result<(Vec<String>, Vec<String>), Error> {
+        match self.execute(Command::Pack(command)).await? {
+            CommandOutput::Cloned {
+                shortcodes,
+                skipped,
+            } => Ok((shortcodes, skipped)),
+            output => Err(unexpected("a clone", &output)),
+        }
+    }
+
     pub async fn rooms_filtered(&self, filter: &RoomListFilter) -> Vec<RoomSummary> {
         let matcher = filter.matcher();
         self.rooms()
@@ -1047,6 +1230,11 @@ impl Request {
 pub(crate) struct Responder(oneshot::Sender<Result<CommandOutput, Error>>);
 
 impl Responder {
+    pub(crate) fn channel() -> (Self, Pending) {
+        let (reply, pending) = oneshot::channel();
+        (Self(reply), Pending(pending))
+    }
+
     pub(crate) fn send(self, result: Result<CommandOutput, Error>) {
         if let Err(error) = &result {
             tracing::debug!(%error, kind = ?error.kind, "command failed");
@@ -1241,3 +1429,10 @@ fn normalise_push_notification(
         NotificationStatus::EventRedacted => PushNotificationStatus::Redacted,
     }
 }
+
+fn unexpected(wanted: &str, output: &CommandOutput) -> Error {
+    Error::new(
+        ErrorKind::Other,
+        format!("expected {wanted} but got {output:?}"),
+    )
+}

macltok

Commit fa51490b6ae9

Commit `fa51490b6ae9`