Gabriel Brown
b4ce148caf
Every role carried a single representative type, so setting "Images" changed image/png and left image/jpeg wherever it landed. That is how this desktop ended up opening PDFs in GIMP, PNGs in a pixel-art editor and MP3s in a video transcoder: nobody chose any of it, applications registered themselves for everything they could read, and the roles governed one type each. Roles now own families and write every type when set, the settings page exposes the documents, text and archives roles it never offered, and a new seed command curates a fresh machine during setup while always keeping a choice the user has already made. The shipped editor entry launches kitty explicitly. The stock nvim.desktop sets Terminal=true, which defers to whatever the system considers default rather than the terminal this desktop themes. Claude-Session: https://claude.ai/code/session_01BRvzt4H8XXLPVH5MyYdk9L
424 lines
15 KiB
Python
Executable File
424 lines
15 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
"""Read and update freedesktop defaults for Panama's settings page."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import ast
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
|
|
|
|
# A role owns a FAMILY of types, not one representative.
|
|
#
|
|
# Each role used to carry a single mime type, so setting "images" changed
|
|
# image/png and left image/jpeg wherever it happened to land. That is exactly
|
|
# how this machine ended up opening PNGs in a pixel-art editor, MP3s in a video
|
|
# transcoder and PDFs in GIMP: nobody chose any of it, the applications
|
|
# registered themselves and the roles only ever governed one type each.
|
|
#
|
|
# The FIRST entry in each list is the one queried when reporting the current
|
|
# handler; all of them are written when the role is set, so a family cannot
|
|
# drift apart again.
|
|
ROLE_TARGETS = {
|
|
"browser": ("settings", ["default-web-browser"]),
|
|
"mail": ("mime", ["x-scheme-handler/mailto"]),
|
|
"files": ("mime", ["inode/directory"]),
|
|
"terminal": ("mime", ["x-scheme-handler/terminal"]),
|
|
"music": ("mime", [
|
|
"audio/mpeg", "audio/flac", "audio/x-vorbis+ogg", "audio/ogg",
|
|
"audio/x-wav", "audio/mp4", "audio/aac", "audio/opus",
|
|
]),
|
|
"images": ("mime", [
|
|
"image/png", "image/jpeg", "image/gif", "image/webp",
|
|
"image/tiff", "image/bmp", "image/svg+xml", "image/avif",
|
|
]),
|
|
"video": ("mime", [
|
|
"video/mp4", "video/x-matroska", "video/webm", "video/quicktime",
|
|
"video/x-msvideo", "video/mpeg",
|
|
]),
|
|
"documents": ("mime", [
|
|
"application/pdf", "application/epub+zip",
|
|
]),
|
|
"text": ("mime", [
|
|
"text/plain", "text/markdown", "text/x-python", "text/x-csrc",
|
|
"text/x-chdr", "text/x-c++src", "text/x-shellscript",
|
|
"application/json", "application/x-yaml", "text/xml",
|
|
]),
|
|
"archives": ("mime", [
|
|
"application/zip", "application/x-tar", "application/gzip",
|
|
"application/x-7z-compressed", "application/vnd.rar",
|
|
]),
|
|
}
|
|
DESKTOP_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._+-]*\.desktop$")
|
|
EXEC_CMD = re.compile(r"hl\.exec_cmd\(\s*(\"(?:\\.|[^\"\\])*\")\s*\)")
|
|
|
|
|
|
class BoundaryError(RuntimeError):
|
|
"""A user-visible validation or command failure."""
|
|
|
|
|
|
def xdg_data_roots() -> list[Path]:
|
|
data_home = Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local/share"))
|
|
data_dirs = os.environ.get("XDG_DATA_DIRS", "/usr/local/share:/usr/share")
|
|
return [data_home, *(Path(item) for item in data_dirs.split(":") if item)]
|
|
|
|
|
|
def discovered_desktop_files() -> dict[str, Path]:
|
|
desktop_files: dict[str, Path] = {}
|
|
for root in xdg_data_roots():
|
|
applications = root / "applications"
|
|
if not applications.is_dir():
|
|
continue
|
|
for path in applications.rglob("*.desktop"):
|
|
if not path.is_file():
|
|
continue
|
|
relative = path.relative_to(applications)
|
|
desktop_files.setdefault("-".join(relative.parts), path)
|
|
return desktop_files
|
|
|
|
|
|
def discovered_desktop_ids() -> set[str]:
|
|
return set(discovered_desktop_files())
|
|
|
|
|
|
def require_desktop_id(desktop_id: str, *, discovered: set[str]) -> None:
|
|
if not DESKTOP_ID.fullmatch(desktop_id) or desktop_id not in discovered:
|
|
raise BoundaryError("That application is not available.")
|
|
|
|
|
|
def run(command: list[str]) -> str:
|
|
completed = subprocess.run(command, check=False, capture_output=True, text=True)
|
|
if completed.returncode != 0:
|
|
detail = completed.stderr.strip()
|
|
raise BoundaryError(detail or "The system default could not be updated.")
|
|
return completed.stdout.strip()
|
|
|
|
|
|
def query_handlers() -> dict[str, str]:
|
|
handlers: dict[str, str] = {}
|
|
for role, (kind, targets) in ROLE_TARGETS.items():
|
|
# The first type represents the family when reporting.
|
|
target = targets[0]
|
|
command = (
|
|
["xdg-settings", "get", target]
|
|
if kind == "settings"
|
|
else ["xdg-mime", "query", "default", target]
|
|
)
|
|
output = run(command)
|
|
handlers[role] = output.splitlines()[0] if output else ""
|
|
return handlers
|
|
|
|
|
|
def parse_desktop_entry(path: Path) -> dict[str, str]:
|
|
values: dict[str, str] = {}
|
|
section = ""
|
|
try:
|
|
lines = path.read_text(encoding="utf-8").splitlines()
|
|
except (OSError, UnicodeError) as error:
|
|
raise BoundaryError(f"Could not read {path.name}.") from error
|
|
for line in lines:
|
|
stripped = line.strip()
|
|
if stripped.startswith("[") and stripped.endswith("]"):
|
|
section = stripped[1:-1]
|
|
continue
|
|
if section != "Desktop Entry" or "=" not in line or stripped.startswith("#"):
|
|
continue
|
|
key, value = line.split("=", 1)
|
|
values.setdefault(key.strip(), value.strip())
|
|
return values
|
|
|
|
|
|
def autostart_directory() -> Path:
|
|
config_home = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
|
|
return config_home / "autostart"
|
|
|
|
|
|
def user_autostart_entries() -> list[dict[str, object]]:
|
|
directory = autostart_directory()
|
|
if not directory.is_dir():
|
|
return []
|
|
entries: list[dict[str, object]] = []
|
|
for path in directory.glob("*.desktop"):
|
|
if path.is_symlink() or not path.is_file():
|
|
continue
|
|
values = parse_desktop_entry(path)
|
|
entries.append(
|
|
{
|
|
"id": path.name,
|
|
"name": values.get("Name", path.stem),
|
|
"enabled": values.get("Hidden", "false").lower() != "true",
|
|
}
|
|
)
|
|
return sorted(entries, key=lambda entry: (str(entry["name"]).casefold(), str(entry["id"])))
|
|
|
|
|
|
def hypr_autostart_path() -> Path:
|
|
override = os.environ.get("PANAMA_HYPR_AUTOSTART")
|
|
if override:
|
|
return Path(override)
|
|
return Path(__file__).resolve().parents[2] / "hypr" / "autostart.lua"
|
|
|
|
|
|
def lua_autostart_entries() -> list[dict[str, object]]:
|
|
path = hypr_autostart_path()
|
|
try:
|
|
lines = path.read_text(encoding="utf-8").splitlines()
|
|
except (OSError, UnicodeError):
|
|
return []
|
|
|
|
commands: list[str] = []
|
|
in_start_handler = False
|
|
for line in lines:
|
|
if not in_start_handler:
|
|
in_start_handler = bool(re.search(r'hl\.on\(\s*"hyprland\.start"', line))
|
|
continue
|
|
if line.strip() == "end)":
|
|
break
|
|
match = EXEC_CMD.search(line)
|
|
if match:
|
|
try:
|
|
commands.append(ast.literal_eval(match.group(1)))
|
|
except (SyntaxError, ValueError):
|
|
continue
|
|
|
|
return [
|
|
{
|
|
"id": f"hyprland:{index}",
|
|
"name": command.split()[0].rsplit("/", 1)[-1],
|
|
"command": command,
|
|
"enabled": True,
|
|
"readOnly": True,
|
|
"source": "config/dot/hypr/autostart.lua",
|
|
}
|
|
for index, command in enumerate(commands, start=1)
|
|
]
|
|
|
|
|
|
def snapshot() -> dict[str, object]:
|
|
return {
|
|
"handlers": query_handlers(),
|
|
"autostartEntries": user_autostart_entries(),
|
|
"luaAutostartEntries": lua_autostart_entries(),
|
|
}
|
|
|
|
|
|
def set_default(role: str, desktop_id: str) -> None:
|
|
target = ROLE_TARGETS.get(role)
|
|
if target is None:
|
|
raise BoundaryError("That default application role is not supported.")
|
|
require_desktop_id(desktop_id, discovered=discovered_desktop_ids())
|
|
kind, settings = target
|
|
if kind == "settings":
|
|
run(["xdg-settings", "set", settings[0], desktop_id])
|
|
return
|
|
# Every type in the family, so a role cannot be half-applied. xdg-mime
|
|
# accepts several types in one call, but they are written individually so a
|
|
# type this system does not know about cannot fail the whole role.
|
|
for setting in settings:
|
|
run(["xdg-mime", "default", desktop_id, setting])
|
|
|
|
|
|
# What this desktop opens a file with, when nobody has said otherwise.
|
|
#
|
|
# Applications register themselves for every type they can technically read, so
|
|
# an unattended machine decides these by installation order: a pixel-art editor
|
|
# claims PNG, a video transcoder claims MP3, an image editor claims PDF. None of
|
|
# that is a choice anyone made, and it is only discovered by double-clicking.
|
|
#
|
|
# Each role lists candidates best-first; the first one installed wins. A role
|
|
# with no candidate installed is left alone rather than forced.
|
|
PREFERRED_HANDLERS = {
|
|
"images": ["org.gnome.Loupe.desktop", "org.gnome.eog.desktop"],
|
|
"music": ["org.gnome.Decibels.desktop", "io.bassi.Amberol.desktop", "io.mpv.Mpv.desktop"],
|
|
"video": ["io.mpv.Mpv.desktop", "mpv.desktop", "org.gnome.Totem.desktop"],
|
|
"documents": ["org.gnome.Papers.desktop", "org.gnome.Evince.desktop"],
|
|
"text": ["panama-nvim.desktop"],
|
|
"archives": ["org.gnome.Nautilus.desktop", "org.gnome.FileRoller.desktop"],
|
|
}
|
|
|
|
|
|
def user_mimeapps() -> Path:
|
|
config_home = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
|
|
return config_home / "mimeapps.list"
|
|
|
|
|
|
def chosen_types() -> set[str]:
|
|
"""Types the person using this machine has already assigned by hand.
|
|
|
|
A type listed under [Default Applications] in the user's own mimeapps.list
|
|
got there because someone picked "Open With" and made it stick, or because
|
|
the settings page wrote it. Seeding must never overrule that.
|
|
"""
|
|
path = user_mimeapps()
|
|
if not path.is_file():
|
|
return set()
|
|
chosen: set[str] = set()
|
|
section = ""
|
|
try:
|
|
lines = path.read_text(encoding="utf-8").splitlines()
|
|
except (OSError, UnicodeError):
|
|
return set()
|
|
for line in lines:
|
|
stripped = line.strip()
|
|
if stripped.startswith("[") and stripped.endswith("]"):
|
|
section = stripped[1:-1]
|
|
continue
|
|
if section != "Default Applications" or "=" not in line or stripped.startswith("#"):
|
|
continue
|
|
chosen.add(line.split("=", 1)[0].strip())
|
|
return chosen
|
|
|
|
|
|
def seed() -> None:
|
|
"""Apply Panama's curated defaults to roles nobody has chosen for."""
|
|
discovered = discovered_desktop_ids()
|
|
already = chosen_types()
|
|
for role, candidates in PREFERRED_HANDLERS.items():
|
|
kind, targets = ROLE_TARGETS[role]
|
|
if kind != "mime":
|
|
continue
|
|
if any(target in already for target in targets):
|
|
print(f"{role}: keeping the existing choice")
|
|
continue
|
|
preferred = next((entry for entry in candidates if entry in discovered), None)
|
|
if preferred is None:
|
|
print(f"{role}: no preferred application installed, leaving it alone")
|
|
continue
|
|
set_default(role, preferred)
|
|
print(f"{role}: {preferred}")
|
|
|
|
|
|
def with_hidden(original: str, *, hidden: bool) -> str:
|
|
lines = original.splitlines()
|
|
output: list[str] = []
|
|
section = ""
|
|
found_section = False
|
|
wrote_hidden = False
|
|
for line in lines:
|
|
stripped = line.strip()
|
|
if stripped.startswith("[") and stripped.endswith("]"):
|
|
if section == "Desktop Entry" and not wrote_hidden:
|
|
output.append(f"Hidden={'true' if hidden else 'false'}")
|
|
wrote_hidden = True
|
|
section = stripped[1:-1]
|
|
found_section = found_section or section == "Desktop Entry"
|
|
output.append(line)
|
|
continue
|
|
if section == "Desktop Entry" and line.split("=", 1)[0].strip() == "Hidden":
|
|
if not wrote_hidden:
|
|
output.append(f"Hidden={'true' if hidden else 'false'}")
|
|
wrote_hidden = True
|
|
continue
|
|
output.append(line)
|
|
|
|
if not found_section:
|
|
raise BoundaryError("That autostart entry is not a desktop file.")
|
|
if not wrote_hidden:
|
|
output.append(f"Hidden={'true' if hidden else 'false'}")
|
|
return "\n".join(output) + "\n"
|
|
|
|
|
|
def write_atomic(path: Path, text: str, *, mode: int) -> None:
|
|
temporary_path: Path | None = None
|
|
try:
|
|
with tempfile.NamedTemporaryFile(
|
|
"w", encoding="utf-8", dir=path.parent, prefix=f".{path.name}.", delete=False
|
|
) as temporary:
|
|
temporary.write(text)
|
|
temporary.flush()
|
|
os.fsync(temporary.fileno())
|
|
temporary_path = Path(temporary.name)
|
|
temporary_path.chmod(mode)
|
|
os.replace(temporary_path, path)
|
|
except OSError as error:
|
|
if temporary_path is not None:
|
|
temporary_path.unlink(missing_ok=True)
|
|
raise BoundaryError("That autostart entry could not be updated.") from error
|
|
|
|
|
|
def update_hidden(path: Path, *, hidden: bool) -> None:
|
|
try:
|
|
original = path.read_text(encoding="utf-8")
|
|
except (OSError, UnicodeError) as error:
|
|
raise BoundaryError("That autostart entry could not be read.") from error
|
|
|
|
mode = path.stat().st_mode
|
|
write_atomic(path, with_hidden(original, hidden=hidden), mode=mode)
|
|
|
|
|
|
def add_autostart(desktop_id: str) -> None:
|
|
desktop_files = discovered_desktop_files()
|
|
require_desktop_id(desktop_id, discovered=set(desktop_files))
|
|
source = desktop_files[desktop_id]
|
|
directory = autostart_directory()
|
|
try:
|
|
directory.mkdir(parents=True, exist_ok=True)
|
|
except OSError as error:
|
|
raise BoundaryError("The user autostart directory could not be created.") from error
|
|
|
|
target = directory / desktop_id
|
|
if target.is_symlink():
|
|
raise BoundaryError("That autostart entry is not available.")
|
|
if target.exists():
|
|
if not target.is_file():
|
|
raise BoundaryError("That autostart entry is not available.")
|
|
update_hidden(target, hidden=False)
|
|
return
|
|
|
|
try:
|
|
original = source.read_text(encoding="utf-8")
|
|
except (OSError, UnicodeError) as error:
|
|
raise BoundaryError("That application could not be read.") from error
|
|
write_atomic(target, with_hidden(original, hidden=False), mode=0o644)
|
|
|
|
|
|
def set_autostart(desktop_id: str, enabled_text: str) -> None:
|
|
if enabled_text not in {"true", "false"}:
|
|
raise BoundaryError("Autostart state must be true or false.")
|
|
if not DESKTOP_ID.fullmatch(desktop_id):
|
|
raise BoundaryError("That autostart entry is not available.")
|
|
|
|
directory = autostart_directory()
|
|
path = directory / desktop_id
|
|
try:
|
|
resolved_directory = directory.resolve(strict=True)
|
|
resolved_path = path.resolve(strict=True)
|
|
except OSError as error:
|
|
raise BoundaryError("That autostart entry is not available.") from error
|
|
if path.is_symlink() or resolved_path.parent != resolved_directory or not resolved_path.is_file():
|
|
raise BoundaryError("That autostart entry is not available.")
|
|
update_hidden(resolved_path, hidden=enabled_text == "false")
|
|
|
|
|
|
def main(arguments: list[str]) -> int:
|
|
try:
|
|
if arguments == ["snapshot"]:
|
|
print(json.dumps(snapshot(), separators=(",", ":")))
|
|
elif arguments == ["seed"]:
|
|
seed()
|
|
elif len(arguments) == 3 and arguments[0] == "set-default":
|
|
set_default(arguments[1], arguments[2])
|
|
elif len(arguments) == 3 and arguments[0] == "set-autostart":
|
|
set_autostart(arguments[1], arguments[2])
|
|
elif len(arguments) == 2 and arguments[0] == "add-autostart":
|
|
add_autostart(arguments[1])
|
|
else:
|
|
raise BoundaryError(
|
|
"Usage: panama-default-apps snapshot | seed | set-default ROLE DESKTOP_ID | "
|
|
"set-autostart DESKTOP_ID true|false | add-autostart DESKTOP_ID"
|
|
)
|
|
except BoundaryError as error:
|
|
print(str(error), file=sys.stderr)
|
|
return 2
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main(sys.argv[1:]))
|