feat: remove OpenConnect integration and related features

- Deleted the aetheris-openconnect crate and its dependencies from the project.
- Updated contributing documentation to reflect the removal of OpenConnect integration.
- Refactored aetheris-app to remove references to OpenConnect and adjusted related features and dependencies.
- Updated LICENSE to reflect the current copyright holder.
- Enhanced Kubernetes resource handling in aetheris-kube, including timeout handling for resource metrics.
- Improved object detail display in aetheris-app to include container resource requests and limits.
- Added tests for container resource extraction from Kubernetes objects.

Author: leandromqrs

ARCHITECTURE.md

@@ -10,7 +10,6 @@ flowchart TD
   UI --> Relm[Relm4 App Component]
   Relm --> Commands[Async Commands and Streams]
   Commands --> KubeCrate[aetheris-kube]
-  Commands -. optional VPN .-> OpenConnectCrate[aetheris-openconnect]
   KubeCrate --> Kubeconfig[Kubeconfig]
   KubeCrate --> Api[Kubernetes / OpenShift API]
   Relm --> Store[ProjectStore]
@@ -19,7 +18,7 @@ flowchart TD
   VTE --> Commands
 ```
 
-`aetheris-app` owns windows, widgets, user state, and persistence of Aetheris projects. `aetheris-kube` owns kubeconfig parsing, Kubernetes clients, discovery, list/watch, mutations, logs, exec, port-forwarding, metrics, and resource details. `aetheris-openconnect` is an optional native integration crate for libopenconnect; it isolates C FFI and exposes a Rust API for future VPN workflows.
+`aetheris-app` owns windows, widgets, user state, and persistence of Aetheris projects. `aetheris-kube` owns kubeconfig parsing, Kubernetes clients, discovery, list/watch, mutations, logs, exec, port-forwarding, metrics, and resource details.
 
 ## Crate Boundaries
 
@@ -41,17 +40,10 @@ flowchart LR
     Ops[Logs exec port-forward mutations]
   end
 
-  subgraph OpenConnect["aetheris-openconnect"]
-    SafeApi[Safe Rust API]
-    Ffi[libopenconnect FFI]
-  end
-
   Widgets --> State
   State --> Commands
   State --> Streams
   Commands --> Manager
-  Commands -. optional .-> SafeApi
-  SafeApi --> Ffi
   Streams --> Manager
   Manager --> Session
   Session --> Resources
@@ -60,7 +52,7 @@ flowchart LR
   Projects --> State
 ```
 
-The backend crate must not import GTK, Adwaita, Relm4, VTE, or application widgets. Shared data crosses the boundary through DTOs exported from `aetheris-kube::types`. Native C integrations are kept out of both UI widgets and `aetheris-kube`; each integration gets a focused crate such as `aetheris-openconnect`, with `unsafe` declarations confined to its FFI module.
+The backend crate must not import GTK, Adwaita, Relm4, VTE, or application widgets. Shared data crosses the boundary through DTOs exported from `aetheris-kube::types`.
 
 ## Application Lifecycle
 

CONTRIBUTING.md

@@ -13,16 +13,6 @@ sudo dnf install -y \
   openssl-devel
 ```
 
-OpenConnect integration is optional while the VPN UI is under development. To
-build it locally, install the libopenconnect development files and enable the
-feature:
-
-```sh
-sudo dnf install -y openconnect-devel
-cargo check -p aetheris-openconnect --features system-libopenconnect
-cargo check -p aetheris-app --features openconnect
-```
-
 Run the app:
 
 ```sh
@@ -66,7 +56,6 @@ Aetheris has two Rust crates:
 
 - `aetheris-kube` — pure Kubernetes backend. It must not depend on GTK, Relm4, Libadwaita, or VTE.
 - `aetheris-app` — Relm4/GTK4 application. It owns UI state, widgets, project persistence, and command wiring.
-- `aetheris-openconnect` — optional libopenconnect integration. It owns C FFI and exposes only safe Rust types to the app.
 
 See [ARCHITECTURE.md](ARCHITECTURE.md) for diagrams and module responsibilities.
 

Cargo.lock

@@ -3,7 +3,6 @@ resolver = "2"
 members = [
     "crates/aetheris-app",
     "crates/aetheris-kube",
-    "crates/aetheris-openconnect",
 ]
 
 [workspace.package]

Cargo.toml

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2026 LuminusOS
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

LICENSE

@@ -55,14 +55,9 @@ resources = [
 
 [features]
 default = []
-openconnect = [
-  "dep:aetheris-openconnect",
-  "aetheris-openconnect/system-libopenconnect",
-]
 
 [dependencies]
 aetheris-kube = { path = "../aetheris-kube" }
-aetheris-openconnect = { path = "../aetheris-openconnect", optional = true }
 anyhow = "1"
 dirs = "6"
 futures = "0.3"

crates/aetheris-app/Cargo.toml

@@ -5,9 +5,10 @@ use std::{
 };
 
 use aetheris_kube::{
-    AddClusterRequest, ClusterSummary, ContainerUsage, ContextInfo, KubeManager, ObjectCondition,
-    ObjectDetail, ObjectEvent, ObjectSummary, ObjectWatchEvent, PodExecEvent, PodExecRequest,
-    PodLogRequest, PodPortForwardEvent, PodPortForwardRequest, ResourceKind, ResourceUsage,
+    AddClusterRequest, ClusterSummary, ContainerResources, ContainerUsage, ContextInfo,
+    KubeManager, ObjectCondition, ObjectDetail, ObjectEvent, ObjectSummary, ObjectWatchEvent,
+    PodExecEvent, PodExecRequest, PodLogRequest, PodPortForwardEvent, PodPortForwardRequest,
+    ResourceKind, ResourceUsage,
 };
 use futures::FutureExt;
 use futures::future::{AbortHandle, Abortable};
@@ -178,6 +179,7 @@ pub struct App {
     object_columns: Vec<(ObjectTableColumn, gtk::ColumnViewColumn)>,
     object_list_stack: gtk::Stack,
     detail: DetailPane,
+    object_load_token: u64,
     object_watch_token: u64,
     object_watch_abort_handle: Option<AbortHandle>,
     log_streaming: bool,
@@ -308,7 +310,7 @@ pub enum AppMsg {
     CaFileLoaded(Result<String, String>),
     ShowImportFile,
     Refresh,
-    ObjectsLoaded(Result<Vec<ObjectSummary>, String>),
+    ObjectsLoaded(u64, Result<Vec<ObjectSummary>, String>),
     AddCluster,
     ClusterAdded(Result<(String, String), String>),
     StateLoadedForCluster(String, Result<LoadedState, String>),

crates/aetheris-app/src/app.rs

@@ -1,6 +1,10 @@
+use std::time::Duration;
+
 use super::utils::*;
 use super::*;
 
+const CLUSTER_LOAD_TIMEOUT: Duration = Duration::from_secs(30);
+
 pub(super) async fn load_state() -> AppMsg {
     let result = async {
         // A missing kubeconfig is the normal first-run state — the user
@@ -34,29 +38,39 @@ pub(super) async fn load_state() -> AppMsg {
 }
 
 pub(super) async fn load_cluster(context: String) -> AppMsg {
-    let result = async {
-        let manager = KubeManager::load()?;
-        let session = manager.connect_context(&context).await?;
-        let (namespaces, namespace_warning) = match session.list_namespaces().await {
-            Ok(namespaces) => (namespaces, None),
-            Err(error) => (
-                manager.namespace_for_context(&context),
-                Some(format_error(error)),
-            ),
-        };
-        let resources = session.discover_resources().await?;
-        Ok::<_, anyhow::Error>(ClusterState {
-            namespaces,
-            resources,
-            namespace_warning,
-        })
-    }
+    let result = match tokio::time::timeout(CLUSTER_LOAD_TIMEOUT, async {
+        load_cluster_state(context).await
+    })
     .await
+    {
+        Ok(result) => result,
+        Err(_) => Err(anyhow::anyhow!(
+            "Timed out while discovering Kubernetes resources for this cluster. Check that the API server is reachable and try again."
+        )),
+    }
     .map_err(format_error);
 
     AppMsg::ClusterLoaded(result)
 }
 
+async fn load_cluster_state(context: String) -> anyhow::Result<ClusterState> {
+    let manager = KubeManager::load()?;
+    let session = manager.connect_context(&context).await?;
+    let (namespaces, namespace_warning) = match session.list_namespaces().await {
+        Ok(namespaces) => (namespaces, None),
+        Err(error) => (
+            manager.namespace_for_context(&context),
+            Some(format_error(error)),
+        ),
+    };
+    let resources = session.discover_resources().await?;
+    Ok(ClusterState {
+        namespaces,
+        resources,
+        namespace_warning,
+    })
+}
+
 pub(super) async fn load_cluster_summary(context: String) -> AppMsg {
     let result = async {
         let manager = KubeManager::load()?;
@@ -70,13 +84,14 @@ pub(super) async fn load_cluster_summary(context: String) -> AppMsg {
 }
 
 pub(super) async fn list_objects(
+    token: u64,
     context: String,
     resource: ResourceKind,
     namespace: Option<String>,
 ) -> AppMsg {
     let result = list_objects_snapshot(context, resource, namespace).await;
 
-    AppMsg::ObjectsLoaded(result)
+    AppMsg::ObjectsLoaded(token, result)
 }
 
 pub(super) async fn list_objects_snapshot(

crates/aetheris-app/src/app/commands.rs

@@ -971,6 +971,7 @@ impl Component for App {
                 node_unschedulable: None,
                 request_token: 0,
             },
+            object_load_token: 0,
             object_watch_token: 0,
             object_watch_abort_handle: None,
             log_streaming: false,

crates/aetheris-app/src/app/component.rs

@@ -1127,7 +1127,10 @@ impl App {
                     self.refresh_objects(sender);
                 }
             }
-            AppMsg::ObjectsLoaded(Ok(objects)) => {
+            AppMsg::ObjectsLoaded(token, Ok(objects)) => {
+                if token != self.object_load_token {
+                    return;
+                }
                 self.loading = false;
                 let count = objects.len();
                 self.objects = objects;
@@ -1136,7 +1139,10 @@ impl App {
                 self.rebuild_object_list();
                 self.start_object_watch(sender);
             }
-            AppMsg::ObjectsLoaded(Err(error)) => {
+            AppMsg::ObjectsLoaded(token, Err(error)) => {
+                if token != self.object_load_token {
+                    return;
+                }
                 self.loading = false;
                 self.stop_object_watch();
                 self.objects.clear();