dulus-bar 0.3.0__py3-none-any.whl

dulus_bar/__init__.py

@@ -0,0 +1,6 @@
+"""Dulus Bar — a cross-platform Dynamic Island for your AI agents.
+
+Free, native, no subscription. Windows / macOS (notch-aware) / Linux.
+"""
+
+__version__ = "0.2.0"

dulus_bar/__main__.py

@@ -0,0 +1,6 @@
+"""python -m dulus_bar"""
+
+from .main import main
+
+if __name__ == "__main__":
+    main()

dulus_bar/agents.py

@@ -0,0 +1,111 @@
+"""Agent catalog — per-agent identity (icon + accent color) for any AI CLI.
+
+Dulus Bar is agent-agnostic: it will happily show *any* agent name a wrapper
+reports. This module just gives the well-known ones a recognizable emoji and
+accent color, and hands unknown agents a stable, nicely-distributed color so
+the UI still looks intentional. It is presentation-only.
+"""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from typing import Dict, List, Tuple
+
+
+@dataclass(frozen=True)
+class AgentStyle:
+    key: str
+    display: str
+    emoji: str
+    accent: str  # hex
+    aliases: tuple = ()
+
+
+# Curated identities. `accent` roughly follows each brand.
+_AGENTS: List[AgentStyle] = [
+    AgentStyle("dulus", "Dulus", "🦅", "#f59e0b", ("dulus", "interant")),
+    AgentStyle("claude", "Claude Code", "✳️", "#d97757", ("claude", "claude code", "anthropic")),
+    AgentStyle("codex", "Codex", "◆", "#10a37f", ("codex", "openai", "gpt")),
+    AgentStyle("gemini", "Gemini", "✦", "#4285f4", ("gemini", "google")),
+    AgentStyle("cursor", "Cursor", "▸", "#7c3aed", ("cursor",)),
+    AgentStyle("copilot", "Copilot", "⧉", "#6e7681", ("copilot", "github copilot")),
+    AgentStyle("kimi", "Kimi", "◐", "#2563eb", ("kimi", "moonshot")),
+    AgentStyle("deepseek", "DeepSeek", "≋", "#4d6bfe", ("deepseek",)),
+    AgentStyle("grok", "Grok", "𝕏", "#111827", ("grok", "xai")),
+    AgentStyle("qwen", "Qwen", "✺", "#615ced", ("qwen", "alibaba", "tongyi")),
+    AgentStyle("mistral", "Mistral", "◢", "#fa5010", ("mistral", "codestral")),
+    AgentStyle("windsurf", "Windsurf", "≈", "#09b6a2", ("windsurf", "codeium")),
+    AgentStyle("zed", "Zed", "⚡", "#084ccf", ("zed",)),
+    AgentStyle("aider", "Aider", "✎", "#22c55e", ("aider",)),
+    AgentStyle("cline", "Cline", "◔", "#0ea5e9", ("cline", "roo")),
+    AgentStyle("ollama", "Ollama", "◍", "#000000", ("ollama", "llama")),
+]
+
+_BY_ALIAS: Dict[str, AgentStyle] = {}
+for _a in _AGENTS:
+    _BY_ALIAS[_a.key] = _a
+    for _al in _a.aliases:
+        _BY_ALIAS[_al] = _a
+
+# Fallback palette for unknown agents (kept colorblind-distinct-ish).
+_FALLBACK_PALETTE = (
+    "#38bdf8",
+    "#a78bfa",
+    "#34d399",
+    "#fbbf24",
+    "#fb7185",
+    "#e879f9",
+    "#5eead4",
+    "#93c5fd",
+)
+
+
+def style_for(agent_name: str) -> AgentStyle:
+    """Return an AgentStyle for any agent name (never raises)."""
+    name = (agent_name or "").strip()
+    low = name.lower()
+    if low in _BY_ALIAS:
+        return _BY_ALIAS[low]
+    for alias, style in _BY_ALIAS.items():
+        if alias in low:
+            return style
+    # Deterministic fallback color from the name.
+    idx = sum(ord(c) for c in low) % len(_FALLBACK_PALETTE) if low else 0
+    return AgentStyle(
+        key=low or "agent",
+        display=name or "Agent",
+        emoji="●",
+        accent=_FALLBACK_PALETTE[idx],
+    )
+
+
+def is_dulus(agent_name: str) -> bool:
+    return style_for(agent_name).key == "dulus"
+
+
+# CLI executable names for known agents, used by "quick launch" in the UI.
+# The first name found on PATH wins.
+_LAUNCH_COMMANDS: Dict[str, Tuple[str, ...]] = {
+    "claude": ("claude",),
+    "codex": ("codex",),
+    "gemini": ("gemini",),
+    "cursor": ("cursor-agent", "cursor"),
+    "aider": ("aider",),
+    "qwen": ("qwen",),
+    "grok": ("grok",),
+    "copilot": ("copilot",),
+    "opencode": ("opencode",),
+}
+
+
+def detect_installed() -> List[Tuple[AgentStyle, str]]:
+    """Return (style, resolved_executable) for known agents found on PATH."""
+    found: List[Tuple[AgentStyle, str]] = []
+    for key, exe_names in _LAUNCH_COMMANDS.items():
+        for exe in exe_names:
+            path = shutil.which(exe)
+            if path:
+                found.append((_BY_ALIAS[key], path))
+                break
+    return found

dulus_bar/macos_native.py

@@ -0,0 +1,118 @@
+"""Lifecycle bridge for the native SwiftUI/AppKit notch surface on macOS."""
+
+from __future__ import annotations
+
+import atexit
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from .server import AgentEventServer
+
+WS_PORT = 17372
+_NATIVE_EXECUTABLE = "DulusBarNative"
+
+
+def project_root() -> Path:
+    return Path(__file__).resolve().parent.parent
+
+
+def native_binary(root: Optional[Path] = None) -> Path:
+    """Return the preferred release helper path."""
+    base = root or project_root()
+    override = os.environ.get("DULUS_BAR_NATIVE_BINARY")
+    if override:
+        return Path(override).expanduser().resolve()
+    return base / "macos" / ".build" / "release" / _NATIVE_EXECUTABLE
+
+
+def native_available(root: Optional[Path] = None) -> bool:
+    path = native_binary(root)
+    return path.is_file() and os.access(path, os.X_OK)
+
+
+def build_native(root: Optional[Path] = None) -> Path:
+    """Build the native helper and return its executable path."""
+    base = root or project_root()
+    package = base / "macos"
+    if not (package / "Package.swift").is_file():
+        raise FileNotFoundError(f"native package missing: {package}")
+    subprocess.run(
+        ["swift", "build", "-c", "release"],
+        cwd=package,
+        check=True,
+    )
+    binary = native_binary(base)
+    if not binary.is_file():
+        raise FileNotFoundError(f"native build completed without {binary}")
+    return binary
+
+
+def _terminate(process: subprocess.Popen) -> None:
+    if process.poll() is not None:
+        return
+    process.terminate()
+    try:
+        process.wait(timeout=3)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait(timeout=2)
+
+
+def run_native() -> int:
+    """Own the WebSocket hub and run the native helper until it exits."""
+    binary = native_binary()
+    if not native_available():
+        if os.environ.get("DULUS_BAR_NATIVE_AUTOBUILD", "1") == "0":
+            raise FileNotFoundError(f"native helper not built: {binary}")
+        print("[dulusbar] native helper missing; building release binary...")
+        binary = build_native()
+
+    server = AgentEventServer(port=WS_PORT)
+    server.start()
+    process = subprocess.Popen(
+        [str(binary), "--websocket", f"ws://127.0.0.1:{WS_PORT}"],
+        cwd=project_root(),
+        env={**os.environ, "DULUS_BAR_PARENT_PID": str(os.getpid())},
+    )
+
+    cleaned = False
+
+    def cleanup() -> None:
+        nonlocal cleaned
+        if cleaned:
+            return
+        cleaned = True
+        _terminate(process)
+        server.stop()
+
+    def handle_signal(signum: int, _frame: object) -> None:
+        cleanup()
+        raise SystemExit(128 + signum)
+
+    atexit.register(cleanup)
+    previous_handlers = {}
+    for signum in (signal.SIGINT, signal.SIGTERM):
+        previous_handlers[signum] = signal.getsignal(signum)
+        signal.signal(signum, handle_signal)
+
+    try:
+        while True:
+            code = process.poll()
+            if code is not None:
+                return code
+            time.sleep(0.25)
+    finally:
+        cleanup()
+        for signum, handler in previous_handlers.items():
+            signal.signal(signum, handler)
+
+
+def should_use_native() -> bool:
+    if sys.platform != "darwin":
+        return False
+    return os.environ.get("DULUS_BAR_FORCE_QT", "0").lower() not in {"1", "true", "yes"}

dulus_bar/main.py

@@ -0,0 +1,42 @@
+"""Entry point for Dulus Bar.
+
+Supports both:
+  python -m dulus_bar
+  python dulus_bar/main.py
+"""
+
+import os
+import sys
+
+
+def main():
+    try:
+        from dulus_bar.macos_native import run_native, should_use_native
+
+        if should_use_native():
+            try:
+                raise SystemExit(run_native())
+            except Exception as exc:
+                if os.environ.get("DULUS_BAR_NATIVE_REQUIRED", "0") in {"1", "true", "yes"}:
+                    raise
+                print(
+                    f"[dulusbar] native macOS surface unavailable ({exc}); using Qt fallback",
+                    file=sys.stderr,
+                )
+
+        from dulus_bar.overlay import run_overlay
+
+        run_overlay()
+    except SystemExit:
+        raise
+    except Exception as exc:
+        print(f"Dulus Bar crashed: {exc}", file=sys.stderr)
+        raise
+
+
+if __name__ == "__main__":
+    if __package__ is None:
+        # Running directly (python dulus_bar/main.py): add project root to path.
+        project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        sys.path.insert(0, project_root)
+    main()

dulus_bar/native/__init__.py

@@ -0,0 +1,99 @@
+"""Cross-platform native integration layer for Dulus Bar.
+
+Exposes a single OS-appropriate backend so the rest of the app never has to
+know whether it is running on Windows, macOS or Linux. Each backend knows how
+to:
+
+  * find and focus terminal / editor windows (jump-to-terminal)
+  * report the camera-notch geometry (macOS) so the island can hug it
+  * keep the overlay always-visible across Spaces / full-screen (macOS)
+  * pick a native-looking default UI font
+
+Importing this package is always safe: the heavy, OS-specific imports live
+inside each backend module and are guarded, so `import dulus_bar.native` works
+on any platform even if the native deps are missing.
+"""
+
+from __future__ import annotations
+
+import sys
+from functools import lru_cache
+from typing import List, Optional
+
+from .base import NativeBackend, NotchGeometry, WindowInfo
+
+__all__ = [
+    "NativeBackend",
+    "NotchGeometry",
+    "WindowInfo",
+    "get_backend",
+    "activate_window",
+    "find_window_by_title",
+    "jump_to_terminal",
+    "open_terminal",
+    "open_terminal_running",
+    "notch_geometry",
+    "configure_always_visible",
+    "default_font_family",
+]
+
+
+@lru_cache(maxsize=1)
+def get_backend() -> NativeBackend:
+    """Return the singleton backend for the current OS (never raises)."""
+    platform = sys.platform
+    try:
+        if platform.startswith("win"):
+            from .windows import WindowsBackend
+
+            return WindowsBackend()
+        if platform == "darwin":
+            from .macos import MacOSBackend
+
+            return MacOSBackend()
+        if platform.startswith("linux"):
+            from .linux import LinuxBackend
+
+            return LinuxBackend()
+    except Exception as exc:  # pragma: no cover - defensive
+        print(f"[native] backend init failed ({platform}): {exc}; using no-op backend")
+    return NativeBackend()
+
+
+# --- thin module-level convenience wrappers -------------------------------
+
+
+def activate_window(handle: object) -> bool:
+    return get_backend().activate_window(handle)
+
+
+def find_window_by_title(title_substring: str) -> Optional[WindowInfo]:
+    return get_backend().find_window_by_title(title_substring)
+
+
+def jump_to_terminal(title_hint: str = "") -> bool:
+    return get_backend().jump_to_terminal(title_hint)
+
+
+def open_terminal() -> bool:
+    return get_backend().open_terminal()
+
+
+def open_terminal_running(command, title: str = "", cwd: Optional[str] = None) -> bool:
+    return get_backend().open_terminal_running(command, title=title, cwd=cwd)
+
+
+def notch_geometry() -> Optional[NotchGeometry]:
+    return get_backend().notch_geometry()
+
+
+def configure_always_visible(win: object) -> None:
+    get_backend().configure_always_visible(win)
+
+
+def default_font_family() -> str:
+    return get_backend().default_font_family()
+
+
+def list_windows() -> List[WindowInfo]:
+    return get_backend().list_windows()

dulus_bar/native/base.py

@@ -0,0 +1,130 @@
+"""Backend interface + safe no-op fallback shared by every platform."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class WindowInfo:
+    """Lightweight, platform-agnostic descriptor of a top-level window."""
+
+    handle: object  # hwnd (win), window id (x11), or app pid/name (mac)
+    title: str
+    pid: int = 0
+    process_name: str = ""
+
+    def __repr__(self) -> str:
+        return f"WindowInfo({self.process_name or '?'}: {self.title!r})"
+
+
+@dataclass
+class NotchGeometry:
+    """Camera-notch rectangle in global screen pixels (macOS)."""
+
+    x: int
+    y: int
+    width: int
+    height: int
+    screen_width: int
+    screen_height: int
+
+
+# Terminal / editor process or title fragments we consider "jumpable".
+TERMINAL_HINTS = (
+    "windows terminal",
+    "powershell",
+    "pwsh",
+    "cmd.exe",
+    "conhost",
+    "wt.exe",
+    "alacritty",
+    "wezterm",
+    "kitty",
+    "tabby",
+    "hyper",
+    "conemu",
+    "cmder",
+    "iterm",
+    "terminal",
+    "gnome-terminal",
+    "konsole",
+    "xterm",
+    "warp",
+    "ghostty",
+    "cursor",
+    "visual studio code",
+    "code.exe",
+    "code",
+    "zed",
+    "windsurf",
+)
+
+
+class NativeBackend:
+    """Default backend: everything is a safe no-op.
+
+    Real platforms subclass this and override what they can do. Anything a
+    platform cannot do falls back to these no-ops instead of crashing.
+    """
+
+    name = "noop"
+
+    # --- window discovery / focus ---------------------------------------
+    def list_windows(self, only_visible: bool = True) -> List[WindowInfo]:
+        return []
+
+    def find_window_by_title(self, title_substring: str) -> Optional[WindowInfo]:
+        needle = title_substring.lower().strip()
+        if not needle:
+            return None
+        for w in self.list_windows():
+            if needle in w.title.lower():
+                return w
+        return None
+
+    def find_terminal_windows(self) -> List[WindowInfo]:
+        out: List[WindowInfo] = []
+        for w in self.list_windows():
+            haystack = f"{w.title} {w.process_name}".lower()
+            if any(h in haystack for h in TERMINAL_HINTS):
+                out.append(w)
+        return out
+
+    def activate_window(self, handle: object) -> bool:
+        return False
+
+    def jump_to_terminal(self, title_hint: str = "") -> bool:
+        if title_hint:
+            w = self.find_window_by_title(title_hint)
+            if w and self.activate_window(w.handle):
+                return True
+        for w in self.find_terminal_windows():
+            if self.activate_window(w.handle):
+                return True
+        return False
+
+    def open_terminal(self) -> bool:
+        return False
+
+    def open_terminal_running(self, command, title="", cwd=None) -> bool:
+        """Open a NEW interactive terminal window running ``command``.
+
+        ``command`` is an argv list. The agent gets a real console it can read
+        stdin from, which is what lets the wrapper pipe approvals. Returns False
+        if the platform can't spawn a terminal.
+        """
+        return False
+
+    # --- overlay placement / behavior -----------------------------------
+    def notch_geometry(self) -> Optional[NotchGeometry]:
+        """Return the camera-notch rect, or None when the display has none."""
+        return None
+
+    def configure_always_visible(self, win: object) -> None:
+        """Keep the overlay above the menu bar / on every Space (macOS)."""
+        return None
+
+    def default_font_family(self) -> str:
+        return "sans-serif"

dulus_bar/native/linux.py

@@ -0,0 +1,103 @@
+"""Linux (X11) native backend using wmctrl / xdotool when available.
+
+Wayland exposes no portable window-activation API, so on Wayland the overlay
+still shows and stays on top (handled by Qt) but jump-to-terminal degrades to a
+best-effort no-op. X11 with wmctrl or xdotool installed gets full behavior.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from typing import List, Optional
+
+from .base import NativeBackend, WindowInfo
+
+
+class LinuxBackend(NativeBackend):
+    name = "linux"
+
+    def __init__(self) -> None:
+        self._wmctrl = shutil.which("wmctrl")
+        self._xdotool = shutil.which("xdotool")
+
+    def list_windows(self, only_visible: bool = True) -> List[WindowInfo]:
+        if not self._wmctrl:
+            return []
+        try:
+            out = subprocess.run(
+                [self._wmctrl, "-lp"], capture_output=True, text=True, timeout=2
+            ).stdout
+        except Exception:
+            return []
+        results: List[WindowInfo] = []
+        for line in out.splitlines():
+            # id  desktop  pid  host  title...
+            parts = line.split(None, 4)
+            if len(parts) < 5:
+                continue
+            win_id, _desktop, pid_s, _host, title = parts
+            try:
+                pid = int(pid_s)
+            except ValueError:
+                pid = 0
+            results.append(WindowInfo(handle=win_id, title=title, pid=pid, process_name=_proc_name(pid)))
+        return results
+
+    def activate_window(self, handle: object) -> bool:
+        win_id = str(handle)
+        if self._wmctrl:
+            try:
+                r = subprocess.run([self._wmctrl, "-ia", win_id], capture_output=True, timeout=2)
+                if r.returncode == 0:
+                    return True
+            except Exception:
+                pass
+        if self._xdotool:
+            try:
+                r = subprocess.run([self._xdotool, "windowactivate", win_id], capture_output=True, timeout=2)
+                return r.returncode == 0
+            except Exception:
+                return False
+        return False
+
+    def open_terminal(self) -> bool:
+        for exe in ("x-terminal-emulator", "gnome-terminal", "konsole", "alacritty", "xterm"):
+            path = shutil.which(exe)
+            if path:
+                try:
+                    subprocess.Popen([path])
+                    return True
+                except Exception:
+                    continue
+        return False
+
+    def open_terminal_running(self, command, title="", cwd=None) -> bool:
+        import shlex
+
+        inner = " ".join(shlex.quote(str(c)) for c in command)
+        # keep the shell open after the agent exits so the user sees output
+        bash_cmd = f"{inner}; exec bash"
+        for exe in ("x-terminal-emulator", "gnome-terminal", "konsole", "alacritty", "xterm", "kitty"):
+            path = shutil.which(exe)
+            if not path:
+                continue
+            try:
+                subprocess.Popen([path, "-e", "bash", "-c", bash_cmd], cwd=cwd)
+                return True
+            except Exception:
+                continue
+        return False
+
+    def default_font_family(self) -> str:
+        return "Noto Sans"
+
+
+def _proc_name(pid: int) -> str:
+    if not pid:
+        return ""
+    try:
+        with open(f"/proc/{pid}/comm", "r", encoding="utf-8", errors="replace") as fh:
+            return fh.read().strip().lower()
+    except Exception:
+        return ""