@lattices/cli 0.4.14 → 0.5.0

package/apps/mac/Sources/Core/System/PermissionChecker.swift

@@ -1,224 +0,0 @@
-import AppKit
-import SwiftUI
-import Combine
-import ScreenCaptureKit
-
-final class PermissionChecker: ObservableObject {
-    static let shared = PermissionChecker()
-
-    @Published var accessibility: Bool = false
-    @Published var screenRecording: Bool = false
-
-    private var pollTimer: Timer?
-    private var hasLoggedInitial = false
-
-    var allGranted: Bool { accessibility && screenRecording }
-
-    var isSimulatingMissingPermissions: Bool {
-        CommandLine.arguments.contains("--simulate-missing-permissions")
-            || UserDefaults.standard.bool(forKey: "permissions.simulateMissing")
-    }
-
-    /// Check current permission state without prompting.
-    func check(pollIfMissing: Bool = false) {
-        let diag = DiagnosticLog.shared
-
-        let realAX = AXIsProcessTrusted()
-        let realSR = CGPreflightScreenCaptureAccess()
-        let simulating = isSimulatingMissingPermissions
-        let ax = simulating ? false : realAX
-        let sr = simulating ? false : realSR
-
-        // First check: log identity info only
-        if !hasLoggedInitial {
-            hasLoggedInitial = true
-            let bundleId = Bundle.main.bundleIdentifier ?? "<no bundle id>"
-            let execPath = Bundle.main.executablePath ?? ProcessInfo.processInfo.arguments.first ?? "<unknown>"
-            let pid = ProcessInfo.processInfo.processIdentifier
-            diag.info("PermissionChecker: bundleId=\(bundleId) pid=\(pid)")
-            diag.info("PermissionChecker: exec=\(execPath)")
-            diag.info("AXIsProcessTrusted() → \(realAX)")
-            diag.info("CGPreflightScreenCaptureAccess() → \(realSR)")
-            if simulating {
-                diag.warn("PermissionChecker: simulating missing permissions for UX preview")
-            }
-        }
-
-        // Log on state changes
-        if ax != accessibility || sr != screenRecording {
-            diag.info("Permissions: Accessibility \(ax ? "✓" : "✗"), Screen Recording \(sr ? "✓" : "✗")")
-        }
-
-        accessibility = ax
-        screenRecording = sr
-
-        // Only poll after an intentional permission request. A passive launch-time
-        // check should not keep nudging macOS privacy state in the background.
-        if allGranted {
-            stopPolling()
-        } else if pollIfMissing {
-            startPolling()
-        }
-    }
-
-    /// Request Accessibility permission — shows the system dialog if not yet granted,
-    /// which adds lattices to the Accessibility list and asks the user to toggle it on.
-    func requestAccessibility() {
-        let diag = DiagnosticLog.shared
-        if isSimulatingMissingPermissions {
-            diag.warn("requestAccessibility: skipped because missing-permission simulation is enabled")
-            accessibility = false
-            return
-        }
-        let beforeCheck = AXIsProcessTrusted()
-        diag.info("requestAccessibility: before=\(beforeCheck), prompting…")
-        let opts = [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
-        let result = AXIsProcessTrustedWithOptions(opts)
-        diag.info("AXIsProcessTrustedWithOptions(prompt) → \(result)")
-        accessibility = result
-        if !result {
-            diag.warn("Accessibility not granted — opening System Settings. Toggle ON in Privacy → Accessibility.")
-            openAccessibilitySettings()
-            startPolling()
-        }
-    }
-
-    /// Request Screen Recording permission — triggers the system prompt on first call,
-    /// which adds lattices to the Screen Recording list. The user toggles it on in Settings.
-    func requestScreenRecording() {
-        let diag = DiagnosticLog.shared
-        if isSimulatingMissingPermissions {
-            diag.warn("requestScreenRecording: skipped because missing-permission simulation is enabled")
-            screenRecording = false
-            return
-        }
-        let beforeCheck = CGPreflightScreenCaptureAccess()
-        diag.info("requestScreenRecording: before=\(beforeCheck), probing…")
-
-        // On newer macOS releases TCC no longer reliably prompts for screen capture
-        // through the legacy CoreGraphics request API. Warm up ScreenCaptureKit first,
-        // then fall back to opening System Settings if access is still denied.
-        if #available(macOS 15.0, *) {
-            NSApp.activate(ignoringOtherApps: true)
-            Task { @MainActor [weak self] in
-                guard let self else { return }
-
-                let shareableProbe = await self.probeScreenCaptureShareableContent()
-                diag.info("ScreenCaptureKit shareable probe → \(shareableProbe)")
-
-                if #available(macOS 15.2, *) {
-                    let afterShareable = CGPreflightScreenCaptureAccess()
-                    if !afterShareable {
-                        let screenshotProbe = await self.probeScreenCaptureScreenshot()
-                        diag.info("ScreenCaptureKit screenshot probe → \(screenshotProbe)")
-                    }
-                }
-
-                let afterCheck = CGPreflightScreenCaptureAccess()
-                diag.info("requestScreenRecording: after=\(afterCheck)")
-                self.screenRecording = afterCheck
-
-                if !afterCheck {
-                    diag.warn("Screen capture not granted — opening System Settings. On newer macOS versions this may require enabling Lattices in Privacy → Screen & System Audio Recording.")
-                    self.openScreenRecordingSettings()
-                    self.startPolling()
-                }
-            }
-            return
-        }
-
-        diag.info("requestScreenRecording: using legacy CoreGraphics request API")
-        let result = CGRequestScreenCaptureAccess()
-        diag.info("CGRequestScreenCaptureAccess() → \(result)")
-        screenRecording = result
-        if !result {
-            diag.warn("Screen capture not granted — opening System Settings. Toggle ON in Privacy → Screen Recording.")
-            openScreenRecordingSettings()
-            startPolling()
-        }
-    }
-
-    /// Opens System Settings → Privacy & Security → Accessibility
-    func openAccessibilitySettings() {
-        if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility") {
-            NSWorkspace.shared.open(url)
-        }
-    }
-
-    /// Opens System Settings → Privacy & Security → Screen Recording
-    func openScreenRecordingSettings() {
-        if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture") {
-            NSWorkspace.shared.open(url)
-        }
-    }
-
-    /// Opens System Settings → Privacy & Security → Automation.
-    func openAutomationSettings() {
-        if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Automation") {
-            NSWorkspace.shared.open(url)
-        }
-    }
-
-    /// Opens System Settings → Privacy & Security → Input Monitoring.
-    func openInputMonitoringSettings() {
-        if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_ListenEvent") {
-            NSWorkspace.shared.open(url)
-        }
-    }
-
-    @available(macOS 15.0, *)
-    private func probeScreenCaptureShareableContent() async -> String {
-        await withCheckedContinuation { continuation in
-            SCShareableContent.getExcludingDesktopWindows(true, onScreenWindowsOnly: true) { content, error in
-                if let error {
-                    continuation.resume(returning: "error \(Self.describe(error))")
-                    return
-                }
-
-                let windows = content?.windows.count ?? 0
-                let displays = content?.displays.count ?? 0
-                let apps = content?.applications.count ?? 0
-                continuation.resume(returning: "ok windows=\(windows) displays=\(displays) apps=\(apps)")
-            }
-        }
-    }
-
-    @available(macOS 15.2, *)
-    private func probeScreenCaptureScreenshot() async -> String {
-        let rect = CGRect(x: 0, y: 0, width: 1, height: 1)
-        return await withCheckedContinuation { continuation in
-            SCScreenshotManager.captureImage(in: rect) { _, error in
-                if let error {
-                    continuation.resume(returning: "error \(Self.describe(error))")
-                } else {
-                    continuation.resume(returning: "ok")
-                }
-            }
-        }
-    }
-
-    private static func describe(_ error: Error) -> String {
-        let nsError = error as NSError
-        if nsError.localizedDescription.isEmpty {
-            return "\(nsError.domain)#\(nsError.code)"
-        }
-        return "\(nsError.domain)#\(nsError.code) \(nsError.localizedDescription)"
-    }
-
-    // MARK: - Polling
-
-    /// Poll every 2 seconds to detect permission changes made in System Settings.
-    private func startPolling() {
-        guard pollTimer == nil else { return }
-        pollTimer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: true) { [weak self] _ in
-            DispatchQueue.main.async {
-                self?.check()
-            }
-        }
-    }
-
-    private func stopPolling() {
-        pollTimer?.invalidate()
-        pollTimer = nil
-    }
-}

package/apps/mac/Sources/Core/System/ProcessModel.swift

@@ -1,199 +0,0 @@
-import Foundation
-
-final class ProcessModel: ObservableObject {
-    static let shared = ProcessModel()
-
-    @Published private(set) var processTable: [Int: ProcessEntry] = [:]
-    @Published private(set) var childrenMap: [Int: [Int]] = [:]       // ppid → [child pids]
-    @Published private(set) var interesting: [ProcessEntry] = []
-
-    private var timer: DispatchSourceTimer?
-    private var lastInterestingPids: Set<Int> = []
-
-    // Terminal tab cache — refreshed lazily when terminals are queried
-    private var cachedTerminalTabs: [TerminalTab] = []
-    private var lastTabQueryTime: Date = .distantPast
-    private static let tabCacheTTL: TimeInterval = 300.0  // 5 minutes
-
-    /// Background queue for process polling — avoids blocking the main thread
-    /// with posix_spawn calls (waitUntilExit deadlocks on macOS 26 main run loop).
-    private let pollQueue = DispatchQueue(label: "lattices.process-poll", qos: .userInitiated)
-
-    func start(interval: TimeInterval = 5.0) {
-        guard timer == nil else { return }
-        DiagnosticLog.shared.info("ProcessModel: starting (interval=\(interval)s)")
-
-        let source = DispatchSource.makeTimerSource(queue: pollQueue)
-        source.schedule(deadline: .now(), repeating: interval)
-        source.setEventHandler { [weak self] in
-            self?.poll()
-        }
-        source.resume()
-        timer = source
-    }
-
-    func stop() {
-        timer?.cancel()
-        timer = nil
-    }
-
-    // MARK: - Query Methods
-
-    /// All interesting developer processes with CWDs resolved.
-    func interestingProcesses() -> [ProcessEntry] {
-        interesting
-    }
-
-    /// BFS walk all descendants of a given PID.
-    func descendants(of pid: Int) -> [ProcessEntry] {
-        var result: [ProcessEntry] = []
-        var queue = childrenMap[pid] ?? []
-        var visited: Set<Int> = [pid]
-
-        while !queue.isEmpty {
-            let childPid = queue.removeFirst()
-            guard !visited.contains(childPid) else { continue }
-            visited.insert(childPid)
-            if let entry = processTable[childPid] {
-                result.append(entry)
-            }
-            if let grandchildren = childrenMap[childPid] {
-                queue.append(contentsOf: grandchildren)
-            }
-        }
-        return result
-    }
-
-    /// BFS descendants filtered to interesting commands only.
-    func interestingDescendants(of pid: Int) -> [ProcessEntry] {
-        descendants(of: pid).filter { ProcessQuery.interestingCommands.contains($0.comm) }
-    }
-
-    // MARK: - Enrichment
-
-    struct Enrichment {
-        let process: ProcessEntry
-        let tmuxSession: String?
-        let tmuxPaneId: String?
-        let windowId: UInt32?
-    }
-
-    /// Walk ppid chain from a process upward until we find a tmux pane_pid.
-    /// Returns (sessionName, paneId) or nil.
-    func tmuxLinkage(for entry: ProcessEntry) -> (session: String, paneId: String)? {
-        let paneLookup = buildPaneLookup()
-        var current = entry.pid
-        // Walk up at most 10 hops (typically 2-3)
-        for _ in 0..<10 {
-            if let match = paneLookup[current] {
-                return match
-            }
-            guard let parent = processTable[current]?.ppid, parent != current, parent > 1 else {
-                break
-            }
-            current = parent
-        }
-        return nil
-    }
-
-    /// Enrich a single process with tmux + window linkage.
-    func enrich(_ entry: ProcessEntry) -> Enrichment {
-        if let link = tmuxLinkage(for: entry) {
-            let win = DesktopModel.shared.windowForSession(link.session)
-            return Enrichment(
-                process: entry,
-                tmuxSession: link.session,
-                tmuxPaneId: link.paneId,
-                windowId: win?.wid
-            )
-        }
-        return Enrichment(process: entry, tmuxSession: nil, tmuxPaneId: nil, windowId: nil)
-    }
-
-    /// Enrich all interesting processes.
-    func enrichedProcesses() -> [Enrichment] {
-        interesting.map { enrich($0) }
-    }
-
-    // MARK: - Terminal Synthesis (on-demand)
-
-    /// Synthesize terminal instances on demand. Merges the current process table,
-    /// tmux sessions, terminal tabs (cached), and window list into a unified view.
-    /// Called by API endpoints — no background polling needed.
-    func synthesizeTerminals() -> [TerminalInstance] {
-        // Refresh tab cache if stale
-        let now = Date()
-        if now.timeIntervalSince(lastTabQueryTime) >= Self.tabCacheTTL {
-            cachedTerminalTabs = TerminalQuery.queryAll()
-            lastTabQueryTime = now
-        }
-
-        return TerminalSynthesizer.synthesize(
-            processTable: processTable,
-            interesting: interesting,
-            tmuxSessions: TmuxModel.shared.sessions,
-            terminalTabs: cachedTerminalTabs,
-            windows: DesktopModel.shared.windows
-        )
-    }
-
-    /// Force-refresh the terminal tab cache (e.g. on first query or explicit refresh).
-    func refreshTerminalTabs() {
-        cachedTerminalTabs = TerminalQuery.queryAll()
-        lastTabQueryTime = Date()
-    }
-
-    // MARK: - Polling (runs on pollQueue)
-
-    func poll() {
-        // 1. Full process snapshot
-        var table = ProcessQuery.snapshot()
-
-        // 2. Build parent → children map
-        var children: [Int: [Int]] = [:]
-        for (pid, entry) in table {
-            children[entry.ppid, default: []].append(pid)
-        }
-
-        // 3. Filter interesting, batch-resolve CWDs
-        let interestingEntries = ProcessQuery.filterInteresting(table)
-        let pids = interestingEntries.map(\.pid)
-        let cwds = ProcessQuery.batchCWD(pids: pids)
-
-        // 4. Merge CWDs back into table
-        for (pid, cwd) in cwds {
-            table[pid]?.cwd = cwd
-        }
-
-        let freshInteresting = pids.compactMap { table[$0] }
-        let freshPidSet = Set(pids)
-
-        // 5. Detect change
-        let changed = freshPidSet != lastInterestingPids
-
-        DispatchQueue.main.async {
-            self.processTable = table
-            self.childrenMap = children
-            self.interesting = freshInteresting
-        }
-
-        lastInterestingPids = freshPidSet
-
-        if changed {
-            EventBus.shared.post(.processesChanged(interesting: Array(freshPidSet)))
-        }
-    }
-
-    // MARK: - Private
-
-    /// Build [pane_pid: (sessionName, paneId)] from current TmuxModel state.
-    private func buildPaneLookup() -> [Int: (session: String, paneId: String)] {
-        var lookup: [Int: (session: String, paneId: String)] = [:]
-        for session in TmuxModel.shared.sessions {
-            for pane in session.panes {
-                lookup[pane.pid] = (session: session.name, paneId: pane.id)
-            }
-        }
-        return lookup
-    }
-}

package/apps/mac/Sources/Core/System/ProcessQuery.swift

@@ -1,151 +0,0 @@
-import Foundation
-
-// MARK: - Data Models
-
-struct ProcessEntry {
-    let pid: Int
-    let ppid: Int
-    let pgid: Int
-    let tty: String        // "ttys003" or "??"
-    let comm: String       // basename, e.g. "node"
-    let args: String       // full command line
-    var cwd: String?       // filled by batchCWD
-}
-
-// MARK: - Query
-
-enum ProcessQuery {
-
-    /// Process names we care about for developer workspace enrichment
-    static let interestingCommands: Set<String> = [
-        "claude", "node", "bun", "deno", "python", "python3",
-        "ruby", "go", "cargo", "nvim", "vim", "npm", "npx",
-        "pnpm", "swift", "make", "git"
-    ]
-
-    /// Snapshot the full process table in a single `ps` call.
-    /// Returns [pid: ProcessEntry].
-    static func snapshot() -> [Int: ProcessEntry] {
-        let raw = shell([
-            "/bin/ps", "-eo", "pid,ppid,pgid,tty,comm,args"
-        ])
-        guard !raw.isEmpty else { return [:] }
-
-        var table: [Int: ProcessEntry] = [:]
-        let lines = raw.split(separator: "\n", omittingEmptySubsequences: true)
-
-        for line in lines.dropFirst() { // skip header
-            let str = String(line)
-            // Columns are whitespace-separated; args can contain spaces.
-            // Format: "  PID  PPID  PGID TTY      COMM             ARGS"
-            let trimmed = str.trimmingCharacters(in: .whitespaces)
-            let parts = trimmed.split(separator: " ", maxSplits: 5, omittingEmptySubsequences: true)
-            guard parts.count >= 6 else { continue }
-
-            guard let pid = Int(parts[0]),
-                  let ppid = Int(parts[1]),
-                  let pgid = Int(parts[2]) else { continue }
-
-            let tty = String(parts[3])
-            let commFull = String(parts[4])
-            let args = String(parts[5])
-
-            // comm from ps is the full path; take basename
-            let comm = (commFull as NSString).lastPathComponent
-
-            table[pid] = ProcessEntry(
-                pid: pid, ppid: ppid, pgid: pgid,
-                tty: tty, comm: comm, args: args, cwd: nil
-            )
-        }
-
-        return table
-    }
-
-    /// Batch-resolve working directories for a set of PIDs via a single `lsof` call.
-    /// Returns [pid: cwdPath].
-    static func batchCWD(pids: [Int]) -> [Int: String] {
-        guard !pids.isEmpty else { return [:] }
-
-        let pidList = pids.map(String.init).joined(separator: ",")
-        let raw = shell([
-            "/usr/sbin/lsof", "-a", "-d", "cwd", "-p", pidList, "-Fn"
-        ])
-        guard !raw.isEmpty else { return [:] }
-
-        var result: [Int: String] = [:]
-        var currentPid: Int?
-
-        for line in raw.split(separator: "\n", omittingEmptySubsequences: true) {
-            let s = String(line)
-            if s.hasPrefix("p") {
-                currentPid = Int(s.dropFirst())
-            } else if s.hasPrefix("n"), let pid = currentPid {
-                result[pid] = String(s.dropFirst())
-            }
-        }
-
-        return result
-    }
-
-    /// Filter a process table down to interesting developer processes.
-    static func filterInteresting(_ table: [Int: ProcessEntry]) -> [ProcessEntry] {
-        table.values.filter { interestingCommands.contains($0.comm) }
-    }
-
-    // MARK: - Shell helper
-
-    /// Run a command and capture stdout using posix_spawn + waitpid.
-    /// Avoids Process/NSTask's waitUntilExit() which deadlocks on macOS 26
-    /// when called from GUI apps (CFRunLoop issue).
-    static func shell(_ args: [String]) -> String {
-        // Set up stdout pipe
-        var pipeFds: [Int32] = [0, 0]
-        guard pipe(&pipeFds) == 0 else { return "" }
-
-        // File actions: stdout → write end of pipe, stderr → /dev/null
-        var fileActions: posix_spawn_file_actions_t?
-        posix_spawn_file_actions_init(&fileActions)
-        posix_spawn_file_actions_adddup2(&fileActions, pipeFds[1], STDOUT_FILENO)
-        posix_spawn_file_actions_addopen(&fileActions, STDERR_FILENO, "/dev/null", O_WRONLY, 0)
-        posix_spawn_file_actions_addclose(&fileActions, pipeFds[0])
-        posix_spawn_file_actions_addclose(&fileActions, pipeFds[1])
-
-        // Build C strings
-        let cPath = args[0]
-        let cArgs = args.map { strdup($0) } + [nil]
-        defer { cArgs.compactMap({ $0 }).forEach { free($0) } }
-
-        var pid: pid_t = 0
-        let spawnResult = cPath.withCString { path in
-            posix_spawn(&pid, path, &fileActions, nil, cArgs, environ)
-        }
-        posix_spawn_file_actions_destroy(&fileActions)
-
-        // Close write end in parent
-        close(pipeFds[1])
-
-        guard spawnResult == 0 else {
-            close(pipeFds[0])
-            return ""
-        }
-
-        // Read all stdout
-        var data = Data()
-        let bufSize = 65536
-        var buf = [UInt8](repeating: 0, count: bufSize)
-        while true {
-            let n = read(pipeFds[0], &buf, bufSize)
-            if n <= 0 { break }
-            data.append(buf, count: n)
-        }
-        close(pipeFds[0])
-
-        // Wait for child
-        var status: Int32 = 0
-        waitpid(pid, &status, 0)
-
-        guard status == 0 else { return "" }
-        return String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-    }
-}