tool-tray 0.3.8__py3-none-any.whl

tool_tray/config.py

@@ -0,0 +1,109 @@
+import base64
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def get_config_dir() -> Path:
+    """Get OS-appropriate config directory."""
+    if sys.platform == "win32":
+        base = os.environ.get("LOCALAPPDATA")
+        if base:
+            return Path(base) / "tooltray"
+        return Path.home() / "AppData/Local/tooltray"
+    elif sys.platform == "darwin":
+        return Path.home() / "Library/Application Support/tooltray"
+    else:
+        xdg = os.environ.get("XDG_CONFIG_HOME")
+        if xdg:
+            return Path(xdg) / "tooltray"
+        return Path.home() / ".config/tooltray"
+
+
+def get_config_path() -> Path:
+    """Get path to config.json."""
+    return get_config_dir() / "config.json"
+
+
+def encode_config(token: str, repos: list[str], prefix: str = "TB") -> str:
+    """Encode token and repos into a shareable config code (v2 format).
+
+    Args:
+        token: GitHub PAT (ghp_xxx)
+        repos: List of "org/repo" strings
+        prefix: Code prefix for branding (default: "TB")
+
+    Returns:
+        Config code like "TB-eyJ0b2tlbi..."
+    """
+    data = {"token": token, "repos": repos}
+    b64 = base64.b64encode(json.dumps(data).encode()).decode()
+    return f"{prefix}-{b64}"
+
+
+def decode_config(code: str) -> dict:
+    """Decode config code back to token and repos.
+
+    Args:
+        code: Config code in format "PREFIX-base64data"
+
+    Returns:
+        Dict with "token" and "repos" keys
+
+    Raises:
+        ValueError: If code is invalid
+    """
+    if "-" not in code:
+        raise ValueError("Invalid config code: expected PREFIX-base64data format")
+
+    _, b64 = code.split("-", 1)
+    try:
+        data = json.loads(base64.b64decode(b64))
+    except Exception as e:
+        raise ValueError(f"Invalid config code: {e}") from e
+
+    if "token" not in data or "repos" not in data:
+        raise ValueError("Invalid config code: missing token or repos")
+
+    return data
+
+
+def load_config() -> dict | None:
+    """Load config from disk."""
+    from tool_tray.logging import log_debug, log_error
+
+    path = get_config_path()
+    if not path.exists():
+        log_debug(f"Config not found: {path}")
+        return None
+
+    try:
+        data = json.loads(path.read_text())
+        # Sanitize repo names (strip quotes that may have been included on Windows)
+        if "repos" in data:
+            from urllib.parse import unquote
+
+            data["repos"] = [unquote(r).strip().strip("'\"") for r in data["repos"]]
+        repos = data.get("repos", [])
+        log_debug(f"Config loaded: {len(repos)} repos")
+        return data
+    except (json.JSONDecodeError, OSError) as e:
+        log_error(f"Failed to load config: {path}", e)
+        return None
+
+
+def save_config(config: dict) -> None:
+    """Save config to disk."""
+    from tool_tray.logging import log_info
+
+    path = get_config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(config, indent=2))
+    repos = config.get("repos", [])
+    log_info(f"Config saved: {len(repos)} repos -> {path}")
+
+
+def config_exists() -> bool:
+    """Check if config file exists."""
+    return get_config_path().exists()

tool_tray/desktop.py

@@ -0,0 +1,103 @@
+import contextlib
+import io
+import os
+import sys
+from pathlib import Path
+
+from tool_tray.tray import get_tool_executable
+
+
+def get_desktop_path() -> Path:
+    """Get OS-appropriate desktop directory."""
+    if sys.platform == "win32":
+        desktop = os.environ.get("USERPROFILE", "")
+        return Path(desktop) / "Desktop" if desktop else Path.home() / "Desktop"
+    elif sys.platform == "darwin":
+        return Path.home() / "Desktop"
+    else:
+        # Linux: check XDG user dirs, fall back to ~/Desktop
+        xdg_desktop = os.environ.get("XDG_DESKTOP_DIR")
+        if xdg_desktop:
+            return Path(xdg_desktop)
+        return Path.home() / "Desktop"
+
+
+def get_desktop_icon_path(tool_name: str) -> Path:
+    """Compute where pyshortcuts creates the desktop icon."""
+    display_name = tool_name.replace("-", " ").title()
+
+    if sys.platform == "win32":
+        return get_desktop_path() / f"{display_name}.lnk"
+    elif sys.platform == "darwin":
+        return get_desktop_path() / f"{display_name}.app"
+    else:
+        # Linux: .desktop file
+        return get_desktop_path() / f"{display_name}.desktop"
+
+
+def remove_desktop_icon(tool_name: str) -> bool:
+    """Delete desktop icon from disk. Returns True if deleted."""
+    from tool_tray.logging import log_debug, log_error, log_info
+
+    path = get_desktop_icon_path(tool_name)
+    log_debug(f"Removing desktop icon: {path}")
+
+    if not path.exists():
+        log_debug(f"Desktop icon not found: {path}")
+        return False
+
+    try:
+        if path.is_dir():
+            # macOS .app bundles are directories
+            import shutil
+
+            shutil.rmtree(path)
+        else:
+            path.unlink()
+        log_info(f"Desktop icon removed: {path}")
+        return True
+    except OSError as e:
+        log_error(f"Failed to remove desktop icon: {path}", e)
+        return False
+
+
+def create_desktop_icon(
+    tool_name: str, icon_path: str | None = None, repo: str | None = None
+) -> bool:
+    """Create desktop shortcut for a uv tool."""
+    from tool_tray.logging import log_debug, log_error, log_info
+
+    log_debug(f"Creating desktop icon: {tool_name}")
+
+    from pyshortcuts import make_shortcut
+
+    exe = get_tool_executable(tool_name)
+    if not exe:
+        log_error(f"Tool not found for desktop icon: {tool_name}")
+        return False
+
+    try:
+        # Suppress stdout - pyshortcuts has debug prints on macOS
+        # noexe=True because uv tool shims are self-contained executables
+        with contextlib.redirect_stdout(io.StringIO()):
+            make_shortcut(
+                str(exe),
+                name=tool_name.replace("-", " ").title(),
+                icon=icon_path,
+                terminal=False,
+                desktop=True,
+                noexe=True,
+            )
+        log_info(f"Desktop icon created: {tool_name}")
+
+        # Record the icon in state if repo is provided
+        if repo:
+            from tool_tray.state import record_desktop_icon
+
+            icon_file = get_desktop_icon_path(tool_name)
+            record_desktop_icon(tool_name, str(icon_file), repo)
+
+        return True
+    except Exception as e:
+        log_error(f"Failed to create desktop icon: {tool_name}", e)
+        return False

tool_tray/logging.py

@@ -0,0 +1,76 @@
+import logging
+import os
+import sys
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+_logger: logging.Logger | None = None
+
+
+def get_log_dir() -> Path:
+    """Get OS-appropriate log directory."""
+    if sys.platform == "win32":
+        base = os.environ.get("LOCALAPPDATA")
+        if base:
+            return Path(base) / "tooltray/log"
+        return Path.home() / "AppData/Local/tooltray/log"
+    elif sys.platform == "darwin":
+        return Path.home() / "Library/Logs/tooltray"
+    else:
+        return Path.home() / ".local/state/tooltray/log"
+
+
+def get_logger() -> logging.Logger:
+    """Get or create the tooltray logger."""
+    global _logger
+    if _logger is not None:
+        return _logger
+
+    _logger = logging.getLogger("tooltray")
+    _logger.setLevel(logging.DEBUG)
+
+    # Avoid duplicate handlers
+    if _logger.handlers:
+        return _logger
+
+    # File handler with rotation (1MB, keep 3 files)
+    log_dir = get_log_dir()
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / "tooltray.log"
+
+    file_handler = RotatingFileHandler(
+        log_file,
+        maxBytes=1_000_000,
+        backupCount=3,
+        encoding="utf-8",
+    )
+    file_handler.setLevel(logging.DEBUG)
+
+    # Format: timestamp - level - message
+    formatter = logging.Formatter(
+        "%(asctime)s [%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    file_handler.setFormatter(formatter)
+    _logger.addHandler(file_handler)
+
+    return _logger
+
+
+def log_info(msg: str) -> None:
+    """Log info message."""
+    get_logger().info(msg)
+
+
+def log_error(msg: str, exc: Exception | None = None) -> None:
+    """Log error message with optional exception."""
+    logger = get_logger()
+    if exc:
+        logger.error(f"{msg}: {exc}", exc_info=True)
+    else:
+        logger.error(msg)
+
+
+def log_debug(msg: str) -> None:
+    """Log debug message."""
+    get_logger().debug(msg)

tool_tray/manifest.py

@@ -0,0 +1,61 @@
+import tomllib
+from dataclasses import dataclass
+
+import httpx
+
+
+@dataclass
+class Manifest:
+    """Tool manifest from tooltray.toml."""
+
+    name: str
+    type: str  # "uv" | "git"
+    launch: str | None = None
+    build: str | None = None
+    desktop_icon: bool = False
+    icon: str | None = None
+    autostart: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Manifest":
+        """Create Manifest from parsed TOML dict."""
+        return cls(
+            name=data["name"],
+            type=data["type"],
+            launch=data.get("launch"),
+            build=data.get("build"),
+            desktop_icon=data.get("desktop_icon", False),
+            icon=data.get("icon"),
+            autostart=data.get("autostart", False),
+        )
+
+
+def fetch_manifest(repo: str, token: str) -> Manifest | None:
+    """Fetch tooltray.toml from GitHub repo."""
+    from tool_tray.logging import log_debug, log_error
+
+    url = f"https://api.github.com/repos/{repo}/contents/tooltray.toml"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/vnd.github.raw+json",
+    }
+    log_debug(f"Fetching manifest: {repo}")
+    try:
+        resp = httpx.get(url, headers=headers, timeout=10)
+        if resp.status_code == 404:
+            log_debug(f"No manifest found: {repo}")
+            return None
+        resp.raise_for_status()
+        data = tomllib.loads(resp.text)
+        manifest = Manifest.from_dict(data)
+        log_debug(f"Manifest loaded: {repo} -> {manifest.name} ({manifest.type})")
+        return manifest
+    except httpx.HTTPError as e:
+        log_error(f"HTTP error fetching manifest: {repo}", e)
+        return None
+    except tomllib.TOMLDecodeError as e:
+        log_error(f"Invalid TOML in manifest: {repo}", e)
+        return None
+    except KeyError as e:
+        log_error(f"Missing required field in manifest: {repo}", e)
+        return None

tool_tray/setup_dialog.py

@@ -0,0 +1,83 @@
+import tkinter as tk
+from tkinter import ttk
+
+from tool_tray.config import decode_config, save_config
+
+
+def show_setup_dialog() -> bool:
+    """Show GUI setup dialog for pasting config code.
+
+    Returns:
+        True if config was saved successfully, False if cancelled
+    """
+    result = {"saved": False}
+
+    root = tk.Tk()
+    root.title("Tool Tray Setup")
+    root.resizable(False, False)
+
+    # Center window on screen
+    window_width = 400
+    window_height = 180
+    screen_width = root.winfo_screenwidth()
+    screen_height = root.winfo_screenheight()
+    x = (screen_width - window_width) // 2
+    y = (screen_height - window_height) // 2
+    root.geometry(f"{window_width}x{window_height}+{x}+{y}")
+
+    # Main frame with padding
+    frame = ttk.Frame(root, padding=20)
+    frame.pack(fill=tk.BOTH, expand=True)
+
+    # Label
+    label = ttk.Label(frame, text="Paste configuration code:")
+    label.pack(anchor=tk.W)
+
+    # Entry field
+    code_var = tk.StringVar()
+    entry = ttk.Entry(frame, textvariable=code_var, width=50)
+    entry.pack(fill=tk.X, pady=(5, 15))
+    entry.focus_set()
+
+    # Error label (hidden initially)
+    error_var = tk.StringVar()
+    error_label = ttk.Label(frame, textvariable=error_var, foreground="red")
+    error_label.pack(anchor=tk.W)
+
+    def on_ok(event: tk.Event | None = None) -> None:
+        code = code_var.get().strip()
+        if not code:
+            error_var.set("Please enter a configuration code")
+            return
+
+        try:
+            config = decode_config(code)
+            save_config(config)
+            result["saved"] = True
+            root.destroy()
+        except ValueError as e:
+            error_var.set(str(e))
+
+    def on_cancel() -> None:
+        root.destroy()
+
+    # Button frame
+    btn_frame = ttk.Frame(frame)
+    btn_frame.pack(fill=tk.X, pady=(10, 0))
+
+    cancel_btn = ttk.Button(btn_frame, text="Cancel", command=on_cancel)
+    cancel_btn.pack(side=tk.RIGHT, padx=(5, 0))
+
+    ok_btn = ttk.Button(btn_frame, text="OK", command=on_ok)
+    ok_btn.pack(side=tk.RIGHT)
+
+    # Bind Enter key to OK
+    root.bind("<Return>", on_ok)
+    root.bind("<Escape>", lambda e: on_cancel())
+
+    # Handle window close button
+    root.protocol("WM_DELETE_WINDOW", on_cancel)
+
+    root.mainloop()
+
+    return result["saved"]

tool_tray/state.py

@@ -0,0 +1,107 @@
+import json
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+
+from tool_tray.config import get_config_dir
+
+
+@dataclass
+class DesktopIconRecord:
+    """Record of a desktop icon we created."""
+
+    path: str
+    tool_name: str
+    created_at: str
+    repo: str
+
+
+@dataclass
+class State:
+    """Application state persisted to disk."""
+
+    version: int = 1
+    desktop_icons: dict[str, DesktopIconRecord] = field(default_factory=dict)
+
+
+def get_state_path() -> Path:
+    """Get path to state.json (same directory as config)."""
+    return get_config_dir() / "state.json"
+
+
+def load_state() -> State:
+    """Load state from disk, returning empty state if not found."""
+    from tool_tray.logging import log_debug, log_error
+
+    path = get_state_path()
+    if not path.exists():
+        log_debug(f"State not found: {path}")
+        return State()
+
+    try:
+        data = json.loads(path.read_text())
+        icons: dict[str, DesktopIconRecord] = {}
+        for key, record in data.get("desktop_icons", {}).items():
+            icons[key] = DesktopIconRecord(
+                path=record["path"],
+                tool_name=record["tool_name"],
+                created_at=record["created_at"],
+                repo=record["repo"],
+            )
+        log_debug(f"State loaded: {len(icons)} desktop icons")
+        return State(version=data.get("version", 1), desktop_icons=icons)
+    except (json.JSONDecodeError, OSError, KeyError) as e:
+        log_error(f"Failed to load state: {path}", e)
+        return State()
+
+
+def save_state(state: State) -> None:
+    """Save state to disk."""
+    from tool_tray.logging import log_debug
+
+    path = get_state_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    data = {
+        "version": state.version,
+        "desktop_icons": {
+            key: {
+                "path": record.path,
+                "tool_name": record.tool_name,
+                "created_at": record.created_at,
+                "repo": record.repo,
+            }
+            for key, record in state.desktop_icons.items()
+        },
+    }
+    path.write_text(json.dumps(data, indent=2))
+    log_debug(f"State saved: {len(state.desktop_icons)} desktop icons -> {path}")
+
+
+def record_desktop_icon(tool_name: str, path: str, repo: str) -> None:
+    """Record that we created a desktop icon."""
+    from tool_tray.logging import log_debug
+
+    state = load_state()
+    state.desktop_icons[tool_name] = DesktopIconRecord(
+        path=path,
+        tool_name=tool_name,
+        created_at=datetime.now().isoformat(),
+        repo=repo,
+    )
+    save_state(state)
+    log_debug(f"Recorded desktop icon: {tool_name} -> {path}")
+
+
+def remove_icon_record(tool_name: str) -> bool:
+    """Remove a desktop icon record. Returns True if record existed."""
+    from tool_tray.logging import log_debug
+
+    state = load_state()
+    if tool_name not in state.desktop_icons:
+        return False
+
+    del state.desktop_icons[tool_name]
+    save_state(state)
+    log_debug(f"Removed icon record: {tool_name}")
+    return True