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

Sources/Bridging/MacMonitor-Bridging-Header.h

@@ -23,5 +23,7 @@
 #import "MMLoadAverageProvider.h"
 #import "MMDiskIOProvider.h"
 #import "MMNetworkBandwidthProvider.h"
+#import "MMNetworkSocketsProvider.h"
+#import "MMProcessTelemetryProvider.h"
 
 #endif /* MacMonitor_Bridging_Header_h */

Sources/Telemetry/Network/MMNetworkSocketsProvider.h

@@ -0,0 +1,27 @@
+#ifndef MMNetworkSocketsProvider_h
+#define MMNetworkSocketsProvider_h
+
+#import <Foundation/Foundation.h>
+#import "MMTelemetryProvider.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * MMNetworkSocketsProvider
+ * Inspects system-wide open TCP and UDP sockets, local/remote endpoints, connection states,
+ * and owning processes.
+ */
+@interface MMNetworkSocketsProvider : NSObject <MMTelemetryProvider>
+
+- (instancetype)init;
+
+/**
+ * Pure calculator / summarizer method for deterministic unit testing.
+ */
++ (NSDictionary<NSString *, id> *)calculateSocketSummaryWithSocketList:(NSArray<NSDictionary<NSString *, id> *> *)sockets;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* MMNetworkSocketsProvider_h */

Sources/Telemetry/Network/MMNetworkSocketsProvider.m

@@ -0,0 +1,152 @@
+#import "MMNetworkSocketsProvider.h"
+#import <libproc.h>
+#import <sys/proc_info.h>
+#import <arpa/inet.h>
+
+@implementation MMNetworkSocketsProvider
+
+- (instancetype)init {
+    self = [super init];
+    return self;
+}
+
+- (MMTelemetryDomain)domain {
+    return MMTelemetryDomainNetwork;
+}
+
+- (NSString *)providerIdentifier {
+    return @"com.i3omb.macmonitor.telemetry.network.sockets";
+}
+
+- (BOOL)isAvailable {
+    return YES;
+}
+
+static NSString *tcpStateString(int state) {
+    switch (state) {
+        case 0: return @"CLOSED";
+        case 1: return @"LISTEN";
+        case 2: return @"SYN_SENT";
+        case 3: return @"SYN_RCVD";
+        case 4: return @"ESTABLISHED";
+        case 5: return @"CLOSE_WAIT";
+        case 6: return @"FIN_WAIT_1";
+        case 7: return @"CLOSING";
+        case 8: return @"LAST_ACK";
+        case 9: return @"FIN_WAIT_2";
+        case 10: return @"TIME_WAIT";
+        default: return @"UNKNOWN";
+    }
+}
+
++ (NSDictionary<NSString *, id> *)calculateSocketSummaryWithSocketList:(NSArray<NSDictionary<NSString *, id> *> *)sockets {
+    NSUInteger tcpCount = 0;
+    NSUInteger udpCount = 0;
+    NSUInteger listenCount = 0;
+    NSUInteger establishedCount = 0;
+    
+    for (NSDictionary<NSString *, id> *sock in sockets) {
+        NSString *proto = sock[@"protocol"];
+        NSString *state = sock[@"state"];
+        
+        if ([proto isEqualToString:@"TCP"]) {
+            tcpCount++;
+            if ([state isEqualToString:@"LISTEN"]) {
+                listenCount++;
+            } else if ([state isEqualToString:@"ESTABLISHED"]) {
+                establishedCount++;
+            }
+        } else if ([proto isEqualToString:@"UDP"]) {
+            udpCount++;
+        }
+    }
+    
+    return @{
+        @"socketCount": @(sockets.count),
+        @"tcpCount": @(tcpCount),
+        @"udpCount": @(udpCount),
+        @"listenCount": @(listenCount),
+        @"establishedCount": @(establishedCount),
+        @"sockets": sockets
+    };
+}
+
+- (nullable NSDictionary<NSString *, id> *)sampleTelemetryWithError:(NSError **)error {
+    int pids[2048];
+    int bytes = proc_listpids(PROC_ALL_PIDS, 0, pids, sizeof(pids));
+    int pidCount = bytes / sizeof(int);
+    
+    NSMutableArray<NSDictionary<NSString *, id> *> *sockets = [NSMutableArray array];
+    
+    for (int i = 0; i < pidCount; i++) {
+        pid_t pid = pids[i];
+        if (pid <= 0) continue;
+        
+        int sz = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, NULL, 0);
+        if (sz <= 0) continue;
+        
+        struct proc_fdinfo *fds = malloc(sz);
+        if (!fds) continue;
+        
+        int actual = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, fds, sz);
+        int fdCount = actual / sizeof(struct proc_fdinfo);
+        
+        char procNameBuf[256] = {0};
+        BOOL procNameFetched = NO;
+        
+        for (int j = 0; j < fdCount; j++) {
+            if (fds[j].proc_fdtype == PROX_FDTYPE_SOCKET) {
+                struct socket_fdinfo si;
+                if (proc_pidfdinfo(pid, fds[j].proc_fd, PROC_PIDFDSOCKETINFO, &si, sizeof(si)) == sizeof(si)) {
+                    int family = si.psi.soi_family;
+                    if (family == AF_INET || family == AF_INET6) {
+                        if (!procNameFetched) {
+                            proc_name(pid, procNameBuf, sizeof(procNameBuf));
+                            procNameFetched = YES;
+                        }
+                        
+                        char localIP[INET6_ADDRSTRLEN] = {0};
+                        char remoteIP[INET6_ADDRSTRLEN] = {0};
+                        int lport = 0, rport = 0;
+                        NSString *familyStr = (family == AF_INET) ? @"IPv4" : @"IPv6";
+                        NSString *proto = (si.psi.soi_type == SOCK_STREAM) ? @"TCP" : @"UDP";
+                        NSString *state = @"NONE";
+                        
+                        if (family == AF_INET) {
+                            inet_ntop(AF_INET, &si.psi.soi_proto.pri_in.insi_laddr.ina_46.i46a_addr4, localIP, sizeof(localIP));
+                            inet_ntop(AF_INET, &si.psi.soi_proto.pri_in.insi_faddr.ina_46.i46a_addr4, remoteIP, sizeof(remoteIP));
+                            lport = ntohs(si.psi.soi_proto.pri_in.insi_lport);
+                            rport = ntohs(si.psi.soi_proto.pri_in.insi_fport);
+                        } else {
+                            inet_ntop(AF_INET6, &si.psi.soi_proto.pri_in.insi_laddr.ina_6, localIP, sizeof(localIP));
+                            inet_ntop(AF_INET6, &si.psi.soi_proto.pri_in.insi_faddr.ina_6, remoteIP, sizeof(remoteIP));
+                            lport = ntohs(si.psi.soi_proto.pri_in.insi_lport);
+                            rport = ntohs(si.psi.soi_proto.pri_in.insi_fport);
+                        }
+                        
+                        if (si.psi.soi_type == SOCK_STREAM) {
+                            state = tcpStateString(si.psi.soi_proto.pri_tcp.tcpsi_state);
+                        }
+                        
+                        [sockets addObject:@{
+                            @"pid": @(pid),
+                            @"processName": [NSString stringWithUTF8String:procNameBuf],
+                            @"protocol": proto,
+                            @"family": familyStr,
+                            @"localAddress": [NSString stringWithUTF8String:localIP],
+                            @"localPort": @(lport),
+                            @"remoteAddress": [NSString stringWithUTF8String:remoteIP],
+                            @"remotePort": @(rport),
+                            @"state": state
+                        }];
+                    }
+                }
+            }
+        }
+        free(fds);
+    }
+    
+    return [MMNetworkSocketsProvider calculateSocketSummaryWithSocketList:sockets];
+}
+
+@end

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/MMNetworkSocketsTests.swift

@@ -0,0 +1,68 @@
+import XCTest
+@testable import MacMonitor
+
+final class MMNetworkSocketsTests: XCTestCase {
+    
+    func testSocketSummaryCalculation() {
+        let testSockets: [[String: Any]] = [
+            [
+                "pid": 100,
+                "processName": "web_server",
+                "protocol": "TCP",
+                "family": "IPv4",
+                "localAddress": "0.0.0.0",
+                "localPort": 8080,
+                "remoteAddress": "0.0.0.0",
+                "remotePort": 0,
+                "state": "LISTEN"
+            ],
+            [
+                "pid": 200,
+                "processName": "browser",
+                "protocol": "TCP",
+                "family": "IPv4",
+                "localAddress": "192.168.1.50",
+                "localPort": 54321,
+                "remoteAddress": "142.250.190.46",
+                "remotePort": 443,
+                "state": "ESTABLISHED"
+            ],
+            [
+                "pid": 300,
+                "processName": "dns_daemon",
+                "protocol": "UDP",
+                "family": "IPv4",
+                "localAddress": "0.0.0.0",
+                "localPort": 53,
+                "remoteAddress": "0.0.0.0",
+                "remotePort": 0,
+                "state": "NONE"
+            ]
+        ]
+        
+        let summary = MMNetworkSocketsProvider.calculateSocketSummary(withSocketList: testSockets)
+        
+        let total = summary["socketCount"] as? Int ?? 0
+        let tcp = summary["tcpCount"] as? Int ?? 0
+        let udp = summary["udpCount"] as? Int ?? 0
+        let listen = summary["listenCount"] as? Int ?? 0
+        let established = summary["establishedCount"] as? Int ?? 0
+        
+        XCTAssertEqual(total, 3)
+        XCTAssertEqual(tcp, 2)
+        XCTAssertEqual(udp, 1)
+        XCTAssertEqual(listen, 1)
+        XCTAssertEqual(established, 1)
+    }
+    
+    func testLiveNetworkSocketsProvider() throws {
+        let provider = MMNetworkSocketsProvider()
+        XCTAssertEqual(provider.domain, .network)
+        XCTAssertEqual(provider.providerIdentifier, "com.i3omb.macmonitor.telemetry.network.sockets")
+        
+        let sample = try provider.sampleTelemetry()
+        XCTAssertNotNil(sample)
+        XCTAssertNotNil(sample["socketCount"])
+        XCTAssertNotNil(sample["sockets"])
+    }
+}

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"])
+    }
+}