feat: Enhance build process and add test execution

- Added a step to run tests in the GitHub Actions build workflow.
- Introduced publishing for the UpdateAgent project in the build workflow.
- Copied install scripts during the build process.

refactor: Improve process checking in WarningPopup

- Refactored process checking logic to use a dedicated method for better readability and resource management.

docs: Update security notes in README

- Expanded security notes regarding remote access and TLS requirements for the dashboard listener.

fix: Ensure proper disposal of process objects in DiscoveryService and LimitEnforcer

- Added finally blocks to dispose of process objects to prevent resource leaks.

feat: Implement input validation utility

- Created InputValidation class to centralize validation logic for app names, process names, and other inputs.

fix: Enhance email command processing in EmailService

- Improved command processing logic to handle email commands more robustly and added validation for app names and limits.

feat: Add session management for admin password in dashboard

- Implemented session management for admin password prompts in the dashboard JavaScript.

refactor: Optimize DashboardServer for better performance

- Refactored DashboardServer to improve token management and streamline API responses.

Author: geogengames-hue

.github/workflows/build.yml

@@ -24,6 +24,9 @@ jobs:
     - name: Build (Release)
       run: dotnet build .\MonitorAndControl.csproj -c Release --no-restore
 
+    - name: Run tests
+      run: dotnet run --project .\Tests\MonitorAndControl.Tests.csproj -c Release
+
     - name: Publish Monitor
       run: dotnet publish .\MonitorAndControl.csproj -c Release -r win-x64 --self-contained false -p:PublishSingleFile=true -o publish
 
@@ -33,6 +36,15 @@ jobs:
     - name: Publish PopupHost
       run: dotnet publish .\PopupHost\PopupHost.csproj -c Release -r win-x64 --self-contained false -p:PublishSingleFile=true -o publish
 
+    - name: Publish UpdateAgent
+      run: dotnet publish .\UpdateAgent\UpdateAgent.csproj -c Release -r win-x64 --self-contained false -p:PublishSingleFile=true -o publish
+
+    - name: Copy install scripts
+      shell: pwsh
+      run: |
+        Copy-Item .\install-watchdog.ps1 publish\
+        Copy-Item .\uninstall-watchdog.ps1 publish\
+
     - name: Upload artifacts
       uses: actions/upload-artifact@v4
       with:

PopupHost/WarningPopup.cs

@@ -112,8 +112,7 @@ public WarningPopup(
         _checkTimer = new System.Windows.Forms.Timer { Interval = 2000 };
         _checkTimer.Tick += (s, e) =>
         {
-            if (!string.IsNullOrEmpty(_processName) &&
-                Process.GetProcessesByName(Path.GetFileNameWithoutExtension(_processName)).Length == 0)
+            if (!string.IsNullOrEmpty(_processName) && !IsProcessRunning(_processName))
             {
                 _checkTimer.Stop();
                 _timer.Stop();
@@ -149,6 +148,17 @@ public WarningPopup(
         }
     }
 
+    private static bool IsProcessRunning(string processName)
+    {
+        var processes = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(processName));
+        try { return processes.Length > 0; }
+        finally
+        {
+            foreach (var process in processes)
+                process.Dispose();
+        }
+    }
+
     private string FormatCountdown(int seconds) => FormatTemplate(_closingTemplate, seconds);
 
     private string FormatTemplate(string template, int seconds) =>

README.md

@@ -282,7 +282,7 @@ Place this file alongside `DeviceMon.exe`. All settings are optional — default
 | `DefaultLimits` | `[]` | Daily limits imported only when the database is first created |
 | `Schedule` | `[]` | Allowed-hours rules imported only when the database is first created |
 
-> **Security note:** When remote access is enabled, remote users cannot open the dashboard until an admin password has been created from a trusted local dashboard. After setup, remote users are redirected to the login page. Successful authentication creates an HTTP-only session cookie; use **Settings → Logout** to end that browser session.
+> **Security note:** When remote access is enabled, remote users cannot open the dashboard until an admin password has been created from a trusted local dashboard. After setup, remote users are redirected to the login page. Successful authentication creates an HTTP-only session cookie; use **Settings → Logout** to end that browser session. The built-in dashboard listener is HTTP only; do not expose it beyond a trusted LAN unless you put it behind a TLS reverse proxy, VPN/tunnel, or a trusted local certificate setup.
 
 ### Installing the Watchdog (optional, requires admin)
 
@@ -331,6 +331,15 @@ Once installed, the `GameHost` service runs under the SYSTEM account and automat
 
 **Remote access:** Settings show the computer name and IP addresses. From another PC, open `http://CHILD_PC_NAME:5000` or `http://192.168.x.x:5000`.
 
+**LAN HTTPS:** HTTPS always requires a certificate. For a local LAN, use one of these approaches:
+
+- Put DeviceMon behind a reverse proxy with a certificate trusted by the parent devices.
+- Use a real domain name that resolves to the LAN IP and issue a certificate with DNS validation.
+- Use a private CA/self-signed certificate and install that CA/certificate as trusted on every parent device.
+- Use a VPN/tunnel product that provides HTTPS at its edge.
+
+Without one of those trust models, browsers will show certificate warnings because they cannot verify the local server identity.
+
 ### Email control (optional)
 
 1. Enable 2‑Factor Authentication on your Gmail account

Services/DiscoveryService.cs

@@ -123,6 +123,10 @@ private void ScanRunningProcesses(Dictionary<string, DiscoveredApp> results)
                     results.TryAdd(procName, new DiscoveredApp(procName, title, path, "Running"));
                 }
                 catch { }
+                finally
+                {
+                    proc.Dispose();
+                }
             }
         }
         catch { }

Services/EmailService.cs

@@ -35,6 +35,7 @@ public class EmailService : IDisposable
     private string _allowedSender = "";
     private string _deviceId = Environment.MachineName;
     private string _startAlertDate = DateTime.Now.ToString("yyyy-MM-dd");
+    private const int MaxCommandScanMessages = 25;
     private const string SmtpHost = "smtp.gmail.com";
     private const int SmtpPort = 587;
     private const string ImapHost = "imap.gmail.com";
@@ -234,31 +235,31 @@ private async void PollInbox(object? state)
             // be used as command-delivery state because the first computer would hide a
             // broadcast from all the others. Each installation keeps its own receipt list.
             var allUids = await client.Inbox.SearchAsync(fromQuery);
-            var uids = allUids.Skip(Math.Max(0, allUids.Count - 250)).ToList();
+            var uids = allUids.Skip(Math.Max(0, allUids.Count - MaxCommandScanMessages)).ToList();
             if (uids.Count == 0) { await client.DisconnectAsync(true); return; }
 
-            var items = await client.Inbox.FetchAsync(uids, new MailKit.FetchRequest(MailKit.MessageSummaryItems.Full));
+            var summaryItems =
+                MailKit.MessageSummaryItems.UniqueId |
+                MailKit.MessageSummaryItems.Envelope |
+                MailKit.MessageSummaryItems.Flags |
+                MailKit.MessageSummaryItems.InternalDate;
+            var items = await client.Inbox.FetchAsync(uids, new MailKit.FetchRequest(summaryItems));
             var initialized = (await _db.GetSettingAsync("EmailCommandTrackingInitialized", "false")) == "true";
             foreach (var item in items)
             {
-                var mime = await client.Inbox.GetMessageAsync(item.UniqueId);
-                var from = mime.From.Mailboxes.FirstOrDefault()?.Address ?? "";
-                var subject = mime.Subject ?? "";
-                var body = (mime.TextBody ?? mime.HtmlBody ?? "").Trim();
+                var from = item.Envelope?.From.Mailboxes.FirstOrDefault()?.Address ?? "";
+                var subject = item.Envelope?.Subject ?? "";
                 if (!allowedSenders.Contains(from, StringComparer.OrdinalIgnoreCase))
                     continue;
 
-                var commandText = ExtractCommandText(subject, body);
-                if (commandText == null)
-                    continue;
-
-                var messageKey = !string.IsNullOrWhiteSpace(mime.MessageId)
-                    ? $"message-id:{mime.MessageId.Trim()}"
+                var messageId = item.Envelope?.MessageId;
+                var messageKey = !string.IsNullOrWhiteSpace(messageId)
+                    ? $"message-id:{messageId.Trim()}"
                     : $"imap:{client.Inbox.UidValidity}:{item.UniqueId.Id}";
                 if (await _db.IsEmailCommandProcessedAsync(messageKey))
                     continue;
 
-                var receivedAt = item.InternalDate ?? mime.Date;
+                var receivedAt = item.InternalDate ?? item.Envelope?.Date ?? DateTimeOffset.UtcNow;
                 var tooOld = receivedAt < DateTimeOffset.UtcNow.AddDays(-30);
                 var predatesUpgrade = !initialized
                     && item.Flags.HasValue
@@ -270,6 +271,18 @@ private async void PollInbox(object? state)
                     continue;
                 }
 
+                var subjectCommand = ExtractCommandText(subject, "");
+                var mime = subjectCommand == null
+                    ? await client.Inbox.GetMessageAsync(item.UniqueId)
+                    : null;
+                var body = mime == null ? "" : (mime.TextBody ?? mime.HtmlBody ?? "").Trim();
+                var commandText = subjectCommand ?? ExtractCommandText(subject, body);
+                if (commandText == null)
+                {
+                    await _db.MarkEmailCommandProcessedAsync(messageKey);
+                    continue;
+                }
+
                 if (!IsCommandForThisDevice(commandText, out var effectiveCommand))
                 {
                     Logger.Instance.Info($"Email command ignored on {_deviceId}; target does not match: \"{commandText}\"");
@@ -429,8 +442,11 @@ set kill-delay [seconds]      - set kill delay
             var setMatch = Regex.Match(line, @"^set\s+(.+?)\s+(\d+)\s*min", RegexOptions.IgnoreCase);
             if (setMatch.Success)
             {
-                var appName = setMatch.Groups[1].Value.Trim();
+                var appName = InputValidation.Clean(setMatch.Groups[1].Value);
                 var minutes = int.Parse(setMatch.Groups[2].Value);
+                if (!InputValidation.IsValidAppName(appName) || !InputValidation.IsValidLimitMinutes(minutes))
+                    return "Error: Limit requires a valid app name and 1-1440 minutes.";
+
                 await _db.SaveLimitRuleAsync(new AppLimitRule
                 {
                     AppName = appName,
@@ -445,10 +461,10 @@ await _db.SaveLimitRuleAsync(new AppLimitRule
             var bonusMatch = Regex.Match(line, @"^(?:bonus|extend)\s+(.+?)\s+(\d+)\s*min", RegexOptions.IgnoreCase);
             if (bonusMatch.Success)
             {
-                var appName = bonusMatch.Groups[1].Value.Trim();
+                var appName = InputValidation.Clean(bonusMatch.Groups[1].Value);
                 var minutes = int.Parse(bonusMatch.Groups[2].Value);
-                if (minutes is < 1 or > 240)
-                    return "Error: Bonus minutes must be between 1 and 240.";
+                if (!InputValidation.IsValidAppName(appName) || !InputValidation.IsValidBonusMinutes(minutes))
+                    return "Error: Bonus requires a valid app name and 1-240 minutes.";
 
                 var limits = await _db.GetLimitRulesAsync();
                 if (!limits.Any(l => l.AppName.Equals(appName, StringComparison.OrdinalIgnoreCase)))
@@ -462,7 +478,10 @@ await _db.SaveLimitRuleAsync(new AppLimitRule
             var bedtimeMatch = Regex.Match(line, @"^(?:bonus|extend|allow)\s+(.+?)\s+(?:until\s+)?bedtime$", RegexOptions.IgnoreCase);
             if (bedtimeMatch.Success)
             {
-                var appName = bedtimeMatch.Groups[1].Value.Trim();
+                var appName = InputValidation.Clean(bedtimeMatch.Groups[1].Value);
+                if (!InputValidation.IsValidAppName(appName))
+                    return "Error: Invalid app name.";
+
                 var limits = await _db.GetLimitRulesAsync();
                 var limit = limits.FirstOrDefault(l => l.AppName.Equals(appName, StringComparison.OrdinalIgnoreCase));
                 if (limit == null)
@@ -491,17 +510,23 @@ await _db.SaveLimitRuleAsync(new AppLimitRule
             {
                 var day = schedMatch.Groups[1].Value;
                 day = char.ToUpper(day[0]) + day.Substring(1).ToLower();
+                var startTime = schedMatch.Groups[2].Value;
+                var endTime = schedMatch.Groups[3].Value;
+                if (!TimeSpan.TryParse(startTime, out var start) || start < TimeSpan.Zero || start >= TimeSpan.FromDays(1) ||
+                    !TimeSpan.TryParse(endTime, out var end) || end < TimeSpan.Zero || end >= TimeSpan.FromDays(1))
+                    return "Error: Invalid schedule time.";
+
                 if (day is "Weekday" or "Weekend" or "Everyday" or "Monday" or "Tuesday" or "Wednesday" or "Thursday" or "Friday" or "Saturday" or "Sunday")
                 {
                     await _db.SaveScheduleRuleAsync(new ScheduleRule
                     {
                         DayOfWeek = day,
-                        StartTime = schedMatch.Groups[2].Value,
-                        EndTime = schedMatch.Groups[3].Value,
+                        StartTime = startTime,
+                        EndTime = endTime,
                         Enabled = true
                     });
                     _scheduler.InvalidateCache();
-                    return $"OK: Schedule added: {day} {schedMatch.Groups[2].Value}-{schedMatch.Groups[3].Value}";
+                    return $"OK: Schedule added: {day} {startTime}-{endTime}";
                 }
                 return $"Error: Invalid day: {day}. Use: Weekday, Weekend, Everyday, or day name.";
             }
@@ -511,6 +536,9 @@ await _db.SaveScheduleRuleAsync(new ScheduleRule
             if (delayMatch.Success)
             {
                 var secs = int.Parse(delayMatch.Groups[1].Value);
+                if (!InputValidation.IsValidKillDelaySeconds(secs))
+                    return "Error: Kill delay must be between 5 and 300 seconds.";
+
                 await _db.SetKillDelayAsync(secs);
                 return $"OK: Kill delay set to {secs}s";
             }
@@ -519,8 +547,11 @@ await _db.SaveScheduleRuleAsync(new ScheduleRule
             var addMatch = Regex.Match(line, @"^add\s+(\S+)\s+(.+)", RegexOptions.IgnoreCase);
             if (addMatch.Success)
             {
-                var proc = addMatch.Groups[1].Value;
-                var name = addMatch.Groups[2].Value.Trim();
+                var proc = InputValidation.Clean(addMatch.Groups[1].Value);
+                var name = InputValidation.Clean(addMatch.Groups[2].Value);
+                if (!InputValidation.IsValidProcessName(proc) || !InputValidation.IsValidAppName(name))
+                    return "Error: Invalid process or app name.";
+
                 var existing = (await _db.GetAppMappingsAsync()).FirstOrDefault(mapping =>
                     mapping.ProcessName.Equals(proc, StringComparison.OrdinalIgnoreCase));
                 var countInBackground = existing?.CountInBackground ?? false;

Services/InputValidation.cs

@@ -0,0 +1,25 @@
+namespace MonitorAndControl.Services;
+
+public static class InputValidation
+{
+    public static string Clean(string? value) => (value ?? "").Trim();
+
+    public static bool IsValidAppName(string value) =>
+        value.Length is > 0 and <= 120 && !value.Any(char.IsControl);
+
+    public static bool IsValidProcessName(string value) =>
+        value.Length is > 4 and <= 260 &&
+        value.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) &&
+        Path.GetFileName(value).Equals(value, StringComparison.OrdinalIgnoreCase) &&
+        !value.Any(char.IsControl);
+
+    public static bool IsValidLimitMinutes(int minutes) => minutes is >= 1 and <= 1440;
+
+    public static bool IsValidBonusMinutes(int minutes) => minutes is >= 1 and <= 240;
+
+    public static bool IsValidKillDelaySeconds(int seconds) => seconds is >= 5 and <= 300;
+
+    public static bool IsValidHttpUrl(string value) =>
+        Uri.TryCreate(value, UriKind.Absolute, out var uri) &&
+        (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps);
+}

Services/LimitEnforcer.cs

@@ -366,6 +366,10 @@ private void KillProcessByName(string processName)
                 {
                     Logger.Instance.Error($"Failed to close process {proc.ProcessName} ({proc.Id}): {ex.Message}");
                 }
+                finally
+                {
+                    proc.Dispose();
+                }
             }
         }
         catch (Exception ex)

Services/NotificationService.cs

@@ -65,11 +65,18 @@ private async Task<bool> FireWebhook(string eventType, string appName, object pa
         {
             var url = await GetWebhookUrlAsync();
             if (string.IsNullOrWhiteSpace(url)) return false;
+            if (!Uri.TryCreate(url, UriKind.Absolute, out var uri) ||
+                (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps) ||
+                await IsBlockedWebhookTargetAsync(uri))
+            {
+                Logger.Instance.Warn($"Blocked unsafe webhook target: {url}");
+                return false;
+            }
 
             var json = JsonSerializer.Serialize(payload, JsonOpts);
             using var content = new StringContent(json, Encoding.UTF8, "application/json");
 
-            using var response = await _http.PostAsync(url, content);
+            using var response = await _http.PostAsync(uri, content);
             if (!response.IsSuccessStatusCode)
             {
                 System.Diagnostics.Debug.WriteLine(
@@ -84,6 +91,44 @@ private async Task<bool> FireWebhook(string eventType, string appName, object pa
         }
     }
 
+    private static async Task<bool> IsBlockedWebhookTargetAsync(Uri uri)
+    {
+        if (uri.IsLoopback || uri.Host.Equals("localhost", StringComparison.OrdinalIgnoreCase))
+            return true;
+
+        try
+        {
+            var addresses = await System.Net.Dns.GetHostAddressesAsync(uri.Host);
+            return addresses.Length == 0 || addresses.Any(IsLocalOnlyAddress);
+        }
+        catch
+        {
+            return true;
+        }
+    }
+
+    private static bool IsLocalOnlyAddress(System.Net.IPAddress address)
+    {
+        if (System.Net.IPAddress.IsLoopback(address) ||
+            address.Equals(System.Net.IPAddress.Any) ||
+            address.Equals(System.Net.IPAddress.IPv6Any) ||
+            address.Equals(System.Net.IPAddress.Broadcast) ||
+            address.IsIPv6LinkLocal ||
+            address.IsIPv6SiteLocal)
+            return true;
+
+        if (address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
+        {
+            var bytes = address.GetAddressBytes();
+            return (bytes[0] & 0xfe) == 0xfc;
+        }
+
+        var b = address.GetAddressBytes();
+        return b[0] == 0 ||
+            b[0] == 127 ||
+            (b[0] == 169 && b[1] == 254);
+    }
+
     public async Task TestWebhookAsync()
     {
         await FireWebhook("test", "System", new