dulus 0.2.0__py3-none-any.whl

clipboard_utils.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+import importlib
+import io
+import os
+import shutil
+import subprocess
+import sys
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, cast
+
+import pyperclip
+from PIL import Image, ImageGrab
+
+# Video file extensions recognized for clipboard paste.
+_VIDEO_SUFFIXES: frozenset[str] = frozenset(
+    {".mp4", ".mkv", ".avi", ".mov", ".wmv", ".webm", ".m4v", ".flv", ".3gp", ".3g2"}
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ClipboardResult:
+    """Result of reading media from the clipboard.
+
+    Both fields may be non-empty when the clipboard contains a mix of
+    image files and non-image files (videos, PDFs, etc.).
+    """
+
+    images: tuple[Image.Image, ...]
+    file_paths: tuple[Path, ...]
+
+
+def is_clipboard_available() -> bool:
+    """Check if the Pyperclip text clipboard is available."""
+    try:
+        pyperclip.paste()
+        return True
+    except Exception:
+        return False
+
+
+def is_media_clipboard_available() -> bool:
+    """Check if the media clipboard (xclip/wl-paste) is available.
+
+    On headless Linux (e.g. SSH remote), pyperclip may fail because
+    DISPLAY is not set, but images can still be read through xclip or
+    wl-paste (e.g. via clipboard bridging tools like cc-clip that shim
+    xclip over an SSH tunnel).
+    """
+    if sys.platform == "linux":
+        return shutil.which("xclip") is not None or shutil.which("wl-paste") is not None
+    # macOS and Windows use native APIs that do not require external tools.
+    return True
+
+
+def grab_media_from_clipboard() -> ClipboardResult | None:
+    """Read media from the clipboard.
+
+    Inspects the clipboard once and returns all detected media.
+    Image files are returned as loaded PIL images; non-image files
+    (videos, PDFs, etc.) are returned as file paths.
+
+    On macOS the native pasteboard API is tried first to avoid
+    misidentifying a file's thumbnail as clipboard image data.
+    """
+    # 1. Try macOS native API for file paths (most reliable for Finder copies).
+    if sys.platform == "darwin":
+        file_paths = _read_clipboard_file_paths_macos_native()
+        images, non_image_paths = _classify_file_paths(file_paths)
+        if images or non_image_paths:
+            return ClipboardResult(
+                images=tuple(images),
+                file_paths=tuple(non_image_paths),
+            )
+
+    # 2. On Linux, use explicit xclip/wl-paste fallback instead of Pillow's
+    #    opaque internal selection, which may pick a broken tool first.
+    if sys.platform == "linux":
+        image = _grab_image_linux()
+        if image is not None:
+            return ClipboardResult(images=(image,), file_paths=())
+        return None
+
+    # 3. On Windows and other platforms, use Pillow's default implementation.
+    payload = ImageGrab.grabclipboard()
+    if payload is None:
+        return None
+    if isinstance(payload, Image.Image):
+        # Raw image data (screenshot or thumbnail).
+        # If we reach here, the macOS native path lookup did not find any
+        # file paths, so this is safe to treat as a real image.
+        return ClipboardResult(images=(payload,), file_paths=())
+    # payload is a list of file path strings.
+    images, non_image_paths = _classify_file_paths(payload)
+    if images or non_image_paths:
+        return ClipboardResult(
+            images=tuple(images),
+            file_paths=tuple(non_image_paths),
+        )
+    return None
+
+
+def _grab_image_linux() -> Image.Image | None:
+    """Read image from Linux clipboard with session-aware tool fallback.
+
+    Tries the backend matching the current session type first to avoid
+    reading stale data from the wrong clipboard (e.g. XWayland vs
+    Wayland). On headless systems with no session type, xclip is tried
+    first since clipboard bridges (e.g. cc-clip) typically shim xclip.
+    """
+    xclip_args = ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"]
+    wlpaste_args = ["wl-paste", "-t", "image"]
+
+    if os.getenv("WAYLAND_DISPLAY"):
+        candidates = (wlpaste_args, xclip_args)
+    elif os.getenv("DISPLAY"):
+        candidates = (xclip_args, wlpaste_args)
+    else:  # headless — xclip first for common clipboard bridges
+        candidates = (xclip_args, wlpaste_args)
+
+    for idx, args in enumerate(candidates):
+        if shutil.which(args[0]) is None:
+            continue
+        try:
+            p = subprocess.run(args, capture_output=True, timeout=3)
+        except subprocess.TimeoutExpired:
+            continue
+        if p.returncode == 0 and p.stdout:
+            data = io.BytesIO(p.stdout)
+            try:
+                im = Image.open(data)
+                im.load()
+                return im
+            except Exception:
+                continue
+        # Silent errors mean clipboard is empty or has no image.
+        err = p.stderr
+        silent_errors = [
+            b"Nothing is copied",
+            b"No selection",
+            b"No suitable type of content copied",
+            b" not available",
+            b"cannot convert ",
+            b"no owner for the ",
+        ]
+        if any(se in err for se in silent_errors):
+            # Trust the session-native tool: if it says "no image", don't
+            # fall back to a different clipboard namespace (e.g. XWayland
+            # vs Wayland) which may contain stale unrelated data.
+            if idx == 0:
+                return None
+            continue
+        # Otherwise, a real error (e.g. tool broken) — try next candidate.
+
+    return None
+
+
+def _classify_file_paths(
+    paths: Iterable[os.PathLike[str] | str],
+) -> tuple[list[Image.Image], list[Path]]:
+    """Classify clipboard file paths into images and non-image files.
+
+    Returns ``(images, non_image_paths)`` where *images* contains loaded
+    PIL images and *non_image_paths* contains paths to videos, documents,
+    and other non-image files.
+    """
+    resolved: list[Path] = []
+    for item in paths:
+        try:
+            path = Path(item)
+        except (TypeError, ValueError):
+            continue
+        if not path.is_file():
+            continue
+        resolved.append(path)
+
+    images: list[Image.Image] = []
+    non_image_paths: list[Path] = []
+
+    for path in resolved:
+        # Video files are never opened as images.
+        if path.suffix.lower() in _VIDEO_SUFFIXES:
+            non_image_paths.append(path)
+            continue
+        try:
+            with Image.open(path) as img:
+                img.load()
+                images.append(img.copy())
+        except Exception:
+            non_image_paths.append(path)
+
+    return images, non_image_paths
+
+
+def _read_clipboard_file_paths_macos_native() -> list[Path]:
+    try:
+        appkit = cast(Any, importlib.import_module("AppKit"))
+        foundation = cast(Any, importlib.import_module("Foundation"))
+    except Exception:
+        return []
+
+    NSPasteboard = appkit.NSPasteboard
+    NSURL = foundation.NSURL
+    options_key = getattr(
+        appkit,
+        "NSPasteboardURLReadingFileURLsOnlyKey",
+        "NSPasteboardURLReadingFileURLsOnlyKey",
+    )
+
+    pb = NSPasteboard.generalPasteboard()
+    options = {options_key: True}
+    try:
+        urls: list[Any] | None = pb.readObjectsForClasses_options_([NSURL], options)
+    except Exception:
+        urls = None
+
+    paths: list[Path] = []
+    if urls:
+        for url in urls:
+            try:
+                path = url.path()
+            except Exception:
+                continue
+            if path:
+                paths.append(Path(str(path)))
+
+    if paths:
+        return paths
+
+    try:
+        file_list = cast(list[str] | str | None, pb.propertyListForType_("NSFilenamesPboardType"))
+    except Exception:
+        return []
+
+    if not file_list:
+        return []
+
+    file_items: list[str] = []
+    if isinstance(file_list, list):
+        file_items.extend(item for item in file_list if item)
+    else:
+        file_items.append(file_list)
+
+    return [Path(item) for item in file_items]

cloudsave.py

@@ -0,0 +1,159 @@
+"""
+Cloud sync for dulus sessions via GitHub Gist.
+
+Supported provider: GitHub Gist
+  - No extra cloud account needed beyond a GitHub Personal Access Token
+  - Sessions stored as private Gists (JSON), browsable in GitHub UI
+  - Zero extra dependencies (uses urllib from stdlib)
+
+Config keys (stored in ~/.dulus/config.json):
+  gist_token      — GitHub Personal Access Token (needs 'gist' scope)
+  cloudsave_auto  — bool: auto-upload on /exit
+  cloudsave_last_gist_id — last uploaded gist ID (for in-place update)
+"""
+from __future__ import annotations
+import json
+import urllib.request
+import urllib.error
+from datetime import datetime
+
+GIST_TAG = "[dulus]"
+_API = "https://api.github.com"
+
+
+# ── Low-level Gist API ────────────────────────────────────────────────────────
+
+def _request(method: str, path: str, token: str, body: dict | None = None) -> dict:
+    url = f"{_API}{path}"
+    data = json.dumps(body).encode() if body else None
+    req = urllib.request.Request(
+        url,
+        data=data,
+        method=method,
+        headers={
+            "Authorization": f"token {token}",
+            "Accept": "application/vnd.github+json",
+            "Content-Type": "application/json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+    )
+    with urllib.request.urlopen(req) as resp:
+        return json.loads(resp.read())
+
+
+def _request_safe(method: str, path: str, token: str, body: dict | None = None):
+    """Like _request but returns (result, error_str)."""
+    try:
+        return _request(method, path, token, body), None
+    except urllib.error.HTTPError as e:
+        msg = e.read().decode(errors="replace")
+        try:
+            msg = json.loads(msg).get("message", msg)
+        except Exception:
+            pass
+        return None, f"GitHub API {e.code}: {msg}"
+    except Exception as e:
+        return None, str(e)
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+def validate_token(token: str) -> tuple[bool, str]:
+    """Check token is valid and has gist scope. Returns (ok, message)."""
+    result, err = _request_safe("GET", "/user", token)
+    if err:
+        return False, f"Token validation failed: {err}"
+    scopes_needed = {"gist"}
+    # GitHub returns X-OAuth-Scopes header but urllib doesn't easily expose it;
+    # a successful /user call is sufficient for basic validation.
+    login = result.get("login", "unknown")
+    return True, login
+
+
+def upload_session(
+    session_data: dict,
+    token: str,
+    description: str = "",
+    gist_id: str | None = None,
+) -> tuple[str | None, str | None]:
+    """
+    Create or update a Gist with the session JSON.
+    Returns (gist_id, error). On success gist_id is the Gist ID.
+    """
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M")
+    desc = f"{GIST_TAG} {description or ts}"
+    filename = f"dulus_session_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+    content = json.dumps(session_data, indent=2, default=str)
+
+    body = {
+        "description": desc,
+        "public": False,
+        "files": {filename: {"content": content}},
+    }
+
+    if gist_id:
+        result, err = _request_safe("PATCH", f"/gists/{gist_id}", token, body)
+    else:
+        result, err = _request_safe("POST", "/gists", token, body)
+
+    if err:
+        return None, err
+    return result["id"], None
+
+
+def list_sessions(token: str, max_results: int = 20) -> tuple[list[dict], str | None]:
+    """
+    List Gists tagged as dulus sessions.
+    Returns (list of {id, description, updated_at, url}), error).
+    """
+    result, err = _request_safe("GET", "/gists?per_page=100", token)
+    if err:
+        return [], err
+
+    sessions = [
+        {
+            "id": g["id"],
+            "description": g["description"],
+            "updated_at": g["updated_at"],
+            "url": g["html_url"],
+            "files": list(g["files"].keys()),
+        }
+        for g in result
+        if g.get("description", "").startswith(GIST_TAG)
+    ]
+    return sessions[:max_results], None
+
+
+def download_session(token: str, gist_id: str) -> tuple[dict | None, str | None]:
+    """
+    Fetch a Gist and return the parsed session JSON.
+    Returns (session_data, error).
+    """
+    result, err = _request_safe("GET", f"/gists/{gist_id}", token)
+    if err:
+        return None, err
+
+    files = result.get("files", {})
+    if not files:
+        return None, "Gist has no files"
+
+    # Take the first (and usually only) file
+    file_info = next(iter(files.values()))
+    raw_content = file_info.get("content")
+    if not raw_content:
+        # Truncated — fetch raw URL
+        raw_url = file_info.get("raw_url")
+        if not raw_url:
+            return None, "Could not retrieve file content"
+        req = urllib.request.Request(
+            raw_url,
+            headers={"Authorization": f"token {token}"},
+        )
+        with urllib.request.urlopen(req) as resp:
+            raw_content = resp.read().decode()
+
+    try:
+        data = json.loads(raw_content)
+    except json.JSONDecodeError as e:
+        return None, f"Invalid JSON in Gist: {e}"
+    return data, None

common.py

@@ -0,0 +1,177 @@
+import sys
+import json
+
+# ── Import slash completer helpers ──
+try:
+    from backend.ui.input import (
+        setup as _setup_slash_complete,
+        read_line as _read_line_pt,
+        reset_session as _reset_pt_session,
+        HAS_PROMPT_TOOLKIT as _HAS_PT,
+    )
+    def setup_slash_commands(commands_provider, meta_provider):
+        """Initialize slash command tab completion."""
+        _setup_slash_complete(commands_provider, meta_provider)
+        return _HAS_PT
+
+    def read_slash_input(prompt):
+        """Read input with slash completion."""
+        return _read_line_pt(prompt, None)
+
+    def reset_slash_session():
+        """Reset the prompt_toolkit session."""
+        _reset_pt_session()
+except ImportError:
+    def setup_slash_commands(*args, **kwargs):
+        return False
+    def read_slash_input(prompt):
+        return input(prompt)
+    def reset_slash_session():
+        pass
+
+# ── ANSI helpers ─────────────────────────────────────────────────────────────
+
+def _rgb(hex_str: str) -> str:
+    """Convert '#rrggbb' → ANSI 24-bit foreground escape."""
+    h = hex_str.lstrip("#")
+    r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+    return f"\033[38;2;{r};{g};{b}m"
+
+
+# Curated palettes (hex per semantic role). `cyan/green/blue` collapse to the
+# theme's accent color since Dulus uses them all for primary chrome.
+# Add new ones here and they show up in `/theme` automatically.
+THEMES: dict = {
+    "dulus":      {"accent": "#FF8700", "warn": "#FFAF00", "code": "monokai"},
+    "dracula":     {"accent": "#BD93F9", "warn": "#FFB86C", "code": "dracula"},
+    "nord":        {"accent": "#88C0D0", "warn": "#EBCB8B", "code": "nord"},
+    "gruvbox":     {"accent": "#FABD2F", "warn": "#FE8019", "code": "gruvbox-dark"},
+    "solarized":   {"accent": "#268BD2", "warn": "#B58900", "code": "solarized-dark"},
+    "tokyo-night": {"accent": "#7AA2F7", "warn": "#E0AF68", "code": "one-dark"},
+    "catppuccin":  {"accent": "#F5C2E7", "warn": "#FAB387", "code": "one-dark"},
+    "matrix":      {"accent": "#00FF41", "warn": "#CCFF00", "code": "monokai"},
+    "synthwave":   {"accent": "#FF00FF", "warn": "#FFCC00", "code": "fruity"},
+    "midnight":    {"accent": "#00BCD4", "warn": "#FFC107", "code": "dracula"},
+    "ocean":       {"accent": "#38bdf8", "warn": "#fbbf24", "code": "nord"},
+    "monokai":     {"accent": "#a6e22e", "warn": "#e6db74", "code": "monokai"},
+    "mono":        {"accent": "#E0E0E0", "warn": "#A0A0A0", "code": "bw"},
+    "none":        {"accent": "#FFFFFF", "warn": "#FFFFFF", "code": "default"},
+}
+
+# Active code-block style for Rich Markdown rendering — read by dulus.py.
+CODE_THEME: str = "monokai"
+
+C = {
+    "cyan":    "", "green": "", "yellow": "", "red": "",
+    "blue":    "", "magenta": "", "white": "", "gray": "",
+    "bold":    "\033[1m",
+    "dim":     "\033[2m",
+    "reset":   "\033[0m",
+}
+
+
+def apply_theme(name: str) -> bool:
+    """Mutate the global ANSI color map in-place to a named theme."""
+    global CODE_THEME
+    p = THEMES.get(name)
+    if not p:
+        return False
+    accent = _rgb(p["accent"])
+    warn   = _rgb(p["warn"])
+    C["cyan"] = C["green"] = C["blue"] = accent
+    C["yellow"] = C["magenta"] = warn
+    C["red"]    = "\033[38;5;196m"   # errors stay red across all themes
+    C["white"]  = "\033[97m"
+    C["gray"]   = "\033[90m"
+    CODE_THEME  = p["code"]
+    return True
+
+
+# Default = Dulus orange (preserve previous look).
+apply_theme("dulus")
+
+def clr(text: str, *keys: str) -> str:
+    return "".join(C[k] for k in keys) + str(text) + C["reset"]
+
+def info(msg: str):   print(clr(msg, "cyan"))
+def ok(msg: str):     print(clr(msg, "green"))
+def warn(msg: str):   print(clr(f"Warning: {msg}", "yellow"))
+def err(msg: str):    print(clr(f"Error: {msg}", "red"), file=sys.stderr)
+
+def stream_thinking(chunk: str, verbose: bool):
+    if verbose:
+        clean_chunk = chunk.replace("\n", " ")
+        if clean_chunk:
+            print(f"{C['dim']}{clean_chunk}", end="", flush=True)
+
+# ── Tool Impersonation UI ────────────────────────────────────────────────────
+def print_tool_start(name: str, inputs: dict):
+    desc = f"{name}({', '.join(f'{k}={v}' for k, v in inputs.items())})"
+    if name == "Read": desc = f"Read({inputs.get('file_path','')})"
+    if name == "Write": desc = f"Write({inputs.get('file_path','')})"
+    if name == "Bash": desc = f"Bash({inputs.get('command','')[:60]})"
+    
+    print(clr(f"  ⚙  {desc}", "dim", "cyan"), flush=True)
+
+def print_tool_end(name: str, result: str, success: bool = True, verbose: bool = False, auto_show: bool = True):
+    # For PrintToConsole, always show the full content since that's the point
+    if name == "PrintToConsole":
+        print(clr(f"  [PrintToConsole] {len(result)} chars displayed", "dim", "cyan"))
+        print()
+        # Print the actual content directly without clr() to avoid encoding issues
+        try:
+            print(result)
+        except UnicodeEncodeError:
+            # Fallback: encode then decode with error handling
+            print(result.encode('utf-8', errors='replace').decode('utf-8'))
+        print()
+        return
+    
+    # For display-only tools (ASCII art, etc.), show full content like PrintToConsole if auto_show is ON
+    from tool_registry import is_display_only
+    is_display = is_display_only(name)
+
+    if success:
+        symbol = "[OK]"
+        color = "green"
+        summary = f"-> {len(result)} chars" if len(result) > 100 else f"-> {result}"
+        print(clr(f"  {symbol} {summary}", "dim", color), flush=True)
+
+        # For display-only tools, show the full content immediately if auto_show is ON
+        if is_display and auto_show:
+            print()
+            try:
+                print(result)
+            except UnicodeEncodeError:
+                print(result.encode('utf-8', errors='replace').decode('utf-8'))
+            print()
+    else:
+        symbol = "[X]"
+        color = "red"
+        print(clr(f"  {symbol} {result[:120]}", "dim", color), flush=True)
+
+    if verbose and success and not (is_display and auto_show):
+        preview = result[:300] + ("..." if len(result) > 300 else "")
+        # Replace newlines for indentation but handle encoding
+        try:
+            indented = preview.replace(chr(10), chr(10)+'     ')
+            print(clr(f"     {indented}", "dim"))
+        except UnicodeEncodeError:
+            safe_preview = preview.encode('ascii', errors='replace').decode('ascii')
+            print(clr(f"     {safe_preview}", "dim"))
+
+
+def sanitize_text(text: str) -> str:
+    """Remove invalid UTF-16 surrogates and ensure valid UTF-8.
+
+    On Windows consoles (cp1252) pasted emojis often become stray surrogates
+    (e.g. \\ud83d\\udcec) which later explode with:
+        'utf-8' codec can't encode characters: surrogates not allowed
+    This helper cleans them *once* at the boundary before they enter the
+    conversation state or are sent to any API.
+    """
+    if not isinstance(text, str):
+        return str(text)
+    # Strip surrogate characters (U+D800-U+DFFF) — these are invalid in
+    # UTF-8 and will cause encoding errors when JSON-serialised.
+    return "".join(c for c in text if not (0xD800 <= ord(c) <= 0xDFFF))