claude-code-usage 1.0.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

src/icon_generator.py

@@ -1,55 +1,36 @@
 """
 Icon generation utilities for Claude Code usage overlay.
 
-Generates circular gauge icons using Cairo for system tray display.
+Generates circular gauge icons using Pillow for system tray display.
+Cross-platform: works on Windows, macOS, and Linux.
 """
-import cairo
-import math
-import os
-import tempfile
-from pathlib import Path
 from typing import Tuple
 
-# Secure temp directory for icons (created once, reused)
-_icon_temp_dir: str | None = None
+from PIL import Image, ImageDraw
 
 
-def _get_secure_icon_dir() -> str:
-    """Get or create a secure temporary directory for icon files.
-
-    Returns:
-        Path to secure temp directory with restricted permissions (0o700)
-    """
-    global _icon_temp_dir
-    if _icon_temp_dir is None or not Path(_icon_temp_dir).exists():
-        # Create secure temp directory owned by current user only
-        _icon_temp_dir = tempfile.mkdtemp(prefix="claude-usage-icons-")
-        os.chmod(_icon_temp_dir, 0o700)
-    return _icon_temp_dir
-
-
-def get_color_for_percentage(percentage: float) -> Tuple[float, float, float]:
+def get_color_for_percentage(percentage: float) -> Tuple[int, int, int, int]:
     """
-    Return RGB color tuple based on usage percentage.
+    Return RGBA color tuple based on usage percentage.
 
     Args:
         percentage: Usage percentage (0-100)
 
     Returns:
-        RGB tuple in Cairo format (0.0-1.0 range)
+        RGBA tuple in Pillow format (0-255 range)
         - Green for < 50%
         - Yellow for 50-75%
         - Red for >= 75%
     """
     if percentage < 50:
-        return (0.2, 0.8, 0.2)  # Green
+        return (51, 204, 51, 255)  # Green
     elif percentage < 75:
-        return (0.9, 0.7, 0.0)  # Yellow
+        return (230, 179, 0, 255)  # Yellow
     else:
-        return (0.9, 0.2, 0.2)  # Red
+        return (230, 51, 51, 255)  # Red
 
 
-def generate_gauge_icon(percentage: float, color_percentage: float, size: int = 22) -> str:
+def generate_gauge_icon(percentage: float, color_percentage: float, size: int = 22) -> Image.Image:
     """
     Generate a circular gauge icon showing usage percentage.
 
@@ -59,7 +40,7 @@ def generate_gauge_icon(percentage: float, color_percentage: float, size: int =
         size: Icon size in pixels (default: 22)
 
     Returns:
-        Absolute path to generated PNG file in /tmp
+        PIL.Image.Image object (RGBA mode) for use with pystray
 
     Notes:
         - percentage controls the arc fill amount (how full the gauge is)
@@ -68,6 +49,53 @@ def generate_gauge_icon(percentage: float, color_percentage: float, size: int =
     """
     # Get color based on color_percentage parameter
     fill_color = get_color_for_percentage(color_percentage)
+    gray_color = (128, 128, 128, 255)
+
+    # Create transparent RGBA image
+    image = Image.new('RGBA', (size, size), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(image)
+
+    # Calculate center and radius (leave 2px margin)
+    margin = 2
+    line_width = 2
+
+    # Bounding box for the arc (accounts for margin)
+    bbox = [margin, margin, size - margin - 1, size - margin - 1]
+
+    # Draw gray outline (full circle) as arc from 0 to 360
+    draw.arc(bbox, start=0, end=360, fill=gray_color, width=line_width)
+
+    # Draw colored fill arc (based on percentage)
+    if percentage > 0:
+        # Pillow arc: 0 degrees = 3 o'clock, angles go counter-clockwise
+        # We want: start at 12 o'clock (-90 degrees), go clockwise
+        # Pillow arc goes counter-clockwise, so we need to reverse direction
+        # Start at -90 (12 o'clock), end at -90 + percentage*3.6
+        start_angle = -90
+        end_angle = -90 + (360 * percentage / 100)
+        draw.arc(bbox, start=start_angle, end=end_angle, fill=fill_color, width=line_width)
+
+    return image
+
+
+def generate_gauge_icon_path(percentage: float, color_percentage: float, size: int = 22) -> str:
+    """
+    Generate a circular gauge icon and save to temp file.
+
+    This function is for backwards compatibility with code that needs file paths.
+    Prefer using generate_gauge_icon() directly with pystray.
+
+    Args:
+        percentage: Usage level to display as arc fill (0-100)
+        color_percentage: Percentage used to determine color (0-100)
+        size: Icon size in pixels (default: 22)
+
+    Returns:
+        Absolute path to generated PNG file in temp directory
+    """
+    import os
+    import tempfile
+    from pathlib import Path
 
     # Determine color name for filename (to bust icon cache)
     if color_percentage < 50:
@@ -77,36 +105,16 @@ def generate_gauge_icon(percentage: float, color_percentage: float, size: int =
     else:
         color_name = "red"
 
-    # Create Cairo surface with transparent background
-    surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, size, size)
-    ctx = cairo.Context(surface)
+    # Get or create temp directory
+    temp_dir = tempfile.gettempdir()
+    icon_dir = os.path.join(temp_dir, "claude-usage-icons")
+    os.makedirs(icon_dir, exist_ok=True)
 
-    # Clear background (transparent)
-    ctx.set_source_rgba(0, 0, 0, 0)
-    ctx.paint()
-
-    # Calculate center and radius (leave 2px margin)
-    center = size / 2
-    radius = (size / 2) - 2
+    # Generate icon
+    image = generate_gauge_icon(percentage, color_percentage, size)
 
-    # Draw gray outline (full circle)
-    ctx.set_source_rgb(0.5, 0.5, 0.5)
-    ctx.set_line_width(2)
-    ctx.arc(center, center, radius, 0, 2 * math.pi)
-    ctx.stroke()
-
-    # Draw colored fill arc (based on percentage)
-    if percentage > 0:
-        ctx.set_source_rgb(*fill_color)
-        ctx.set_line_width(2)
-        # Start at 12 o'clock (-pi/2), go clockwise by percentage amount
-        end_angle = -math.pi / 2 + (2 * math.pi * percentage / 100)
-        ctx.arc(center, center, radius, -math.pi / 2, end_angle)
-        ctx.stroke()
-
-    # Save to secure temp directory with unique filename (bust GTK icon cache)
-    icon_dir = _get_secure_icon_dir()
+    # Save to file
     icon_path = os.path.join(icon_dir, f"gauge-{int(percentage)}-{color_name}.png")
-    surface.write_to_png(icon_path)
+    image.save(icon_path, 'PNG')
 
     return os.path.abspath(icon_path)

src/notifier.py

@@ -1,12 +1,15 @@
-"""Desktop notification manager for usage threshold alerts."""
+"""Desktop notification manager for usage threshold alerts.
 
-import subprocess
-import time
+Cross-platform: uses desktop-notifier for Windows, macOS, and Linux.
+"""
 
-import gi
+import asyncio
+import sys
+import time
+import webbrowser
+from typing import Optional
 
-gi.require_version('Notify', '0.7')
-from gi.repository import Notify
+from desktop_notifier import DesktopNotifier, Urgency, Button
 
 
 class UsageNotifier:
@@ -26,8 +29,11 @@ class UsageNotifier:
             session_thresholds: List of threshold percentages for session (default [50, 75, 90])
             weekly_thresholds: List of threshold percentages for weekly (default to session_thresholds)
         """
-        # Initialize libnotify once
-        Notify.init(app_name)
+        # Initialize desktop-notifier
+        self.notifier = DesktopNotifier(
+            app_name=app_name,
+            notification_limit=10
+        )
 
         # Configure thresholds
         self.session_thresholds = session_thresholds if session_thresholds is not None else [50, 75, 90]
@@ -44,8 +50,36 @@ class UsageNotifier:
         # Pause notifications mode
         self.pause_notifications = False
 
-        # Cache server capabilities
-        self._actions_supported = None
+        # Event loop for async operations
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+
+    def _get_event_loop(self) -> asyncio.AbstractEventLoop:
+        """Get or create event loop for async operations."""
+        if self._loop is None or self._loop.is_closed():
+            try:
+                self._loop = asyncio.get_running_loop()
+            except RuntimeError:
+                # No running loop, create new one
+                self._loop = asyncio.new_event_loop()
+        return self._loop
+
+    def _run_async(self, coro):
+        """Run async coroutine synchronously."""
+        loop = self._get_event_loop()
+        try:
+            # Try to run in existing loop
+            if loop.is_running():
+                # Schedule in running loop (won't block)
+                asyncio.ensure_future(coro, loop=loop)
+            else:
+                loop.run_until_complete(coro)
+        except RuntimeError:
+            # Fallback: create new loop
+            new_loop = asyncio.new_event_loop()
+            try:
+                new_loop.run_until_complete(coro)
+            finally:
+                new_loop.close()
 
     def check_and_notify(self, session_pct, weekly_pct, session_reset, weekly_reset):
         """Check thresholds and show notifications if needed.
@@ -126,6 +160,22 @@ class UsageNotifier:
         crossed = [t for t in thresholds if percentage >= t]
         return max(crossed) if crossed else None
 
+    def _get_urgency(self, threshold: int) -> Urgency:
+        """Map threshold to desktop-notifier Urgency level.
+
+        Args:
+            threshold: Threshold percentage (50, 75, or 90)
+
+        Returns:
+            Urgency enum value
+        """
+        if threshold >= 90:
+            return Urgency.Critical
+        elif threshold >= 75:
+            return Urgency.Normal
+        else:
+            return Urgency.Low
+
     def _show_notification(self, metric, percentage, threshold, reset_time):
         """Show notification for single metric threshold.
 
@@ -137,12 +187,13 @@ class UsageNotifier:
         """
         # Map threshold to urgency and advice
         urgency_map = {
-            50: (Notify.Urgency.LOW, "Heads up"),
-            75: (Notify.Urgency.NORMAL, "Consider saving your work"),
-            90: (Notify.Urgency.CRITICAL, "Save your work now")
+            50: "Heads up",
+            75: "Consider saving your work",
+            90: "Save your work now"
         }
 
-        urgency, advice = urgency_map[threshold]
+        advice = urgency_map[threshold]
+        urgency = self._get_urgency(threshold)
 
         # Format title
         metric_name = "Session Usage" if metric == 'session' else "Weekly Usage"
@@ -152,27 +203,8 @@ class UsageNotifier:
         reset_str = self._format_reset_time(reset_time)
         body = f"{advice}\n\nResets in {reset_str}"
 
-        # Create notification
-        notification = Notify.Notification.new(
-            title,
-            body,
-            "dialog-information"
-        )
-
-        # Set urgency level
-        notification.set_urgency(urgency)
-
-        # Add action button if server supports it
-        if self._server_supports_actions():
-            notification.add_action(
-                "open-claude",
-                "Open Claude Code",
-                self._on_open_claude,
-                None
-            )
-
-        # Show notification
-        notification.show()
+        # Show notification asynchronously
+        self._run_async(self._send_notification(title, body, urgency))
 
     def _show_combined_notification(self, threshold, session_pct, weekly_pct,
                                     session_reset, weekly_reset):
@@ -187,12 +219,13 @@ class UsageNotifier:
         """
         # Map threshold to urgency and advice
         urgency_map = {
-            50: (Notify.Urgency.LOW, "Heads up"),
-            75: (Notify.Urgency.NORMAL, "Consider saving your work"),
-            90: (Notify.Urgency.CRITICAL, "Save your work now")
+            50: "Heads up",
+            75: "Consider saving your work",
+            90: "Save your work now"
         }
 
-        urgency, advice = urgency_map[threshold]
+        advice = urgency_map[threshold]
+        urgency = self._get_urgency(threshold)
 
         # Format title (show threshold, not individual percentages)
         title = f"Session & Weekly Usage: {threshold}%"
@@ -204,27 +237,32 @@ class UsageNotifier:
                 f"Session resets in {session_reset_str}\n"
                 f"Weekly resets in {weekly_reset_str}")
 
-        # Create notification
-        notification = Notify.Notification.new(
-            title,
-            body,
-            "dialog-information"
-        )
+        # Show notification asynchronously
+        self._run_async(self._send_notification(title, body, urgency))
 
-        # Set urgency level
-        notification.set_urgency(urgency)
+    async def _send_notification(self, title: str, body: str, urgency: Urgency):
+        """Send notification via desktop-notifier.
 
-        # Add action button if server supports it
-        if self._server_supports_actions():
-            notification.add_action(
-                "open-claude",
-                "Open Claude Code",
-                self._on_open_claude,
-                None
+        Args:
+            title: Notification title
+            body: Notification body text
+            urgency: Urgency level
+        """
+        try:
+            await self.notifier.send(
+                title=title,
+                message=body,
+                urgency=urgency,
+                buttons=[
+                    Button(
+                        title="Open Claude",
+                        on_pressed=lambda: webbrowser.open("https://claude.ai")
+                    )
+                ]
             )
-
-        # Show notification
-        notification.show()
+        except Exception as e:
+            # Log but don't crash on notification failure
+            print(f"Notification error: {e}", file=sys.stderr)
 
     def _format_reset_time(self, reset_timestamp):
         """Format Unix timestamp to human-readable time until reset.
@@ -253,31 +291,6 @@ class UsageNotifier:
             minutes = remainder // 60
             return f"{minutes}m" if minutes > 0 else "shortly"
 
-    def _server_supports_actions(self):
-        """Check if notification server supports action buttons.
-
-        Returns:
-            bool: True if server supports actions, False otherwise
-        """
-        if self._actions_supported is None:
-            caps = Notify.get_server_caps()
-            self._actions_supported = caps and 'actions' in caps
-        return self._actions_supported
-
-    def _on_open_claude(self, notification, action, user_data):
-        """Callback when 'Open Claude Code' button is clicked.
-
-        Args:
-            notification: The notification that triggered the action
-            action: Action identifier string
-            user_data: User data passed to add_action (unused)
-        """
-        # Close the notification
-        notification.close()
-
-        # Open Claude Code in browser
-        subprocess.Popen(["/usr/bin/xdg-open", "https://claude.ai"])
-
     def set_thresholds(self, session_thresholds, weekly_thresholds=None):
         """Update threshold configuration.