@lattices/cli 0.3.0

package/app/Sources/ScreenMapWindowController.swift

@@ -0,0 +1,89 @@
+import AppKit
+import SwiftUI
+
+/// Manages the unified app window (Screen Map + Settings).
+/// Singleton with show/close/toggle, plus showPage() for navigation.
+final class ScreenMapWindowController: ObservableObject {
+    static let shared = ScreenMapWindowController()
+
+    private var window: NSWindow?
+    private var controller: ScreenMapController?
+    @Published var activePage: AppPage = .screenMap
+
+    var isVisible: Bool { window?.isVisible ?? false }
+
+    /// Exposed for event monitor filtering
+    var nsWindow: NSWindow? { window }
+
+    func toggle() {
+        if let w = window, w.isVisible {
+            close()
+        } else {
+            show()
+        }
+    }
+
+    /// Show the window on the current page (defaults to Screen Map).
+    func show() {
+        if let existing = window {
+            if activePage == .screenMap {
+                controller?.enter()
+            }
+            existing.makeKeyAndOrderFront(nil)
+            NSApp.activate(ignoringOtherApps: true)
+            return
+        }
+
+        let ctrl = ScreenMapController()
+        ctrl.onDismiss = { [weak self] in
+            self?.close()
+        }
+        if activePage == .screenMap {
+            ctrl.enter()
+        }
+
+        let screens = NSScreen.screens
+        let primaryHeight = screens.first?.frame.height ?? 0
+        var bbox = CGRect.zero
+        for (i, screen) in screens.enumerated() {
+            let cgY = primaryHeight - screen.frame.maxY
+            let cgRect = CGRect(x: screen.frame.origin.x, y: cgY,
+                                width: screen.frame.width, height: screen.frame.height)
+            bbox = i == 0 ? cgRect : bbox.union(cgRect)
+        }
+        let aspectRatio = bbox.width / max(bbox.height, 1)
+        let windowWidth = max(860, CGFloat(620) * aspectRatio + 100)
+
+        let view = AppShellView(controller: ctrl)
+
+        let w = AppWindowShell.makeWindow(
+            config: .init(
+                title: "Lattices",
+                initialSize: NSSize(width: windowWidth, height: 620),
+                minSize: NSSize(width: 600, height: 400),
+                maxSize: NSSize(width: 2400, height: 1600)
+            ),
+            rootView: view
+        )
+        AppWindowShell.positionCentered(w)
+        AppWindowShell.present(w)
+
+        self.window = w
+        self.controller = ctrl
+    }
+
+    /// Navigate to a specific page, opening the window if needed.
+    func showPage(_ page: AppPage) {
+        activePage = page
+        show()
+    }
+
+    func close() {
+        controller?.endPreview()
+        window?.orderOut(nil)
+        window = nil
+        controller = nil
+        activePage = .screenMap
+        AppDelegate.updateActivationPolicy()
+    }
+}

package/app/Sources/SessionManager.swift

@@ -0,0 +1,72 @@
+import AppKit
+
+enum SessionManager {
+    private static let latticesPath = "/opt/homebrew/bin/lattices"
+    private static let tmuxPath = "/opt/homebrew/bin/tmux"
+
+    /// Launch or reattach — if session is running, find and focus the existing window
+    static func launch(project: Project) {
+        let terminal = Preferences.shared.terminal
+        if project.isRunning {
+            terminal.focusOrAttach(session: project.sessionName)
+        } else {
+            terminal.launch(command: latticesPath, in: project.path)
+        }
+    }
+
+    /// Detach all clients from a tmux session (keeps it running)
+    static func detach(project: Project) {
+        detachByName(project.sessionName)
+    }
+
+    /// Detach all clients by session name string (for layer switching without a Project object)
+    static func detachByName(_ sessionName: String) {
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: tmuxPath)
+        task.arguments = ["detach-client", "-s", sessionName]
+        task.standardOutput = FileHandle.nullDevice
+        task.standardError = FileHandle.nullDevice
+        try? task.run()
+        task.waitUntilExit()
+    }
+
+    /// Kill a tmux session
+    static func kill(project: Project) {
+        killByName(project.sessionName)
+    }
+
+    /// Kill a tmux session by name string (for orphan sessions without a Project object)
+    static func killByName(_ sessionName: String) {
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: tmuxPath)
+        task.arguments = ["kill-session", "-t", sessionName]
+        task.standardOutput = FileHandle.nullDevice
+        task.standardError = FileHandle.nullDevice
+        try? task.run()
+        task.waitUntilExit()
+    }
+
+    /// Reconcile session state to match declared config (recreate missing panes)
+    static func sync(project: Project) {
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: latticesPath)
+        task.arguments = ["sync"]
+        task.currentDirectoryURL = URL(fileURLWithPath: project.path)
+        task.standardOutput = FileHandle.nullDevice
+        task.standardError = FileHandle.nullDevice
+        try? task.run()
+        task.waitUntilExit()
+    }
+
+    /// Restart a specific pane's process (kill + re-run declared command)
+    static func restart(project: Project, paneName: String? = nil) {
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: latticesPath)
+        task.arguments = paneName != nil ? ["restart", paneName!] : ["restart"]
+        task.currentDirectoryURL = URL(fileURLWithPath: project.path)
+        task.standardOutput = FileHandle.nullDevice
+        task.standardError = FileHandle.nullDevice
+        try? task.run()
+        task.waitUntilExit()
+    }
+}