@lattices/cli 0.3.0

package/app/Sources/ProcessModel.swift

@@ -0,0 +1,199 @@
+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/app/Sources/ProcessQuery.swift

@@ -0,0 +1,151 @@
+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) ?? ""
+    }
+}

package/app/Sources/Project.swift

@@ -0,0 +1,28 @@
+import CryptoKit
+import Foundation
+
+struct Project: Identifiable {
+    let id: String
+    let path: String
+    let name: String
+    let devCommand: String?
+    let packageManager: String?
+    let hasConfig: Bool
+    let paneCount: Int
+    let paneNames: [String]
+    let paneSummary: String
+    var isRunning: Bool
+
+    /// Unique session name: basename-{6-char SHA256 hash of full path}
+    /// Must match the JS `toSessionName()` in lattices.js exactly
+    var sessionName: String {
+        let base = name.replacingOccurrences(
+            of: "[^a-zA-Z0-9_-]",
+            with: "-",
+            options: .regularExpression
+        )
+        let hash = SHA256.hash(data: Data(path.utf8))
+        let short = hash.prefix(3).map { String(format: "%02x", $0) }.joined()
+        return "\(base)-\(short)"
+    }
+}