pi-leo-bridge 0.1.1

package/scripts/remove-brave-models.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import stat
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+def atomic_bytes(path: Path, payload: bytes, mode: int) -> None:
+    fd, temporary = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+    try:
+        with os.fdopen(fd, "wb") as stream:
+            stream.write(payload)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.chmod(temporary, mode)
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("--preferences", type=Path)
+    args = parser.parse_args()
+
+    config = json.loads(args.config.read_text())
+    if not isinstance(config, dict):
+        raise RuntimeError("Invalid bridge configuration")
+    configured_path = config.get("bravePreferencesPath")
+    preferences_path = args.preferences or (
+        Path(configured_path)
+        if isinstance(configured_path, str)
+        else Path.home()
+        / "Library/Application Support/BraveSoftware/Brave-Browser/Default/Preferences"
+    )
+    if not preferences_path.is_file():
+        raise RuntimeError(f"Brave Preferences not found: {preferences_path}")
+
+    owned_keys = {
+        key for key in config.get("braveModelKeys", []) if isinstance(key, str)
+    }
+    owned_ids = (
+        {
+            profile.get("publicModelId")
+            for profile in config.get("profiles", [])
+            if isinstance(profile, dict) and isinstance(profile.get("publicModelId"), str)
+        }
+        if not owned_keys
+        else set()
+    )
+    raw = preferences_path.read_bytes()
+    preferences: dict[str, Any] = json.loads(raw)
+    ai_chat = preferences.get("brave", {}).get("ai_chat", {})
+    models = ai_chat.get("custom_models", [])
+    if not isinstance(models, list) or not all(isinstance(model, dict) for model in models):
+        raise RuntimeError("Unexpected Brave custom-model preference structure")
+
+    def managed(model: dict[str, Any]) -> bool:
+        # Current installations use the exact random Brave keys recorded in
+        # config. Model ids are only a compatibility fallback for the original
+        # private build, which did not record those keys.
+        return model.get("key") in owned_keys or (
+            not owned_keys and model.get("model_request_name") in owned_ids
+        )
+
+    removed = [model for model in models if managed(model)]
+    if not removed:
+        print("No managed Pi Leo models were present in Brave.")
+        return
+
+    removed_keys = {model.get("key") for model in removed}
+    retained = [model for model in models if not managed(model)]
+    ai_chat["custom_models"] = retained
+    if ai_chat.get("default_model_key") in removed_keys:
+        previous = config.get("previousDefaultModelKey")
+        retained_keys = {model.get("key") for model in retained}
+        previous_is_available = (
+            isinstance(previous, str)
+            and bool(previous)
+            and (not previous.startswith("custom:") or previous in retained_keys)
+        )
+        if previous_is_available:
+            ai_chat["default_model_key"] = previous
+        else:
+            ai_chat.pop("default_model_key", None)
+
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
+    backup = preferences_path.with_name(
+        f"Preferences.backup-{stamp}-before-pi-leo-bridge-uninstall"
+    )
+    shutil.copy2(preferences_path, backup)
+    if backup.read_bytes() != raw:
+        raise RuntimeError("Brave Preferences backup verification failed")
+
+    encoded = json.dumps(preferences, ensure_ascii=False, separators=(",", ":")).encode()
+    json.loads(encoded)
+    mode = stat.S_IMODE(preferences_path.stat().st_mode)
+    atomic_bytes(preferences_path, encoded, mode)
+    print(f"Removed {len(removed)} managed Brave model(s).")
+    print(f"Brave backup: {backup}")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/set-brave-default.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import stat
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+def atomic_bytes(path: Path, payload: bytes, mode: int) -> None:
+    fd, temporary = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+    try:
+        with os.fdopen(fd, "wb") as stream:
+            stream.write(payload)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.chmod(temporary, mode)
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("selector", help="Thinking level, public model id, or 'restore'")
+    args = parser.parse_args()
+
+    config: dict[str, Any] = json.loads(args.config.read_text())
+    preferences_value = config.get("bravePreferencesPath")
+    if not isinstance(preferences_value, str):
+        raise RuntimeError("The installed configuration has no Brave profile path")
+    preferences_path = Path(preferences_value)
+    raw = preferences_path.read_bytes()
+    preferences = json.loads(raw)
+    ai_chat = preferences.get("brave", {}).get("ai_chat", {})
+    models = ai_chat.get("custom_models", [])
+    if not isinstance(models, list):
+        raise RuntimeError("Unexpected Brave custom-model preference structure")
+
+    if args.selector == "restore":
+        previous = config.get("previousDefaultModelKey")
+        available_custom_keys = {
+            model.get("key") for model in models if isinstance(model, dict)
+        }
+        if not isinstance(previous, str) or not previous:
+            raise RuntimeError("No previous Brave default was recorded")
+        if previous.startswith("custom:") and previous not in available_custom_keys:
+            raise RuntimeError("The previously selected custom model no longer exists")
+        ai_chat["default_model_key"] = previous
+        selected_label = "the recorded previous Brave model"
+    else:
+        profiles = config.get("profiles", [])
+        profile_index = next(
+            (
+                index
+                for index, candidate in enumerate(profiles)
+                if isinstance(candidate, dict)
+                and (
+                    candidate.get("thinkingLevel") == args.selector
+                    or candidate.get("publicModelId") == args.selector
+                )
+            ),
+            None,
+        )
+        profile = profiles[profile_index] if profile_index is not None else None
+        if profile is None:
+            levels = ", ".join(
+                str(candidate.get("thinkingLevel"))
+                for candidate in profiles
+                if isinstance(candidate, dict)
+            )
+            raise RuntimeError(f"Unknown profile. Available thinking levels: {levels}")
+        managed_keys = config.get("braveModelKeys", [])
+        expected_key = (
+            managed_keys[profile_index]
+            if isinstance(managed_keys, list)
+            and profile_index is not None
+            and profile_index < len(managed_keys)
+            else None
+        )
+        model = next(
+            (
+                candidate
+                for candidate in models
+                if isinstance(candidate, dict)
+                and candidate.get("model_request_name") == profile.get("publicModelId")
+                and (expected_key is None or candidate.get("key") == expected_key)
+            ),
+            None,
+        )
+        if model is None or not isinstance(model.get("key"), str):
+            raise RuntimeError("The selected managed model is missing from Brave")
+        ai_chat["default_model_key"] = model["key"]
+        selected_label = str(model.get("label") or profile.get("publicModelId"))
+
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
+    backup = preferences_path.with_name(
+        f"Preferences.backup-{stamp}-before-pi-leo-default-change"
+    )
+    shutil.copy2(preferences_path, backup)
+    if backup.read_bytes() != raw:
+        raise RuntimeError("Brave Preferences backup verification failed")
+
+    encoded = json.dumps(preferences, ensure_ascii=False, separators=(",", ":")).encode()
+    json.loads(encoded)
+    atomic_bytes(preferences_path, encoded, stat.S_IMODE(preferences_path.stat().st_mode))
+    print(f"Default for new Leo conversations: {selected_label}")
+    print(f"Brave backup: {backup}")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/uninstall.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+LABEL="com.ojm.pi-leo-bridge"
+CONFIG="${HOME}/.config/pi-leo-bridge/config.json"
+PLIST="${HOME}/Library/LaunchAgents/${LABEL}.plist"
+ASSUME_YES=false
+PURGE=false
+
+usage() {
+  cat <<'EOF'
+Usage: pi-leo uninstall [--yes] [--purge]
+
+Stops and removes the LaunchAgent and removes models managed by this bridge
+from Brave after creating a verified Preferences backup.
+
+  --yes          Do not ask for confirmation
+  --purge        Also remove bridge workspace and logs
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --yes) ASSUME_YES=true; shift ;;
+    --purge) PURGE=true; shift ;;
+    -h|--help) usage; exit 0 ;;
+    *) echo "Unknown option: $1" >&2; usage >&2; exit 2 ;;
+  esac
+done
+
+if [[ "$ASSUME_YES" != true && -t 0 ]]; then
+  read -r -p "Remove the Pi Leo service and its managed Brave models? [y/N] " answer
+  case "$answer" in y|Y|yes|YES) ;; *) echo "Cancelled."; exit 0 ;; esac
+fi
+
+WAS_RUNNING=false
+RELAUNCHED=false
+APP_NAME="Brave Browser"
+PREFERENCES=""
+if [[ -f "$CONFIG" ]]; then
+  TARGET="$(python3 - "$CONFIG" <<'PY'
+import json,sys
+c=json.load(open(sys.argv[1]))
+print(c.get('bravePreferencesPath',''))
+print(c.get('braveApplicationName','Brave Browser'))
+PY
+)"
+  PREFERENCES="$(printf '%s\n' "$TARGET" | sed -n '1p')"
+  APP_NAME="$(printf '%s\n' "$TARGET" | sed -n '2p')"
+fi
+
+if [[ -f "$CONFIG" && ( -z "$PREFERENCES" || ! -f "$PREFERENCES" ) ]]; then
+  echo "Configured Brave Preferences could not be found; refusing to orphan authenticated model entries." >&2
+  echo "Expected: ${PREFERENCES:-<missing from configuration>}" >&2
+  exit 1
+fi
+
+WAS_LOADED=false
+UNINSTALL_SUCCEEDED=false
+if launchctl print "gui/${UID}/${LABEL}" >/dev/null 2>&1; then
+  WAS_LOADED=true
+fi
+launchctl bootout "gui/${UID}/${LABEL}" >/dev/null 2>&1 || true
+
+relaunch_if_needed() {
+  if [[ "$UNINSTALL_SUCCEEDED" != true && "$WAS_LOADED" == true && -f "$PLIST" ]]; then
+    launchctl bootstrap "gui/${UID}" "$PLIST" >/dev/null 2>&1 || true
+    launchctl enable "gui/${UID}/${LABEL}" >/dev/null 2>&1 || true
+  fi
+  if [[ "$WAS_RUNNING" == true && "$RELAUNCHED" == false ]]; then
+    open -a "$APP_NAME" >/dev/null 2>&1 || true
+  fi
+}
+trap relaunch_if_needed EXIT
+
+if [[ -f "$CONFIG" ]]; then
+  if pgrep -x "$APP_NAME" >/dev/null 2>&1; then
+    WAS_RUNNING=true
+    echo "Quitting $APP_NAME briefly to remove the managed model entries..."
+    for _ in 1 2 3; do
+      osascript -e "tell application \"$APP_NAME\" to quit" >/dev/null 2>&1 || true
+      for _ in $(seq 1 20); do
+        pgrep -x "$APP_NAME" >/dev/null 2>&1 || break
+        sleep 0.5
+      done
+      pgrep -x "$APP_NAME" >/dev/null 2>&1 || break
+    done
+    if pgrep -x "$APP_NAME" >/dev/null 2>&1; then
+      echo "$APP_NAME did not quit; Brave Preferences were not changed." >&2
+      exit 1
+    fi
+  fi
+  python3 "$ROOT/scripts/remove-brave-models.py" \
+    --config "$CONFIG" \
+    --preferences "$PREFERENCES"
+fi
+
+rm -f "$PLIST"
+rm -f "$CONFIG"
+rmdir "${HOME}/.config/pi-leo-bridge" >/dev/null 2>&1 || true
+
+BIN_LINK="${HOME}/.local/bin/pi-leo"
+if [[ -L "$BIN_LINK" ]]; then
+  LINK_TARGET="$(python3 - "$BIN_LINK" <<'PY'
+import sys
+from pathlib import Path
+print(Path(sys.argv[1]).resolve())
+PY
+)"
+  if [[ "$LINK_TARGET" == "$ROOT/bin/pi-leo" ]]; then
+    rm -f "$BIN_LINK"
+  fi
+fi
+
+if [[ "$PURGE" == true ]]; then
+  rm -rf "${HOME}/.local/share/pi-leo-bridge"
+  rm -f \
+    "${HOME}/Library/Logs/pi-leo-bridge.log" \
+    "${HOME}/Library/Logs/pi-leo-bridge.error.log"
+fi
+
+UNINSTALL_SUCCEEDED=true
+if [[ "$WAS_RUNNING" == true ]]; then
+  open -a "$APP_NAME"
+  RELAUNCHED=true
+fi
+trap - EXIT
+
+echo "Pi Leo bridge uninstalled."
+if [[ "$PURGE" != true ]]; then
+  echo "Workspace and logs were retained; use --purge to remove them."
+fi