@lattices/cli 0.3.0 → 0.4.1

package/bin/lattices-app.ts

@@ -0,0 +1,338 @@
+#!/usr/bin/env bun
+
+import { execSync, spawn } from "node:child_process";
+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";
+
+const __dirname = import.meta.dir;
+const appDir = resolve(__dirname, "../app");
+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 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 ──────────────────────────────────────────────────────────
+
+function isRunning(): boolean {
+  try {
+    execSync("pgrep -x Lattices", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function quit(): boolean {
+  try {
+    execSync("pkill -x Lattices", { stdio: "pipe" });
+    // Wait briefly for process to exit
+    try { execSync("sleep 0.5", { stdio: "pipe" }); } catch {}
+    // Force kill if still running
+    if (isRunning()) {
+      execSync("pkill -9 -x Lattices", { stdio: "pipe" });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function hasSwift(): boolean {
+  try {
+    execSync("which swift", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+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.");
+    return;
+  }
+  const args = [bundlePath];
+  if (extraArgs.length) args.push("--args", ...extraArgs);
+  spawn("open", args, { detached: true, stdio: "ignore" }).unref();
+  console.log("lattices app launched.");
+}
+
+function resolveSigningIdentity(): string | null {
+  try {
+    const identities = execSync("security find-identity -v -p codesigning", { stdio: "pipe" }).toString();
+    return identities.match(/"(Developer ID Application:[^"]+)"/)?.[1]
+        || identities.match(/"(Apple Development:[^"]+)"/)?.[1]
+        || null;
+  } catch {
+    return null;
+  }
+}
+
+function signBundle(): void {
+  const identity = resolveSigningIdentity();
+  const entFlag = existsSync(entitlementsPath) ? ` --entitlements '${entitlementsPath}'` : "";
+
+  if (identity) {
+    console.log(`Signing with: ${identity}`);
+    try {
+      execSync(
+        `codesign --force --sign '${identity}'${entFlag} --identifier com.arach.lattices '${bundlePath}'`,
+        { stdio: "pipe" }
+      );
+      return;
+    } catch {
+      console.log(`Warning: signing with '${identity}' failed — falling back to ad-hoc.`);
+    }
+  } else {
+    console.log("Warning: no local signing identity found — falling back to ad-hoc.");
+  }
+
+  execSync(
+    `codesign --force --sign -${entFlag} --identifier com.arach.lattices '${bundlePath}'`,
+    { stdio: "pipe" }
+  );
+}
+
+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 {
+  console.log("Building lattices app from source...");
+  try {
+    execSync("swift build -c release", {
+      cwd: appDir,
+      stdio: "inherit",
+    });
+  } catch {
+    return false;
+  }
+
+  const builtPath = resolve(appDir, ".build/release/Lattices");
+  if (!existsSync(builtPath)) return false;
+
+  mkdirSync(binaryDir, { recursive: true });
+  execSync(`cp '${builtPath}' '${binaryPath}'`);
+  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.
+  try {
+    signBundle();
+  } catch {
+    // Non-fatal — app still works, just permissions won't persist across rebuilds
+    console.log("Warning: code signing failed — permissions may not persist across rebuilds.");
+  }
+  // Update bundle timestamp so Finder shows the correct modified date
+  try { execSync(`touch '${bundlePath}'`, { stdio: "pipe" }); } catch {}
+  console.log("Build complete.");
+  return true;
+}
+
+// ── Download from GitHub releases ────────────────────────────────────
+
+function httpsGet(url: string): Promise<IncomingMessage> {
+  return new Promise((resolve, reject) => {
+    get(url, { headers: { "User-Agent": "lattices" } }, (res) => {
+      if (res.statusCode! >= 300 && res.statusCode! < 400 && res.headers.location) {
+        return httpsGet(res.headers.location).then(resolve, reject);
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        res.resume();
+        return;
+      }
+      resolve(res);
+    }).on("error", reject);
+  });
+}
+
+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 lattices app...");
+
+  try {
+    const apiUrl = `https://api.github.com/repos/${REPO}/releases/latest`;
+    const apiRes = await httpsGet(apiUrl);
+    const chunks: Buffer[] = [];
+    for await (const chunk of apiRes) chunks.push(chunk as Buffer);
+    const release = JSON.parse(Buffer.concat(chunks).toString());
+
+    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 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 });
+    await downloadToFile(binaryAsset.browser_download_url, binaryPath);
+    chmodSync(binaryPath, 0o755);
+    writeInfoPlist();
+    syncBundleResources();
+    console.log("Download complete.");
+    return true;
+  } catch (e) {
+    console.log(`Download failed: ${(e as Error).message}`);
+    return false;
+  }
+}
+
+// ── Commands ─────────────────────────────────────────────────────────
+
+async function ensureBinary(): Promise<void> {
+  if (existsSync(binaryPath)) return;
+
+  const downloaded = await download();
+  if (downloaded) return;
+
+  console.error(
+    "Could not find a bundled lattices app or download one.\n" +
+    "Options:\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);
+}
+
+const cmd = process.argv[2];
+const flags = process.argv.slice(3);
+const launchFlags: string[] = [];
+if (flags.includes("--diagnostics") || flags.includes("-d")) launchFlags.push("--diagnostics");
+if (flags.includes("--screen-map") || flags.includes("-m")) launchFlags.push("--screen-map");
+
+if (cmd === "build") {
+  if (!hasSwift()) {
+    console.error("Swift is required. Install with: xcode-select --install");
+    process.exit(1);
+  }
+  buildFromSource();
+} else if (cmd === "quit") {
+  if (quit()) {
+    console.log("lattices app stopped.");
+  } else {
+    console.log("lattices app is not running.");
+  }
+} else if (cmd === "restart") {
+  // Quit → rebuild → relaunch
+  quit();
+  if (!hasSwift()) {
+    console.error("Swift is required. Install with: xcode-select --install");
+    process.exit(1);
+  }
+  if (!buildFromSource()) {
+    console.error("Build failed.");
+    process.exit(1);
+  }
+  launch(launchFlags);
+} else {
+  await ensureBinary();
+  launch(launchFlags);
+}

package/bin/lattices-dev

@@ -0,0 +1,208 @@
+#!/usr/bin/env bash
+# lattices-dev — convenience commands for Lattices development
+
+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" "$*"; }
+dim()   { printf "\033[2m%s\033[0m\n" "$*"; }
+
+select_sign_identity() {
+    local identities identity=""
+    identities="$(security find-identity -v -p codesigning 2>/dev/null || true)"
+    identity="$(printf '%s\n' "$identities" | sed -n 's/.*"\(Developer ID Application:[^"]*\)".*/\1/p' | head -n 1)"
+    if [ -z "$identity" ]; then
+        identity="$(printf '%s\n' "$identities" | sed -n 's/.*"\(Apple Development:[^"]*\)".*/\1/p' | head -n 1)"
+    fi
+    printf '%s' "$identity"
+}
+
+sign_bundle() {
+    local identity sign_status=0
+    local -a ent_flags=()
+
+    if [ -f "$ENTITLEMENTS" ]; then
+        ent_flags=(--entitlements "$ENTITLEMENTS")
+    fi
+
+    identity="$(select_sign_identity)"
+    if [ -n "$identity" ]; then
+        dim "Signing with: $identity"
+        if ! codesign --force --sign "$identity" "${ent_flags[@]}" --identifier com.arach.lattices "$BUNDLE"; then
+            red "Signing with '$identity' failed. Falling back to ad-hoc."
+            sign_status=1
+        fi
+    else
+        sign_status=1
+    fi
+
+    if [ "$sign_status" -ne 0 ]; then
+        dim "No usable signing identity found. Using ad-hoc signature."
+        codesign --force --sign - "${ent_flags[@]}" --identifier com.arach.lattices "$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
+    # 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"
+    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."
+}
+
+cmd_restart() {
+    echo "Restarting Lattices..."
+    pkill -x Lattices 2>/dev/null && sleep 1 || true
+    cmd_build
+    open "$BUNDLE"
+    green "Lattices restarted."
+}
+
+cmd_quit() {
+    if pkill -x Lattices 2>/dev/null; then
+        green "Lattices stopped."
+    else
+        dim "Lattices is not running."
+    fi
+}
+
+cmd_launch() {
+    if pgrep -x Lattices >/dev/null 2>&1; then
+        dim "Lattices is already running."
+    else
+        open "$BUNDLE"
+        green "Lattices launched."
+    fi
+}
+
+cmd_logs() {
+    if [ -f "$LOG_FILE" ]; then
+        tail -f "$LOG_FILE"
+    else
+        red "No log file at $LOG_FILE"
+    fi
+}
+
+cmd_log() {
+    # Show last N lines (default 30)
+    local n="${1:-30}"
+    if [ -f "$LOG_FILE" ]; then
+        tail -n "$n" "$LOG_FILE"
+    else
+        red "No log file at $LOG_FILE"
+    fi
+}
+
+cmd_clear_logs() {
+    if [ -f "$LOG_FILE" ]; then
+        > "$LOG_FILE"
+        green "Logs cleared."
+    else
+        dim "No log file to clear."
+    fi
+}
+
+cmd_status() {
+    if pgrep -x Lattices >/dev/null 2>&1; then
+        local pid=$(pgrep -x Lattices)
+        green "Lattices running (pid $pid)"
+    else
+        dim "Lattices is not running."
+    fi
+    if [ -f "$LOG_FILE" ]; then
+        local lines=$(wc -l < "$LOG_FILE" | tr -d ' ')
+        local size=$(du -h "$LOG_FILE" | cut -f1 | tr -d ' ')
+        dim "Log: $lines lines, $size"
+    fi
+    if [ -f "$HOME/.lattices/advisor-learning.jsonl" ]; then
+        local entries=$(wc -l < "$HOME/.lattices/advisor-learning.jsonl" | tr -d ' ')
+        dim "Advisor learning: $entries entries"
+    fi
+}
+
+cmd_help() {
+    echo "lattices-dev — Lattices development commands"
+    echo ""
+    echo "  restart      Quit + rebuild + relaunch"
+    echo "  build        Build release binary"
+    echo "  quit         Stop the running app"
+    echo "  launch       Start the app (if not running)"
+    echo "  logs         Tail the log file (live)"
+    echo "  log [N]      Show last N log lines (default 30)"
+    echo "  clear-logs   Clear the log file"
+    echo "  status       Show running state and stats"
+    echo "  help         Show this help"
+}
+
+case "${1:-help}" in
+    restart)    cmd_restart ;;
+    build)      cmd_build ;;
+    quit|stop)  cmd_quit ;;
+    launch|start) cmd_launch ;;
+    logs)       cmd_logs ;;
+    log)        cmd_log "${2:-30}" ;;
+    clear-logs) cmd_clear_logs ;;
+    status)     cmd_status ;;
+    help|--help|-h) cmd_help ;;
+    *) red "Unknown command: $1"; cmd_help; exit 1 ;;
+esac