Monorepo missing features (#1273)

* fix tauri config

* fix package patch

* regen pnpm lock

* use new workflow

* New GH actions

* Update lockfile

* update scripts

* Fix build script

* Fix missing deps

* Fix assets eslint

* Update libraries lint

* Fix all lint configs

* update lockfile

* add fmt + clippy fails

* Separate App Tauri portion

* fix app features

* Fix lints

* install tauri cli

* update lockfile

* corepack, fix lints

* add store path

* fix unused import

* Fix tests

* Issue templates + port over tauri release

* fix actions

* fix before build command

* Add X86 target

* Update build matrix

* finalize actions

* make debug build smaller

* Use debug build to make cache smaller

* dummy commit

* change proj name

* update file name

* Use release builds for less space use

* Remove rust cache

* Readd for app build

* add merge queue trigger

apps/app/src/api/process.rs

@@ -0,0 +1,78 @@
+use crate::api::Result;
+use theseus::prelude::*;
+use uuid::Uuid;
+
+pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
+    tauri::plugin::Builder::new("process")
+        .invoke_handler(tauri::generate_handler![
+            process_has_finished_by_uuid,
+            process_get_exit_status_by_uuid,
+            process_get_all_uuids,
+            process_get_all_running_uuids,
+            process_get_uuids_by_profile_path,
+            process_get_all_running_profile_paths,
+            process_get_all_running_profiles,
+            process_kill_by_uuid,
+            process_wait_for_by_uuid,
+        ])
+        .build()
+}
+
+// Checks if a process has finished by process UUID
+#[tauri::command]
+pub async fn process_has_finished_by_uuid(uuid: Uuid) -> Result<bool> {
+    Ok(process::has_finished_by_uuid(uuid).await?)
+}
+
+// Gets process exit status by process UUID
+#[tauri::command]
+pub async fn process_get_exit_status_by_uuid(
+    uuid: Uuid,
+) -> Result<Option<i32>> {
+    Ok(process::get_exit_status_by_uuid(uuid).await?)
+}
+
+// Gets all process UUIDs
+#[tauri::command]
+pub async fn process_get_all_uuids() -> Result<Vec<Uuid>> {
+    Ok(process::get_all_uuids().await?)
+}
+
+// Gets all running process UUIDs
+#[tauri::command]
+pub async fn process_get_all_running_uuids() -> Result<Vec<Uuid>> {
+    Ok(process::get_all_running_uuids().await?)
+}
+
+// Gets all process UUIDs by profile path
+#[tauri::command]
+pub async fn process_get_uuids_by_profile_path(
+    profile_path: ProfilePathId,
+) -> Result<Vec<Uuid>> {
+    Ok(process::get_uuids_by_profile_path(profile_path).await?)
+}
+
+// Gets the Profile paths of each *running* stored process in the state
+#[tauri::command]
+pub async fn process_get_all_running_profile_paths(
+) -> Result<Vec<ProfilePathId>> {
+    Ok(process::get_all_running_profile_paths().await?)
+}
+
+// Gets the Profiles (cloned) of each *running* stored process in the state
+#[tauri::command]
+pub async fn process_get_all_running_profiles() -> Result<Vec<Profile>> {
+    Ok(process::get_all_running_profiles().await?)
+}
+
+// Kill a process by process UUID
+#[tauri::command]
+pub async fn process_kill_by_uuid(uuid: Uuid) -> Result<()> {
+    Ok(process::kill_by_uuid(uuid).await?)
+}
+
+// Wait for a process to finish by process UUID
+#[tauri::command]
+pub async fn process_wait_for_by_uuid(uuid: Uuid) -> Result<()> {
+    Ok(process::wait_for_by_uuid(uuid).await?)
+}