bitbardd

README.md

@@ -77,13 +77,22 @@ curl -fsSL https://raw.githubusercontent.com/geersch/bitbard-cli/master/install.
 
 ### Uninstalling
 
+Run these commands to fully remove bitbard:
+
 ```sh
+# Stop and remove the background daemon
+launchctl unload ~/Library/LaunchAgents/com.bitbard.bitbardd.plist
+rm ~/Library/LaunchAgents/com.bitbard.bitbardd.plist
+
+# Remove installed binaries
+rm ~/.local/share/bitbard/bin/bitbardd
 rm ~/.local/bin/bitbard
-rm -rf ~/.local/share/bitbard
+
+# Optional: remove config and state
 rm -rf ~/.config/bitbard
 ```
 
-Then remove the `# Added by bitbard installer` block from your shell profile (`~/.zshrc`, `~/.bashrc`, etc.).
+Then remove the `export PATH` line added by the installer from your shell config file (e.g. `~/.zshrc`).
 
 ## Commands
 
@@ -171,7 +180,7 @@ Toggle a warm screen tint similar to [f.lux](https://justgetflux.com/). Reduces
 bitbard display flux
 ```
 
-Each invocation toggles the tint on or off. State is persisted in `~/.config/bitbard/flux.json`.
+Each invocation toggles the tint on or off. State is held in memory by the bitbardd daemon.
 
 > **Note:** macOS only. Requires permission to control display gamma (no additional entitlements needed beyond running as the current user).
 

install.sh

@@ -35,6 +35,48 @@ bb_warn() {
   printf "${ORANGE}Warning: %s${NC}\n" "$*" >&2
 }
 
+bb_install_launchagent() {
+  local plist_dir="${HOME}/Library/LaunchAgents"
+  local plist_path="${plist_dir}/com.bitbard.bitbardd.plist"
+  local daemon_bin="${INSTALL_DATA_DIR}/bitbardd"
+
+  mkdir -p "$plist_dir"
+
+  # Unload existing agent before replacing it
+  if [[ -f "$plist_path" ]]; then
+    launchctl unload "$plist_path" 2>/dev/null || true
+  fi
+
+  cat > "$plist_path" <<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>Label</key>
+  <string>com.bitbard.bitbardd</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${daemon_bin}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>/tmp/bitbardd.log</string>
+  <key>StandardErrorPath</key>
+  <string>/tmp/bitbardd.log</string>
+</dict>
+</plist>
+PLIST
+
+  if launchctl load "$plist_path" 2>/dev/null; then
+    bb_echo "=> bitbardd LaunchAgent installed and started"
+  else
+    bb_warn "launchctl load failed. Start manually: launchctl load ${plist_path}"
+  fi
+}
+
 usage() {
   cat <<EOF
 bitbard installer
@@ -180,12 +222,13 @@ mv "${tmp_dir}/${APP}" "${INSTALL_BIN_DIR}/${APP}"
 chmod 755 "${INSTALL_BIN_DIR}/${APP}"
 bb_echo "=> Installed ${APP} to ${INSTALL_BIN_DIR}/${APP}"
 
-# Install Swift helpers (may not exist on all platforms / in all releases)
+# Install bitbardd daemon (may not exist on all platforms / in all releases)
 if [[ -d "${tmp_dir}/bin" ]]; then
   mkdir -p "$INSTALL_DATA_DIR"
   cp -r "${tmp_dir}/bin/." "$INSTALL_DATA_DIR/"
   chmod 755 "${INSTALL_DATA_DIR}"/*
-  bb_echo "=> Installed Swift helpers to ${INSTALL_DATA_DIR}"
+  bb_echo "=> Installed bitbardd to ${INSTALL_DATA_DIR}"
+  bb_install_launchagent
 fi
 
 # ---------------------------------------------------------------------------

packages/bitbardd/Sources/AlertHandler.swift

@@ -0,0 +1,121 @@
+import AppKit
+
+// MARK: - Style constants
+
+private let pillRadius: CGFloat      = 27
+private let pillFillAlpha: CGFloat   = 0.75
+private let pillPaddingH: CGFloat    = 27
+private let pillPaddingV: CGFloat    = 13
+private let pillTextSize: CGFloat    = 27
+private let pillFadeIn               = 0.15
+private let pillFadeOut              = 0.15
+
+// MARK: - Pill view
+//
+// Pure AppKit, no SwiftUI.
+//
+// NSHostingView and NSHostingController both register SwiftUI attribute-graph
+// objects in the Objective-C autorelease pool. When a second alert is shown
+// before the first window closes, the pool accumulates stale back-pointers into
+// the first view's already-deallocated SwiftUI graph. When NSApp.run() drains
+// the pool between run-loop cycles, objc_release dereferences a dangling
+// pointer → EXC_BAD_ACCESS / SIGSEGV. Using plain AppKit drawing avoids the
+// autorelease pool entirely and is simpler for a static pill label.
+
+private class PillView: NSView {
+    private let label: NSTextField
+
+    init(message: String) {
+        label = NSTextField(labelWithString: message)
+        label.font = NSFont.systemFont(ofSize: pillTextSize, weight: .regular)
+        label.textColor = .white
+        label.backgroundColor = .clear
+        label.isBezeled = false
+        label.isEditable = false
+        label.sizeToFit()
+
+        let size = NSSize(
+            width:  label.frame.width  + pillPaddingH * 2,
+            height: label.frame.height + pillPaddingV * 2
+        )
+        super.init(frame: NSRect(origin: .zero, size: size))
+        wantsLayer = true
+
+        label.frame = NSRect(
+            x: pillPaddingH,
+            y: pillPaddingV,
+            width: label.frame.width,
+            height: label.frame.height
+        )
+        addSubview(label)
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    override func layout() {
+        super.layout()
+        guard let layer else { return }
+        layer.backgroundColor = NSColor(white: 0, alpha: pillFillAlpha).cgColor
+        layer.cornerRadius    = pillRadius
+        layer.borderColor     = NSColor.white.cgColor
+        layer.borderWidth     = 2
+    }
+}
+
+// MARK: - Handler
+
+class AlertHandler {
+    // Strong references keep windows alive until their fade-out completes.
+    private var activeWindows: [NSWindow] = []
+
+    @discardableResult
+    func handle(message: String, duration: Double) -> DaemonResponse {
+        guard let screen = NSScreen.main else {
+            return .failure("alert: no main screen available")
+        }
+
+        let pill = PillView(message: message)
+        let size = pill.frame.size
+
+        let screenFrame = screen.frame
+        let x = screenFrame.midX - size.width  / 2
+        let y = screenFrame.midY - size.height / 2 + screenFrame.height * 0.05
+
+        let win = NSWindow(
+            contentRect: NSRect(x: x, y: y, width: size.width, height: size.height),
+            styleMask: .borderless,
+            backing: .buffered,
+            defer: false
+        )
+        win.isOpaque = false
+        win.backgroundColor = .clear
+        win.level = .floating
+        win.ignoresMouseEvents = true
+        win.collectionBehavior = [.canJoinAllSpaces, .stationary, .fullScreenAuxiliary]
+        win.hasShadow = false
+        win.contentView = pill
+
+        activeWindows.append(win)
+        win.alphaValue = 0
+        win.orderFront(nil)
+
+        NSAnimationContext.runAnimationGroup { ctx in
+            ctx.duration = pillFadeIn
+            win.animator().alphaValue = 1
+        }
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + duration) { [weak self, weak win] in
+            guard let win else { return }
+            NSAnimationContext.runAnimationGroup({ ctx in
+                ctx.duration = pillFadeOut
+                win.animator().alphaValue = 0
+            }, completionHandler: { [weak self, weak win] in
+                guard let win else { return }
+                win.orderOut(nil)
+                self?.activeWindows.removeAll { $0 === win }
+            })
+        }
+
+        return .success("ok")
+    }
+}

packages/bitbardd/Sources/AnyCodable.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+/// A type-erased `Codable` wrapper for arbitrary JSON-compatible values.
+/// Supported types: `nil`, `Bool`, `Int`, `Double`, `String`,
+/// `[AnyCodable]`, `[String: AnyCodable]`.
+struct AnyCodable: Codable {
+    let value: Any?
+
+    init(_ value: Any?) {
+        self.value = value
+    }
+
+    /// Encode an `Encodable` value into an `AnyCodable` tree via JSONSerialization.
+    /// encode → Data → JSONSerialization.jsonObject → recursive AnyCodable tree
+    init<T: Encodable>(encoding value: T, encoder: JSONEncoder = JSONEncoder()) throws {
+        let data = try encoder.encode(value)
+        let obj = try JSONSerialization.jsonObject(with: data, options: [])
+        self.value = AnyCodable.fromFoundation(obj)
+    }
+
+    /// Recursively convert a Foundation JSON object into an AnyCodable-compatible value.
+    private static func fromFoundation(_ obj: Any) -> Any? {
+        switch obj {
+        case let dict as [String: Any]:
+            return dict.mapValues { AnyCodable(fromFoundation($0)) }
+        case let arr as [Any]:
+            return arr.map { AnyCodable(fromFoundation($0)) }
+        case let num as NSNumber:
+            // CFBooleanGetTypeID distinguishes NSNumber-wrapping-bool from numeric NSNumber
+            if CFGetTypeID(num) == CFBooleanGetTypeID() {
+                return num.boolValue
+            } else if num === kCFBooleanTrue || num === kCFBooleanFalse {
+                return num.boolValue
+            } else {
+                // Prefer Int if it round-trips, else Double
+                let d = num.doubleValue
+                let i = num.intValue
+                return Double(i) == d ? i : d
+            }
+        case let str as String:
+            return str
+        case is NSNull:
+            return nil
+        default:
+            return nil
+        }
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if container.decodeNil() {
+            value = nil
+        } else if let b = try? container.decode(Bool.self) {
+            value = b
+        } else if let i = try? container.decode(Int.self) {
+            value = i
+        } else if let d = try? container.decode(Double.self) {
+            value = d
+        } else if let s = try? container.decode(String.self) {
+            value = s
+        } else if let arr = try? container.decode([AnyCodable].self) {
+            value = arr
+        } else if let dict = try? container.decode([String: AnyCodable].self) {
+            value = dict
+        } else {
+            throw DecodingError.dataCorruptedError(
+                in: container,
+                debugDescription: "AnyCodable: unsupported JSON value"
+            )
+        }
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch value {
+        case nil:
+            try container.encodeNil()
+        case let b as Bool:
+            try container.encode(b)
+        case let i as Int:
+            try container.encode(i)
+        case let d as Double:
+            try container.encode(d)
+        case let s as String:
+            try container.encode(s)
+        case let arr as [AnyCodable]:
+            try container.encode(arr)
+        case let dict as [String: AnyCodable]:
+            try container.encode(dict)
+        default:
+            throw EncodingError.invalidValue(
+                value as Any,
+                .init(codingPath: encoder.codingPath,
+                      debugDescription: "AnyCodable: unsupported value type \(type(of: value as Any))")
+            )
+        }
+    }
+}