Skip to content

Open source Grok Bot alternative, Bring your own agent and subscription: message Claude Code, Codex, Gemini CLI, Cursor, Copilot and 40+ AI agents as bots on your own computer, from iPhone, Mac, Windows, Linux or terminal. Agent-agnostic and free. Also a Muse and Dots alternative. Built in Rust.

feat: add SessionScanner and SessionStateManager

libokaibdbfcc65e77b
diff --git a/CodePulse-macOS/Services/SessionScanner.swift b/CodePulse-macOS/Services/SessionScanner.swift
new file mode 100644
index 00000000..23598cee
--- /dev/null
+++ b/CodePulse-macOS/Services/SessionScanner.swift
@@ -0,0 +1,65 @@
+import Foundation
+import Combine
+
+@MainActor
+final class SessionScanner: ObservableObject {
+ @Published var activeSessions: [String: RawSessionFile] = [:]
+
+ private var sessionsWatcher: DispatchSourceFileSystemObject?
+ private var scanTimer: Timer?
+ private let debounceInterval: TimeInterval = 1.0
+ private var debounceTask: Task<Void, Never>?
+
+ func start() {
+ scan()
+ watchDirectory(ClaudePaths.sessionsDir) { [weak self] in
+ self?.scheduleScan()
+ }
+ scanTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { [weak self] _ in
+ Task { @MainActor in
+ self?.scan()
+ }
+ }
+ }
+
+ func stop() {
+ sessionsWatcher?.cancel()
+ sessionsWatcher = nil
+ scanTimer?.invalidate()
+ scanTimer = nil
+ debounceTask?.cancel()
+ }
+
+ private func scheduleScan() {
+ debounceTask?.cancel()
+ debounceTask = Task { @MainActor in
+ try? await Task.sleep(for: .seconds(debounceInterval))
+ guard !Task.isCancelled else { return }
+ scan()
+ }
+ }
+
+ func scan() {
+ let files = SessionFileParser.parseSessionFiles()
+ var newSessions: [String: RawSessionFile] = [:]
+ for file in files {
+ guard PIDChecker.isAlive(pid: file.pid) else { continue }
+ newSessions[file.sessionId] = file
+ }
+ activeSessions = newSessions
+ }
+
+ private func watchDirectory(_ url: URL, handler: @escaping () -> Void) {
+ let fd = open(url.path, O_EVTONLY)
+ guard fd >= 0 else { return }
+ let source = DispatchSource.makeFileSystemObjectSource(
+ fileDescriptor: fd,
+ eventMask: [.write, .rename, .delete],
+ queue: .main
+ )
+ source.setEventHandler(handler: handler)
+ source.setCancelHandler { close(fd) }
+ source.resume()
+ sessionsWatcher = source
+ }
+}
diff --git a/CodePulse-macOS/Services/SessionStateManager.swift b/CodePulse-macOS/Services/SessionStateManager.swift
new file mode 100644
index 00000000..bca1adce
--- /dev/null
+++ b/CodePulse-macOS/Services/SessionStateManager.swift
@@ -0,0 +1,103 @@
+import Foundation
+import Combine
+import CodePulseShared
+
+@MainActor
+final class SessionStateManager: ObservableObject {
+ @Published var sessions: [SessionState] = []
+
+ private let scanner: SessionScanner
+ private var cancellables = Set<AnyCancellable>()
+ private var jsonlSizes: [String: UInt64] = [:]
+ private var jsonlSizeTimestamps: [String: Date] = [:]
+ private let deviceId = Host.current().localizedName ?? UUID().uuidString
+
+ init(scanner: SessionScanner) {
+ self.scanner = scanner
+ scanner.$activeSessions
+ .debounce(for: .seconds(1), scheduler: RunLoop.main)
+ .sink { [weak self] rawSessions in
+ self?.updateSessions(from: rawSessions)
+ }
+ .store(in: &cancellables)
+ }
+
+ private func updateSessions(from rawSessions: [String: RawSessionFile]) {
+ var updated: [SessionState] = []
+
+ for (sessionId, raw) in rawSessions {
+ let tasks = SessionFileParser.parseTasks(sessionId: sessionId)
+ let indexEntry = SessionFileParser.parseSessionIndex(cwd: raw.cwd, sessionId: sessionId)
+ let jsonlUrl = ClaudePaths.jsonlPath(cwd: raw.cwd, sessionId: sessionId)
+ let jsonlInfo = JSONLTailReader.extractInfo(url: jsonlUrl)
+ let status = detectStatus(raw: raw, tasks: tasks, jsonlUrl: jsonlUrl)
+
+ let projectName = URL(fileURLWithPath: raw.cwd).lastPathComponent
+ let startDate = Date(timeIntervalSince1970: TimeInterval(raw.startedAt) / 1000)
+ let duration = Int(Date().timeIntervalSince(startDate))
+ let currentTask = tasks.first(where: { $0.status == .inProgress })?.activeForm
+
+ let summary = indexEntry?.summary
+ ?? indexEntry?.firstPrompt.map { String($0.prefix(50)) }
+ ?? projectName
+
+ let session = SessionState(
+ sessionId: sessionId,
+ projectName: projectName,
+ gitBranch: indexEntry?.gitBranch ?? "unknown",
+ status: status,
+ model: formatModel(jsonlInfo.model),
+ summary: summary,
+ currentTask: currentTask,
+ tasks: tasks,
+ contextPct: jsonlInfo.contextPct,
+ costUSD: jsonlInfo.costUSD,
+ startedAt: startDate,
+ durationSec: duration,
+ deviceId: deviceId,
+ updatedAt: Date()
+ )
+ updated.append(session)
+ }
+
+ // Mark recently disappeared sessions as completed
+ for existing in sessions where existing.status != .completed {
+ if !rawSessions.keys.contains(existing.sessionId) {
+ var completed = existing
+ completed.status = .completed
+ completed.updatedAt = Date()
+ updated.append(completed)
+ }
+ }
+
+ sessions = updated.sorted { $0.startedAt > $1.startedAt }
+ }
+
+ private func detectStatus(raw: RawSessionFile, tasks: [TaskItem], jsonlUrl: URL) -> SessionStatus {
+ guard PIDChecker.isAlive(pid: raw.pid) else { return .completed }
+ if tasks.contains(where: { $0.status == .inProgress }) { return .working }
+
+ let currentSize = JSONLTailReader.fileSize(url: jsonlUrl) ?? 0
+ let previousSize = jsonlSizes[raw.sessionId] ?? currentSize
+ let lastChange = jsonlSizeTimestamps[raw.sessionId] ?? Date()
+
+ if currentSize != previousSize {
+ jsonlSizes[raw.sessionId] = currentSize
+ jsonlSizeTimestamps[raw.sessionId] = Date()
+ return .working
+ }
+
+ if Date().timeIntervalSince(lastChange) > 30 {
+ return .needsInput
+ }
+
+ return .idle
+ }
+
+ private func formatModel(_ raw: String) -> String {
+ if raw.contains("opus") { return "Opus" }
+ if raw.contains("sonnet") { return "Sonnet" }
+ if raw.contains("haiku") { return "Haiku" }
+ return raw
+ }
+}