@lattices/cli 0.4.0 → 0.4.1

package/app/Tests/StageTileTests.swift

@@ -0,0 +1,353 @@
+import XCTest
+import CoreGraphics
+import AppKit
+
+// Private APIs (same as WindowTiler uses)
+@_silgen_name("_AXUIElementGetWindow")
+func _AXUIElementGetWindow(_ element: AXUIElement, _ windowID: UnsafeMutablePointer<CGWindowID>) -> AXError
+
+private let skyLight: UnsafeMutableRawPointer? = dlopen(
+    "/System/Library/PrivateFrameworks/SkyLight.framework/SkyLight", RTLD_NOW)
+
+private typealias SLSMainConnectionIDFunc = @convention(c) () -> Int32
+private typealias SLSDisableUpdateFunc = @convention(c) (Int32) -> Int32
+private typealias SLSReenableUpdateFunc = @convention(c) (Int32) -> Int32
+
+private let _SLSMainConnectionID: SLSMainConnectionIDFunc? = {
+    guard let sl = skyLight, let sym = dlsym(sl, "SLSMainConnectionID") else { return nil }
+    return unsafeBitCast(sym, to: SLSMainConnectionIDFunc.self)
+}()
+private let _SLSDisableUpdate: SLSDisableUpdateFunc? = {
+    guard let sl = skyLight, let sym = dlsym(sl, "SLSDisableUpdate") else { return nil }
+    return unsafeBitCast(sym, to: SLSDisableUpdateFunc.self)
+}()
+private let _SLSReenableUpdate: SLSReenableUpdateFunc? = {
+    guard let sl = skyLight, let sym = dlsym(sl, "SLSReenableUpdate") else { return nil }
+    return unsafeBitCast(sym, to: SLSReenableUpdateFunc.self)
+}()
+
+/// Tile windows within the current Stage Manager stage.
+/// Run ONE test at a time: swift test --filter StageTileTests/testMosaic
+final class StageTileTests: XCTestCase {
+
+    struct LiveWindow {
+        let wid: UInt32
+        let app: String
+        let pid: Int32
+        let title: String
+        let bounds: CGRect
+        let isOnScreen: Bool
+    }
+
+    func getRealWindows() -> [LiveWindow] {
+        guard let list = CGWindowListCopyWindowInfo(
+            [.optionAll, .excludeDesktopElements],
+            kCGNullWindowID
+        ) as? [[String: Any]] else { return [] }
+
+        let skip: Set<String> = [
+            "Window Server", "Dock", "Control Center", "SystemUIServer",
+            "Notification Center", "Spotlight", "WindowManager", "Lattices",
+        ]
+
+        return list.compactMap { info in
+            guard let wid = info[kCGWindowNumber as String] as? UInt32,
+                  let owner = info[kCGWindowOwnerName as String] as? String,
+                  let pid = info[kCGWindowOwnerPID as String] as? Int32,
+                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary
+            else { return nil }
+
+            var rect = CGRect.zero
+            guard CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) else { return nil }
+            let title = info[kCGWindowName as String] as? String ?? ""
+            let layer = info[kCGWindowLayer as String] as? Int ?? 0
+            let isOnScreen = info[kCGWindowIsOnscreen as String] as? Bool ?? false
+
+            guard layer == 0, rect.width >= 50, rect.height >= 50 else { return nil }
+            guard !skip.contains(owner) else { return nil }
+
+            return LiveWindow(wid: wid, app: owner, pid: pid, title: title,
+                            bounds: rect, isOnScreen: isOnScreen)
+        }
+    }
+
+    func getActiveStage() -> [LiveWindow] {
+        getRealWindows().filter { $0.isOnScreen && $0.bounds.width > 250 }
+    }
+
+    func detectStripWidth() -> CGFloat {
+        let thumbnails = getRealWindows().filter {
+            $0.isOnScreen && $0.bounds.width < 250 && $0.bounds.height < 250
+            && $0.bounds.origin.x >= 0 && $0.bounds.origin.x < 300
+        }
+        if thumbnails.isEmpty { return 0 }
+        let maxRight = thumbnails.map { $0.bounds.maxX }.max() ?? 0
+        return maxRight + 12
+    }
+
+    func stageArea() -> CGRect {
+        guard let screen = NSScreen.main else { return .zero }
+        let visible = screen.visibleFrame
+        let screenHeight = screen.frame.height
+        let cgY = screenHeight - visible.origin.y - visible.height
+        let strip = detectStripWidth()
+        return CGRect(
+            x: visible.origin.x + strip,
+            y: cgY,
+            width: visible.width - strip,
+            height: visible.height
+        )
+    }
+
+    func printStageState(label: String) {
+        let active = getActiveStage()
+        print("\n[\(label)] — \(active.count) windows")
+        for w in active {
+            print("  \(w.app) [\(w.wid)] \"\(w.title.prefix(40))\" — \(Int(w.bounds.origin.x)),\(Int(w.bounds.origin.y)) \(Int(w.bounds.width))x\(Int(w.bounds.height))")
+        }
+    }
+
+    // MARK: - Batch tile (no app activation — avoids SM stage switches)
+
+    func batchTile(_ moves: [(wid: UInt32, pid: Int32, frame: CGRect)]) {
+        guard !moves.isEmpty else { return }
+
+        var byPid: [Int32: [(wid: UInt32, target: CGRect)]] = [:]
+        for move in moves {
+            byPid[move.pid, default: []].append((wid: move.wid, target: move.frame))
+        }
+
+        // Freeze screen
+        let cid = _SLSMainConnectionID?()
+        if let cid { _ = _SLSDisableUpdate?(cid) }
+
+        for (pid, windowMoves) in byPid {
+            let appRef = AXUIElementCreateApplication(pid)
+            AXUIElementSetAttributeValue(appRef, "AXEnhancedUserInterface" as CFString, false as CFTypeRef)
+
+            var windowsRef: CFTypeRef?
+            guard AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef) == .success,
+                  let axWindows = windowsRef as? [AXUIElement] else { continue }
+
+            var axByWid: [UInt32: AXUIElement] = [:]
+            for axWin in axWindows {
+                var windowId: CGWindowID = 0
+                if _AXUIElementGetWindow(axWin, &windowId) == .success {
+                    axByWid[windowId] = axWin
+                }
+            }
+
+            for wm in windowMoves {
+                guard let axWin = axByWid[wm.wid] else { continue }
+
+                var newSize = CGSize(width: wm.target.width, height: wm.target.height)
+                var newPos = CGPoint(x: wm.target.origin.x, y: wm.target.origin.y)
+
+                if let sv = AXValueCreate(.cgSize, &newSize) {
+                    AXUIElementSetAttributeValue(axWin, kAXSizeAttribute as CFString, sv)
+                }
+                if let pv = AXValueCreate(.cgPoint, &newPos) {
+                    AXUIElementSetAttributeValue(axWin, kAXPositionAttribute as CFString, pv)
+                }
+                if let sv = AXValueCreate(.cgSize, &newSize) {
+                    AXUIElementSetAttributeValue(axWin, kAXSizeAttribute as CFString, sv)
+                }
+
+                AXUIElementPerformAction(axWin, kAXRaiseAction as CFString)
+            }
+
+            AXUIElementSetAttributeValue(appRef, "AXEnhancedUserInterface" as CFString, true as CFTypeRef)
+            // NO app.activate() — just move windows in place without triggering SM
+        }
+
+        if let cid { _ = _SLSReenableUpdate?(cid) }
+    }
+
+    func gridShape(for count: Int) -> [Int] {
+        switch count {
+        case 1:  return [1]
+        case 2:  return [2]
+        case 3:  return [1, 2]
+        case 4:  return [2, 2]
+        case 5:  return [3, 2]
+        case 6:  return [3, 3]
+        default:
+            let cols = Int(ceil(sqrt(Double(count) * 1.5)))
+            var rows: [Int] = []
+            var remaining = count
+            while remaining > 0 {
+                rows.append(min(cols, remaining))
+                remaining -= cols
+            }
+            return rows
+        }
+    }
+
+    // MARK: - Layouts (run one at a time)
+
+    /// swift test --filter StageTileTests/testMosaic
+    func testMosaic() throws {
+        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
+        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
+
+        let windows = getActiveStage()
+        guard windows.count >= 2 else {
+            print("Need >= 2 windows in active stage, got \(windows.count)")
+            return
+        }
+
+        let area = stageArea()
+        let gap: CGFloat = 6
+        let shape = gridShape(for: windows.count)
+
+        print("MOSAIC: \(windows.count) windows → \(shape)")
+        printStageState(label: "BEFORE")
+
+        var moves: [(wid: UInt32, pid: Int32, frame: CGRect)] = []
+        var idx = 0
+        let rows = shape.count
+        let rowH = (area.height - gap * CGFloat(rows + 1)) / CGFloat(rows)
+
+        for (row, cols) in shape.enumerated() {
+            let colW = (area.width - gap * CGFloat(cols + 1)) / CGFloat(cols)
+            for col in 0..<cols {
+                guard idx < windows.count else { break }
+                let win = windows[idx]
+                moves.append((wid: win.wid, pid: win.pid, frame: CGRect(
+                    x: area.origin.x + gap + CGFloat(col) * (colW + gap),
+                    y: area.origin.y + gap + CGFloat(row) * (rowH + gap),
+                    width: colW,
+                    height: rowH
+                )))
+                idx += 1
+            }
+        }
+
+        batchTile(moves)
+        Thread.sleep(forTimeInterval: 0.3)
+        printStageState(label: "AFTER")
+    }
+
+    /// swift test --filter StageTileTests/testMainSidebar
+    func testMainSidebar() throws {
+        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
+        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
+
+        let windows = getActiveStage()
+        guard windows.count >= 2 else { return }
+
+        let area = stageArea()
+        let gap: CGFloat = 6
+        let mainW = (area.width - gap * 3) * 0.65
+        let sideW = (area.width - gap * 3) * 0.35
+        let sideCount = windows.count - 1
+        let sideH = (area.height - gap * CGFloat(sideCount + 1)) / CGFloat(sideCount)
+
+        print("MAIN + SIDEBAR: 1 main (65%) + \(sideCount) stacked")
+        printStageState(label: "BEFORE")
+
+        var moves: [(wid: UInt32, pid: Int32, frame: CGRect)] = []
+
+        moves.append((wid: windows[0].wid, pid: windows[0].pid, frame: CGRect(
+            x: area.origin.x + gap,
+            y: area.origin.y + gap,
+            width: mainW,
+            height: area.height - gap * 2
+        )))
+
+        for i in 0..<sideCount {
+            let win = windows[i + 1]
+            moves.append((wid: win.wid, pid: win.pid, frame: CGRect(
+                x: area.origin.x + gap * 2 + mainW,
+                y: area.origin.y + gap + CGFloat(i) * (sideH + gap),
+                width: sideW,
+                height: sideH
+            )))
+        }
+
+        batchTile(moves)
+        Thread.sleep(forTimeInterval: 0.3)
+        printStageState(label: "AFTER")
+    }
+
+    /// swift test --filter StageTileTests/testColumns
+    func testColumns() throws {
+        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
+        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
+
+        let windows = getActiveStage()
+        guard windows.count >= 2 else { return }
+
+        let area = stageArea()
+        let gap: CGFloat = 6
+        let colW = (area.width - gap * CGFloat(windows.count + 1)) / CGFloat(windows.count)
+
+        print("COLUMNS: \(windows.count) equal")
+        printStageState(label: "BEFORE")
+
+        let moves = windows.enumerated().map { (i, win) in
+            (wid: win.wid, pid: win.pid, frame: CGRect(
+                x: area.origin.x + gap + CGFloat(i) * (colW + gap),
+                y: area.origin.y + gap,
+                width: colW,
+                height: area.height - gap * 2
+            ))
+        }
+
+        batchTile(moves)
+        Thread.sleep(forTimeInterval: 0.3)
+        printStageState(label: "AFTER")
+    }
+
+    /// swift test --filter StageTileTests/testTallWide
+    func testTallWide() throws {
+        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
+        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
+
+        let windows = getActiveStage()
+        guard windows.count >= 2 else { return }
+
+        let area = stageArea()
+        let gap: CGFloat = 6
+
+        // Terminal-like apps go tall on the left
+        let terminalApps = Set(["iTerm2", "Terminal", "Alacritty", "kitty", "Warp"])
+        let sorted = windows.sorted { a, b in
+            let aT = terminalApps.contains(a.app)
+            let bT = terminalApps.contains(b.app)
+            if aT != bT { return aT }
+            return a.wid < b.wid
+        }
+
+        let tallW = (area.width - gap * 3) * 0.45
+        let wideW = (area.width - gap * 3) * 0.55
+        let wideCount = sorted.count - 1
+        let wideH = (area.height - gap * CGFloat(wideCount + 1)) / CGFloat(wideCount)
+
+        print("TALL + WIDE: terminal left (45%), \(wideCount) stacked right (55%)")
+        printStageState(label: "BEFORE")
+
+        var moves: [(wid: UInt32, pid: Int32, frame: CGRect)] = []
+
+        moves.append((wid: sorted[0].wid, pid: sorted[0].pid, frame: CGRect(
+            x: area.origin.x + gap,
+            y: area.origin.y + gap,
+            width: tallW,
+            height: area.height - gap * 2
+        )))
+
+        for i in 0..<wideCount {
+            let win = sorted[i + 1]
+            moves.append((wid: win.wid, pid: win.pid, frame: CGRect(
+                x: area.origin.x + gap * 2 + tallW,
+                y: area.origin.y + gap + CGFloat(i) * (wideH + gap),
+                width: wideW,
+                height: wideH
+            )))
+        }
+
+        batchTile(moves)
+        Thread.sleep(forTimeInterval: 0.3)
+        printStageState(label: "AFTER")
+    }
+}

package/bin/handsoff-worker.ts

@@ -18,9 +18,18 @@
 
 import { infer, inferJSON } from "../lib/infer.ts";
 
+const INFER_TIMEOUT_MS = 15_000;
+
 /** Call infer and parse JSON if possible, otherwise treat as spoken-only response */
 async function inferSmart(prompt: string, options: any): Promise<{ data: any; raw: any }> {
-  const raw = await infer(prompt, options);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), INFER_TIMEOUT_MS);
+  let raw: any;
+  try {
+    raw = await infer(prompt, { ...options, abortSignal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
 
   // Try to parse as JSON
   let cleaned = raw.text

package/bin/lattices-app.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env bun
 
 import { execSync, spawn } from "node:child_process";
-import { existsSync, mkdirSync, chmodSync, createWriteStream } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync, mkdirSync, chmodSync, createWriteStream, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 import { get } from "node:https";
 import type { IncomingMessage } from "node:http";
 
@@ -12,9 +13,14 @@ const bundlePath = resolve(appDir, "Lattices.app");
 const binaryDir = resolve(bundlePath, "Contents/MacOS");
 const binaryPath = resolve(binaryDir, "Lattices");
 const entitlementsPath = resolve(__dirname, "../app/Lattices.entitlements");
+const resourcesDir = resolve(bundlePath, "Contents/Resources");
+const iconPath = resolve(__dirname, "../assets/AppIcon.icns");
+const tapSoundPath = resolve(__dirname, "../app/Resources/tap.wav");
 
 const REPO = "arach/lattices";
-const ASSET_NAME = "Lattices-macos-arm64";
+const RELEASE_APP_ASSET_NAMES = ["Lattices.dmg"];
+const RELEASE_BINARY_ASSET_NAMES = ["Lattices-macos-arm64", "LatticeApp-macos-arm64"];
+type ReleaseAsset = { name: string; browser_download_url: string };
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
@@ -51,6 +57,15 @@ function hasSwift(): boolean {
   }
 }
 
+function packageVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : "0.1.0";
+  } catch {
+    return "0.1.0";
+  }
+}
+
 function launch(extraArgs: string[] = []): void {
   if (isRunning()) {
     console.log("lattices app is already running.");
@@ -98,6 +113,53 @@ function signBundle(): void {
   );
 }
 
+function writeInfoPlist(): void {
+  mkdirSync(resolve(bundlePath, "Contents"), { recursive: true });
+  const version = packageVersion();
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleIdentifier</key>
+    <string>com.arach.lattices</string>
+    <key>CFBundleName</key>
+    <string>Lattices</string>
+    <key>CFBundleDisplayName</key>
+    <string>Lattices</string>
+    <key>CFBundleExecutable</key>
+    <string>Lattices</string>
+    <key>CFBundleIconFile</key>
+    <string>AppIcon</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleVersion</key>
+    <string>${version}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${version}</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>13.0</string>
+    <key>LSUIElement</key>
+    <true/>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+    <key>NSSupportsAutomaticTermination</key>
+    <true/>
+</dict>
+</plist>
+`;
+  writeFileSync(resolve(bundlePath, "Contents/Info.plist"), plist);
+}
+
+function syncBundleResources(): void {
+  mkdirSync(resourcesDir, { recursive: true });
+  if (existsSync(iconPath)) {
+    execSync(`cp '${iconPath}' '${resolve(resourcesDir, "AppIcon.icns")}'`);
+  }
+  if (existsSync(tapSoundPath)) {
+    execSync(`cp '${tapSoundPath}' '${resolve(resourcesDir, "tap.wav")}'`);
+  }
+}
+
 // ── Build from source (current arch only) ────────────────────────────
 
 function buildFromSource(): boolean {
@@ -116,20 +178,8 @@ function buildFromSource(): boolean {
 
   mkdirSync(binaryDir, { recursive: true });
   execSync(`cp '${builtPath}' '${binaryPath}'`);
-
-  // Copy Info.plist into bundle
-  const plistSrc = resolve(__dirname, "../app/Info.plist");
-  if (existsSync(plistSrc)) {
-    execSync(`cp '${plistSrc}' '${resolve(bundlePath, "Contents/Info.plist")}'`);
-  }
-
-  // Copy app icon into bundle
-  const iconSrc = resolve(__dirname, "../assets/AppIcon.icns");
-  const resourcesDir = resolve(bundlePath, "Contents/Resources");
-  mkdirSync(resourcesDir, { recursive: true });
-  if (existsSync(iconSrc)) {
-    execSync(`cp '${iconSrc}' '${resolve(resourcesDir, "AppIcon.icns")}'`);
-  }
+  writeInfoPlist();
+  syncBundleResources();
 
   // Re-sign the bundle so macOS TCC recognizes a stable identity across rebuilds.
   // Prefer a real local signing identity; only fall back to ad-hoc when necessary.
@@ -163,8 +213,36 @@ function httpsGet(url: string): Promise<IncomingMessage> {
   });
 }
 
+async function downloadToFile(url: string, destination: string): Promise<void> {
+  const res = await httpsGet(url);
+  const ws = createWriteStream(destination);
+  await new Promise<void>((resolve, reject) => {
+    res.pipe(ws);
+    ws.on("finish", resolve);
+    ws.on("error", reject);
+  });
+}
+
+function installBundleFromDmg(dmgPath: string): void {
+  const mountPoint = mkdtempSync(join(tmpdir(), "lattices-mount-"));
+  try {
+    execSync(`hdiutil attach -nobrowse -readonly -mountpoint '${mountPoint}' '${dmgPath}'`, { stdio: "pipe" });
+    const mountedBundle = resolve(mountPoint, "Lattices.app");
+    if (!existsSync(mountedBundle)) {
+      throw new Error("Lattices.app not found in mounted disk image");
+    }
+    rmSync(bundlePath, { recursive: true, force: true });
+    execSync(`cp -R '${mountedBundle}' '${bundlePath}'`);
+  } finally {
+    try {
+      execSync(`hdiutil detach '${mountPoint}' -quiet`, { stdio: "pipe" });
+    } catch {}
+    rmSync(mountPoint, { recursive: true, force: true });
+  }
+}
+
 async function download(): Promise<boolean> {
-  console.log("Downloading pre-built binary...");
+  console.log("Downloading pre-built lattices app...");
 
   try {
     const apiUrl = `https://api.github.com/repos/${REPO}/releases/latest`;
@@ -173,20 +251,31 @@ async function download(): Promise<boolean> {
     for await (const chunk of apiRes) chunks.push(chunk as Buffer);
     const release = JSON.parse(Buffer.concat(chunks).toString());
 
-    const asset = release.assets?.find((a: { name: string }) => a.name === ASSET_NAME);
-    if (!asset) throw new Error("Binary not found in release assets");
+    const assets: ReleaseAsset[] = Array.isArray(release.assets) ? release.assets : [];
+    const appAsset = assets.find((a) =>
+      RELEASE_APP_ASSET_NAMES.includes(a.name) || (a.name.endsWith(".dmg") && a.name.startsWith("Lattices"))
+    );
+    if (appAsset) {
+      const tempDir = mkdtempSync(join(tmpdir(), "lattices-download-"));
+      const dmgPath = resolve(tempDir, appAsset.name);
+      try {
+        await downloadToFile(appAsset.browser_download_url, dmgPath);
+        installBundleFromDmg(dmgPath);
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+      console.log("Download complete.");
+      return true;
+    }
 
-    const dlRes = await httpsGet(asset.browser_download_url);
+    const binaryAsset = assets.find((a) => RELEASE_BINARY_ASSET_NAMES.includes(a.name));
+    if (!binaryAsset) throw new Error("App bundle not found in release assets");
 
     mkdirSync(binaryDir, { recursive: true });
-    const ws = createWriteStream(binaryPath);
-    await new Promise<void>((resolve, reject) => {
-      dlRes.pipe(ws);
-      ws.on("finish", resolve);
-      ws.on("error", reject);
-    });
-
+    await downloadToFile(binaryAsset.browser_download_url, binaryPath);
     chmodSync(binaryPath, 0o755);
+    writeInfoPlist();
+    syncBundleResources();
     console.log("Download complete.");
     return true;
   } catch (e) {
@@ -200,21 +289,14 @@ async function download(): Promise<boolean> {
 async function ensureBinary(): Promise<void> {
   if (existsSync(binaryPath)) return;
 
-  // 1. Try local compile (fast, matches exact system)
-  if (hasSwift()) {
-    if (buildFromSource()) return;
-    console.log("Local build failed, trying download...");
-  }
-
-  // 2. Fall back to pre-built binary from GitHub releases
   const downloaded = await download();
   if (downloaded) return;
 
-  // 3. Nothing worked
   console.error(
-    "Could not build or download the lattices app.\n" +
+    "Could not find a bundled lattices app or download one.\n" +
     "Options:\n" +
-    "  \u2022 Install Xcode CLI tools:  xcode-select --install\n" +
+    "  \u2022 Reinstall or update @lattices/cli\n" +
+    "  \u2022 Developers can build from source with: lattices-app build\n" +
     "  \u2022 Download manually from:   https://github.com/" + REPO + "/releases"
   );
   process.exit(1);

package/bin/lattices-dev

@@ -5,11 +5,16 @@ set -euo pipefail
 
 SCRIPT_PATH="$(readlink -f "$0" 2>/dev/null || python3 -c "import os,sys; print(os.path.realpath(sys.argv[1]))" "$0")"
 APP_DIR="$(cd "$(dirname "$SCRIPT_PATH")/../app" && pwd)"
+ROOT="$(cd "$(dirname "$SCRIPT_PATH")/.." && pwd)"
 LOG_FILE="$HOME/.lattices/lattices.log"
 BINARY="$APP_DIR/.build/release/Lattices"
 BUNDLE="$APP_DIR/Lattices.app"
 BUNDLE_BIN="$BUNDLE/Contents/MacOS/Lattices"
+RESOURCES_DIR="$BUNDLE/Contents/Resources"
 ENTITLEMENTS="$APP_DIR/Lattices.entitlements"
+ICON="$ROOT/assets/AppIcon.icns"
+TAP_SOUND="$APP_DIR/Resources/tap.wav"
+VERSION="$(node -p "require('$ROOT/package.json').version" 2>/dev/null || echo '0.1.0')"
 
 red()   { printf "\033[31m%s\033[0m\n" "$*"; }
 green() { printf "\033[32m%s\033[0m\n" "$*"; }
@@ -50,13 +55,56 @@ sign_bundle() {
     fi
 }
 
+write_info_plist() {
+    mkdir -p "$BUNDLE/Contents"
+    cat > "$BUNDLE/Contents/Info.plist" <<PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleIdentifier</key>
+    <string>com.arach.lattices</string>
+    <key>CFBundleName</key>
+    <string>Lattices</string>
+    <key>CFBundleDisplayName</key>
+    <string>Lattices</string>
+    <key>CFBundleExecutable</key>
+    <string>Lattices</string>
+    <key>CFBundleIconFile</key>
+    <string>AppIcon</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleVersion</key>
+    <string>$VERSION</string>
+    <key>CFBundleShortVersionString</key>
+    <string>$VERSION</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>13.0</string>
+    <key>LSUIElement</key>
+    <true/>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+    <key>NSSupportsAutomaticTermination</key>
+    <true/>
+</dict>
+</plist>
+PLIST
+}
+
 cmd_build() {
     echo "Building release..."
     cd "$APP_DIR" && swift build -c release
-    # Copy into app bundle so it runs with the proper bundle ID
-    mkdir -p "$(dirname "$BUNDLE_BIN")" "$BUNDLE/Contents/Resources"
+    # Refresh the bundle so dev builds and published bundles are complete.
+    rm -rf "$BUNDLE/Contents/MacOS" "$RESOURCES_DIR"
+    mkdir -p "$(dirname "$BUNDLE_BIN")" "$RESOURCES_DIR"
     cp "$BINARY" "$BUNDLE_BIN"
-    cp "$APP_DIR/Info.plist" "$BUNDLE/Contents/Info.plist" 2>/dev/null || true
+    if [ -f "$ICON" ]; then
+        cp "$ICON" "$RESOURCES_DIR/AppIcon.icns"
+    fi
+    if [ -f "$TAP_SOUND" ]; then
+        cp "$TAP_SOUND" "$RESOURCES_DIR/tap.wav"
+    fi
+    write_info_plist
     # Re-sign so TCC permissions persist across rebuilds
     sign_bundle
     green "Build complete."