Add identity and repo creation flow — radicle-desktop

Remove AuthenticationError component
Remove authenticate e2e test
Remove replacing standard html checkboxes with custom ones
Remove @public path alias
Reduce tauri log verbosity
- Instead of logging to stdout everything, just do so until Info level

 ]
 [[package]]
 name = "getrandom"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
 dependencies = [
  "cfg-if",
  "libc",
  "wasi 0.13.3+wasi-0.2.2",
  "windows-targets 0.52.6",
 ]
 [[package]]
 name = "ghash"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"

  "radicle-types",
  "serde",
  "serde_json",
  "ssh-key",
  "tauri",
  "tauri-build",
  "tauri-plugin-clipboard-manager",

  "thiserror 1.0.69",
  "tokio",
  "ts-rs",
  "zeroize",
 ]
 [[package]]

  "serde",
  "serde_json",
  "sqlite",
  "ssh-key",
  "tauri-plugin-clipboard-manager",
  "tauri-plugin-fs",
  "tempfile",
  "thiserror 1.0.69",
  "tree-sitter-bash",

 [[package]]
 name = "tar"
 version = "0.4.43"
 version = "0.4.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c65998313f8e17d0d553d28f91a0df93e4dbbbf770279c7bc21ca0f09ea1a1f6"
 checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
 dependencies = [
  "filetime",
  "libc",

 [[package]]
 name = "tempfile"
 version = "3.14.0"
 version = "3.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c"
 checksum = "22e5a0acb1f3f55f65cc4a866c361b2fb2a0ff6366785ae6fbb5f85df07ba230"
 dependencies = [
  "cfg-if",
  "fastrand",
  "getrandom 0.3.1",
  "once_cell",
  "rustix",
  "windows-sys 0.59.0",

 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 [[package]]
 name = "wasi"
 version = "0.13.3+wasi-0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
 dependencies = [
  "wit-bindgen-rt",
 ]
 [[package]]
 name = "wasm-bindgen"
 version = "0.2.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 ]
 [[package]]
 name = "wit-bindgen-rt"
 version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
 dependencies = [
  "bitflags 2.6.0",
 ]
 [[package]]
 name = "write16"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 thiserror = { version = "1.0.64" }
 tokio = { version = "1.40.0", features = ["time"] }
 ts-rs = { version = "10.0.0", features = ["serde-json-impl", "no-serde-warnings"] }
 ssh-key = { version = "0.6.3" }
 zeroize = { version = "1.8.1", features = ["serde"] }
 [features]
 # by default Tauri runs in production mode

 pub mod cob;
 pub mod diff;
 pub mod inbox;
 pub mod init;
 pub mod profile;
 pub mod repo;
 pub mod startup;
 pub mod thread;

 use std::str::FromStr;
 use radicle::crypto::ssh::{self, Passphrase};
 use radicle::node::Alias;
 use radicle::profile::env;
 use radicle_types::error::Error;
 use radicle_types::traits::auth::Auth;
 use crate::AppState;
 #[tauri::command]
 pub(crate) fn authenticate(ctx: tauri::State<AppState>) -> Result<(), Error> {
     ctx.authenticate().map_err(Error::from)
 pub fn authenticate(
     ctx: tauri::State<AppState>,
     passphrase: Option<Passphrase>,
 ) -> Result<(), Error> {
     let profile = &ctx.profile;
     if !profile.keystore.is_encrypted()? {
         return Ok(());
     }
     match ssh::agent::Agent::connect() {
         Ok(mut agent) => {
             if agent.request_identities()?.contains(&profile.public_key) {
                 return Ok(());
             }
             match passphrase {
                 Some(passphrase) => {
                     profile.keystore.secret_key(Some(passphrase.clone()))?;
                     register(&mut agent, profile, passphrase)
                 }
                 None => Err(Error::Crypto(
                     radicle::crypto::ssh::keystore::Error::PassphraseMissing,
                 )),
             }
         }
         Err(e) if e.is_not_running() => Err(Error::AgentNotRunning)?,
         Err(e) => Err(e)?,
     }
 }
 #[tauri::command]
 pub(crate) fn init(alias: String, passphrase: Passphrase) -> Result<(), Error> {
     let home = radicle::profile::home()?;
     let alias = Alias::from_str(&alias)?;
     if passphrase.is_empty() {
         return Err(Error::Crypto(
             radicle::crypto::ssh::keystore::Error::PassphraseMissing,
         ));
     }
     let profile = radicle::Profile::init(home, alias, Some(passphrase.clone()), env::seed())?;
     match ssh::agent::Agent::connect() {
         Ok(mut agent) => register(&mut agent, &profile, passphrase.clone())?,
         Err(e) if e.is_not_running() => return Err(Error::AgentNotRunning),
         Err(e) => Err(e)?,
     }
     Ok(())
 }
 pub fn register(
     agent: &mut ssh::agent::Agent,
     profile: &radicle::Profile,
     passphrase: ssh::Passphrase,
 ) -> Result<(), Error> {
     let secret = profile
         .keystore
         .secret_key(Some(passphrase))
         .map_err(|e| {
             if e.is_crypto_err() {
                 Error::Crypto(radicle::crypto::ssh::keystore::Error::Ssh(
                     ssh_key::Error::Crypto,
                 ))
             } else {
                 e.into()
             }
         })?
         .ok_or(Error::Crypto(radicle::crypto::ssh::keystore::Error::Ssh(
             ssh_key::Error::Crypto,
         )))?;
     agent.register(&secret)?;
     Ok(())
 }

 use std::path::PathBuf;
 use anyhow::{Context, Result};
 use radicle::git;
 use radicle::identity;
 use radicle_types as types;

     let content = app_handle
         .clipboard()
         .read_image()
         .map(|i| i.rgba().to_vec())
         .context("Not able to read the image from the clipboard")?;
         .map(|i| i.rgba().to_vec())?;
     ctx.save_embed_by_bytes(rid, name, content)
 }

     oid: git::Oid,
     name: String,
 ) -> Result<(), Error> {
     let path = app_handle
     let Some(path) = app_handle
         .dialog()
         .file()
         .set_file_name(name)
         .blocking_save_file()
         .context("no path defined")?;
     let path = path
         .into_path()
         .context("Not able to convert into PathBuf")?;
     else {
         return Err(Error::SaveEmbedError);
     };
     let path = path.into_path()?;
     ctx.save_embed_to_disk(rid, oid, path)
 }

 use std::collections::BTreeMap;
 use radicle::cob::cache::COBS_DB_FILE;
 use radicle::identity::RepoId;
 use radicle::node::{Handle, Node, NOTIFICATIONS_DB_FILE};
 use radicle::storage::ReadStorage;
 use tauri::{AppHandle, Emitter, Manager};
 use radicle_types::config::Config;
 use radicle_types::error::Error;
 use radicle_types::traits::Profile;
 use radicle_types::{domain, AppState};
 #[tauri::command]
 pub(crate) fn startup(app: AppHandle) -> Result<Config, Error> {
     let profile = radicle::Profile::load()?;
     let inbox_db = radicle_types::outbound::sqlite::Sqlite::reader(
         profile.node().join(NOTIFICATIONS_DB_FILE),
     )?;
     let cob_db =
         radicle_types::outbound::sqlite::Sqlite::reader(profile.cobs().join(COBS_DB_FILE))?;
     let inbox_service = domain::inbox::service::Service::new(inbox_db);
     let patch_service = domain::patch::service::Service::new(cob_db);
     app.manage(inbox_service);
     app.manage(patch_service);
     let state = AppState { profile };
     app.manage(state.clone());
     Ok(state.config())
 }
 #[tauri::command]
 pub(crate) fn node_status_events(app: AppHandle, ctx: tauri::State<AppState>) -> Result<(), Error> {
     let app_handle = app.clone();
     let node = Node::new(ctx.profile.socket());
     let node_status = node.clone();
     tauri::async_runtime::spawn(async move {
         loop {
             let _ = app_handle.emit("node_running", node_status.is_running());
             tokio::time::sleep(std::time::Duration::from_secs(2)).await;
         }
     });
     Ok(())
 }
 #[tauri::command]
 pub(crate) fn repo_sync_events(app: AppHandle, ctx: tauri::State<AppState>) -> Result<(), Error> {
     let profile = &ctx.profile;
     let repositories = profile.storage.repositories()?;
     let app_handle = app.clone();
     let public_key = profile.public_key;
     let node = Node::new(profile.socket());
     let mut node_seeds = node.clone();
     tauri::async_runtime::spawn(async move {
         loop {
             let mut sync_status =
                 BTreeMap::<RepoId, Option<radicle_types::cobs::repo::SyncStatus>>::new();
             for repo in &repositories {
                 if let Ok(seeds) = node_seeds.seeds(repo.rid).map(Into::<Vec<_>>::into) {
                     if let Some(status) =
                         seeds
                             .iter()
                             .find_map(|radicle::node::Seed { nid, sync, .. }| {
                                 (*nid == public_key).then_some(sync.clone())
                             })
                     {
                         sync_status.insert(repo.rid, status.map(Into::into));
                     } else {
                         // The local node wasn't found in the seed nodes table.
                         sync_status.insert(repo.rid, None);
                     }
                 }
             }
             let _ = app_handle.emit("sync_status", sync_status);
             tokio::time::sleep(std::time::Duration::from_secs(10)).await;
         }
     });
     Ok(())
 }
 #[tauri::command]
 pub(crate) fn node_events(app: AppHandle, ctx: tauri::State<AppState>) -> Result<(), Error> {
     let app_handle = app.clone();
     let node = Node::new(ctx.profile.socket());
     tauri::async_runtime::spawn(async move {
         loop {
             if node.is_running() {
                 log::debug!("node: spawned node event subscription.");
                 while let Ok(events) = node.subscribe(std::time::Duration::MAX) {
                     for event in events.into_iter().flatten() {
                         let _ = app_handle.emit("event", event);
                     }
                 }
                 log::debug!("node: event subscription loop has exited.");
             }
             tokio::time::sleep(std::time::Duration::from_secs(2)).await;
         }
     });
     Ok(())
 }

+	`// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.`
+
+	`export type ErrorWrapper = { code: string; message?: string };`

 use radicle::git;
 use radicle::identity::RepoId;
 use std::collections::BTreeSet;
 use std::str::FromStr;
 use radicle::git;
 use radicle::identity::project::ProjectName;
 use radicle::identity::{doc, Project, RepoId, Visibility};
 use radicle::rad::InitError;
 use radicle::storage::git::Repository;
 use radicle::storage::refs::branch_of;
 use radicle::storage::{SignRepository, WriteRepository};
 use radicle_types as types;
 use radicle_types::error::Error;
 use radicle_types::traits::repo::{Repo, Show};

 ) -> Result<Vec<types::repo::Commit>, Error> {
     ctx.list_commits(rid, base, head)
 }
 #[tauri::command]
 pub(crate) async fn create_repo(
     ctx: tauri::State<'_, AppState>,
     name: String,
     description: String,
 ) -> Result<(), Error> {
     let profile = &ctx.profile;
     let storage = &profile.storage;
     let signer = ctx.profile.signer()?;
     let config = radicle::git::raw::Config::open_default()?;
     // SAFETY: "master" is always a valid RefString
     let default_branch = git::RefString::try_from(
         config
             .get_string("init.defaultBranch")
             .unwrap_or("master".to_owned()),
     )
     .unwrap();
     let name = ProjectName::from_str(&name)?;
     if description.len() > doc::MAX_STRING_LENGTH {
         return Err(Error::ProjectError(
             radicle::identity::project::ProjectError::Description("Cannot exceed 255 characters."),
         ));
     }
     let visibility = Visibility::Private {
         allow: BTreeSet::default(),
     };
     let proj = Project::new(name, description, default_branch.clone()).map_err(|errs| {
         InitError::ProjectPayload(
             errs.into_iter()
                 .map(|err| err.to_string())
                 .collect::<Vec<_>>()
                 .join(", "),
         )
     })?;
     let doc = radicle::identity::Doc::initial(proj, profile.public_key.into(), visibility);
     let (project, identity) = Repository::init(&doc, &storage, &signer)?;
     let tree_id = {
         let mut index = project.backend.index()?;
         index.write_tree()
     }?;
     let sig = project.backend.signature()?;
     let tree = project.backend.find_tree(tree_id)?;
     project.set_remote_identity_root_to(signer.public_key(), identity)?;
     project.set_identity_head_to(identity)?;
     let base = project
         .backend
         .commit(Some("HEAD"), &sig, &sig, "Initial commit", &tree, &[])?;
     let ns_head = branch_of(&ctx.profile.public_key, &default_branch);
     project
         .backend
         .reference(ns_head.as_str(), base, false, "Created namespace ref")?;
     project.set_head()?;
     project.sign_refs(&signer)?;
     Ok(())
 }

 use radicle_types::AppState;
 use commands::{auth, cob, diff, inbox, init, profile, repo, thread};
 use commands::{auth, cob, diff, inbox, profile, repo, startup, thread};
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     #[cfg(debug_assertions)]
     let builder = tauri::Builder::default()
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_log::Builder::new().build());
         .plugin(
             tauri_plugin_log::Builder::new()
                 .level(log::LevelFilter::Info)
                 .build(),
         );
     #[cfg(not(debug_assertions))]
     let builder = tauri::Builder::default();

         .plugin(tauri_plugin_clipboard_manager::init())
         .plugin(tauri_plugin_window_state::Builder::default().build())
         .invoke_handler(tauri::generate_handler![
             init::startup,
             init::node_status_events,
             init::repo_sync_events,
             init::node_events,
             auth::authenticate,
             repo::repo_count,
             repo::list_repos,
             repo::repo_by_id,
             repo::diff_stats,
             repo::list_commits,
             diff::get_diff,
             inbox::list_notifications,
             inbox::count_notifications_by_repo,
             inbox::clear_notifications,
             auth::init,
             cob::get_embed,
             cob::save_embed_to_disk,
             cob::save_embed_by_path,
             cob::save_embed_by_clipboard,
             cob::save_embed_by_bytes,
             cob::issue::activity_by_issue,
             cob::issue::list_issues,
             cob::issue::issue_by_id,
             cob::issue::comment_threads_by_issue_id,
             cob::issue::create_issue,
             cob::issue::edit_issue,
             cob::issue::issue_by_id,
             cob::issue::list_issues,
             cob::patch::activity_by_patch,
             cob::patch::edit_patch,
             cob::patch::list_patches,
             cob::patch::patch_by_id,
             cob::patch::edit_patch,
             cob::patch::review_by_patch_and_revision_and_id,
             cob::patch::revisions_by_patch,
             cob::patch::revision_by_patch_and_id,
             cob::patch::revisions_by_patch,
             cob::save_embed_by_bytes,
             cob::save_embed_by_clipboard,
             cob::save_embed_by_path,
             cob::save_embed_to_disk,
             diff::get_diff,
             inbox::clear_notifications,
             inbox::count_notifications_by_repo,
             inbox::list_notifications,
             profile::alias,
             profile::config,
             repo::create_repo,
             repo::diff_stats,
             repo::list_commits,
             repo::list_repos,
             repo::repo_by_id,
             repo::repo_count,
             startup::startup,
             thread::create_issue_comment,
             thread::create_patch_comment,
             profile::config,
             profile::alias,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

 serde = { version = "1.0.210", features = ["derive"] }
 serde_json = { version = "1.0.132" }
 sqlite = { version = "0.32.0", features = ["bundled"] }
 ssh-key = { version = "0.6.3" }
 tauri-plugin-clipboard-manager = { version = "2.2.1" }
 tauri-plugin-fs = { version = "2.2.0" }
 tempfile = { version = "3.14.0" }
 thiserror = { version = "1.0.65" }
 tree-sitter-bash = { version = "0.23.3" }

 pub enum Error {
     /// Profile error.
     #[error(transparent)]
     Profile(#[from] radicle::profile::Error),
     ProfileError(#[from] radicle::profile::Error),
     /// Missing SSH Agent error.
     #[error("ssh agent not running")]
     AgentNotRunning,
     /// Embeds error.
     #[error("not able to save embed")]
     SaveEmbedError,
     /// Init Error error.
     #[error(transparent)]
     InitError(#[from] radicle::rad::InitError),
     /// Alias error.
     #[error(transparent)]
     AliasError(#[from] radicle::node::AliasError),
     /// Tauri Plugin Clipboard error.
     #[error(transparent)]
     TauriPluginClipboard(#[from] tauri_plugin_clipboard_manager::Error),
     /// Tauri Plugin Fs error.
     #[error(transparent)]
     TauriPluginFs(#[from] tauri_plugin_fs::Error),
     /// Project error.
     #[error(transparent)]
     ProjectError(#[from] radicle::identity::project::ProjectError),
     /// List notification error.
     #[error(transparent)]

     #[error(transparent)]
     CobStore(#[from] radicle::cob::store::Error),
     /// Anyhow error.
     #[error(transparent)]
     Anyhow(#[from] anyhow::Error),
     /// Io error.
     #[error(transparent)]
     Io(#[from] std::io::Error),

     #[error(transparent)]
     Node(#[from] radicle::node::Error),
     /// An error with a hint.
     #[error("{err} {hint}")]
     WithHint {
         err: anyhow::Error,
         hint: &'static str,
     },
     /// Serde JSON error.
     #[error(transparent)]
     SerdeJSON(#[from] serde_json::error::Error),
 }
 #[derive(Serialize)]
 struct ErrorWrapperWithHint {
     err: String,
     hint: String,
 impl Error {
     #[must_use]
     pub const fn code(&self) -> &'static str {
         match self {
             Error::ProjectError(radicle::identity::project::ProjectError::Name(_)) => {
                 "ProjectError.InvalidName"
             }
             Error::ProjectError(radicle::identity::project::ProjectError::Description(_)) => {
                 "ProjectError.InvalidDescription"
             }
             Error::Crypto(radicle::crypto::ssh::keystore::Error::Ssh(ssh_key::Error::Crypto))
             | Error::Crypto(radicle::crypto::ssh::keystore::Error::PassphraseMissing) => {
                 "PassphraseError.InvalidPassphrase"
             }
             Error::AliasError(radicle::node::AliasError::Empty) => "AliasError.EmptyAlias",
             Error::AliasError(radicle::node::AliasError::MaxBytesExceeded) => {
                 "AliasError.TooLongAlias"
             }
             Error::ProfileError(radicle::profile::Error::NotFound(_)) => {
                 "IdentityError.MissingProfile"
             }
             Error::AliasError(radicle::node::AliasError::InvalidCharacter) => {
                 "AliasError.InvalidAlias"
             }
             _ => "UnknownError",
         }
     }
 }
 #[derive(Serialize)]
 struct ErrorWrapper {
     err: String,
 #[derive(Serialize, ts_rs::TS, Debug)]
 #[ts(export)]
 #[ts(export_to = "error/")]
 pub struct ErrorWrapper {
     code: String,
     #[ts(optional)]
     message: Option<String>,
 }
 impl Serialize for Error {
 impl serde::Serialize for Error {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::ser::Serializer,
     {
         match self {
             Error::WithHint { err, hint } => ErrorWrapperWithHint {
                 err: err.to_string(),
                 hint: hint.to_string(),
             }
             .serialize(serializer),
             err => ErrorWrapper {
                 err: err.to_string(),
             }
             .serialize(serializer),
         }
         use serde::ser::SerializeStruct;
         let mut state = serializer.serialize_struct("ErrorWrapper", 2)?;
         state.serialize_field("code", &self.code().to_string())?;
         state.serialize_field("message", &self.to_string())?;
         state.end()
     }
 }

 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod test {
     use super::Error;
     use anyhow::anyhow;
     use crate::error::Error;
     #[test]
     fn serialize_nested_errors() {
         let serialized = serde_json::to_string(&Error::Crypto(
             radicle::crypto::ssh::keystore::Error::Ssh(ssh_key::Error::Crypto),
         ))
         .unwrap();
         assert_eq!(
             serialized,
             "{\"code\":\"PassphraseError.InvalidPassphrase\",\"message\":\"ssh keygen: cryptographic error\"}"
         );
     }
     #[test]
     fn serialize_errors() {
         assert_eq!(serde_json::to_string(&Error::WithHint {
             err: anyhow!("Not able to find your keys in the ssh agent"),
             hint: "Make sure to run <code>rad auth</code> in your terminal to add your keys to the ssh-agent.",
         }).unwrap(),"{\"err\":\"Not able to find your keys in the ssh agent\",\"hint\":\"Make sure to run <code>rad auth</code> in your terminal to add your keys to the ssh-agent.\"}");
     fn serialize_unknown_errors() {
         let serialized =
             serde_json::to_string(&Error::Issue(radicle::issue::Error::MissingIdentity)).unwrap();
         assert_eq!(
             serialized,
             "{\"code\":\"UnknownError\",\"message\":\"identity document missing\"}"
         );
     }
 }

 use traits::auth::Auth;
 use traits::cobs::Cobs;
 use traits::issue::{Issues, IssuesMut};
 use traits::patch::{Patches, PatchesMut};

     pub profile: radicle::Profile,
 }
 impl Auth for AppState {}
 impl Repo for AppState {}
 impl Thread for AppState {}
 impl Cobs for AppState {}

     type Error = error::Error;
     fn try_from(value: identity::doc::Payload) -> Result<Self, Self::Error> {
         serde_json::from_value::<Self>((*value).clone()).map_err(error::Error::from)
         serde_json::from_value::<Self>((*value).clone()).map_err(Into::into)
     }
 }

 use crate::config::Config;
 pub mod auth;
 pub mod cobs;
 pub mod issue;
 pub mod patch;

 use radicle_types::domain::patch::traits::PatchService;
 use radicle_types::error::Error;
 use radicle_types::outbound::sqlite::Sqlite;
 use radicle_types::traits::auth::Auth;
 use radicle_types::traits::cobs::Cobs;
 use radicle_types::traits::issue::{Issues, IssuesMut};
 use radicle_types::traits::patch::{Patches, PatchesMut};

     patches: Arc<Service<Sqlite>>,
 }
 impl Auth for Context {}
 impl Repo for Context {}
 impl Cobs for Context {}
 impl Thread for Context {}

     Ok::<_, Error>(Json(config))
 }
 async fn auth_handler(State(ctx): State<Context>) -> impl IntoResponse {
     ctx.authenticate()?;
 async fn auth_handler() -> impl IntoResponse {
     Ok::<_, Error>(Json(()))
 }

   flex-shrink: 0;
 }
 .global-link {
   color: var(--color-foreground-default);
   text-decoration: none;
 }
 .global-link:hover {
   text-decoration: underline;
   text-decoration-thickness: 1px;
   text-underline-offset: 2px;
 }
 :root {
   --elevation-low: 0 0 48px 0 #000000ee;
 }

 <script lang="ts">
   import type { ErrorWrapper } from "@bindings/error/ErrorWrapper";
   import type { Config } from "@bindings/config/Config";
   import type { UnlistenFn } from "@tauri-apps/api/event";
   import type { SyncStatus } from "@bindings/repo/SyncStatus";
   import { SvelteMap } from "svelte/reactivity";
   import { onDestroy, onMount } from "svelte";
   import { invoke } from "@app/lib/invoke";
   import { listen } from "@tauri-apps/api/event";
   import * as router from "@app/lib/router";
   import { nodeRunning, syncStatus } from "@app/lib/events";
   import { checkAuth, startup } from "@app/lib/auth.svelte";
   import { dynamicInterval } from "@app/lib/interval";
   import { createEventEmittersOnce } from "@app/lib/startup.svelte";
   import { invoke } from "@app/lib/invoke";
   import { theme } from "@app/components/ThemeSwitch.svelte";
   import { unreachable } from "@app/lib/utils";
   import AuthenticationError from "@app/views/AuthenticationError.svelte";
   import Auth from "@app/views/booting/Auth.svelte";
   import CreateIdentity from "@app/views/booting/CreateIdentity.svelte";
   import CreateIssue from "@app/views/repo/CreateIssue.svelte";
   import Inbox from "./views/home/Inbox.svelte";
   import Inbox from "@app/views/home/Inbox.svelte";
   import Issue from "@app/views/repo/Issue.svelte";
   import Issues from "@app/views/repo/Issues.svelte";
   import Patch from "@app/views/repo/Patch.svelte";
   import Patches from "@app/views/repo/Patches.svelte";
   import Repos from "./views/home/Repos.svelte";
   import { dynamicInterval, checkAuth } from "./lib/auth";
   import Repos from "@app/views/home/Repos.svelte";
   const activeRouteStore = router.activeRouteStore;
   let profile = $state<Config>();
   let unlistenEvents: UnlistenFn | undefined = undefined;
   let unlistenNodeEvents: UnlistenFn | undefined = undefined;
   let unlistenSyncStatus: UnlistenFn | undefined = undefined;
   let error = $state<undefined | unknown>();
   onMount(async () => {
     try {
       await invoke<Config>("startup");
     } catch (e: unknown) {
       error = e;
       profile = await invoke<Config>("startup");
     } catch (err) {
       startup.error = err as ErrorWrapper;
       return;
     }
     if (window.__TAURI_INTERNALS__) {
       unlistenEvents = await listen("event", () => {
         // Add handler for incoming events
       });
       unlistenSyncStatus = await listen<Record<string, SyncStatus>>(
         "sync_status",
         event => {
           syncStatus.set(new SvelteMap(Object.entries(event.payload)));
         },
       );
       unlistenNodeEvents = await listen<boolean>("node_running", event => {
         nodeRunning.set(event.payload);
       });
       [unlistenEvents, unlistenNodeEvents, unlistenSyncStatus] =
         await createEventEmittersOnce();
     }
     try {
       await invoke("authenticate");
       void router.loadFromLocation();
       void dynamicInterval(
       dynamicInterval(
         "auth",
         checkAuth,
         import.meta.env.VITE_AUTH_LONG_DELAY || 30_000,
       );
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (e: any) {
       void router.push({
         resource: "authenticationError",
         params: {
           error: e.err,
           hint: e.hint,
         },
       });
       void dynamicInterval(checkAuth, 1000);
     } catch (err) {
       startup.error = err as ErrorWrapper;
       void router.push({ resource: "booting" });
       dynamicInterval("auth", checkAuth, 5_000);
     }
   });

 </script>
 {#if $activeRouteStore.resource === "booting"}
   {#if error && typeof error === "object" && "err" in error && typeof error.err === "string"}
     <AuthenticationError error={error.err} />
   {#if startup.error?.code === "IdentityError.MissingProfile"}
     <CreateIdentity />
   {:else if startup.error?.code === "PassphraseError.InvalidPassphrase" && profile}
     <Auth profile={{ did: profile.publicKey, alias: profile.alias }} />
   {/if}
   <!-- Don't show anything -->
 {:else if $activeRouteStore.resource === "home"}
   <Repos {...$activeRouteStore.params} />
 {:else if $activeRouteStore.resource === "inbox"}

   <Patch {...$activeRouteStore.params} />
 {:else if $activeRouteStore.resource === "repo.patches"}
   <Patches {...$activeRouteStore.params} />
 {:else if $activeRouteStore.resource === "authenticationError"}
   <AuthenticationError {...$activeRouteStore.params} />
 {:else}
   {unreachable($activeRouteStore)}
 {/if}