computer-use-ootb-internal 0.0.111__py3-none-any.whl → 0.0.113__py3-none-any.whl

computer_use_ootb_internal/app_teachmode.py

@@ -8,6 +8,9 @@ import platform  # Add platform import
 import pyautogui  # Add pyautogui import
 import webbrowser # Add webbrowser import
 import os # Import os for path joining
+import logging # Import logging
+import importlib # For dynamic imports
+import pkgutil # To find modules
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
@@ -90,68 +93,47 @@ class SharedState:
 shared_state = None
 rate_limiter = RateLimiter(interval_seconds=2)
 
-# Add the new prepare_environment function here
+# Set up logging for this module
+log = logging.getLogger(__name__)
+
 def prepare_environment(state):
-    """Prepares the environment before starting the main processing loop, e.g., opening specific apps."""
-    if platform.system() == "Windows":
-        # Assuming Star Rail mode is indicated by user_id containing "star_rail"
-        # You might need to adjust this condition based on the actual logic in run_teachmode_args
-        is_star_rail = "star_rail" in state.user_id.lower() or \
-                       "star_rail" in state.trace_id.lower() or \
-                       "hero_case" in state.user_id.lower() or \
-                       "hero_case" in state.trace_id.lower()
-        
-        if is_star_rail:
-            print("Star Rail mode detected on Windows. Opening Edge browser...")
-            url = "https://sr.mihoyo.com/cloud/#/"
-            browser_opened = False
-            try:
-                # Use only webbrowser.open
-                print(f"Attempting to open {url} using webbrowser.open()...")
-                if webbrowser.open(url):
-                    print(f"Successfully requested browser to open {url} via webbrowser.open().")
-                    browser_opened = True
-                else:
-                    print("webbrowser.open() returned False, indicating potential failure.")
-
-                if not browser_opened:
-                    print("ERROR: Failed to confirm browser opening via webbrowser.open().")
-                    # Still proceed to click attempt
-
-                # Add pyautogui click after attempting to open the browser
-                print("Proceeding with pyautogui actions...")
-                time.sleep(5) # Wait time for the browser to load
-                
-                # Print detected screen size
-                screen_width, screen_height = pyautogui.size()
-                print(f"Detected screen size: {screen_width}x{screen_height}")
-
-                click_x = int(screen_width * (1036 / 1280))
-                click_y = int(screen_height * (500 / 720))
-                print(f"Calculated click coordinates: ({click_x}, {click_y})")
-
-                # Disable failsafe before clicking
-                pyautogui.FAILSAFE = False
-                print("PyAutoGUI failsafe temporarily disabled.")
-
-                print(f"Clicking at coordinates: ({click_x}, {click_y})")
-                pyautogui.click(click_x, click_y)
-                time.sleep(2)
-                pyautogui.click(click_x, click_y)
-                
-                # Re-enable failsafe (optional, as script might end anyway)
-                # pyautogui.FAILSAFE = True 
-                # print("PyAutoGUI failsafe re-enabled.")
-
-            except Exception as e:
-                print(f"Error during environment preparation (browser/click): {e}")
-            finally:
-                 # Ensure failsafe is re-enabled if an error occurs after disabling it
-                 pyautogui.FAILSAFE = True
-                 print("PyAutoGUI failsafe re-enabled.")
-    else:
-        # Placeholder for potential preparations on other OS or non-Star Rail modes
-        print("Environment preparation: No specific actions required for this OS/mode.")
+    """Dynamically loads and runs preparation logic based on software name."""
+    # TODO: Replace hardcoded software name with value from shared_state when available
+    software_name = "star rail"
+    # Normalize the software name to be a valid Python module name
+    # Replace spaces/hyphens with underscores, convert to lowercase
+    module_name_base = software_name.replace(" ", "_").replace("-", "_").lower()
+    module_to_run = f"{module_name_base}_prepare"
+
+    log.info(f"Attempting preparation for software: '{software_name}' (Module: '{module_to_run}')")
+
+    try:
+        # Construct the full module path within the package
+        prep_package = "computer_use_ootb_internal.preparation"
+        full_module_path = f"{prep_package}.{module_to_run}"
+
+        # Dynamically import the module
+        # Check if module exists first using pkgutil to avoid import errors
+        # Note: pkgutil.find_loader might be deprecated, consider importlib.util.find_spec
+        loader = pkgutil.find_loader(full_module_path)
+        if loader is None:
+            log.warning(f"Preparation module '{full_module_path}' not found. Skipping preparation.")
+            return
+
+        prep_module = importlib.import_module(full_module_path)
+
+        # Check if the module has the expected function
+        if hasattr(prep_module, "run_preparation") and callable(prep_module.run_preparation):
+            log.info(f"Running preparation function from {full_module_path}...")
+            prep_module.run_preparation(state)
+            log.info(f"Preparation function from {full_module_path} completed.")
+        else:
+            log.warning(f"Module {full_module_path} found, but does not have a callable 'run_preparation' function. Skipping.")
+
+    except ModuleNotFoundError:
+        log.warning(f"Preparation module '{full_module_path}' not found. Skipping preparation.")
+    except Exception as e:
+        log.error(f"Error during dynamic preparation loading/execution for '{module_to_run}': {e}", exc_info=True)
 
 
 @app.post("/update_params")
@@ -178,7 +160,7 @@ async def update_parameters(request: Request):
     
     log_ootb_request(shared_state.server_url, "update_params", data)
 
-    # Call the preparation function here, after parameters are updated
+    # Call the (now dynamic) preparation function here, after parameters are updated
     prepare_environment(shared_state)
 
     return JSONResponse(

computer_use_ootb_internal/guard_service.py

@@ -6,7 +6,9 @@ import logging
 import subprocess
 import pathlib
 import ctypes
-import requests # For server polling
+import threading # For running server thread
+import queue # For queuing commands
+import requests # Keep for status reporting back
 import servicemanager # From pywin32
 import win32serviceutil # From pywin32
 import win32service # From pywin32
@@ -16,48 +18,81 @@ import win32process # From pywin32
 import win32security # From pywin32
 import win32profile # From pywin32
 import win32ts # From pywin32 (Terminal Services API)
-import win32con # Added import
+import win32con
 import psutil # For process/user info
+from flask import Flask, request, jsonify # For embedded server
+from waitress import serve # For serving Flask app
 
 # --- Configuration ---
-# Internal service name
 _SERVICE_NAME = "OOTBGuardService"
-# Display name in Windows Services MMC
 _SERVICE_DISPLAY_NAME = "OOTB Guard Service"
-# Description in Windows Services MMC
-_SERVICE_DESCRIPTION = "Background service for OOTB monitoring and remote management."
-# Package name for updates
+_SERVICE_DESCRIPTION = "Background service for OOTB monitoring and remote management (Server POST mode)."
 _PACKAGE_NAME = "computer-use-ootb-internal"
-# Main module to start/stop for users
 _OOTB_MODULE = "computer_use_ootb_internal.app_teachmode"
-# Server endpoint to poll for commands (replace with your actual URL)
-_SERVER_COMMAND_URL = "https://52.160.105.102/api/guard/commands" # EXAMPLE URL - Verify protocol/port/path
-# How often to poll the server (in seconds)
-_POLLING_INTERVAL = 60
-# Placeholder for a machine identifier or API key for the server
-_MACHINE_ID = "YOUR_MACHINE_ID_OR_API_KEY" # EXAMPLE - Implement actual ID/auth
-# Log file location (consider using Windows Event Log instead for production)
-_LOG_FILE = pathlib.Path(os.environ['PROGRAMDATA']) / "OOTBGuardService" / "guard.log"
+# --- Server POST Configuration ---
+_LISTEN_HOST = "0.0.0.0" # Listen on all interfaces
+_LISTEN_PORT = 7001 # Port for server to POST commands TO
+# _SHARED_SECRET = "YOUR_SECRET_HERE" # !! REMOVED !! - No secret check implemented now
+# --- End Server POST Configuration ---
+_SERVER_STATUS_REPORT_URL = "http://52.160.105.102:7000/api/guard/status" # URL to POST status back TO
+_LOG_FILE = pathlib.Path(os.environ['PROGRAMDATA']) / "OOTBGuardService" / "guard_post_mode.log" # Different log file
 # --- End Configuration ---
 
-# Ensure log directory exists
 _LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
-
 logging.basicConfig(
     filename=_LOG_FILE,
     level=logging.INFO,
-    format='%(asctime)s %(levelname)s %(message)s'
+    format='%(asctime)s %(levelname)s:%(name)s:%(threadName)s: %(message)s'
 )
 
+# --- Global service instance reference (needed for Flask routes) ---
+_service_instance = None
+
+# --- Flask App Definition ---
+flask_app = Flask(__name__)
+
+@flask_app.route('/command', methods=['POST'])
+def receive_command():
+    global _service_instance
+    if not _service_instance:
+        logging.error("Received command but service instance is not set.")
+        return jsonify({"error": "Service not ready"}), 503
+
+    # --- Authentication REMOVED ---
+    # secret = request.headers.get('X-Guard-Secret')
+    # if not secret or secret != _SHARED_SECRET:
+    #     logging.warning(f"Unauthorized command POST received (Invalid/Missing X-Guard-Secret). Remote Addr: {request.remote_addr}")
+    #     return jsonify({"error": "Unauthorized"}), 403
+    # --- End Authentication REMOVED ---
+
+    if not request.is_json:
+        logging.warning("Received non-JSON command POST.")
+        return jsonify({"error": "Request must be JSON"}), 400
+
+    command = request.get_json()
+    logging.info(f"Received command via POST: {command}")
+
+    # Basic validation
+    action = command.get("action")
+    command_id = command.get("command_id", "N/A") # Use for status reporting
+    if not action:
+         logging.error(f"Received command POST with no action: {command}")
+         return jsonify({"error": "Missing 'action' in command"}), 400
+
+    # Queue the command for processing in a background thread
+    _service_instance.command_queue.put((command_id, command))
+    logging.info(f"Queued command {command_id} ({action}) for processing.")
+
+    return jsonify({"message": f"Command {command_id} received and queued"}), 202 # Accepted
+
+# --- Helper Functions --- Only logging helpers needed adjustments
 def get_python_executable():
-    """Gets the quoted path to the current python executable."""
     python_exe = sys.executable
     if " " in python_exe and not python_exe.startswith('"'):
         python_exe = f'"{python_exe}"'
     return python_exe
 
 def get_pip_executable():
-    """Tries to locate the pip executable in the same environment."""
     python_path = pathlib.Path(sys.executable)
     pip_path = python_path.parent / "Scripts" / "pip.exe"
     if pip_path.exists():
@@ -70,16 +105,25 @@ def get_pip_executable():
         return f"{get_python_executable()} -m pip"
 
 def log_info(msg):
-    logging.info(msg)
+    thread_name = threading.current_thread().name
+    full_msg = f"[{thread_name}] {msg}"
+    logging.info(full_msg)
     try:
-        servicemanager.LogInfoMsg(str(msg)) # Also log to Windows Event Log Application channel
+        # Only log to event log from main service thread or known non-daemon threads if possible
+        # Trying from waitress/flask threads might cause issues.
+        # For simplicity, maybe remove event log integration or make it conditional.
+        if threading.current_thread().name in ["MainThread", "CommandProcessor"]: # Example condition
+             servicemanager.LogInfoMsg(str(full_msg))
     except Exception as e:
-        logging.warning(f"Could not write to Windows Event Log: {e}") # Avoid crashing service if event log fails
+        logging.warning(f"Could not write info to Windows Event Log: {e}")
 
 def log_error(msg, exc_info=False):
-    logging.error(msg, exc_info=exc_info)
+    thread_name = threading.current_thread().name
+    full_msg = f"[{thread_name}] {msg}"
+    logging.error(full_msg, exc_info=exc_info)
     try:
-        servicemanager.LogErrorMsg(str(msg))
+        if threading.current_thread().name in ["MainThread", "CommandProcessor"]:
+            servicemanager.LogErrorMsg(str(full_msg))
     except Exception as e:
         logging.warning(f"Could not write error to Windows Event Log: {e}")
 
@@ -89,67 +133,92 @@ class GuardService(win32serviceutil.ServiceFramework):
     _svc_description_ = _SERVICE_DESCRIPTION
 
     def __init__(self, args):
+        global _service_instance
         win32serviceutil.ServiceFramework.__init__(self, args)
         self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
         self.is_running = True
+        self.server_thread = None
+        self.command_queue = queue.Queue()
+        self.command_processor_thread = None
+        self.session = requests.Session() # For status reporting
+
         self.python_exe = get_python_executable()
         self.pip_command_base = get_pip_executable()
         self.ootb_command = f"{self.python_exe} -m {_OOTB_MODULE}"
-        self.session = requests.Session() # Reuse session for polling
+        _service_instance = self # Set global reference
 
     def SvcStop(self):
+        log_info(f"Service stop requested.")
         self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
-        win32event.SetEvent(self.hWaitStop)
         self.is_running = False
-        log_info(f"{_SERVICE_NAME} is stopping.")
+        # Signal the command processor thread to stop
+        self.command_queue.put(None) # Sentinel value
+        # Signal the main wait loop
+        win32event.SetEvent(self.hWaitStop)
+        # Stopping waitress gracefully from another thread is non-trivial.
+        # We rely on the SCM timeout / process termination for now.
+        log_info(f"{_SERVICE_NAME} SvcStop: Stop signaled. Server thread will be terminated by SCM.")
+
 
     def SvcDoRun(self):
         servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,
                               servicemanager.PYS_SERVICE_STARTED,
                               (self._svc_name_, ''))
-        self.main_loop()
-        # If main_loop exits cleanly (shouldn't happen with while self.is_running)
-        log_info(f"{_SERVICE_NAME} main loop exited.")
+        try:
+            log_info(f"{_SERVICE_NAME} starting.")
+            # Start the command processor thread
+            self.command_processor_thread = threading.Thread(
+                target=self.process_commands, name="CommandProcessor", daemon=True)
+            self.command_processor_thread.start()
+            log_info("Command processor thread started.")
+
+            # Start the Flask server (via Waitress) in a separate thread
+            self.server_thread = threading.Thread(
+                target=self.run_server, name="WebServerThread", daemon=True)
+            self.server_thread.start()
+            log_info(f"Web server thread started, listening on {_LISTEN_HOST}:{_LISTEN_PORT}.")
+
+            log_info(f"{_SERVICE_NAME} running. Waiting for stop signal.")
+            # Keep the main service thread alive waiting for stop signal
+            win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
+            log_info(f"{_SERVICE_NAME} received stop signal in main thread.")
 
+        except Exception as e:
+            log_error(f"Fatal error in SvcDoRun: {e}", exc_info=True)
+            self.SvcStop() # Signal stop if possible
+        finally:
+            log_info(f"{_SERVICE_NAME} SvcDoRun finished.")
 
-    def main_loop(self):
-        log_info(f"{_SERVICE_NAME} started. Polling {_SERVER_COMMAND_URL} every {_POLLING_INTERVAL}s.")
-        while self.is_running:
-            try:
-                self.poll_server_for_commands()
-            except Exception as e:
-                log_error(f"Error in main loop polling cycle: {e}", exc_info=True)
 
-            # Wait for stop event or timeout
-            rc = win32event.WaitForSingleObject(self.hWaitStop, _POLLING_INTERVAL * 1000)
-            if rc == win32event.WAIT_OBJECT_0:
-                # Stop event signaled
-                break
-        log_info(f"{_SERVICE_NAME} is shutting down main loop.")
+    def run_server(self):
+        """Runs the Flask app using Waitress."""
+        log_info(f"Waitress server starting on {_LISTEN_HOST}:{_LISTEN_PORT}")
+        try:
+            serve(flask_app, host=_LISTEN_HOST, port=_LISTEN_PORT, threads=4)
+            log_info("Waitress server has stopped.") # Should only happen on shutdown
+        except Exception as e:
+            log_error(f"Web server thread encountered an error: {e}", exc_info=True)
+            # Consider signaling the main thread to stop if the web server fails critically
+            # For now, just log the error.
 
 
-    def poll_server_for_commands(self):
-        log_info(f"Polling server for commands...")
-        try:
-            headers = {'Authorization': f'Bearer {_MACHINE_ID}'} # Example auth
-            # Add machine identifier if needed by server
-            params = {'machine_id': os.getenv('COMPUTERNAME', 'unknown')}
-            response = self.session.get(_SERVER_COMMAND_URL, headers=headers, params=params, timeout=30)
-            response.raise_for_status() # Raise exception for bad status codes
-
-            commands = response.json() # Expecting a list of command objects
-            if not commands:
-                # log_info("No commands received.") # Reduce log noise
-                return
-
-            log_info(f"Received {len(commands)} command(s). Processing...")
-            for command in commands:
+    def process_commands(self):
+        """Worker thread to process commands from the queue."""
+        log_info("Command processor thread starting.")
+        while self.is_running:
+            try:
+                item = self.command_queue.get(block=True, timeout=1) # Add timeout to check is_running periodically
+                if item is None:
+                    log_info("Command processor received stop signal.")
+                    break # Exit loop
+
+                command_id, command = item
                 action = command.get("action")
-                target = command.get("target_user", "all_active") # Default to all
-                command_id = command.get("command_id", "N/A") # Optional: for reporting status
+                target = command.get("target_user", "all_active")
+                status = "failed_unknown" # Default
+
+                log_info(f"Dequeued Command ID {command_id}: action='{action}', target='{target}'")
 
-                log_info(f"Processing Command ID {command_id}: action='{action}', target='{target}'")
-                status = "failed" # Default status
                 try:
                     if action == "update":
                         status = self.handle_update()
@@ -158,21 +227,49 @@ class GuardService(win32serviceutil.ServiceFramework):
                     elif action == "start_ootb":
                         status = self.handle_start(target)
                     else:
-                        log_error(f"Unknown action received: {action}")
-                        status = "unknown_action"
+                        log_error(f"Unknown action in queue: {action}")
+                        status = "failed_unknown_action"
                 except Exception as handler_ex:
-                     log_error(f"Error executing action '{action}' for command {command_id}: {handler_ex}", exc_info=True)
-                     status = "execution_error"
-
-                # TODO: Add mechanism to report command completion/failure back to server
-                # Example: self.report_command_status(command_id, status)
-                log_info(f"Finished processing Command ID {command_id}: Status='{status}'")
-
+                    log_error(f"Exception processing Command ID {command_id} ({action}): {handler_ex}", exc_info=True)
+                    status = "failed_exception"
+                finally:
+                    self.report_command_status(command_id, status)
+                    self.command_queue.task_done()
+
+            except queue.Empty:
+                # Timeout occurred, just loop again and check self.is_running
+                continue
+            except Exception as e:
+                 log_error(f"Error in command processing loop: {e}", exc_info=True)
+                 if self.is_running:
+                     time.sleep(5)
+
+        log_info("Command processor thread finished.")
+
+
+    def report_command_status(self, command_id, status, details=""):
+        """Sends command status back to the server."""
+        if not _SERVER_STATUS_REPORT_URL:
+            log_warning("No server status report URL configured. Skipping report.")
+            return
+
+        payload = {
+            "command_id": command_id,
+            "status": status,
+            "details": details,
+            "machine_id": os.getenv('COMPUTERNAME', 'unknown_guard')
+        }
+        log_info(f"Reporting status for command {command_id}: {status}")
+        try:
+            response = self.session.post(_SERVER_STATUS_REPORT_URL, json=payload, timeout=15)
+            response.raise_for_status()
+            log_info(f"Status report for command {command_id} accepted by server.")
         except requests.exceptions.RequestException as e:
-            log_error(f"Failed to poll server: {e}")
+            log_error(f"Failed to report status for command {command_id}: {e}")
         except Exception as e:
-            log_error(f"Error processing server commands: {e}", exc_info=True)
+             log_error(f"Unexpected error reporting status for command {command_id}: {e}", exc_info=True)
 
+    # --- Command Handlers --- Copying full implementation from previous version
 
     def handle_update(self):
         log_info("Executing OOTB update...")
@@ -183,8 +280,7 @@ class GuardService(win32serviceutil.ServiceFramework):
         update_command = f"{self.pip_command_base} install --upgrade --no-cache-dir {_PACKAGE_NAME}"
         log_info(f"Running update command: {update_command}")
         try:
-            # Run update command
-            result = subprocess.run(update_command, shell=True, capture_output=True, text=True, check=True, timeout=300)
+            result = subprocess.run(update_command, shell=True, capture_output=True, text=True, check=True, timeout=300, encoding='utf-8')
             log_info(f"Update successful: \nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}")
             return "success"
         except subprocess.CalledProcessError as e:
@@ -199,15 +295,12 @@ class GuardService(win32serviceutil.ServiceFramework):
 
 
     def _get_ootb_processes(self, target_user="all_active"):
-        """Finds OOTB processes, optionally filtering by username."""
         ootb_procs = []
         target_pid_list = []
         try:
-            # Get a list of usernames we are interested in
             target_users = set()
             if target_user == "all_active":
                  for user_session in psutil.users():
-                      # Normalize username (remove domain if present)
                       username = user_session.name.split('\\')[-1]
                       target_users.add(username.lower())
             else:
@@ -215,26 +308,25 @@ class GuardService(win32serviceutil.ServiceFramework):
 
             log_info(f"Searching for OOTB processes for users: {target_users}")
 
-            for proc in psutil.process_iter(['pid', 'name', 'username', 'cmdline']):
+            python_exe_path = self.python_exe.strip('"') # Get unquoted path for comparison
+
+            for proc in psutil.process_iter(['pid', 'name', 'username', 'cmdline', 'exe']):
                 try:
                     pinfo = proc.info
-                    # Normalize process username
                     proc_username = pinfo['username']
                     if proc_username:
                         proc_username = proc_username.split('\\')[-1].lower()
 
-                    # Check if process user is one of the targets
                     if proc_username in target_users:
-                        # Check if command line matches our OOTB app pattern
                         cmdline = ' '.join(pinfo['cmdline']) if pinfo['cmdline'] else ''
-                        # Simple check: does it contain python executable and the module name?
-                        if (self.python_exe.strip('"') in cmdline) and (_OOTB_MODULE in cmdline):
+                        # Check if the process executable matches our python path AND module is in cmdline
+                        if pinfo['exe'] and pinfo['exe'] == python_exe_path and _OOTB_MODULE in cmdline:
                             log_info(f"Found matching OOTB process: PID={pinfo['pid']}, User={pinfo['username']}, Cmd={cmdline}")
                             ootb_procs.append(proc)
                             target_pid_list.append(pinfo['pid'])
 
                 except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-                    continue # Process might have died or we lack permissions
+                    continue
             log_info(f"Found {len(ootb_procs)} OOTB process(es) matching criteria: {target_pid_list}")
         except Exception as e:
              log_error(f"Error enumerating processes: {e}", exc_info=True)
@@ -254,9 +346,9 @@ class GuardService(win32serviceutil.ServiceFramework):
             try:
                 username = proc.info.get('username', 'unknown_user')
                 log_info(f"Terminating process PID={proc.pid}, User={username}")
-                proc.terminate() # Ask nicely first
+                proc.terminate()
                 try:
-                    proc.wait(timeout=3) # Wait a bit
+                    proc.wait(timeout=3)
                     log_info(f"Process PID={proc.pid} terminated successfully.")
                     stopped_count += 1
                 except psutil.TimeoutExpired:
@@ -265,7 +357,7 @@ class GuardService(win32serviceutil.ServiceFramework):
                     stopped_count += 1
             except psutil.NoSuchProcess:
                  log_info(f"Process PID={proc.pid} already terminated.")
-                 stopped_count +=1 # Count it if it disappeared
+                 stopped_count +=1
             except psutil.AccessDenied:
                 log_error(f"Access denied trying to terminate process PID={proc.pid}. Service might lack privileges?")
             except Exception as e:
@@ -283,15 +375,13 @@ class GuardService(win32serviceutil.ServiceFramework):
 
         try:
             sessions = win32ts.WTSEnumerateSessions(win32ts.WTS_CURRENT_SERVER_HANDLE)
-            active_sessions = {} # Store user: session_id for active sessions
+            active_sessions = {}
 
             for session in sessions:
-                 # Look for Active sessions, potentially disconnected ones too?
-                 # For now, only WTSActive
                  if session['State'] == win32ts.WTSActive:
                     try:
                          user = win32ts.WTSQuerySessionInformation(win32ts.WTS_CURRENT_SERVER_HANDLE, session['SessionId'], win32ts.WTSUserName)
-                         if user: # Filter out system sessions etc.
+                         if user:
                               normalized_user = user.lower()
                               active_sessions[normalized_user] = session['SessionId']
                     except Exception as query_err:
@@ -299,7 +389,7 @@ class GuardService(win32serviceutil.ServiceFramework):
 
             log_info(f"Found active user sessions: {active_sessions}")
 
-            target_session_map = {} # user:session_id
+            target_session_map = {}
             if target_user == "all_active":
                  target_session_map = active_sessions
             else:
@@ -314,7 +404,6 @@ class GuardService(win32serviceutil.ServiceFramework):
                  log_info("No target user sessions found to start OOTB in.")
                  return "failed_no_target_sessions"
 
-            # Check if OOTB is already running for the target users
             running_procs = self._get_ootb_processes(target_user)
             users_already_running = set()
             for proc in running_procs:
@@ -323,55 +412,33 @@ class GuardService(win32serviceutil.ServiceFramework):
                      if proc_username:
                           users_already_running.add(proc_username.split('\\')[-1].lower())
                 except Exception:
-                     pass # Ignore errors getting username here
+                     pass
 
             log_info(f"Users already running OOTB: {users_already_running}")
 
             for user, session_id in target_session_map.items():
-                 token = None # Ensure token is reset/defined
+                 token = None
                  try:
                      if user in users_already_running:
                          log_info(f"OOTB already seems to be running for user '{user}'. Skipping start.")
                          continue
 
                      log_info(f"Attempting to start OOTB for user '{user}' in session {session_id}...")
-
-                     # Get user token
                      token = win32ts.WTSQueryUserToken(session_id)
-
-                     # Create environment block for the user
                      env = win32profile.CreateEnvironmentBlock(token, False)
-
-                     # Create startup info
                      startup = win32process.STARTUPINFO()
                      startup.dwFlags = win32process.STARTF_USESHOWWINDOW
-                     # Attempt to show window on user's desktop
-                     # Requires Service to have "Allow service to interact with desktop" checked
-                     # AND Interactive Services Detection service running (often disabled now).
-                     # May be better to run hidden (SW_HIDE) or default.
-                     startup.wShowWindow = win32con.SW_SHOW
-                     startup.lpDesktop = 'winsta0\\default' # Try targeting default interactive desktop
-
-                     # Create process as user
-                     # Needs SeAssignPrimaryTokenPrivilege, SeIncreaseQuotaPrivilege for service account.
+                     startup.wShowWindow = win32con.SW_SHOW # Try showing the window
+                     startup.lpDesktop = 'winsta0\\default'
                      creation_flags = win32process.CREATE_NEW_CONSOLE | win32process.CREATE_UNICODE_ENVIRONMENT
 
                      hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
-                         token,              # User token
-                         self.python_exe,    # Application name (python executable)
-                         self.ootb_command,  # Command line
-                         None,               # Process attributes
-                         None,               # Thread attributes
-                         False,              # Inherit handles
-                         creation_flags,     # Creation flags
-                         env,                # Environment
-                         None,               # Current directory (use default)
-                         startup             # Startup info
+                         token, self.python_exe, self.ootb_command,
+                         None, None, False, creation_flags, env, None, startup
                      )
                      log_info(f"Successfully started OOTB for user '{user}' (PID: {dwPid}).")
                      started_count += 1
                      target_users_started.add(user)
-                     # Close handles immediately
                      win32api.CloseHandle(hProcess)
                      win32api.CloseHandle(hThread)
 
@@ -379,12 +446,10 @@ class GuardService(win32serviceutil.ServiceFramework):
                       log_error(f"Failed to start OOTB for user '{user}' in session {session_id}: {proc_err}", exc_info=True)
                       users_failed_to_start.add(user)
                  finally:
-                      # Ensure token handle is always closed if obtained
                       if token:
                            try: win32api.CloseHandle(token)
                            except: pass
 
-
             log_info(f"Finished starting OOTB. Started {started_count} new instance(s). Failed for users: {users_failed_to_start or 'None'}")
             if users_failed_to_start:
                  return f"partial_success_started_{started_count}_failed_for_{len(users_failed_to_start)}"
@@ -397,26 +462,20 @@ class GuardService(win32serviceutil.ServiceFramework):
              log_error(f"Error during start OOTB process: {e}", exc_info=True)
              return "failed_exception"
 
-
-# This block is essential for the service framework to handle
-# command-line arguments like 'install', 'start', 'stop', 'remove', 'debug'.
+# --- Main Execution Block ---
 if __name__ == '__main__':
-    # Add logic to allow debugging from command line easily
     if len(sys.argv) > 1 and sys.argv[1] == 'debug':
         log_info("Starting service in debug mode...")
-        service_instance = GuardService(sys.argv)
-        service_instance.is_running = True # Ensure loop runs
+        print(f"Running Flask server via Waitress on {_LISTEN_HOST}:{_LISTEN_PORT} for debugging...")
+        print("Service logic (command processing) will NOT run in this mode.")
+        print("Use this primarily to test the '/command' endpoint receiving POSTs.")
+        print("Press Ctrl+C to stop.")
         try:
-            # Run the main loop directly for debugging
-            service_instance.main_loop()
-            # Simulate stop signal for clean exit in debug
-            # service_instance.SvcStop() # Or let it run until Ctrl+C?
+             serve(flask_app, host=_LISTEN_HOST, port=_LISTEN_PORT, threads=1)
         except KeyboardInterrupt:
-            log_info("Debug mode interrupted by user.")
-            service_instance.SvcStop() # Attempt clean stop
-        log_info("Debug mode finished.")
+             print("\nDebug server stopped.")
+
     elif len(sys.argv) == 1:
-        # Called without arguments, run as a service instance via SCM
         try:
             servicemanager.Initialize()
             servicemanager.PrepareToHostSingle(GuardService)
@@ -424,13 +483,11 @@ if __name__ == '__main__':
         except win32service.error as details:
             import winerror
             if details.winerror == winerror.ERROR_FAILED_SERVICE_CONTROLLER_CONNECT:
-                print(f"Error: Cannot connect to Service Control Manager.")
+                print(f"Error: Not started by SCM.")
                 print(f"Use 'python {os.path.basename(__file__)} install|start|stop|remove|debug'")
             else:
                 print(f"Error preparing service: {details}")
         except Exception as e:
              print(f"Unexpected error initializing service: {e}")
-
     else:
-         # Called with install/start/stop/remove args, let ServiceFramework handle them
         win32serviceutil.HandleCommandLine(GuardService) 

computer_use_ootb_internal/preparation/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'preparation' directory a Python package 

computer_use_ootb_internal/preparation/star_rail_prepare.py

@@ -0,0 +1,65 @@
+# src/computer_use_ootb_internal/preparation/star_rail_prepare.py
+import time
+import platform
+import pyautogui
+import webbrowser
+import logging # Use logging instead of print for better practice
+
+# Set up logging for this module if needed, or rely on root logger
+log = logging.getLogger(__name__)
+
+def run_preparation(state):
+    """
+    Performs environment preparation specific to Star Rail on Windows.
+    Opens the specified URL in Edge and performs initial clicks.
+    """
+    if platform.system() != "Windows":
+        log.info("Star Rail preparation skipped: Not running on Windows.")
+        return
+
+    log.info("Star Rail preparation: Starting environment setup on Windows...")
+    url = "https://sr.mihoyo.com/cloud/#/" # Consider making this configurable later
+    browser_opened = False
+    try:
+        # Use only webbrowser.open
+        log.info(f"Attempting to open {url} using webbrowser.open()...")
+        if webbrowser.open(url):
+            log.info(f"Successfully requested browser to open {url} via webbrowser.open().")
+            browser_opened = True
+        else:
+            log.warning("webbrowser.open() returned False, indicating potential failure.")
+
+        if not browser_opened:
+            log.error("Failed to confirm browser opening via webbrowser.open(). Will still attempt clicks.")
+
+        # Add pyautogui click after attempting to open the browser
+        log.info("Proceeding with pyautogui actions...")
+        time.sleep(5) # Wait time for the browser to load
+
+        # Get screen size
+        screen_width, screen_height = pyautogui.size()
+        log.info(f"Detected screen size: {screen_width}x{screen_height}")
+
+        # Calculate click coordinates based on a reference resolution (e.g., 1280x720)
+        # TODO: Make these coordinates more robust or configurable
+        click_x = int(screen_width * (1036 / 1280))
+        click_y = int(screen_height * (500 / 720))
+        log.info(f"Calculated click coordinates: ({click_x}, {click_y})")
+
+        # Disable failsafe before clicking
+        pyautogui.FAILSAFE = False
+        log.info("PyAutoGUI failsafe temporarily disabled.")
+
+        log.info(f"Clicking at coordinates: ({click_x}, {click_y})")
+        pyautogui.click(click_x, click_y)
+        time.sleep(2)
+        pyautogui.click(click_x, click_y) # Double click?
+
+        log.info("Star Rail preparation clicks completed.")
+
+    except Exception as e:
+        log.error(f"Error during Star Rail preparation (browser/click): {e}", exc_info=True)
+    finally:
+         # Ensure failsafe is re-enabled
+         pyautogui.FAILSAFE = True
+         log.info("PyAutoGUI failsafe re-enabled.") 

{computer_use_ootb_internal-0.0.111.dist-info → computer_use_ootb_internal-0.0.113.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: computer-use-ootb-internal
-Version: 0.0.111
+Version: 0.0.113
 Summary: Computer Use OOTB
 Author-email: Siyuan Hu <siyuan.hu.sg@gmail.com>
 Requires-Python: >=3.11
 Requires-Dist: anthropic[bedrock,vertex]>=0.37.1
 Requires-Dist: boto3>=1.28.57
+Requires-Dist: flask>=2.0
 Requires-Dist: google-auth<3,>=2
 Requires-Dist: gradio>=5.6.0
 Requires-Dist: jsonschema==4.22.0
@@ -21,6 +22,7 @@ Requires-Dist: screeninfo
 Requires-Dist: streamlit>=1.38.0
 Requires-Dist: textdistance
 Requires-Dist: uiautomation; sys_platform == 'win32'
+Requires-Dist: waitress>=2.0
 Provides-Extra: dev
 Requires-Dist: pre-commit>=3.8.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23.6; extra == 'dev'

{computer_use_ootb_internal-0.0.111.dist-info → computer_use_ootb_internal-0.0.113.dist-info}/RECORD

@@ -1,9 +1,9 @@
 computer_use_ootb_internal/README.md,sha256=FxpW95lyub2iX73ZDfK6ML7SdEKg060H5I6Grub7li4,31
 computer_use_ootb_internal/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-computer_use_ootb_internal/app_teachmode.py,sha256=rNJ8o6EHhQLsFwHgDSUHghFaKjheGW957NHPfRXsewY,18836
+computer_use_ootb_internal/app_teachmode.py,sha256=U0vHAEHeDMDioYatLQkzesT1Hy0aI6kKjhAlV86zxfc,17902
 computer_use_ootb_internal/app_teachmode_gradio.py,sha256=cmFpBrkdlZxOQADWveVdIaaNqaBD8IVs-xNLJogU7F8,7909
 computer_use_ootb_internal/dependency_check.py,sha256=y8RMEP6RXQzTgU1MS_1piBLtz4J-Hfn9RjUZg59dyvo,1333
-computer_use_ootb_internal/guard_service.py,sha256=bhxgDD2bYZ7g12gf-2o_7o0irEUovc5bFXLOpTnX2Gw,20570
+computer_use_ootb_internal/guard_service.py,sha256=HU9_nM2Jw38Us7vo49qSc-jBeMkCZFoXiILBx1VvOoc,22574
 computer_use_ootb_internal/requirements-lite.txt,sha256=5DAHomz4A_P2BmTIXNkNqkHbnIF0AyZ4_1XAlb1LaYs,290
 computer_use_ootb_internal/run_teachmode_ootb_args.py,sha256=7Dj0iY4GG7P03tRKYJ2x9Yvt-PE-b7uyjCAed3SaF3Y,7086
 computer_use_ootb_internal/service_manager.py,sha256=sesbSUBBqm6W77Dykaw-HGARU-yNdK9DqOHPiR2TbkE,6920
@@ -32,7 +32,9 @@ computer_use_ootb_internal/computer_use_demo/tools/computer_marbot.py,sha256=zZu
 computer_use_ootb_internal/computer_use_demo/tools/edit.py,sha256=b0PwUitxckHCQqFP3ZwlthWdqNkn7WETeTHeB6-o98c,11486
 computer_use_ootb_internal/computer_use_demo/tools/run.py,sha256=xhXdnBK1di9muaO44CEirL9hpGy3NmKbjfMpyeVmn8Y,1595
 computer_use_ootb_internal/computer_use_demo/tools/screen_capture.py,sha256=L8qfvtUkPPQGt92N-2Zfw5ZTDBzLsDps39uMnX3_uSA,6857
-computer_use_ootb_internal-0.0.111.dist-info/METADATA,sha256=Ybw5i4bp5sY5a5bT6SWWymP-jXV87juXL5YQxFM5pvY,993
-computer_use_ootb_internal-0.0.111.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-computer_use_ootb_internal-0.0.111.dist-info/entry_points.txt,sha256=bXfyAU_qq-G1EiEgAQEioXvgEdRCFxaTooqdDD9Y4OA,258
-computer_use_ootb_internal-0.0.111.dist-info/RECORD,,
+computer_use_ootb_internal/preparation/__init__.py,sha256=AgtGHcBpiTkxJjF0xwcs3yyQ6SyUvhL3G0vD2XO-zJw,63
+computer_use_ootb_internal/preparation/star_rail_prepare.py,sha256=s1VWszcTnJAKxqCHFlaOEwPkqVSrkiFx_yKpWSnSbHs,2649
+computer_use_ootb_internal-0.0.113.dist-info/METADATA,sha256=NHF7noSgn8aC5JpMIfId8afNaTZI_XssG0HNCW2nPPI,1048
+computer_use_ootb_internal-0.0.113.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+computer_use_ootb_internal-0.0.113.dist-info/entry_points.txt,sha256=bXfyAU_qq-G1EiEgAQEioXvgEdRCFxaTooqdDD9Y4OA,258
+computer_use_ootb_internal-0.0.113.dist-info/RECORD,,