feat(telemetry): implement live process explorer and resource attribution provider (fixes #11)

Sources/Bridging/MacMonitor-Bridging-Header.h

@@ -24,5 +24,6 @@
 #import "MMDiskIOProvider.h"
 #import "MMNetworkBandwidthProvider.h"
 #import "MMNetworkSocketsProvider.h"
+#import "MMProcessTelemetryProvider.h"
 
 #endif /* MacMonitor_Bridging_Header_h */

Sources/Telemetry/Process/MMProcessTelemetryProvider.h

@@ -0,0 +1,34 @@
+#ifndef MMProcessTelemetryProvider_h
+#define MMProcessTelemetryProvider_h
+
+#import <Foundation/Foundation.h>
+#import "MMTelemetryProvider.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * MMProcessTelemetryProvider
+ * Live process explorer sampling CPU utilization, resident memory (RSS),
+ * virtual memory, thread counts, and process hierarchy.
+ */
+@interface MMProcessTelemetryProvider : NSObject <MMTelemetryProvider>
+
+- (instancetype)init;
+
+/**
+ * Safely terminates a process via SIGTERM or SIGKILL.
+ */
++ (BOOL)terminateProcessWithPID:(pid_t)pid force:(BOOL)force;
+
+/**
+ * Pure calculator method for deterministic unit testing.
+ */
++ (NSArray<NSDictionary<NSString *, id> *> *)calculateProcessListWithRawProcesses:(NSArray<NSDictionary<NSString *, id> *> *)rawProcesses
+                                                                previousCPUTimes:(nullable NSDictionary<NSNumber *, NSNumber *> *)previousCPUTimes
+                                                                       timeDelta:(NSTimeInterval)timeDelta;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* MMProcessTelemetryProvider_h */

Sources/Telemetry/Process/MMProcessTelemetryProvider.m

@@ -0,0 +1,160 @@
+#import "MMProcessTelemetryProvider.h"
+#import <libproc.h>
+#import <sys/proc_info.h>
+#import <pwd.h>
+#import <signal.h>
+#import <mach/mach_time.h>
+#import <os/lock.h>
+
+@interface MMProcessTelemetryProvider () {
+    os_unfair_lock _lock;
+    NSMutableDictionary<NSNumber *, NSNumber *> *_previousCPUTimes;
+    uint64_t _previousTimestamp;
+    mach_timebase_info_data_t _timebase;
+    NSMutableDictionary<NSNumber *, NSString *> *_usernameCache;
+}
+@end
+
+@implementation MMProcessTelemetryProvider
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _lock = OS_UNFAIR_LOCK_INIT;
+        _previousCPUTimes = [NSMutableDictionary dictionary];
+        _previousTimestamp = 0;
+        _usernameCache = [NSMutableDictionary dictionary];
+        mach_timebase_info(&_timebase);
+    }
+    return self;
+}
+
+- (MMTelemetryDomain)domain {
+    return MMTelemetryDomainProcess;
+}
+
+- (NSString *)providerIdentifier {
+    return @"com.i3omb.macmonitor.telemetry.process";
+}
+
+- (BOOL)isAvailable {
+    return YES;
+}
+
++ (BOOL)terminateProcessWithPID:(pid_t)pid force:(BOOL)force {
+    int sig = force ? SIGKILL : SIGTERM;
+    return kill(pid, sig) == 0;
+}
+
++ (NSArray<NSDictionary<NSString *, id> *> *)calculateProcessListWithRawProcesses:(NSArray<NSDictionary<NSString *, id> *> *)rawProcesses
+                                                                previousCPUTimes:(nullable NSDictionary<NSNumber *, NSNumber *> *)previousCPUTimes
+                                                                       timeDelta:(NSTimeInterval)timeDelta {
+    NSMutableArray<NSDictionary<NSString *, id> *> *processed = [NSMutableArray arrayWithCapacity:rawProcesses.count];
+    
+    for (NSDictionary<NSString *, id> *raw in rawProcesses) {
+        NSNumber *pidNum = raw[@"pid"];
+        uint64_t currCPUTime = [raw[@"cpuTimeNs"] unsignedLongLongValue];
+        
+        double cpuPercent = 0.0;
+        if (previousCPUTimes && previousCPUTimes[pidNum]) {
+            uint64_t prevCPUTime = [previousCPUTimes[pidNum] unsignedLongLongValue];
+            if (currCPUTime >= prevCPUTime && timeDelta > 0.001) {
+                uint64_t deltaNs = currCPUTime - prevCPUTime;
+                double deltaSec = (double)deltaNs / 1e9;
+                cpuPercent = (deltaSec / timeDelta) * 100.0;
+            }
+        }
+        
+        NSMutableDictionary<NSString *, id> *entry = [raw mutableCopy];
+        entry[@"cpuPercent"] = @(cpuPercent);
+        [processed addObject:entry];
+    }
+    
+    // Sort descending by cpuPercent
+    [processed sortUsingComparator:^NSComparisonResult(NSDictionary<NSString *, id> *obj1, NSDictionary<NSString *, id> *obj2) {
+        NSNumber *c1 = obj1[@"cpuPercent"];
+        NSNumber *c2 = obj2[@"cpuPercent"];
+        return [c2 compare:c1];
+    }];
+    
+    return processed;
+}
+
+- (nullable NSDictionary<NSString *, id> *)sampleTelemetryWithError:(NSError **)error {
+    uint64_t now = mach_absolute_time();
+    
+    int pids[4096];
+    int bytes = proc_listpids(PROC_ALL_PIDS, 0, pids, sizeof(pids));
+    int pidCount = bytes / sizeof(int);
+    
+    NSMutableArray<NSDictionary<NSString *, id> *> *rawList = [NSMutableArray arrayWithCapacity:pidCount];
+    NSMutableDictionary<NSNumber *, NSNumber *> *currentCPUTimes = [NSMutableDictionary dictionaryWithCapacity:pidCount];
+    
+    NSUInteger totalThreads = 0;
+    
+    for (int i = 0; i < pidCount; i++) {
+        pid_t pid = pids[i];
+        if (pid <= 0) continue;
+        
+        struct proc_taskallinfo tai;
+        if (proc_pidinfo(pid, PROC_PIDTASKALLINFO, 0, &tai, sizeof(tai)) != sizeof(tai)) {
+            continue;
+        }
+        
+        uint64_t cpuTimeNs = tai.ptinfo.pti_total_user + tai.ptinfo.pti_total_system;
+        currentCPUTimes[@(pid)] = @(cpuTimeNs);
+        
+        totalThreads += tai.ptinfo.pti_threadnum;
+        
+        // Resolve username
+        NSNumber *uidNum = @(tai.pbsd.pbi_uid);
+        NSString *username = _usernameCache[uidNum];
+        if (!username) {
+            struct passwd *pw = getpwuid(tai.pbsd.pbi_uid);
+            username = pw ? [NSString stringWithUTF8String:pw->pw_name] : [uidNum stringValue];
+            _usernameCache[uidNum] = username;
+        }
+        
+        NSString *pname = [NSString stringWithUTF8String:tai.pbsd.pbi_name];
+        
+        [rawList addObject:@{
+            @"pid": @(pid),
+            @"ppid": @(tai.pbsd.pbi_ppid),
+            @"uid": uidNum,
+            @"username": username,
+            @"name": pname,
+            @"cpuTimeNs": @(cpuTimeNs),
+            @"residentBytes": @(tai.ptinfo.pti_resident_size),
+            @"virtualBytes": @(tai.ptinfo.pti_virtual_size),
+            @"threadCount": @(tai.ptinfo.pti_threadnum),
+            @"runningThreads": @(tai.ptinfo.pti_numrunning)
+        }];
+    }
+    
+    os_unfair_lock_lock(&_lock);
+    NSDictionary<NSNumber *, NSNumber *> *prev = [_previousCPUTimes copy];
+    uint64_t prevTime = _previousTimestamp;
+    
+    _previousCPUTimes = currentCPUTimes;
+    _previousTimestamp = now;
+    os_unfair_lock_unlock(&_lock);
+    
+    NSTimeInterval timeDelta = 1.0;
+    if (prevTime > 0) {
+        uint64_t elapsed = now - prevTime;
+        timeDelta = (double)elapsed * _timebase.numer / _timebase.denom / 1e9;
+    }
+    
+    NSArray<NSDictionary<NSString *, id> *> *processed = [MMProcessTelemetryProvider calculateProcessListWithRawProcesses:rawList
+                                                                                                          previousCPUTimes:prev
+                                                                                                                 timeDelta:timeDelta];
+    
+    return @{
+        @"processCount": @(processed.count),
+        @"totalThreads": @(totalThreads),
+        @"processes": processed,
+        @"timeDelta": @(timeDelta)
+    };
+}
+
+@end

Tests/MMProcessTests.swift

@@ -0,0 +1,69 @@
+import XCTest
+@testable import MacMonitor
+
+final class MMProcessTests: XCTestCase {
+    
+    func testProcessCPUPercentCalculation() {
+        let prevCPUTimes: [NSNumber: NSNumber] = [
+            100: NSNumber(value: 1_000_000_000), // 1.0s
+            200: NSNumber(value: 500_000_000)   // 0.5s
+        ]
+        
+        let rawProcesses: [[String: Any]] = [
+            [
+                "pid": 100,
+                "ppid": 1,
+                "uid": 501,
+                "username": "tester",
+                "name": "cpu_hog",
+                "cpuTimeNs": NSNumber(value: 2_000_000_000), // delta = 1.0s over 2.0s = 50% CPU
+                "residentBytes": NSNumber(value: 50_000_000),
+                "virtualBytes": NSNumber(value: 100_000_000),
+                "threadCount": 4,
+                "runningThreads": 1
+            ],
+            [
+                "pid": 200,
+                "ppid": 1,
+                "uid": 501,
+                "username": "tester",
+                "name": "idle_app",
+                "cpuTimeNs": NSNumber(value: 520_000_000), // delta = 0.02s over 2.0s = 1% CPU
+                "residentBytes": NSNumber(value: 20_000_000),
+                "virtualBytes": NSNumber(value: 50_000_000),
+                "threadCount": 2,
+                "runningThreads": 0
+            ]
+        ]
+        
+        let timeDelta: TimeInterval = 2.0
+        
+        let results = MMProcessTelemetryProvider.calculateProcessList(
+            withRawProcesses: rawProcesses,
+            previousCPUTimes: prevCPUTimes,
+            timeDelta: timeDelta
+        )
+        
+        XCTAssertEqual(results.count, 2)
+        // First entry should be highest CPU
+        XCTAssertEqual(results[0]["name"] as? String, "cpu_hog")
+        let hogCPU = results[0]["cpuPercent"] as? Double ?? 0
+        XCTAssertEqual(hogCPU, 50.0, accuracy: 0.1)
+        
+        let idleCPU = results[1]["cpuPercent"] as? Double ?? 0
+        XCTAssertEqual(idleCPU, 1.0, accuracy: 0.1)
+    }
+    
+    func testLiveProcessProvider() throws {
+        let provider = MMProcessTelemetryProvider()
+        XCTAssertEqual(provider.domain, .process)
+        XCTAssertEqual(provider.providerIdentifier, "com.i3omb.macmonitor.telemetry.process")
+        
+        let sample = try provider.sampleTelemetry()
+        XCTAssertNotNil(sample)
+        let processCount = sample["processCount"] as? Int ?? 0
+        XCTAssertGreaterThan(processCount, 0)
+        XCTAssertNotNil(sample["processes"])
+        XCTAssertNotNil(sample["totalThreads"])
+    }
+}