@lattices/cli 0.3.0

package/app/Sources/SettingsWindow.swift

@@ -0,0 +1,20 @@
+import AppKit
+
+/// Thin redirect — Settings is now a page inside the unified app window.
+final class SettingsWindowController {
+    static let shared = SettingsWindowController()
+
+    var isVisible: Bool { ScreenMapWindowController.shared.isVisible }
+
+    func toggle() {
+        if isVisible { close() } else { show() }
+    }
+
+    func show() {
+        ScreenMapWindowController.shared.showPage(.settings)
+    }
+
+    func close() {
+        ScreenMapWindowController.shared.close()
+    }
+}

package/app/Sources/TabGroupRow.swift

@@ -0,0 +1,178 @@
+import SwiftUI
+
+struct TabGroupRow: View {
+    let group: TabGroup
+    @ObservedObject var workspace: WorkspaceManager
+
+    @State private var isHovered = false
+    @State private var isExpanded = false
+
+    private var isRunning: Bool { workspace.isGroupRunning(group) }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            // Header row
+            HStack(spacing: 10) {
+                // Status bar
+                RoundedRectangle(cornerRadius: 1)
+                    .fill(isRunning ? Palette.running : Palette.border)
+                    .frame(width: 3, height: 32)
+
+                // Expand chevron
+                Button {
+                    withAnimation(.easeOut(duration: 0.15)) { isExpanded.toggle() }
+                } label: {
+                    Image(systemName: isExpanded ? "chevron.down" : "chevron.right")
+                        .font(.system(size: 9, weight: .semibold))
+                        .foregroundColor(Palette.textMuted)
+                        .frame(width: 14)
+                }
+                .buttonStyle(.plain)
+
+                // Info
+                VStack(alignment: .leading, spacing: 3) {
+                    HStack(spacing: 6) {
+                        Text(group.label)
+                            .font(Typo.heading(13))
+                            .foregroundColor(Palette.text)
+                            .lineLimit(1)
+
+                        Text("\(group.tabs.count) tabs")
+                            .font(Typo.mono(9))
+                            .foregroundColor(Palette.textMuted)
+                            .padding(.horizontal, 5)
+                            .padding(.vertical, 1)
+                            .background(
+                                RoundedRectangle(cornerRadius: 3)
+                                    .fill(Palette.surface)
+                            )
+                    }
+
+                    Text(group.tabs.map { $0.label ?? ($0.path as NSString).lastPathComponent }.joined(separator: " \u{00B7} "))
+                        .font(Typo.mono(10))
+                        .foregroundColor(Palette.textMuted)
+                        .lineLimit(1)
+                }
+
+                Spacer()
+
+                // Actions
+                HStack(spacing: 4) {
+                    if isRunning {
+                        Button {
+                            workspace.killGroup(group)
+                            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                                ProjectScanner.shared.refreshStatus()
+                            }
+                        } label: {
+                            Text("Kill")
+                                .angularButton(Palette.kill, filled: false)
+                        }
+                        .buttonStyle(.plain)
+                    }
+
+                    Button {
+                        if isRunning {
+                            // Focus the first tab's session
+                            if let firstTab = group.tabs.first {
+                                let session = WorkspaceManager.sessionName(for: firstTab.path)
+                                let terminal = Preferences.shared.terminal
+                                terminal.focusOrAttach(session: session)
+                            }
+                        } else {
+                            workspace.launchGroup(group)
+                        }
+                    } label: {
+                        Text(isRunning ? "Attach" : "Launch")
+                            .angularButton(isRunning ? Palette.running : Palette.launch)
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+            .padding(.horizontal, 10)
+            .padding(.vertical, 8)
+            .glassCard(hovered: isHovered)
+
+            // Expanded tab list
+            if isExpanded {
+                VStack(spacing: 2) {
+                    ForEach(Array(group.tabs.enumerated()), id: \.offset) { idx, tab in
+                        tabRow(tab: tab, index: idx)
+                    }
+                }
+                .padding(.leading, 36)
+                .padding(.trailing, 10)
+                .padding(.vertical, 4)
+                .transition(.opacity.combined(with: .move(edge: .top)))
+            }
+        }
+        .contentShape(Rectangle())
+        .onHover { isHovered = $0 }
+        .contextMenu {
+            if isRunning {
+                Button("Attach") {
+                    if let firstTab = group.tabs.first {
+                        let session = WorkspaceManager.sessionName(for: firstTab.path)
+                        let terminal = Preferences.shared.terminal
+                        terminal.focusOrAttach(session: session)
+                    }
+                }
+                Divider()
+                ForEach(Array(group.tabs.enumerated()), id: \.offset) { idx, tab in
+                    Button("Go to: \(tab.label ?? (tab.path as NSString).lastPathComponent)") {
+                        workspace.focusTab(group: group, tabIndex: idx)
+                    }
+                }
+                Divider()
+                Button("Kill Group") {
+                    workspace.killGroup(group)
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                        ProjectScanner.shared.refreshStatus()
+                    }
+                }
+            } else {
+                Button("Launch") {
+                    workspace.launchGroup(group)
+                }
+            }
+        }
+    }
+
+    private func tabRow(tab: TabGroupTab, index: Int) -> some View {
+        HStack(spacing: 8) {
+            Image(systemName: "rectangle.topthird.inset.filled")
+                .font(.system(size: 9))
+                .foregroundColor(isRunning ? Palette.running.opacity(0.7) : Palette.textMuted)
+
+            Text(tab.label ?? (tab.path as NSString).lastPathComponent)
+                .font(Typo.mono(11))
+                .foregroundColor(Palette.text)
+                .lineLimit(1)
+
+            Spacer()
+
+            if isRunning {
+                Button {
+                    workspace.focusTab(group: group, tabIndex: index)
+                } label: {
+                    Text("Go")
+                        .font(Typo.mono(9))
+                        .foregroundColor(Palette.textDim)
+                        .padding(.horizontal, 6)
+                        .padding(.vertical, 2)
+                        .background(
+                            RoundedRectangle(cornerRadius: 3)
+                                .fill(Palette.surface)
+                                .overlay(
+                                    RoundedRectangle(cornerRadius: 3)
+                                        .strokeBorder(Palette.border, lineWidth: 0.5)
+                                )
+                        )
+                }
+                .buttonStyle(.plain)
+            }
+        }
+        .padding(.horizontal, 8)
+        .padding(.vertical, 4)
+    }
+}

package/app/Sources/Terminal.swift

@@ -0,0 +1,259 @@
+import AppKit
+
+enum Terminal: String, CaseIterable, Identifiable {
+    case terminal = "Terminal"
+    case iterm2 = "iTerm2"
+    case warp = "Warp"
+    case ghostty = "Ghostty"
+    case kitty = "Kitty"
+    case alacritty = "Alacritty"
+
+    var id: String { rawValue }
+
+    var bundleId: String {
+        switch self {
+        case .terminal:  return "com.apple.Terminal"
+        case .iterm2:    return "com.googlecode.iterm2"
+        case .warp:      return "dev.warp.Warp-Stable"
+        case .ghostty:   return "com.mitchellh.ghostty"
+        case .kitty:     return "net.kovidgoyal.kitty"
+        case .alacritty: return "org.alacritty"
+        }
+    }
+
+    var isInstalled: Bool {
+        NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundleId) != nil
+    }
+
+    static var installed: [Terminal] {
+        allCases.filter(\.isInstalled)
+    }
+
+    /// Launch a command in this terminal
+    func launch(command: String, in directory: String) {
+        // Use single quotes for the shell command to avoid AppleScript escaping issues
+        let dir = directory.replacingOccurrences(of: "'", with: "'\\''")
+        let cmd = command.replacingOccurrences(of: "'", with: "'\\''")
+        let fullCmd = "cd '\(dir)' && \(cmd)"
+
+        switch self {
+        case .terminal:
+            runOsascript(
+                "tell application \"Terminal\"",
+                "activate",
+                "do script \"\(fullCmd)\"",
+                "end tell"
+            )
+
+        case .iterm2:
+            runOsascript(
+                "tell application \"iTerm2\"",
+                "activate",
+                "set newWindow to (create window with default profile)",
+                "tell current session of newWindow",
+                "write text \"\(fullCmd)\"",
+                "end tell",
+                "end tell"
+            )
+
+        case .warp:
+            let task = Process()
+            task.executableURL = URL(fileURLWithPath: "/usr/bin/open")
+            task.arguments = ["-a", "Warp", directory]
+            try? task.run()
+            task.waitUntilExit()
+            DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+                runOsascript(
+                    "tell application \"System Events\"",
+                    "tell process \"Warp\"",
+                    "keystroke \"\(cmd)\"",
+                    "keystroke return",
+                    "end tell",
+                    "end tell"
+                )
+            }
+
+        case .ghostty:
+            let task = Process()
+            task.executableURL = URL(fileURLWithPath: "/usr/bin/open")
+            task.arguments = ["-a", "Ghostty"]
+            task.environment = ["GHOSTTY_SHELL_COMMAND": fullCmd]
+            try? task.run()
+
+        case .kitty:
+            if let appUrl = NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundleId) {
+                let kittyBin = appUrl.appendingPathComponent("Contents/MacOS/kitty").path
+                let task = Process()
+                task.executableURL = URL(fileURLWithPath: kittyBin)
+                task.arguments = ["--single-instance", "--directory", directory, "sh", "-c", command]
+                try? task.run()
+            }
+
+        case .alacritty:
+            if let appUrl = NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundleId) {
+                let bin = appUrl.appendingPathComponent("Contents/MacOS/alacritty").path
+                let task = Process()
+                task.executableURL = URL(fileURLWithPath: bin)
+                task.arguments = ["--working-directory", directory, "-e", "sh", "-c", command]
+                try? task.run()
+            }
+        }
+    }
+
+    /// Launch a command in a new tab of the current terminal window
+    func launchTab(command: String, in directory: String, tabName: String? = nil) {
+        let dir = directory.replacingOccurrences(of: "'", with: "'\\''")
+        let cmd = command.replacingOccurrences(of: "'", with: "'\\''")
+        let fullCmd = "cd '\(dir)' && \(cmd)"
+
+        switch self {
+        case .iterm2:
+            var lines = [
+                "tell application \"iTerm2\"",
+                "activate",
+                "if (count of windows) = 0 then",
+                "  create window with default profile",
+                "else",
+                "  tell current window to create tab with default profile",
+                "end if",
+                "tell current session of current tab of current window",
+                "  write text \"\(fullCmd)\"",
+            ]
+            if let name = tabName {
+                let escaped = name.replacingOccurrences(of: "\"", with: "\\\"")
+                lines.append("  set name to \"\(escaped)\"")
+            }
+            lines.append("end tell")
+            lines.append("end tell")
+            runOsascriptLines(lines)
+
+        case .terminal:
+            var lines = [
+                "tell application \"Terminal\"",
+                "activate",
+                "if (count of windows) = 0 then",
+                "  do script \"\(fullCmd)\"",
+                "else",
+                "  do script \"\(fullCmd)\" in front window",
+                "end if",
+            ]
+            if let name = tabName {
+                let escaped = name.replacingOccurrences(of: "\"", with: "\\\"")
+                lines.append("set custom title of selected tab of front window to \"\(escaped)\"")
+            }
+            lines.append("end tell")
+            runOsascriptLines(lines)
+
+        default:
+            // Terminals without AppleScript tab support: fall back to new window
+            launch(command: command, in: directory)
+        }
+    }
+
+    /// Rename the current/frontmost tab in this terminal
+    func nameTab(_ name: String) {
+        let escaped = name.replacingOccurrences(of: "\"", with: "\\\"")
+        switch self {
+        case .iterm2:
+            runOsascript(
+                "tell application \"iTerm2\"",
+                "tell current session of current tab of current window",
+                "set name to \"\(escaped)\"",
+                "end tell",
+                "end tell"
+            )
+        case .terminal:
+            runOsascript(
+                "tell application \"Terminal\"",
+                "set custom title of selected tab of front window to \"\(escaped)\"",
+                "end tell"
+            )
+        default:
+            break
+        }
+    }
+
+    /// The tag we put in the terminal window title via tmux set-titles
+    static func windowTag(for session: String) -> String {
+        "[lattices:\(session)]"
+    }
+
+    /// Find and focus the existing terminal window by its [lattices:name] tag, or open a new attach
+    func focusOrAttach(session: String) {
+        let tag = Terminal.windowTag(for: session)
+
+        switch self {
+        case .terminal:
+            runOsascript(
+                "tell application \"Terminal\"",
+                "activate",
+                "set found to false",
+                "repeat with w in windows",
+                "  if name of w contains \"\(tag)\" then",
+                "    set index of w to 1",
+                "    set found to true",
+                "    exit repeat",
+                "  end if",
+                "end repeat",
+                "if not found then do script \"tmux attach -t \(session)\"",
+                "end tell"
+            )
+
+        case .iterm2:
+            // Search through all sessions in all tabs of all windows
+            runOsascript(
+                "tell application \"iTerm2\"",
+                "activate",
+                "set found to false",
+                "repeat with w in windows",
+                "  repeat with t in tabs of w",
+                "    repeat with s in sessions of t",
+                "      if name of s contains \"\(tag)\" then",
+                "        select w",
+                "        tell w to set current tab to t",
+                "        set found to true",
+                "        exit repeat",
+                "      end if",
+                "    end repeat",
+                "    if found then exit repeat",
+                "  end repeat",
+                "  if found then exit repeat",
+                "end repeat",
+                "if not found then",
+                "  if (count of windows) = 0 then",
+                "    create window with default profile",
+                "  else",
+                "    tell current window to create tab with default profile",
+                "  end if",
+                "  tell current session of current tab of current window",
+                "    write text \"tmux attach -t \(session)\"",
+                "  end tell",
+                "end if",
+                "end tell"
+            )
+
+        default:
+            // For terminals without good AppleScript support, just activate and attach
+            let task = Process()
+            task.executableURL = URL(fileURLWithPath: "/usr/bin/open")
+            task.arguments = ["-a", rawValue]
+            try? task.run()
+        }
+    }
+}
+
+/// Run an AppleScript by joining lines into a single -e script block
+private func runOsascript(_ lines: String...) {
+    runOsascriptLines(lines)
+}
+
+/// Run an AppleScript from an array of lines
+private func runOsascriptLines(_ lines: [String]) {
+    let script = lines.joined(separator: "\n")
+    let task = Process()
+    task.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")
+    task.arguments = ["-e", script]
+    task.standardOutput = FileHandle.nullDevice
+    task.standardError = FileHandle.nullDevice
+    try? task.run()
+}

package/app/Sources/TerminalQuery.swift

@@ -0,0 +1,156 @@
+import AppKit
+
+// MARK: - Data Model
+
+struct TerminalTab {
+    let app: Terminal
+    let windowIndex: Int
+    let tabIndex: Int
+    let tty: String           // normalized: "ttys003"
+    let isActiveTab: Bool
+    let title: String
+    let sessionId: String?    // iTerm2 unique ID only
+}
+
+// MARK: - Query
+
+enum TerminalQuery {
+
+    /// Normalize TTY strings: strip "/dev/" prefix if present.
+    /// iTerm2 returns "/dev/ttys003", Terminal.app and `ps` return "ttys003".
+    static func normalizeTTY(_ raw: String) -> String {
+        if raw.hasPrefix("/dev/") {
+            return String(raw.dropFirst(5))
+        }
+        return raw
+    }
+
+    /// Query all running terminal emulators for tab info.
+    /// Only queries apps that are currently running (won't auto-launch).
+    static func queryAll() -> [TerminalTab] {
+        var results: [TerminalTab] = []
+        if isAppRunning("iTerm2") {
+            results.append(contentsOf: queryITerm2())
+        }
+        if isAppRunning("Terminal") {
+            results.append(contentsOf: queryTerminalApp())
+        }
+        // Future: queryWarp(), queryGhostty(), etc.
+        return results
+    }
+
+    // MARK: - iTerm2
+
+    static func queryITerm2() -> [TerminalTab] {
+        let script = """
+        tell application "iTerm2"
+            set output to ""
+            set winIdx to 0
+            repeat with w in windows
+                set tabIdx to 0
+                repeat with t in tabs of w
+                    repeat with s in sessions of t
+                        set output to output & winIdx & "\t" & tabIdx & "\t" & (tty of s) & "\t" & (name of s) & "\t" & (unique ID of s) & linefeed
+                    end repeat
+                    set tabIdx to tabIdx + 1
+                end repeat
+                set winIdx to winIdx + 1
+            end repeat
+            return output
+        end tell
+        """
+
+        let raw = osascript(script)
+        guard !raw.isEmpty else { return [] }
+
+        var tabs: [TerminalTab] = []
+        for line in raw.split(separator: "\n", omittingEmptySubsequences: true) {
+            let cols = line.split(separator: "\t", maxSplits: 4, omittingEmptySubsequences: false)
+            guard cols.count >= 5 else { continue }
+
+            guard let winIdx = Int(cols[0]),
+                  let tabIdx = Int(cols[1]) else { continue }
+
+            let tty = normalizeTTY(String(cols[2]))
+            guard tty.hasPrefix("ttys") else { continue }
+
+            let title = String(cols[3])
+            let sessionId = String(cols[4])
+
+            tabs.append(TerminalTab(
+                app: .iterm2,
+                windowIndex: winIdx,
+                tabIndex: tabIdx,
+                tty: tty,
+                isActiveTab: false, // iTerm2 doesn't expose this easily in a single call
+                title: title,
+                sessionId: sessionId
+            ))
+        }
+        return tabs
+    }
+
+    // MARK: - Terminal.app
+
+    static func queryTerminalApp() -> [TerminalTab] {
+        let script = """
+        tell application "Terminal"
+            set output to ""
+            set winIdx to 0
+            repeat with w in windows
+                set selTab to selected tab of w
+                set tabIdx to 0
+                repeat with t in tabs of w
+                    set isSel to (t = selTab)
+                    set output to output & winIdx & "\t" & tabIdx & "\t" & (tty of t) & "\t" & (custom title of t) & "\t" & isSel & linefeed
+                    set tabIdx to tabIdx + 1
+                end repeat
+                set winIdx to winIdx + 1
+            end repeat
+            return output
+        end tell
+        """
+
+        let raw = osascript(script)
+        guard !raw.isEmpty else { return [] }
+
+        var tabs: [TerminalTab] = []
+        for line in raw.split(separator: "\n", omittingEmptySubsequences: true) {
+            let cols = line.split(separator: "\t", maxSplits: 4, omittingEmptySubsequences: false)
+            guard cols.count >= 5 else { continue }
+
+            guard let winIdx = Int(cols[0]),
+                  let tabIdx = Int(cols[1]) else { continue }
+
+            let tty = normalizeTTY(String(cols[2]))
+            guard tty.hasPrefix("ttys") else { continue }
+
+            let title = String(cols[3])
+            let isActive = String(cols[4]).lowercased() == "true"
+
+            tabs.append(TerminalTab(
+                app: .terminal,
+                windowIndex: winIdx,
+                tabIndex: tabIdx,
+                tty: tty,
+                isActiveTab: isActive,
+                title: title,
+                sessionId: nil
+            ))
+        }
+        return tabs
+    }
+
+    // MARK: - Helpers
+
+    /// Check if a named app is already running (prevents AppleScript from auto-launching it).
+    private static func isAppRunning(_ name: String) -> Bool {
+        NSWorkspace.shared.runningApplications.contains { $0.localizedName == name }
+    }
+
+    /// Run an AppleScript and capture stdout.
+    /// Uses ProcessQuery.shell to avoid Process.waitUntilExit() deadlocks on macOS 26.
+    private static func osascript(_ source: String) -> String {
+        ProcessQuery.shell(["/usr/bin/osascript", "-e", source])
+    }
+}