@synopackageland/templates 0.9.5 → 0.9.7

package/templates/native-rust/backend/THIRD_PARTY_NOTICES.txt

@@ -0,0 +1,207 @@
+Native Rust package build dependencies (crates linked into the backend binaries)
+
+syno-pkg-land-sdk v0.9.8 (MIT)
+
+MIT License
+
+Copyright (c) 2026 synopkgland
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+itoa v1.0.18 (MIT OR Apache-2.0; used under MIT)
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+libc v0.2.190 (MIT OR Apache-2.0; used under MIT)
+
+Copyright (c) The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+memchr v2.8.3 (Unlicense OR MIT; used under MIT)
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Andrew Gallant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+serde v1.0.229 (MIT OR Apache-2.0; used under MIT)
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+serde_core v1.0.229 (MIT OR Apache-2.0; used under MIT)
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+serde_json v1.0.154 (MIT OR Apache-2.0; used under MIT)
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+zmij v1.0.23 (MIT)
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/templates/native-rust/backend/permissions.json

@@ -0,0 +1,5 @@
+{
+  "schema": 1,
+  "default": "administrators",
+  "methods": {}
+}

package/templates/native-rust/backend/rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "1.97.1"
+targets = ["x86_64-unknown-linux-musl", "aarch64-unknown-linux-musl", "armv7-unknown-linux-gnueabihf"]
+components = ["clippy", "rustfmt"]

package/templates/native-rust/backend/src/app/background/mod.rs

@@ -0,0 +1,424 @@
+//! The opt-in background jobs API: owner-scoped routes over the SDK's
+//! package-private spool. The overlay `background_routes.rs` decides whether
+//! a build serves them.
+
+mod owner;
+#[cfg(test)]
+mod owner_tests;
+mod schedule;
+#[cfg(test)]
+mod schedule_tests;
+#[cfg(test)]
+mod tests;
+mod work;
+#[cfg(test)]
+mod work_tests;
+
+pub use work::hash_work;
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use serde::Deserialize;
+use serde_json::{Value, json};
+use syno_pkg_land_sdk::api::{self, Caller, Route};
+use syno_pkg_land_sdk::background::{
+    Access, JOB_TIMEOUT, Job, MAX_INPUT_BYTES, MAX_OWNER_BYTES, MAX_OWNER_PENDING, MAX_QUEUED,
+    MAX_SCHEDULES, MAX_TOTAL_BYTES, Store, StoreError, SubmitRequest, WorkerInfo,
+};
+use syno_pkg_land_sdk::ctx::{Context, CtxError};
+use syno_pkg_land_sdk::delegate;
+use syno_pkg_land_sdk::filestation::{Page, Service};
+use syno_pkg_land_sdk::http::Request;
+use syno_pkg_land_sdk::time::Timestamp;
+use syno_pkg_land_sdk::{BoxError, jsonx};
+
+use super::UidLookup;
+use super::routes::decode_params;
+
+/// How recent the worker heartbeat must be to count as running.
+const WORKER_FRESH: Duration = Duration::from_secs(15);
+
+/// Resolves the authenticated DSM username on every request. Unknown UIDs
+/// fail closed for owners and submission.
+pub fn system_uid_lookup() -> UidLookup {
+    Arc::new(delegate::lookup_uid)
+}
+
+/// What the jobs API needs of File Station: browsing and importing one file
+/// through the caller's own DSM session.
+pub trait BackgroundFiles: Send + Sync {
+    fn browse(
+        &self,
+        ctx: &Context,
+        caller: &Caller,
+        req: &Request,
+        folder: &str,
+        offset: i64,
+    ) -> Result<Page, BoxError>;
+
+    fn read_file(
+        &self,
+        ctx: &Context,
+        caller: &Caller,
+        req: &Request,
+        folder: &str,
+        rel: &str,
+    ) -> Result<Vec<u8>, BoxError>;
+}
+
+impl BackgroundFiles for Service {
+    fn browse(
+        &self,
+        ctx: &Context,
+        caller: &Caller,
+        req: &Request,
+        folder: &str,
+        offset: i64,
+    ) -> Result<Page, BoxError> {
+        Service::browse(self, ctx, caller, req, folder, offset)
+    }
+
+    fn read_file(
+        &self,
+        ctx: &Context,
+        caller: &Caller,
+        req: &Request,
+        folder: &str,
+        rel: &str,
+    ) -> Result<Vec<u8>, BoxError> {
+        Service::read_file(self, ctx, caller, req, folder, rel)
+    }
+}
+
+/// A handler of one background route; the access it works under was derived
+/// from the authenticated caller, never from params.
+type Handler =
+    fn(&BackgroundApi, &Context, &Caller, &Request, &Access, &[u8]) -> Result<Value, BoxError>;
+
+pub struct BackgroundApi {
+    store: Arc<Store>,
+    files: Arc<dyn BackgroundFiles>,
+    uid_lookup: UidLookup,
+}
+
+impl BackgroundApi {
+    pub fn new(
+        store: Arc<Store>,
+        files: Arc<dyn BackgroundFiles>,
+        uid_lookup: UidLookup,
+    ) -> Arc<Self> {
+        Arc::new(BackgroundApi {
+            store,
+            files,
+            uid_lookup,
+        })
+    }
+
+    /// The production assembly: the request-bounded spool under the data
+    /// directory and the caller's own File Station session. `synopkgland init
+    /// --with jobs` wires it in through `background_routes.rs`.
+    pub fn production(data_dir: &std::path::Path, uid_lookup: UidLookup) -> Arc<Self> {
+        Self::new(
+            Arc::new(Store::new_request(data_dir.join("background"))),
+            Arc::new(Service::local(data_dir)),
+            uid_lookup,
+        )
+    }
+
+    /// Every request authenticates against DSM afresh. Owner routes are
+    /// available to signed-in users; schedule reapproval and owner cleanup
+    /// are admin-only.
+    pub fn routes(self: &Arc<Self>) -> Vec<Route> {
+        vec![
+            self.owner("bg.status", Self::status),
+            self.owner("bg.schedules.list", Self::schedules),
+            self.owner("bg.schedules.create", Self::create_schedule),
+            self.owner("bg.schedules.disable", Self::disable_schedule),
+            self.owner("bg.schedules.delete", Self::delete_schedule),
+            self.admin("bg.schedules.enable", Self::enable_schedule),
+            self.admin("bg.jobs.purge", Self::purge),
+            self.owner("bg.browse", Self::browse),
+            self.owner("bg.jobs.submit", Self::submit),
+            self.owner("bg.jobs.list", Self::list),
+            self.owner("bg.jobs.get", Self::get),
+            self.owner("bg.jobs.cancel", Self::cancel),
+            self.owner("bg.jobs.pause", Self::pause),
+            self.owner("bg.jobs.resume", Self::resume),
+            self.owner("bg.jobs.result", Self::result),
+        ]
+    }
+
+    fn status(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        decode_params::<jsonx::Empty>(params)?;
+        let st = self
+            .store
+            .status_for(ctx, access)
+            .map_err(background_error)?;
+        let worker = st.worker.as_ref().map(|w| {
+            json!({
+                "pid": w.pid, "uid": w.uid, "username": w.username,
+                "revision": w.revision, "at": w.at,
+                "alive": worker_alive(w, Timestamp::now()),
+            })
+        });
+        Ok(json!({
+            "owner": access.owner, "supported": true, "admin": access.admin,
+            "algorithm": st.algorithm, "revision": st.revision,
+            "queued": st.queued, "running": st.running, "worker": worker,
+            "limits": {
+                "maxInputBytes": MAX_INPUT_BYTES, "maxQueued": MAX_QUEUED,
+                "maxSchedules": MAX_SCHEDULES, "intervalSeconds": [3600, 86400, 604800],
+                "maxTotalBytes": MAX_TOTAL_BYTES, "maxOwnerPending": MAX_OWNER_PENDING,
+                "maxOwnerBytes": MAX_OWNER_BYTES,
+                "jobTimeoutSeconds": JOB_TIMEOUT.as_secs(),
+            },
+        }))
+    }
+
+    /// Lists what the caller's own File Station session can see, so the
+    /// panel can pick a file instead of typing a path. It grants nothing:
+    /// submit still reads through the same session.
+    fn browse(
+        &self,
+        ctx: &Context,
+        caller: &Caller,
+        req: &Request,
+        _: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        #[derive(Default, Deserialize)]
+        #[serde(deny_unknown_fields)]
+        struct Params {
+            #[serde(default)]
+            folder: String,
+            #[serde(default)]
+            offset: i64,
+        }
+        let params: Params = decode_params(params)?;
+        if params.offset < 0 {
+            return Err(api::Error::bad_request("offset must not be negative").into());
+        }
+        let page = self
+            .files
+            .browse(ctx, caller, req, &params.folder, params.offset)?;
+        Ok(serde_json::to_value(page)?)
+    }
+
+    fn submit(
+        &self,
+        ctx: &Context,
+        caller: &Caller,
+        req: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        #[derive(Default, Deserialize)]
+        #[serde(deny_unknown_fields)]
+        struct Params {
+            #[serde(default)]
+            key: String,
+            #[serde(default)]
+            folder: String,
+            #[serde(default)]
+            relative: String,
+        }
+        let params: Params = decode_params(params)?;
+        if params.key.is_empty() || params.folder.is_empty() || params.relative.is_empty() {
+            return Err(api::Error::bad_request("key, folder and relative are required").into());
+        }
+        if !access.owner.valid() {
+            return Err(identity_unavailable().into());
+        }
+        let data = self
+            .files
+            .read_file(ctx, caller, req, &params.folder, &params.relative)?;
+        let (job, duplicate) = self
+            .store
+            .submit(
+                ctx,
+                SubmitRequest {
+                    key: params.key,
+                    name: base_name(&params.relative),
+                    data,
+                    submitter: access.owner.clone(),
+                },
+            )
+            .map_err(background_error)?;
+        Ok(json!({"job": job, "duplicate": duplicate}))
+    }
+
+    fn list(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        decode_params::<jsonx::Empty>(params)?;
+        let mut jobs = self.store.list_for(ctx, access).map_err(background_error)?;
+        jobs.reverse();
+        Ok(json!({"jobs": jobs}))
+    }
+
+    fn get(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        self.by_id(ctx, access, params, Store::get_for)
+    }
+
+    fn cancel(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        self.by_id(ctx, access, params, Store::cancel_for)
+    }
+
+    /// Holds a queued job at once; a running job pauses at its next checkpoint.
+    fn pause(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        self.by_id(ctx, access, params, Store::pause_for)
+    }
+
+    fn resume(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        self.by_id(ctx, access, params, Store::resume_for)
+    }
+
+    fn by_id(
+        &self,
+        ctx: &Context,
+        access: &Access,
+        params: &[u8],
+        act: fn(&Store, &Context, &str, &Access) -> Result<Job, BoxError>,
+    ) -> Result<Value, BoxError> {
+        let id = decode_id(params)?;
+        let job = act(&self.store, ctx, &id, access).map_err(background_error)?;
+        Ok(json!({"job": job}))
+    }
+
+    fn result(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        let id = decode_id(params)?;
+        let job = self
+            .store
+            .get_for(ctx, &id, access)
+            .map_err(background_error)?;
+        let result = match (&job.state, &job.result) {
+            (syno_pkg_land_sdk::background::State::Succeeded, Some(result)) => result,
+            _ => return Err(api::Error::new("not_ready", "the job has no result").into()),
+        };
+        Ok(json!({"job": job, "result": {
+            "jobId": job.id, "worker": job.worker, "workerRevision": job.worker_revision,
+            "algorithm": "sha256", "sha256": result.sha256, "bytes": result.bytes,
+            "inputDigest": job.input_digest, "name": job.name,
+        }}))
+    }
+}
+
+fn decode_id(params: &[u8]) -> Result<String, api::Error> {
+    #[derive(Default, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    struct IdParams {
+        #[serde(default)]
+        id: String,
+    }
+    Ok(decode_params::<IdParams>(params)?.id)
+}
+
+fn identity_unavailable() -> api::Error {
+    api::Error::new("identity_unavailable", "DSM user UID could not be resolved")
+}
+
+fn worker_alive(w: &WorkerInfo, now: Timestamp) -> bool {
+    now.unix_nanos() - w.at.unix_nanos() <= WORKER_FRESH.as_nanos() as i128
+}
+
+/// The last element of a slash-separated path, as Go's path.Base.
+fn base_name(path: &str) -> String {
+    if path.is_empty() {
+        return ".".into();
+    }
+    let trimmed = path.trim_end_matches('/');
+    if trimmed.is_empty() {
+        return "/".into();
+    }
+    trimmed.rsplit('/').next().unwrap_or(trimmed).into()
+}
+
+/// Maps the spool's errors to the codes the panel knows; anything else is
+/// logged and reported as unavailable.
+fn background_error(err: BoxError) -> BoxError {
+    let message = |code: &str, text: &str| -> BoxError { api::Error::new(code, text).into() };
+    match api::find_error::<StoreError>(&*err) {
+        Some(StoreError::Busy) => message("jobs_busy", "background jobs are busy; retry later"),
+        Some(StoreError::ScheduleFull) => {
+            message("schedule-full", "the schedule limit has been reached")
+        }
+        Some(StoreError::InputUnavailable) => {
+            message("input-unavailable", "import the private copy again")
+        }
+        Some(StoreError::OwnerQueueFull) => message(
+            "owner-queue-full",
+            "your pending job limit has been reached",
+        ),
+        Some(StoreError::OwnerQuota) => message(
+            "owner-quota-exceeded",
+            "your background storage limit has been reached",
+        ),
+        Some(StoreError::Invalid) => api::Error::bad_request("invalid background request").into(),
+        Some(StoreError::TooLarge) => message(
+            "limit-exceeded",
+            "the file is larger than the background limit",
+        ),
+        Some(StoreError::QueueFull) => message("queue-full", "the background queue is full"),
+        Some(StoreError::Quota) => message("quota-exceeded", "the background spool is full"),
+        Some(StoreError::KeyConflict | StoreError::NotCancelable | StoreError::NotPausable) => {
+            message(
+                "conflict",
+                "the request conflicts with the job's current state",
+            )
+        }
+        Some(StoreError::NotFound) => message("not_found", "job not found"),
+        _ if api::find_error::<CtxError>(&*err).is_some() => err,
+        _ => {
+            eprintln!("background spool error: {err}");
+            message("unavailable", "the background spool is unavailable")
+        }
+    }
+}