@lattices/cli 0.3.0 → 0.4.0

package/app/Sources/WorkspaceManager.swift

@@ -78,7 +78,7 @@ class WorkspaceManager: ObservableObject {
 
     private let configPath: String
     private let gridConfigPath: String
-    private let tmuxPath = "/opt/homebrew/bin/tmux"
+    private var tmuxPath: String { TmuxQuery.resolvedPath ?? "/opt/homebrew/bin/tmux" }
     private let activeLayerKey = "lattices.activeLayerIndex"
 
     init() {
@@ -173,13 +173,15 @@ class WorkspaceManager: ObservableObject {
 
     /// Resolve a tile string to fractions: check user presets first, then built-in TilePosition
     func resolveTileFractions(_ tile: String) -> (CGFloat, CGFloat, CGFloat, CGFloat)? {
-        if let preset = gridPresets[tile] {
-            return preset.fractions
-        }
-        if let position = TilePosition(rawValue: tile) {
-            return position.rect
+        resolvePlacement(tile)?.fractions
+    }
+
+    func resolvePlacement(_ tile: String) -> PlacementSpec? {
+        if let preset = gridPresets[tile],
+           let placement = FractionalPlacement(x: preset.x, y: preset.y, w: preset.w, h: preset.h) {
+            return .fractions(placement)
         }
-        return nil
+        return PlacementSpec(string: tile)
     }
 
     // MARK: - Tab Groups
@@ -275,7 +277,7 @@ class WorkspaceManager: ObservableObject {
 
     /// Resolve a session name to a tile target: (wid, pid, frame).
     /// Returns nil if the window isn't tracked or has no tile position.
-    private func batchTarget(session: String, position: TilePosition, screen: NSScreen) -> (wid: UInt32, pid: Int32, frame: CGRect)? {
+    private func batchTarget(session: String, position: PlacementSpec, screen: NSScreen) -> (wid: UInt32, pid: Int32, frame: CGRect)? {
         guard let entry = windowForSession(session) else { return nil }
         let frame = WindowTiler.tileFrame(for: position, on: screen)
         return (entry.wid, entry.pid, frame)
@@ -309,6 +311,71 @@ class WorkspaceManager: ObservableObject {
         return (running, total)
     }
 
+    // MARK: - Layer Focus (raise only)
+
+    /// Switch to a layer by raising all its windows in place — no launching, no tiling, no moving.
+    /// This is the default hotkey action: just bring the layer's windows to the front.
+    func focusLayer(index: Int) {
+        guard let config, let layers = config.layers, index < layers.count else { return }
+        if index == activeLayerIndex { return }
+
+        let diag = DiagnosticLog.shared
+        let t = diag.startTimed("focusLayer \(activeLayerIndex)→\(index)")
+
+        DesktopModel.shared.poll()
+
+        let targetLayer = layers[index]
+        var windowsToRaise: [(wid: UInt32, pid: Int32)] = []
+
+        for lp in targetLayer.projects {
+            if let groupId = lp.group, let grp = group(byId: groupId) {
+                // Raise all tab windows in the group
+                for tab in grp.tabs {
+                    let sessionName = Self.sessionName(for: tab.path)
+                    if let entry = windowForSession(sessionName) {
+                        windowsToRaise.append((entry.wid, entry.pid))
+                    }
+                }
+                continue
+            }
+
+            if let appName = lp.app {
+                if let entry = DesktopModel.shared.windowForApp(app: appName, title: lp.title) {
+                    windowsToRaise.append((entry.wid, entry.pid))
+                }
+                continue
+            }
+
+            guard let path = lp.path else { continue }
+            let sessionName = Self.sessionName(for: path)
+            if let entry = windowForSession(sessionName) {
+                windowsToRaise.append((entry.wid, entry.pid))
+            }
+
+            // Also raise companion windows
+            let companions = projectWindows(at: path)
+            for cw in companions {
+                guard let appName = cw.app else { continue }
+                if let entry = DesktopModel.shared.windowForApp(app: appName, title: cw.title) {
+                    windowsToRaise.append((entry.wid, entry.pid))
+                }
+            }
+        }
+
+        if !windowsToRaise.isEmpty {
+            WindowTiler.raiseWindowsAndReactivate(windows: windowsToRaise)
+        }
+
+        activeLayerIndex = index
+        UserDefaults.standard.set(index, forKey: activeLayerKey)
+
+        let allLabels = layers.map(\.label)
+        LayerBezel.shared.show(label: targetLayer.label, index: index, total: layers.count, allLabels: allLabels)
+        HandsOffSession.shared.playCachedCue("Switched.")
+
+        diag.finish(t)
+    }
+
     // MARK: - Unified Layer Tiling
 
     /// Unified entry point for arranging a layer's windows.
@@ -332,14 +399,17 @@ class WorkspaceManager: ObservableObject {
         let scanner = ProjectScanner.shared
         let targetLayer = layers[index]
 
+        // Fresh poll so we see windows on all Spaces before matching
+        DesktopModel.shared.poll()
+
         // Tile debug log (written to ~/.lattices/tile-debug.log)
         let debugPath = (FileManager.default.homeDirectoryForCurrentUser.path as NSString).appendingPathComponent(".lattices/tile-debug.log")
         var debugLines: [String] = ["tileLayer index=\(index) launch=\(launch) force=\(force) layer=\(targetLayer.id)"]
 
         // Phase 1: classify each project
         var batchMoves: [(wid: UInt32, pid: Int32, frame: CGRect)] = []
-        var fallbacks: [(session: String, position: TilePosition, screen: NSScreen)] = []
-        var launchQueue: [(session: String, position: TilePosition?, screen: NSScreen, launchAction: () -> Void)] = []
+        var fallbacks: [(session: String, position: PlacementSpec, screen: NSScreen)] = []
+        var launchQueue: [(session: String, position: PlacementSpec?, screen: NSScreen, launchAction: () -> Void)] = []
 
         // Log screen info
         for (i, s) in NSScreen.screens.enumerated() {
@@ -351,7 +421,7 @@ class WorkspaceManager: ObservableObject {
 
             if let groupId = lp.group, let grp = group(byId: groupId) {
                 let firstTabSession = grp.tabs.first.map { Self.sessionName(for: $0.path) } ?? ""
-                let position = lp.tile.flatMap { TilePosition(rawValue: $0) }
+                let position = lp.tile.flatMap { resolvePlacement($0) }
                 let groupRunning = isGroupRunning(grp)
 
                 if groupRunning, let pos = position,
@@ -373,12 +443,19 @@ class WorkspaceManager: ObservableObject {
 
             // App-based window matching
             if let appName = lp.app {
-                let position = lp.tile.flatMap { TilePosition(rawValue: $0) }
+                let position = lp.tile.flatMap { resolvePlacement($0) }
                 if let entry = DesktopModel.shared.windowForApp(app: appName, title: lp.title) {
                     if let pos = position {
                         let frame = WindowTiler.tileFrame(for: pos, on: lpScreen)
                         batchMoves.append((entry.wid, entry.pid, frame))
                     }
+                } else if let found = Self.findAppWindow(app: appName, title: lp.title) {
+                    // Window exists but wasn't in DesktopModel (e.g. different Space) — tile it
+                    diag.info("  found app via CGWindowList fallback: \(appName) wid=\(found.wid)")
+                    if let pos = position {
+                        let frame = WindowTiler.tileFrame(for: pos, on: lpScreen)
+                        batchMoves.append((found.wid, found.pid, frame))
+                    }
                 } else if launch {
                     diag.info("  launch app: \(appName)")
                     let capturedLp = lp
@@ -407,13 +484,13 @@ class WorkspaceManager: ObservableObject {
             guard let path = lp.path else { continue }
             let sessionName = Self.sessionName(for: path)
             let project = scanner.projects.first(where: { $0.path == path })
-            let position = lp.tile.flatMap { TilePosition(rawValue: $0) }
+            let position = lp.tile.flatMap { resolvePlacement($0) }
             // Check scanner first, fall back to direct tmux check for projects without .lattices.json
             let isRunning = project?.isRunning == true || shell([tmuxPath, "has-session", "-t", sessionName]) == 0
 
             if isRunning {
                 let foundWindow = windowForSession(sessionName)
-                let msg = "  \(sessionName): running=\(isRunning) window=\(foundWindow?.wid ?? 0) tile=\(position?.rawValue ?? "nil") desktopCount=\(DesktopModel.shared.windows.count)"
+                let msg = "  \(sessionName): running=\(isRunning) window=\(foundWindow?.wid ?? 0) tile=\(position?.wireValue ?? "nil") desktopCount=\(DesktopModel.shared.windows.count)"
                 diag.info(msg)
                 debugLines.append(msg)
                 if let pos = position,
@@ -422,7 +499,7 @@ class WorkspaceManager: ObservableObject {
                     debugLines.append("    → batch move wid=\(target.wid) frame=\(target.frame)")
                 } else if let pos = position {
                     fallbacks.append((sessionName, pos, lpScreen))
-                    debugLines.append("    → fallback \(pos.rawValue)")
+                    debugLines.append("    → fallback \(pos.wireValue)")
                 }
             } else if launch {
                 if let project {
@@ -443,7 +520,7 @@ class WorkspaceManager: ObservableObject {
             for cw in companions {
                 guard let appName = cw.app else { continue }
                 let cwScreen = screen(for: cw.display ?? lp.display) ?? lpScreen
-                let cwPosition = cw.tile.flatMap { TilePosition(rawValue: $0) }
+                let cwPosition = cw.tile.flatMap { resolvePlacement($0) }
                 if let entry = DesktopModel.shared.windowForApp(app: appName, title: cw.title) {
                     if let pos = cwPosition {
                         let frame = WindowTiler.tileFrame(for: pos, on: cwScreen)
@@ -486,7 +563,7 @@ class WorkspaceManager: ObservableObject {
         for (i, fb) in fallbacks.enumerated() {
             let delay = Double(i) * 0.15 + 0.1
             DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
-                diag.info("  tile fallback: \(fb.session) → \(fb.position.rawValue)")
+                diag.info("  tile fallback: \(fb.session) → \(fb.position.wireValue)")
                 WindowTiler.navigateToWindow(session: fb.session, terminal: terminal)
                 WindowTiler.tile(session: fb.session, terminal: terminal, to: fb.position, on: fb.screen)
             }
@@ -498,7 +575,7 @@ class WorkspaceManager: ObservableObject {
             DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
                 item.launchAction()
                 if let pos = item.position {
-                    let t = diag.startTimed("tile launched: \(item.session) → \(pos.rawValue)")
+                    let t = diag.startTimed("tile launched: \(item.session) → \(pos.wireValue)")
                     WindowTiler.tile(session: item.session, terminal: terminal, to: pos, on: item.screen)
                     diag.finish(t)
                 }
@@ -558,6 +635,38 @@ class WorkspaceManager: ObservableObject {
         }
     }
 
+    // MARK: - App Window Fallback (CGWindowList .optionAll)
+
+    /// Find an app window across ALL Spaces via CGWindowList (bypasses DesktopModel cache)
+    static func findAppWindow(app: String, title: String?) -> (wid: UInt32, pid: Int32)? {
+        guard let list = CGWindowListCopyWindowInfo(
+            [.optionAll, .excludeDesktopElements],
+            kCGNullWindowID
+        ) as? [[String: Any]] else { return nil }
+
+        for info in list {
+            guard let ownerName = info[kCGWindowOwnerName as String] as? String,
+                  ownerName.localizedCaseInsensitiveContains(app),
+                  let wid = info[kCGWindowNumber as String] as? UInt32,
+                  let pid = info[kCGWindowOwnerPID as String] as? Int32,
+                  let layer = info[kCGWindowLayer as String] as? Int, layer == 0,
+                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary
+            else { continue }
+
+            var rect = CGRect.zero
+            guard CGRectMakeWithDictionaryRepresentation(boundsDict, &rect),
+                  rect.width >= 50, rect.height >= 50 else { continue }
+
+            if let title {
+                let windowTitle = info[kCGWindowName as String] as? String ?? ""
+                guard windowTitle.localizedCaseInsensitiveContains(title) else { continue }
+            }
+
+            return (wid, pid)
+        }
+        return nil
+    }
+
     // MARK: - Session Name Helper
 
     /// Replicates Project.sessionName logic from a bare path

package/bin/client.ts

@@ -0,0 +1,16 @@
+// Public API — re-exports from daemon-client for a cleaner import path.
+// Usage: import { daemonCall, isDaemonRunning } from '@lattices/cli'
+
+export { daemonCall, isDaemonRunning } from "./daemon-client.ts";
+export {
+  ProjectTwin,
+  createProjectTwin,
+  readOpenScoutRelayContext,
+  type OpenScoutRelayContext,
+  type ProjectTwinEvent,
+  type ProjectTwinInvokeRequest,
+  type ProjectTwinOptions,
+  type ProjectTwinResult,
+  type ProjectTwinState,
+  type ProjectTwinThinkingLevel,
+} from "./project-twin.ts";

package/bin/{daemon-client.js → daemon-client.ts}

@@ -1,21 +1,26 @@
 // Lightweight WebSocket client for lattices daemon (ws://127.0.0.1:9399)
 // Uses Node `net` module with manual HTTP upgrade + minimal WS framing.
-// Zero npm dependencies. Requires Node >= 18.
+// Zero npm dependencies.
 
-import { createConnection } from "node:net";
+import { createConnection, type Socket } from "node:net";
 import { randomBytes } from "node:crypto";
 
 const DAEMON_HOST = "127.0.0.1";
 const DAEMON_PORT = 9399;
 
+interface ParsedFrame {
+  payload: string;
+  rest: Buffer<ArrayBuffer>;
+}
+
 /**
  * Send a JSON-RPC-style request to the daemon and return the response.
- * @param {string} method
- * @param {object} [params]
- * @param {number} [timeoutMs=3000]
- * @returns {Promise<object>} The result field from the response
  */
-export async function daemonCall(method, params, timeoutMs = 3000) {
+export async function daemonCall(
+  method: string,
+  params?: Record<string, unknown> | null,
+  timeoutMs = 3000
+): Promise<unknown> {
   const id = randomBytes(4).toString("hex");
   const request = JSON.stringify({ id, method, params: params ?? null });
 
@@ -62,8 +67,8 @@ export async function daemonCall(method, params, timeoutMs = 3000) {
       socket.write(upgrade);
     });
 
-    socket.on("data", (chunk) => {
-      buffer = Buffer.concat([buffer, chunk]);
+    socket.on("data", (chunk: Buffer) => {
+      buffer = Buffer.concat([buffer, chunk]) as Buffer<ArrayBuffer>;
 
       if (!upgraded) {
         const headerEnd = buffer.indexOf("\r\n\r\n");
@@ -82,23 +87,38 @@ export async function daemonCall(method, params, timeoutMs = 3000) {
         sendFrame(socket, request);
       }
 
-      // Try to parse a WebSocket frame from the buffer
-      const result = parseFrame(buffer);
-      if (result) {
+      // The daemon can push broadcast events before the RPC response.
+      // Keep consuming frames until we see our matching response id.
+      while (true) {
+        const result = parseFrame(buffer);
+        if (!result) break;
         buffer = result.rest;
-        if (!settled) {
-          settled = true;
-          cleanup();
-          try {
-            const parsed = JSON.parse(result.payload);
+
+        try {
+          const parsed = JSON.parse(result.payload);
+          if (parsed.event) {
+            continue;
+          }
+          if (parsed.id !== id) {
+            continue;
+          }
+          if (!settled) {
+            settled = true;
+            cleanup();
             if (parsed.error) {
               reject(new Error(parsed.error));
             } else {
               resolve(parsed.result);
             }
-          } catch (e) {
+          }
+          return;
+        } catch {
+          if (!settled) {
+            settled = true;
+            cleanup();
             reject(new Error("Invalid JSON response from daemon"));
           }
+          return;
         }
       }
     });
@@ -107,9 +127,8 @@ export async function daemonCall(method, params, timeoutMs = 3000) {
 
 /**
  * Check if the daemon is reachable.
- * @returns {Promise<boolean>}
  */
-export async function isDaemonRunning() {
+export async function isDaemonRunning(): Promise<boolean> {
   try {
     await daemonCall("daemon.status", null, 1000);
     return true;
@@ -120,12 +139,12 @@ export async function isDaemonRunning() {
 
 // MARK: - WebSocket framing helpers
 
-function sendFrame(socket, text) {
+function sendFrame(socket: Socket, text: string): void {
   const payload = Buffer.from(text, "utf8");
   const mask = randomBytes(4);
   const len = payload.length;
 
-  let header;
+  let header: Buffer;
   if (len < 126) {
     header = Buffer.alloc(2);
     header[0] = 0x81; // FIN + text opcode
@@ -145,17 +164,17 @@ function sendFrame(socket, text) {
   // Mask payload
   const masked = Buffer.alloc(payload.length);
   for (let i = 0; i < payload.length; i++) {
-    masked[i] = payload[i] ^ mask[i % 4];
+    masked[i] = payload[i]! ^ mask[i % 4]!;
   }
 
   socket.write(Buffer.concat([header, mask, masked]));
 }
 
-function parseFrame(buf) {
+function parseFrame(buf: Buffer): ParsedFrame | null {
   if (buf.length < 2) return null;
 
-  const masked = (buf[1] & 0x80) !== 0;
-  let payloadLen = buf[1] & 0x7f;
+  const isMasked = (buf[1]! & 0x80) !== 0;
+  let payloadLen = buf[1]! & 0x7f;
   let offset = 2;
 
   if (payloadLen === 126) {
@@ -168,20 +187,20 @@ function parseFrame(buf) {
     offset = 10;
   }
 
-  if (masked) offset += 4;
+  if (isMasked) offset += 4;
   if (buf.length < offset + payloadLen) return null;
 
   let payload = buf.subarray(offset, offset + payloadLen);
-  if (masked) {
+  if (isMasked) {
     const maskKey = buf.subarray(offset - 4, offset);
     payload = Buffer.alloc(payloadLen);
     for (let i = 0; i < payloadLen; i++) {
-      payload[i] = buf[offset + i] ^ maskKey[i % 4];
+      payload[i] = buf[offset + i]! ^ maskKey[i % 4]!;
     }
   }
 
   return {
     payload: payload.toString("utf8"),
-    rest: buf.subarray(offset + payloadLen),
+    rest: buf.subarray(offset + payloadLen) as Buffer<ArrayBuffer>,
   };
 }