agent2win 1.0.0__py3-none-any.whl

agent2win/__init__.py

@@ -0,0 +1,3 @@
+# agent2win - Universal Bridge Between Web/Cloud AI Agents & Windows OS
+__version__ = "1.0.0"
+__author__ = "agent2win"

agent2win/audio.py

@@ -0,0 +1,160 @@
+"""
+Windows Arena AI — Audio Control
+Control system volume, mute, and audio devices.
+"""
+import subprocess
+import ctypes
+from typing import Optional
+from .config import Settings
+from .logger import audit_log
+
+try:
+    from pycaw.pycaw import AudioUtilities, IAudioEndpointVolume
+    from comtypes import CLSCTX_ALL, CoCreateInstance
+    from ctypes import POINTER
+    HAS_PYCAW = True
+except ImportError:
+    HAS_PYCAW = False
+
+
+class AudioController:
+    """System audio control."""
+
+    def __init__(self, settings: Settings, logger):
+        self.settings = settings
+        self.logger = logger
+        self._volume_interface = None
+
+    def _get_volume_interface(self):
+        if self._volume_interface is None and HAS_PYCAW:
+            try:
+                devices = AudioUtilities.GetSpeakers()
+                interface = devices.Activate(IAudioEndpointVolume._iid_, CLSCTX_ALL, None)
+                self._volume_interface = interface.QueryInterface(POINTER(IAudioEndpointVolume))
+            except Exception:
+                pass
+        return self._volume_interface
+
+    async def get_volume(self) -> dict:
+        """Get current system volume (0-100)."""
+        audit_log(self.settings, "get_volume", {})
+        if HAS_PYCAW:
+            try:
+                vol = self._get_volume_interface()
+                if vol:
+                    level = vol.GetMasterVolumeLevelScalar()
+                    muted = vol.GetMute()
+                    return {"success": True, "volume": round(level * 100), "muted": bool(muted), "level_scalar": round(level, 3)}
+            except Exception as e:
+                pass
+
+        # Fallback: nircmd or PowerShell
+        try:
+            result = subprocess.run(
+                ["powershell", "-command",
+                 "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('')"],
+                capture_output=True, text=True, timeout=5,
+                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
+            )
+            return {"success": True, "note": "Install pycaw for precise volume control: pip install pycaw"}
+        except Exception:
+            return {"success": False, "error": "Install pycaw: pip install pycaw"}
+
+    async def set_volume(self, level: int) -> dict:
+        """Set system volume (0-100)."""
+        audit_log(self.settings, "set_volume", {"level": level})
+        level = max(0, min(100, level))
+
+        if HAS_PYCAW:
+            try:
+                vol = self._get_volume_interface()
+                if vol:
+                    vol.SetMasterVolumeLevelScalar(level / 100.0, None)
+                    return {"success": True, "volume": level}
+            except Exception:
+                pass
+
+        # Fallback: nircmd
+        try:
+            vol_val = int(level * 65535 / 100)
+            subprocess.run(
+                ["nircmd", "setsysvolume", str(vol_val)],
+                capture_output=True, timeout=5,
+                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
+            )
+            return {"success": True, "volume": level, "method": "nircmd"}
+        except Exception:
+            return {"success": False, "error": "Install pycaw: pip install pycaw"}
+
+    async def mute(self) -> dict:
+        """Mute system audio."""
+        audit_log(self.settings, "mute", {})
+        if HAS_PYCAW:
+            try:
+                vol = self._get_volume_interface()
+                if vol:
+                    vol.SetMute(True, None)
+                    return {"success": True, "muted": True}
+            except Exception:
+                pass
+        return {"success": False, "error": "Install pycaw: pip install pycaw"}
+
+    async def unmute(self) -> dict:
+        """Unmute system audio."""
+        audit_log(self.settings, "unmute", {})
+        if HAS_PYCAW:
+            try:
+                vol = self._get_volume_interface()
+                if vol:
+                    vol.SetMute(False, None)
+                    return {"success": True, "muted": False}
+            except Exception:
+                pass
+        return {"success": False, "error": "Install pycaw: pip install pycaw"}
+
+    async def toggle_mute(self) -> dict:
+        """Toggle mute state."""
+        if HAS_PYCAW:
+            try:
+                vol = self._get_volume_interface()
+                if vol:
+                    current = vol.GetMute()
+                    vol.SetMute(not current, None)
+                    return {"success": True, "muted": not bool(current)}
+            except Exception:
+                pass
+        return {"success": False, "error": "Install pycaw: pip install pycaw"}
+
+    async def volume_up(self, step: int = 5) -> dict:
+        """Increase volume by step."""
+        current = await self.get_volume()
+        if current.get("success"):
+            new_level = min(100, current["volume"] + step)
+            return await self.set_volume(new_level)
+        return current
+
+    async def volume_down(self, step: int = 5) -> dict:
+        """Decrease volume by step."""
+        current = await self.get_volume()
+        if current.get("success"):
+            new_level = max(0, current["volume"] - step)
+            return await self.set_volume(new_level)
+        return current
+
+    async def list_devices(self) -> dict:
+        """List audio devices."""
+        audit_log(self.settings, "list_audio_devices", {})
+        if HAS_PYCAW:
+            try:
+                devices = AudioUtilities.GetAllDevices()
+                result = []
+                for d in devices:
+                    result.append({
+                        "id": str(d.id) if d.id else "",
+                        "name": str(d.FriendlyName) if d.FriendlyName else "",
+                        "state": str(d.State) if d.State else "",
+                    })
+                return {"success": True, "devices": result, "count": len(result)}
+            except Exception as e:
+                return {"success": False, "error": str(e)}
+        return {"success": False, "error": "Install pycaw: pip install pycaw"}

agent2win/cli.py

@@ -0,0 +1,113 @@
+"""
+agent2win — CLI Entry Point for PyPI package
+"""
+import asyncio
+import argparse
+import sys
+import os
+
+from .config import Settings
+from .server import ArenaServer
+from .tray import TrayApp
+from .gui import SettingsGUI
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="agent2win — Universal Bridge Between Web/Cloud AI Agents & Windows OS",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  agent2win                              Start server on port 7770
+  agent2win --port 8080 --key abc        Custom port with API key
+  agent2win --unrestricted               No approval prompts (⚠️ use carefully)
+  agent2win --settings                   Open settings GUI
+  agent2win --tunnel cloudflared         Use Cloudflare tunnel
+  agent2win --tunnel ngrok               Use ngrok tunnel
+  agent2win --no-tunnel                  Disable tunnels
+        """,
+    )
+    parser.add_argument("--port", type=int, help="Server port (default: 7770)")
+    parser.add_argument("--host", type=str, help="Bind address (default: 0.0.0.0)")
+    parser.add_argument("--key", type=str, help="API key for authentication")
+    parser.add_argument("--unrestricted", action="store_true", help="Enable unrestricted mode (no approval prompts)")
+    parser.add_argument("--no-tray", action="store_true", help="Don't show system tray icon")
+    parser.add_argument("--no-tunnel", action="store_true", help="Disable tunnel")
+    parser.add_argument("--tunnel", type=str, choices=["cloudflared", "ngrok"], help="Tunnel provider")
+    parser.add_argument("--settings", action="store_true", help="Open settings GUI and exit")
+    parser.add_argument("--config", type=str, help="Path to config file")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    # Load settings
+    settings = Settings.load()
+
+    # Apply CLI overrides
+    if args.port:
+        settings.port = args.port
+    if args.host:
+        settings.host = args.host
+    if args.key:
+        settings.api_key = args.key
+    if args.unrestricted:
+        settings.unrestricted_mode = True
+    if args.no_tunnel:
+        settings.tunnel_provider = "none"
+    if args.tunnel:
+        settings.tunnel_provider = args.tunnel
+
+    settings.save()
+
+    # Settings GUI mode
+    if args.settings:
+        gui = SettingsGUI(settings)
+        gui.show()
+        return
+
+    # Print banner
+    print(r"""
+    ╔═══════════════════════════════════════════════════════╗
+    ║         🚀  agent2win  v1.0.0                         ║
+    ║  Bridge Web/Cloud AI (ChatGPT, Gemini, Grok) to Win   ║
+    ╠═══════════════════════════════════════════════════════╣
+    ║  Server:  http://0.0.0.0:{port:<5}                      ║
+    ║  Mode:    {mode:<20}                   ║
+    ║  Tunnel:  {tunnel:<20}                   ║
+    ╚═══════════════════════════════════════════════════════╝
+    """.format(
+        port=settings.port,
+        mode="UNRESTRICTED ⚠️" if settings.unrestricted_mode else "SECURE 🔒",
+        tunnel=settings.tunnel_provider,
+    ))
+
+    server = ArenaServer(settings)
+
+    # Start system tray
+    tray = None
+    if not args.no_tray:
+        try:
+            tray = TrayApp(settings, server.notifications, settings.port)
+            tray.start()
+            print("  ✅ System tray icon active")
+        except Exception as e:
+            print(f"  ⚠️ System tray unavailable: {e}")
+
+    # Start server
+    print(f"  🚀 Starting server on port {settings.port}...")
+    print(f"  📖 Open http://localhost:{settings.port} for API docs")
+    print(f"  ⏹️  Press Ctrl+C to stop\n")
+
+    try:
+        asyncio.run(server.start())
+    except KeyboardInterrupt:
+        print("\n  👋 Shutting down...")
+    finally:
+        if tray:
+            tray.stop()
+
+
+if __name__ == "__main__":
+    main()

agent2win/clipboard.py

@@ -0,0 +1,90 @@
+"""
+Windows Arena AI — Clipboard Manager
+Read and write the system clipboard (text, images).
+"""
+import subprocess
+import time
+from typing import Optional
+from .config import Settings
+from .logger import audit_log
+
+try:
+    import pyperclip
+    HAS_PYPERCLIP = True
+except ImportError:
+    HAS_PYPERCLIP = False
+
+
+class ClipboardManager:
+    """System clipboard operations."""
+
+    def __init__(self, settings: Settings, logger):
+        self.settings = settings
+        self.logger = logger
+
+    async def get_text(self) -> dict:
+        """Get current clipboard text."""
+        audit_log(self.settings, "clipboard_get", {})
+        if HAS_PYPERCLIP:
+            try:
+                text = pyperclip.paste()
+                return {"success": True, "text": text, "length": len(text)}
+            except Exception as e:
+                return {"success": False, "error": str(e)}
+
+        # Fallback: PowerShell
+        try:
+            result = subprocess.run(
+                ["powershell", "-command", "Get-Clipboard"],
+                capture_output=True, text=True, timeout=5,
+                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
+            )
+            return {"success": True, "text": result.stdout.strip(), "length": len(result.stdout.strip())}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    async def set_text(self, text: str) -> dict:
+        """Set clipboard text."""
+        audit_log(self.settings, "clipboard_set", {"length": len(text)})
+        if HAS_PYPERCLIP:
+            try:
+                pyperclip.copy(text)
+                return {"success": True, "text_length": len(text)}
+            except Exception as e:
+                return {"success": False, "error": str(e)}
+
+        try:
+            subprocess.run(
+                ["powershell", "-command", f'Set-Clipboard -Value @"\\n{text}\\n"@'],
+                capture_output=True, text=True, timeout=5,
+                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
+            )
+            return {"success": True, "text_length": len(text)}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    async def get_history(self) -> dict:
+        """Get clipboard history (Windows 10+)."""
+        audit_log(self.settings, "clipboard_history", {})
+        try:
+            result = subprocess.run(
+                ["powershell", "-command", "Get-Clipboard -TextFormatType Text"],
+                capture_output=True, text=True, timeout=5,
+                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
+            )
+            return {"success": True, "history": result.stdout.strip()}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    async def clear(self) -> dict:
+        """Clear the clipboard."""
+        audit_log(self.settings, "clipboard_clear", {})
+        try:
+            subprocess.run(
+                ["powershell", "-command", "Clear-Clipboard"],
+                capture_output=True, text=True, timeout=5,
+                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
+            )
+            return {"success": True}
+        except Exception as e:
+            return {"success": False, "error": str(e)}

agent2win/commands.py

@@ -0,0 +1,89 @@
+"""
+Windows Arena AI — Command Execution Engine
+Runs shell commands with safety checks, timeouts, and approval flow.
+"""
+import subprocess
+import shlex
+import time
+import threading
+from typing import Optional
+from .config import Settings
+from .logger import audit_log
+
+class CommandEngine:
+    def __init__(self, settings: Settings, logger, approval_callback=None):
+        self.settings = settings
+        self.logger = logger
+        self.approval_callback = approval_callback  # async fn(action, details) -> bool
+
+    def _is_blocked(self, cmd: str) -> bool:
+        cmd_lower = cmd.lower().strip()
+        for blocked in self.settings.blocked_commands:
+            if blocked.lower() in cmd_lower:
+                return True
+        return False
+
+    def _needs_approval(self, cmd: str) -> bool:
+        if self.settings.unrestricted_mode:
+            return False
+        if not self.settings.require_approval:
+            return False
+        cmd_lower = cmd.lower().strip()
+        # Known safe read-only commands pass without approval
+        safe_prefixes = ("dir", "cd", "echo", "whoami", "hostname", "ipconfig",
+                         "systeminfo", "tasklist", "where", "type", "tree",
+                         "netstat", "ping", "tracert", "ver", "date", "time")
+        for safe in safe_prefixes:
+            if cmd_lower.startswith(safe):
+                return False
+        return True
+
+    async def execute(self, cmd: str, cwd: Optional[str] = None, timeout: Optional[int] = None) -> dict:
+        """
+        Execute a Windows command. Returns dict with:
+          success, stdout, stderr, returncode, duration_sec, approved
+        """
+        if self._is_blocked(cmd):
+            audit_log(self.settings, "command_blocked", {"cmd": cmd}, approved=False)
+            return {"success": False, "error": f"Command blocked by security policy: {cmd}", "stdout": "", "stderr": "", "returncode": -1}
+
+        approved = True
+        if self._needs_approval(cmd):
+            if self.approval_callback:
+                approved = await self.approval_callback("command", {"cmd": cmd, "cwd": cwd})
+            else:
+                approved = False
+            if not approved:
+                audit_log(self.settings, "command_denied", {"cmd": cmd}, approved=False)
+                return {"success": False, "error": "Command denied by user", "stdout": "", "stderr": "", "returncode": -1}
+
+        audit_log(self.settings, "command_executed", {"cmd": cmd, "cwd": cwd}, approved=True)
+        self.logger.info(f"Executing: {cmd}")
+
+        effective_timeout = timeout or self.settings.max_command_timeout_sec
+        t0 = time.time()
+
+        try:
+            proc = subprocess.run(
+                cmd,
+                shell=True,
+                capture_output=True,
+                text=True,
+                cwd=cwd,
+                timeout=effective_timeout,
+                encoding="utf-8",
+                errors="replace",
+            )
+            duration = round(time.time() - t0, 3)
+            return {
+                "success": proc.returncode == 0,
+                "stdout": proc.stdout,
+                "stderr": proc.stderr,
+                "returncode": proc.returncode,
+                "duration_sec": duration,
+                "approved": approved,
+            }
+        except subprocess.TimeoutExpired:
+            return {"success": False, "error": f"Command timed out after {effective_timeout}s", "stdout": "", "stderr": "", "returncode": -1}
+        except Exception as e:
+            return {"success": False, "error": str(e), "stdout": "", "stderr": "", "returncode": -1}

agent2win/config.py

@@ -0,0 +1,64 @@
+"""
+agent2win — Configuration & Settings Manager
+"""
+import json
+import os
+from pathlib import Path
+from dataclasses import dataclass, field, asdict
+from typing import Optional
+
+CONFIG_DIR = Path(os.environ.get("APPDATA", "~")) / "agent2win"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+@dataclass
+class Settings:
+    # Server
+    host: str = "0.0.0.0"
+    port: int = 7770
+    api_key: str = ""
+    auto_start: bool = False
+
+    # Security
+    unrestricted_mode: bool = False          # True = no approval prompts
+    require_approval: bool = True            # Show notification before actions
+    approval_timeout_sec: int = 60           # Auto-deny after timeout
+    allowed_commands: list = field(default_factory=lambda: ["dir", "cd", "type", "echo", "whoami", "hostname", "ipconfig", "systeminfo", "tasklist", "where"])
+    blocked_commands: list = field(default_factory=lambda: ["format", "del /s", "rd /s", "reg delete", "bcdedit"])
+    max_command_timeout_sec: int = 30
+
+    # Screen
+    screen_capture_fps: int = 2              # Frames per second for live view
+    screen_quality: int = 60                 # JPEG quality 1-100
+    screen_scale: float = 0.75               # Downscale factor
+
+    # Tunnel
+    tunnel_provider: str = "cloudflared"     # cloudflared | ngrok | none
+    tunnel_custom_url: str = ""              # If you have your own tunnel
+
+    # Logging
+    log_file: str = str(CONFIG_DIR / "agent2win.log")
+    log_level: str = "INFO"
+    audit_log: str = str(CONFIG_DIR / "audit.jsonl")
+
+    def save(self):
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(json.dumps(asdict(self), indent=2, ensure_ascii=False), encoding="utf-8")
+
+    @classmethod
+    def load(cls) -> "Settings":
+        if CONFIG_FILE.exists():
+            try:
+                data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+                known = {f.name for f in cls.__dataclass_fields__.values()}
+                return cls(**{k: v for k, v in data.items() if k in known})
+            except Exception:
+                pass
+        s = cls()
+        s.save()
+        return s
+
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if hasattr(self, k):
+                setattr(self, k, v)
+        self.save()