DriverHelper.cs

// =============================================================================
// GPAL - Generally Positive Automation Library
// Copyright © 2026 Software Decisions, Inc. All rights reserved.
//
// This file is part of GPAL.
// Licensed under the Business Source License 1.1
//
// Primary development, architecture, and vision by Michael B. Vederman,
// CEO of Software Decisions, Inc., Texas.
//
// Internal development maintained privately.
// Public releases appear on GitHub: https://github.com/SoftwareDecisionsInc/GPAL.
//
// See LICENSE for full terms, including Additional Use Grant.
// =============================================================================
 
using Microsoft.Win32;
using Newtonsoft.Json.Linq;
using OpenQA.Selenium;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using static GenerallyPositive.Enums;
 
namespace GenerallyPositive.Browser
{
    internal static class DriverHelper
    {
        static IBrowser browser = null;
        static string chromeVersionForSelector = string.Empty;
        static string edgeVersionForSelector = string.Empty;
        static bool updateSuccess = false;
        static GPALFile versionFile;
        static string version = string.Empty;
        static string url;
        static Selector showMoreFiles = GPAL.Selector.WithXPath(GPAL.GPALSettings.FirefoxDriverShowAllXpath).WithSelectorName("ShowMoreFilesFF").ToGPALObject();
 
        public static void UpdateDriver(BrowserSettings browserSettings)
        {
            Selector tdSelector = null;
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Driver Auto Update running for [{browserSettings.BrowserType}]", browserSettings, GPALObjectType.Other);
 
            // firefox does not scrape a page. Geckodriver publishes its releases, and it is not versioned against
            // the browser, so neither the releases page nor the Firefox version can say whether we are current
            if (BrowserType.FireFox == browserSettings.BrowserType)
            {
                UpdateFirefoxDriver(browserSettings);
                return;
            }
 
            browser =
             GPAL.Browser.WithBrowserType(browserSettings.BrowserType).WithOpenPDFExternally(false).WithDriverLocation(browserSettings.DriverLocation).ToGPALObject();
 
            if (false == string.IsNullOrEmpty(browserSettings.ProfileDataDirectory))
                browser.WithProfileDataDirectory(browserSettings.ProfileDataDirectory);
 
            browser
                .WithAutomationEngine(browserSettings.AutomationEngine);
 
            switch (browser.BrowserType)
            {
                case Enums.BrowserType.Chrome:
                    chromeVersionForSelector = GetChromeVersion(out version);
                    tdSelector = CreateChromeSelector();
                    url = GPAL.GPALSettings.ChromeDriverUpdateURL;
                    break;
                case Enums.BrowserType.Edge:
                    edgeVersionForSelector = GetEdgeVersion(out version);
                    tdSelector = CreateEdgeSelector();
                    url = GPAL.GPALSettings.EdgeDriverUpdateURL;
                    break;
                case Enums.BrowserType.FireFox:
                    GetFirefoxVersion(out version);
                    tdSelector = CreateFirefoxSelector(); 
                    url = GPAL.GPALSettings.FirefoxDriverUpdateURL;
                    break;
            }
 
            IGPALGrid<string> lastUpdatedVersion = GPAL.Grid.ToGPALObject();
            string driverLocation = FileHelper.EnsureDirectoryEndsWithBackslash(browserSettings.DriverLocation);    // might not be set by user, could be system determined
 
            // find our verions.yaml and read what version we last updated on
            string yamlFile = Path.Combine(driverLocation, $"{browserSettings.BrowserType}.version.yaml");
            versionFile = yamlFile;
            GPAL.Converter.WithInput(versionFile).SaveTo(ref lastUpdatedVersion);
 
            if (true == lastUpdatedVersion.Contains(version))
            {
                GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Web driver already current for version [{version}]");
                return; // already updated
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Attempting to update web driver for browser version [{version}]");
 
            browser
                .Get(url);
 
            if (BrowserType.FireFox == browserSettings.BrowserType)
            {
                browser.LeftClick(showMoreFiles)
                .WaitFor(1_000);
            }
 
            browser
                .WithSelector(tdSelector)
                .StartWorkflow();
        }

        private static void UpdateFirefoxDriver(BrowserSettings browserSettings)
        {
            string path = FileHelper.EnsureDirectoryEndsWithBackslash(browserSettings.DriverLocation);
            string driver = GPAL.GPALSettings.FirefoxDriverFilename;
            string zipFilename = GPAL.GPALSettings.FirefoxDriverZipFilename;
            string[] nameParts = zipFilename.Split('*');
            string installed = GetGeckodriverVersion($"{path}{driver}");
 
            url = GPAL.GPALSettings.FirefoxDriverUpdateURL;
            versionFile = Path.Combine(path, $"{BrowserType.FireFox}.version.yaml");
 
            try
            {
                using (HttpClient httpClient = new HttpClient())
                {
                    httpClient.DefaultRequestHeaders.Add("User-Agent", MagicHelper.GetUserAgentString(BrowserType.FireFox));
 
                    JObject release = JObject.Parse(httpClient.GetStringAsync(url).Result);
                    string latest = release["tag_name"]?.ToString().TrimStart('v');
 
                    JToken asset = release["assets"]?.FirstOrDefault(a =>
                        true == a["name"].ToString().StartsWith(nameParts[0], StringComparison.OrdinalIgnoreCase) &&
                        true == a["name"].ToString().EndsWith(nameParts[nameParts.Length - 1], StringComparison.OrdinalIgnoreCase));
 
                    if (true == string.Equals(installed, latest, StringComparison.OrdinalIgnoreCase))
                        GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Web driver already current for geckodriver [{installed}]", browserSettings, GPALObjectType.Browser);
                    else if (null == asset)
                    {
                        GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Geckodriver [{latest}] publishes no asset matching [{zipFilename}]", browserSettings, GPALObjectType.Browser);
                        GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Please update driver manually at [{url}]", browserSettings, GPALObjectType.Browser);
                    }
                    else
                        DownloadAndExtractDriver(asset["browser_download_url"].ToString(), path, zipFilename.Replace("*", ""), driver, latest);
                }
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Unable to check for a geckodriver update at [{url}]", browserSettings, GPALObjectType.Browser, ex);
            }
        }
        private static string GetGeckodriverVersion(string driverPath)
        {
            string installed = null;
 
            if (true == File.Exists(driverPath))
            {
                Process process = Process.Start(new ProcessStartInfo
                {
                    FileName = driverPath,
                    Arguments = "--version",
                    RedirectStandardOutput = true,
                    UseShellExecute = false,
                    CreateNoWindow = true
                });
 
                string[] parts = (process.StandardOutput.ReadLine() ?? string.Empty).Split(' ');
                process.WaitForExit();
 
                if (1 < parts.Length)
                    installed = parts[1];
            }
 
            return installed;
        }
        private static void DownloadAndExtractDriver(string href, string path, string zipFilename, string driver, string driverVersion)
        {
            File.Delete($"{path}{zipFilename}");
            GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Trying to download driver [{href}] to [{$"{path}{zipFilename}"}]");
 
            using (HttpClient httpClient = new HttpClient())
            {
                httpClient.DefaultRequestHeaders.Add("User-Agent", MagicHelper.GetUserAgentString(BrowserType.FireFox));
                File.WriteAllBytes($"{path}{zipFilename}", httpClient.GetByteArrayAsync(href).Result);
            }
 
            using (ZipArchive archive = ZipFile.OpenRead($"{path}{zipFilename}"))
            {
                GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Extracting [{driver}] from zip file");
 
                ZipArchiveEntry entryToExtract = archive.Entries.FirstOrDefault(e => e.Name.Equals(driver, StringComparison.OrdinalIgnoreCase));
 
                if (null != entryToExtract)
                {
                    string destinationFilePath = Path.Combine(path, entryToExtract.Name);
 
                    if (true == File.Exists(destinationFilePath))
                        File.Delete(destinationFilePath);
 
                    entryToExtract.ExtractToFile(destinationFilePath);
                }
            }
 
            File.Delete($"{path}{zipFilename}");
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO, $"[{BrowserType.FireFox}] web driver updated to geckodriver [{driverVersion}]");
 
            IGPALGrid<string> gPALGrid = GPAL.Grid.ToGPALObject();
            gPALGrid.AddRow(new List<string> { BrowserType.FireFox.ToString(), driverVersion });
 
            GPAL.Converter.WithInput(gPALGrid).SaveTo(versionFile);
        }
        public static CallIfStatus CallIfFound(IBrowser browser, List<IGPALElement> foundElements, List<IGPALElement> matchedElements, Selector selector, bool matchedAll)
        {
            if (true == updateSuccess)
                return CallIfStatus.Handled;
 
            // last element will be highest available version which could be dev, beta or upcoming. first will be stable
            GPALElement webElement = (GPALElement)matchedElements[0];
            // string href = webElement.GetAttribute("href");
            string href = string.Empty;
            string path = ((Browser)browser).BrowserSettings.DriverLocation ?? ".\\";
            string filename = string.Empty;
            string driver = string.Empty;
 
            switch (browser.BrowserType)
            {
                case Enums.BrowserType.Chrome:
                    filename = GPAL.GPALSettings.ChromeDriverZipFilename;
                    driver = GPAL.GPALSettings.ChromeDriverFilename;
                    href = webElement.Text;
                    break;
                case Enums.BrowserType.Edge:
                    filename = GPAL.GPALSettings.EdgeDriverZipFilename;
                    driver = GPAL.GPALSettings.EdgeDriverFilename;
                    href = webElement.GetAttribute("href");
                    break;
                case Enums.BrowserType.FireFox:
                    filename = GPAL.GPALSettings.FirefoxDriverZipFilename;
                    driver = GPAL.GPALSettings.FirefoxDriverFilename;
                    href = webElement.GetAttribute("href");
                    break;
            }
 
            browser.Close(true);    // release chromedriver we are using...
                                    //System.Threading.Thread.Sleep(2_000);
 
            // NOTE: firefox special case "geckodriver*win64.zip"  // must have * to split on for creating the selector, but we save to this filename
            filename = filename.Replace("*", "");
 
            File.Delete($"{path}{filename}");
            GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Trying to download driver [{href}] to [{$"{path}{filename}"}]");
 
            try
            {
                using (HttpClient httpClient = new HttpClient())
                {
                    httpClient.DefaultRequestHeaders.Add("User-Agent", MagicHelper.GetUserAgentString(browser.BrowserType));
                    byte[] data = httpClient.GetByteArrayAsync(href).Result;
                    File.WriteAllBytes($"{path}{filename}", data);
                    GPAL.PublishSimpleEvent(GPALEventType.INFO, $"[{$"{path}{filename}"}] downloaded");
                }
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Unable to download from [{href}]", browser, GPALObjectType.Browser, ex);
            }
 
            if (true == File.Exists($"{path}{filename}"))
            {
                using (ZipArchive archive = ZipFile.OpenRead($"{path}{filename}"))
                {
                    GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Extracting [{driver}] from zip file", browser, GPALObjectType.Browser);
 
                    ZipArchiveEntry entryToExtract = archive.Entries.FirstOrDefault(e => e.Name.Equals(driver, StringComparison.OrdinalIgnoreCase));
 
                    if (entryToExtract != null)
                    {
                        string destinationFilePath = Path.Combine(path, entryToExtract.Name);
 
                        if (File.Exists(destinationFilePath))
                            File.Delete(destinationFilePath);
 
                        entryToExtract.ExtractToFile(destinationFilePath);
                    }
                }
            
                File.Delete($"{path}{filename}");
                GPAL.PublishSimpleEvent(GPALEventType.INFO, $"[{browser.BrowserType}] web driver updated for version [{version}]. NOTE: Geckodriver is not tied to browser version.", browser, Enums.GPALObjectType.Browser);
                IGPALGrid<string> gPALGrid = GPAL.Grid.ToGPALObject();
                gPALGrid.AddRow(new List<string> { browser.BrowserType.ToString(), version });
 
                GPAL.Converter.WithInput(gPALGrid).SaveTo(versionFile);
            }
 
            //            updateSuccess = true; - bug - don't need to set?
            return CallIfStatus.Handled;
        }
        public static CallIfStatus CallIfNotFound(IBrowser browser, List<IGPALElement> foundElements, List<IGPALElement> matchedElements, Selector selector, bool matchedAll)
        {
            GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Auto web driver update unable to find driver for version [{version}]", browser, Enums.GPALObjectType.Browser);
            GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Please update driver manually at [{url}]", browser, Enums.GPALObjectType.Browser);
            browser.Close(true);
 
            return CallIfStatus.Handled;  // we handled, we will not terminate the workflow, but pershaps we should. the old driver could still work fine, don't call global handlers (if any)
        }
        private static Selector CreateSelector(string xpathExpression)
        {
            return GPAL.Selector
                .WithXPath(xpathExpression) // generic xpath, use .WithAllThatMatch(#)
                .CallIfNotFound(CallIfNotFound)
                .CallIfFound(CallIfFound)
                .WithSelectorName("DriverDownloadSelector")
                .ToGPALObject();
        }
        private static Selector CreateChromeSelector()
        {
            string xpathExpression = GPAL.GPALSettings.ChromeDriverXpathExpression.Replace("@chromeVersionForSelector", chromeVersionForSelector).Replace("@chromeDriverZipFileName", GPAL.GPALSettings.ChromeDriverZipFilename);
            return CreateSelector(xpathExpression);
        }
        internal static string GetChromeVersion(out string fullVersion)
        {
            string version = null;
            RegistryKey regKey = null;
 
            try
            {
                regKey = Registry.CurrentUser.OpenSubKey(GPAL.GPALSettings.ChromeVersionRegistry);
                version = regKey.GetValue("version").ToString();
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "Unable to get Chrome version from registry", null, Enums.GPALObjectType.None, ex);
            }
            finally
            {
                regKey?.Close();
            }
            fullVersion = version;
 
            return string.Join(".", version.Split('.').Take(3));    // NOTEL CAVEAT: 144.0.7559.96 - we are taking 3 but that doesn't always work, but anything less and we will update every time
        }
        private static Selector CreateEdgeSelector()
        {
            string xpathExpression = GPAL.GPALSettings.EdgeDriverXpathExpression.Replace("@edgeDriverZipFilename", GPAL.GPALSettings.EdgeDriverZipFilename).Replace("@edgeVersionForSelector", edgeVersionForSelector);
            return CreateSelector(xpathExpression);
        }
        internal static string GetEdgeVersion(out string fullVersion)
        {
            string version = null;
            RegistryKey regKey = null;
 
            try
            {
                regKey = Registry.CurrentUser.OpenSubKey(GPAL.GPALSettings.EdgeVersionRegistry);
                version = regKey.GetValue("version").ToString();
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "Unable to get Edge version from registry", null, Enums.GPALObjectType.None, ex);
            }
            finally
            {
               regKey?.Close();
            }
 
            fullVersion = version;
            return version.Split('.')[0];
        }
        private static Selector CreateFirefoxSelector()
        {
            string[] nameParts = GPAL.GPALSettings.FirefoxDriverZipFilename.Split('*');
            string xpathExpression = GPAL.GPALSettings.FirefoxDriverXpath.Replace("@firefoxDriverName1", nameParts[1]); //.Replace("@firefoxDriverName2", nameParts[1]);
            Selector tmpSelector = CreateSelector(xpathExpression);
            tmpSelector.ContainsHRef(nameParts[1]);
 
            return tmpSelector;
        }
        internal static string GetFirefoxVersion(out string fullVersion)
        {
            string version = null;
            RegistryKey regKey = null;
 
            try
            {
                regKey = Registry.CurrentUser.OpenSubKey(GPAL.GPALSettings.FirefoxVersionRegistry);
                version = regKey.GetValue("CurrentVersion")?.ToString();
                if (true == string.IsNullOrEmpty(version))
                {
                    regKey = Registry.CurrentUser.OpenSubKey(GPAL.GPALSettings.FirefoxVersionRegistry2);
                    version = regKey.GetValue("CurrentVersion")?.ToString();
                }
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "Unable to get Firefox version from registry", null, Enums.GPALObjectType.None, ex);
            }
            finally
            {
                regKey?.Close();
            }
            fullVersion = version;
 
            return version.Split('.')[0];
        }
    }
}