consolidate crates

core/Cargo.toml

@@ -1,3 +1,3 @@
 [workspace]
 
-members = ["helpers", "models", "startos"]
+members = ["startos"]

core/build-cli.sh

@@ -69,7 +69,7 @@ fi
 
 echo "FEATURES=\"$FEATURES\""
 echo "RUSTFLAGS=\"$RUSTFLAGS\""
-rust-zig-builder cargo zigbuild --manifest-path=./core/Cargo.toml $BUILD_FLAGS --no-default-features --features=docker,$FEATURES --locked --bin start-cli --target=$TARGET
+rust-zig-builder cargo zigbuild --manifest-path=./core/Cargo.toml $BUILD_FLAGS --features=$FEATURES --locked --bin start-cli --target=$TARGET
 if [ "$(ls -nd "core/target/$TARGET/$PROFILE/start-cli" | awk '{ print $3 }')" != "$UID" ]; then
   rust-zig-builder sh -c "cd core && chown -R $UID:$UID target && chown -R $UID:$UID  /usr/local/cargo"
 fi

core/helpers/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "helpers"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-color-eyre = "0.6.2"
-futures = "0.3.28"
-lazy_async_pool = "0.3.3"
-models = { path = "../models" }
-pin-project = "1.1.3"
-rpc-toolkit = { git = "https://github.com/Start9Labs/rpc-toolkit.git", branch = "master" }
-serde = { version = "1.0", features = ["derive", "rc"] }
-serde_json = "1.0"
-tokio = { version = "1", features = ["full"] }
-tokio-stream = { version = "0.1.14", features = ["io-util", "sync"] }
-tracing = "0.1.39"

core/helpers/src/byte_replacement_reader.rs

@@ -1,31 +0,0 @@
-use std::task::Poll;
-
-use tokio::io::{AsyncRead, ReadBuf};
-
-#[pin_project::pin_project]
-pub struct ByteReplacementReader<R> {
-    pub replace: u8,
-    pub with: u8,
-    #[pin]
-    pub inner: R,
-}
-impl<R: AsyncRead> AsyncRead for ByteReplacementReader<R> {
-    fn poll_read(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> std::task::Poll<std::io::Result<()>> {
-        let this = self.project();
-        match this.inner.poll_read(cx, buf) {
-            Poll::Ready(Ok(())) => {
-                for idx in 0..buf.filled().len() {
-                    if buf.filled()[idx] == *this.replace {
-                        buf.filled_mut()[idx] = *this.with;
-                    }
-                }
-                Poll::Ready(Ok(()))
-            }
-            a => a,
-        }
-    }
-}

core/helpers/src/lib.rs

@@ -1,262 +0,0 @@
-use std::future::Future;
-use std::ops::{Deref, DerefMut};
-use std::path::{Path, PathBuf};
-use std::time::Duration;
-
-use color_eyre::eyre::{eyre, Context, Error};
-use futures::future::BoxFuture;
-use futures::FutureExt;
-use models::ResultExt;
-use tokio::fs::File;
-use tokio::sync::oneshot;
-use tokio::task::{JoinError, JoinHandle, LocalSet};
-
-mod byte_replacement_reader;
-mod rsync;
-mod script_dir;
-pub use byte_replacement_reader::*;
-pub use rsync::*;
-pub use script_dir::*;
-
-pub fn const_true() -> bool {
-    true
-}
-
-pub fn to_tmp_path(path: impl AsRef<Path>) -> Result<PathBuf, Error> {
-    let path = path.as_ref();
-    if let (Some(parent), Some(file_name)) =
-        (path.parent(), path.file_name().and_then(|f| f.to_str()))
-    {
-        Ok(parent.join(format!(".{}.tmp", file_name)))
-    } else {
-        Err(eyre!("invalid path: {}", path.display()))
-    }
-}
-
-pub async fn canonicalize(
-    path: impl AsRef<Path> + Send + Sync,
-    create_parent: bool,
-) -> Result<PathBuf, Error> {
-    fn create_canonical_folder<'a>(
-        path: impl AsRef<Path> + Send + Sync + 'a,
-    ) -> BoxFuture<'a, Result<PathBuf, Error>> {
-        async move {
-            let path = canonicalize(path, true).await?;
-            tokio::fs::create_dir(&path)
-                .await
-                .with_context(|| path.display().to_string())?;
-            Ok(path)
-        }
-        .boxed()
-    }
-    let path = path.as_ref();
-    if tokio::fs::metadata(path).await.is_err() {
-        let parent = path.parent().unwrap_or(Path::new("."));
-        if let Some(file_name) = path.file_name() {
-            if create_parent && tokio::fs::metadata(parent).await.is_err() {
-                return Ok(create_canonical_folder(parent).await?.join(file_name));
-            } else {
-                return Ok(tokio::fs::canonicalize(parent)
-                    .await
-                    .with_context(|| parent.display().to_string())?
-                    .join(file_name));
-            }
-        }
-    }
-    tokio::fs::canonicalize(&path)
-        .await
-        .with_context(|| path.display().to_string())
-}
-
-#[pin_project::pin_project(PinnedDrop)]
-pub struct NonDetachingJoinHandle<T>(#[pin] JoinHandle<T>);
-impl<T> NonDetachingJoinHandle<T> {
-    pub async fn wait_for_abort(self) -> Result<T, JoinError> {
-        self.abort();
-        self.await
-    }
-}
-impl<T> From<JoinHandle<T>> for NonDetachingJoinHandle<T> {
-    fn from(t: JoinHandle<T>) -> Self {
-        NonDetachingJoinHandle(t)
-    }
-}
-
-impl<T> Deref for NonDetachingJoinHandle<T> {
-    type Target = JoinHandle<T>;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-impl<T> DerefMut for NonDetachingJoinHandle<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-#[pin_project::pinned_drop]
-impl<T> PinnedDrop for NonDetachingJoinHandle<T> {
-    fn drop(self: std::pin::Pin<&mut Self>) {
-        let this = self.project();
-        this.0.into_ref().get_ref().abort()
-    }
-}
-impl<T> Future for NonDetachingJoinHandle<T> {
-    type Output = Result<T, JoinError>;
-    fn poll(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Self::Output> {
-        let this = self.project();
-        this.0.poll(cx)
-    }
-}
-
-pub struct AtomicFile {
-    tmp_path: PathBuf,
-    path: PathBuf,
-    file: Option<File>,
-}
-impl AtomicFile {
-    pub async fn new(
-        path: impl AsRef<Path> + Send + Sync,
-        tmp_path: Option<impl AsRef<Path> + Send + Sync>,
-    ) -> Result<Self, Error> {
-        let path = canonicalize(&path, true).await?;
-        let tmp_path = if let Some(tmp_path) = tmp_path {
-            canonicalize(&tmp_path, true).await?
-        } else {
-            to_tmp_path(&path)?
-        };
-        let file = File::create(&tmp_path)
-            .await
-            .with_context(|| tmp_path.display().to_string())?;
-        Ok(Self {
-            tmp_path,
-            path,
-            file: Some(file),
-        })
-    }
-
-    pub async fn rollback(mut self) -> Result<(), Error> {
-        drop(self.file.take());
-        tokio::fs::remove_file(&self.tmp_path)
-            .await
-            .with_context(|| format!("rm {}", self.tmp_path.display()))?;
-        Ok(())
-    }
-
-    pub async fn save(mut self) -> Result<(), Error> {
-        use tokio::io::AsyncWriteExt;
-        if let Some(file) = self.file.as_mut() {
-            file.flush().await?;
-            file.shutdown().await?;
-            file.sync_all().await?;
-        }
-        drop(self.file.take());
-        tokio::fs::rename(&self.tmp_path, &self.path)
-            .await
-            .with_context(|| {
-                format!("mv {} -> {}", self.tmp_path.display(), self.path.display())
-            })?;
-        Ok(())
-    }
-}
-impl std::ops::Deref for AtomicFile {
-    type Target = File;
-    fn deref(&self) -> &Self::Target {
-        self.file.as_ref().unwrap()
-    }
-}
-impl std::ops::DerefMut for AtomicFile {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.file.as_mut().unwrap()
-    }
-}
-impl Drop for AtomicFile {
-    fn drop(&mut self) {
-        if let Some(file) = self.file.take() {
-            drop(file);
-            let path = std::mem::take(&mut self.tmp_path);
-            tokio::spawn(async move { tokio::fs::remove_file(path).await.log_err() });
-        }
-    }
-}
-
-pub struct TimedResource<T: 'static + Send> {
-    handle: NonDetachingJoinHandle<Option<T>>,
-    ready: oneshot::Sender<()>,
-}
-impl<T: 'static + Send> TimedResource<T> {
-    pub fn new(resource: T, timer: Duration) -> Self {
-        let (send, recv) = oneshot::channel();
-        let handle = tokio::spawn(async move {
-            tokio::select! {
-                _ = tokio::time::sleep(timer) => {
-                    drop(resource);
-                    None
-                },
-                _ = recv => Some(resource),
-            }
-        });
-        Self {
-            handle: handle.into(),
-            ready: send,
-        }
-    }
-
-    pub fn new_with_destructor<
-        Fn: FnOnce(T) -> Fut + Send + 'static,
-        Fut: Future<Output = ()> + Send,
-    >(
-        resource: T,
-        timer: Duration,
-        destructor: Fn,
-    ) -> Self {
-        let (send, recv) = oneshot::channel();
-        let handle = tokio::spawn(async move {
-            tokio::select! {
-                _ = tokio::time::sleep(timer) => {
-                    destructor(resource).await;
-                    None
-                },
-                _ = recv => Some(resource),
-            }
-        });
-        Self {
-            handle: handle.into(),
-            ready: send,
-        }
-    }
-
-    pub async fn get(self) -> Option<T> {
-        let _ = self.ready.send(());
-        self.handle.await.unwrap()
-    }
-
-    pub fn is_timed_out(&self) -> bool {
-        self.ready.is_closed()
-    }
-}
-
-pub async fn spawn_local<
-    T: 'static + Send,
-    F: FnOnce() -> Fut + Send + 'static,
-    Fut: Future<Output = T> + 'static,
->(
-    fut: F,
-) -> NonDetachingJoinHandle<T> {
-    let (send, recv) = tokio::sync::oneshot::channel();
-    std::thread::spawn(move || {
-        tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .unwrap()
-            .block_on(async move {
-                let set = LocalSet::new();
-                send.send(set.spawn_local(fut()).into())
-                    .unwrap_or_else(|_| unreachable!());
-                set.await
-            })
-    });
-    recv.await.unwrap()
-}

core/helpers/src/os_api.rs

@@ -1,82 +0,0 @@
-use std::sync::Arc;
-
-use color_eyre::Report;
-use models::InterfaceId;
-use models::PackageId;
-use serde_json::Value;
-use tokio::sync::mpsc;
-
-pub struct RuntimeDropped;
-
-pub struct Callback {
-    id: Arc<String>,
-    sender: mpsc::UnboundedSender<(Arc<String>, Vec<Value>)>,
-}
-impl Callback {
-    pub fn new(id: String, sender: mpsc::UnboundedSender<(Arc<String>, Vec<Value>)>) -> Self {
-        Self {
-            id: Arc::new(id),
-            sender,
-        }
-    }
-    pub fn is_listening(&self) -> bool {
-        self.sender.is_closed()
-    }
-    pub fn call(&self, args: Vec<Value>) -> Result<(), RuntimeDropped> {
-        self.sender
-            .send((self.id.clone(), args))
-            .map_err(|_| RuntimeDropped)
-    }
-}
-
-#[derive(serde::Deserialize, serde::Serialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct AddressSchemaOnion {
-    pub id: InterfaceId,
-    pub external_port: u16,
-}
-#[derive(serde::Deserialize, serde::Serialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct AddressSchemaLocal {
-    pub id: InterfaceId,
-    pub external_port: u16,
-}
-
-#[derive(serde::Deserialize, serde::Serialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct Address(pub String);
-#[derive(serde::Deserialize, serde::Serialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct Domain;
-#[derive(serde::Deserialize, serde::Serialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct Name;
-
-#[async_trait::async_trait]
-#[allow(unused_variables)]
-pub trait OsApi: Send + Sync + 'static {
-    async fn get_service_config(
-        &self,
-        id: PackageId,
-        path: &str,
-        callback: Option<Callback>,
-    ) -> Result<Vec<Value>, Report>;
-
-    async fn bind_local(
-        &self,
-        internal_port: u16,
-        address_schema: AddressSchemaLocal,
-    ) -> Result<Address, Report>;
-    async fn bind_onion(
-        &self,
-        internal_port: u16,
-        address_schema: AddressSchemaOnion,
-    ) -> Result<Address, Report>;
-
-    async fn unbind_local(&self, id: InterfaceId, external: u16) -> Result<(), Report>;
-    async fn unbind_onion(&self, id: InterfaceId, external: u16) -> Result<(), Report>;
-    fn set_started(&self) -> Result<(), Report>;
-    async fn restart(&self) -> Result<(), Report>;
-    async fn start(&self) -> Result<(), Report>;
-    async fn stop(&self) -> Result<(), Report>;
-}

core/helpers/src/script_dir.rs

@@ -1,17 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use models::{PackageId, VersionString};
-
-pub const PKG_SCRIPT_DIR: &str = "package-data/scripts";
-
-pub fn script_dir<P: AsRef<Path>>(
-    datadir: P,
-    pkg_id: &PackageId,
-    version: &VersionString,
-) -> PathBuf {
-    datadir
-        .as_ref()
-        .join(&*PKG_SCRIPT_DIR)
-        .join(pkg_id)
-        .join(version.as_str())
-}

core/models/Cargo.toml

@@ -1,47 +0,0 @@
-[package]
-edition = "2021"
-name = "models"
-version = "0.1.0"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[features]
-arti = ["arti-client"]
-
-[dependencies]
-arti-client = { version = "0.33", default-features = false, git = "https://github.com/Start9Labs/arti.git", branch = "patch/disable-exit", optional = true }
-axum = "0.8.4"
-base64 = "0.22.1"
-color-eyre = "0.6.2"
-ed25519-dalek = { version = "2.0.0", features = ["serde"] }
-exver = { version = "0.2.0", git = "https://github.com/Start9Labs/exver-rs.git", features = [
-  "serde",
-] }
-gpt = "4.1.0"
-ipnet = "2.8.0"
-lazy_static = "1.4"
-lettre = { version = "0.11", default-features = false }
-mbrman = "0.6.0"
-miette = "7.6.0"
-num_enum = "0.7.1"
-openssl = { version = "0.10.57", features = ["vendored"] }
-patch-db = { version = "*", path = "../../patch-db/patch-db", features = [
-  "trace",
-] }
-rand = "0.9.1"
-regex = "1.10.2"
-reqwest = "0.12"
-rpc-toolkit = { git = "https://github.com/Start9Labs/rpc-toolkit.git", branch = "master" }
-rustls = "0.23"
-serde = { version = "1.0", features = ["derive", "rc"] }
-serde_json = "1.0"
-ssh-key = "0.6.2"
-hyper = "1.8.1"
-thiserror = "2.0"
-tokio = { version = "1", features = ["full"] }
-torut = "0.2.1"
-tracing = "0.1.39"
-ts-rs = "9"
-typeid = "1"
-yasi = { version = "0.1.6", features = ["serde", "ts-rs"] }
-zbus = "5"

core/models/bindings/ServiceInterfaceId.ts

@@ -1,3 +0,0 @@
-// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
-
-export type ServiceInterfaceId = string;

core/models/src/errors.rs

@@ -1,675 +0,0 @@
-use std::fmt::{Debug, Display};
-
-use axum::http::uri::InvalidUri;
-use axum::http::StatusCode;
-use color_eyre::eyre::eyre;
-use num_enum::TryFromPrimitive;
-use patch_db::Revision;
-use rpc_toolkit::reqwest;
-use rpc_toolkit::yajrc::{
-    RpcError, INVALID_PARAMS_ERROR, INVALID_REQUEST_ERROR, METHOD_NOT_FOUND_ERROR, PARSE_ERROR,
-};
-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 = (typeid::of::<E>() == 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>);
-impl ErrorCollection {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn handle<T, E: Into<Error>>(&mut self, result: Result<T, E>) -> Option<T> {
-        match result {
-            Ok(a) => Some(a),
-            Err(e) => {
-                self.0.push(e.into());
-                None
-            }
-        }
-    }
-
-    pub fn into_result(self) -> Result<(), Error> {
-        if self.0.is_empty() {
-            Ok(())
-        } else {
-            Err(Error::new(eyre!("{}", self), ErrorKind::MultipleErrors))
-        }
-    }
-}
-impl From<ErrorCollection> for Result<(), Error> {
-    fn from(e: ErrorCollection) -> Self {
-        e.into_result()
-    }
-}
-impl<T, E: Into<Error>> Extend<Result<T, E>> for ErrorCollection {
-    fn extend<I: IntoIterator<Item = Result<T, E>>>(&mut self, iter: I) {
-        for item in iter {
-            self.handle(item);
-        }
-    }
-}
-impl std::fmt::Display for ErrorCollection {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        for (idx, e) in self.0.iter().enumerate() {
-            if idx > 0 {
-                write!(f, "; ")?;
-            }
-            write!(f, "{}", e)?;
-        }
-        Ok(())
-    }
-}
-
-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 = (typeid::of::<E>() == 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) {
-            return Err(Error::new(color_eyre::eyre::eyre!($fmt, $($arg, )*), $c));
-        }
-    };
-}

core/models/src/lib.rs

@@ -1,15 +0,0 @@
-mod clap;
-mod data_url;
-mod errors;
-mod id;
-mod mime;
-mod procedure_name;
-mod version;
-
-pub use clap::*;
-pub use data_url::*;
-pub use errors::*;
-pub use id::*;
-pub use mime::*;
-pub use procedure_name::*;
-pub use version::*;

core/startos/Cargo.toml

@@ -44,7 +44,6 @@ path = "src/main/tunnelbox.rs"
 [features]
 arti = [
   "arti-client",
-  "models/arti",
   "safelog",
   "tor-cell",
   "tor-hscrypto",
@@ -55,9 +54,8 @@ arti = [
   "tor-rtcompat",
 ]
 console = ["console-subscriber", "tokio/tracing"]
-default = ["procfs", "pty-process"]
+default = []
-dev = ["backtrace-on-stack-overflow"]
+dev = []
-docker = []
 test = []
 unstable = ["backtrace-on-stack-overflow"]
 
@@ -86,9 +84,7 @@ async-compression = { version = "0.4.32", features = [
 async-stream = "0.3.5"
 async-trait = "0.1.74"
 axum = { version = "0.8.4", features = ["ws", "http2"] }
-axum-server = "0.8.0"
 backtrace-on-stack-overflow = { version = "0.3.0", optional = true }
-barrage = "0.2.3"
 base32 = "0.5.0"
 base64 = "0.22.1"
 base64ct = "1.6.0"
@@ -98,16 +94,16 @@ bytes = "1"
 chrono = { version = "0.4.31", features = ["serde"] }
 clap = { version = "4.4.12", features = ["string"] }
 color-eyre = "0.6.2"
-console = "0.15.7"
+console = "0.16.2"
-console-subscriber = { version = "0.4.1", optional = true }
+console-subscriber = { version = "0.5.0", optional = true }
 const_format = "0.2.34"
 cookie = "0.18.0"
-cookie_store = "0.21.0"
+cookie_store = "0.22.0"
 curve25519-dalek = "4.1.3"
 der = { version = "0.7.9", features = ["derive", "pem"] }
 digest = "0.10.7"
 divrem = "1.0.0"
-dns-lookup = "2.1.0"
+dns-lookup = "3.0.1"
 ed25519 = { version = "2.2.3", features = ["alloc", "pem", "pkcs8"] }
 ed25519-dalek = { version = "2.2.0", features = [
   "digest",
@@ -125,7 +121,6 @@ fd-lock-rs = "0.1.4"
 form_urlencoded = "1.2.1"
 futures = "0.3.28"
 gpt = "4.1.0"
-helpers = { path = "../helpers" }
 hex = "0.4.3"
 hickory-client = "0.25.2"
 hickory-server = "0.25.2"
@@ -151,7 +146,7 @@ imbl = { version = "6", features = ["serde", "small-chunks"] }
 imbl-value = { version = "0.4.3", features = ["ts-rs"] }
 include_dir = { version = "0.7.3", features = ["metadata"] }
 indexmap = { version = "2.0.2", features = ["serde"] }
-indicatif = { version = "0.17.7", features = ["tokio"] }
+indicatif = { version = "0.18.3", features = ["tokio"] }
 inotify = "0.11.0"
 integer-encoding = { version = "4.0.0", features = ["tokio_async"] }
 ipnet = { version = "2.8.0", features = ["serde"] }
@@ -178,7 +173,6 @@ log = "0.4.20"
 mbrman = "0.6.0"
 miette = { version = "7.6.0", features = ["fancy"] }
 mio = "1"
-models = { version = "*", path = "../models" }
 new_mime_guess = "4"
 nix = { version = "0.30.1", features = [
   "fs",
@@ -204,10 +198,8 @@ pbkdf2 = "0.12.2"
 pin-project = "1.1.3"
 pkcs8 = { version = "0.10.2", features = ["std"] }
 prettytable-rs = "0.10.0"
-procfs = { version = "0.17.0", optional = true }
 proptest = "1.3.1"
-proptest-derive = "0.5.0"
+proptest-derive = "0.7.0"
-pty-process = { version = "0.5.1", optional = true }
 qrcode = "0.14.1"
 r3bl_tui = "0.7.6"
 rand = "0.9.2"
@@ -218,24 +210,20 @@ reqwest = { version = "0.12.25", features = [
   "stream",
   "http2",
 ] }
-reqwest_cookie_store = "0.8.0"
+reqwest_cookie_store = "0.9.0"
 rpassword = "7.2.0"
 rpc-toolkit = { git = "https://github.com/Start9Labs/rpc-toolkit.git", rev = "068db90" }
-rust-argon2 = "2.0.0"
+rust-argon2 = "3.0.0"
 safelog = { version = "0.4.8", git = "https://github.com/Start9Labs/arti.git", branch = "patch/disable-exit", optional = true }
 semver = { version = "1.0.20", features = ["serde"] }
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_cbor = { package = "ciborium", version = "0.2.1" }
 serde_json = "1.0"
-serde_toml = { package = "toml", version = "0.8.2" }
+serde_toml = { package = "toml", version = "0.9.9+spec-1.0.0" }
-serde_urlencoded = "0.7"
-serde_with = { version = "3.4.0", features = ["json", "macros"] }
 serde_yaml = { package = "serde_yml", version = "0.0.12" }
 sha-crypt = "0.5.0"
 sha2 = "0.10.2"
-shell-words = "1"
 signal-hook = "0.3.17"
-simple-logging = "2.0.2"
 socket2 = { version = "0.6.0", features = ["all"] }
 socks5-impl = { version = "0.7.2", features = ["client", "server"] }
 sqlx = { version = "0.8.6", features = [
@@ -274,19 +262,19 @@ torut = "0.2.1"
 tower-service = "0.3.3"
 tracing = "0.1.39"
 tracing-error = "0.2.0"
-tracing-futures = "0.2.5"
 tracing-journald = "0.3.0"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 ts-rs = "9.0.1"
-typed-builder = "0.21.0"
+typed-builder = "0.23.2"
-unix-named-pipe = "0.2.0"
 url = { version = "2.4.1", features = ["serde"] }
-urlencoding = "2.1.3"
 uuid = { version = "1.4.1", features = ["v4"] }
 visit-rs = "0.1.1"
 x25519-dalek = { version = "2.0.1", features = ["static_secrets"] }
 zbus = "5.1.1"
-zeroize = "1.6.0"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+procfs = "0.18.0"
+pty-process = "0.5.1"
 
 [profile.test]
 opt-level = 3

core/startos/src/action.rs

@@ -1,8 +1,8 @@
 use std::fmt;
 
 use clap::{CommandFactory, FromArgMatches, Parser};
-pub use models::ActionId;
+pub use crate::ActionId;
-use models::{PackageId, ReplayId};
+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>)
+        AtomicFile::new(backup_guard.path().join("os-backup.json"), None::<PathBuf>).await?;
-            .await
-            .with_kind(ErrorKind::Filesystem)?;
     os_backup_file
         .write_all(&IoFormat::Json.to_vec(&OsBackup {
             account: ctx.account.peek(|a| a.clone()),
             ui,
         })?)
         .await?;
-    os_backup_file
+    os_backup_file.save().await?;
-        .save()
-        .await
-        .with_kind(ErrorKind::Filesystem)?;
 
     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 crate::PackageId;
-use models::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>)
+        let mut file = AtomicFile::new(&metadata_path, None::<PathBuf>).await?;
-            .await
-            .with_kind(ErrorKind::Filesystem)?;
         file.write_all(&IoFormat::Json.to_vec(&self.metadata)?)
             .await?;
-        file.save().await.with_kind(ErrorKind::Filesystem)?;
+        file.save().await?;
-        let mut file = AtomicFile::new(&self.unencrypted_metadata_path, None::<PathBuf>)
+        let mut file = AtomicFile::new(&self.unencrypted_metadata_path, None::<PathBuf>).await?;
-            .await
-            .with_kind(ErrorKind::Filesystem)?;
         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> {
+    pub fn into_result(self) -> Result<(), Error> {
-        if self.0.len() <= 1 {
+        if self.0.is_empty() {
-            if let Some(err) = self.0.pop() {
+            Ok(())
-                Err(err)
-            } else {
-                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/gateway.rs

@@ -4,7 +4,7 @@ use std::str::FromStr;
 
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
-use yasi::InternedString;
+use imbl_value::InternedString;
 
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
 #[ts(type = "string")]

core/startos/src/id/host.rs

@@ -3,7 +3,7 @@ use std::str::FromStr;
 
 use serde::{Deserialize, Deserializer, Serialize};
 use ts_rs::TS;
-use yasi::InternedString;
+use imbl_value::InternedString;
 
 use crate::{Id, InvalidId};
 

core/startos/src/id/image.rs

@@ -5,7 +5,8 @@ use std::str::FromStr;
 use serde::{Deserialize, Deserializer, Serialize};
 use ts_rs::TS;
 
-use crate::{Id, InvalidId, PackageId, VersionString};
+use crate::util::VersionString;
+use crate::{Id, InvalidId, PackageId};
 
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
 #[ts(type = "string")]

core/startos/src/id/invalid_id.rs

@@ -1,4 +1,4 @@
-use yasi::InternedString;
+use imbl_value::InternedString;
 
 #[derive(Debug, thiserror::Error)]
 #[error("Invalid ID: {0}")]

core/startos/src/id/mod.rs

@@ -3,7 +3,7 @@ use std::str::FromStr;
 
 use regex::Regex;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use yasi::InternedString;
+use imbl_value::InternedString;
 
 mod action;
 mod gateway;

core/startos/src/id/package.rs

@@ -4,7 +4,7 @@ use std::str::FromStr;
 
 use serde::{Deserialize, Serialize, Serializer};
 use ts_rs::TS;
-use yasi::InternedString;
+use imbl_value::InternedString;
 
 use crate::{Id, InvalidId, SYSTEM_ID};
 

core/startos/src/id/replay.rs

@@ -4,7 +4,7 @@ use std::str::FromStr;
 
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
-use yasi::InternedString;
+use imbl_value::InternedString;
 
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
 #[ts(type = "string")]

core/startos/src/id/service_interface.rs

@@ -5,7 +5,8 @@ use rpc_toolkit::clap::builder::ValueParserFactory;
 use serde::{Deserialize, Deserializer, Serialize};
 use ts_rs::TS;
 
-use crate::{FromStrParser, Id};
+use crate::util::FromStrParser;
+use crate::Id;
 
 #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, TS)]
 #[ts(export, type = "string")]

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}"));
+    let tmp_docker = Path::new(PACKAGE_DATA).join("tmp").join(*CONTAINER_TOOL);
-    crate::disk::mount::util::bind(&tmp_docker, CONTAINER_DATADIR, false).await?;
+    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>)
+        let mut file = AtomicFile::new(&download, None::<&Path>).await?;
-            .await
-            .with_kind(ErrorKind::Filesystem)?;
 
         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;
+pub use crate::PackageId;
-use models::{ActionId, HealthCheckId, ImageId, VolumeId};
+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;
+pub use crate::PackageId;
-use models::{ImageId, VolumeId, mime};
+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 static PREFER_DOCKER: OnceLock<bool> = OnceLock::new();
-pub const CONTAINER_TOOL: &str = "podman";
-#[cfg(feature = "docker")]
-pub const CONTAINER_TOOL: &str = "docker";
 
-#[cfg(feature = "docker")]
+pub static CONTAINER_TOOL: LazyLock<&'static str> = LazyLock::new(|| {
-pub const CONTAINER_DATADIR: &str = "/var/lib/docker";
+    if *PREFER_DOCKER.get_or_init(|| false) {
-#[cfg(not(feature = "docker"))]
+        if std::process::Command::new("which")
-pub const CONTAINER_DATADIR: &str = "/var/lib/containers";
+            .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);
+                    let mut command = Command::new(*CONTAINER_TOOL);
-                    if CONTAINER_TOOL == "docker" {
+                    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),