Desktop Control

name: Release and Publish to PyPI

on:
  push:
    branches:
      - main
    paths:
      - 'pyproject.toml'

permissions:
  contents: write
  id-token: write  # Required for PyPI trusted publishing

jobs:
  release:
    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Fetch all history for changelog generation
      
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      
      - name: Install uv
        uses: astral-sh/setup-uv@v5
        with:
          enable-cache: true
      
      - name: Extract version from pyproject.toml
        id: get_version
        run: |
          VERSION=$(grep -m 1 'version' pyproject.toml | sed 's/.*"\(.*\)".*/\1/')
          echo "version=$VERSION" >> $GITHUB_OUTPUT
          echo "tag=v$VERSION" >> $GITHUB_OUTPUT
      
      - name: Check if tag exists
        id: check_tag
        run: |
          if git rev-parse "${{ steps.get_version.outputs.tag }}" >/dev/null 2>&1; then
            echo "exists=true" >> $GITHUB_OUTPUT
          else
            echo "exists=false" >> $GITHUB_OUTPUT
          fi
      
      - name: Build package
        if: steps.check_tag.outputs.exists == 'false'
        run: |
          uv build
      
      - name: Create GitHub Release
        if: steps.check_tag.outputs.exists == 'false'
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          gh release create "${{ steps.get_version.outputs.tag }}" \
            --title "Release ${{ steps.get_version.outputs.version }}" \
            --generate-notes \
            dist/*
      
      - name: Publish to PyPI
        if: steps.check_tag.outputs.exists == 'false'
        uses: pypa/gh-action-pypi-publish@release/v1
        with:
          verbose: true

# Python-generated files
__pycache__/
*.py[oc]
build/
dist/
wheels/
*.egg-info

# Virtual environments
.venv

3.12

"""Commands package for desktop-skill CLI."""

"""Keyboard control commands."""
import typer
import pyautogui

app = typer.Typer(help="Keyboard control commands")


@app.command()
def write(
    text: str = typer.Argument(..., help="Text to type"),
    interval: float = typer.Option(0.0, "--interval", "-i", help="Interval between keystrokes"),
):
    """Type text with optional interval between keys."""
    pyautogui.write(text, interval=interval)
    typer.echo(f"Typed: {text}")


@app.command()
def press(
    keys: str = typer.Argument(..., help="Key(s) to press (comma-separated for sequence)"),
    presses: int = typer.Option(1, "--presses", "-p", help="Number of times to press"),
    interval: float = typer.Option(0.0, "--interval", "-i", help="Interval between presses"),
):
    """Press one or more keys."""
    key_list = [k.strip() for k in keys.split(",")]
    for key in key_list:
        pyautogui.press(key, presses=presses, interval=interval)
    typer.echo(f"Pressed: {keys} ({presses}x)")


@app.command()
def hotkey(
    keys: str = typer.Argument(..., help="Keys for hotkey (comma-separated, e.g., 'ctrl,c')"),
    interval: float = typer.Option(0.0, "--interval", "-i", help="Interval between key presses"),
):
    """Execute a hotkey combination."""
    key_list = [k.strip() for k in keys.split(",")]
    pyautogui.hotkey(*key_list, interval=interval)
    typer.echo(f"Executed hotkey: {' + '.join(key_list)}")


@app.command()
def keydown(
    key: str = typer.Argument(..., help="Key to hold down"),
):
    """Hold down a key."""
    pyautogui.keyDown(key)
    typer.echo(f"Key down: {key}")


@app.command()
def keyup(
    key: str = typer.Argument(..., help="Key to release"),
):
    """Release a held key."""
    pyautogui.keyUp(key)
    typer.echo(f"Key up: {key}")

"""Message box commands."""
import typer
import pyautogui

app = typer.Typer(help="Message box commands")


@app.command()
def alert(
    text: str = typer.Argument(..., help="Alert message"),
    title: str = typer.Option("Alert", "--title", "-t", help="Window title"),
    button: str = typer.Option("OK", "--button", "-b", help="Button text"),
):
    """Display an alert message box."""
    result = pyautogui.alert(text=text, title=title, button=button)
    typer.echo(f"Alert shown: {result}")


@app.command()
def confirm(
    text: str = typer.Argument(..., help="Confirmation message"),
    title: str = typer.Option("Confirm", "--title", "-t", help="Window title"),
    buttons: str = typer.Option("OK,Cancel", "--buttons", "-b", help="Button texts (comma-separated)"),
):
    """Display a confirmation dialog."""
    button_list = [b.strip() for b in buttons.split(",")]
    result = pyautogui.confirm(text=text, title=title, buttons=button_list)
    typer.echo(f"User selected: {result}")


@app.command()
def prompt(
    text: str = typer.Argument(..., help="Prompt message"),
    title: str = typer.Option("Input", "--title", "-t", help="Window title"),
    default: str = typer.Option("", "--default", "-d", help="Default value"),
):
    """Display a prompt dialog for text input."""
    result = pyautogui.prompt(text=text, title=title, default=default)
    if result is not None:
        typer.echo(f"User entered: {result}")
    else:
        typer.echo("User cancelled")


@app.command()
def password(
    text: str = typer.Argument(..., help="Password prompt message"),
    title: str = typer.Option("Password", "--title", "-t", help="Window title"),
    default: str = typer.Option("", "--default", "-d", help="Default value"),
    mask: str = typer.Option("*", "--mask", "-m", help="Mask character"),
):
    """Display a password input dialog."""
    result = pyautogui.password(text=text, title=title, default=default, mask=mask)
    if result is not None:
        typer.echo(f"Password entered (length: {len(result)})")
    else:
        typer.echo("User cancelled")

"""Mouse control commands."""
import typer
import pyautogui

app = typer.Typer(help="Mouse control commands")


@app.command()
def move(
    x: int = typer.Argument(..., help="X coordinate"),
    y: int = typer.Argument(..., help="Y coordinate"),
    duration: float = typer.Option(0.0, "--duration", "-d", help="Duration in seconds"),
):
    """Move mouse to specified coordinates."""
    pyautogui.moveTo(x, y, duration=duration)
    typer.echo(f"Mouse moved to ({x}, {y})")


@app.command()
def click(
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
    button: str = typer.Option("left", "--button", "-b", help="Mouse button: left, right, middle"),
    clicks: int = typer.Option(1, "--clicks", "-c", help="Number of clicks"),
):
    """Click at current position or specified coordinates."""
    if x is not None and y is not None:
        pyautogui.click(x, y, clicks=clicks, button=button)
        typer.echo(f"{button.capitalize()} clicked {clicks}x at ({x}, {y})")
    else:
        pyautogui.click(clicks=clicks, button=button)
        typer.echo(f"{button.capitalize()} clicked {clicks}x at current position")


@app.command()
def double_click(
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
):
    """Double click at current position or specified coordinates."""
    if x is not None and y is not None:
        pyautogui.doubleClick(x, y)
        typer.echo(f"Double clicked at ({x}, {y})")
    else:
        pyautogui.doubleClick()
        typer.echo("Double clicked at current position")


@app.command()
def right_click(
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
):
    """Right click at current position or specified coordinates."""
    if x is not None and y is not None:
        pyautogui.rightClick(x, y)
        typer.echo(f"Right clicked at ({x}, {y})")
    else:
        pyautogui.rightClick()
        typer.echo("Right clicked at current position")


@app.command()
def middle_click(
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
):
    """Middle click at current position or specified coordinates."""
    if x is not None and y is not None:
        pyautogui.middleClick(x, y)
        typer.echo(f"Middle clicked at ({x}, {y})")
    else:
        pyautogui.middleClick()
        typer.echo("Middle clicked at current position")


@app.command()
def drag(
    x: int = typer.Argument(..., help="Target X coordinate"),
    y: int = typer.Argument(..., help="Target Y coordinate"),
    duration: float = typer.Option(0.0, "--duration", "-d", help="Duration in seconds"),
    button: str = typer.Option("left", "--button", "-b", help="Mouse button: left, right, middle"),
):
    """Drag mouse to specified coordinates."""
    pyautogui.drag(x, y, duration=duration, button=button)
    typer.echo(f"Dragged to ({x}, {y}) with {button} button")


@app.command()
def scroll(
    clicks: int = typer.Argument(..., help="Number of scroll clicks (negative for down)"),
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
):
    """Scroll at current position or specified coordinates."""
    if x is not None and y is not None:
        pyautogui.scroll(clicks, x, y)
        typer.echo(f"Scrolled {clicks} clicks at ({x}, {y})")
    else:
        pyautogui.scroll(clicks)
        typer.echo(f"Scrolled {clicks} clicks at current position")


@app.command()
def position():
    """Get current mouse position."""
    pos = pyautogui.position()
    typer.echo(f"Mouse position: ({pos.x}, {pos.y})")

"""Screen and screenshot commands."""
import typer
import pyautogui
from pathlib import Path

app = typer.Typer(help="Screen and screenshot commands")


@app.command()
def screenshot(
    filename: str = typer.Argument("screenshot.png", help="Output filename"),
    region: str = typer.Option(None, "--region", "-r", help="Region as 'x,y,width,height'"),
):
    """Take a screenshot of the entire screen or a region."""
    if region:
        try:
            x, y, width, height = map(int, region.split(","))
            img = pyautogui.screenshot(region=(x, y, width, height))
            img.save(filename)
            typer.echo(f"Screenshot saved to {filename} (region: {region})")
        except ValueError:
            typer.echo("Error: Region must be in format 'x,y,width,height'", err=True)
            raise typer.Exit(1)
    else:
        img = pyautogui.screenshot()
        img.save(filename)
        typer.echo(f"Screenshot saved to {filename}")


@app.command()
def locate(
    image: str = typer.Argument(..., help="Path to image to locate"),
    confidence: float = typer.Option(0.9, "--confidence", "-c", help="Match confidence (0.0-1.0)"),
):
    """Locate an image on the screen."""
    try:
        location = pyautogui.locateOnScreen(image, confidence=confidence)
        if location:
            typer.echo(f"Found at: x={location.left}, y={location.top}, width={location.width}, height={location.height}")
        else:
            typer.echo("Image not found on screen")
    except pyautogui.ImageNotFoundException:
        typer.echo("Image not found on screen")
    except Exception as e:
        typer.echo(f"Error: {e}", err=True)
        raise typer.Exit(1)


@app.command()
def locate_center(
    image: str = typer.Argument(..., help="Path to image to locate"),
    confidence: float = typer.Option(0.9, "--confidence", "-c", help="Match confidence (0.0-1.0)"),
):
    """Get the center coordinates of an image on the screen."""
    try:
        location = pyautogui.locateCenterOnScreen(image, confidence=confidence)
        if location:
            typer.echo(f"Center at: ({location.x}, {location.y})")
        else:
            typer.echo("Image not found on screen")
    except pyautogui.ImageNotFoundException:
        typer.echo("Image not found on screen")
    except Exception as e:
        typer.echo(f"Error: {e}", err=True)
        raise typer.Exit(1)


@app.command()
def pixel(
    x: int = typer.Argument(..., help="X coordinate"),
    y: int = typer.Argument(..., help="Y coordinate"),
):
    """Get the RGB color of a pixel at specified coordinates."""
    color = pyautogui.pixel(x, y)
    typer.echo(f"Pixel at ({x}, {y}): RGB{color}")


@app.command()
def size():
    """Get the screen size."""
    screen_size = pyautogui.size()
    typer.echo(f"Screen size: {screen_size.width}x{screen_size.height}")


@app.command()
def on_screen(
    x: int = typer.Argument(..., help="X coordinate"),
    y: int = typer.Argument(..., help="Y coordinate"),
):
    """Check if coordinates are on the screen."""
    is_on_screen = pyautogui.onScreen(x, y)
    if is_on_screen:
        typer.echo(f"({x}, {y}) is on screen")
    else:
        typer.echo(f"({x}, {y}) is NOT on screen")

"""Desktop Agent - CLI for controlling mouse, keyboard, and screen using PyAutoGUI."""
import typer
from desktop_agent.commands import mouse, keyboard, screen, message, app

app_cli = typer.Typer(
    name="desktop-agent",
    help="Control your desktop with mouse, keyboard, and screen automation",
    no_args_is_help=True,
)

# Register sub-applications
app_cli.add_typer(mouse.app, name="mouse")
app_cli.add_typer(keyboard.app, name="keyboard")
app_cli.add_typer(screen.app, name="screen")
app_cli.add_typer(message.app, name="message")
app_cli.add_typer(app.app, name="app")


@app_cli.command()
def version():
    """Show version information."""
    typer.echo("desktop-agent v1.1.0")

"""Entry point for running desktop-agent as a module.

Usage: python -m desktop_agent <command>
"""
from desktop_agent import app

if __name__ == "__main__":
    app()

"""Commands package for desktop-agent CLI."""

"""Application control commands - cross-platform app launching and focusing."""
import platform
import subprocess
import time
import typer
from typing import Optional
from desktop_agent.utils import CommandResponse, ErrorCode, DesktopAgentError

app = typer.Typer(help="Application control commands")


def _get_platform() -> str:
    """Get the current platform."""
    system = platform.system().lower()
    if system == "darwin":
        return "macos"
    elif system == "windows":
        return "windows"
    else:
        return "linux"


def _handle_command(command: str, func, *args, **kwargs):
    start = time.time()
    try:
        result = func(*args, **kwargs)
        duration_ms = int((time.time() - start) * 1000)
        response = CommandResponse.success_response(
            command=command,
            data=result,
            duration_ms=duration_ms,
        )
        response.print()
    except Exception as e:
        duration_ms = int((time.time() - start) * 1000)
        error = DesktopAgentError(
            code=ErrorCode.from_exception(e),
            message=str(e),
        )
        response = CommandResponse.error_response(
            command=command,
            code=error.code.to_string(),
            message=error.message,
            details=error.details,
            duration_ms=duration_ms,
         )
        response.print()
        raise sys.exit(error.exit_code())


@app.command()
def open(
    name: str = typer.Argument(..., help="Application name or path to open"),
    args: Optional[list[str]] = typer.Option(None, "--arg", "-a", help="Arguments to pass to the application"),
):
    """Open an application by name or path."""
    def execute():
        current_platform = _get_platform()
        args_list = args or []

        if current_platform == "windows":
            if args_list:
                subprocess.Popen(
                    f'start "" "{name}" {" ".join(args_list)}',
                    shell=True,
                )
            else:
                subprocess.Popen(f'start "" "{name}"', shell=True)

        elif current_platform == "macos":
            cmd = ["open", "-a", name]
            if args_list:
                cmd.extend(["--args"] + args_list)
            subprocess.Popen(cmd)

        else:
            cmd = [name] + args_list
            subprocess.Popen(
                cmd,
                stdout=subprocess.DEVNULL,
                stderr=subprocess.DEVNULL,
            )

        return {"application": name, "args": args_list}
    _handle_command("app.open", execute)


@app.command()
def focus(name: str = typer.Argument(..., help="Window title or application name to focus")):
    """Focus on a window by title or application name."""
    def execute():
        current_platform = _get_platform()

        if current_platform == "windows":
            import ctypes
            from ctypes import wintypes

            user32 = ctypes.windll.user32

            EnumWindowsProc = ctypes.WINFUNCTYPE(
                ctypes.c_bool,
                wintypes.HWND,
                wintypes.LPARAM
            )

            found_hwnd = None

            def enum_callback(hwnd, lparam):
                nonlocal found_hwnd
                if user32.IsWindowVisible(hwnd):
                    length = user32.GetWindowTextLengthW(hwnd)
                    if length > 0:
                        buffer = ctypes.create_unicode_buffer(length + 1)
                        user32.GetWindowTextW(hwnd, buffer, length + 1)
                        title = buffer.value
                        if name.lower() in title.lower():
                            found_hwnd = hwnd
                            return False
                return True

            user32.EnumWindows(EnumWindowsProc(enum_callback), 0)

            if found_hwnd:
                SW_RESTORE = 9
                user32.ShowWindow(found_hwnd, SW_RESTORE)
                user32.SetForegroundWindow(found_hwnd)
                return {"window_title": name, "focused": True}
            else:
                raise DesktopAgentError(
                    code=ErrorCode.WINDOW_NOT_FOUND,
                    message=f"Window '{name}' not found",
                )

        elif current_platform == "macos":
            script = f'''
            tell application "{name}"
                activate
            end tell
            '''
            result = subprocess.run(
                ["osascript", "-e", script],
                capture_output=True,
                text=True,
            )
            if result.returncode == 0:
                return {"application": name, "focused": True}
            else:
                raise DesktopAgentError(
                    code=ErrorCode.WINDOW_NOT_FOUND,
                    message=f"Could not focus '{name}'",
                    details={"stderr": result.stderr},
                )

        else:
            try:
                result = subprocess.run(
                    ["wmctrl", "-a", name],
                    capture_output=True,
                    text=True,
                )
                if result.returncode == 0:
                    return {"window_title": name, "focused": True}
                else:
                    raise FileNotFoundError("wmctrl failed")
            except FileNotFoundError:
                result = subprocess.run(
                    ["xdotool", "search", "--name", name, "windowactivate"],
                    capture_output=True,
                    text=True,
                )
                if result.returncode == 0:
                    return {"window_title": name, "focused": True}
                else:
                    raise DesktopAgentError(
                        code=ErrorCode.WINDOW_NOT_FOUND,
                        message=f"Could not focus '{name}'. Install wmctrl or xdotool.",
                    )
    _handle_command("app.focus", execute)


@app.command()
def list():
    """List all visible windows."""
    def execute():
        current_platform = _get_platform()
        windows = []

        if current_platform == "windows":
            import ctypes
            from ctypes import wintypes

            user32 = ctypes.windll.user32

            EnumWindowsProc = ctypes.WINFUNCTYPE(
                ctypes.c_bool,
                wintypes.HWND,
                wintypes.LPARAM
            )

            def enum_callback(hwnd, lparam):
                if user32.IsWindowVisible(hwnd):
                    length = user32.GetWindowTextLengthW(hwnd)
                    if length > 0:
                        buffer = ctypes.create_unicode_buffer(length + 1)
                        user32.GetWindowTextW(hwnd, buffer, length + 1)
                        title = buffer.value
                        if title.strip():
                            windows.append(title)
                return True

            user32.EnumWindows(EnumWindowsProc(enum_callback), 0)

        elif current_platform == "macos":
            script = '''
            tell application "System Events"
                set windowList to {}
                repeat with proc in (every process whose background only is false)
                    repeat with win in (every window of proc)
                        set end of windowList to (name of proc) & " - " & (name of win)
                    end repeat
                end repeat
                return windowList
            end tell
            '''
            result = subprocess.run(
                ["osascript", "-e", script],
                capture_output=True,
                text=True,
            )
            if result.returncode == 0 and result.stdout.strip():
                output = result.stdout.strip()
                if output:
                    windows = [w.strip() for w in output.split(",")]

        else:
            result = subprocess.run(
                ["wmctrl", "-l"],
                capture_output=True,
                text=True,
            )
            if result.returncode == 0:
                for line in result.stdout.strip().split("\n"):
                    if line:
                        parts = line.split(None, 3)
                        if len(parts) >= 4:
                            windows.append(parts[3])
            else:
                raise DesktopAgentError(
                    code=ErrorCode.PLATFORM_NOT_SUPPORTED,
                    message="wmctrl not found. Install it with: sudo apt install wmctrl",
                )

        return {"windows": windows}
    _handle_command("app.list", execute)


import sys

"""Keyboard control commands."""
import time
import typer
import pyautogui
from desktop_agent.utils import CommandResponse, ErrorCode, DesktopAgentError

app = typer.Typer(help="Keyboard control commands")


def _handle_command(command: str, func, *args, **kwargs):
    start = time.time()
    try:
        result = func(*args, **kwargs)
        duration_ms = int((time.time() - start) * 1000)
        response = CommandResponse.success_response(
            command=command,
            data=result,
            duration_ms=duration_ms,
        )
        response.print()
    except Exception as e:
        duration_ms = int((time.time() - start) * 1000)
        error = DesktopAgentError(
            code=ErrorCode.from_exception(e),
            message=str(e),
        )
        response = CommandResponse.error_response(
            command=command,
            code=error.code.to_string(),
            message=error.message,
            details=error.details,
            duration_ms=duration_ms,
        )
        response.print()
        raise sys.exit(error.exit_code())


@app.command()
def write(
    text: str = typer.Argument(..., help="Text to type"),
    interval: float = typer.Option(0.0, "--interval", "-i", help="Interval between keystrokes"),
):
    """Type text with optional interval between keys."""
    def execute():
        pyautogui.write(text, interval=interval)
        return {"text": text, "interval": interval}
    _handle_command("keyboard.write", execute)


@app.command()
def press(
    keys: str = typer.Argument(..., help="Key(s) to press (comma-separated for sequence)"),
    presses: int = typer.Option(1, "--presses", "-p", help="Number of times to press"),
    interval: float = typer.Option(0.0, "--interval", "-i", help="Interval between presses"),
):
    """Press one or more keys."""
    def execute():
        key_list = [k.strip() for k in keys.split(",")]
        for key in key_list:
            pyautogui.press(key, presses=presses, interval=interval)
        return {"keys": key_list, "presses": presses, "interval": interval}
    _handle_command("keyboard.press", execute)


@app.command()
def hotkey(
    keys: str = typer.Argument(..., help="Keys for hotkey (comma-separated, e.g., 'ctrl,c')"),
    interval: float = typer.Option(0.0, "--interval", "-i", help="Interval between key presses"),
):
    """Execute a hotkey combination."""
    def execute():
        key_list = [k.strip() for k in keys.split(",")]
        pyautogui.hotkey(*key_list, interval=interval)
        return {"keys": key_list, "interval": interval}
    _handle_command("keyboard.hotkey", execute)


@app.command()
def keydown(key: str = typer.Argument(..., help="Key to hold down")):
    """Hold down a key."""
    def execute():
        pyautogui.keyDown(key)
        return {"key": key}
    _handle_command("keyboard.keydown", execute)


@app.command()
def keyup(key: str = typer.Argument(..., help="Key to release")):
    """Release a held key."""
    def execute():
        pyautogui.keyUp(key)
        return {"key": key}
    _handle_command("keyboard.keyup", execute)


import sys

"""Message box commands."""
import time
import typer
import pyautogui
from desktop_agent.utils import CommandResponse, ErrorCode, DesktopAgentError

app = typer.Typer(help="Message box commands")


def _handle_command(command: str, func, *args, **kwargs):
    start = time.time()
    try:
        result = func(*args, **kwargs)
        duration_ms = int((time.time() - start) * 1000)
        response = CommandResponse.success_response(
            command=command,
            data=result,
            duration_ms=duration_ms,
        )
        response.print()
    except Exception as e:
        duration_ms = int((time.time() - start) * 1000)
        error = DesktopAgentError(
            code=ErrorCode.from_exception(e),
            message=str(e),
        )
        response = CommandResponse.error_response(
            command=command,
            code=error.code.to_string(),
            message=error.message,
            details=error.details,
            duration_ms=duration_ms,
        )
        response.print()
        raise sys.exit(error.exit_code())


@app.command()
def alert(
    text: str = typer.Argument(..., help="Alert message"),
    title: str = typer.Option("Alert", "--title", "-t", help="Window title"),
    button: str = typer.Option("OK", "--button", "-b", help="Button text"),
):
    """Display an alert message box."""
    def execute():
        result = pyautogui.alert(text=text, title=title, button=button)
        return {"button_pressed": result}
    _handle_command("message.alert", execute)


@app.command()
def confirm(
    text: str = typer.Argument(..., help="Confirmation message"),
    title: str = typer.Option("Confirm", "--title", "-t", help="Window title"),
    buttons: str = typer.Option("OK,Cancel", "--buttons", "-b", help="Button texts (comma-separated)"),
):
    """Display a confirmation dialog."""
    def execute():
        button_list = [b.strip() for b in buttons.split(",")]
        result = pyautogui.confirm(text=text, title=title, buttons=button_list)
        return {"button_pressed": result}
    _handle_command("message.confirm", execute)


@app.command()
def prompt(
    text: str = typer.Argument(..., help="Prompt message"),
    title: str = typer.Option("Input", "--title", "-t", help="Window title"),
    default: str = typer.Option("", "--default", "-d", help="Default value"),
):
    """Display a prompt dialog for text input."""
    def execute():
        result = pyautogui.prompt(text=text, title=title, default=default)
        if result is not None:
            return {"user_input": result, "cancelled": False}
        else:
            return {"user_input": None, "cancelled": True}
    _handle_command("message.prompt", execute)


@app.command()
def password(
    text: str = typer.Argument(..., help="Password prompt message"),
    title: str = typer.Option("Password", "--title", "-t", help="Window title"),
    default: str = typer.Option("", "--default", "-d", help="Default value"),
    mask: str = typer.Option("*", "--mask", "-m", help="Mask character"),
):
    """Display a password input dialog."""
    def execute():
        result = pyautogui.password(text=text, title=title, default=default, mask=mask)
        if result is not None:
            return {"entered": True, "length": len(result)}
        else:
            return {"entered": False, "length": 0}
    _handle_command("message.password", execute)


import sys

"""Mouse control commands."""
import time
import typer
import pyautogui
from desktop_agent.utils import CommandResponse, ErrorCode, DesktopAgentError

app = typer.Typer(help="Mouse control commands")


def _handle_command(command: str, func, *args, **kwargs):
    start = time.time()
    try:
        result = func(*args, **kwargs)
        duration_ms = int((time.time() - start) * 1000)
        response = CommandResponse.success_response(
            command=command,
            data=result,
            duration_ms=duration_ms,
        )
        response.print()
    except Exception as e:
        duration_ms = int((time.time() - start) * 1000)
        error = DesktopAgentError(
            code=ErrorCode.from_exception(e),
            message=str(e),
        )
        response = CommandResponse.error_response(
            command=command,
            code=error.code.to_string(),
            message=error.message,
            details=error.details,
            duration_ms=duration_ms,
        )
        response.print()
        raise sys.exit(error.exit_code())


@app.command()
def move(
    x: int = typer.Argument(..., help="X coordinate"),
    y: int = typer.Argument(..., help="Y coordinate"),
    duration: float = typer.Option(0.0, "--duration", "-d", help="Duration in seconds"),
):
    """Move mouse to specified coordinates."""
    def execute():
        pyautogui.moveTo(x, y, duration=duration)
        return {"x": x, "y": y, "duration": duration}
    _handle_command("mouse.move", execute)


@app.command()
def click(
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
    button: str = typer.Option("left", "--button", "-b", help="Mouse button: left, right, middle"),
    clicks: int = typer.Option(1, "--clicks", "-c", help="Number of clicks"),
):
    """Click at current position or specified coordinates."""
    def execute():
        if x is not None and y is not None:
            pyautogui.click(x, y, clicks=clicks, button=button)
            return {"position": {"x": x, "y": y}, "button": button, "clicks": clicks}
        else:
            pyautogui.click(clicks=clicks, button=button)
            return {"position": None, "button": button, "clicks": clicks}
    _handle_command("mouse.click", execute)


@app.command()
def double_click(
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
):
    """Double click at current position or specified coordinates."""
    def execute():
        if x is not None and y is not None:
            pyautogui.doubleClick(x, y)
            return {"position": {"x": x, "y": y}}
        else:
            pyautogui.doubleClick()
            return {"position": None}
    _handle_command("mouse.double_click", execute)


@app.command()
def right_click(
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
):
    """Right click at current position or specified coordinates."""
    def execute():
        if x is not None and y is not None:
            pyautogui.rightClick(x, y)
            return {"position": {"x": x, "y": y}}
        else:
            pyautogui.rightClick()
            return {"position": None}
    _handle_command("mouse.right_click", execute)


@app.command()
def middle_click(
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
):
    """Middle click at current position or specified coordinates."""
    def execute():
        if x is not None and y is not None:
            pyautogui.middleClick(x, y)
            return {"position": {"x": x, "y": y}}
        else:
            pyautogui.middleClick()
            return {"position": None}
    _handle_command("mouse.middle_click", execute)


@app.command()
def drag(
    x: int = typer.Argument(..., help="Target X coordinate"),
    y: int = typer.Argument(..., help="Target Y coordinate"),
    duration: float = typer.Option(0.0, "--duration", "-d", help="Duration in seconds"),
    button: str = typer.Option("left", "--button", "-b", help="Mouse button: left, right, middle"),
):
    """Drag mouse to specified coordinates."""
    def execute():
        pyautogui.drag(x, y, duration=duration, button=button)
        return {"x": x, "y": y, "duration": duration, "button": button}
    _handle_command("mouse.drag", execute)


@app.command()
def scroll(
    clicks: int = typer.Argument(..., help="Number of scroll clicks (negative for down)"),
    x: int = typer.Argument(None, help="X coordinate (optional)"),
    y: int = typer.Argument(None, help="Y coordinate (optional)"),
):
    """Scroll at current position or specified coordinates."""
    def execute():
        if x is not None and y is not None:
            pyautogui.scroll(clicks, x, y)
            return {"clicks": clicks, "position": {"x": x, "y": y}}
        else:
            pyautogui.scroll(clicks)
            return {"clicks": clicks, "position": None}
    _handle_command("mouse.scroll", execute)


@app.command()
def position():
    """Get current mouse position."""
    def execute():
        pos = pyautogui.position()
        return {"position": {"x": pos.x, "y": pos.y}}
    _handle_command("mouse.position", execute)


import sys

"""Screen and screenshot commands."""
import time
import typer
import pyautogui
from pathlib import Path
from typing import Optional
import json
import pywinctl
from desktop_agent.utils import CommandResponse, ErrorCode, DesktopAgentError

app = typer.Typer(help="Screen and screenshot commands")


def _get_window_region(window_name: Optional[str] = None, active: bool = False) -> Optional[tuple[int, int, int, int]]:
    """Get the region of a specific or active window using PyWinCtl."""
    try:
        if active:
            window = pywinctl.getActiveWindow()
            if not window:
                return None
        elif window_name:
            windows = pywinctl.getWindowsWithTitle(window_name)
            if not windows:
                return None
            window = windows[0]
        else:
            return None

        return (int(window.left), int(window.top), int(window.width), int(window.height))
    except Exception:
        return None


def _handle_command(command: str, func, *args, **kwargs):
    start = time.time()
    try:
        result = func(*args, **kwargs)
        duration_ms = int((time.time() - start) * 1000)
        response = CommandResponse.success_response(
            command=command,
            data=result,
            duration_ms=duration_ms,
        )
        response.print()
    except Exception as e:
        duration_ms = int((time.time() - start) * 1000)
        error = DesktopAgentError(
            code=ErrorCode.from_exception(e),
            message=str(e),
        )
        response = CommandResponse.error_response(
            command=command,
            code=error.code.to_string(),
            message=error.message,
            details=error.details,
            duration_ms=duration_ms,
        )
        response.print()
        raise sys.exit(error.exit_code())


@app.command()
def screenshot(
    filename: str = typer.Argument("screenshot.png", help="Output filename"),
    region: str = typer.Option(None, "--region", "-r", help="Region as 'x,y,width,height'"),
    window: Optional[str] = typer.Option(None, "--window", "-w", help="Target window title"),
    active: bool = typer.Option(False, "--active", "-a", help="Target active window"),
):
    """Take a screenshot of the entire screen, a window, or a specific region."""
    def execute():
        target_region = None

        window_region = _get_window_region(window, active)
        if window_region:
            target_region = window_region

        if region:
            try:
                target_region = tuple(map(int, region.split(",")))
            except ValueError:
                raise DesktopAgentError(
                    code=ErrorCode.INVALID_ARGUMENT,
                    message="Region must be in format 'x,y,width,height'",
                )

        if target_region:
            img = pyautogui.screenshot(region=target_region)
            img.save(filename)
            return {
                "filename": filename,
                "region": {
                    "x": target_region[0],
                    "y": target_region[1],
                    "width": target_region[2],
                    "height": target_region[3],
                },
            }
        else:
            img = pyautogui.screenshot()
            img.save(filename)
            return {"filename": filename, "region": None}
    _handle_command("screen.screenshot", execute)


@app.command()
def locate(
    image: str = typer.Argument(..., help="Path to image to locate"),
    confidence: float = typer.Option(0.9, "--confidence", "-c", help="Match confidence (0.0-1.0)"),
    window: Optional[str] = typer.Option(None, "--window", "-w", help="Search within a specific window"),
    active: bool = typer.Option(False, "--active", "-a", help="Search within the active window"),
):
    """Locate an image on the screen or within a targeted window."""
    def execute():
        region = _get_window_region(window, active)

        if not Path(image).exists():
            raise DesktopAgentError(
                code=ErrorCode.IMAGE_NOT_FOUND,
                message=f"Image file '{image}' not found",
            )

        location = pyautogui.locateOnScreen(image, confidence=confidence, region=region)
        if location:
            return {
                "image_found": True,
                "bounding_box": {
                    "left": location.left,
                    "top": location.top,
                    "width": location.width,
                    "height": location.height,
                    "center_x": location.left + location.width // 2,
                    "center_y": location.top + location.height // 2,
                },
            }
        else:
            return {"image_found": False}
    _handle_command("screen.locate", execute)


@app.command()
def locate_center(
    image: str = typer.Argument(..., help="Path to image to locate"),
    confidence: float = typer.Option(0.9, "--confidence", "-c", help="Match confidence (0.0-1.0)"),
    window: Optional[str] = typer.Option(None, "--window", "-w", help="Search within a specific window"),
    active: bool = typer.Option(False, "--active", "-a", help="Search within the active window"),
):
    """Get the center coordinates of an image on the screen or within a window."""
    def execute():
        region = _get_window_region(window, active)

        if not Path(image).exists():
            raise DesktopAgentError(
                code=ErrorCode.IMAGE_NOT_FOUND,
                message=f"Image file '{image}' not found",
            )

        location = pyautogui.locateCenterOnScreen(image, confidence=confidence, region=region)
        if location:
            return {"position": {"x": location.x, "y": location.y}}
        else:
            return {"image_found": False}
    _handle_command("screen.locate_center", execute)


@app.command()
def pixel(
    x: int = typer.Argument(..., help="X coordinate"),
    y: int = typer.Argument(..., help="Y coordinate"),
):
    """Get the RGB color of a pixel at specified coordinates."""
    def execute():
        color = pyautogui.pixel(x, y)
        return {
            "pixel": {
                "r": color[0],
                "g": color[1],
                "b": color[2],
                "hex": f"#{color[0]:02x}{color[1]:02x}{color[2]:02x}",
            }
        }
    _handle_command("screen.pixel", execute)


@app.command()
def size():
    """Get the screen size."""
    def execute():
        screen_size = pyautogui.size()
        return {
            "size": {
                "width": screen_size.width,
                "height": screen_size.height,
            }
        }
    _handle_command("screen.size", execute)


@app.command()
def on_screen(
    x: int = typer.Argument(..., help="X coordinate"),
    y: int = typer.Argument(..., help="Y coordinate"),
):
    """Check if coordinates are on the screen."""
    def execute():
        is_on_screen = pyautogui.onScreen(x, y)
        return {"on_screen": is_on_screen}
    _handle_command("screen.on_screen", execute)


_reader = None
_reader_langs = None


def _get_system_language() -> str:
    import locale
    try:
        system_locale = locale.getdefaultlocale()[0]
        if system_locale:
            lang_code = system_locale.split('_')[0].lower()
            return lang_code
    except Exception:
        pass
    return 'en'


def _get_default_languages() -> list[str]:
    system_lang = _get_system_language()
    if system_lang == 'en':
        return ['en']
    return [system_lang, 'en']


def get_reader(lang: Optional[list[str]] = None):
    global _reader, _reader_langs
    langs = lang or _get_default_languages()
    if _reader is None or set(langs) != set(_reader_langs or []):
        import easyocr
        _reader = easyocr.Reader(langs)
        _reader_langs = langs
    return _reader


@app.command(name="locate-text-coordinates")
def locate_text_coordinates(
    search: str = typer.Argument(..., help="Text to search for (partial match)"),
    image: Optional[str] = typer.Option(None, "--image", "-i", help="Path to image (if not provided, takes screenshot)"),
    lang: Optional[str] = typer.Option(None, "--lang", "-l", help="Languages to use (comma-separated, default: system language + en)"),
    case_sensitive: bool = typer.Option(False, "--case-sensitive", "-c", help="Case sensitive search"),
    window: Optional[str] = typer.Option(None, "--window", "-w", help="Search within a specific window"),
    active: bool = typer.Option(False, "--active", "-a", help="Search within the active window"),
):
    """Locate text coordinates on screen, within a window, or in an image using OCR."""
    def execute():
        region = _get_window_region(window, active)

        if image:
            if not Path(image).exists():
                raise DesktopAgentError(
                    code=ErrorCode.IMAGE_NOT_FOUND,
                    message=f"Image file '{image}' not found",
                )
            image_path = image
        else:
            screenshot_path = "temp_screenshot.png"
            img = pyautogui.screenshot(region=region)
            img.save(screenshot_path)
            image_path = screenshot_path

        languages = lang.split(',') if lang else None
        reader = get_reader(languages)

        results = reader.readtext(image_path)

        search_text = search if case_sensitive else search.lower()
        matches = []

        for (bbox, text, confidence) in results:
            compare_text = text if case_sensitive else text.lower()
            if search_text in compare_text:
                top_left = bbox[0]
                bottom_right = bbox[2]

                x1, y1 = int(top_left[0]), int(top_left[1])
                x2, y2 = int(bottom_right[0]), int(bottom_right[1])
                width = x2 - x1
                height = y2 - y1
                center_x = int((x1 + x2) / 2)
                center_y = int((y1 + y2) / 2)

                match = {
                    "text": text,
                    "confidence": float(confidence),
                    "bounding_box": {
                        "x": x1,
                        "y": y1,
                        "width": width,
                        "height": height,
                        "center_x": center_x,
                        "center_y": center_y,
                    },
                }
                matches.append(match)

        if not image and Path("temp_screenshot.png").exists():
            Path("temp_screenshot.png").unlink()

        return {"matches": matches}
    _handle_command("screen.locate_text_coordinates", execute)


@app.command(name="read-all-text")
def read_all_text(
    image: Optional[str] = typer.Option(None, "--image", "-i", help="Path to image (if not provided, takes screenshot)"),
    lang: Optional[str] = typer.Option(None, "--lang", "-l", help="Languages to use (comma-separated, default: system language + en)"),
    window: Optional[str] = typer.Option(None, "--window", "-w", help="Read from a specific window"),
    active: bool = typer.Option(False, "--active", "-a", help="Read from the active window"),
):
    """Read all text from screen, a targeted window, or an image using OCR."""
    def execute():
        region = _get_window_region(window, active)

        if image:
            if not Path(image).exists():
                raise DesktopAgentError(
                    code=ErrorCode.IMAGE_NOT_FOUND,
                    message=f"Image file '{image}' not found",
                )
            image_path = image
        else:
            screenshot_path = "temp_screenshot.png"
            img = pyautogui.screenshot(region=region)
            img.save(screenshot_path)
            image_path = screenshot_path

        languages = lang.split(',') if lang else None
        reader = get_reader(languages)

        results = reader.readtext(image_path)

        all_text = []
        for (bbox, text, confidence) in results:
            top_left = bbox[0]
            bottom_right = bbox[2]

            x1, y1 = int(top_left[0]), int(top_left[1])
            x2, y2 = int(bottom_right[0]), int(bottom_right[1])
            width = x2 - x1
            height = y2 - y1
            center_x = int((x1 + x2) / 2)
            center_y = int((y1 + y2) / 2)

            item = {
                "text": text,
                "confidence": float(confidence),
                "bounding_box": {
                    "x": x1,
                    "y": y1,
                    "width": width,
                    "height": height,
                    "center_x": center_x,
                    "center_y": center_y,
                },
            }
            all_text.append(item)

        if not image and Path("temp_screenshot.png").exists():
            Path("temp_screenshot.png").unlink()

        return {"text_items": all_text}
    _handle_command("screen.read_all_text", execute)


import sys

from pathlib import Path

SPECS_DIR = Path(__file__).parent

def get_schema() -> dict:
    schema_path = SPECS_DIR / "v1" / "schema.json"
    if schema_path.exists():
        import json
        return json.loads(schema_path.read_text())
    return {}

def get_version() -> str:
    return "1.0.0"

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Desktop Agent Command Response",
  "description": "Schema for all desktop-agent command responses",
  "type": "object",
  "properties": {
    "success": {
      "type": "boolean",
      "description": "Whether the command executed successfully"
    },
    "command": {
      "type": "string",
      "description": "Full command path (e.g., 'mouse.move', 'screen.screenshot')"
    },
    "timestamp": {
      "type": "string",
      "format": "date-time",
      "description": "ISO 8601 timestamp in UTC"
    },
    "duration_ms": {
      "type": "integer",
      "minimum": 0,
      "description": "Execution time in milliseconds"
    },
    "data": {
      "type": "object",
      "description": "Command-specific result data",
      "properties": {
        "x": { "type": "integer", "description": "X coordinate" },
        "y": { "type": "integer", "description": "Y coordinate" },
        "position": {
          "type": "object",
          "properties": {
            "x": { "type": "integer" },
            "y": { "type": "integer" }
          }
        },
        "size": {
          "type": "object",
          "properties": {
            "width": { "type": "integer" },
            "height": { "type": "integer" }
          }
        },
        "windows": {
          "type": "array",
          "items": { "type": "string" },
          "description": "List of window titles"
        },
        "text": { "type": "string", "description": "Extracted or input text" },
        "pixel": {
          "type": "object",
          "properties": {
            "r": { "type": "integer" },
            "g": { "type": "integer" },
            "b": { "type": "integer" },
            "hex": { "type": "string" }
          }
        },
        "message": { "type": "string", "description": "Status message" },
        "result": { "type": "string", "description": "Generic result" },
        "on_screen": { "type": "boolean", "description": "Whether coordinates are on screen" },
        "image_found": { "type": "boolean", "description": "Whether image was found" },
        "bounding_box": {
          "type": "object",
          "properties": {
            "left": { "type": "integer" },
            "top": { "type": "integer" },
            "width": { "type": "integer" },
            "height": { "type": "integer" },
            "center_x": { "type": "integer" },
            "center_y": { "type": "integer" }
          }
        }
      }
    },
    "error": {
      "type": "object",
      "description": "Error details if command failed",
      "properties": {
        "code": {
          "type": "string",
          "description": "Error code (e.g., 'invalid_argument', 'image_not_found')"
        },
        "message": {
          "type": "string",
          "description": "Human-readable error message"
        },
        "details": {
          "type": "object",
          "description": "Additional error context"
        },
        "recoverable": {
          "type": "boolean",
          "description": "Whether the error can be recovered from"
        }
      }
    }
  },
  "required": ["success", "command", "timestamp"]
}

from .errors import ErrorCode, DesktopAgentError
from .response import CommandResponse

__all__ = ["ErrorCode", "DesktopAgentError", "CommandResponse"]