@lattices/cli 0.4.7 → 0.4.9

package/app/Sources/AppShell/SettingsWindow.swift

@@ -14,6 +14,10 @@ final class SettingsWindowController {
         ScreenMapWindowController.shared.showPage(.settings)
     }
 
+    func showCompanion() {
+        ScreenMapWindowController.shared.showPage(.companionSettings)
+    }
+
     func close() {
         ScreenMapWindowController.shared.close()
     }

package/app/Sources/Core/Companion/LatticesCompanionBridgeServer.swift

@@ -7,6 +7,8 @@ final class LatticesCompanionBridgeServer: NSObject {
 
     static let bonjourType = "_lattices-companion._tcp."
     static let defaultPort: UInt16 = 5287
+    static let protocolVersion = "1"
+    static let maxBodyBytes = 512 * 1024
 
     private let queue = DispatchQueue(label: "lattices.companion.bridge", qos: .userInitiated)
     private let encoder = JSONEncoder()
@@ -101,12 +103,14 @@ private extension LatticesCompanionBridgeServer {
         let serviceType: String
         let hostName: String
         let port: UInt16
+        let protocolVersion: String
         let version: String
         let mode: String
         let bridgePublicKey: String
         let bridgeFingerprint: String
         let requestSigningRequired: Bool
         let payloadEncryptionRequired: Bool
+        let capabilities: [String]
     }
 
     func publishBonjour() {
@@ -118,6 +122,13 @@ private extension LatticesCompanionBridgeServer {
             port: Int32(Self.defaultPort)
         )
         service.includesPeerToPeer = true
+        service.setTXTRecord(NetService.data(fromTXTRecord: [
+            "v": Data(Self.protocolVersion.utf8),
+            "mode": Data("local-network-secure".utf8),
+            "fp": Data(LatticesCompanionSecurityCoordinator.shared.bridgeFingerprint.utf8),
+            "sec": Data("signed,encrypted".utf8),
+            "cap": Data(DeckBridgeCapability.defaultCompanionCapabilities.joined(separator: ",").utf8),
+        ]))
         service.publish()
         self.service = service
     }
@@ -164,7 +175,7 @@ private extension LatticesCompanionBridgeServer {
         } catch let error as LatticesCompanionSecurityError {
             let status: Int
             switch error {
-            case .untrustedDevice:
+            case .untrustedDevice, .insufficientCapability:
                 status = 403
             case .missingHeader, .staleRequest, .replayedRequest, .invalidSignature, .invalidEnvelope, .invalidDeviceKey:
                 status = 401
@@ -185,12 +196,14 @@ private extension LatticesCompanionBridgeServer {
                 serviceType: Self.bonjourType,
                 hostName: localHostName(),
                 port: Self.defaultPort,
+                protocolVersion: Self.protocolVersion,
                 version: LatticesRuntime.appVersion,
                 mode: "local-network-secure",
                 bridgePublicKey: LatticesCompanionSecurityCoordinator.shared.bridgePublicKeyBase64,
                 bridgeFingerprint: LatticesCompanionSecurityCoordinator.shared.bridgeFingerprint,
                 requestSigningRequired: security.requestSigningRequired,
-                payloadEncryptionRequired: security.payloadEncryptionRequired
+                payloadEncryptionRequired: security.payloadEncryptionRequired,
+                capabilities: DeckBridgeCapability.defaultCompanionCapabilities
             )
             try sendJSON(status: 200, value: response, to: fd)
 
@@ -204,7 +217,7 @@ private extension LatticesCompanionBridgeServer {
             try sendJSON(status: status, value: response, to: fd)
 
         case ("GET", "/deck/snapshot"):
-            let auth = try authorizeProtectedRequest(request)
+            let auth = try authorizeProtectedRequest(request, requiredCapability: DeckBridgeCapability.deckRead)
             let snapshot = try LatticesDeckHost.shared.runtimeSnapshotSync()
             let response = try LatticesCompanionSecurityCoordinator.shared.encodeProtectedResponse(
                 snapshot,
@@ -215,7 +228,7 @@ private extension LatticesCompanionBridgeServer {
             try sendJSON(status: 200, value: response, to: fd)
 
         case ("POST", "/deck/perform"):
-            let auth = try authorizeProtectedRequest(request)
+            let auth = try authorizeProtectedRequest(request, requiredCapability: DeckBridgeCapability.deckPerform)
             let action = try LatticesCompanionSecurityCoordinator.shared.decodeProtectedBody(
                 DeckActionRequest.self,
                 body: request.body,
@@ -233,7 +246,7 @@ private extension LatticesCompanionBridgeServer {
             try sendJSON(status: 200, value: response, to: fd)
 
         case ("POST", "/deck/trackpad"):
-            let auth = try authorizeProtectedRequest(request)
+            let auth = try authorizeProtectedRequest(request, requiredCapability: DeckBridgeCapability.inputTrackpad)
             let eventRequest = try LatticesCompanionSecurityCoordinator.shared.decodeProtectedBody(
                 DeckTrackpadEventRequest.self,
                 body: request.body,
@@ -255,17 +268,19 @@ private extension LatticesCompanionBridgeServer {
         }
     }
 
-    func authorizeProtectedRequest(_ request: HTTPRequest) throws -> AuthorizedBridgeRequest {
+    func authorizeProtectedRequest(_ request: HTTPRequest, requiredCapability: String) throws -> AuthorizedBridgeRequest {
         let security = LatticesDeckHost.shared.securityConfiguration
         guard security.requestSigningRequired else {
             throw LatticesCompanionSecurityError.untrustedDevice
         }
-        return try LatticesCompanionSecurityCoordinator.shared.authorize(
+        let auth = try LatticesCompanionSecurityCoordinator.shared.authorize(
             method: request.method,
             path: request.path,
             headers: request.headers,
             body: request.body
         )
+        try LatticesCompanionSecurityCoordinator.shared.requireCapability(requiredCapability, for: auth)
+        return auth
     }
 
     func readRequest(from fd: Int32) -> HTTPRequest? {
@@ -312,6 +327,7 @@ private extension LatticesCompanionBridgeServer {
         }
 
         let contentLength = Int(headers["content-length"] ?? "") ?? 0
+        guard contentLength <= Self.maxBodyBytes else { return nil }
         var body = Data(buffer[headerRange.upperBound...])
         while body.count < contentLength {
             guard let count = readChunk(

package/app/Sources/Core/Companion/LatticesCompanionSecurityCoordinator.swift

@@ -12,6 +12,7 @@ enum LatticesCompanionSecurityError: LocalizedError {
     case invalidSignature
     case invalidEnvelope
     case invalidDeviceKey
+    case insufficientCapability(String)
 
     var errorDescription: String? {
         switch self {
@@ -29,6 +30,8 @@ enum LatticesCompanionSecurityError: LocalizedError {
             return "The bridge payload could not be decrypted."
         case .invalidDeviceKey:
             return "The device pairing key is invalid."
+        case .insufficientCapability(let capability):
+            return "This trusted device is missing the required bridge capability: \(capability)."
         }
     }
 }
@@ -40,6 +43,7 @@ struct LatticesCompanionTrustedDeviceRecord: Codable, Equatable, Identifiable, S
     var fingerprint: String
     var platform: String
     var appVersion: String?
+    var capabilities: [String]?
     var pairedAt: Date
     var lastSeenAt: Date
 
@@ -48,10 +52,15 @@ struct LatticesCompanionTrustedDeviceRecord: Codable, Equatable, Identifiable, S
             id: id,
             name: name,
             fingerprint: fingerprint,
+            capabilities: effectiveCapabilities,
             pairedAt: pairedAt,
             lastSeenAt: lastSeenAt
         )
     }
+
+    var effectiveCapabilities: [String] {
+        capabilities ?? DeckBridgeCapability.defaultCompanionCapabilities
+    }
 }
 
 struct AuthorizedBridgeRequest {
@@ -117,9 +126,15 @@ final class LatticesCompanionSecurityCoordinator {
         persistTrustedDevices()
     }
 
+    func revokeTrustedDevice(id: String) {
+        trustedDevices.removeValue(forKey: id)
+        persistTrustedDevices()
+    }
+
     func handlePairingRequest(_ request: DeckPairingRequest) -> DeckPairingResponse {
         let diag = DiagnosticLog.shared
         diag.info("CompanionPairing: request device=\(request.deviceName) id=\(request.deviceID)")
+        let grantedCapabilities = Self.grantedCapabilities(for: request.requestedCapabilities)
 
         guard
             request.deviceID.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false,
@@ -134,12 +149,14 @@ final class LatticesCompanionSecurityCoordinator {
                 bridgeFingerprint: bridgeFingerprint,
                 requestSigningRequired: true,
                 payloadEncryptionRequired: true,
+                grantedCapabilities: [],
                 detail: LatticesCompanionSecurityError.invalidDeviceKey.localizedDescription
             )
         }
 
         if var existing = trustedDevices[request.deviceID], existing.publicKey == request.devicePublicKey {
             existing.lastSeenAt = Date()
+            existing.capabilities = grantedCapabilities.isEmpty ? existing.effectiveCapabilities : grantedCapabilities
             trustedDevices[request.deviceID] = existing
             persistTrustedDevices()
             diag.success("CompanionPairing: device already trusted id=\(request.deviceID)")
@@ -150,6 +167,7 @@ final class LatticesCompanionSecurityCoordinator {
                 bridgeFingerprint: bridgeFingerprint,
                 requestSigningRequired: true,
                 payloadEncryptionRequired: true,
+                grantedCapabilities: existing.effectiveCapabilities,
                 detail: "This device is already trusted on the Mac."
             )
         }
@@ -164,6 +182,7 @@ final class LatticesCompanionSecurityCoordinator {
                 bridgeFingerprint: bridgeFingerprint,
                 requestSigningRequired: true,
                 payloadEncryptionRequired: true,
+                grantedCapabilities: [],
                 detail: "Pairing was denied on the Mac."
             )
         }
@@ -176,6 +195,7 @@ final class LatticesCompanionSecurityCoordinator {
             fingerprint: Self.fingerprint(forPublicKeyBase64: request.devicePublicKey),
             platform: request.platform,
             appVersion: request.appVersion,
+            capabilities: grantedCapabilities,
             pairedAt: now,
             lastSeenAt: now
         )
@@ -189,6 +209,7 @@ final class LatticesCompanionSecurityCoordinator {
             bridgeFingerprint: bridgeFingerprint,
             requestSigningRequired: true,
             payloadEncryptionRequired: true,
+            grantedCapabilities: grantedCapabilities,
             detail: "Trusted and ready for encrypted bridge requests."
         )
     }
@@ -241,6 +262,12 @@ final class LatticesCompanionSecurityCoordinator {
         )
     }
 
+    func requireCapability(_ capability: String, for auth: AuthorizedBridgeRequest) throws {
+        guard auth.device.effectiveCapabilities.contains(capability) else {
+            throw LatticesCompanionSecurityError.insufficientCapability(capability)
+        }
+    }
+
     func decodeProtectedBody<T: Decodable>(
         _ type: T.Type,
         body: Data,
@@ -315,6 +342,14 @@ private extension LatticesCompanionSecurityCoordinator {
         return compact.chunked(into: 4).joined(separator: "-")
     }
 
+    static func grantedCapabilities(for requested: [String]) -> [String] {
+        let supported = Set(DeckBridgeCapability.defaultCompanionCapabilities)
+        let requested = requested.isEmpty ? supported : Set(requested)
+        return requested
+            .intersection(supported)
+            .sorted()
+    }
+
     func persistTrustedDevices() {
         let sorted = trustedDevices.values.sorted { lhs, rhs in
             lhs.name.localizedCaseInsensitiveCompare(rhs.name) == .orderedAscending

package/app/Sources/Core/Companion/LatticesCompanionTrackpadController.swift

@@ -13,7 +13,7 @@ final class LatticesCompanionTrackpadController {
                 isEnabled: false,
                 isAvailable: false,
                 statusTitle: "Trackpad Off",
-                statusDetail: "Enable the companion trackpad from the Mac Shortcuts settings.",
+                statusDetail: "Enable the companion trackpad from the Mac Companion settings.",
                 pointerScale: 1.6,
                 scrollScale: 1.0,
                 supportsDragLock: true

package/app/Sources/Core/Input/KeyboardRemapConfig.swift

@@ -0,0 +1,69 @@
+import CoreGraphics
+import Foundation
+
+enum KeyboardRemapKey: String, Codable, Equatable {
+    case capsLock = "caps_lock"
+
+    var keyCode: Int64 {
+        switch self {
+        case .capsLock: return 57
+        }
+    }
+
+    var displayLabel: String {
+        switch self {
+        case .capsLock: return "Caps Lock"
+        }
+    }
+}
+
+enum KeyboardRemapAction: String, Codable, Equatable {
+    case escape
+    case hyper
+
+    var displayLabel: String {
+        switch self {
+        case .escape: return "Escape"
+        case .hyper: return "Hyper"
+        }
+    }
+}
+
+struct KeyboardRemapRule: Codable, Equatable, Identifiable {
+    var id: String
+    var enabled: Bool
+    var from: KeyboardRemapKey
+    var toIfHeld: KeyboardRemapAction
+    var toIfAlone: KeyboardRemapAction?
+
+    var summaryLine: String {
+        let held = "hold \(from.displayLabel) -> \(toIfHeld.displayLabel)"
+        guard let alone = toIfAlone else { return held }
+        return "\(held), tap -> \(alone.displayLabel)"
+    }
+}
+
+struct KeyboardRemapConfig: Codable, Equatable {
+    var rules: [KeyboardRemapRule]
+
+    static let defaults = KeyboardRemapConfig(
+        rules: [
+            KeyboardRemapRule(
+                id: "caps_lock_hyper_escape",
+                enabled: true,
+                from: .capsLock,
+                toIfHeld: .hyper,
+                toIfAlone: .escape
+            )
+        ]
+    )
+}
+
+extension CGEventFlags {
+    static let latticesHyper: CGEventFlags = [
+        .maskCommand,
+        .maskControl,
+        .maskAlternate,
+        .maskShift,
+    ]
+}

package/app/Sources/Core/Input/KeyboardRemapController.swift

@@ -0,0 +1,184 @@
+import AppKit
+import Combine
+import CoreGraphics
+
+final class KeyboardRemapController {
+    static let shared = KeyboardRemapController()
+
+    private static let syntheticMarker: Int64 = 0x4C4B524D
+
+    private var eventTap: CFMachPort?
+    private var runLoopSource: CFRunLoopSource?
+    private var subscriptions: Set<AnyCancellable> = []
+    private var installedObservers = false
+    private var capsLayerActive = false
+    private var capsUsedAsModifier = false
+
+    private init() {}
+
+    func start() {
+        installObserversIfNeeded()
+        refresh()
+    }
+
+    func stop() {
+        removeEventTap()
+        capsLayerActive = false
+        capsUsedAsModifier = false
+    }
+
+    private func installObserversIfNeeded() {
+        guard !installedObservers else { return }
+        installedObservers = true
+
+        Preferences.shared.$keyboardRemapsEnabled
+            .receive(on: RunLoop.main)
+            .sink { [weak self] _ in self?.refresh() }
+            .store(in: &subscriptions)
+
+        PermissionChecker.shared.$accessibility
+            .receive(on: RunLoop.main)
+            .sink { [weak self] _ in self?.refresh() }
+            .store(in: &subscriptions)
+    }
+
+    private func refresh() {
+        guard Preferences.shared.keyboardRemapsEnabled,
+              PermissionChecker.shared.accessibility else {
+            removeEventTap()
+            return
+        }
+
+        KeyboardRemapStore.shared.ensureConfigFile()
+        if eventTap == nil {
+            installEventTap()
+        } else if let eventTap {
+            CGEvent.tapEnable(tap: eventTap, enable: true)
+        }
+    }
+
+    private func installEventTap() {
+        var mask = CGEventMask(0)
+        mask |= CGEventMask(1) << CGEventType.keyDown.rawValue
+        mask |= CGEventMask(1) << CGEventType.keyUp.rawValue
+        mask |= CGEventMask(1) << CGEventType.flagsChanged.rawValue
+
+        let tap = CGEvent.tapCreate(
+            tap: .cgSessionEventTap,
+            place: .headInsertEventTap,
+            options: .defaultTap,
+            eventsOfInterest: mask,
+            callback: Self.eventTapCallback,
+            userInfo: UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())
+        )
+
+        guard let tap else {
+            DiagnosticLog.shared.warn("KeyboardRemap: failed to install keyboard event tap")
+            return
+        }
+
+        let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
+        eventTap = tap
+        runLoopSource = source
+
+        if let source {
+            CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes)
+        }
+        CGEvent.tapEnable(tap: tap, enable: true)
+        DiagnosticLog.shared.info("KeyboardRemap: keyboard event tap installed")
+    }
+
+    private func removeEventTap() {
+        if let source = runLoopSource {
+            CFRunLoopRemoveSource(CFRunLoopGetMain(), source, .commonModes)
+        }
+        runLoopSource = nil
+        if let tap = eventTap {
+            CFMachPortInvalidate(tap)
+        }
+        eventTap = nil
+    }
+
+    private static let eventTapCallback: CGEventTapCallBack = { _, type, event, userInfo in
+        guard let userInfo else { return Unmanaged.passUnretained(event) }
+        let controller = Unmanaged<KeyboardRemapController>.fromOpaque(userInfo).takeUnretainedValue()
+        return controller.handleEvent(type: type, event: event)
+    }
+
+    private func handleEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
+        if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {
+            if let eventTap {
+                CGEvent.tapEnable(tap: eventTap, enable: true)
+            }
+            return Unmanaged.passUnretained(event)
+        }
+
+        if event.getIntegerValueField(.eventSourceUserData) == Self.syntheticMarker {
+            return Unmanaged.passUnretained(event)
+        }
+
+        KeyboardRemapStore.shared.reloadIfNeeded()
+        guard let rule = KeyboardRemapStore.shared.capsLockRule,
+              rule.toIfHeld == .hyper else {
+            return Unmanaged.passUnretained(event)
+        }
+
+        let keyCode = event.getIntegerValueField(.keyboardEventKeycode)
+        if type == .flagsChanged, keyCode == rule.from.keyCode {
+            return handleCapsLockFlagsChanged(event, rule: rule)
+        }
+
+        guard capsLayerActive else {
+            return Unmanaged.passUnretained(event)
+        }
+
+        switch type {
+        case .keyDown:
+            capsUsedAsModifier = true
+            event.flags = normalizedFlags(event.flags).union(.latticesHyper)
+            return Unmanaged.passUnretained(event)
+        case .keyUp:
+            event.flags = normalizedFlags(event.flags).union(.latticesHyper)
+            return Unmanaged.passUnretained(event)
+        default:
+            return Unmanaged.passUnretained(event)
+        }
+    }
+
+    private func handleCapsLockFlagsChanged(_ event: CGEvent, rule: KeyboardRemapRule) -> Unmanaged<CGEvent>? {
+        let isDown = event.flags.contains(.maskAlphaShift)
+        if isDown {
+            capsLayerActive = true
+            capsUsedAsModifier = false
+            DiagnosticLog.shared.info("KeyboardRemap: Caps Lock layer active")
+        } else {
+            let shouldTap = capsLayerActive && !capsUsedAsModifier && rule.toIfAlone == .escape
+            capsLayerActive = false
+            capsUsedAsModifier = false
+            if shouldTap {
+                postKeyTap(keyCode: 53)
+            }
+            DiagnosticLog.shared.info("KeyboardRemap: Caps Lock layer inactive")
+        }
+
+        return nil
+    }
+
+    private func normalizedFlags(_ flags: CGEventFlags) -> CGEventFlags {
+        var normalized = flags
+        normalized.remove(.maskAlphaShift)
+        return normalized
+    }
+
+    private func postKeyTap(keyCode: CGKeyCode) {
+        guard let source = CGEventSource(stateID: .combinedSessionState),
+              let down = CGEvent(keyboardEventSource: source, virtualKey: keyCode, keyDown: true),
+              let up = CGEvent(keyboardEventSource: source, virtualKey: keyCode, keyDown: false) else {
+            return
+        }
+        down.setIntegerValueField(.eventSourceUserData, value: Self.syntheticMarker)
+        up.setIntegerValueField(.eventSourceUserData, value: Self.syntheticMarker)
+        down.post(tap: .cghidEventTap)
+        up.post(tap: .cghidEventTap)
+    }
+}

package/app/Sources/Core/Input/KeyboardRemapStore.swift

@@ -0,0 +1,84 @@
+import AppKit
+import Combine
+import Foundation
+
+final class KeyboardRemapStore: ObservableObject {
+    static let shared = KeyboardRemapStore()
+
+    @Published private(set) var config: KeyboardRemapConfig
+
+    let configURL: URL
+    private var lastLoadedModifiedDate: Date?
+
+    private init() {
+        let dir = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".lattices")
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        self.configURL = dir.appendingPathComponent("keyboard-remaps.json")
+        self.config = .defaults
+        ensureConfigFile()
+        reload()
+    }
+
+    var enabledRules: [KeyboardRemapRule] {
+        config.rules.filter(\.enabled)
+    }
+
+    var summaryLines: [String] {
+        enabledRules.map(\.summaryLine)
+    }
+
+    var capsLockRule: KeyboardRemapRule? {
+        enabledRules.first { $0.from == .capsLock }
+    }
+
+    func ensureConfigFile() {
+        guard !FileManager.default.fileExists(atPath: configURL.path) else { return }
+        write(config: .defaults)
+    }
+
+    func reload() {
+        guard let data = FileManager.default.contents(atPath: configURL.path) else {
+            config = .defaults
+            return
+        }
+
+        do {
+            config = try JSONDecoder().decode(KeyboardRemapConfig.self, from: data)
+            lastLoadedModifiedDate = modifiedDate()
+        } catch {
+            DiagnosticLog.shared.error("KeyboardRemapStore: failed to decode keyboard-remaps.json - \(error.localizedDescription)")
+            config = .defaults
+        }
+    }
+
+    func reloadIfNeeded() {
+        let currentModifiedDate = modifiedDate()
+        guard currentModifiedDate != lastLoadedModifiedDate else { return }
+        reload()
+    }
+
+    func restoreDefaults() {
+        write(config: .defaults)
+        reload()
+        DiagnosticLog.shared.info("Keyboard remaps restored to defaults")
+    }
+
+    func openConfiguration() {
+        ensureConfigFile()
+        NSWorkspace.shared.open(configURL)
+    }
+
+    private func write(config: KeyboardRemapConfig) {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes]
+        guard let data = try? encoder.encode(config) else { return }
+        try? data.write(to: configURL, options: .atomic)
+        lastLoadedModifiedDate = modifiedDate()
+    }
+
+    private func modifiedDate() -> Date? {
+        let attrs = try? FileManager.default.attributesOfItem(atPath: configURL.path)
+        return attrs?[.modificationDate] as? Date
+    }
+}

package/app/Sources/Core/Workspace/SessionManager.swift

@@ -13,7 +13,7 @@ enum SessionManager {
             }
             terminal.focusOrAttach(session: project.sessionName)
         } else {
-            terminal.launch(command: latticesPath, in: project.path)
+            terminal.launch(command: "\(latticesPath) start", in: project.path)
         }
     }
 

package/app/Sources/Core/Workspace/WorkspaceManager.swift

@@ -555,12 +555,12 @@ class WorkspaceManager: ObservableObject {
             let label = tab.label ?? (tab.path as NSString).lastPathComponent
             DispatchQueue.main.asyncAfter(deadline: .now() + Double(i) * 0.4) {
                 if i == 0 {
-                    terminal.launch(command: "/opt/homebrew/bin/lattices", in: tab.path)
+                    terminal.launch(command: "/opt/homebrew/bin/lattices start", in: tab.path)
                     DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
                         terminal.nameTab(label)
                     }
                 } else {
-                    terminal.launchTab(command: "/opt/homebrew/bin/lattices", in: tab.path, tabName: label)
+                    terminal.launchTab(command: "/opt/homebrew/bin/lattices start", in: tab.path, tabName: label)
                 }
             }
         }
@@ -851,7 +851,7 @@ class WorkspaceManager: ObservableObject {
                     diag.finish(t)
                 } else {
                     diag.info("  launch (direct): \(sessionName)")
-                    terminal.launch(command: "/opt/homebrew/bin/lattices", in: path)
+                    terminal.launch(command: "/opt/homebrew/bin/lattices start", in: path)
                 }
                 launchQueue.append((sessionName, position, lpScreen, {}))
             } else {

package/bin/lattices-app.ts

@@ -152,6 +152,17 @@ function writeInfoPlist(): void {
     <string>AppIcon</string>
     <key>CFBundlePackageType</key>
     <string>APPL</string>
+    <key>CFBundleURLTypes</key>
+    <array>
+        <dict>
+            <key>CFBundleURLName</key>
+            <string>com.arach.lattices</string>
+            <key>CFBundleURLSchemes</key>
+            <array>
+                <string>lattices</string>
+            </array>
+        </dict>
+    </array>
     <key>CFBundleVersion</key>
     <string>${version}</string>
     <key>CFBundleShortVersionString</key>

package/bin/lattices-dev

@@ -78,6 +78,17 @@ write_info_plist() {
     <string>AppIcon</string>
     <key>CFBundlePackageType</key>
     <string>APPL</string>
+    <key>CFBundleURLTypes</key>
+    <array>
+        <dict>
+            <key>CFBundleURLName</key>
+            <string>com.arach.lattices</string>
+            <key>CFBundleURLSchemes</key>
+            <array>
+                <string>lattices</string>
+            </array>
+        </dict>
+    </array>
     <key>CFBundleVersion</key>
     <string>$VERSION</string>
     <key>CFBundleShortVersionString</key>