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 DocumentFormat.OpenXml.Wordprocessing;
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 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 IAllowRunningExecutable Launch()
        {
            if (_process != null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Process already started.", null, GPALObjectType.None);
                return this;
            }
 
            bool shellExecute = Executable.StartsWith("http://", StringComparison.OrdinalIgnoreCase)
                             || Executable.StartsWith("https://", StringComparison.OrdinalIgnoreCase);
 
            _process = new Process
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = Executable,
                    Arguments = string.Join(" ", _arguments),
                    UseShellExecute = shellExecute,
                    RedirectStandardOutput = false,
                    RedirectStandardError = false,
                    CreateNoWindow = !shellExecute
                }
            };
 
            try
            {
                _process.Start();
                return this;
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Failed to start [{Executable}]", null, GPALObjectType.None, ex);
                return this; // Return to allow chaining despite failure
            }
        }
 
        public IAllowRunningExecutable RedirectOutput(Action<string> outputHandler)
        {
            EnsureRunning(); // This will publish an event if invalid
            if (_process.StartInfo.RedirectStandardOutput)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Output already redirected.", null, GPALObjectType.None);
                return this;
            }
 
            _process.StartInfo.RedirectStandardOutput = true;
            _process.OutputDataReceived += (sender, e) => { if (e.Data != null) outputHandler(e.Data); };
            if (!_process.HasExited) _process.BeginOutputReadLine();
            return this;
        }
 
        public IAllowRunningExecutable RedirectError(Action<string> errorHandler)
        {
            EnsureRunning();
            if (_process.StartInfo.RedirectStandardError)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Error already redirected.", null, GPALObjectType.None);
                return this;
            }
 
            _process.StartInfo.RedirectStandardError = true;
            _process.ErrorDataReceived += (sender, e) => { if (e.Data != null) errorHandler(e.Data); };
            if (!_process.HasExited) _process.BeginErrorReadLine();
            return this;
        }
 
        public IAllowRunningExecutable SetWorkingDirectory(string directory)
        {
            EnsureRunning();
            if (directory == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Working directory cannot be null.", null, GPALObjectType.None, new ArgumentNullException(nameof(directory)));
                return this;
            }
            _process.StartInfo.WorkingDirectory = directory;
            return this;
        }
 
        public IAllowRunningExecutable SetEnvironmentVariable(string name, string value)
        {
            EnsureRunning();
            if (name == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Environment variable name cannot be null.", null, GPALObjectType.None, new ArgumentNullException(nameof(name)));
                return this;
            }
            if (value == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Environment variable value cannot be null.", null, GPALObjectType.None, new ArgumentNullException(nameof(value)));
                return this;
            }
            _process.StartInfo.EnvironmentVariables[name] = value;
            return this;
        }
 
        public IAllowRunningExecutable IsRunning()
        {
            EnsureRunning(); // Logs event if not running
            return this;
        }
 
        public IAllowWaitingExecutable WaitForExit(int milliseconds)
        {
            EnsureRunning();
            _process.WaitForExit(milliseconds);
            _hasWaitedOrExited = true;
            return this;
        }
 
        public void Kill()
        {
            EnsureStarted();
            if (!_process.HasExited)
            {
                _process.Kill();
                _process.Dispose();
                _hasWaitedOrExited = true;
            }
        }
 
        public void KillTree()
        {
            EnsureStarted();
            if (!_process.HasExited)
            {
                KillProcessTree(_process.Id); // Use internal PID
                _process.Kill(); // Ensure the root process is killed
                _process.Dispose();
                _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 void EnsureStarted()
        {
            if (_process == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.INFO, "Process not started. Call Start() first.", null, GPALObjectType.None);
                return;
            }
        }
 
        private void EnsureRunning()
        {
            EnsureStarted();
            if (_process.HasExited || _hasWaitedOrExited)
                GPAL.PublishSimpleEvent(GPALEventType.INFO, $"[{Executable}] is not running.", null, GPALObjectType.None);
            else
                GPAL.PublishSimpleEvent(GPALEventType.INFO, $"[{Executable}] is running.", null, GPALObjectType.None);
            return;
        }
    }
}