macbot-cli 0.1.0__py3-none-any.whl

macbot/commands/bluetooth.py

@@ -0,0 +1,261 @@
+"""Bluetooth control commands."""
+
+import subprocess
+
+import click
+
+from ..context import pass_context
+
+
+def has_blueutil() -> bool:
+    """Check if blueutil is installed."""
+    result = subprocess.run(["which", "blueutil"], capture_output=True)
+    return result.returncode == 0
+
+
+@click.group()
+def bluetooth():
+    """Bluetooth status and control."""
+    pass
+
+
+@bluetooth.command("status")
+@pass_context
+def bluetooth_status(ctx):
+    """Get Bluetooth status.
+
+    Example:
+        macbot bluetooth status
+    """
+    if not has_blueutil():
+        ctx.error("blueutil not installed. Run: brew install blueutil")
+
+    try:
+        # Get power state
+        power_result = subprocess.run(
+            ["blueutil", "-p"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        power_on = power_result.stdout.strip() == "1"
+
+        # Get discoverable state
+        disc_result = subprocess.run(
+            ["blueutil", "-d"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        discoverable = disc_result.stdout.strip() == "1"
+
+        ctx.output({
+            "power": "on" if power_on else "off",
+            "discoverable": discoverable,
+        })
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to get Bluetooth status: {e.stderr}")
+
+
+@bluetooth.command("on")
+@pass_context
+def bluetooth_on(ctx):
+    """Turn Bluetooth on.
+
+    Example:
+        macbot bluetooth on
+    """
+    if not has_blueutil():
+        ctx.error("blueutil not installed. Run: brew install blueutil")
+
+    try:
+        subprocess.run(
+            ["blueutil", "-p", "1"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        ctx.output({"bluetooth": "on"})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to turn Bluetooth on: {e.stderr}")
+
+
+@bluetooth.command("off")
+@pass_context
+def bluetooth_off(ctx):
+    """Turn Bluetooth off.
+
+    Example:
+        macbot bluetooth off
+    """
+    if not has_blueutil():
+        ctx.error("blueutil not installed. Run: brew install blueutil")
+
+    try:
+        subprocess.run(
+            ["blueutil", "-p", "0"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        ctx.output({"bluetooth": "off"})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to turn Bluetooth off: {e.stderr}")
+
+
+@bluetooth.command("devices")
+@click.option("--paired", "-p", is_flag=True, help="Show only paired devices")
+@click.option("--connected", "-c", is_flag=True, help="Show only connected devices")
+@pass_context
+def bluetooth_devices(ctx, paired: bool, connected: bool):
+    """List Bluetooth devices.
+
+    Example:
+        macbot bluetooth devices
+        macbot bluetooth devices --paired
+        macbot bluetooth devices --connected
+    """
+    if not has_blueutil():
+        ctx.error("blueutil not installed. Run: brew install blueutil")
+
+    try:
+        if connected:
+            result = subprocess.run(
+                ["blueutil", "--connected"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        elif paired:
+            result = subprocess.run(
+                ["blueutil", "--paired"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        else:
+            result = subprocess.run(
+                ["blueutil", "--paired"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+        devices = []
+        for line in result.stdout.strip().split("\n"):
+            if line.strip():
+                # Parse: address: XX-XX-XX-XX-XX-XX, connected (paired, name: "Device Name")
+                parts = {}
+                if "address:" in line:
+                    addr_match = line.split("address:")[1].split(",")[0].strip()
+                    parts["address"] = addr_match
+                if "name:" in line:
+                    # Extract name in quotes
+                    import re
+                    name_match = re.search(r'name:\s*"([^"]*)"', line)
+                    if name_match:
+                        parts["name"] = name_match.group(1)
+                parts["connected"] = "connected" in line.lower()
+                parts["paired"] = "paired" in line.lower()
+                if parts:
+                    devices.append(parts)
+
+        ctx.output({"devices": devices, "count": len(devices)})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to list devices: {e.stderr}")
+
+
+@bluetooth.command("connect")
+@click.argument("address")
+@pass_context
+def bluetooth_connect(ctx, address: str):
+    """Connect to a Bluetooth device.
+
+    Example:
+        macbot bluetooth connect XX-XX-XX-XX-XX-XX
+    """
+    if not has_blueutil():
+        ctx.error("blueutil not installed. Run: brew install blueutil")
+
+    try:
+        subprocess.run(
+            ["blueutil", "--connect", address],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        ctx.output({"address": address, "connected": True})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to connect: {e.stderr}")
+
+
+@bluetooth.command("disconnect")
+@click.argument("address")
+@pass_context
+def bluetooth_disconnect(ctx, address: str):
+    """Disconnect a Bluetooth device.
+
+    Example:
+        macbot bluetooth disconnect XX-XX-XX-XX-XX-XX
+    """
+    if not has_blueutil():
+        ctx.error("blueutil not installed. Run: brew install blueutil")
+
+    try:
+        subprocess.run(
+            ["blueutil", "--disconnect", address],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        ctx.output({"address": address, "disconnected": True})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to disconnect: {e.stderr}")
+
+
+@bluetooth.command("pair")
+@click.argument("address")
+@pass_context
+def bluetooth_pair(ctx, address: str):
+    """Pair with a Bluetooth device.
+
+    Example:
+        macbot bluetooth pair XX-XX-XX-XX-XX-XX
+    """
+    if not has_blueutil():
+        ctx.error("blueutil not installed. Run: brew install blueutil")
+
+    try:
+        subprocess.run(
+            ["blueutil", "--pair", address],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        ctx.output({"address": address, "paired": True})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to pair: {e.stderr}")
+
+
+@bluetooth.command("unpair")
+@click.argument("address")
+@pass_context
+def bluetooth_unpair(ctx, address: str):
+    """Unpair a Bluetooth device.
+
+    Example:
+        macbot bluetooth unpair XX-XX-XX-XX-XX-XX
+    """
+    if not has_blueutil():
+        ctx.error("blueutil not installed. Run: brew install blueutil")
+
+    try:
+        subprocess.run(
+            ["blueutil", "--unpair", address],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        ctx.output({"address": address, "unpaired": True})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to unpair: {e.stderr}")

macbot/commands/brightness.py

@@ -0,0 +1,104 @@
+"""Display brightness control."""
+
+import subprocess
+
+import click
+
+from ..context import pass_context
+
+
+@click.command()
+@click.argument("level", required=False, type=float)
+@click.option("--display", "-d", type=int, help="Display number (default: all)")
+@pass_context
+def brightness(ctx, level: float | None, display: int | None):
+    """Get or set display brightness (0.0-1.0).
+
+    Example:
+        macbot brightness          # Get current brightness
+        macbot brightness 0.7      # Set to 70%
+        macbot brightness 0.5 -d 1 # Set external display
+    """
+    # Check for brightness command
+    try:
+        result = subprocess.run(
+            ["which", "brightness"],
+            capture_output=True,
+            text=True,
+        )
+        has_brightness_cli = result.returncode == 0
+    except Exception:
+        has_brightness_cli = False
+
+    if level is not None:
+        # Set brightness
+        if level < 0 or level > 1:
+            ctx.error("Brightness must be between 0.0 and 1.0")
+
+        if has_brightness_cli:
+            cmd = ["brightness", str(level)]
+            if display:
+                cmd = ["brightness", "-d", str(display), str(level)]
+            try:
+                subprocess.run(cmd, check=True, capture_output=True, text=True)
+                ctx.output({"brightness": level, "display": display, "set": True})
+            except subprocess.CalledProcessError as e:
+                ctx.error(f"Failed to set brightness: {e.stderr}")
+        else:
+            # Use AppleScript for built-in display
+            # Note: AppleScript brightness is 0-100
+            as_level = level * 100
+            script = f'''
+            tell application "System Preferences"
+                reveal anchor "displaysDisplayTab" of pane id "com.apple.preference.displays"
+            end tell
+            tell application "System Events"
+                tell process "System Preferences"
+                    set value of slider 1 of group 1 of tab group 1 of window 1 to {as_level}
+                end tell
+            end tell
+            quit application "System Preferences"
+            '''
+            # Actually, this is unreliable. Use IOKit approach
+            ctx.error("brightness CLI not installed. Run: brew install brightness")
+    else:
+        # Get brightness
+        if has_brightness_cli:
+            try:
+                result = subprocess.run(
+                    ["brightness", "-l"],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                # Parse output like "display 0: brightness 0.5"
+                displays = []
+                for line in result.stdout.strip().split("\n"):
+                    if "brightness" in line:
+                        parts = line.split("brightness")
+                        if len(parts) >= 2:
+                            try:
+                                bright = float(parts[1].strip())
+                                disp_num = 0
+                                if "display" in parts[0]:
+                                    disp_num = int(parts[0].split("display")[1].strip().rstrip(":"))
+                                displays.append({"display": disp_num, "brightness": bright})
+                            except ValueError:
+                                pass
+
+                if displays:
+                    ctx.output({"displays": displays})
+                else:
+                    ctx.error("Could not parse brightness output")
+            except subprocess.CalledProcessError as e:
+                ctx.error(f"Failed to get brightness: {e.stderr}")
+        else:
+            # Try AppleScript method for getting brightness
+            script = '''
+            tell application "System Events"
+                tell appearance preferences
+                    return 0.5
+                end tell
+            end tell
+            '''
+            ctx.error("brightness CLI not installed. Run: brew install brightness")

macbot/commands/clipboard.py

@@ -0,0 +1,75 @@
+"""Clipboard operations."""
+
+import subprocess
+
+import click
+
+from ..context import pass_context
+
+
+@click.group()
+def clipboard():
+    """Clipboard get/set operations."""
+    pass
+
+
+@clipboard.command("get")
+@pass_context
+def clipboard_get(ctx):
+    """Get current clipboard contents.
+
+    Example:
+        macbot clipboard get
+    """
+    try:
+        result = subprocess.run(
+            ["pbpaste"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        content = result.stdout
+        ctx.output({"content": content, "length": len(content)})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to read clipboard: {e.stderr}")
+
+
+@clipboard.command("set")
+@click.argument("text")
+@pass_context
+def clipboard_set(ctx, text: str):
+    """Set clipboard contents.
+
+    Example:
+        macbot clipboard set "Hello, World!"
+    """
+    try:
+        subprocess.run(
+            ["pbcopy"],
+            input=text,
+            text=True,
+            check=True,
+        )
+        ctx.output({"content": text, "length": len(text), "set": True})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to set clipboard: {e.stderr}")
+
+
+@clipboard.command("clear")
+@pass_context
+def clipboard_clear(ctx):
+    """Clear clipboard contents.
+
+    Example:
+        macbot clipboard clear
+    """
+    try:
+        subprocess.run(
+            ["pbcopy"],
+            input="",
+            text=True,
+            check=True,
+        )
+        ctx.output({"cleared": True})
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to clear clipboard: {e.stderr}")

macbot/commands/notify.py

@@ -0,0 +1,50 @@
+"""Send macOS notifications."""
+
+import subprocess
+
+import click
+
+from ..context import pass_context
+
+
+@click.command()
+@click.argument("title")
+@click.argument("message", required=False, default="")
+@click.option("--subtitle", "-s", help="Notification subtitle")
+@click.option("--sound", "-S", help="Sound name (e.g., Ping, Basso, Glass)")
+@pass_context
+def notify(ctx, title: str, message: str, subtitle: str | None, sound: str | None):
+    """Send a macOS notification.
+
+    Examples:
+        macbot notify "Build Complete" "All tests passed"
+        macbot notify "Alert" --subtitle "Warning" --sound Ping
+    """
+    # Build AppleScript
+    script_parts = [f'display notification "{message}"']
+    script_parts.append(f'with title "{title}"')
+
+    if subtitle:
+        script_parts.append(f'subtitle "{subtitle}"')
+
+    if sound:
+        script_parts.append(f'sound name "{sound}"')
+
+    script = " ".join(script_parts)
+
+    try:
+        subprocess.run(
+            ["osascript", "-e", script],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        ctx.output({
+            "title": title,
+            "message": message,
+            "subtitle": subtitle,
+            "sound": sound,
+            "sent": True,
+        })
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to send notification: {e.stderr}")

macbot/commands/say.py

@@ -0,0 +1,94 @@
+"""Text-to-speech command."""
+
+import subprocess
+
+import click
+
+from ..context import pass_context
+
+
+@click.command()
+@click.argument("text")
+@click.option("--voice", "-v", help="Voice name (e.g., Alex, Samantha, Daniel)")
+@click.option("--rate", "-r", type=int, help="Speech rate (words per minute)")
+@click.option("--output", "-o", help="Save to audio file instead of speaking")
+@click.option("--list-voices", is_flag=True, help="List available voices")
+@pass_context
+def say(
+    ctx,
+    text: str,
+    voice: str | None,
+    rate: int | None,
+    output: str | None,
+    list_voices: bool,
+):
+    """Speak text using macOS text-to-speech.
+
+    Examples:
+        macbot say "Hello, World!"
+        macbot say "British accent" --voice Daniel
+        macbot say "Fast speech" --rate 300
+        macbot say "Save this" --output speech.aiff
+        macbot say "" --list-voices
+    """
+    if list_voices:
+        try:
+            result = subprocess.run(
+                ["say", "-v", "?"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            voices = []
+            for line in result.stdout.strip().split("\n"):
+                if line.strip():
+                    # Parse: "Voice Name    lang  # description"
+                    parts = line.split()
+                    if len(parts) >= 2:
+                        # Voice name may have spaces, lang is before #
+                        name_parts = []
+                        lang = None
+                        for i, part in enumerate(parts):
+                            if part.startswith("#"):
+                                break
+                            if "_" in part or len(part) == 5:  # Language codes like en_US
+                                lang = part
+                                break
+                            name_parts.append(part)
+                        voices.append({
+                            "name": " ".join(name_parts),
+                            "language": lang,
+                        })
+            ctx.output({"voices": voices, "count": len(voices)})
+            return
+        except subprocess.CalledProcessError as e:
+            ctx.error(f"Failed to list voices: {e.stderr}")
+
+    cmd = ["say"]
+
+    if voice:
+        cmd.extend(["-v", voice])
+
+    if rate:
+        cmd.extend(["-r", str(rate)])
+
+    if output:
+        cmd.extend(["-o", output])
+
+    cmd.append(text)
+
+    try:
+        subprocess.run(cmd, check=True, capture_output=True, text=True)
+        result = {
+            "text": text,
+            "voice": voice,
+            "rate": rate,
+            "spoken": True,
+        }
+        if output:
+            result["output"] = output
+            result["spoken"] = False
+            result["saved"] = True
+        ctx.output(result)
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to speak: {e.stderr}")

macbot/commands/screenshot.py

@@ -0,0 +1,109 @@
+"""Screenshot commands."""
+
+import subprocess
+import os
+from datetime import datetime
+
+import click
+
+from ..context import pass_context
+
+
+@click.command()
+@click.argument("output", required=False)
+@click.option("--clipboard", "-c", is_flag=True, help="Copy to clipboard instead of file")
+@click.option("--window", "-w", is_flag=True, help="Capture front window only")
+@click.option("--interactive", "-i", is_flag=True, help="Interactive selection mode")
+@click.option("--screen", "-s", type=int, help="Capture specific screen (1, 2, ...)")
+@click.option("--delay", "-d", type=int, help="Delay in seconds before capture")
+@click.option("--no-shadow", is_flag=True, help="Disable window shadow")
+@pass_context
+def screenshot(
+    ctx,
+    output: str | None,
+    clipboard: bool,
+    window: bool,
+    interactive: bool,
+    screen: int | None,
+    delay: int | None,
+    no_shadow: bool,
+):
+    """Take a screenshot.
+
+    Examples:
+        macbot screenshot                     # Save to desktop with timestamp
+        macbot screenshot screen.png          # Save to specific file
+        macbot screenshot --clipboard         # Copy to clipboard
+        macbot screenshot --window            # Capture front window
+        macbot screenshot --interactive       # Select region
+        macbot screenshot --delay 3           # 3 second delay
+    """
+    cmd = ["screencapture"]
+
+    # Silent mode (no camera sound)
+    cmd.append("-x")
+
+    if clipboard:
+        cmd.append("-c")
+    else:
+        if output is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            desktop = os.path.expanduser("~/Desktop")
+            output = os.path.join(desktop, f"screenshot_{timestamp}.png")
+
+    if window:
+        cmd.append("-l")
+        # Get front window ID
+        script = '''
+        tell application "System Events"
+            set frontApp to first application process whose frontmost is true
+            set frontWindow to front window of frontApp
+            return id of frontWindow
+        end tell
+        '''
+        try:
+            result = subprocess.run(
+                ["osascript", "-e", script],
+                capture_output=True,
+                text=True,
+            )
+            window_id = result.stdout.strip()
+            if window_id:
+                cmd.append(window_id)
+        except Exception:
+            # Fall back to interactive window selection
+            cmd = ["screencapture", "-x", "-w"]
+
+    if interactive:
+        cmd.append("-i")
+
+    if screen:
+        cmd.extend(["-D", str(screen)])
+
+    if delay:
+        cmd.extend(["-T", str(delay)])
+
+    if no_shadow:
+        cmd.append("-o")
+
+    if not clipboard and output:
+        cmd.append(output)
+
+    try:
+        subprocess.run(cmd, check=True, capture_output=True, text=True)
+
+        result = {
+            "captured": True,
+            "clipboard": clipboard,
+            "window": window,
+            "interactive": interactive,
+        }
+        if output and not clipboard:
+            result["path"] = output
+            result["exists"] = os.path.exists(output)
+            if result["exists"]:
+                result["size"] = os.path.getsize(output)
+
+        ctx.output(result)
+    except subprocess.CalledProcessError as e:
+        ctx.error(f"Failed to capture screenshot: {e.stderr}")