consolidate crates

core/startos/src/action.rs

@@ -1,8 +1,8 @@
 use std::fmt;
 
 use clap::{CommandFactory, FromArgMatches, Parser};
-pub use models::ActionId;
-use models::{PackageId, ReplayId};
+pub use crate::ActionId;
+use crate::{PackageId, ReplayId};
 use qrcode::QrCode;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};

core/startos/src/backup/backup_bulk.rs

@@ -5,9 +5,8 @@ use std::sync::Arc;
 use chrono::Utc;
 use clap::Parser;
 use color_eyre::eyre::eyre;
-use helpers::AtomicFile;
 use imbl::OrdSet;
-use models::PackageId;
+use crate::PackageId;
 use serde::{Deserialize, Serialize};
 use tokio::io::AsyncWriteExt;
 use tracing::instrument;
@@ -26,7 +25,7 @@ use crate::disk::mount::guard::{GenericMountGuard, TmpMountGuard};
 use crate::middleware::auth::AuthContext;
 use crate::notifications::{NotificationLevel, notify};
 use crate::prelude::*;
-use crate::util::io::dir_copy;
+use crate::util::io::{AtomicFile, dir_copy};
 use crate::util::serde::IoFormat;
 use crate::version::VersionT;
 
@@ -312,19 +311,14 @@ async fn perform_backup(
     let ui = ctx.db.peek().await.into_public().into_ui().de()?;
 
     let mut os_backup_file =
-        AtomicFile::new(backup_guard.path().join("os-backup.json"), None::<PathBuf>)
-            .await
-            .with_kind(ErrorKind::Filesystem)?;
+        AtomicFile::new(backup_guard.path().join("os-backup.json"), None::<PathBuf>).await?;
     os_backup_file
         .write_all(&IoFormat::Json.to_vec(&OsBackup {
             account: ctx.account.peek(|a| a.clone()),
             ui,
         })?)
         .await?;
-    os_backup_file
-        .save()
-        .await
-        .with_kind(ErrorKind::Filesystem)?;
+    os_backup_file.save().await?;
 
     let luks_folder_old = backup_guard.path().join("luks.old");
     if tokio::fs::metadata(&luks_folder_old).await.is_ok() {

core/startos/src/backup/mod.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use models::PackageId;
+use crate::PackageId;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 

core/startos/src/backup/restore.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 
 use clap::Parser;
 use futures::{StreamExt, stream};
-use models::PackageId;
+use crate::PackageId;
 use patch_db::json_ptr::ROOT;
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;

core/startos/src/backup/target/mod.rs

@@ -9,7 +9,8 @@ use digest::OutputSizeUser;
 use digest::generic_array::GenericArray;
 use exver::Version;
 use imbl_value::InternedString;
-use models::{FromStrParser, PackageId};
+use crate::util::FromStrParser;
+use crate::PackageId;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use sha2::Sha256;

core/startos/src/bins/tunnel.rs

@@ -5,7 +5,7 @@ use std::time::Duration;
 
 use clap::Parser;
 use futures::FutureExt;
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use rpc_toolkit::CliApp;
 use tokio::signal::unix::signal;
 use tracing::instrument;

core/startos/src/config/hook.rs

@@ -1,7 +1,7 @@
 use helpers::Callback;
 use itertools::Itertools;
 use jsonpath_lib::Compiled;
-use models::PackageId;
+use crate::PackageId;
 use serde_json::Value;
 
 use crate::context::RpcContext;

core/startos/src/context/rpc.rs

@@ -8,12 +8,12 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 
 use chrono::{TimeDelta, Utc};
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use imbl::OrdMap;
 use imbl_value::InternedString;
 use itertools::Itertools;
 use josekit::jwk::Jwk;
-use models::{ActionId, PackageId};
+use crate::{ActionId, PackageId};
 use reqwest::{Client, Proxy};
 use rpc_toolkit::yajrc::RpcError;
 use rpc_toolkit::{CallRemote, Context, Empty};

core/startos/src/context/setup.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use futures::{Future, StreamExt};
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use imbl_value::InternedString;
 use josekit::jwk::Jwk;
 use patch_db::PatchDb;

core/startos/src/control.rs

@@ -1,5 +1,5 @@
 use clap::Parser;
-use models::PackageId;
+use crate::PackageId;
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
 use ts_rs::TS;

core/startos/src/db/model/package.rs

@@ -4,7 +4,8 @@ use std::path::PathBuf;
 use chrono::{DateTime, Utc};
 use exver::VersionRange;
 use imbl_value::InternedString;
-use models::{ActionId, DataUrl, HealthCheckId, HostId, PackageId, ReplayId, ServiceInterfaceId};
+use crate::util::DataUrl;
+use crate::{ActionId, HealthCheckId, HostId, PackageId, ReplayId, ServiceInterfaceId};
 use patch_db::HasModel;
 use patch_db::json_ptr::JsonPointer;
 use reqwest::Url;

core/startos/src/db/model/private.rs

@@ -1,6 +1,6 @@
 use std::collections::{BTreeMap, HashSet};
 
-use models::PackageId;
+use crate::PackageId;
 use patch_db::{HasModel, Value};
 use serde::{Deserialize, Serialize};
 

core/startos/src/db/model/public.rs

@@ -9,7 +9,7 @@ use imbl_value::InternedString;
 use ipnet::IpNet;
 use isocountry::CountryCode;
 use itertools::Itertools;
-use models::{GatewayId, PackageId};
+use crate::{GatewayId, PackageId};
 use openssl::hash::MessageDigest;
 use patch_db::{HasModel, Value};
 use serde::{Deserialize, Serialize};

core/startos/src/dependencies.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 use std::path::Path;
 
 use imbl_value::InternedString;
-use models::PackageId;
+use crate::PackageId;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 

core/startos/src/disk/mount/backup.rs

@@ -2,8 +2,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use color_eyre::eyre::eyre;
-use helpers::AtomicFile;
-use models::PackageId;
+use crate::PackageId;
 use tokio::io::AsyncWriteExt;
 use tracing::instrument;
 
@@ -14,9 +13,10 @@ use crate::disk::mount::filesystem::ReadWrite;
 use crate::disk::mount::filesystem::backupfs::BackupFS;
 use crate::disk::mount::guard::SubPath;
 use crate::disk::util::StartOsRecoveryInfo;
+use crate::prelude::*;
 use crate::util::crypto::{decrypt_slice, encrypt_slice};
+use crate::util::io::AtomicFile;
 use crate::util::serde::IoFormat;
-use crate::{Error, ErrorKind, ResultExt};
 
 #[derive(Clone, Debug)]
 pub struct BackupMountGuard<G: GenericMountGuard> {
@@ -184,18 +184,14 @@ impl<G: GenericMountGuard> BackupMountGuard<G> {
     #[instrument(skip_all)]
     pub async fn save(&self) -> Result<(), Error> {
         let metadata_path = self.path().join("metadata.json");
-        let mut file = AtomicFile::new(&metadata_path, None::<PathBuf>)
-            .await
-            .with_kind(ErrorKind::Filesystem)?;
+        let mut file = AtomicFile::new(&metadata_path, None::<PathBuf>).await?;
         file.write_all(&IoFormat::Json.to_vec(&self.metadata)?)
             .await?;
-        file.save().await.with_kind(ErrorKind::Filesystem)?;
-        let mut file = AtomicFile::new(&self.unencrypted_metadata_path, None::<PathBuf>)
-            .await
-            .with_kind(ErrorKind::Filesystem)?;
+        file.save().await?;
+        let mut file = AtomicFile::new(&self.unencrypted_metadata_path, None::<PathBuf>).await?;
         file.write_all(&IoFormat::Json.to_vec(&self.unencrypted_metadata)?)
             .await?;
-        file.save().await.with_kind(ErrorKind::Filesystem)?;
+        file.save().await?;
         Ok(())
     }
 

core/startos/src/disk/mount/filesystem/idmapped.rs

@@ -8,7 +8,7 @@ use clap::Parser;
 use clap::builder::ValueParserFactory;
 use digest::generic_array::GenericArray;
 use digest::{Digest, OutputSizeUser};
-use models::FromStrParser;
+use crate::util::FromStrParser;
 use serde::{Deserialize, Serialize};
 use sha2::Sha256;
 use tokio::process::Command;

core/startos/src/disk/mount/guard.rs

@@ -4,7 +4,7 @@ use std::sync::{Arc, Weak};
 
 use futures::Future;
 use lazy_static::lazy_static;
-use models::ResultExt;
+use crate::ResultExt;
 use tokio::sync::Mutex;
 use tracing::instrument;
 

core/startos/src/error.rs

@@ -1,4 +1,526 @@
-pub use models::{Error, ErrorKind, OptionExt, ResultExt};
+use std::fmt::{Debug, Display};
+
+use axum::http::StatusCode;
+use tokio_rustls::rustls;
+use axum::http::uri::InvalidUri;
+use color_eyre::eyre::eyre;
+use num_enum::TryFromPrimitive;
+use patch_db::Revision;
+use rpc_toolkit::reqwest;
+use rpc_toolkit::yajrc::{
+    INVALID_PARAMS_ERROR, INVALID_REQUEST_ERROR, METHOD_NOT_FOUND_ERROR, PARSE_ERROR, RpcError,
+};
+use serde::{Deserialize, Serialize};
+use tokio::task::JoinHandle;
+use ts_rs::TS;
+
+use crate::InvalidId;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, TryFromPrimitive)]
+#[repr(i32)]
+pub enum ErrorKind {
+    Unknown = 1,
+    Filesystem = 2,
+    Docker = 3,
+    ConfigSpecViolation = 4,
+    ConfigRulesViolation = 5,
+    NotFound = 6,
+    IncorrectPassword = 7,
+    VersionIncompatible = 8,
+    Network = 9,
+    Registry = 10,
+    Serialization = 11,
+    Deserialization = 12,
+    Utf8 = 13,
+    ParseVersion = 14,
+    IncorrectDisk = 15,
+    // Nginx = 16,
+    Dependency = 17,
+    ParseS9pk = 18,
+    ParseUrl = 19,
+    DiskNotAvailable = 20,
+    BlockDevice = 21,
+    InvalidOnionAddress = 22,
+    Pack = 23,
+    ValidateS9pk = 24,
+    DiskCorrupted = 25, // Remove
+    Tor = 26,
+    ConfigGen = 27,
+    ParseNumber = 28,
+    Database = 29,
+    InvalidId = 30,
+    InvalidSignature = 31,
+    Backup = 32,
+    Restore = 33,
+    Authorization = 34,
+    AutoConfigure = 35,
+    Action = 36,
+    RateLimited = 37,
+    InvalidRequest = 38,
+    MigrationFailed = 39,
+    Uninitialized = 40,
+    ParseNetAddress = 41,
+    ParseSshKey = 42,
+    SoundError = 43,
+    ParseTimestamp = 44,
+    ParseSysInfo = 45,
+    Wifi = 46,
+    Journald = 47,
+    DiskManagement = 48,
+    OpenSsl = 49,
+    PasswordHashGeneration = 50,
+    DiagnosticMode = 51,
+    ParseDbField = 52,
+    Duplicate = 53,
+    MultipleErrors = 54,
+    Incoherent = 55,
+    InvalidBackupTargetId = 56,
+    ProductKeyMismatch = 57,
+    LanPortConflict = 58,
+    Javascript = 59,
+    Pem = 60,
+    TLSInit = 61,
+    Ascii = 62,
+    MissingHeader = 63,
+    Grub = 64,
+    Systemd = 65,
+    OpenSsh = 66,
+    Zram = 67,
+    Lshw = 68,
+    CpuSettings = 69,
+    Firmware = 70,
+    Timeout = 71,
+    Lxc = 72,
+    Cancelled = 73,
+    Git = 74,
+    DBus = 75,
+    InstallFailed = 76,
+    UpdateFailed = 77,
+    Smtp = 78,
+}
+impl ErrorKind {
+    pub fn as_str(&self) -> &'static str {
+        use ErrorKind::*;
+        match self {
+            Unknown => "Unknown Error",
+            Filesystem => "Filesystem I/O Error",
+            Docker => "Docker Error",
+            ConfigSpecViolation => "Config Spec Violation",
+            ConfigRulesViolation => "Config Rules Violation",
+            NotFound => "Not Found",
+            IncorrectPassword => "Incorrect Password",
+            VersionIncompatible => "Version Incompatible",
+            Network => "Network Error",
+            Registry => "Registry Error",
+            Serialization => "Serialization Error",
+            Deserialization => "Deserialization Error",
+            Utf8 => "UTF-8 Parse Error",
+            ParseVersion => "Version Parsing Error",
+            IncorrectDisk => "Incorrect Disk",
+            // Nginx => "Nginx Error",
+            Dependency => "Dependency Error",
+            ParseS9pk => "S9PK Parsing Error",
+            ParseUrl => "URL Parsing Error",
+            DiskNotAvailable => "Disk Not Available",
+            BlockDevice => "Block Device Error",
+            InvalidOnionAddress => "Invalid Onion Address",
+            Pack => "Pack Error",
+            ValidateS9pk => "S9PK Validation Error",
+            DiskCorrupted => "Disk Corrupted", // Remove
+            Tor => "Tor Daemon Error",
+            ConfigGen => "Config Generation Error",
+            ParseNumber => "Number Parsing Error",
+            Database => "Database Error",
+            InvalidId => "Invalid ID",
+            InvalidSignature => "Invalid Signature",
+            Backup => "Backup Error",
+            Restore => "Restore Error",
+            Authorization => "Unauthorized",
+            AutoConfigure => "Auto-Configure Error",
+            Action => "Action Failed",
+            RateLimited => "Rate Limited",
+            InvalidRequest => "Invalid Request",
+            MigrationFailed => "Migration Failed",
+            Uninitialized => "Uninitialized",
+            ParseNetAddress => "Net Address Parsing Error",
+            ParseSshKey => "SSH Key Parsing Error",
+            SoundError => "Sound Interface Error",
+            ParseTimestamp => "Timestamp Parsing Error",
+            ParseSysInfo => "System Info Parsing Error",
+            Wifi => "WiFi Internal Error",
+            Journald => "Journald Error",
+            DiskManagement => "Disk Management Error",
+            OpenSsl => "OpenSSL Internal Error",
+            PasswordHashGeneration => "Password Hash Generation Error",
+            DiagnosticMode => "Server is in Diagnostic Mode",
+            ParseDbField => "Database Field Parse Error",
+            Duplicate => "Duplication Error",
+            MultipleErrors => "Multiple Errors",
+            Incoherent => "Incoherent",
+            InvalidBackupTargetId => "Invalid Backup Target ID",
+            ProductKeyMismatch => "Incompatible Product Keys",
+            LanPortConflict => "Incompatible LAN Port Configuration",
+            Javascript => "Javascript Engine Error",
+            Pem => "PEM Encoding Error",
+            TLSInit => "TLS Backend Initialization Error",
+            Ascii => "ASCII Parse Error",
+            MissingHeader => "Missing Header",
+            Grub => "Grub Error",
+            Systemd => "Systemd Error",
+            OpenSsh => "OpenSSH Error",
+            Zram => "Zram Error",
+            Lshw => "LSHW Error",
+            CpuSettings => "CPU Settings Error",
+            Firmware => "Firmware Error",
+            Timeout => "Timeout Error",
+            Lxc => "LXC Error",
+            Cancelled => "Cancelled",
+            Git => "Git Error",
+            DBus => "DBus Error",
+            InstallFailed => "Install Failed",
+            UpdateFailed => "Update Failed",
+            Smtp => "SMTP Error",
+        }
+    }
+}
+impl Display for ErrorKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+pub struct Error {
+    pub source: color_eyre::eyre::Error,
+    pub debug: Option<color_eyre::eyre::Error>,
+    pub kind: ErrorKind,
+    pub revision: Option<Revision>,
+    pub task: Option<JoinHandle<()>>,
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}: {:#}", self.kind.as_str(), self.source)
+    }
+}
+impl Debug for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}: {:?}",
+            self.kind.as_str(),
+            self.debug.as_ref().unwrap_or(&self.source)
+        )
+    }
+}
+impl Error {
+    pub fn new<E: Into<color_eyre::eyre::Error> + std::fmt::Debug + 'static>(
+        source: E,
+        kind: ErrorKind,
+    ) -> Self {
+        let debug = (std::any::TypeId::of::<E>() == std::any::TypeId::of::<color_eyre::eyre::Error>())
+            .then(|| eyre!("{source:?}"));
+        Error {
+            source: source.into(),
+            debug,
+            kind,
+            revision: None,
+            task: None,
+        }
+    }
+    pub fn clone_output(&self) -> Self {
+        Error {
+            source: eyre!("{}", self.source),
+            debug: self.debug.as_ref().map(|e| eyre!("{e}")),
+            kind: self.kind,
+            revision: self.revision.clone(),
+            task: None,
+        }
+    }
+    pub fn with_task(mut self, task: JoinHandle<()>) -> Self {
+        self.task = Some(task);
+        self
+    }
+    pub async fn wait(mut self) -> Self {
+        if let Some(task) = &mut self.task {
+            task.await.log_err();
+        }
+        self.task.take();
+        self
+    }
+}
+impl axum::response::IntoResponse for Error {
+    fn into_response(self) -> axum::response::Response {
+        let mut res = axum::Json(RpcError::from(self)).into_response();
+        *res.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+        res
+    }
+}
+impl From<std::convert::Infallible> for Error {
+    fn from(value: std::convert::Infallible) -> Self {
+        match value {}
+    }
+}
+impl From<InvalidId> for Error {
+    fn from(err: InvalidId) -> Self {
+        Error::new(err, ErrorKind::InvalidId)
+    }
+}
+impl From<std::io::Error> for Error {
+    fn from(e: std::io::Error) -> Self {
+        Error::new(e, ErrorKind::Filesystem)
+    }
+}
+impl From<std::str::Utf8Error> for Error {
+    fn from(e: std::str::Utf8Error) -> Self {
+        Error::new(e, ErrorKind::Utf8)
+    }
+}
+impl From<std::string::FromUtf8Error> for Error {
+    fn from(e: std::string::FromUtf8Error) -> Self {
+        Error::new(e, ErrorKind::Utf8)
+    }
+}
+impl From<exver::ParseError> for Error {
+    fn from(e: exver::ParseError) -> Self {
+        Error::new(e, ErrorKind::ParseVersion)
+    }
+}
+impl From<rpc_toolkit::url::ParseError> for Error {
+    fn from(e: rpc_toolkit::url::ParseError) -> Self {
+        Error::new(e, ErrorKind::ParseUrl)
+    }
+}
+impl From<std::num::ParseIntError> for Error {
+    fn from(e: std::num::ParseIntError) -> Self {
+        Error::new(e, ErrorKind::ParseNumber)
+    }
+}
+impl From<std::num::ParseFloatError> for Error {
+    fn from(e: std::num::ParseFloatError) -> Self {
+        Error::new(e, ErrorKind::ParseNumber)
+    }
+}
+impl From<patch_db::Error> for Error {
+    fn from(e: patch_db::Error) -> Self {
+        Error::new(e, ErrorKind::Database)
+    }
+}
+impl From<ed25519_dalek::SignatureError> for Error {
+    fn from(e: ed25519_dalek::SignatureError) -> Self {
+        Error::new(e, ErrorKind::InvalidSignature)
+    }
+}
+impl From<std::net::AddrParseError> for Error {
+    fn from(e: std::net::AddrParseError) -> Self {
+        Error::new(e, ErrorKind::ParseNetAddress)
+    }
+}
+impl From<ipnet::AddrParseError> for Error {
+    fn from(e: ipnet::AddrParseError) -> Self {
+        Error::new(e, ErrorKind::ParseNetAddress)
+    }
+}
+impl From<openssl::error::ErrorStack> for Error {
+    fn from(e: openssl::error::ErrorStack) -> Self {
+        Error::new(eyre!("{}", e), ErrorKind::OpenSsl)
+    }
+}
+impl From<mbrman::Error> for Error {
+    fn from(e: mbrman::Error) -> Self {
+        Error::new(e, ErrorKind::DiskManagement)
+    }
+}
+impl From<gpt::GptError> for Error {
+    fn from(e: gpt::GptError) -> Self {
+        Error::new(e, ErrorKind::DiskManagement)
+    }
+}
+impl From<gpt::mbr::MBRError> for Error {
+    fn from(e: gpt::mbr::MBRError) -> Self {
+        Error::new(e, ErrorKind::DiskManagement)
+    }
+}
+impl From<InvalidUri> for Error {
+    fn from(e: InvalidUri) -> Self {
+        Error::new(eyre!("{}", e), ErrorKind::ParseUrl)
+    }
+}
+impl From<ssh_key::Error> for Error {
+    fn from(e: ssh_key::Error) -> Self {
+        Error::new(e, ErrorKind::OpenSsh)
+    }
+}
+impl From<reqwest::Error> for Error {
+    fn from(e: reqwest::Error) -> Self {
+        let kind = match e {
+            _ if e.is_builder() => ErrorKind::ParseUrl,
+            _ if e.is_decode() => ErrorKind::Deserialization,
+            _ => ErrorKind::Network,
+        };
+        Error::new(e, kind)
+    }
+}
+#[cfg(feature = "arti")]
+impl From<arti_client::Error> for Error {
+    fn from(e: arti_client::Error) -> Self {
+        Error::new(e, ErrorKind::Tor)
+    }
+}
+impl From<torut::control::ConnError> for Error {
+    fn from(e: torut::control::ConnError) -> Self {
+        Error::new(e, ErrorKind::Tor)
+    }
+}
+impl From<zbus::Error> for Error {
+    fn from(e: zbus::Error) -> Self {
+        Error::new(e, ErrorKind::DBus)
+    }
+}
+impl From<rustls::Error> for Error {
+    fn from(e: rustls::Error) -> Self {
+        Error::new(e, ErrorKind::OpenSsl)
+    }
+}
+impl From<lettre::error::Error> for Error {
+    fn from(e: lettre::error::Error) -> Self {
+        Error::new(e, ErrorKind::Smtp)
+    }
+}
+impl From<lettre::transport::smtp::Error> for Error {
+    fn from(e: lettre::transport::smtp::Error) -> Self {
+        Error::new(e, ErrorKind::Smtp)
+    }
+}
+impl From<lettre::address::AddressError> for Error {
+    fn from(e: lettre::address::AddressError) -> Self {
+        Error::new(e, ErrorKind::Smtp)
+    }
+}
+impl From<hyper::Error> for Error {
+    fn from(e: hyper::Error) -> Self {
+        Error::new(e, ErrorKind::Network)
+    }
+}
+impl From<patch_db::value::Error> for Error {
+    fn from(value: patch_db::value::Error) -> Self {
+        match value.kind {
+            patch_db::value::ErrorKind::Serialization => {
+                Error::new(value.source, ErrorKind::Serialization)
+            }
+            patch_db::value::ErrorKind::Deserialization => {
+                Error::new(value.source, ErrorKind::Deserialization)
+            }
+        }
+    }
+}
+
+#[derive(Clone, Deserialize, Serialize, TS)]
+pub struct ErrorData {
+    pub details: String,
+    pub debug: String,
+}
+impl Display for ErrorData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.details, f)
+    }
+}
+impl Debug for ErrorData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.debug, f)
+    }
+}
+impl std::error::Error for ErrorData {}
+impl From<Error> for ErrorData {
+    fn from(value: Error) -> Self {
+        Self {
+            details: value.to_string(),
+            debug: format!("{:?}", value),
+        }
+    }
+}
+impl From<&RpcError> for ErrorData {
+    fn from(value: &RpcError) -> Self {
+        Self {
+            details: value
+                .data
+                .as_ref()
+                .and_then(|d| {
+                    d.as_object()
+                        .and_then(|d| {
+                            d.get("details")
+                                .and_then(|d| d.as_str().map(|s| s.to_owned()))
+                        })
+                        .or_else(|| d.as_str().map(|s| s.to_owned()))
+                })
+                .unwrap_or_else(|| value.message.clone().into_owned()),
+            debug: value
+                .data
+                .as_ref()
+                .and_then(|d| {
+                    d.as_object()
+                        .and_then(|d| {
+                            d.get("debug")
+                                .and_then(|d| d.as_str().map(|s| s.to_owned()))
+                        })
+                        .or_else(|| d.as_str().map(|s| s.to_owned()))
+                })
+                .unwrap_or_else(|| value.message.clone().into_owned()),
+        }
+    }
+}
+
+impl From<Error> for RpcError {
+    fn from(e: Error) -> Self {
+        let mut data_object = serde_json::Map::with_capacity(3);
+        data_object.insert("details".to_owned(), format!("{}", e.source).into());
+        data_object.insert("debug".to_owned(), format!("{:?}", e.source).into());
+        data_object.insert(
+            "revision".to_owned(),
+            match serde_json::to_value(&e.revision) {
+                Ok(a) => a,
+                Err(e) => {
+                    tracing::warn!("Error serializing revision for Error object: {}", e);
+                    serde_json::Value::Null
+                }
+            },
+        );
+        RpcError {
+            code: e.kind as i32,
+            message: e.kind.as_str().into(),
+            data: Some(
+                match serde_json::to_value(&ErrorData {
+                    details: format!("{}", e.source),
+                    debug: format!("{:?}", e.source),
+                }) {
+                    Ok(a) => a,
+                    Err(e) => {
+                        tracing::warn!("Error serializing revision for Error object: {}", e);
+                        serde_json::Value::Null
+                    }
+                },
+            ),
+        }
+    }
+}
+impl From<RpcError> for Error {
+    fn from(e: RpcError) -> Self {
+        Error::new(
+            ErrorData::from(&e),
+            if let Ok(kind) = e.code.try_into() {
+                kind
+            } else if e.code == METHOD_NOT_FOUND_ERROR.code {
+                ErrorKind::NotFound
+            } else if e.code == PARSE_ERROR.code
+                || e.code == INVALID_PARAMS_ERROR.code
+                || e.code == INVALID_REQUEST_ERROR.code
+            {
+                ErrorKind::Deserialization
+            } else {
+                ErrorKind::Unknown
+            },
+        )
+    }
+}
 
 #[derive(Debug, Default)]
 pub struct ErrorCollection(Vec<Error>);
@@ -17,15 +539,11 @@ impl ErrorCollection {
         }
     }
 
-    pub fn into_result(mut self) -> Result<(), Error> {
-        if self.0.len() <= 1 {
-            if let Some(err) = self.0.pop() {
-                Err(err)
-            } else {
-                Ok(())
-            }
+    pub fn into_result(self) -> Result<(), Error> {
+        if self.0.is_empty() {
+            Ok(())
         } else {
-            Err(Error::new(self, ErrorKind::MultipleErrors))
+            Err(Error::new(eyre!("{}", self), ErrorKind::MultipleErrors))
         }
     }
 }
@@ -52,13 +570,107 @@ impl std::fmt::Display for ErrorCollection {
         Ok(())
     }
 }
-impl std::error::Error for ErrorCollection {}
+
+pub trait ResultExt<T, E>
+where
+    Self: Sized,
+{
+    fn with_kind(self, kind: ErrorKind) -> Result<T, Error>;
+    fn with_ctx<F: FnOnce(&E) -> (ErrorKind, D), D: Display>(self, f: F) -> Result<T, Error>;
+    fn log_err(self) -> Option<T>;
+}
+impl<T, E> ResultExt<T, E> for Result<T, E>
+where
+    color_eyre::eyre::Error: From<E>,
+    E: std::fmt::Debug + 'static,
+{
+    fn with_kind(self, kind: ErrorKind) -> Result<T, Error> {
+        self.map_err(|e| Error::new(e, kind))
+    }
+
+    fn with_ctx<F: FnOnce(&E) -> (ErrorKind, D), D: Display>(self, f: F) -> Result<T, Error> {
+        self.map_err(|e| {
+            let (kind, ctx) = f(&e);
+            let debug = (std::any::TypeId::of::<E>() == std::any::TypeId::of::<color_eyre::eyre::Error>())
+                .then(|| eyre!("{ctx}: {e:?}"));
+            let source = color_eyre::eyre::Error::from(e);
+            let with_ctx = format!("{ctx}: {source}");
+            let source = source.wrap_err(with_ctx);
+            Error {
+                kind,
+                source,
+                debug,
+                revision: None,
+                task: None,
+            }
+        })
+    }
+
+    fn log_err(self) -> Option<T> {
+        match self {
+            Ok(a) => Some(a),
+            Err(e) => {
+                let e: color_eyre::eyre::Error = e.into();
+                tracing::error!("{e}");
+                tracing::debug!("{e:?}");
+                None
+            }
+        }
+    }
+}
+impl<T> ResultExt<T, Error> for Result<T, Error> {
+    fn with_kind(self, kind: ErrorKind) -> Result<T, Error> {
+        self.map_err(|e| Error { kind, ..e })
+    }
+
+    fn with_ctx<F: FnOnce(&Error) -> (ErrorKind, D), D: Display>(self, f: F) -> Result<T, Error> {
+        self.map_err(|e| {
+            let (kind, ctx) = f(&e);
+            let source = e.source;
+            let with_ctx = format!("{ctx}: {source}");
+            let source = source.wrap_err(with_ctx);
+            let debug = e.debug.map(|e| {
+                let with_ctx = format!("{ctx}: {e}");
+                e.wrap_err(with_ctx)
+            });
+            Error {
+                kind,
+                source,
+                debug,
+                ..e
+            }
+        })
+    }
+
+    fn log_err(self) -> Option<T> {
+        match self {
+            Ok(a) => Some(a),
+            Err(e) => {
+                tracing::error!("{e}");
+                tracing::debug!("{e:?}");
+                None
+            }
+        }
+    }
+}
+
+pub trait OptionExt<T>
+where
+    Self: Sized,
+{
+    fn or_not_found(self, message: impl std::fmt::Display) -> Result<T, Error>;
+}
+impl<T> OptionExt<T> for Option<T> {
+    fn or_not_found(self, message: impl std::fmt::Display) -> Result<T, Error> {
+        self.ok_or_else(|| Error::new(eyre!("{}", message), ErrorKind::NotFound))
+    }
+}
 
 #[macro_export]
 macro_rules! ensure_code {
     ($x:expr, $c:expr, $fmt:expr $(, $arg:expr)*) => {
         if !($x) {
-            Err::<(), _>(crate::error::Error::new(color_eyre::eyre::eyre!($fmt, $($arg, )*), $c))?;
+            return Err(Error::new(color_eyre::eyre::eyre!($fmt, $($arg, )*), $c));
         }
     };
 }

core/startos/src/id/action.rs

@@ -0,0 +1,45 @@
+use std::path::Path;
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+use ts_rs::TS;
+
+use crate::{Id, InvalidId};
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
+#[ts(type = "string")]
+pub struct ActionId(Id);
+impl FromStr for ActionId {
+    type Err = InvalidId;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(ActionId(Id::try_from(s.to_owned())?))
+    }
+}
+impl AsRef<ActionId> for ActionId {
+    fn as_ref(&self) -> &ActionId {
+        self
+    }
+}
+impl std::fmt::Display for ActionId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl AsRef<str> for ActionId {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl AsRef<Path> for ActionId {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}
+impl<'de> Deserialize<'de> for ActionId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        Ok(ActionId(serde::Deserialize::deserialize(deserializer)?))
+    }
+}

core/startos/src/id/gateway.rs

@@ -0,0 +1,60 @@
+use std::convert::Infallible;
+use std::path::Path;
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+use ts_rs::TS;
+use imbl_value::InternedString;
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
+#[ts(type = "string")]
+pub struct GatewayId(InternedString);
+impl GatewayId {
+    pub fn as_str(&self) -> &str {
+        &*self.0
+    }
+}
+impl From<InternedString> for GatewayId {
+    fn from(value: InternedString) -> Self {
+        Self(value)
+    }
+}
+impl From<GatewayId> for InternedString {
+    fn from(value: GatewayId) -> Self {
+        value.0
+    }
+}
+impl FromStr for GatewayId {
+    type Err = Infallible;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(GatewayId(InternedString::intern(s)))
+    }
+}
+impl AsRef<GatewayId> for GatewayId {
+    fn as_ref(&self) -> &GatewayId {
+        self
+    }
+}
+impl std::fmt::Display for GatewayId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl AsRef<str> for GatewayId {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl AsRef<Path> for GatewayId {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref()
+    }
+}
+impl<'de> Deserialize<'de> for GatewayId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        Ok(GatewayId(serde::Deserialize::deserialize(deserializer)?))
+    }
+}

core/startos/src/id/health_check.rs

@@ -0,0 +1,40 @@
+use std::path::Path;
+use std::str::FromStr;
+
+use serde::{Deserialize, Deserializer, Serialize};
+use ts_rs::TS;
+
+use crate::{Id, InvalidId};
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
+#[ts(type = "string")]
+pub struct HealthCheckId(Id);
+impl std::fmt::Display for HealthCheckId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl FromStr for HealthCheckId {
+    type Err = InvalidId;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Id::from_str(s).map(HealthCheckId)
+    }
+}
+impl AsRef<str> for HealthCheckId {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<'de> Deserialize<'de> for HealthCheckId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(HealthCheckId(Deserialize::deserialize(deserializer)?))
+    }
+}
+impl AsRef<Path> for HealthCheckId {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}

core/startos/src/id/host.rs

@@ -0,0 +1,62 @@
+use std::path::Path;
+use std::str::FromStr;
+
+use serde::{Deserialize, Deserializer, Serialize};
+use ts_rs::TS;
+use imbl_value::InternedString;
+
+use crate::{Id, InvalidId};
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
+#[ts(type = "string")]
+pub struct HostId(Id);
+impl FromStr for HostId {
+    type Err = InvalidId;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(Id::try_from(s.to_owned())?))
+    }
+}
+impl From<Id> for HostId {
+    fn from(id: Id) -> Self {
+        Self(id)
+    }
+}
+impl From<HostId> for Id {
+    fn from(value: HostId) -> Self {
+        value.0
+    }
+}
+impl From<HostId> for InternedString {
+    fn from(value: HostId) -> Self {
+        value.0.into()
+    }
+}
+impl std::fmt::Display for HostId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl std::ops::Deref for HostId {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+impl AsRef<str> for HostId {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<'de> Deserialize<'de> for HostId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(HostId(Deserialize::deserialize(deserializer)?))
+    }
+}
+impl AsRef<Path> for HostId {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}

core/startos/src/id/image.rs

@@ -0,0 +1,47 @@
+use std::fmt::Debug;
+use std::path::Path;
+use std::str::FromStr;
+
+use serde::{Deserialize, Deserializer, Serialize};
+use ts_rs::TS;
+
+use crate::util::VersionString;
+use crate::{Id, InvalidId, PackageId};
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
+#[ts(type = "string")]
+pub struct ImageId(Id);
+impl AsRef<Path> for ImageId {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}
+impl std::fmt::Display for ImageId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl ImageId {
+    pub fn for_package(&self, pkg_id: &PackageId, pkg_version: Option<&VersionString>) -> String {
+        format!(
+            "start9/{}/{}:{}",
+            pkg_id,
+            self.0,
+            pkg_version.map(|v| { v.as_str() }).unwrap_or("latest")
+        )
+    }
+}
+impl FromStr for ImageId {
+    type Err = InvalidId;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(ImageId(Id::try_from(s.to_owned())?))
+    }
+}
+impl<'de> Deserialize<'de> for ImageId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(ImageId(Deserialize::deserialize(deserializer)?))
+    }
+}

core/startos/src/id/invalid_id.rs

@@ -0,0 +1,5 @@
+use imbl_value::InternedString;
+
+#[derive(Debug, thiserror::Error)]
+#[error("Invalid ID: {0}")]
+pub struct InvalidId(pub(super) InternedString);

core/startos/src/id/mod.rs

@@ -0,0 +1,120 @@
+use std::borrow::Borrow;
+use std::str::FromStr;
+
+use regex::Regex;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use imbl_value::InternedString;
+
+mod action;
+mod gateway;
+mod health_check;
+mod host;
+mod image;
+mod invalid_id;
+mod package;
+mod replay;
+mod service_interface;
+mod volume;
+
+pub use action::ActionId;
+pub use gateway::GatewayId;
+pub use health_check::HealthCheckId;
+pub use host::HostId;
+pub use image::ImageId;
+pub use invalid_id::InvalidId;
+pub use package::{PackageId, SYSTEM_PACKAGE_ID};
+pub use replay::ReplayId;
+pub use service_interface::ServiceInterfaceId;
+pub use volume::VolumeId;
+
+lazy_static::lazy_static! {
+    static ref ID_REGEX: Regex = Regex::new("^[a-z0-9]+(-[a-z0-9]+)*$").unwrap();
+    pub static ref SYSTEM_ID: Id = Id(InternedString::intern("x_system"));
+}
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub struct Id(InternedString);
+impl std::fmt::Debug for Id {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+impl TryFrom<InternedString> for Id {
+    type Error = InvalidId;
+    fn try_from(value: InternedString) -> Result<Self, Self::Error> {
+        if ID_REGEX.is_match(&value) {
+            Ok(Id(value))
+        } else {
+            Err(InvalidId(value))
+        }
+    }
+}
+impl TryFrom<String> for Id {
+    type Error = InvalidId;
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        if ID_REGEX.is_match(&value) {
+            Ok(Id(InternedString::intern(value)))
+        } else {
+            Err(InvalidId(InternedString::intern(value)))
+        }
+    }
+}
+impl TryFrom<&str> for Id {
+    type Error = InvalidId;
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        if ID_REGEX.is_match(value) {
+            Ok(Id(InternedString::intern(value)))
+        } else {
+            Err(InvalidId(InternedString::intern(value)))
+        }
+    }
+}
+impl FromStr for Id {
+    type Err = InvalidId;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::try_from(s)
+    }
+}
+impl From<Id> for InternedString {
+    fn from(value: Id) -> Self {
+        value.0
+    }
+}
+impl std::ops::Deref for Id {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl std::fmt::Display for Id {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &*self.0)
+    }
+}
+impl AsRef<str> for Id {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+impl Borrow<str> for Id {
+    fn borrow(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<'de> Deserialize<'de> for Id {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let unchecked: InternedString = Deserialize::deserialize(deserializer)?;
+        Id::try_from(unchecked).map_err(serde::de::Error::custom)
+    }
+}
+impl Serialize for Id {
+    fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
+    where
+        Ser: Serializer,
+    {
+        serializer.serialize_str(self)
+    }
+}

core/startos/src/id/package.rs

@@ -0,0 +1,89 @@
+use std::borrow::Borrow;
+use std::path::Path;
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize, Serializer};
+use ts_rs::TS;
+use imbl_value::InternedString;
+
+use crate::{Id, InvalidId, SYSTEM_ID};
+
+lazy_static::lazy_static! {
+    pub static ref SYSTEM_PACKAGE_ID: PackageId = PackageId(SYSTEM_ID.clone());
+}
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, TS)]
+#[ts(type = "string")]
+pub struct PackageId(Id);
+impl FromStr for PackageId {
+    type Err = InvalidId;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(PackageId(Id::try_from(s.to_owned())?))
+    }
+}
+impl From<Id> for PackageId {
+    fn from(id: Id) -> Self {
+        PackageId(id)
+    }
+}
+impl From<PackageId> for Id {
+    fn from(value: PackageId) -> Self {
+        value.0
+    }
+}
+impl From<PackageId> for InternedString {
+    fn from(value: PackageId) -> Self {
+        value.0.into()
+    }
+}
+impl std::ops::Deref for PackageId {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl AsRef<PackageId> for PackageId {
+    fn as_ref(&self) -> &PackageId {
+        self
+    }
+}
+impl std::fmt::Display for PackageId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl AsRef<str> for PackageId {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl Borrow<str> for PackageId {
+    fn borrow(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<'a> Borrow<str> for &'a PackageId {
+    fn borrow(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl AsRef<Path> for PackageId {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}
+impl<'de> Deserialize<'de> for PackageId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        Ok(PackageId(Deserialize::deserialize(deserializer)?))
+    }
+}
+impl Serialize for PackageId {
+    fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
+    where
+        Ser: Serializer,
+    {
+        Serialize::serialize(&self.0, serializer)
+    }
+}

core/startos/src/id/replay.rs

@@ -0,0 +1,53 @@
+use std::convert::Infallible;
+use std::path::Path;
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+use ts_rs::TS;
+use imbl_value::InternedString;
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
+#[ts(type = "string")]
+pub struct ReplayId(InternedString);
+impl<T> From<T> for ReplayId
+where
+    T: Into<InternedString>,
+{
+    fn from(value: T) -> Self {
+        Self(value.into())
+    }
+}
+impl FromStr for ReplayId {
+    type Err = Infallible;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(ReplayId(InternedString::intern(s)))
+    }
+}
+impl AsRef<ReplayId> for ReplayId {
+    fn as_ref(&self) -> &ReplayId {
+        self
+    }
+}
+impl std::fmt::Display for ReplayId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl AsRef<str> for ReplayId {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl AsRef<Path> for ReplayId {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref()
+    }
+}
+impl<'de> Deserialize<'de> for ReplayId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        Ok(ReplayId(serde::Deserialize::deserialize(deserializer)?))
+    }
+}

core/startos/src/id/service_interface.rs

@@ -0,0 +1,59 @@
+use std::path::Path;
+use std::str::FromStr;
+
+use rpc_toolkit::clap::builder::ValueParserFactory;
+use serde::{Deserialize, Deserializer, Serialize};
+use ts_rs::TS;
+
+use crate::util::FromStrParser;
+use crate::Id;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
+#[ts(export, type = "string")]
+pub struct ServiceInterfaceId(Id);
+impl From<Id> for ServiceInterfaceId {
+    fn from(id: Id) -> Self {
+        Self(id)
+    }
+}
+impl std::fmt::Display for ServiceInterfaceId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl std::ops::Deref for ServiceInterfaceId {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+impl AsRef<str> for ServiceInterfaceId {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<'de> Deserialize<'de> for ServiceInterfaceId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(ServiceInterfaceId(Deserialize::deserialize(deserializer)?))
+    }
+}
+impl AsRef<Path> for ServiceInterfaceId {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}
+impl FromStr for ServiceInterfaceId {
+    type Err = <Id as FromStr>::Err;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Id::from_str(s).map(Self)
+    }
+}
+impl ValueParserFactory for ServiceInterfaceId {
+    type Parser = FromStrParser<Self>;
+    fn value_parser() -> Self::Parser {
+        FromStrParser::new()
+    }
+}

core/startos/src/id/volume.rs

@@ -0,0 +1,70 @@
+use std::borrow::Borrow;
+use std::path::Path;
+use std::str::FromStr;
+
+use serde::{Deserialize, Deserializer, Serialize};
+use ts_rs::TS;
+
+use crate::{Id, InvalidId};
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, TS)]
+#[ts(type = "string")]
+pub enum VolumeId {
+    Backup,
+    Custom(Id),
+}
+impl FromStr for VolumeId {
+    type Err = InvalidId;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "BACKUP" => VolumeId::Backup,
+            s => VolumeId::Custom(Id::try_from(s.to_owned())?),
+        })
+    }
+}
+impl std::fmt::Display for VolumeId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            VolumeId::Backup => write!(f, "BACKUP"),
+            VolumeId::Custom(id) => write!(f, "{}", id),
+        }
+    }
+}
+impl AsRef<str> for VolumeId {
+    fn as_ref(&self) -> &str {
+        match self {
+            VolumeId::Backup => "BACKUP",
+            VolumeId::Custom(id) => id.as_ref(),
+        }
+    }
+}
+impl Borrow<str> for VolumeId {
+    fn borrow(&self) -> &str {
+        self.as_ref()
+    }
+}
+impl AsRef<Path> for VolumeId {
+    fn as_ref(&self) -> &Path {
+        AsRef::<str>::as_ref(self).as_ref()
+    }
+}
+impl<'de> Deserialize<'de> for VolumeId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let unchecked: String = Deserialize::deserialize(deserializer)?;
+        Ok(match unchecked.as_ref() {
+            "BACKUP" => VolumeId::Backup,
+            _ => VolumeId::Custom(Id::try_from(unchecked).map_err(serde::de::Error::custom)?),
+        })
+    }
+}
+impl Serialize for VolumeId {
+    fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
+    where
+        Ser: serde::Serializer,
+    {
+        serializer.serialize_str(self.as_ref())
+    }
+}

core/startos/src/init.rs

@@ -7,7 +7,6 @@ use axum::extract::ws;
 use const_format::formatcp;
 use futures::{StreamExt, TryStreamExt};
 use itertools::Itertools;
-use models::ResultExt;
 use rpc_toolkit::{Context, Empty, HandlerArgs, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use tokio::process::Command;
@@ -39,7 +38,7 @@ use crate::util::io::{IOHook, open_file};
 use crate::util::lshw::lshw;
 use crate::util::net::WebSocketExt;
 use crate::util::{Invoke, cpupower};
-use crate::{Error, MAIN_DATA, PACKAGE_DATA};
+use crate::{Error, MAIN_DATA, PACKAGE_DATA, ResultExt};
 
 pub const SYSTEM_REBUILD_PATH: &str = "/media/startos/config/system-rebuild";
 pub const STANDBY_MODE_PATH: &str = "/media/startos/config/standby";
@@ -303,8 +302,8 @@ pub async fn init(
     if tokio::fs::metadata(&downloading).await.is_ok() {
         tokio::fs::remove_dir_all(&downloading).await?;
     }
-    let tmp_docker = Path::new(PACKAGE_DATA).join(formatcp!("tmp/{CONTAINER_TOOL}"));
-    crate::disk::mount::util::bind(&tmp_docker, CONTAINER_DATADIR, false).await?;
+    let tmp_docker = Path::new(PACKAGE_DATA).join("tmp").join(*CONTAINER_TOOL);
+    crate::disk::mount::util::bind(&tmp_docker, *CONTAINER_DATADIR, false).await?;
     init_tmp.complete();
 
     let server_info = db.peek().await.into_public().into_server_info();

core/startos/src/install/mod.rs

@@ -10,7 +10,7 @@ use exver::VersionRange;
 use futures::StreamExt;
 use imbl_value::{InternedString, json};
 use itertools::Itertools;
-use models::{FromStrParser, VersionString};
+use crate::util::{FromStrParser, VersionString};
 use reqwest::Url;
 use reqwest::header::{CONTENT_LENGTH, HeaderMap};
 use rpc_toolkit::HandlerArgs;

core/startos/src/lib.rs

@@ -43,6 +43,7 @@ pub mod diagnostic;
 pub mod disk;
 pub mod error;
 pub mod firmware;
+pub mod id;
 pub mod hostname;
 pub mod init;
 pub mod install;
@@ -75,7 +76,8 @@ pub mod volume;
 use std::time::SystemTime;
 
 use clap::Parser;
-pub use error::{Error, ErrorKind, ResultExt};
+pub use error::{Error, ErrorKind, OptionExt, ResultExt};
+pub use id::*;
 use imbl_value::Value;
 use rpc_toolkit::yajrc::RpcError;
 use rpc_toolkit::{

core/startos/src/logs.rs

@@ -13,7 +13,8 @@ use color_eyre::eyre::eyre;
 use futures::stream::BoxStream;
 use futures::{Future, FutureExt, Stream, StreamExt, TryStreamExt};
 use itertools::Itertools;
-use models::{FromStrParser, PackageId};
+use crate::util::FromStrParser;
+use crate::PackageId;
 use rpc_toolkit::yajrc::RpcError;
 use rpc_toolkit::{
     CallRemote, Context, Empty, HandlerArgs, HandlerExt, HandlerFor, ParentHandler, from_fn_async,

core/startos/src/lxc/mod.rs

@@ -7,7 +7,8 @@ use std::time::Duration;
 use clap::builder::ValueParserFactory;
 use futures::StreamExt;
 use imbl_value::InternedString;
-use models::{FromStrParser, InvalidId, PackageId};
+use crate::util::FromStrParser;
+use crate::{InvalidId, PackageId};
 use rpc_toolkit::yajrc::RpcError;
 use rpc_toolkit::{RpcRequest, RpcResponse};
 use serde::{Deserialize, Serialize};

core/startos/src/main/start-cli.rs

@@ -1,5 +1,19 @@
 use startos::bins::MultiExecutable;
+use startos::s9pk::v2::pack::PREFER_DOCKER;
 
 fn main() {
+    if !std::env::var("STARTOS_USE_PODMAN").map_or(false, |v| {
+        let v = v.trim();
+        if ["1", "true", "y", "yes"].into_iter().any(|x| v == x) {
+            true
+        } else if ["0", "false", "n", "no"].into_iter().any(|x| v == x) {
+            false
+        } else {
+            tracing::warn!("Unknown value for STARTOS_USE_PODMAN: {v}");
+            false
+        }
+    }) {
+        PREFER_DOCKER.set(true).ok();
+    }
     MultiExecutable::default().enable_start_cli().execute()
 }

core/startos/src/middleware/auth.rs

@@ -12,7 +12,6 @@ use basic_cookies::Cookie;
 use chrono::Utc;
 use color_eyre::eyre::eyre;
 use digest::Digest;
-use helpers::const_true;
 use http::HeaderValue;
 use http::header::{COOKIE, USER_AGENT};
 use imbl_value::{InternedString, json};
@@ -32,7 +31,7 @@ use crate::prelude::*;
 use crate::rpc_continuations::OpenAuthedContinuations;
 use crate::util::Invoke;
 use crate::util::io::{create_file_mod, read_file_to_string};
-use crate::util::serde::BASE64;
+use crate::util::serde::{BASE64, const_true};
 use crate::util::sync::SyncMutex;
 
 pub trait AuthContext: SignatureAuthContext {

core/startos/src/net/acme.rs

@@ -9,7 +9,8 @@ use clap::builder::ValueParserFactory;
 use futures::StreamExt;
 use imbl_value::InternedString;
 use itertools::Itertools;
-use models::{ErrorData, FromStrParser};
+use crate::error::ErrorData;
+use crate::util::FromStrParser;
 use openssl::pkey::{PKey, Private};
 use openssl::x509::X509;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};

core/startos/src/net/dns.rs

@@ -9,7 +9,7 @@ use clap::Parser;
 use color_eyre::eyre::eyre;
 use futures::future::BoxFuture;
 use futures::{FutureExt, StreamExt};
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use hickory_client::client::Client;
 use hickory_client::proto::DnsHandle;
 use hickory_client::proto::runtime::TokioRuntimeProvider;
@@ -23,7 +23,7 @@ use hickory_server::proto::rr::{Name, Record, RecordType};
 use hickory_server::server::{Request, RequestHandler, ResponseHandler, ResponseInfo};
 use imbl::OrdMap;
 use imbl_value::InternedString;
-use models::{GatewayId, OptionExt, PackageId};
+use crate::{GatewayId, OptionExt, PackageId};
 use patch_db::json_ptr::JsonPointer;
 use rpc_toolkit::{
     Context, HandlerArgs, HandlerExt, ParentHandler, from_fn_async, from_fn_blocking,

core/startos/src/net/forward.rs

@@ -4,11 +4,11 @@ use std::sync::{Arc, Weak};
 use std::time::Duration;
 
 use futures::channel::oneshot;
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use id_pool::IdPool;
 use iddqd::{IdOrdItem, IdOrdMap};
 use imbl::OrdMap;
-use models::GatewayId;
+use crate::GatewayId;
 use rpc_toolkit::{Context, HandlerArgs, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use tokio::process::Command;

core/startos/src/net/gateway.rs

@@ -10,12 +10,12 @@ use std::time::Duration;
 use clap::Parser;
 use futures::future::Either;
 use futures::{FutureExt, Stream, StreamExt, TryStreamExt};
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use imbl::{OrdMap, OrdSet};
 use imbl_value::InternedString;
 use ipnet::IpNet;
 use itertools::Itertools;
-use models::GatewayId;
+use crate::GatewayId;
 use nix::net::if_::if_nametoindex;
 use patch_db::json_ptr::JsonPointer;
 use rpc_toolkit::{Context, HandlerArgs, HandlerExt, ParentHandler, from_fn_async};

core/startos/src/net/host/address.rs

@@ -3,7 +3,7 @@ use std::net::Ipv4Addr;
 
 use clap::Parser;
 use imbl_value::InternedString;
-use models::GatewayId;
+use crate::GatewayId;
 use rpc_toolkit::{Context, Empty, HandlerArgs, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;

core/startos/src/net/host/binding.rs

@@ -4,7 +4,8 @@ use std::str::FromStr;
 use clap::Parser;
 use clap::builder::ValueParserFactory;
 use imbl::OrdSet;
-use models::{FromStrParser, GatewayId, HostId};
+use crate::util::FromStrParser;
+use crate::{GatewayId, HostId};
 use rpc_toolkit::{Context, Empty, HandlerArgs, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;

core/startos/src/net/host/mod.rs

@@ -5,7 +5,7 @@ use std::panic::RefUnwindSafe;
 use clap::Parser;
 use imbl_value::InternedString;
 use itertools::Itertools;
-use models::{HostId, PackageId};
+use crate::{HostId, PackageId};
 use rpc_toolkit::{Context, Empty, HandlerExt, OrEmpty, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;

core/startos/src/net/net_controller.rs

@@ -6,7 +6,7 @@ use color_eyre::eyre::eyre;
 use imbl::{OrdMap, vector};
 use imbl_value::InternedString;
 use ipnet::IpNet;
-use models::{GatewayId, HostId, OptionExt, PackageId};
+use crate::{GatewayId, HostId, OptionExt, PackageId};
 use tokio::sync::Mutex;
 use tokio::task::JoinHandle;
 use tokio_rustls::rustls::ClientConfig as TlsClientConfig;

core/startos/src/net/service_interface.rs

@@ -1,7 +1,7 @@
 use std::net::{Ipv4Addr, Ipv6Addr};
 
 use imbl_value::InternedString;
-use models::{GatewayId, HostId, ServiceInterfaceId};
+use crate::{GatewayId, HostId, ServiceInterfaceId};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 

core/startos/src/net/socks.rs

@@ -2,7 +2,7 @@ use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
 use std::sync::Arc;
 use std::time::Duration;
 
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use socks5_impl::protocol::{Address, Reply};
 use socks5_impl::server::auth::NoAuth;
 use socks5_impl::server::{AuthAdaptor, ClientConnection, Server};

core/startos/src/net/static_server.rs

@@ -22,7 +22,7 @@ use http::request::Parts as RequestParts;
 use http::{HeaderValue, Method, StatusCode};
 use imbl_value::InternedString;
 use include_dir::Dir;
-use models::PackageId;
+use crate::PackageId;
 use new_mime_guess::MimeGuess;
 use openssl::hash::MessageDigest;
 use openssl::x509::X509;

core/startos/src/net/tor/arti.rs

@@ -11,7 +11,7 @@ use base64::Engine;
 use clap::Parser;
 use color_eyre::eyre::eyre;
 use futures::{FutureExt, StreamExt};
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use imbl_value::InternedString;
 use itertools::Itertools;
 use rpc_toolkit::{Context, Empty, HandlerExt, ParentHandler, from_fn_async};

core/startos/src/net/tor/ctor.rs

@@ -10,7 +10,7 @@ use clap::Parser;
 use color_eyre::eyre::eyre;
 use futures::future::BoxFuture;
 use futures::{FutureExt, TryFutureExt, TryStreamExt};
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use imbl::OrdMap;
 use imbl_value::InternedString;
 use lazy_static::lazy_static;

core/startos/src/net/tunnel.rs

@@ -1,6 +1,6 @@
 use clap::Parser;
 use imbl_value::InternedString;
-use models::GatewayId;
+use crate::GatewayId;
 use patch_db::json_ptr::JsonPointer;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};

core/startos/src/net/utils.rs

@@ -8,7 +8,7 @@ use futures::stream::BoxStream;
 use futures::{StreamExt, TryStreamExt};
 use imbl_value::InternedString;
 use ipnet::{IpNet, Ipv4Net, Ipv6Net};
-use models::GatewayId;
+use crate::GatewayId;
 use nix::net::if_::if_nametoindex;
 use tokio::net::{TcpListener, TcpStream};
 use tokio::process::Command;

core/startos/src/net/vhost.rs

@@ -9,9 +9,9 @@ use async_acme::acme::ACME_TLS_ALPN_NAME;
 use color_eyre::eyre::eyre;
 use futures::FutureExt;
 use futures::future::BoxFuture;
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use imbl_value::{InOMap, InternedString};
-use models::ResultExt;
+use crate::ResultExt;
 use rpc_toolkit::{Context, HandlerArgs, HandlerExt, ParentHandler, from_fn};
 use serde::{Deserialize, Serialize};
 use tokio::net::TcpStream;

core/startos/src/net/web_server.rs

@@ -12,7 +12,7 @@ use std::time::Duration;
 use axum::Router;
 use futures::future::Either;
 use futures::{FutureExt, TryFutureExt};
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use http::Extensions;
 use hyper_util::rt::{TokioIo, TokioTimer};
 use tokio::net::TcpListener;

core/startos/src/notifications.rs

@@ -6,9 +6,9 @@ use chrono::{DateTime, Utc};
 use clap::Parser;
 use clap::builder::ValueParserFactory;
 use color_eyre::eyre::eyre;
-use helpers::const_true;
 use imbl_value::InternedString;
-use models::{FromStrParser, PackageId};
+use crate::util::FromStrParser;
+use crate::PackageId;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
@@ -18,7 +18,7 @@ use crate::backup::BackupReport;
 use crate::context::{CliContext, RpcContext};
 use crate::db::model::DatabaseModel;
 use crate::prelude::*;
-use crate::util::serde::HandlerExtSerde;
+use crate::util::serde::{HandlerExtSerde, const_true};
 
 // #[command(subcommands(list, delete, delete_before, create))]
 pub fn notification<C: Context>() -> ParentHandler<C> {

core/startos/src/os_install/mod.rs

@@ -2,7 +2,7 @@ use std::path::{Path, PathBuf};
 
 use clap::Parser;
 use color_eyre::eyre::eyre;
-use models::Error;
+use crate::Error;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use tokio::process::Command;

core/startos/src/prelude.rs

@@ -1,11 +1,10 @@
 pub use color_eyre::eyre::eyre;
 pub use lazy_format::lazy_format;
-pub use models::OptionExt;
 pub use tracing::instrument;
 
 pub use crate::db::prelude::*;
 pub use crate::ensure_code;
-pub use crate::error::{Error, ErrorCollection, ErrorKind, ResultExt};
+pub use crate::error::{Error, ErrorCollection, ErrorKind, OptionExt, ResultExt};
 
 #[macro_export]
 macro_rules! dbg {

core/startos/src/progress.rs

@@ -4,7 +4,6 @@ use std::time::Duration;
 use futures::future::pending;
 use futures::stream::BoxStream;
 use futures::{Future, FutureExt, StreamExt, TryFutureExt};
-use helpers::NonDetachingJoinHandle;
 use imbl::Vector;
 use imbl_value::{InOMap, InternedString};
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
@@ -16,6 +15,7 @@ use ts_rs::TS;
 
 use crate::db::model::{Database, DatabaseModel};
 use crate::prelude::*;
+use crate::util::future::NonDetachingJoinHandle;
 
 lazy_static::lazy_static! {
     static ref SPINNER: ProgressStyle = ProgressStyle::with_template("{spinner} {msg}...").unwrap();

core/startos/src/registry/asset.rs

@@ -3,7 +3,7 @@ use std::path::Path;
 use std::sync::Arc;
 
 use chrono::{DateTime, Utc};
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use reqwest::Client;
 use serde::{Deserialize, Serialize};
 use tokio::io::AsyncWrite;

core/startos/src/registry/info.rs

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 use clap::Parser;
 use imbl_value::InternedString;
 use itertools::Itertools;
-use models::DataUrl;
+use crate::util::DataUrl;
 use rpc_toolkit::{Context, Empty, HandlerArgs, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;

core/startos/src/registry/mod.rs

@@ -3,7 +3,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use axum::Router;
 use futures::future::ready;
 use imbl_value::InternedString;
-use models::DataUrl;
+use crate::util::DataUrl;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, Server, from_fn_async};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;

core/startos/src/registry/os/asset/get.rs

@@ -4,7 +4,6 @@ use std::path::{Path, PathBuf};
 
 use clap::Parser;
 use exver::Version;
-use helpers::AtomicFile;
 use imbl_value::{InternedString, json};
 use itertools::Itertools;
 use rpc_toolkit::{Context, HandlerArgs, HandlerExt, ParentHandler, from_fn_async};
@@ -21,7 +20,7 @@ use crate::registry::os::index::OsVersionInfo;
 use crate::s9pk::merkle_archive::source::multi_cursor_file::MultiCursorFile;
 use crate::sign::commitment::Commitment;
 use crate::sign::commitment::blake3::Blake3Commitment;
-use crate::util::io::open_file;
+use crate::util::io::{AtomicFile, open_file};
 
 pub fn get_api<C: Context>() -> ParentHandler<C> {
     ParentHandler::new()
@@ -159,9 +158,7 @@ async fn cli_get_os_asset(
 
     if let Some(download) = download {
         let download = download.join(format!("startos-{version}_{platform}.{ext}"));
-        let mut file = AtomicFile::new(&download, None::<&Path>)
-            .await
-            .with_kind(ErrorKind::Filesystem)?;
+        let mut file = AtomicFile::new(&download, None::<&Path>).await?;
 
         let progress = FullProgressTracker::new();
         let mut download_phase =
@@ -181,7 +178,7 @@ async fn cli_get_os_asset(
         res.download(ctx.client.clone(), &mut download_writer)
             .await?;
         let (_, mut download_phase) = download_writer.into_inner();
-        file.save().await.with_kind(ErrorKind::Filesystem)?;
+        file.save().await?;
         download_phase.complete();
 
         if let Some(mut reverify_phase) = reverify_phase {

core/startos/src/registry/package/add.rs

@@ -4,7 +4,8 @@ use std::sync::Arc;
 use clap::Parser;
 use imbl_value::InternedString;
 use itertools::Itertools;
-use models::{PackageId, VersionString};
+use crate::util::VersionString;
+use crate::PackageId;
 use rpc_toolkit::HandlerArgs;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;

core/startos/src/registry/package/category.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 
 use clap::Parser;
 use imbl_value::InternedString;
-use models::PackageId;
+use crate::PackageId;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;

core/startos/src/registry/package/get.rs

@@ -3,10 +3,9 @@ use std::path::{Path, PathBuf};
 
 use clap::{Parser, ValueEnum};
 use exver::{ExtendedVersion, VersionRange};
-use helpers::to_tmp_path;
 use imbl_value::{InternedString, json};
 use itertools::Itertools;
-use models::PackageId;
+use crate::PackageId;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 
@@ -19,7 +18,7 @@ use crate::registry::package::index::{PackageIndex, PackageVersionInfo};
 use crate::s9pk::merkle_archive::source::ArchiveSource;
 use crate::s9pk::v2::SIG_CONTEXT;
 use crate::util::VersionString;
-use crate::util::io::TrackingIO;
+use crate::util::io::{TrackingIO, to_tmp_path};
 use crate::util::serde::{WithIoFormat, display_serializable};
 use crate::util::tui::choose;
 
@@ -457,7 +456,7 @@ pub async fn cli_download(
     fetching_progress.complete();
 
     let dest = dest.unwrap_or_else(|| Path::new(".").join(id).with_extension("s9pk"));
-    let dest_tmp = to_tmp_path(&dest).with_kind(ErrorKind::Filesystem)?;
+    let dest_tmp = to_tmp_path(&dest)?;
     let (mut parsed, source) = s9pk
         .download_to(&dest_tmp, ctx.client.clone(), download_progress)
         .await?;

core/startos/src/registry/package/index.rs

@@ -3,7 +3,8 @@ use std::collections::{BTreeMap, BTreeSet};
 use chrono::Utc;
 use exver::{Version, VersionRange};
 use imbl_value::InternedString;
-use models::{DataUrl, PackageId, VersionString};
+use crate::util::{DataUrl, VersionString};
+use crate::PackageId;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 use url::Url;

core/startos/src/registry/package/signer.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 
 use clap::Parser;
 use exver::VersionRange;
-use models::PackageId;
+use crate::PackageId;
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;

core/startos/src/registry/signer.rs

@@ -3,7 +3,7 @@ use std::str::FromStr;
 
 use clap::builder::ValueParserFactory;
 use itertools::Itertools;
-use models::FromStrParser;
+use crate::util::FromStrParser;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 use url::Url;

core/startos/src/rpc_continuations.rs

@@ -11,14 +11,14 @@ use axum::response::Response;
 use clap::builder::ValueParserFactory;
 use futures::future::BoxFuture;
 use futures::{Future, FutureExt};
-use helpers::TimedResource;
 use imbl_value::InternedString;
-use models::FromStrParser;
+use crate::util::FromStrParser;
 use tokio::sync::{Mutex as AsyncMutex, broadcast};
 use ts_rs::TS;
 
 #[allow(unused_imports)]
 use crate::prelude::*;
+use crate::util::future::TimedResource;
 use crate::util::new_guid;
 
 #[derive(

core/startos/src/s9pk/rpc.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use clap::Parser;
-use models::ImageId;
+use crate::ImageId;
 use rpc_toolkit::{Empty, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;

core/startos/src/s9pk/v1/manifest.rs

@@ -4,8 +4,8 @@ use std::path::{Path, PathBuf};
 use exver::{Version, VersionRange};
 use imbl_value::InternedString;
 use indexmap::IndexMap;
-pub use models::PackageId;
-use models::{ActionId, HealthCheckId, ImageId, VolumeId};
+pub use crate::PackageId;
+use crate::{ActionId, HealthCheckId, ImageId, VolumeId};
 use serde::{Deserialize, Serialize};
 use url::Url;
 

core/startos/src/s9pk/v1/reader.rs

@@ -9,7 +9,7 @@ use std::task::{Context, Poll};
 use color_eyre::eyre::eyre;
 use digest::Output;
 use ed25519_dalek::VerifyingKey;
-use models::{ImageId, PackageId};
+use crate::{ImageId, PackageId};
 use sha2::{Digest, Sha512};
 use tokio::fs::File;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncSeek, AsyncSeekExt, BufReader, ReadBuf};

core/startos/src/s9pk/v2/compat.rs

@@ -4,7 +4,6 @@ use std::str::FromStr;
 use std::sync::Arc;
 
 use exver::{ExtendedVersion, VersionRange};
-use models::{ImageId, VolumeId};
 use tokio::io::{AsyncRead, AsyncSeek, AsyncWriteExt};
 use tokio::process::Command;
 
@@ -20,6 +19,7 @@ use crate::s9pk::v2::pack::{CONTAINER_TOOL, ImageSource, PackSource};
 use crate::s9pk::v2::{S9pk, SIG_CONTEXT};
 use crate::util::Invoke;
 use crate::util::io::{TmpDir, create_file};
+use crate::{ImageId, VolumeId};
 
 pub const MAGIC_AND_VERSION: &[u8] = &[0x3b, 0x3b, 0x01];
 
@@ -30,7 +30,7 @@ impl S9pk<TmpSource<PackSource>> {
         tmp_dir: Arc<TmpDir>,
         signer: ed25519_dalek::SigningKey,
     ) -> Result<Self, Error> {
-        Command::new(CONTAINER_TOOL)
+        Command::new(*CONTAINER_TOOL)
             .arg("run")
             .arg("--rm")
             .arg("--privileged")
@@ -80,7 +80,7 @@ impl S9pk<TmpSource<PackSource>> {
 
         // images
         for arch in reader.docker_arches().await? {
-            Command::new(CONTAINER_TOOL)
+            Command::new(*CONTAINER_TOOL)
                 .arg("load")
                 .input(Some(&mut reader.docker_images(&arch).await?))
                 .invoke(ErrorKind::Docker)
@@ -104,7 +104,7 @@ impl S9pk<TmpSource<PackSource>> {
                         &mut archive,
                     )
                     .await?;
-                Command::new(CONTAINER_TOOL)
+                Command::new(*CONTAINER_TOOL)
                     .arg("rmi")
                     .arg("-f")
                     .arg(&image_name)

core/startos/src/s9pk/v2/manifest.rs

@@ -4,8 +4,9 @@ use std::path::Path;
 use color_eyre::eyre::eyre;
 use exver::{Version, VersionRange};
 use imbl_value::InternedString;
-pub use models::PackageId;
-use models::{ImageId, VolumeId, mime};
+pub use crate::PackageId;
+use crate::util::mime;
+use crate::{ImageId, VolumeId};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 use url::Url;

core/startos/src/s9pk/v2/mod.rs

@@ -3,7 +3,8 @@ use std::path::Path;
 use std::sync::Arc;
 
 use imbl_value::InternedString;
-use models::{DataUrl, PackageId, mime};
+use crate::util::{DataUrl, mime};
+use crate::PackageId;
 use tokio::fs::File;
 
 use crate::dependencies::DependencyMetadata;

core/startos/src/s9pk/v2/pack.rs

@@ -1,12 +1,11 @@
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock, OnceLock};
 
 use clap::Parser;
 use futures::future::{BoxFuture, ready};
 use futures::{FutureExt, TryStreamExt};
 use imbl_value::InternedString;
-use models::{DataUrl, ImageId, PackageId, VersionString};
 use serde::{Deserialize, Serialize};
 use tokio::process::Command;
 use tokio::sync::OnceCell;
@@ -31,17 +30,33 @@ use crate::s9pk::merkle_archive::{Entry, MerkleArchive};
 use crate::s9pk::v2::SIG_CONTEXT;
 use crate::util::io::{TmpDir, create_file, open_file};
 use crate::util::serde::IoFormat;
-use crate::util::{Invoke, PathOrUrl, new_guid};
+use crate::util::{DataUrl, Invoke, PathOrUrl, VersionString, new_guid};
+use crate::{ImageId, PackageId};
 
-#[cfg(not(feature = "docker"))]
-pub const CONTAINER_TOOL: &str = "podman";
-#[cfg(feature = "docker")]
-pub const CONTAINER_TOOL: &str = "docker";
+pub static PREFER_DOCKER: OnceLock<bool> = OnceLock::new();
 
-#[cfg(feature = "docker")]
-pub const CONTAINER_DATADIR: &str = "/var/lib/docker";
-#[cfg(not(feature = "docker"))]
-pub const CONTAINER_DATADIR: &str = "/var/lib/containers";
+pub static CONTAINER_TOOL: LazyLock<&'static str> = LazyLock::new(|| {
+    if *PREFER_DOCKER.get_or_init(|| false) {
+        if std::process::Command::new("which")
+            .arg("docker")
+            .status()
+            .map_or(false, |o| o.success())
+        {
+            "docker"
+        } else {
+            "podman"
+        }
+    } else {
+        "podman"
+    }
+});
+pub static CONTAINER_DATADIR: LazyLock<&'static str> = LazyLock::new(|| {
+    if *CONTAINER_TOOL == "docker" {
+        "/var/lib/docker"
+    } else {
+        "/var/lib/containers"
+    }
+});
 
 pub struct SqfsDir {
     path: PathBuf,
@@ -423,8 +438,8 @@ impl ImageSource {
                     };
                     // docker buildx build ${path} -o type=image,name=start9/${id}
                     let tag = format!("start9/{id}/{image_id}:{}", new_guid());
-                    let mut command = Command::new(CONTAINER_TOOL);
-                    if CONTAINER_TOOL == "docker" {
+                    let mut command = Command::new(*CONTAINER_TOOL);
+                    if *CONTAINER_TOOL == "docker" {
                         command.arg("buildx");
                     }
                     command
@@ -461,13 +476,13 @@ impl ImageSource {
                         .arg("-o")
                         .arg("type=docker,dest=-")
                         .capture(false)
-                        .pipe(Command::new(CONTAINER_TOOL).arg("load"))
+                        .pipe(Command::new(*CONTAINER_TOOL).arg("load"))
                         .invoke(ErrorKind::Docker)
                         .await?;
                     ImageSource::DockerTag(tag.clone())
                         .load(tmp_dir, id, version, image_id, arch, into)
                         .await?;
-                    Command::new(CONTAINER_TOOL)
+                    Command::new(*CONTAINER_TOOL)
                         .arg("rmi")
                         .arg("-f")
                         .arg(&tag)
@@ -484,7 +499,7 @@ impl ImageSource {
                         format!("--platform=linux/{arch}")
                     };
                     let container = String::from_utf8(
-                        Command::new(CONTAINER_TOOL)
+                        Command::new(*CONTAINER_TOOL)
                             .arg("create")
                             .arg(&docker_platform)
                             .arg(&tag)
@@ -493,7 +508,7 @@ impl ImageSource {
                     )?;
                     let container = container.trim();
                     let config = serde_json::from_slice::<DockerImageConfig>(
-                        &Command::new(CONTAINER_TOOL)
+                        &Command::new(*CONTAINER_TOOL)
                             .arg("container")
                             .arg("inspect")
                             .arg("--format")
@@ -545,14 +560,14 @@ impl ImageSource {
                         .join(Guid::new().as_ref())
                         .with_extension("squashfs");
 
-                    Command::new(CONTAINER_TOOL)
+                    Command::new(*CONTAINER_TOOL)
                         .arg("export")
                         .arg(container)
                         .pipe(&mut tar2sqfs(&dest)?)
                         .capture(false)
                         .invoke(ErrorKind::Docker)
                         .await?;
-                    Command::new(CONTAINER_TOOL)
+                    Command::new(*CONTAINER_TOOL)
                         .arg("rm")
                         .arg(container)
                         .invoke(ErrorKind::Docker)
@@ -586,7 +601,7 @@ fn tar2sqfs(dest: impl AsRef<Path>) -> Result<Command, Error> {
                 .parent()
                 .unwrap_or_else(|| Path::new("/"))
                 .to_path_buf();
-            let mut command = Command::new(CONTAINER_TOOL);
+            let mut command = Command::new(*CONTAINER_TOOL);
             command
                 .arg("run")
                 .arg("-i")

core/startos/src/service/action.rs

@@ -2,7 +2,8 @@ use std::collections::BTreeMap;
 use std::time::Duration;
 
 use imbl_value::json;
-use models::{ActionId, PackageId, ProcedureName, ReplayId};
+use crate::service::ProcedureName;
+use crate::{ActionId, PackageId, ReplayId};
 
 use crate::action::{ActionInput, ActionResult};
 use crate::db::model::package::{

core/startos/src/service/effects/action.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeSet;
 
-use models::{ActionId, PackageId, ReplayId};
+use crate::{ActionId, PackageId, ReplayId};
 use rpc_toolkit::{Context, HandlerExt, ParentHandler, from_fn_async};
 
 use crate::action::{ActionInput, ActionResult, display_action_result};

core/startos/src/service/effects/callbacks.rs

@@ -5,10 +5,10 @@ use std::time::{Duration, SystemTime};
 
 use clap::Parser;
 use futures::future::join_all;
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use imbl::{Vector, vector};
 use imbl_value::InternedString;
-use models::{HostId, PackageId, ServiceInterfaceId};
+use crate::{HostId, PackageId, ServiceInterfaceId};
 use serde::{Deserialize, Serialize};
 use tracing::warn;
 use ts_rs::TS;

core/startos/src/service/effects/control.rs

@@ -2,7 +2,8 @@ use std::str::FromStr;
 
 use chrono::Utc;
 use clap::builder::ValueParserFactory;
-use models::{FromStrParser, PackageId};
+use crate::util::FromStrParser;
+use crate::PackageId;
 
 use crate::service::RebuildParams;
 use crate::service::effects::prelude::*;

core/startos/src/service/effects/dependency.rs

@@ -5,7 +5,8 @@ use std::str::FromStr;
 use clap::builder::ValueParserFactory;
 use exver::VersionRange;
 use imbl_value::InternedString;
-use models::{FromStrParser, HealthCheckId, PackageId, ReplayId, VersionString, VolumeId};
+use crate::util::{FromStrParser, VersionString};
+use crate::{HealthCheckId, PackageId, ReplayId, VolumeId};
 
 use crate::DATA_DIR;
 use crate::db::model::package::{

core/startos/src/service/effects/health.rs

@@ -1,4 +1,4 @@
-use models::HealthCheckId;
+use crate::HealthCheckId;
 
 use crate::service::effects::prelude::*;
 use crate::status::health_check::NamedHealthCheckResult;

core/startos/src/service/effects/net/bind.rs

@@ -1,4 +1,4 @@
-use models::{HostId, PackageId};
+use crate::{HostId, PackageId};
 
 use crate::net::host::binding::{BindId, BindOptions, NetInfo};
 use crate::service::effects::prelude::*;

core/startos/src/service/effects/net/host.rs

@@ -1,4 +1,4 @@
-use models::{HostId, PackageId};
+use crate::{HostId, PackageId};
 
 use crate::net::host::Host;
 use crate::service::effects::callbacks::CallbackHandler;

core/startos/src/service/effects/net/info.rs

@@ -1,6 +1,6 @@
 use std::net::Ipv4Addr;
 
-use models::PackageId;
+use crate::PackageId;
 
 use crate::service::effects::callbacks::CallbackHandler;
 use crate::service::effects::prelude::*;

core/startos/src/service/effects/net/interface.rs

@@ -1,7 +1,7 @@
 use std::collections::BTreeMap;
 
 use imbl::vector;
-use models::{PackageId, ServiceInterfaceId};
+use crate::{PackageId, ServiceInterfaceId};
 
 use crate::net::service_interface::{AddressInfo, ServiceInterface, ServiceInterfaceType};
 use crate::service::effects::callbacks::CallbackHandler;

core/startos/src/service/effects/subcontainer/mod.rs

@@ -1,9 +1,9 @@
 use std::path::{Path, PathBuf};
 
 use imbl_value::InternedString;
-use models::ImageId;
 use tokio::process::Command;
 
+use crate::ImageId;
 use crate::disk::mount::filesystem::overlayfs::OverlayGuard;
 use crate::disk::mount::guard::GenericMountGuard;
 use crate::rpc_continuations::Guid;
@@ -11,14 +11,14 @@ use crate::service::effects::prelude::*;
 use crate::service::persistent_container::Subcontainer;
 use crate::util::Invoke;
 
-#[cfg(all(feature = "pty-process", feature = "procfs"))]
+#[cfg(target_os = "linux")]
 mod sync;
 
-#[cfg(not(all(feature = "pty-process", feature = "procfs")))]
+#[cfg(not(target_os = "linux"))]
 mod sync_dummy;
 
 pub use sync::*;
-#[cfg(not(all(feature = "pty-process", feature = "procfs")))]
+#[cfg(not(target_os = "linux"))]
 use sync_dummy as sync;
 
 #[derive(Debug, Deserialize, Serialize, Parser, TS)]
@@ -41,7 +41,7 @@ pub async fn destroy_subcontainer_fs(
         .await
         .remove(&guid)
     {
-        #[cfg(all(feature = "pty-process", feature = "procfs"))]
+        #[cfg(target_os = "linux")]
         if tokio::fs::metadata(overlay.overlay.path().join("proc/1"))
             .await
             .is_ok()

core/startos/src/service/effects/subcontainer/sync.rs

@@ -46,7 +46,7 @@ pub fn kill_init(procfs: &Path, chroot: &Path) -> Result<(), Error> {
                 .get(OsStr::new("pid"))
                 .map_or(false, |ns| ns.identifier == ns_id)
             {
-                let pids = proc.read::<NSPid>("status").with_ctx(|_| {
+                let pids = proc.read::<_, NSPid>("status").with_ctx(|_| {
                     (
                         ErrorKind::Filesystem,
                         lazy_format!("read pid {} NSpid", pid),

core/startos/src/service/mod.rs

@@ -13,10 +13,10 @@ use clap::Parser;
 use futures::future::BoxFuture;
 use futures::stream::FusedStream;
 use futures::{FutureExt, SinkExt, StreamExt, TryStreamExt};
-use helpers::{AtomicFile, NonDetachingJoinHandle};
+use crate::util::future::NonDetachingJoinHandle;
 use imbl_value::{InternedString, json};
 use itertools::Itertools;
-use models::{ActionId, HostId, ImageId, PackageId};
+use crate::{ActionId, HostId, ImageId, PackageId};
 use nix::sys::signal::Signal;
 use persistent_container::{PersistentContainer, Subcontainer};
 use rpc_toolkit::HandlerArgs;
@@ -47,7 +47,7 @@ use crate::service::service_map::InstallProgressHandles;
 use crate::service::uninstall::cleanup;
 use crate::util::Never;
 use crate::util::actor::concurrent::ConcurrentActor;
-use crate::util::io::{AsyncReadStream, TermSize, delete_file};
+use crate::util::io::{AsyncReadStream, AtomicFile, TermSize, delete_file};
 use crate::util::net::WebSocketExt;
 use crate::util::serde::Pem;
 use crate::util::sync::SyncMutex;
@@ -58,6 +58,7 @@ pub mod action;
 pub mod cli;
 pub mod effects;
 pub mod persistent_container;
+pub mod procedure_name;
 mod rpc;
 mod service_actor;
 pub mod service_map;
@@ -65,6 +66,7 @@ pub mod start_stop;
 mod transition;
 pub mod uninstall;
 
+pub use procedure_name::ProcedureName;
 pub use service_map::ServiceMap;
 
 pub const HEALTH_CHECK_COOLDOWN_SECONDS: u64 = 15;
@@ -580,16 +582,15 @@ impl Service {
     #[instrument(skip_all)]
     pub async fn backup(&self, guard: impl GenericMountGuard) -> Result<(), Error> {
         let id = &self.seed.id;
-        let mut file = AtomicFile::new(guard.path().join(id).with_extension("s9pk"), None::<&str>)
-            .await
-            .with_kind(ErrorKind::Filesystem)?;
+        let mut file =
+            AtomicFile::new(guard.path().join(id).with_extension("s9pk"), None::<&str>).await?;
         self.seed
             .persistent_container
             .s9pk
             .clone()
             .serialize(&mut *file, true)
             .await?;
-        file.save().await.with_kind(ErrorKind::Filesystem)?;
+        file.save().await?;
         // TODO: reverify?
         let backup = self
             .actor

core/startos/src/service/persistent_container.rs

@@ -5,10 +5,11 @@ use std::time::Duration;
 
 use futures::Future;
 use futures::future::ready;
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use imbl::{Vector, vector};
 use imbl_value::InternedString;
-use models::{ImageId, ProcedureName, VolumeId};
+use crate::service::ProcedureName;
+use crate::{ImageId, VolumeId};
 use rpc_toolkit::{Empty, Server, ShutdownHandle};
 use serde::de::DeserializeOwned;
 use tokio::process::Command;

core/startos/src/service/procedure_name.rs

@@ -0,0 +1,20 @@
+use serde::{Deserialize, Serialize};
+
+use crate::ActionId;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum ProcedureName {
+    CreateBackup,
+    GetActionInput(ActionId),
+    RunAction(ActionId),
+}
+
+impl ProcedureName {
+    pub fn js_function_name(&self) -> String {
+        match self {
+            ProcedureName::CreateBackup => "/backup/create".to_string(),
+            ProcedureName::RunAction(id) => format!("/actions/{}/run", id),
+            ProcedureName::GetActionInput(id) => format!("/actions/{}/getInput", id),
+        }
+    }
+}

core/startos/src/service/rpc.rs

@@ -7,7 +7,8 @@ use clap::builder::ValueParserFactory;
 use exver::{ExtendedVersion, VersionRange};
 use imbl::Vector;
 use imbl_value::{InternedString, Value};
-use models::{FromStrParser, ProcedureName};
+use crate::service::ProcedureName;
+use crate::util::FromStrParser;
 use rpc_toolkit::Empty;
 use rpc_toolkit::yajrc::RpcMethod;
 use ts_rs::TS;

core/startos/src/service/service_map.rs

@@ -8,9 +8,9 @@ use exver::VersionRange;
 use futures::future::{BoxFuture, Fuse};
 use futures::stream::FuturesUnordered;
 use futures::{Future, FutureExt, StreamExt, TryFutureExt};
-use helpers::NonDetachingJoinHandle;
+use crate::util::future::NonDetachingJoinHandle;
 use imbl::OrdMap;
-use models::ErrorData;
+use crate::error::ErrorData;
 use tokio::sync::{OwnedRwLockReadGuard, OwnedRwLockWriteGuard, RwLock, oneshot};
 use tracing::instrument;
 use url::Url;

core/startos/src/service/transition/backup.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use futures::future::BoxFuture;
 use futures::{FutureExt, TryFutureExt};
-use models::ProcedureName;
+use crate::service::ProcedureName;
 use rpc_toolkit::yajrc::RpcError;
 
 use crate::disk::mount::filesystem::ReadWrite;

core/startos/src/service/uninstall.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use models::PackageId;
+use crate::PackageId;
 
 use crate::context::RpcContext;
 use crate::db::model::package::{InstalledState, InstallingInfo, InstallingState, PackageState};

core/startos/src/sign/mod.rs

@@ -4,7 +4,7 @@ use std::str::FromStr;
 use ::ed25519::pkcs8::BitStringRef;
 use clap::builder::ValueParserFactory;
 use der::referenced::OwnedToRef;
-use models::FromStrParser;
+use crate::util::FromStrParser;
 use pkcs8::der::AnyRef;
 use pkcs8::{PrivateKeyInfo, SubjectPublicKeyInfo};
 use serde::{Deserialize, Serialize};

core/startos/src/ssh.rs

@@ -4,7 +4,7 @@ use std::path::Path;
 use clap::Parser;
 use clap::builder::ValueParserFactory;
 use imbl_value::InternedString;
-use models::FromStrParser;
+use crate::util::FromStrParser;
 use rpc_toolkit::{Context, Empty, HandlerExt, ParentHandler, from_fn_async};
 use serde::{Deserialize, Serialize};
 use tokio::fs::OpenOptions;

core/startos/src/status/health_check.rs

@@ -1,8 +1,8 @@
 use std::str::FromStr;
 
 use clap::builder::ValueParserFactory;
-use models::FromStrParser;
-pub use models::HealthCheckId;
+use crate::util::FromStrParser;
+pub use crate::HealthCheckId;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 

core/startos/src/status/mod.rs

@@ -1,7 +1,8 @@
 use std::collections::BTreeMap;
 
 use chrono::{DateTime, Utc};
-use models::{ErrorData, HealthCheckId};
+use crate::error::ErrorData;
+use crate::HealthCheckId;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 

core/startos/src/tunnel/context.rs

@@ -11,7 +11,7 @@ use imbl::OrdMap;
 use imbl_value::InternedString;
 use include_dir::Dir;
 use ipnet::Ipv4Net;
-use models::GatewayId;
+use crate::GatewayId;
 use patch_db::PatchDb;
 use rpc_toolkit::yajrc::RpcError;
 use rpc_toolkit::{CallRemote, Context, Empty, ParentHandler};

core/startos/src/tunnel/db.rs

@@ -8,7 +8,7 @@ use clap::Parser;
 use imbl::{HashMap, OrdMap};
 use imbl_value::InternedString;
 use itertools::Itertools;
-use models::GatewayId;
+use crate::GatewayId;
 use patch_db::Dump;
 use patch_db::json_ptr::{JsonPointer, ROOT};
 use rpc_toolkit::yajrc::RpcError;