Program.cs

using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text.Json;
using System.Text.Json.Serialization;

/// <summary>
/// QuickSheet System Monitor Extension — shows CPU, RAM, and disk usage in cells.
/// Registers the "sys" prefix. Usage: "sys: cpu", "sys: mem", "sys: disk", "sys: all".
/// Refreshes every 2 seconds with live metrics.
/// </summary>
class Program
{
    private static readonly JsonSerializerOptions JsonOpts = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
        WriteIndented = false
    };

    private static readonly HashSet<string> ActiveMonitors = new();
    private static readonly object Lock = new();
    private static TimeSpan _prevCpuTime = TimeSpan.Zero;
    private static DateTime _prevSampleTime = DateTime.UtcNow;
    private static double _lastCpuPercent = 0;
    // Track idle time separately for proper CPU calculation on Linux
    private static long _prevIdleJiffies = 0;
    private static long _prevTotalJiffies = 0;

    static void Main()
    {
        Console.OutputEncoding = System.Text.Encoding.UTF8;

        // Initialize CPU baseline
        InitCpuBaseline();

        // Background thread to push updates every 2 seconds
        var updateTimer = new System.Timers.Timer(2000);
        updateTimer.Elapsed += OnTimerTick;
        updateTimer.AutoReset = true;
        updateTimer.Start();

        string? line;
        while ((line = Console.ReadLine()) != null)
        {
            if (string.IsNullOrWhiteSpace(line)) continue;

            try
            {
                using var doc = JsonDocument.Parse(line);
                string? type = doc.RootElement.TryGetProperty("type", out var tp) ? tp.GetString() : null;

                switch (type)
                {
                    case "init":
                        HandleInit();
                        break;
                    case "activate":
                        HandleActivate(doc.RootElement);
                        break;
                    case "deactivate":
                        HandleDeactivate(doc.RootElement);
                        break;
                }
            }
            catch (Exception ex)
            {
                SendError("", $"Parse error: {ex.Message}");
            }
        }
    }

    static void HandleInit()
    {
        var register = new
        {
            type = "register",
            prefix = "sys",
            name = "System Monitor",
            version = "1.0.0"
        };
        SendJson(register);
        SendLog("System Monitor extension registered with prefix 'sys'");
    }

    static void HandleActivate(JsonElement root)
    {
        string id = root.TryGetProperty("id", out var idProp) ? idProp.GetString() ?? "" : "";

        string[] extParams = [];
        if (root.TryGetProperty("params", out var paramsProp) && paramsProp.ValueKind == JsonValueKind.Array)
        {
            extParams = paramsProp.EnumerateArray()
                .Select(p => p.GetString() ?? "")
                .ToArray();
        }

        string param = extParams.Length > 0 ? extParams[0].Trim().ToLowerInvariant() : "all";

        lock (Lock)
        {
            ActiveMonitors.Add(id + ":" + param);
        }

        SendMetrics(id, param);
    }

    static void HandleDeactivate(JsonElement root)
    {
        string id = root.TryGetProperty("id", out var idProp) ? idProp.GetString() ?? "" : "";

        lock (Lock)
        {
            // Remove all monitors for this id
            ActiveMonitors.RemoveWhere(m => m.StartsWith(id + ":"));
        }
    }

    static void OnTimerTick(object? sender, System.Timers.ElapsedEventArgs e)
    {
        SampleCpu();

        List<string> monitors;
        lock (Lock)
        {
            if (ActiveMonitors.Count == 0) return;
            monitors = ActiveMonitors.ToList();
        }

        foreach (var entry in monitors)
        {
            var parts = entry.Split(':', 2);
            if (parts.Length == 2)
            {
                try { SendMetrics(parts[0], parts[1]); }
                catch { }
            }
        }
    }

    static void SendMetrics(string id, string metric)
    {
        var cells = new List<object>();

        switch (metric)
        {
            case "cpu":
                AddCpuCells(cells, 0);
                break;
            case "mem":
            case "ram":
            case "memory":
                AddMemoryCells(cells, 0);
                break;
            case "disk":
                AddDiskCells(cells, 0);
                break;
            case "all":
            default:
                AddCpuCells(cells, 0);
                AddMemoryCells(cells, 1);
                AddDiskCells(cells, 2);
                AddUptimeCells(cells, 3);
                break;
        }

        SendJson(new { type = "write", id, cells });
    }

    static void AddCpuCells(List<object> cells, int row)
    {
        double cpuPercent = _lastCpuPercent;
        string bar = RenderBar(cpuPercent, 20);
        string emoji = cpuPercent > 80 ? "🔴" : cpuPercent > 50 ? "🟡" : "🟢";
        int cores = Environment.ProcessorCount;

        cells.Add(new { r = row, c = 0, v = $"{emoji} CPU" });
        cells.Add(new { r = row, c = 1, v = $"{cpuPercent:F1}%  {bar}" });
        cells.Add(new { r = row, c = 2, v = $"{cores} cores" });
    }

    static void AddMemoryCells(List<object> cells, int row)
    {
        var (usedMB, totalMB) = GetMemoryInfo();
        double percent = totalMB > 0 ? (usedMB / totalMB) * 100 : 0;
        string bar = RenderBar(percent, 20);
        string emoji = percent > 80 ? "🔴" : percent > 50 ? "🟡" : "🟢";

        cells.Add(new { r = row, c = 0, v = $"{emoji} RAM" });
        cells.Add(new { r = row, c = 1, v = $"{percent:F1}%  {bar}" });
        cells.Add(new { r = row, c = 2, v = $"{usedMB / 1024:F1}/{totalMB / 1024:F1} GB" });
    }

    static void AddDiskCells(List<object> cells, int row)
    {
        try
        {
            string rootPath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? @"C:\" : "/";
            var drive = new DriveInfo(rootPath);
            double totalGB = drive.TotalSize / (1024.0 * 1024 * 1024);
            double freeGB = drive.AvailableFreeSpace / (1024.0 * 1024 * 1024);
            double usedGB = totalGB - freeGB;
            double percent = totalGB > 0 ? (usedGB / totalGB) * 100 : 0;
            string bar = RenderBar(percent, 20);
            string emoji = percent > 80 ? "🔴" : percent > 50 ? "🟡" : "🟢";

            cells.Add(new { r = row, c = 0, v = $"{emoji} Disk" });
            cells.Add(new { r = row, c = 1, v = $"{percent:F1}%  {bar}" });
            cells.Add(new { r = row, c = 2, v = $"{usedGB:F1}/{totalGB:F1} GB" });
        }
        catch
        {
            cells.Add(new { r = row, c = 0, v = "💾 Disk" });
            cells.Add(new { r = row, c = 1, v = "unavailable" });
        }
    }

    static void AddUptimeCells(List<object> cells, int row)
    {
        try
        {
            TimeSpan uptime = TimeSpan.FromMilliseconds(Environment.TickCount64);
            string uptimeStr = uptime.Days > 0
                ? $"{uptime.Days}d {uptime.Hours}h {uptime.Minutes}m"
                : $"{uptime.Hours}h {uptime.Minutes}m {uptime.Seconds}s";

            cells.Add(new { r = row, c = 0, v = "⏱️ Uptime" });
            cells.Add(new { r = row, c = 1, v = uptimeStr });
            cells.Add(new { r = row, c = 2, v = DateTime.Now.ToString("HH:mm:ss") });
        }
        catch
        {
            cells.Add(new { r = row, c = 0, v = "⏱️ Uptime" });
            cells.Add(new { r = row, c = 1, v = "unavailable" });
        }
    }

    static string RenderBar(double percent, int width)
    {
        int filled = (int)Math.Round(percent / 100 * width);
        filled = Math.Clamp(filled, 0, width);
        return "[" + new string('█', filled) + new string('░', width - filled) + "]";
    }

    // ── CPU ──────────────────────────────────────────────────────────

    static void InitCpuBaseline()
    {
        try
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                ReadLinuxCpuJiffies(out _prevIdleJiffies, out _prevTotalJiffies);
            }
            else
            {
                _prevCpuTime = Process.GetCurrentProcess().TotalProcessorTime;
            }
            _prevSampleTime = DateTime.UtcNow;
        }
        catch { }
    }

    static void SampleCpu()
    {
        try
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                SampleCpuLinux();
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                SampleCpuWindows();
            }
        }
        catch { }
    }

    static void SampleCpuLinux()
    {
        if (ReadLinuxCpuJiffies(out long idle, out long total))
        {
            long deltaIdle = idle - _prevIdleJiffies;
            long deltaTotal = total - _prevTotalJiffies;
            if (deltaTotal > 0)
            {
                _lastCpuPercent = Math.Clamp((1.0 - (double)deltaIdle / deltaTotal) * 100, 0, 100);
            }
            _prevIdleJiffies = idle;
            _prevTotalJiffies = total;
        }
    }

    static bool ReadLinuxCpuJiffies(out long idle, out long total)
    {
        idle = 0; total = 0;
        try
        {
            string[] lines = File.ReadAllLines("/proc/stat");
            string? cpuLine = lines.FirstOrDefault(l => l.StartsWith("cpu "));
            if (cpuLine == null) return false;

            var parts = cpuLine.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            if (parts.Length < 5) return false;

            // cpu user nice system idle [iowait irq softirq steal]
            long user = long.Parse(parts[1]);
            long nice = long.Parse(parts[2]);
            long system = long.Parse(parts[3]);
            idle = long.Parse(parts[4]);
            long iowait = parts.Length > 5 ? long.Parse(parts[5]) : 0;
            long irq = parts.Length > 6 ? long.Parse(parts[6]) : 0;
            long softirq = parts.Length > 7 ? long.Parse(parts[7]) : 0;
            long steal = parts.Length > 8 ? long.Parse(parts[8]) : 0;

            idle += iowait;
            total = user + nice + system + idle + irq + softirq + steal;
            return true;
        }
        catch { return false; }
    }

    static void SampleCpuWindows()
    {
        // Use GetSystemTimes via P/Invoke for system-wide CPU on Windows
        if (GetSystemTimes(out long idleTime, out long kernelTime, out long userTime))
        {
            long totalTime = kernelTime + userTime; // kernel includes idle
            long deltaIdle = idleTime - _prevIdleJiffies;
            long deltaTotal = totalTime - _prevTotalJiffies;
            if (deltaTotal > 0)
            {
                _lastCpuPercent = Math.Clamp((1.0 - (double)deltaIdle / deltaTotal) * 100, 0, 100);
            }
            _prevIdleJiffies = idleTime;
            _prevTotalJiffies = totalTime;
        }
    }

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool GetSystemTimes(out long idleTime, out long kernelTime, out long userTime);

    // ── Memory ──────────────────────────────────────────────────────

    static (double usedMB, double totalMB) GetMemoryInfo()
    {
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            try
            {
                string[] lines = File.ReadAllLines("/proc/meminfo");
                long totalKB = 0, availKB = 0;
                foreach (var line in lines)
                {
                    if (line.StartsWith("MemTotal:"))
                        totalKB = ParseMemInfoValue(line);
                    else if (line.StartsWith("MemAvailable:"))
                        availKB = ParseMemInfoValue(line);
                }
                double totalMB = totalKB / 1024.0;
                double usedMB = (totalKB - availKB) / 1024.0;
                return (usedMB, totalMB);
            }
            catch { }
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            try
            {
                var memStatus = new MEMORYSTATUSEX { dwLength = 64 };
                if (GlobalMemoryStatusEx(ref memStatus))
                {
                    double totalMB = memStatus.ullTotalPhys / (1024.0 * 1024);
                    double availMB = memStatus.ullAvailPhys / (1024.0 * 1024);
                    return (totalMB - availMB, totalMB);
                }
            }
            catch { }
        }

        // Last resort fallback
        var gcInfo = GC.GetGCMemoryInfo();
        return (gcInfo.HeapSizeBytes / (1024.0 * 1024), gcInfo.TotalAvailableMemoryBytes / (1024.0 * 1024));
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct MEMORYSTATUSEX
    {
        public int dwLength;
        public int dwMemoryLoad;
        public ulong ullTotalPhys;
        public ulong ullAvailPhys;
        public ulong ullTotalPageFile;
        public ulong ullAvailPageFile;
        public ulong ullTotalVirtual;
        public ulong ullAvailVirtual;
        public ulong ullAvailExtendedVirtual;
    }

    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool GlobalMemoryStatusEx(ref MEMORYSTATUSEX lpBuffer);

    static long ParseMemInfoValue(string line)
    {
        var parts = line.Split(':', 2);
        if (parts.Length == 2)
        {
            string val = parts[1].Trim().Replace("kB", "").Trim();
            if (long.TryParse(val, out long result)) return result;
        }
        return 0;
    }

    // ── JSON helpers ────────────────────────────────────────────────

    static void SendJson(object obj)
    {
        string json = JsonSerializer.Serialize(obj, JsonOpts);
        Console.WriteLine(json);
        Console.Out.Flush();
    }

    static void SendLog(string message)
    {
        SendJson(new { type = "log", message });
    }

    static void SendError(string id, string message)
    {
        SendJson(new { type = "error", id, message });
    }
}