Launcher.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.Linq;
using System.Management;
using System.Text;
using System.Threading.Tasks;
using static GenerallyPositive.Enums;
 
namespace GenerallyPositive
{
    // written by Grok
    public class Launcher : IAllowExecutableSetup, IAllowRunningExecutable, IAllowWaitingExecutable
    {
        public string Name { get; internal set; }
        public string Executable { get; internal set; }
 
        private readonly List<string> _arguments = new List<string>();
        private readonly Dictionary<string, string> _environment = new Dictionary<string, string>();
        private string _workingDirectory;
        private Action<string> _outputHandler;
        private Action<string> _errorHandler;
        private Process _process;
        private bool _hasWaitedOrExited;
 
        public Launcher()
        {
        }
 
        public IAllowExecutableSetup WithExecutable(string executable)
        {
            Executable = executable;
            return this;
        }
 
        public IAllowExecutableSetup WithName(string name)
        {
            Name = name;
            return this;
        }
        public IAllowExecutableSetup WithArgument(string argument)
        {
            if (_process != null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Cannot add arguments after starting.", null, GPALObjectType.None);
                return this; // Return to allow chaining, but operation is skipped
            }
            if (argument == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Argument cannot be null.", null, GPALObjectType.None, new ArgumentNullException(nameof(argument)));
                return this;
            }
            _arguments.Add(argument);
            return this;
        }

        public IAllowExecutableSetup WithWorkingDirectory(string directory)
        {
            if (null == directory)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "A working directory cannot be null", null, GPALObjectType.None);
                return this;
            }
 
            _workingDirectory = directory;
            return this;
        }

        public IAllowExecutableSetup WithEnvironmentVariable(string name, string value)
        {
            if (null == name || null == value)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"An environment variable needs a name and a value, given [{name ?? "NULL"}] and [{value ?? "NULL"}]", null, GPALObjectType.None);
                return this;
            }
 
            _environment[name] = value;
            return this;
        }

        public IAllowExecutableSetup WithOutputTo(Action<string> outputHandler)
        {
            _outputHandler = outputHandler;
            return this;
        }

        public IAllowExecutableSetup WithErrorTo(Action<string> errorHandler)
        {
            _errorHandler = errorHandler;
            return this;
        }

        private static string Quoted(string argument)
        {
            if (false == argument.Contains(" ") && false == argument.Contains("\""))
                return argument;
 
            return "\"" + argument.Replace("\"", "\\\"") + "\"";
        }
 
        // what Windows starts directly, without asking the shell what the file is registered to. A path with
        // no extension is one too, because Windows looks for it with .exe added
        private static readonly HashSet<string> runsDirectly = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
        {
            ".exe", ".com", ".bat", ".cmd"
        };

        private static bool IsDocument(string path)
        {
            string name = path.Trim().Trim('"');
            name = name.Substring(Math.Max(name.LastIndexOf('\\'), name.LastIndexOf('/')) + 1);
 
            int dot = name.LastIndexOf('.');
 
            return 0 <= dot && dot < name.Length - 1 && false == runsDirectly.Contains(name.Substring(dot));
        }
 
        public IAllowRunningExecutable Launch()
        {
            if (_process != null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Process already started.", null, GPALObjectType.None);
                return this;
            }
 
            // a url or a document is opened by whatever Windows has registered for it, which is what
            // the shell does. an executable GPAL runs itself
            bool opensWithTheShell = Executable.StartsWith("http://", StringComparison.OrdinalIgnoreCase)
                                  || Executable.StartsWith("https://", StringComparison.OrdinalIgnoreCase)
                                  || true == IsDocument(Executable);
 
            // reading the output and setting the environment both need the process started by GPAL rather
            // than handed to the shell, so asking for either takes the shell out of it
            bool wantsOurOwnProcess = null != _outputHandler || null != _errorHandler || 0 < _environment.Count;
 
            if (true == opensWithTheShell && true == wantsOurOwnProcess)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"[{Executable}] opens with the shell, which has no output to read and no environment to set. Those settings are ignored", null, GPALObjectType.None);
                wantsOurOwnProcess = false;
                _outputHandler = null;
                _errorHandler = null;
 
                // the shell refuses to start anything that carries an environment, so it goes too
                _environment.Clear();
            }
 
            bool shellExecute = opensWithTheShell && false == wantsOurOwnProcess;
 
            _process = new Process
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = Executable,
                    Arguments = string.Join(" ", _arguments.Select(Quoted)),
                    UseShellExecute = shellExecute,
                    RedirectStandardOutput = null != _outputHandler,
                    RedirectStandardError = null != _errorHandler,
                    CreateNoWindow = !shellExecute
                }
            };
 
            if (false == string.IsNullOrEmpty(_workingDirectory))
                _process.StartInfo.WorkingDirectory = _workingDirectory;
 
            foreach (KeyValuePair<string, string> variable in _environment)
                _process.StartInfo.EnvironmentVariables[variable.Key] = variable.Value;
 
            // attached before Start, because a line written before the handler is on is a line nobody sees
            if (null != _outputHandler)
                _process.OutputDataReceived += (sender, e) => { if (null != e.Data) _outputHandler(e.Data); };
 
            if (null != _errorHandler)
                _process.ErrorDataReceived += (sender, e) => { if (null != e.Data) _errorHandler(e.Data); };
 
            try
            {
                _process.Start();
 
                // reading only starts once the process has, and only for the streams that were redirected
                if (null != _outputHandler)
                    _process.BeginOutputReadLine();
 
                if (null != _errorHandler)
                    _process.BeginErrorReadLine();
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Failed to start [{Executable}]", null, GPALObjectType.None, ex);
            }
 
            return this;
        }

        public bool IsRunning()
        {
            bool retVal = null != _process && false == _hasWaitedOrExited && false == _process.HasExited;
 
            return retVal;
        }

        public IAllowWaitingExecutable WaitForExit(int milliseconds)
        {
            if (true == Started("WaitForExit"))
            {
                _process.WaitForExit(milliseconds);
                _hasWaitedOrExited = true;
            }
 
            return this;
        }

        public void Kill()
        {
            if (false == Started("Kill") || false == IsRunning())
                return;
 
            _process.Kill();
            _hasWaitedOrExited = true;
        }

        public void KillTree()
        {
            if (false == Started("KillTree") || false == IsRunning())
                return;
 
            KillProcessTree(_process.Id);
            _process.Kill();
            _hasWaitedOrExited = true;
        }
        private void KillProcessTree(int pid)
        {
            try
            {
                // Use WMI to find child processes
                using (var searcher = new ManagementObjectSearcher(
                    $"SELECT * FROM Win32_Process WHERE ParentProcessId = {pid}"))
                {
                    foreach (ManagementObject obj in searcher.Get())
                    {
                        int childPid = Convert.ToInt32(obj["ProcessId"]);
                        KillProcessTree(childPid); // Recursively kill children
                        try
                        {
                            Process.GetProcessById(childPid).Kill();
                        }
                        catch (ArgumentException)
                        {
                            // Process already exited, ignore
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Failed to kill process tree for PID [{pid}]", null, GPALObjectType.None, ex);
            }
        }
        public Launcher ToGPALObject()
        {
            return this;
        }

        private bool Started(string wanted)
        {
            bool retVal = null != _process;
 
            if (false == retVal)
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"[{wanted}] needs a process, and [{Executable ?? "no executable"}] has not been launched", null, GPALObjectType.None);
 
            return retVal;
        }
    }
}