From 354f14d2c4e8c8a76cc536225309e77b41776e45 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Thu, 8 Jan 2026 10:14:39 +0100
Subject: [PATCH 01/14] Update process actions UI and add InfoBar notifications

Refactored ProcessesPage to replace service actions with process-specific actions (Start, Kill, Restart, View Properties) in both context menu and DropDownButton. The Ellipse icon now binds its Fill property to the data context. Improved process list layout and margins. Renamed event handlers to match process actions. Added InfoBar notification helpers and named the root Grid for dynamic InfoBar display. Minor margin tweaks in ServicesPage for consistency.
---
 .../srvMgnt/Views/ProcessesPage.xaml          | 57 +++++++++--------
 .../srvMgnt/Views/ProcessesPage.xaml.cs       | 63 +++++++++++++++++--
 .../srvMgnt/Views/ServicesPage.xaml           |  6 +-
 3 files changed, 94 insertions(+), 32 deletions(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
index 1ed8159..a061344 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
@@ -9,7 +9,7 @@
     mc:Ignorable="d"
     NavigationCacheMode="Enabled">
 
-    <Grid Padding="8">
+    <Grid Padding="8" x:Name="GridRoot">
         <Grid.RowDefinitions>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="*"/>
@@ -20,7 +20,7 @@
             <TextBox x:Name="FilterByName" Width="150" Header="Name"
 	            HorizontalAlignment="Left" TextChanged="OnFilterChanged"/>
         </StackPanel>
-        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="8,0,8,8" Grid.Row="0">
+        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="8" Grid.Row="0">
             <Button x:Name="RefreshButton"
                     Content="Refresh"
                     Click="RefreshButton_Click"
@@ -35,38 +35,42 @@
             SelectionMode="Single"
             ShowsScrollingPlaceholders="True"
             Grid.Row="1"
-            Margin="0"
             VerticalAlignment="Stretch"
             HorizontalAlignment="Stretch">
 
             <ListView.ItemTemplate>
                 <DataTemplate x:DataType="local:ProcessInfo">
                     <Grid>
+                        <Grid.ContextFlyout>
+                            <MenuFlyout>
+                                <MenuFlyoutItem Text="Start" Click="ProcessStartMenuItem_Click" />
+                                <MenuFlyoutItem Text="Kill" Click="ProcessKillMenuItem_Click" />
+                                <MenuFlyoutItem Text="Restart" Click="ProcessRestartMenuItem_Click" />
+                                <MenuFlyoutItem Text="View Properties" Click="ProcessViewMenuItem_Click" />
+                            </MenuFlyout>
+                        </Grid.ContextFlyout>
+
                         <Grid.ColumnDefinitions>
                             <ColumnDefinition Width="Auto"/>
                             <ColumnDefinition Width="*"/>
                             <ColumnDefinition Width="Auto"/>
                         </Grid.ColumnDefinitions>
                         <Grid.RowDefinitions>
-                            <RowDefinition Height="Auto"/>
+                            <RowDefinition Height="*"/>
+                            <RowDefinition Height="*"/>
                         </Grid.RowDefinitions>
 
-                        <Grid.ContextFlyout>
-                            <MenuFlyout>
-                                <MenuFlyoutItem Text="Start" Click="ServiceStartMenuItem_Click" />
-                                <MenuFlyoutItem Text="Stop" Click="ServiceStopMenuItem_Click" />
-                                <MenuFlyoutItem Text="Restart" Click="ServiceRestartMenuItem_Click" />
-                                <MenuFlyoutItem Text="View Properties" Click="ServiceViewMenuItem_Click" />
-                            </MenuFlyout>
-                        </Grid.ContextFlyout>
-
                         <!-- Icon -->
-                        <Ellipse Width="16" Height="16" Fill="{ThemeResource SystemAccentColor}" VerticalAlignment="Center" HorizontalAlignment="Center" />
+                        <Ellipse Width="16" Height="16" Fill="{x:Bind Fill, Mode=OneWay}" VerticalAlignment="Center" HorizontalAlignment="Center" />
 
                         <!-- Main info -->
                         <StackPanel Grid.Column="1" Margin="12,0,12,0" VerticalAlignment="Center">
-                            <TextBlock Text="{x:Bind ProcessName}" Style="{ThemeResource BodyLargeTextBlockStyle}" TextTrimming="CharacterEllipsis"/>
-                            <StackPanel Orientation="Horizontal" Spacing="12" Margin="0,6,0,0">
+                            <StackPanel Orientation="Horizontal" Spacing="12" Margin="12,8,0,0">
+                                <TextBlock Text="{x:Bind ProcessName}" Style="{ThemeResource BodyLargeTextBlockStyle}" TextTrimming="CharacterEllipsis"/>
+                                <TextBlock Text="{x:Bind Uptime, Mode=OneWay}" Style="{ThemeResource CaptionTextBlockStyle}"
+                                           Margin="0,4,0,0"/>
+                            </StackPanel>
+                            <StackPanel Orientation="Horizontal" Spacing="12" Margin="12,0,0,8">
                                 <StackPanel Orientation="Horizontal" Spacing="4">
                                     <TextBlock Text="PID:" FontWeight="SemiBold" />
                                     <TextBlock Text="{x:Bind ProcessId}" />
@@ -74,25 +78,28 @@
 
                                 <StackPanel Orientation="Horizontal" Spacing="4">
                                     <TextBlock Text="State:" FontWeight="SemiBold" />
-                                    <TextBlock Text="{x:Bind State}" />
+                                    <TextBlock Text="{x:Bind State, Mode=OneWay}" />
                                 </StackPanel>
 
                                 <StackPanel Orientation="Horizontal" Spacing="4">
                                     <TextBlock Text="Threads:" FontWeight="SemiBold" />
-                                    <TextBlock Text="{x:Bind NumThreads}" />
+                                    <TextBlock Text="{x:Bind NumThreads, Mode=OneWay}" />
                                 </StackPanel>
                             </StackPanel>
 
-                            <TextBlock Text="{x:Bind Uptime}" Style="{ThemeResource CaptionTextBlockStyle}"
-                                           Margin="0,4,0,0"/>
                         </StackPanel>
 
                         <!-- Action buttons -->
-                            <StackPanel Grid.Column="2" Orientation="Horizontal" VerticalAlignment="Center" Spacing="8">
-                                <Button Content="Start" Click="ServiceStartMenuItem_Click" Padding="12,8" />
-                                <Button Content="Stop" Click="ServiceStopMenuItem_Click" Padding="12,8" />
-                                <Button Content="Restart" Click="ServiceRestartMenuItem_Click" Padding="12,8" />
-                            </StackPanel>
+                        <DropDownButton Content="Actions" Grid.Column="2" VerticalAlignment="Center">
+                            <DropDownButton.Flyout>
+                                <MenuFlyout Placement="Bottom">
+                                    <MenuFlyoutItem Text="Start" Click="ProcessStartMenuItem_Click" />
+                                    <MenuFlyoutItem Text="Kill" Click="ProcessKillMenuItem_Click" />
+                                    <MenuFlyoutItem Text="Restart" Click="ProcessRestartMenuItem_Click" />
+                                    <MenuFlyoutItem Text="View Properties" Click="ProcessViewMenuItem_Click" />
+                                </MenuFlyout>
+                            </DropDownButton.Flyout>
+                        </DropDownButton>
                     </Grid>
                 </DataTemplate>
             </ListView.ItemTemplate>
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
index e610781..111f760 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
@@ -56,19 +56,19 @@ private void RefreshButton_Click(object sender, RoutedEventArgs e)
         {
         }
 
-        private void ServiceStartMenuItem_Click(object sender, RoutedEventArgs e)
+        private void ProcessStartMenuItem_Click(object sender, RoutedEventArgs e)
         {
         }
 
-        private void ServiceStopMenuItem_Click(object sender, RoutedEventArgs e)
+        private void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
         {
         }
 
-        private void ServiceRestartMenuItem_Click(object sender, RoutedEventArgs e)
+        private void ProcessRestartMenuItem_Click(object sender, RoutedEventArgs e)
         {
         }
 
-        private void ServiceViewMenuItem_Click(object sender, RoutedEventArgs e)
+        private void ProcessViewMenuItem_Click(object sender, RoutedEventArgs e)
         {
         }
 
@@ -140,10 +140,65 @@ await DispatcherQueue.EnqueueAsync(() =>
                 }).ConfigureAwait(false);
             }
         }
+
+        private async Task LoadAllProcesses()
+        {
+            if (client is null || client.Service is null)
+            {
+                return;
+            }
+        }
+        
+        private async Task ShowInfoBarAsync(string title, string message, InfoBarSeverity severity)
+        {
+            // Ensure UI thread
+            await DispatcherQueue.EnqueueAsync(() =>
+            {
+                if (GridRoot == null)
+                {
+                    // fallback to page XamlRoot; but InfoBar must be in visual tree to be visible
+                    // if GridRoot is not available the InfoBar won't be shown persistently.
+                    return;
+                }
+
+                InfoBar infoBar = new()
+                {
+                    Title = title,
+                    Message = message,
+                    Severity = severity,
+                    IsOpen = true,
+                    VerticalAlignment = VerticalAlignment.Top,
+                    Margin = new Thickness(0, 0, 0, 0)
+                };
+
+                // Add to visual tree so it is visible
+                GridRoot.Children.Add(infoBar);
+
+                // Remove from visual tree when closed
+                void OnClosed(object? s, InfoBarClosedEventArgs args)
+                {
+                    infoBar.Closed -= OnClosed;
+                    if (GridRoot.Children.Contains(infoBar))
+                    {
+                        GridRoot.Children.Remove(infoBar);
+                    }
+                }
+
+                infoBar.Closed += OnClosed;
+            });
+        }
+
+        private async Task ShowErrorInfoBarAsync(string message)
+        {
+            await ShowInfoBarAsync("Service Action Result", $"Error: {message}", InfoBarSeverity.Error);
+        }
     }
 
     public class ProcessInfo
     {
+        // Fill
+        public SolidColorBrush Fill { get; set; } = new SolidColorBrush(Microsoft.UI.Colors.Transparent);
+
         // PID
         public int ProcessId { get; set; }
 
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml
index a4e3ced..e14be3f 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml
@@ -68,15 +68,15 @@
                             <TextBlock Grid.Column="1"
                                    Text="{x:Bind Name, Mode=OneWay}"
                                    x:Phase="1"
-                                   Style="{ThemeResource BaseTextBlockStyle}"
-                                   Margin="12,6,0,0"/>
+                                   Style="{ThemeResource BodyLargeTextBlockStyle}"
+                                   Margin="12,8,0,0"/>
 
                             <TextBlock Grid.Column="1"
                                    Grid.Row="1"
                                    Text="{x:Bind Description, Mode=OneWay}"
                                    x:Phase="2"
                                    Style="{ThemeResource BodyTextBlockStyle}"
-                                   Margin="12,0,0,6"/>
+                                   Margin="12,0,0,8"/>
                         </StackPanel>
 
                         <DropDownButton Content="Actions" Grid.Column="2" VerticalAlignment="Center">

From a31902753dc8895560e0cb454aee613739f601e4 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Thu, 8 Jan 2026 10:44:14 +0100
Subject: [PATCH 02/14] Refactor process list: filtering, ordering, error
 handling

- Removed "View Properties" from context/dropdown menus
- Added allProcesses backing collection for filtering
- Implemented filter logic and UI update helpers
- Refresh now reloads processes asynchronously
- Stubbed out process start/kill/restart handlers
- Refactored process loading and color assignment
- Added ordering by state and name
- Improved error handling for missing client
---
 .../srvMgnt/Views/ProcessesPage.xaml          |   2 -
 .../srvMgnt/Views/ProcessesPage.xaml.cs       | 147 +++++++++++++-----
 2 files changed, 109 insertions(+), 40 deletions(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
index a061344..52a299d 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
@@ -46,7 +46,6 @@
                                 <MenuFlyoutItem Text="Start" Click="ProcessStartMenuItem_Click" />
                                 <MenuFlyoutItem Text="Kill" Click="ProcessKillMenuItem_Click" />
                                 <MenuFlyoutItem Text="Restart" Click="ProcessRestartMenuItem_Click" />
-                                <MenuFlyoutItem Text="View Properties" Click="ProcessViewMenuItem_Click" />
                             </MenuFlyout>
                         </Grid.ContextFlyout>
 
@@ -96,7 +95,6 @@
                                     <MenuFlyoutItem Text="Start" Click="ProcessStartMenuItem_Click" />
                                     <MenuFlyoutItem Text="Kill" Click="ProcessKillMenuItem_Click" />
                                     <MenuFlyoutItem Text="Restart" Click="ProcessRestartMenuItem_Click" />
-                                    <MenuFlyoutItem Text="View Properties" Click="ProcessViewMenuItem_Click" />
                                 </MenuFlyout>
                             </DropDownButton.Flyout>
                         </DropDownButton>
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
index 111f760..247a912 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
@@ -35,10 +35,13 @@ public sealed partial class ProcessesPage : Page
 
         public ObservableCollection<ProcessInfo> processes { get; } = new();
 
+        private Collection<ProcessInfo> allProcesses { get; } = new();
+
         public ProcessesPage()
         {
             InitializeComponent();
         }
+
         protected override void OnNavigatedTo(NavigationEventArgs e)
         {
             base.OnNavigatedTo(e);
@@ -49,27 +52,61 @@ protected override void OnNavigatedTo(NavigationEventArgs e)
 
         private void OnFilterChanged(object sender, RoutedEventArgs args)
         {
+            IEnumerable<ProcessInfo> filtered = allProcesses.Where(process => Filter(process));
+            Remove_NonMatching(filtered);
+            AddBack_Processes(filtered);
+            Order_services();
+        }
 
+        private bool Filter(ProcessInfo process)
+        {
+            if (string.IsNullOrWhiteSpace(FilterByName.Text))
+            {
+                return true;
+            }
+            return process.ProcessName.Contains(FilterByName.Text, StringComparison.OrdinalIgnoreCase)
+                || process.ProcessId.ToString().Contains(FilterByName.Text, StringComparison.OrdinalIgnoreCase);
         }
 
-        private void RefreshButton_Click(object sender, RoutedEventArgs e)
+        private void Remove_NonMatching(IEnumerable<ProcessInfo> filteredData)
         {
+            for (int i = processes.Count - 1; i >= 0; i--)
+            {
+                ProcessInfo process = processes[i];
+                if (!filteredData.Contains(process))
+                    processes.Remove(process);
+            }
+
         }
 
-        private void ProcessStartMenuItem_Click(object sender, RoutedEventArgs e)
+        private void AddBack_Processes(IEnumerable<ProcessInfo> filteredData)
         {
+            foreach (ProcessInfo process in filteredData)
+            {
+                if (!processes.Contains(process))
+                    processes.Add(process);
+            }
         }
 
-        private void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
+        private async void RefreshButton_Click(object sender, RoutedEventArgs e)
         {
+            await ClearAllProcesses();
+            await LoadAllProcesses();
         }
 
-        private void ProcessRestartMenuItem_Click(object sender, RoutedEventArgs e)
+        private void ProcessStartMenuItem_Click(object sender, RoutedEventArgs e)
         {
+            // TODO: implement process start
         }
 
-        private void ProcessViewMenuItem_Click(object sender, RoutedEventArgs e)
+        private void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
         {
+            // TODO: implement process kill
+        }
+
+        private void ProcessRestartMenuItem_Click(object sender, RoutedEventArgs e)
+        {
+            // TODO: implement process restart
         }
 
         private async Task InitializeAsync(NavigationEventArgs e)
@@ -89,39 +126,7 @@ private async Task InitializeAsync(NavigationEventArgs e)
                     client = await clientRegistry.GetAsync(endpoint.Id).ConfigureAwait(false);
                 }
 
-                if (client is null || client.Service is null)
-                {
-                    await DispatcherQueue.EnqueueAsync(() =>
-                    {
-                        processes.Clear();
-                        processes.Add(new ProcessInfo
-                        {
-                            ProcessId = 0,
-                            ProcessName = "(no client)",
-                            State = ProcessState.Unspecified,
-                            Uptime = 0,
-                            NumThreads = 0
-                        });
-                    }).ConfigureAwait(false);
-                    return;
-                }
-
-                GetSystemResourcesResponse response = await client.Resources.GetSystemResourcesAsync(new GetSystemResourcesRequest());
-
-                foreach (Process process in response.Resources.Processes)
-                {
-                    await DispatcherQueue.EnqueueAsync(() =>
-                    {
-                        processes.Add(new ProcessInfo
-                        {
-                            ProcessId = (int)process.Pid,
-                            ProcessName = process.Name,
-                            State = process.State,
-                            Uptime = process.Utime,
-                            NumThreads = (int)process.NumThreads
-                        });
-                    }).ConfigureAwait(false);
-                }
+                await LoadAllProcesses();
             }
             catch (Exception ex)
             {
@@ -141,12 +146,78 @@ await DispatcherQueue.EnqueueAsync(() =>
             }
         }
 
+        private async Task ClearAllProcesses()
+        {
+            await DispatcherQueue.EnqueueAsync(() =>
+            {
+                allProcesses.Clear();
+                processes.Clear();
+            });
+        }
+
         private async Task LoadAllProcesses()
         {
             if (client is null || client.Service is null)
             {
+                await ShowErrorInfoBarAsync("No valid AgentClient available.");
                 return;
             }
+            GetSystemResourcesResponse? response = await client.Resources.GetSystemResourcesAsync(new GetSystemResourcesRequest());
+            if (response is null)
+            {
+                throw new InvalidOperationException("Received null response from ActionAsync");
+            }
+            foreach (Process? process in response.Resources.Processes)
+            {
+                SolidColorBrush brush = process.State switch
+                {
+                    ProcessState.Unspecified => (SolidColorBrush)Application.Current.Resources["SystemFillColorNeutralBrush"],
+                    ProcessState.Running => (SolidColorBrush)Application.Current.Resources["SystemFillColorAttentionBrush"],
+                    ProcessState.Sleeping => (SolidColorBrush)Application.Current.Resources["SystemFillColorCautionBrush"],
+                    ProcessState.Stopped => (SolidColorBrush)Application.Current.Resources["SystemFillColorCriticalBrush"],
+                    _ => (SolidColorBrush)Application.Current.Resources["SystemFillColorCriticalBackgroundBrush"],
+                };
+                ProcessInfo processInfo = new()
+                {
+                    Fill = brush,
+                    ProcessId = (int)process.Pid,
+                    ProcessName = process.Name,
+                    State = process.State,
+                    Uptime = process.Utime,
+                    NumThreads = (int)process.NumThreads
+                };
+                await DispatcherQueue.EnqueueAsync(() =>
+                {
+                    allProcesses.Add(processInfo);
+                    processes.Add(processInfo);
+                });
+            }
+            await DispatcherQueue.EnqueueAsync(() =>
+            {
+                Order_services();
+            });
+        }
+
+        private void Order_services()
+        {
+            List<ProcessInfo> ordered = processes
+                .OrderBy(p =>
+                {
+                    if (p.State.Equals(ProcessState.Running))
+                        return 0;
+                    if (p.State.Equals(ProcessState.Sleeping))
+                        return 1;
+                    return 2;
+                })
+                .ThenBy(p => p.State)
+                .ThenBy(p => p.ProcessName)
+                .ToList();
+
+            processes.Clear();
+            foreach (ProcessInfo process in ordered)
+            {
+                processes.Add(process);
+            }
         }
         
         private async Task ShowInfoBarAsync(string title, string message, InfoBarSeverity severity)

From 39605ad828d0a72db5e5117bcb4ad47fd3f28bc0 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Thu, 8 Jan 2026 11:24:02 +0100
Subject: [PATCH 03/14] Adjust SelectorBar margin for improved layout spacing

Changed the SelectorBar Margin property from "-10, -8" to "-10, -8, 0, -24" in ServerMainPage.xaml to refine its positioning and spacing within the layout.
---
 .../srvMgnt/ServerMainPage.xaml                                 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml
index 07814c5..673b197 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml
@@ -42,7 +42,7 @@
                 </StackPanel>
             </Grid>
 
-            <SelectorBar SelectionChanged="SelectorBar_SelectionChanged" Margin="-10, -8" x:Name="SelectorBar">
+            <SelectorBar SelectionChanged="SelectorBar_SelectionChanged" Margin="-10, -8, 0, -24" x:Name="SelectorBar">
                 <SelectorBarItem x:Name="SelectorBarItemOverview" 
                      Text="Overview" Icon="Clock">
                 </SelectorBarItem>

From 9099f93a5733338d52a57463164575354e9da0d7 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Thu, 8 Jan 2026 11:24:37 +0100
Subject: [PATCH 04/14] Add process ordering and confirm dialog for kill action

Added ComboBox for process ordering (Default, Name, PID, Uptime, State) and refactored ordering logic accordingly. Improved toolbar UI with spacing and accent style. Added confirmation dialog before killing a process.
---
 .../srvMgnt/Views/ProcessesPage.xaml          | 19 ++++++-
 .../srvMgnt/Views/ProcessesPage.xaml.cs       | 57 ++++++++++++++-----
 2 files changed, 60 insertions(+), 16 deletions(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
index 52a299d..26fca15 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
@@ -16,18 +16,31 @@
         </Grid.RowDefinitions>
 
         <!-- Toolbar with refresh -->
-        <StackPanel Orientation="Horizontal" HorizontalAlignment="Left" Padding="20,0,8,8" Grid.Row="0">
+        <StackPanel Orientation="Horizontal" HorizontalAlignment="Left" Spacing="8" Padding="20,0,8,8" Grid.Row="0">
             <TextBox x:Name="FilterByName" Width="150" Header="Name"
 	            HorizontalAlignment="Left" TextChanged="OnFilterChanged"/>
+            <ComboBox
+                x:Name="OrderByCombo"
+                SelectedValuePath="Tag"
+                SelectionChanged="OnOrderChanged"
+                VerticalAlignment="Bottom"
+                >
+                <ComboBoxItem Tag="Default" IsSelected="True">Default</ComboBoxItem>
+                <ComboBoxItem Tag="Name">Name</ComboBoxItem>
+                <ComboBoxItem Tag="Pid">Process ID</ComboBoxItem>
+                <ComboBoxItem Tag="Uptime">Uptime</ComboBoxItem>
+                <ComboBoxItem Tag="State">State</ComboBoxItem>
+            </ComboBox>
         </StackPanel>
-        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="8" Grid.Row="0">
+        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" VerticalAlignment="Top" Margin="8" Grid.Row="0">
             <Button x:Name="RefreshButton"
                     Content="Refresh"
                     Click="RefreshButton_Click"
                     VerticalAlignment="Center"
                     HorizontalAlignment="Right"
                     Margin="0,0,4,0"
-                    Padding="12,6"/>
+                    Padding="12,6"
+                    Style="{StaticResource AccentButtonStyle}"/>
         </StackPanel>
 
         <ListView
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
index 247a912..675811f 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
@@ -99,9 +99,26 @@ private void ProcessStartMenuItem_Click(object sender, RoutedEventArgs e)
             // TODO: implement process start
         }
 
-        private void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
+        private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
         {
             // TODO: implement process kill
+            ContentDialog dialog = new()
+            {
+                XamlRoot = this.XamlRoot,
+                Title = "Are you sure you want to Kill this process?",
+                CloseButtonText = "Cancel",
+                PrimaryButtonText = "Kill",
+            };
+
+            ContentDialogResult result = await dialog.ShowAsync();
+
+            if (result == ContentDialogResult.Primary)
+            {
+                // Kill the Process
+            } else
+            {
+                // Cancel, do nothing
+            }
         }
 
         private void ProcessRestartMenuItem_Click(object sender, RoutedEventArgs e)
@@ -198,20 +215,34 @@ await DispatcherQueue.EnqueueAsync(() =>
             });
         }
 
+        public void OnOrderChanged(object sender, SelectionChangedEventArgs args)
+        {
+            Order_services();
+        }
+
         private void Order_services()
         {
-            List<ProcessInfo> ordered = processes
-                .OrderBy(p =>
-                {
-                    if (p.State.Equals(ProcessState.Running))
-                        return 0;
-                    if (p.State.Equals(ProcessState.Sleeping))
-                        return 1;
-                    return 2;
-                })
-                .ThenBy(p => p.State)
-                .ThenBy(p => p.ProcessName)
-                .ToList();
+            string order = OrderByCombo?.SelectedValue as string ?? "State";
+
+            List<ProcessInfo> ordered = order switch
+            {
+                "Name" => processes.OrderBy(p => p.ProcessName).ThenBy(p => p.ProcessId).ToList(),
+                "Pid" => processes.OrderBy(p => p.ProcessId).ToList(),
+                "Uptime" => processes.OrderByDescending(p => p.Uptime).ToList(),
+                "State" => processes.OrderBy(p => p.State).ThenBy(p => p.ProcessName).ToList(),
+                _ => processes
+                    .OrderBy(p =>
+                    {
+                        if (p.State.Equals(ProcessState.Running))
+                            return 0;
+                        if (p.State.Equals(ProcessState.Sleeping))
+                            return 1;
+                        return 2;
+                    })
+                    .ThenBy(p => p.State)
+                    .ThenBy(p => p.ProcessName)
+                    .ToList()
+            };
 
             processes.Clear();
             foreach (ProcessInfo process in ordered)

From a753bb6759bf5dc1db65ef0383bcbe999019dfb7 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Thu, 8 Jan 2026 17:16:15 +0100
Subject: [PATCH 05/14] Improve ProcessesPage init, loading, and cancellation
 logic

- Add ProgressRing to indicate loading state in UI
- Enable NavigationCacheMode and track endpoint to avoid redundant reloads
- Add cancellation support for initialization and data loading
- Refactor to separate client resolution, initialization, and data loading
- Improve error handling and show errors via InfoBar
- Refresh button now triggers non-cancellable reload
- Show/hide ProgressRing during load operations
---
 .../srvMgnt/Views/ProcessesPage.xaml          |   2 +
 .../srvMgnt/Views/ProcessesPage.xaml.cs       | 170 ++++++++++++++----
 .../srvMgnt/Views/ServicesPage.xaml.cs        |   1 -
 3 files changed, 137 insertions(+), 36 deletions(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
index 26fca15..7919c7d 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
@@ -43,6 +43,8 @@
                     Style="{StaticResource AccentButtonStyle}"/>
         </StackPanel>
 
+        <ProgressRing x:Name="LoadingProgressRing" Grid.Row="1" IsActive="True" Width="48" Height="48"/>
+
         <ListView
             ItemsSource="{x:Bind processes, Mode=OneWay}"
             SelectionMode="Single"
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
index 675811f..9e64570 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
@@ -16,6 +16,7 @@
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices.WindowsRuntime;
+using System.Threading;
 using System.Threading.Tasks;
 using Windows.Foundation;
 using Windows.Foundation.Collections;
@@ -33,12 +34,25 @@ public sealed partial class ProcessesPage : Page
     {
         AgentClient? client = null;
 
-        public ObservableCollection<ProcessInfo> processes { get; } = new();
+        public ObservableCollection<ProcessInfo> processes { get; }
 
-        private Collection<ProcessInfo> allProcesses { get; } = new();
+        private Collection<ProcessInfo> allProcesses { get; }
+
+        // track initialization to avoid re-running when page is cached
+        private bool _initialized = false;
+        private Guid? _lastEndpointId;
+
+        // Cancellation support for initialization
+        private CancellationTokenSource? _initCts;
 
         public ProcessesPage()
         {
+            // enable page caching so SelectorBar can reuse cached pages
+            this.NavigationCacheMode = NavigationCacheMode.Enabled;
+
+            processes = new ObservableCollection<ProcessInfo>();
+            allProcesses = new Collection<ProcessInfo>();
+
             InitializeComponent();
         }
 
@@ -46,8 +60,55 @@ protected override void OnNavigatedTo(NavigationEventArgs e)
         {
             base.OnNavigatedTo(e);
 
-            // Fire-and-forget; exceptions observed inside the task
-            _ = InitializeAsync(e);
+            // Expect an AgentEndpoint parameter
+            if (e.Parameter is not AgentEndpoint endpoint)
+            {
+                _ = ShowErrorInfoBarAsync("Invalid navigation parameter; expected AgentEndpoint.");
+                return;
+            }
+
+            bool shouldInit = !_initialized || _lastEndpointId != endpoint.Id;
+
+            // Cancel any previous initialization
+            _initCts?.Cancel();
+            _initCts?.Dispose();
+            _initCts = new CancellationTokenSource();
+            CancellationToken ct = _initCts.Token;
+
+            // Resolve client from registry (parent is expected to have created/registered it)
+            _ = ResolveClientAndMaybeInitAsync(endpoint, shouldInit, ct);
+        }
+
+        protected override void OnNavigatedFrom(NavigationEventArgs e)
+        {
+            base.OnNavigatedFrom(e);
+
+            // Cancel any in-progress initialization when leaving the page
+            _initCts?.Cancel();
+            _initCts?.Dispose();
+            _initCts = null;
+        }
+
+        private async Task ResolveClientAndMaybeInitAsync(AgentEndpoint endpoint, bool shouldInit, CancellationToken ct)
+        {
+            try
+            {
+                var registry = App.Services.GetRequiredService<IAgentClientRegistry>();
+                client = await registry.GetAsync(endpoint.Id).ConfigureAwait(false);
+
+                if (shouldInit)
+                {
+                    await InitializeAsync(endpoint, ct).ConfigureAwait(false);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                // ignore
+            }
+            catch (Exception ex)
+            {
+                await ShowErrorInfoBarAsync($"Failed to resolve AgentClient: {ex.Message}");
+            }
         }
 
         private void OnFilterChanged(object sender, RoutedEventArgs args)
@@ -91,7 +152,8 @@ private void AddBack_Processes(IEnumerable<ProcessInfo> filteredData)
         private async void RefreshButton_Click(object sender, RoutedEventArgs e)
         {
             await ClearAllProcesses();
-            await LoadAllProcesses();
+            // Refresh is user-initiated; use non-cancellable token
+            await LoadAllProcesses(CancellationToken.None);
         }
 
         private void ProcessStartMenuItem_Click(object sender, RoutedEventArgs e)
@@ -115,7 +177,8 @@ private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
             if (result == ContentDialogResult.Primary)
             {
                 // Kill the Process
-            } else
+            }
+            else
             {
                 // Cancel, do nothing
             }
@@ -126,24 +189,41 @@ private void ProcessRestartMenuItem_Click(object sender, RoutedEventArgs e)
             // TODO: implement process restart
         }
 
-        private async Task InitializeAsync(NavigationEventArgs e)
+        private async Task InitializeAsync(AgentEndpoint endpoint, CancellationToken ct)
         {
             try
             {
-                // Determine the AgentClient to use based on navigation parameter
+                await DispatcherQueue.EnqueueAsync(() => LoadingProgressRing.IsActive = true);
 
-                if (e.Parameter is AgentClient passedClient)
+                // Clear previous state
+                await ClearAllProcesses();
+
+                // If client isn't resolved yet, try to get it now (parent should have registered it)
+                if (client is null)
                 {
-                    client = passedClient;
+                    IAgentClientRegistry registry = App.Services.GetRequiredService<IAgentClientRegistry>();
+                    client = await registry.GetAsync(endpoint.Id).ConfigureAwait(false);
                 }
-                else if (e.Parameter is AgentEndpoint endpoint)
+
+                if (client is null)
                 {
-                    // Try to obtain an existing registered client only.
-                    IAgentClientRegistry clientRegistry = App.Services.GetRequiredService<IAgentClientRegistry>();
-                    client = await clientRegistry.GetAsync(endpoint.Id).ConfigureAwait(false);
+                    await ShowErrorInfoBarAsync("No AgentClient available for this server.");
+                    return;
                 }
 
-                await LoadAllProcesses();
+                ct.ThrowIfCancellationRequested();
+
+                // Load processes using resolved client
+                await LoadAllProcesses(ct);
+
+                // remember endpoint id when initialization successful
+                _lastEndpointId = endpoint.Id;
+
+                _initialized = true;
+            }
+            catch (OperationCanceledException)
+            {
+                // initialization was cancelled
             }
             catch (Exception ex)
             {
@@ -160,6 +240,12 @@ await DispatcherQueue.EnqueueAsync(() =>
                         NumThreads = 0
                     });
                 }).ConfigureAwait(false);
+
+                await ShowErrorInfoBarAsync($"Initialization failed: {ex.Message}");
+            }
+            finally
+            {
+                await DispatcherQueue.EnqueueAsync(() => LoadingProgressRing.IsActive = false);
             }
         }
 
@@ -172,39 +258,53 @@ await DispatcherQueue.EnqueueAsync(() =>
             });
         }
 
-        private async Task LoadAllProcesses()
+        private async Task LoadAllProcesses(CancellationToken ct)
         {
             if (client is null || client.Service is null)
             {
                 await ShowErrorInfoBarAsync("No valid AgentClient available.");
                 return;
             }
-            GetSystemResourcesResponse? response = await client.Resources.GetSystemResourcesAsync(new GetSystemResourcesRequest());
+
+            ct.ThrowIfCancellationRequested();
+
+            GetSystemResourcesResponse? response;
+            try
+            {
+                response = await client.Resources.GetSystemResourcesAsync(request: new GetSystemResourcesRequest(), cancellationToken: ct).ConfigureAwait(false);
+            }
+            catch (RpcException rpcEx) when (rpcEx.StatusCode == StatusCode.Cancelled || ct.IsCancellationRequested)
+            {
+                // treated as cancellation
+                return;
+            }
+
             if (response is null)
             {
                 throw new InvalidOperationException("Received null response from ActionAsync");
             }
+
             foreach (Process? process in response.Resources.Processes)
             {
-                SolidColorBrush brush = process.State switch
-                {
-                    ProcessState.Unspecified => (SolidColorBrush)Application.Current.Resources["SystemFillColorNeutralBrush"],
-                    ProcessState.Running => (SolidColorBrush)Application.Current.Resources["SystemFillColorAttentionBrush"],
-                    ProcessState.Sleeping => (SolidColorBrush)Application.Current.Resources["SystemFillColorCautionBrush"],
-                    ProcessState.Stopped => (SolidColorBrush)Application.Current.Resources["SystemFillColorCriticalBrush"],
-                    _ => (SolidColorBrush)Application.Current.Resources["SystemFillColorCriticalBackgroundBrush"],
-                };
-                ProcessInfo processInfo = new()
-                {
-                    Fill = brush,
-                    ProcessId = (int)process.Pid,
-                    ProcessName = process.Name,
-                    State = process.State,
-                    Uptime = process.Utime,
-                    NumThreads = (int)process.NumThreads
-                };
                 await DispatcherQueue.EnqueueAsync(() =>
                 {
+                    SolidColorBrush brush = process.State switch
+                    {
+                        ProcessState.Unspecified => (SolidColorBrush)Application.Current.Resources["SystemFillColorNeutralBrush"],
+                        ProcessState.Running => (SolidColorBrush)Application.Current.Resources["SystemFillColorAttentionBrush"],
+                        ProcessState.Sleeping => (SolidColorBrush)Application.Current.Resources["SystemFillColorCautionBrush"],
+                        ProcessState.Stopped => (SolidColorBrush)Application.Current.Resources["SystemFillColorCriticalBrush"],
+                        _ => (SolidColorBrush)Application.Current.Resources["SystemFillColorCriticalBackgroundBrush"],
+                    };
+                    ProcessInfo processInfo = new()
+                    {
+                        Fill = brush,
+                        ProcessId = (int)process.Pid,
+                        ProcessName = process.Name,
+                        State = process.State,
+                        Uptime = process.Utime,
+                        NumThreads = (int)process.NumThreads
+                    };
                     allProcesses.Add(processInfo);
                     processes.Add(processInfo);
                 });
@@ -250,7 +350,7 @@ private void Order_services()
                 processes.Add(process);
             }
         }
-        
+
         private async Task ShowInfoBarAsync(string title, string message, InfoBarSeverity severity)
         {
             // Ensure UI thread
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml.cs
index 0b0d243..5a31442 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml.cs
@@ -32,7 +32,6 @@ public sealed partial class ServicesPage : Page
 
         private Collection<ServiceInfo> allServices { get; }
 
-        // Add fields
         private bool _initialized;
         private Guid? _lastEndpointId;
         private System.Threading.CancellationTokenSource? _initCts;

From 9bc61060aaa7e05fede79f869aeaac4dff0c6a07 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Fri, 9 Jan 2026 09:40:03 +0100
Subject: [PATCH 06/14] refactor: switch to Resources gRPC V2 and add new proto
 definitions

Updated AgentClient to use Resources.V2. Added new resources.proto for V2 with expanded system resource and process management messages. Updated project file to generate gRPC client code for V2 while retaining V1 for compatibility.
---
 .../Models/AgentClient.cs                     |   2 +-
 .../Protos/Resources/V2/resources.proto       | 117 ++++++++++++++++++
 .../paradigm-ehb.CommandCenter.Core.csproj    |   1 +
 3 files changed, 119 insertions(+), 1 deletion(-)
 create mode 100644 src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto

diff --git a/src/paradigm-ehb.CommandCenter.Core/Models/AgentClient.cs b/src/paradigm-ehb.CommandCenter.Core/Models/AgentClient.cs
index 8501f61..0f90b20 100644
--- a/src/paradigm-ehb.CommandCenter.Core/Models/AgentClient.cs
+++ b/src/paradigm-ehb.CommandCenter.Core/Models/AgentClient.cs
@@ -4,7 +4,7 @@
 using paradigm_ehb.CommandCenter.Core.Services;
 using Journal.V1;
 using Services.V2;
-using Resources.V1;
+using Resources.V2;
 
 namespace paradigm_ehb.CommandCenter.Core.Models
 {
diff --git a/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto b/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
new file mode 100644
index 0000000..151bf01
--- /dev/null
+++ b/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
@@ -0,0 +1,117 @@
+syntax = "proto3";
+
+package resources.v2;
+
+service ResourcesService {
+    rpc GetSystemResources(GetSystemResourcesRequest)
+        returns (GetSystemResourcesResponse);
+    rpc killProcess(KillProcessRequest)
+        returns (KillProcessReply);
+}
+
+message GetSystemResourcesRequest {}
+
+message GetSystemResourcesResponse {
+    SystemResources resources = 1;
+}
+
+message KillProcessRequest {
+    uint32 pid = 1;
+}
+
+message KillProcessReply {
+    bool succes = 1;
+}
+
+/**
+ *
+ * Get a complete system snapshots
+ * @return Cpu, Memory, Device, Disk ( partitions ) and processes
+ *
+ * */
+message SystemResources {
+    Cpu cpu = 1;
+    Memory memory = 2;
+    Device device = 3;
+    repeated Disk disks = 4;
+    repeated Process processes = 5;
+}
+
+/**
+ * Cpu information
+ *
+ * @return vendor, model, frequency, cores
+ * */
+message Cpu {
+    string vendor = 1;
+    string model = 2;
+    string frequency = 3;
+    uint32 max_core = 4;
+}
+
+/**
+ * Memory
+ * @return total memory on system, available memory on system 
+ * */
+message Memory {
+    string total = 1;
+    string free = 2;
+}
+
+/**
+ * Device specific information
+ * @return os version ( distro information ), and uptime in string format
+ *
+ * */
+
+message Device {
+    string os_version = 1;
+    string uptime = 2;
+}
+
+/**
+ *
+ * Disk information
+ * @disk a list of all available partitions
+ *
+ * */
+
+message Disk {
+    repeated DiskPartition partitions = 1;
+}
+
+/**
+ * Partition
+ * @return partition name, major, minor, blocks
+ * */
+message DiskPartition {
+    string name = 1;
+    uint32 major = 2;
+    uint32 minor = 3;
+    uint64 blocks = 4;
+}
+
+enum ProcessState {
+    PROCESS_STATE_UNSPECIFIED = 0;
+    PROCESS_STATE_RUNNING = 1;
+    PROCESS_STATE_SLEEPING = 2;
+    PROCESS_STATE_DISK_SLEEPING = 3;
+    PROCESS_STATE_STOPPED = 4;
+    PROCESS_STATE_TRACING_STOPPED = 5;
+    PROCESS_STATE_ZOMBIE = 6;
+    PROCESS_STATE_DEAD = 7;
+    PROCESS_STATE_IDLE = 8;
+    PROCESS_STATE_UNDEFINED = 9;
+}
+
+/**
+ * Process information
+ * @return pid ( process identifier ), process name, the state, todo :)
+ * */
+message Process {
+    int32 pid = 1;
+    string name = 2;
+    ProcessState state = 3;
+    uint64 utime = 4;
+    uint32 num_threads = 5;
+}
diff --git a/src/paradigm-ehb.CommandCenter.Core/paradigm-ehb.CommandCenter.Core.csproj b/src/paradigm-ehb.CommandCenter.Core/paradigm-ehb.CommandCenter.Core.csproj
index 9c527a5..c8ca271 100644
--- a/src/paradigm-ehb.CommandCenter.Core/paradigm-ehb.CommandCenter.Core.csproj
+++ b/src/paradigm-ehb.CommandCenter.Core/paradigm-ehb.CommandCenter.Core.csproj
@@ -26,6 +26,7 @@
 		<Protobuf Include="Protos\Health\V1\health.proto" GrpcServices="Client" />
 		<Protobuf Include="Protos\Journal\V1\journal.proto" GrpcServices="Client" />
 		<Protobuf Include="Protos\Resources\V1\resources.proto" GrpcServices="Client" />
+		<Protobuf Include="Protos\Resources\V2\resources.proto" GrpcServices="Client" />
 		<Protobuf Include="Protos\Services\V1\services.proto" GrpcServices="Client" />
 		<Protobuf Include="Protos\Services\V2\services.proto" GrpcServices="Client" />
 	</ItemGroup>

From 0e5b65cd906993cb85dd0200b58b2c14bc33708c Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Fri, 9 Jan 2026 09:55:56 +0100
Subject: [PATCH 07/14] feat: update to Resources.V2 and improve process kill
 logic

- Switch gRPC resource usage from Resources.V1 to Resources.V2.
- Change KillProcessRequest.pid from uint32 to int32 in proto.
- Implement process kill operation with error handling and user feedback in ProcessesPage.xaml.cs.
- Show process name in kill confirmation dialog.
- Assign ProcessId directly from int Pid field.
---
 .../Factories/AgentClientFactory.cs           |  2 +-
 .../Protos/Resources/V2/resources.proto       |  2 +-
 .../srvMgnt/Views/ProcessesPage.xaml.cs       | 39 +++++++++++++++++--
 3 files changed, 37 insertions(+), 6 deletions(-)

diff --git a/src/paradigm-ehb.CommandCenter.Core/Factories/AgentClientFactory.cs b/src/paradigm-ehb.CommandCenter.Core/Factories/AgentClientFactory.cs
index b191440..4687113 100644
--- a/src/paradigm-ehb.CommandCenter.Core/Factories/AgentClientFactory.cs
+++ b/src/paradigm-ehb.CommandCenter.Core/Factories/AgentClientFactory.cs
@@ -10,7 +10,7 @@
 using paradigm_ehb.CommandCenter.Core.Interfaces;
 using paradigm_ehb.CommandCenter.Core.Models;
 using paradigm_ehb.CommandCenter.Core.Services;
-using Resources.V1;
+using Resources.V2;
 using Services.V2;
 
 namespace paradigm_ehb.CommandCenter.Core.Factories
diff --git a/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto b/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
index 151bf01..b3cba34 100644
--- a/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
+++ b/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
@@ -16,7 +16,7 @@ message GetSystemResourcesResponse {
 }
 
 message KillProcessRequest {
-    uint32 pid = 1;
+    int32 pid = 1;
 }
 
 message KillProcessReply {
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
index 9e64570..8540402 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
@@ -1,5 +1,4 @@
 using Grpc.Core;
-using Resources.V1;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
@@ -21,6 +20,7 @@
 using Windows.Foundation;
 using Windows.Foundation.Collections;
 using Windows.ApplicationModel.VoiceCommands;
+using Resources.V2;
 
 // To learn more about WinUI, the WinUI project structure,
 // and more about our project templates, see: http://aka.ms/winui-project-info.
@@ -163,11 +163,20 @@ private void ProcessStartMenuItem_Click(object sender, RoutedEventArgs e)
 
         private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
         {
+            MenuFlyoutItem? menuFlyoutItem = sender as MenuFlyoutItem;
+            ProcessInfo? processInfo = menuFlyoutItem?.DataContext as ProcessInfo;
+
+            if (processInfo is null)
+            {
+                await ShowErrorInfoBarAsync("No process selected to kill.");
+                return;
+            }
+
             // TODO: implement process kill
             ContentDialog dialog = new()
             {
                 XamlRoot = this.XamlRoot,
-                Title = "Are you sure you want to Kill this process?",
+                Title = $"Are you sure you want to Kill {processInfo.ProcessName}?",
                 CloseButtonText = "Cancel",
                 PrimaryButtonText = "Kill",
             };
@@ -176,7 +185,29 @@ private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
 
             if (result == ContentDialogResult.Primary)
             {
-                // Kill the Process
+                try
+                {
+                    KillProcessReply killResult = await client!.Resources.killProcessAsync(new KillProcessRequest
+                    {
+                        Pid = processInfo.ProcessId
+                    });
+
+                    if (killResult.Succes)
+                    {
+                        await ShowInfoBarAsync("Process Killed", $"Process {processInfo.ProcessName} (PID {processInfo.ProcessId}) was killed successfully.", InfoBarSeverity.Success);
+                        await ClearAllProcesses();
+                        await LoadAllProcesses(CancellationToken.None);
+                    }
+                    else
+                    {
+                        await ShowErrorInfoBarAsync($"Failed to kill process {processInfo.ProcessName} (PID {processInfo.ProcessId})!");
+                    }
+
+                }
+                catch (Exception ex)
+                {
+                    await ShowErrorInfoBarAsync($"Error killing process: {ex.Message}");
+                }
             }
             else
             {
@@ -299,7 +330,7 @@ await DispatcherQueue.EnqueueAsync(() =>
                     ProcessInfo processInfo = new()
                     {
                         Fill = brush,
-                        ProcessId = (int)process.Pid,
+                        ProcessId = process.Pid,
                         ProcessName = process.Name,
                         State = process.State,
                         Uptime = process.Utime,

From 66158b2565cd05b55aa943c32dd2f606b167171e Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Fri, 9 Jan 2026 10:21:24 +0100
Subject: [PATCH 08/14] Improve process UI: update state in place, add error
 info

Refactored process kill handling to update the affected process's visual state directly, avoiding unnecessary reloads. Introduced UpdateProcessVisualStateAsync to change process color and status based on actions. Added general exception handling to process loading with user feedback on errors.
---
 .../srvMgnt/Views/ProcessesPage.xaml.cs       | 32 +++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
index 8540402..5744bc6 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
@@ -195,8 +195,7 @@ private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
                     if (killResult.Succes)
                     {
                         await ShowInfoBarAsync("Process Killed", $"Process {processInfo.ProcessName} (PID {processInfo.ProcessId}) was killed successfully.", InfoBarSeverity.Success);
-                        await ClearAllProcesses();
-                        await LoadAllProcesses(CancellationToken.None);
+                        await UpdateProcessVisualStateAsync(processInfo, "killed");
                     }
                     else
                     {
@@ -309,6 +308,11 @@ private async Task LoadAllProcesses(CancellationToken ct)
                 // treated as cancellation
                 return;
             }
+            catch (Exception ex)
+            {
+                await ShowErrorInfoBarAsync($"Failed to load processes: {ex.Message}");
+                return;
+            }
 
             if (response is null)
             {
@@ -381,6 +385,30 @@ private void Order_services()
                 processes.Add(process);
             }
         }
+        private async Task UpdateProcessVisualStateAsync(ProcessInfo processInfo, string action)
+        {
+            await DispatcherQueue.EnqueueAsync(() =>
+            {
+                ProcessState state = action switch
+                {
+                    "started" => ProcessState.Running,
+                    "killed" => ProcessState.Stopped,
+                    "restarted" => ProcessState.Running,
+                    _ => processInfo.State
+                };
+
+                SolidColorBrush brush = action switch
+                {
+                    "started" => (SolidColorBrush)Application.Current.Resources["SystemFillColorAttentionBrush"],
+                    "killed" => (SolidColorBrush)Application.Current.Resources["SystemFillColorCriticalBrush"],
+                    "restarted" => (SolidColorBrush)Application.Current.Resources["SystemFillColorCautionBrush"],
+                    _ => processInfo.Fill
+                };
+
+                processInfo.Fill = brush;
+                processInfo.State = state;
+            });
+        }
 
         private async Task ShowInfoBarAsync(string title, string message, InfoBarSeverity severity)
         {

From b7724a1ab91f01160a8d7457a6c172129b99f0c8 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Fri, 9 Jan 2026 11:38:10 +0100
Subject: [PATCH 09/14] Remove "Start" option from process context menu

Removed the "Start" menu item from the process context menu in ProcessesPage and deleted its unused event handler. Users can no longer attempt to start a process from the context menu.
---
 .../srvMgnt/Views/ProcessesPage.xaml                          | 1 -
 .../srvMgnt/Views/ProcessesPage.xaml.cs                       | 4 ----
 2 files changed, 5 deletions(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
index 7919c7d..131f12c 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
@@ -58,7 +58,6 @@
                     <Grid>
                         <Grid.ContextFlyout>
                             <MenuFlyout>
-                                <MenuFlyoutItem Text="Start" Click="ProcessStartMenuItem_Click" />
                                 <MenuFlyoutItem Text="Kill" Click="ProcessKillMenuItem_Click" />
                                 <MenuFlyoutItem Text="Restart" Click="ProcessRestartMenuItem_Click" />
                             </MenuFlyout>
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
index 5744bc6..091f9a0 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
@@ -156,10 +156,6 @@ private async void RefreshButton_Click(object sender, RoutedEventArgs e)
             await LoadAllProcesses(CancellationToken.None);
         }
 
-        private void ProcessStartMenuItem_Click(object sender, RoutedEventArgs e)
-        {
-            // TODO: implement process start
-        }
 
         private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
         {

From 332563d983f17bc64a574b60532d89af7973ad39 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Fri, 9 Jan 2026 14:15:34 +0100
Subject: [PATCH 10/14] Update Processes tab icon to 'Component'

Changed the icon for the "Processes" SelectorBarItem from "Favorite" to "Component" in ServerMainPage.xaml for improved clarity and consistency.
---
 .../srvMgnt/ServerMainPage.xaml                                 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml
index 94b8ea1..da5b205 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml
@@ -49,7 +49,7 @@
                 <SelectorBarItem x:Name="SelectorBarItemServices" 
                      Text="Services" Icon="AllApps"/>
                 <SelectorBarItem x:Name="SelectorBarItemProcesses" 
-                     Text="Processes" Icon="Favorite"/>
+                     Text="Processes" Icon="Component"/>
             </SelectorBar>
         </StackPanel>
 

From 5ace5383184144c5ccf0529e9a013d000bf918df Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Fri, 9 Jan 2026 15:05:55 +0100
Subject: [PATCH 11/14] Refactor process actions API and enhance process UI

- Replace killProcess RPC with generic ProcessAction RPC (pid + sig)
- Add Terminate, Kill, Reload, Pause, Resume, Call actions to process UI
- Implement new handlers in ProcessesPage.xaml.cs for each action, mapping to Unix signals
- Improve user feedback with dialogs and info bars
- Change Processes selector icon to "ViewAll"
- Improve error handling and code clarity throughout
---
 .../Protos/Resources/V2/resources.proto       |   9 +-
 .../srvMgnt/ServerMainPage.xaml               |   2 +-
 .../srvMgnt/Views/ProcessesPage.xaml          |  17 +-
 .../srvMgnt/Views/ProcessesPage.xaml.cs       | 249 +++++++++++++++++-
 4 files changed, 261 insertions(+), 16 deletions(-)

diff --git a/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto b/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
index b3cba34..bee286a 100644
--- a/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
+++ b/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
@@ -5,8 +5,8 @@ package resources.v2;
 service ResourcesService {
     rpc GetSystemResources(GetSystemResourcesRequest)
         returns (GetSystemResourcesResponse);
-    rpc killProcess(KillProcessRequest)
-        returns (KillProcessReply);
+    rpc ProcessAction(ProcessActionRequest)
+        returns (ProcessActionReply);
 }
 
 message GetSystemResourcesRequest {}
@@ -15,11 +15,12 @@ message GetSystemResourcesResponse {
     SystemResources resources = 1;
 }
 
-message KillProcessRequest {
+message ProcessActionRequest {
     int32 pid = 1;
+    int32 sig = 2;
 }
 
-message KillProcessReply {
+message ProcessActionReply {
     bool succes = 1;
 }
 
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml
index da5b205..cb5fb04 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/ServerMainPage.xaml
@@ -49,7 +49,7 @@
                 <SelectorBarItem x:Name="SelectorBarItemServices" 
                      Text="Services" Icon="AllApps"/>
                 <SelectorBarItem x:Name="SelectorBarItemProcesses" 
-                     Text="Processes" Icon="Component"/>
+                     Text="Processes" Icon="ViewAll"/>
             </SelectorBar>
         </StackPanel>
 
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
index 131f12c..cbc3ec6 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml
@@ -58,8 +58,12 @@
                     <Grid>
                         <Grid.ContextFlyout>
                             <MenuFlyout>
-                                <MenuFlyoutItem Text="Kill" Click="ProcessKillMenuItem_Click" />
-                                <MenuFlyoutItem Text="Restart" Click="ProcessRestartMenuItem_Click" />
+                                <MenuFlyoutItem Text="Terminate" Click="ProcessTerminate_Click" ToolTipService.ToolTip="Graceful Process Termination" />
+                                <MenuFlyoutItem Text="Kill" Click="ProcessKill_Click" ToolTipService.ToolTip="Forceful Process Kill" />
+                                <MenuFlyoutItem Text="Reload" Click="ProcessReload_Click" ToolTipService.ToolTip="Reload Process Configuration" />
+                                <MenuFlyoutItem Text="Pause" Click="ProcessPause_Click" ToolTipService.ToolTip="Pause Process Execution" />
+                                <MenuFlyoutItem Text="Resume" Click="ProcessResume_Click" ToolTipService.ToolTip="Resume Process Execution if Paused" />
+                                <MenuFlyoutItem Text="Call" Click="ProcessCall_Click" ToolTipService.ToolTip="Invoke Process-Specific Action" />
                             </MenuFlyout>
                         </Grid.ContextFlyout>
 
@@ -106,9 +110,12 @@
                         <DropDownButton Content="Actions" Grid.Column="2" VerticalAlignment="Center">
                             <DropDownButton.Flyout>
                                 <MenuFlyout Placement="Bottom">
-                                    <MenuFlyoutItem Text="Start" Click="ProcessStartMenuItem_Click" />
-                                    <MenuFlyoutItem Text="Kill" Click="ProcessKillMenuItem_Click" />
-                                    <MenuFlyoutItem Text="Restart" Click="ProcessRestartMenuItem_Click" />
+                                    <MenuFlyoutItem Text="Terminate" Click="ProcessTerminate_Click" ToolTipService.ToolTip="Graceful Process Termination" />
+                                    <MenuFlyoutItem Text="Kill" Click="ProcessKill_Click" ToolTipService.ToolTip="Forceful Process Kill" />
+                                    <MenuFlyoutItem Text="Reload" Click="ProcessReload_Click" ToolTipService.ToolTip="Reload Process Configuration" />
+                                    <MenuFlyoutItem Text="Pause" Click="ProcessPause_Click" ToolTipService.ToolTip="Pause Process Execution" />
+                                    <MenuFlyoutItem Text="Resume" Click="ProcessResume_Click" ToolTipService.ToolTip="Resume Process Execution if Paused" />
+                                    <MenuFlyoutItem Text="Call" Click="ProcessCall_Click" ToolTipService.ToolTip="Invoke Process-Specific Action" />
                                 </MenuFlyout>
                             </DropDownButton.Flyout>
                         </DropDownButton>
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
index 091f9a0..ef6b9f7 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
@@ -21,6 +21,7 @@
 using Windows.Foundation.Collections;
 using Windows.ApplicationModel.VoiceCommands;
 using Resources.V2;
+using System.Runtime.InteropServices.ObjectiveC;
 
 // To learn more about WinUI, the WinUI project structure,
 // and more about our project templates, see: http://aka.ms/winui-project-info.
@@ -156,8 +157,58 @@ private async void RefreshButton_Click(object sender, RoutedEventArgs e)
             await LoadAllProcesses(CancellationToken.None);
         }
 
+        private async void ProcessTerminate_Click(object sender, RoutedEventArgs e)
+        {
+            MenuFlyoutItem? menuFlyoutItem = sender as MenuFlyoutItem;
+            ProcessInfo? processInfo = menuFlyoutItem?.DataContext as ProcessInfo;
+
+            if (processInfo is null)
+            {
+                await ShowErrorInfoBarAsync("No process selected to terminate.");
+                return;
+            }
 
-        private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
+            ContentDialog dialog = new()
+            {
+                XamlRoot = this.XamlRoot,
+                Title = $"Are you sure you want to Terminate {processInfo.ProcessName}?",
+                CloseButtonText = "Cancel",
+                PrimaryButtonText = "Terminate",
+            };
+
+            ContentDialogResult result = await dialog.ShowAsync();
+
+            if (result == ContentDialogResult.Primary)
+            {
+                try
+                {
+                    ProcessActionReply terminateResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
+                    {
+                        Pid = processInfo.ProcessId,
+                        Sig = 15 // SIGTERM
+                    });
+                    if (terminateResult.Succes)
+                    {
+                        await ShowInfoBarAsync("Process Terminated", $"Process {processInfo.ProcessName} (PID {processInfo.ProcessId}) was terminated successfully.", InfoBarSeverity.Success);
+                        await UpdateProcessVisualStateAsync(processInfo, "killed");
+                    }
+                    else
+                    {
+                        await ShowErrorInfoBarAsync($"Failed to terminate process {processInfo.ProcessName} (PID {processInfo.ProcessId})!");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    await ShowErrorInfoBarAsync($"Error terminating process: {ex.Message}");
+                }
+            }
+            else
+            {
+                // Cancel, do nothing
+            }
+        }
+
+        private async void ProcessKill_Click(object sender, RoutedEventArgs e)
         {
             MenuFlyoutItem? menuFlyoutItem = sender as MenuFlyoutItem;
             ProcessInfo? processInfo = menuFlyoutItem?.DataContext as ProcessInfo;
@@ -168,7 +219,6 @@ private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
                 return;
             }
 
-            // TODO: implement process kill
             ContentDialog dialog = new()
             {
                 XamlRoot = this.XamlRoot,
@@ -183,9 +233,10 @@ private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
             {
                 try
                 {
-                    KillProcessReply killResult = await client!.Resources.killProcessAsync(new KillProcessRequest
+                    ProcessActionReply killResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
                     {
-                        Pid = processInfo.ProcessId
+                        Pid = processInfo.ProcessId,
+                        Sig = 9 // SIGKILL
                     });
 
                     if (killResult.Succes)
@@ -210,9 +261,195 @@ private async void ProcessKillMenuItem_Click(object sender, RoutedEventArgs e)
             }
         }
 
-        private void ProcessRestartMenuItem_Click(object sender, RoutedEventArgs e)
+        private async void ProcessReload_Click(object sender, RoutedEventArgs e)
+        {
+            MenuFlyoutItem? menuFlyoutItem = sender as MenuFlyoutItem;
+            ProcessInfo? processInfo = menuFlyoutItem?.DataContext as ProcessInfo;
+
+            if (processInfo is null)
+            {
+                await ShowErrorInfoBarAsync("No process selected to restart.");
+                return;
+            }
+
+            ContentDialog dialog = new()
+            {
+                XamlRoot = this.XamlRoot,
+                Title = $"Are you sure you want to Restart {processInfo.ProcessName}?",
+                CloseButtonText = "Cancel",
+                PrimaryButtonText = "Restart",
+            };
+
+            ContentDialogResult result = await dialog.ShowAsync();
+
+            if (result == ContentDialogResult.Primary)
+            {
+                try
+                {
+                    ProcessActionReply restartResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
+                    {
+                        Pid = processInfo.ProcessId,
+                        Sig = 1
+                    });
+                    if (restartResult.Succes)
+                    {
+                        await ShowInfoBarAsync("Process Restarted", $"Process {processInfo.ProcessName} (PID {processInfo.ProcessId}) was restarted successfully.", InfoBarSeverity.Success);
+                        await UpdateProcessVisualStateAsync(processInfo, "restarted");
+                    }
+                    else
+                    {
+                        await ShowErrorInfoBarAsync($"Failed to restart process {processInfo.ProcessName} (PID {processInfo.ProcessId})!");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    await ShowErrorInfoBarAsync($"Error restarting process: {ex.Message}");
+                }
+            }
+            else
+            {
+                // Cancel, do nothing
+            }
+        }
+
+        private async void ProcessPause_Click(object sender, RoutedEventArgs args)
+        {
+            MenuFlyoutItem? menuFlyoutItem = sender as MenuFlyoutItem;
+            ProcessInfo? processInfo = menuFlyoutItem?.DataContext as ProcessInfo;
+            if (processInfo is null)
+            {
+                await ShowErrorInfoBarAsync("No process selected to pause.");
+                return;
+            }
+            ContentDialog dialog = new()
+            {
+                XamlRoot = this.XamlRoot,
+                Title = $"Are you sure you want to Pause {processInfo.ProcessName}?",
+                CloseButtonText = "Cancel",
+                PrimaryButtonText = "Pause",
+            };
+            ContentDialogResult result = await dialog.ShowAsync();
+            if (result == ContentDialogResult.Primary)
+            {
+                try
+                {
+                    ProcessActionReply pauseResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
+                    {
+                        Pid = processInfo.ProcessId,
+                        Sig = 19 // SIGSTOP
+                    });
+                    if (pauseResult.Succes)
+                    {
+                        await ShowInfoBarAsync("Process Paused", $"Process {processInfo.ProcessName} (PID {processInfo.ProcessId}) was paused successfully.", InfoBarSeverity.Success);
+                        await UpdateProcessVisualStateAsync(processInfo, "paused");
+                    }
+                    else
+                    {
+                        await ShowErrorInfoBarAsync($"Failed to pause process {processInfo.ProcessName} (PID {processInfo.ProcessId})!");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    await ShowErrorInfoBarAsync($"Error pausing process: {ex.Message}");
+                }
+            }
+            else
+            {
+                // Cancel, do nothing
+            }
+        }
+
+        private async void ProcessResume_Click(object sender, RoutedEventArgs args)
+        {
+            MenuFlyoutItem? menuFlyoutItem = sender as MenuFlyoutItem;
+            ProcessInfo? processInfo = menuFlyoutItem?.DataContext as ProcessInfo;
+            if (processInfo is null)
+            {
+                await ShowErrorInfoBarAsync("No process selected to resume.");
+                return;
+            }
+            ContentDialog dialog = new()
+            {
+                XamlRoot = this.XamlRoot,
+                Title = $"Are you sure you want to Resume {processInfo.ProcessName}?",
+                CloseButtonText = "Cancel",
+                PrimaryButtonText = "Resume",
+            };
+            ContentDialogResult result = await dialog.ShowAsync();
+            if (result == ContentDialogResult.Primary)
+            {
+                try
+                {
+                    ProcessActionReply resumeResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
+                    {
+                        Pid = processInfo.ProcessId,
+                        Sig = 18 // SIGCONT
+                    });
+                    if (resumeResult.Succes)
+                    {
+                        await ShowInfoBarAsync("Process Resumed", $"Process {processInfo.ProcessName} (PID {processInfo.ProcessId}) was resumed successfully.", InfoBarSeverity.Success);
+                        await UpdateProcessVisualStateAsync(processInfo, "resumed");
+                    }
+                    else
+                    {
+                        await ShowErrorInfoBarAsync($"Failed to resume process {processInfo.ProcessName} (PID {processInfo.ProcessId})!");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    await ShowErrorInfoBarAsync($"Error resuming process: {ex.Message}");
+                }
+            }
+            else
+            {
+                // Cancel, do nothing
+            }
+        }
+
+        private async void ProcessCall_Click(object sender, RoutedEventArgs args)
         {
-            // TODO: implement process restart
+            MenuFlyoutItem? menuFlyoutItem = sender as MenuFlyoutItem;
+            ProcessInfo? processInfo = menuFlyoutItem?.DataContext as ProcessInfo;
+            if (processInfo is null)
+            {
+                await ShowErrorInfoBarAsync("No process selected to call.");
+                return;
+            }
+            ContentDialog dialog = new()
+            {
+                XamlRoot = this.XamlRoot,
+                Title = $"Are you sure you want to Call {processInfo.ProcessName}?",
+                CloseButtonText = "Cancel",
+                PrimaryButtonText = "Call",
+            };
+            ContentDialogResult result = await dialog.ShowAsync();
+            if (result == ContentDialogResult.Primary)
+            {
+                try
+                {
+                    ProcessActionReply callResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
+                    {
+                        Pid = processInfo.ProcessId,
+                        Sig = 10 // SIGUSR1
+                    });
+                    if (callResult.Succes)
+                    {
+                        await ShowInfoBarAsync("Process Called", $"Process {processInfo.ProcessName} (PID {processInfo.ProcessId}) was called successfully.", InfoBarSeverity.Success);
+                    }
+                    else
+                    {
+                        await ShowErrorInfoBarAsync($"Failed to call process {processInfo.ProcessName} (PID {processInfo.ProcessId})!");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    await ShowErrorInfoBarAsync($"Error calling process: {ex.Message}");
+                }
+            }
+            else
+            {
+                // Cancel, do nothing
+            }
         }
 
         private async Task InitializeAsync(AgentEndpoint endpoint, CancellationToken ct)

From 0af8d4a61e0e2e5a3ab82e4ca4c783072f1d0dd5 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Mon, 12 Jan 2026 10:34:35 +0100
Subject: [PATCH 12/14] Update to gRPC Services V3; add unit management
 features

Switched codebase references from Services.V2 to Services.V3.
Added new services.proto (V3) with HandlerService for unit actions and queries.
Updated resources.proto: added CPU metrics, renamed ProcessActionRequest field, improved formatting.
Registered V3 proto in project for gRPC client generation.
Enhances system unit management and resource reporting via gRPC.
---
 .../Factories/AgentClientFactory.cs           |   2 +-
 .../Models/AgentClient.cs                     |   2 +-
 .../Protos/Resources/V2/resources.proto       |  97 +++++++-------
 .../Protos/Services/V3/services.proto         | 122 ++++++++++++++++++
 .../paradigm-ehb.CommandCenter.Core.csproj    |   1 +
 5 files changed, 175 insertions(+), 49 deletions(-)
 create mode 100644 src/paradigm-ehb.CommandCenter.Core/Protos/Services/V3/services.proto

diff --git a/src/paradigm-ehb.CommandCenter.Core/Factories/AgentClientFactory.cs b/src/paradigm-ehb.CommandCenter.Core/Factories/AgentClientFactory.cs
index 4687113..9b2ea81 100644
--- a/src/paradigm-ehb.CommandCenter.Core/Factories/AgentClientFactory.cs
+++ b/src/paradigm-ehb.CommandCenter.Core/Factories/AgentClientFactory.cs
@@ -11,7 +11,7 @@
 using paradigm_ehb.CommandCenter.Core.Models;
 using paradigm_ehb.CommandCenter.Core.Services;
 using Resources.V2;
-using Services.V2;
+using Services.V3;
 
 namespace paradigm_ehb.CommandCenter.Core.Factories
 {
diff --git a/src/paradigm-ehb.CommandCenter.Core/Models/AgentClient.cs b/src/paradigm-ehb.CommandCenter.Core/Models/AgentClient.cs
index 0f90b20..f30cf97 100644
--- a/src/paradigm-ehb.CommandCenter.Core/Models/AgentClient.cs
+++ b/src/paradigm-ehb.CommandCenter.Core/Models/AgentClient.cs
@@ -3,7 +3,7 @@
 using System;
 using paradigm_ehb.CommandCenter.Core.Services;
 using Journal.V1;
-using Services.V2;
+using Services.V3;
 using Resources.V2;
 
 namespace paradigm_ehb.CommandCenter.Core.Models
diff --git a/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto b/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
index bee286a..8508ae9 100644
--- a/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
+++ b/src/paradigm-ehb.CommandCenter.Core/Protos/Resources/V2/resources.proto
@@ -2,26 +2,18 @@ syntax = "proto3";
 
 package resources.v2;
 
+
 service ResourcesService {
-    rpc GetSystemResources(GetSystemResourcesRequest)
-        returns (GetSystemResourcesResponse);
-    rpc ProcessAction(ProcessActionRequest)
-        returns (ProcessActionReply);
+  rpc GetSystemResources(GetSystemResourcesRequest)
+      returns (GetSystemResourcesResponse);
+  rpc ProcessAction(ProcessActionRequest)
+    returns (ProcessActionReply);
 }
 
 message GetSystemResourcesRequest {}
 
 message GetSystemResourcesResponse {
-    SystemResources resources = 1;
-}
-
-message ProcessActionRequest {
-    int32 pid = 1;
-    int32 sig = 2;
-}
-
-message ProcessActionReply {
-    bool succes = 1;
+  SystemResources resources = 1;
 }
 
 /**
@@ -31,11 +23,11 @@ message ProcessActionReply {
  *
  * */
 message SystemResources {
-    Cpu cpu = 1;
-    Memory memory = 2;
-    Device device = 3;
-    repeated Disk disks = 4;
-    repeated Process processes = 5;
+  Cpu cpu = 1;
+  Memory memory = 2;
+  Device device = 3;
+  repeated Disk disks = 4;
+  repeated Process processes = 5;
 }
 
 /**
@@ -44,10 +36,12 @@ message SystemResources {
  * @return vendor, model, frequency, cores
  * */
 message Cpu {
-    string vendor = 1;
-    string model = 2;
-    string frequency = 3;
-    uint32 max_core = 4;
+  string vendor = 1;
+  string model = 2;
+  string frequency = 3;
+  uint32 max_core = 4;
+  uint64 total_time = 5;
+  uint64 idle_time = 6;
 }
 
 /**
@@ -55,8 +49,8 @@ message Cpu {
  * @return total memory on system, available memory on system 
  * */
 message Memory {
-    string total = 1;
-    string free = 2;
+  string total = 1;
+  string free = 2;
 }
 
 /**
@@ -66,8 +60,8 @@ message Memory {
  * */
 
 message Device {
-    string os_version = 1;
-    string uptime = 2;
+  string os_version = 1;
+  string uptime = 2;
 }
 
 /**
@@ -78,7 +72,7 @@ message Device {
  * */
 
 message Disk {
-    repeated DiskPartition partitions = 1;
+  repeated DiskPartition partitions = 1;
 }
 
 /**
@@ -86,23 +80,23 @@ message Disk {
  * @return partition name, major, minor, blocks
  * */
 message DiskPartition {
-    string name = 1;
-    uint32 major = 2;
-    uint32 minor = 3;
-    uint64 blocks = 4;
+  string name = 1;
+  uint32 major = 2;
+  uint32 minor = 3;
+  uint64 blocks = 4;
 }
 
 enum ProcessState {
-    PROCESS_STATE_UNSPECIFIED = 0;
-    PROCESS_STATE_RUNNING = 1;
-    PROCESS_STATE_SLEEPING = 2;
-    PROCESS_STATE_DISK_SLEEPING = 3;
-    PROCESS_STATE_STOPPED = 4;
-    PROCESS_STATE_TRACING_STOPPED = 5;
-    PROCESS_STATE_ZOMBIE = 6;
-    PROCESS_STATE_DEAD = 7;
-    PROCESS_STATE_IDLE = 8;
-    PROCESS_STATE_UNDEFINED = 9;
+  PROCESS_STATE_UNSPECIFIED = 0;
+  PROCESS_STATE_RUNNING = 1;
+  PROCESS_STATE_SLEEPING = 2;
+  PROCESS_STATE_DISK_SLEEPING = 3;
+  PROCESS_STATE_STOPPED = 4;
+  PROCESS_STATE_TRACING_STOPPED = 5;
+  PROCESS_STATE_ZOMBIE = 6;
+  PROCESS_STATE_DEAD = 7;
+  PROCESS_STATE_IDLE = 8;
+  PROCESS_STATE_UNDEFINED = 9;
 }
 
 /**
@@ -110,9 +104,18 @@ enum ProcessState {
  * @return pid ( process identifier ), process name, the state, todo :)
  * */
 message Process {
-    int32 pid = 1;
-    string name = 2;
-    ProcessState state = 3;
-    uint64 utime = 4;
-    uint32 num_threads = 5;
+  int32 pid = 1;
+  string name = 2;
+  ProcessState state = 3;
+  uint64 utime = 4;
+  uint32 num_threads = 5;
+}
+
+message ProcessActionRequest {
+  int32 pid = 1;
+  int32 signal = 2;
 }
+
+message ProcessActionReply {
+  bool succes = 1;
+}
\ No newline at end of file
diff --git a/src/paradigm-ehb.CommandCenter.Core/Protos/Services/V3/services.proto b/src/paradigm-ehb.CommandCenter.Core/Protos/Services/V3/services.proto
new file mode 100644
index 0000000..e4822af
--- /dev/null
+++ b/src/paradigm-ehb.CommandCenter.Core/Protos/Services/V3/services.proto
@@ -0,0 +1,122 @@
+syntax = "proto3";
+
+package services.v3;
+
+
+service HandlerService {
+  rpc PerformUnitAction (UnitActionRequest) returns (UnitActionReply);
+  rpc PerformUnitFileAction (UnitFileActionRequest) returns (UnitFileActionReply);
+  rpc GetAllUnits (GetUnitsRequest) returns (GetUnitsReply);
+  rpc GetLoadedUnits (GetUnitsRequest) returns (GetUnitsReply);
+  rpc GetFilteredUnits (GetUnitsFilteredRequest) returns (GetUnitsReply);
+  rpc GetUnitStatus (GetUnitStatusRequest) returns (GetUnitStatusReply);
+}
+
+
+message UnitActionRequest {
+  string unit_name = 1;
+
+ enum UnitAction {
+    UNIT_ACTION_UNSPECIFIED = 0;
+    UNIT_ACTION_START = 1;
+    UNIT_ACTION_STOP = 2;
+    UNIT_ACTION_RESTART = 3;
+  }
+
+  UnitAction action = 2;
+  bool force = 3;
+}
+
+message UnitActionReply {
+  bytes status = 1;
+  bool success = 2;
+  string error_message = 3;
+}
+
+
+message UnitFileActionRequest {
+  string unit_name = 1;
+
+  enum UnitFileAction {
+    UNIT_FILE_ACTION_UNSPECIFIED = 0;
+    UNIT_FILE_ACTION_ENABLE = 1;
+    UNIT_FILE_ACTION_DISABLE = 2;
+  }
+
+  UnitFileAction action = 2;
+  bool runtime = 3;
+  bool force = 4;
+}
+
+message UnitFileActionReply {
+  bytes status = 1;
+  bool success = 2;
+  string error_message = 3;
+}
+
+
+message LoadedUnit {
+  string name = 1;
+  string description = 2;
+  string load_state = 3;
+  string sub_state = 4;
+  string active_state = 5;
+  string dep_unit = 6;
+
+  string object_path = 7;
+
+  uint32 queued_job = 8;
+  string job_type = 9;
+  string job_path = 10;
+}
+
+message Unit {
+  string name = 1;
+  string state = 2;
+}
+
+
+message GetUnitsRequest {
+
+  enum UnitState {
+    UNIT_STATE_UNSPECIFIED = 0;
+    ENABLED = 1;
+    DISABLED = 2;
+  }
+
+  string name = 1;
+  UnitState state = 2;
+}
+
+message GetUnitsFilteredRequest {
+
+  enum UnitFileState {
+
+    UNIT_FILE_STATE_UNSPECIFIED = 0;
+    LOADED = 1;
+    NOT_FOUND = 2;
+    BAD_SETTING = 3;
+    ERROR = 4;
+    MASKED = 5;
+  }
+  
+  repeated UnitFileState filters = 1;
+
+}
+
+message GetUnitsReply {
+  repeated LoadedUnit units = 1;
+  bool success = 2;
+  string error_message = 3;
+}
+
+
+message GetUnitStatusRequest {
+  string unit_name = 1;
+}
+
+message GetUnitStatusReply {
+  string state = 1;
+  bool success = 2;
+  string error_message = 3;
+}
\ No newline at end of file
diff --git a/src/paradigm-ehb.CommandCenter.Core/paradigm-ehb.CommandCenter.Core.csproj b/src/paradigm-ehb.CommandCenter.Core/paradigm-ehb.CommandCenter.Core.csproj
index c8ca271..243b060 100644
--- a/src/paradigm-ehb.CommandCenter.Core/paradigm-ehb.CommandCenter.Core.csproj
+++ b/src/paradigm-ehb.CommandCenter.Core/paradigm-ehb.CommandCenter.Core.csproj
@@ -29,6 +29,7 @@
 		<Protobuf Include="Protos\Resources\V2\resources.proto" GrpcServices="Client" />
 		<Protobuf Include="Protos\Services\V1\services.proto" GrpcServices="Client" />
 		<Protobuf Include="Protos\Services\V2\services.proto" GrpcServices="Client" />
+		<Protobuf Include="Protos\Services\V3\services.proto" GrpcServices="Client" />
 	</ItemGroup>
 
 </Project>

From 6a620a25fb9d87cd002b01734f1f05ee46411f19 Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Mon, 12 Jan 2026 10:42:09 +0100
Subject: [PATCH 13/14] Update ProcessActionRequest property and using
 directives

Replaced 'Sig' with 'Signal' in all ProcessActionRequest usages to match the correct property name. Updated using directives in ServicesPage.xaml.cs to use Resources.V2 and Services.V3, removing older versions.
---
 .../srvMgnt/Views/ProcessesPage.xaml.cs              | 12 ++++++------
 .../srvMgnt/Views/ServicesPage.xaml.cs               |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
index ef6b9f7..90c43b4 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ProcessesPage.xaml.cs
@@ -185,7 +185,7 @@ private async void ProcessTerminate_Click(object sender, RoutedEventArgs e)
                     ProcessActionReply terminateResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
                     {
                         Pid = processInfo.ProcessId,
-                        Sig = 15 // SIGTERM
+                        Signal = 15 // SIGTERM
                     });
                     if (terminateResult.Succes)
                     {
@@ -236,7 +236,7 @@ private async void ProcessKill_Click(object sender, RoutedEventArgs e)
                     ProcessActionReply killResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
                     {
                         Pid = processInfo.ProcessId,
-                        Sig = 9 // SIGKILL
+                        Signal = 9 // SIGKILL
                     });
 
                     if (killResult.Succes)
@@ -289,7 +289,7 @@ private async void ProcessReload_Click(object sender, RoutedEventArgs e)
                     ProcessActionReply restartResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
                     {
                         Pid = processInfo.ProcessId,
-                        Sig = 1
+                        Signal = 1
                     });
                     if (restartResult.Succes)
                     {
@@ -336,7 +336,7 @@ private async void ProcessPause_Click(object sender, RoutedEventArgs args)
                     ProcessActionReply pauseResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
                     {
                         Pid = processInfo.ProcessId,
-                        Sig = 19 // SIGSTOP
+                        Signal = 19 // SIGSTOP
                     });
                     if (pauseResult.Succes)
                     {
@@ -383,7 +383,7 @@ private async void ProcessResume_Click(object sender, RoutedEventArgs args)
                     ProcessActionReply resumeResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
                     {
                         Pid = processInfo.ProcessId,
-                        Sig = 18 // SIGCONT
+                        Signal = 18 // SIGCONT
                     });
                     if (resumeResult.Succes)
                     {
@@ -430,7 +430,7 @@ private async void ProcessCall_Click(object sender, RoutedEventArgs args)
                     ProcessActionReply callResult = await client!.Resources.ProcessActionAsync(new ProcessActionRequest
                     {
                         Pid = processInfo.ProcessId,
-                        Sig = 10 // SIGUSR1
+                        Signal = 10 // SIGUSR1
                     });
                     if (callResult.Succes)
                     {
diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml.cs
index 5a31442..cc40f47 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/ServicesPage.xaml.cs
@@ -9,8 +9,8 @@
 using Microsoft.Windows.AppNotifications.Builder;
 using paradigm_ehb.CommandCenter.Core.Interfaces;
 using paradigm_ehb.CommandCenter.Core.Models;
-using Resources.V1;
-using Services.V2;
+using Resources.V2;
+using Services.V3;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;

From ceb060313bac7048e272bbbb33dfd92ebf09020e Mon Sep 17 00:00:00 2001
From: Hublack <71221641+HublackBE@users.noreply.github.com>
Date: Mon, 12 Jan 2026 10:44:46 +0100
Subject: [PATCH 14/14] Update srvOverview to use Resources.V2 namespace

Replaced the Resources.V1 namespace with Resources.V2 in srvOverview.xaml.cs to reference the latest resource or service definitions. This ensures the code uses updated versions and maintains compatibility with newer APIs.
---
 .../srvMgnt/Views/srvOverview.xaml.cs                           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/srvOverview.xaml.cs b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/srvOverview.xaml.cs
index b0b4507..eab91a0 100644
--- a/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/srvOverview.xaml.cs
+++ b/src/paradigm-ehb.CommandCenter.WinUI/srvMgnt/Views/srvOverview.xaml.cs
@@ -4,7 +4,7 @@
 using Microsoft.UI.Xaml.Controls;
 using paradigm_ehb.CommandCenter.Core.Interfaces;
 using paradigm_ehb.CommandCenter.Core.Models;
-using Resources.V1;
+using Resources.V2;
 using System;
 using System.Linq;
 using System.Timers;