ChromeProfileManager.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 System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
 
//using Microsoft.Data.Sqlite;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using static GenerallyPositive.Enums;
using static Org.BouncyCastle.Asn1.Cmp.Challenge;
 
namespace GenerallyPositive.Browser
{
    internal class ChromeProfileManager
    {
        private static readonly Random random = new Random();
 
        // Prefix on every temp profile directory, chromium and firefox alike. Nothing without it is touched by
        // the sweep
        private const string TempProfilePrefix = "BrowserProfile_";
 
        // What a directory is renamed to before it is deleted. A sweep that dies part way through the delete
        // leaves one of these, which the next sweep finishes without waiting for it to age
        private const string SweepingSuffix = ".sweeping";
 
        // Minimum age before a temp profile is considered abandoned. A concurrent GPAL process may have just
        // created one and not yet launched into it, so it is unlocked but in use
        private const int AbandonedAfterMinutes = 1;
 
        // Seconds between sweeps. This runs on every launch and every close, which on a run that opens a browser
        // per site is far more often than there is anything to find
        private const int SweepEverySeconds = 30;
 
        private static DateTime lastSweep = DateTime.MinValue;
        private static int sweeping = 0;

        internal static string NewTempProfilePath()
        {
            return Path.Combine(GPAL.TempProfileDirectory, $"{TempProfilePrefix}{Guid.NewGuid():N}");
        }

        internal static bool DeleteWhenNothingIsUsingIt(string directory)
        {
            bool deleted = false;
 
            try
            {
                string renamedTo = directory;
 
                // one already renamed was proved free by the sweep that renamed it, and renaming it again would
                // only lose track of it
                if (false == directory.EndsWith(SweepingSuffix))
                {
                    renamedTo = Path.Combine(Path.GetDirectoryName(directory), $"{TempProfilePrefix}{Guid.NewGuid():N}{SweepingSuffix}");
                    Directory.Move(directory, renamedTo);
                }
 
                Directory.Delete(renamedTo, true);
                deleted = true;
            }
            catch (Exception)
            {
                // The rename failed, so a browser still has the profile and nothing here was touched, or the
                // delete failed part way and the next sweep picks up the renamed directory
            }
 
            return deleted;
        }

        internal static void SweepAbandonedTempProfiles()
        {
            // One sweep at a time, not too often, and off the thread that is launching a browser
            if (DateTime.Now < lastSweep.AddSeconds(SweepEverySeconds))
                return;
 
            if (0 != Interlocked.Exchange(ref sweeping, 1))
                return;
 
            lastSweep = DateTime.Now;
 
            System.Threading.Tasks.Task.Run(() =>
            {
                try
                {
                    string root = GPAL.TempProfileDirectory;
 
                    if (false == string.IsNullOrEmpty(root) && true == Directory.Exists(root))
                    {
                        DateTime olderThan = DateTime.Now.AddMinutes(-AbandonedAfterMinutes);
                        int swept = 0;
 
                        foreach (string directory in Directory.GetDirectories(root, TempProfilePrefix + "*"))
                        {
                            // age only says a browser may not have opened its files yet, which a directory an
                            // earlier sweep already renamed is past
                            if (false == directory.EndsWith(SweepingSuffix) && Directory.GetCreationTime(directory) > olderThan)
                                continue;
 
                            if (true == DeleteWhenNothingIsUsingIt(directory))
                                swept++;
                        }
 
                        if (0 < swept)
                            GPAL.PublishSimpleEvent(Enums.GPALEventType.INFO, $"Cleared [{swept}] temporary browser profile(s) left behind by earlier runs from [{root}]");
                    }
                }
                catch (Exception ex)
                {
                    // A sweep that cannot run leaves the directories in place
                    GPAL.PublishSimpleEvent(Enums.GPALEventType.WARNING, $"Could not clear old temporary browser profiles", null, GPALObjectType.None, ex);
                }
                finally
                {
                    Interlocked.Exchange(ref sweeping, 0);
                }
            });
        }
 
        internal static string CreateTempUserProfile(
            string downloadDirectory,
            bool promptForDownload,
            bool openPDFExternally,
            bool loadImages,
            bool useOttoMagic,
            Dictionary<string, object> additionalPrefs = null)
        {
            try
            {
                if (!Directory.Exists(downloadDirectory))
                    Directory.CreateDirectory(downloadDirectory);
 
                // Create brand new empty profile root
                string tempProfileDir = NewTempProfilePath();
 
                string defaultDir = Path.Combine(tempProfileDir, "Default");
 
                Directory.CreateDirectory(defaultDir);
 
                Base64Helper base64Helper = new Base64Helper();
                base64Helper.WithInput(GPAL.GPALSettings.Preferences).SaveTo(Path.Combine(defaultDir, "Preferences"));
                base64Helper.WithInput(GPAL.GPALSettings.SecurePreferences).SaveTo(Path.Combine(defaultDir, "Secure Preferences"));
                base64Helper.WithInput(GPAL.GPALSettings.LocalState).SaveTo(Path.Combine(tempProfileDir, "Local State"));
 
                // the canned Preferences blob says whatever it was captured with, so the workflow's own settings
                // are written over it the same way a supplied profile gets them. Without this a temp profile
                // ignored the download prompt, the pdf viewer, images and anything from .WithAdditionalPrefs,
                // which is how those four arguments came to be accepted and never read
                ApplyDownloadPreferences(tempProfileDir, downloadDirectory, promptForDownload, openPDFExternally);
 
                ApplyImagePreference(tempProfileDir, loadImages);
 
                if (null != additionalPrefs && 0 < additionalPrefs.Count)
                    ApplyAdditionalPreferences(tempProfileDir, additionalPrefs);
 
                return tempProfileDir;
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(
                    Enums.GPALEventType.EXCEPTION,
                    $"Failed creating temp Chrome profile folder",
                    null,
                    Enums.GPALObjectType.None,
                    ex);
 
                return null;
            }
        }
 
 
        // reddit consent banner - test to see if injecting this works
        // "Your request has been blocked by network security. Please try to login with your Reddit account."
        // https://www.reddit.com/r/firefox/comments/1mqmsv5/your_request_has_been_blocked_by_network_security/
 
        // the preferences GPAL sets on a supplied profile, by their chrome names, so apply and restore cannot
        // drift apart.
        // session.restore_on_startup does NOT belong here and must not be added. chromium keeps an HMAC for it in
        // Secure Preferences, along with the homepage and the search provider, so that malware cannot hijack what
        // the browser opens with. writing it from outside breaks that mac, and chromium answers by resetting the
        // preference and taking a good part of the rest of the file with it. what actually stops a session being
        // restored is profile.exit_type below: the restore was crash recovery, not the startup setting
        private static readonly string[] downloadPreferenceKeys =
        {
            "download.prompt_for_download",
            "download.default_directory",
            "plugins.always_open_pdf_externally",
            "browser.show_hub_popup_on_download_start",
        };
 

        private static void SetByPath(JObject root, string path, JToken value)
        {
            string[] parts = path.Split('.');
            JObject node = root;
 
            for (int idx = 0; idx < parts.Length - 1; idx++)
            {
                if (false == (node[parts[idx]] is JObject child))
                {
                    child = new JObject();
                    node[parts[idx]] = child;
                }
 
                node = child;
            }
 
            node[parts[parts.Length - 1]] = value;
        }
        private static string PreferencesFileFor(string profileDirectory)
        {
            string preferencesPath = null;
 
            if (false == string.IsNullOrEmpty(profileDirectory))
            {
                string inDefault = Path.Combine(profileDirectory, "Default", "Preferences");
                string inProfile = Path.Combine(profileDirectory, "Preferences");
 
                preferencesPath = File.Exists(inDefault) ? inDefault : File.Exists(inProfile) ? inProfile : null;
            }
 
            return preferencesPath;
        }

        internal static Dictionary<string, JToken> ApplyDownloadPreferences(string profileDirectory, string downloadDirectory, bool promptForDownload, bool openPDFExternally)
        {
            Dictionary<string, JToken> previous = null;
            string preferencesPath = PreferencesFileFor(profileDirectory);
 
            if (null == preferencesPath)
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"No chrome Preferences file under [{profileDirectory}], so prompt for download and open pdf externally cannot be set for this profile.", null, GPALObjectType.None);
            else
                try
                {
                    JObject preferences = JObject.Parse(File.ReadAllText(preferencesPath));
 
                    previous = new Dictionary<string, JToken>();
                    foreach (string key in downloadPreferenceKeys)
                        previous[key] = preferences.SelectToken(key);
 
                    SetByPath(preferences, "download.prompt_for_download", promptForDownload);
                    SetByPath(preferences, "plugins.always_open_pdf_externally", openPDFExternally);
 
                    // the flyout edge opens when a download starts. it takes focus and covers the top right of the
                    // page, which is somewhere a workflow may be about to click
                    SetByPath(preferences, "browser.show_hub_popup_on_download_start", false);
 
                    // not a setting and not restored: it is how the browser records its own last shutdown, and a
                    // killed browser leaves it Crashed. chromium reopens the previous session after a crash no
                    // matter what session.restore_on_startup says, so every run GPAL kills teaches the next run to
                    // come up holding the last one's tabs. saying it exited normally is what breaks that loop
                    SetByPath(preferences, "profile.exit_type", "Normal");
 
                    if (false == string.IsNullOrEmpty(downloadDirectory))
                        SetByPath(preferences, "download.default_directory", downloadDirectory);
 
                    File.WriteAllText(preferencesPath, JsonConvert.SerializeObject(preferences));   // not JToken.ToString(Formatting), whose overload binds against whichever Newtonsoft the host app loaded
 
                    // which file, what it said, what it says now. a profile is the one thing here nobody can see
                    // from the outside, so when a browser goes on prompting after being told not to, this is the
                    // difference between knowing and guessing
                    GPAL.PublishSimpleEvent(GPALEventType.DEBUG, $"Profile [{preferencesPath}] prompt for download [{previous["download.prompt_for_download"]?.ToString() ?? "unset"}] -> [{promptForDownload}], open pdf externally [{previous["plugins.always_open_pdf_externally"]?.ToString() ?? "unset"}] -> [{openPDFExternally}], download directory [{previous["download.default_directory"]?.ToString() ?? "unset"}] -> [{downloadDirectory ?? "left alone"}]", null, GPALObjectType.None);
                }
                catch (Exception ex)
                {
                    previous = null;
                    GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Could not write download preferences into [{preferencesPath}]", null, GPALObjectType.None, ex);
                }
 
            return previous;
        }

        internal static void ApplyImagePreference(string profileDirectory, bool loadImages)
        {
            string preferencesPath = PreferencesFileFor(profileDirectory);
 
            if (null == preferencesPath)
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"No chrome Preferences file under [{profileDirectory}], so load images cannot be set for this profile.", null, GPALObjectType.None);
            else
                try
                {
                    JObject preferences = JObject.Parse(File.ReadAllText(preferencesPath));
 
                    SetByPath(preferences, "profile.default_content_setting_values.images", true == loadImages ? 1 : 2);
 
                    File.WriteAllText(preferencesPath, JsonConvert.SerializeObject(preferences));
 
                    GPAL.PublishSimpleEvent(GPALEventType.DEBUG, $"Profile [{preferencesPath}] load images [{loadImages}]", null, GPALObjectType.None);
                }
                catch (Exception ex)
                {
                    GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Could not write the load images preference into [{preferencesPath}]", null, GPALObjectType.None, ex);
                }
        }

        internal static void ApplyAdditionalPreferences(string profileDirectory, Dictionary<string, object> additionalPrefs)
        {
            string preferencesPath = PreferencesFileFor(profileDirectory);
 
            if (null == preferencesPath)
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"No chrome Preferences file under [{profileDirectory}], so the additional preferences cannot be set for this profile.", null, GPALObjectType.None);
            else
                try
                {
                    JObject preferences = JObject.Parse(File.ReadAllText(preferencesPath));
 
                    foreach (KeyValuePair<string, object> pref in additionalPrefs)
                        SetByPath(preferences, pref.Key, null == pref.Value ? JValue.CreateNull() : JToken.FromObject(pref.Value));
 
                    File.WriteAllText(preferencesPath, JsonConvert.SerializeObject(preferences));
 
                    GPAL.PublishSimpleEvent(GPALEventType.DEBUG, $"Profile [{preferencesPath}] took [{additionalPrefs.Count}] additional preference(s): [{string.Join(", ", additionalPrefs.Keys)}]", null, GPALObjectType.None);
                }
                catch (Exception ex)
                {
                    GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Could not write the additional preferences into [{preferencesPath}]", null, GPALObjectType.None, ex);
                }
        }

        internal static void RestoreDownloadPreferences(string profileDirectory, Dictionary<string, JToken> previous)
        {
            string preferencesPath = null == previous ? null : PreferencesFileFor(profileDirectory);
 
            if (null == preferencesPath)
                return;
 
            try
            {
                JObject preferences = JObject.Parse(File.ReadAllText(preferencesPath));
 
                foreach (string key in downloadPreferenceKeys)
                    if (null == previous[key])
                        preferences.SelectToken(key)?.Parent?.Remove();   // it was not there before, so it goes back to not being there
                    else
                        SetByPath(preferences, key, previous[key]);
 
                File.WriteAllText(preferencesPath, JsonConvert.SerializeObject(preferences));   // not JToken.ToString(Formatting), whose overload binds against whichever Newtonsoft the host app loaded
 
                // the other half of what Apply said. a browser writes this file itself as it shuts down, so which
                // of the two wrote last decides what the next run reads, and that only shows up in the timing
                GPAL.PublishSimpleEvent(GPALEventType.DEBUG, $"Profile [{preferencesPath}] put back, prompt for download [{previous["download.prompt_for_download"]?.ToString() ?? "unset"}], download directory [{previous["download.default_directory"]?.ToString() ?? "unset"}]", null, GPALObjectType.None);
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Could not put the download preferences back in [{preferencesPath}]", null, GPALObjectType.None, ex);
            }
        }
 
        internal static void RemoveTempUserProfile(string profileDirectory)
        {
            Exception innerEx = null;
            if (!Directory.Exists(profileDirectory))
                return;
 
            // the browser is shutting down as this runs, so a first pass usually finds files still open. the
            // rename inside DeleteWhenNothingIsUsingIt is what makes retrying safe: a pass that is too early
            // leaves the profile whole instead of taking half of it with it
            for (int i = 0; i < 10; i++)
            {
                try
                {
                    if (true == DeleteWhenNothingIsUsingIt(profileDirectory))
                    {
                        GPAL.PublishSimpleEvent(Enums.GPALEventType.INFO, $"Deleted temporary user profile at [{profileDirectory}]");
                        return;
                    }
 
                    System.Threading.Thread.Sleep(500);
                }
                catch (Exception ex)
                {
                    innerEx = ex;
                    System.Threading.Thread.Sleep(500);
                    GPAL.PublishSimpleEvent(Enums.GPALEventType.EXCEPTION, $"Failed to delete temporary user profile at [{profileDirectory}][{innerEx.Message}]", null, GPALObjectType.None, innerEx);
                }
            }
 
            // left whole and named the way the sweep looks for, so the next run clears it
            GPAL.PublishSimpleEvent(Enums.GPALEventType.WARNING, $"Still in use after 10 tries, leaving temporary user profile at [{profileDirectory}] for the next run to clear");
        }
    }
}