ProcessPolicyService.cs

using System.Diagnostics;

namespace CodexProcessKeeper;

internal sealed record ProcessPolicyResult(
    int ProcessId,
    string ProcessName,
    string ProcessPath,
    string Priority,
    bool EfficiencyModeOff,
    bool Success,
    int ErrorCode,
    string Message);

internal sealed record ProcessPolicySnapshot(
    DateTime CheckedAt,
    IReadOnlyList<ProcessPolicyResult> Processes,
    string? ServiceError);

internal sealed class ProcessPolicyService : IDisposable
{
    private static readonly HashSet<string> TargetProcessNames = new(
        StringComparer.OrdinalIgnoreCase)
    {
        "ChatGPT",
        "Codex",
        "codex",
        "codex-code-mode-host",
        "codex-command-runner",
        "codex-windows-sandbox-setup"
    };

    private readonly TimeSpan scanInterval;
    private readonly System.Threading.Timer scanTimer;
    private int scanRunning;
    private bool disposed;

    internal ProcessPolicyService(TimeSpan scanInterval)
    {
        this.scanInterval = scanInterval;
        scanTimer = new System.Threading.Timer(ScanProcesses);
    }

    internal event EventHandler<ProcessPolicySnapshot>? SnapshotUpdated;

    internal void Start()
    {
        scanTimer.Change(TimeSpan.Zero, scanInterval);
    }

    internal void ApplyNow()
    {
        ThreadPool.QueueUserWorkItem(ScanProcesses);
    }

    private void ScanProcesses(object? state)
    {
        if (disposed || Interlocked.Exchange(ref scanRunning, 1) != 0)
        {
            return;
        }

        try
        {
            List<ProcessPolicyResult> results = [];
            foreach (Process process in Process.GetProcesses())
            {
                using (process)
                {
                    string processName;
                    try
                    {
                        processName = process.ProcessName;
                    }
                    catch
                    {
                        continue;
                    }

                    if (!TargetProcessNames.Contains(processName))
                    {
                        continue;
                    }

                    NativePolicyResult nativeResult = NativeProcessPolicy.Apply(process.Id);
                    if (nativeResult.ErrorCode is 6 or 87)
                    {
                        continue;
                    }

                    results.Add(new ProcessPolicyResult(
                        process.Id,
                        processName,
                        TryGetProcessPath(process),
                        nativeResult.PriorityLabel,
                        nativeResult.EfficiencyModeOff,
                        nativeResult.Success,
                        nativeResult.ErrorCode,
                        nativeResult.Message));
                }
            }

            ProcessPolicySnapshot snapshot = new(
                DateTime.Now,
                results
                    .OrderBy(result => result.ProcessName, StringComparer.OrdinalIgnoreCase)
                    .ThenBy(result => result.ProcessId)
                    .ToArray(),
                null);
            SnapshotUpdated?.Invoke(this, snapshot);
        }
        catch (Exception exception)
        {
            SnapshotUpdated?.Invoke(
                this,
                new ProcessPolicySnapshot(DateTime.Now, [], exception.Message));
        }
        finally
        {
            Interlocked.Exchange(ref scanRunning, 0);
        }
    }

    private static string TryGetProcessPath(Process process)
    {
        try
        {
            return process.MainModule?.FileName ?? string.Empty;
        }
        catch
        {
            return string.Empty;
        }
    }

    public void Dispose()
    {
        if (disposed)
        {
            return;
        }

        disposed = true;
        scanTimer.Dispose();
    }
}