computer-use-ootb-internal 0.0.126__tar.gz → 0.0.128__tar.gz

{computer_use_ootb_internal-0.0.126 → computer_use_ootb_internal-0.0.128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: computer-use-ootb-internal
-Version: 0.0.126
+Version: 0.0.128
 Summary: Computer Use OOTB
 Author-email: Siyuan Hu <siyuan.hu.sg@gmail.com>
 Requires-Python: >=3.11

{computer_use_ootb_internal-0.0.126 → computer_use_ootb_internal-0.0.128}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "computer-use-ootb-internal"
-version = "0.0.126"
+version = "0.0.128"
 description = "Computer Use OOTB"
 authors = [{ name = "Siyuan Hu", email = "siyuan.hu.sg@gmail.com" }]
 requires-python = ">=3.11"

{computer_use_ootb_internal-0.0.126 → computer_use_ootb_internal-0.0.128}/src/computer_use_ootb_internal/guard_service.py

@@ -104,6 +104,8 @@ def receive_command():
 
 # --- End PowerShell Task Scheduler Helpers ---
 
+TARGET_EXECUTABLE_NAME = "computer-use-ootb-internal.exe"
+
 class GuardService(win32serviceutil.ServiceFramework):
     _svc_name_ = _SERVICE_NAME
     _svc_display_name_ = _SERVICE_DISPLAY_NAME
@@ -134,145 +136,43 @@ class GuardService(win32serviceutil.ServiceFramework):
     # --- End Instance Logging --- 
 
     # --- Instance Helper Methods (Moved from module level) ---
-    def get_base_python_executable(self):
-        """Tries to find python.exe instead of pythonservice.exe if running as service."""
-        service_exe = sys.executable
-        self.log_info(f"get_base_python_executable: sys.executable is {service_exe}")
-        # Normalize path for comparison
-        service_exe_lower = service_exe.lower()
-        
-        # Check if running as pythonservice.exe
-        if 'pythonservice.exe' in os.path.basename(service_exe_lower):
-            # Construct expected python.exe path in the same directory
-            dir_name = os.path.dirname(service_exe)
-            potential_python_exe = os.path.join(dir_name, 'python.exe')
-            self.log_info(f"get_base_python_executable: Checking for python.exe at {potential_python_exe}")
-            
-            if os.path.exists(potential_python_exe):
-                self.log_info(f"get_base_python_executable: Found python.exe at {potential_python_exe}")
-                # Quote if necessary
-                final_exe = potential_python_exe
-                if " " in final_exe and not final_exe.startswith('"'):
-                    return f'"{final_exe}"'
-                return final_exe
-            else:
-                 self.log_error(f"get_base_python_executable: Could not find python.exe near pythonservice.exe (checked {potential_python_exe}). Falling back to using {service_exe}.")
-                 # Fallback to original sys.executable (quoted if needed)
-                 if " " in service_exe and not service_exe.startswith('"'):
-                     return f'"{service_exe}"'
-                 return service_exe
-        else: # Not running as pythonservice.exe, assume sys.executable is correct
-            self.log_info(f"get_base_python_executable: sys.executable is not pythonservice.exe, using it directly.")
-            if " " in service_exe and not service_exe.startswith('"'):
-                 return f'"{service_exe}"'
-            return service_exe
-
-    def get_python_executable(self):
-        # This method is now just an alias for clarity if needed elsewhere,
-        # but primary logic uses get_base_python_executable directly.
-        # Keep for potential compatibility if anything still calls it.
-        return self.get_base_python_executable()
-
-    def get_pip_executable(self):
-        """Tries to locate the pip executable in the same environment."""
+    def _find_target_executable(self):
+        """Finds the target executable (e.g., computer-use-ootb-internal.exe) in the Scripts directory."""
         try:
-            # Use the potentially corrected python path to find pip's location
-            # Note: This assumes pip is relative to python.exe, not pythonservice.exe
-            base_python = self.get_base_python_executable()
-            python_path = pathlib.Path(base_python.strip('"')) # Use unquoted path
-            pip_path = python_path.parent / "Scripts" / "pip.exe"
-            self.log_info(f"get_pip_executable: Checking for pip relative to {python_path.parent} at {pip_path}")
-
-            if pip_path.exists():
-                self.log_info(f"get_pip_executable: pip.exe found at {pip_path}")
-                pip_exe = str(pip_path)
-                if " " in pip_exe and not pip_exe.startswith('"'):
-                    pip_exe = f'"{pip_exe}"'
-                return pip_exe
+            # sys.executable should be python.exe or pythonservice.exe in the env root/Scripts
+            env_dir = os.path.dirname(sys.executable)
+            # If sys.executable is in Scripts, go up one level
+            if os.path.basename(env_dir.lower()) == 'scripts':
+                env_dir = os.path.dirname(env_dir)
+
+            scripts_dir = os.path.join(env_dir, 'Scripts')
+            target_exe_path = os.path.join(scripts_dir, TARGET_EXECUTABLE_NAME)
+
+            self.log_info(f"_find_target_executable: Checking for executable at: {target_exe_path}")
+
+            if os.path.exists(target_exe_path):
+                self.log_info(f"_find_target_executable: Found executable: {target_exe_path}")
+                # Quote if necessary for command line usage
+                if " " in target_exe_path and not target_exe_path.startswith('"'):
+                    return f'"{target_exe_path}"'
+                return target_exe_path
             else:
-                self.log_error(f"get_pip_executable: pip.exe NOT found at {pip_path}. Falling back to '{base_python} -m pip'.")
-                pass
-        except Exception as e:
-            self.log_error(f"get_pip_executable: Error determining pip path: {e}", exc_info=True)
-            self.log_error(f"get_pip_executable: Falling back to 'python -m pip' due to error.")
-        
-        # Fallback uses the potentially corrected python path
-        return f"{self.get_base_python_executable()} -m pip"
-
-    # --- PowerShell Methods (Moved from module level) ---
-    def run_powershell_command(self, command, log_output=True):
-        """Executes a PowerShell command and handles output/errors. Returns True on success."""
-        self.log_info(f"Executing PowerShell: {command}")
-        try:
-            result = subprocess.run(
-                ["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", command],
-                capture_output=True, text=True, check=True, encoding='utf-8', errors='ignore'
-            )
-            if log_output and result.stdout:
-                self.log_info(f"PowerShell STDOUT:\n{result.stdout.strip()}")
-            if log_output and result.stderr:
-                self.log_info(f"PowerShell STDERR:\n{result.stderr.strip()}")
-            return True
-        except FileNotFoundError:
-            self.log_error("'powershell.exe' not found. Cannot manage scheduled tasks.")
-            return False
-        except subprocess.CalledProcessError as e:
-            self.log_error(f"PowerShell command failed (Exit Code {e.returncode}):")
-            self.log_error(f"  Command: {e.cmd}")
-            if e.stdout: self.log_error(f"  STDOUT: {e.stdout.strip()}")
-            if e.stderr: self.log_error(f"  STDERR: {e.stderr.strip()}")
-            return False
-        except Exception as e:
-            self.log_error(f"Unexpected error running PowerShell: {e}", exc_info=True)
-            return False
-
-    def create_or_update_logon_task(self, username, task_command, python_executable):
-        """Creates or updates a scheduled task to run a command at user logon."""
-        task_name = f"{self._task_name_prefix}{username}"
-        safe_python_exe = python_executable.replace("'", "''")
-        command_parts = task_command.split(' ', 1)
-        if len(command_parts) > 1 and command_parts[0] == python_executable:
-             safe_task_command_args = command_parts[1].replace("'", "''")
-        else:
-             safe_task_command_args = task_command.replace(python_executable, "").strip().replace("'", "''")
-
-        safe_task_name = task_name.replace("'", "''")
-        safe_username = username.replace("'", "''")
-
-        action = f"$Action = New-ScheduledTaskAction -Execute '{safe_python_exe}' -Argument '{safe_task_command_args}'"
-        trigger = f"$Trigger = New-ScheduledTaskTrigger -AtLogOn -User '{safe_username}'"
-        principal = f"$Principal = New-ScheduledTaskPrincipal -UserId '{safe_username}' -LogonType Interactive"
-        settings = "$Settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -DontStopOnIdleEnd -ExecutionTimeLimit ([System.TimeSpan]::Zero) -RunOnlyIfNetworkAvailable:$false"
-
-        command = f"""
-        try {{
-            {action}
-            {trigger}
-            {principal}
-            {settings}
-            Register-ScheduledTask -TaskName '{safe_task_name}' -Action $Action -Trigger $Trigger -Principal $Principal -Settings $Settings -Force -ErrorAction Stop
-            Write-Host "Scheduled task '{safe_task_name}' registered/updated successfully."
-        }} catch {{
-            Write-Error "Failed to register/update scheduled task '{safe_task_name}': $_"
-            exit 1
-        }}
-        """
-        success = self.run_powershell_command(command)
-        if success:
-            self.log_info(f"Successfully created/updated scheduled task '{task_name}' for user '{username}'.")
-        else:
-            self.log_error(f"Failed to create/update scheduled task '{task_name}' for user '{username}'.")
-        return success
+                self.log_error(f"_find_target_executable: Target executable not found at {target_exe_path}")
+                # Fallback: Check env root directly (less common for scripts)
+                target_exe_path_root = os.path.join(env_dir, TARGET_EXECUTABLE_NAME)
+                self.log_info(f"_find_target_executable: Checking fallback location: {target_exe_path_root}")
+                if os.path.exists(target_exe_path_root):
+                     self.log_info(f"_find_target_executable: Found executable at fallback location: {target_exe_path_root}")
+                     if " " in target_exe_path_root and not target_exe_path_root.startswith('"'):
+                         return f'"{target_exe_path_root}"'
+                     return target_exe_path_root
+                else:
+                     self.log_error(f"_find_target_executable: Target executable also not found at {target_exe_path_root}")
+                     return None
 
-    def remove_logon_task(self, username):
-        """Removes the logon scheduled task for a user."""
-        task_name = f"{self._task_name_prefix}{username}"
-        safe_task_name = task_name.replace("'", "''")
-        command = f"Unregister-ScheduledTask -TaskName '{safe_task_name}' -Confirm:$false -ErrorAction SilentlyContinue"
-        self.run_powershell_command(command, log_output=False)
-        self.log_info(f"Attempted removal of scheduled task '{task_name}' for user '{username}'.")
-        return True
-    # --- End Instance Helper Methods ---
+        except Exception as e:
+            self.log_error(f"Error finding target executable: {e}")
+            return None
 
     def __init__(self, args):
         global _service_instance
@@ -284,13 +184,16 @@ class GuardService(win32serviceutil.ServiceFramework):
         self.command_processor_thread = None
         self.session = requests.Session()
 
-        # Initialize paths using instance methods that prefer python.exe
-        self.python_exe = self.get_base_python_executable()
-        self.pip_command_base = self.get_pip_executable()
-        # Construct command using the potentially corrected python.exe path
-        self.ootb_command = f"{self.python_exe} -m {_OOTB_MODULE}"
+        self.target_executable_path = self._find_target_executable()
+        if not self.target_executable_path:
+             # Log error and potentially stop service if critical executable is missing
+             self.log_error(f"CRITICAL: Could not find {TARGET_EXECUTABLE_NAME}. Service cannot function.")
+             # Consider stopping the service here if needed, or handle appropriately
+        else:
+             self.log_info(f"Using target executable: {self.target_executable_path}")
+
         _service_instance = self
-        self.log_info(f"Service initialized. OOTB command set to: {self.ootb_command}")
+        self.log_info(f"Service initialized. Target executable set to: {self.target_executable_path}")
 
     def SvcStop(self):
         self.log_info(f"Service stop requested.")
@@ -418,11 +321,11 @@ class GuardService(win32serviceutil.ServiceFramework):
 
     def handle_update(self):
         self.log_info("Executing OOTB update...")
-        if not self.pip_command_base:
-            self.log_error("Cannot update: pip command not found.")
-            return "failed_pip_not_found"
+        if not self.target_executable_path:
+            self.log_error("Cannot update: Target executable not found.")
+            return "failed_executable_not_found"
 
-        update_command = f"{self.pip_command_base} install --upgrade --no-cache-dir {_PACKAGE_NAME}"
+        update_command = f"{self.target_executable_path} update"
         self.log_info(f"Running update command: {update_command}")
         try:
             result = subprocess.run(update_command, shell=True, capture_output=True, text=True, check=True, timeout=300, encoding='utf-8')
@@ -452,7 +355,7 @@ class GuardService(win32serviceutil.ServiceFramework):
             self.log_info(f"Searching for OOTB processes for users: {target_users}")
             
             # Use the potentially corrected python.exe path for matching
-            python_exe_path_for_check = self.python_exe.strip('"') 
+            python_exe_path_for_check = self.target_executable_path.strip('"') 
             self.log_info(f"_get_ootb_processes: Checking against python path: {python_exe_path_for_check}")
 
             for proc in psutil.process_iter(['pid', 'name', 'username', 'cmdline', 'exe']):
@@ -688,7 +591,7 @@ class GuardService(win32serviceutil.ServiceFramework):
 
                 # 1. Always try to create/update the scheduled task
                 try:
-                    task_created = self.create_or_update_logon_task(user, self.ootb_command, self.python_exe)
+                    task_created = self.create_or_update_logon_task(user)
                     task_created_status = "task_success" if task_created else "task_failed"
                 except Exception as task_err:
                      self.log_error(f"Exception creating/updating scheduled task for {user}: {task_err}", exc_info=True)
@@ -719,7 +622,7 @@ class GuardService(win32serviceutil.ServiceFramework):
                             user_profile_dir = win32profile.GetUserProfileDirectory(token)
 
                             hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
-                                token, self.python_exe, self.ootb_command,
+                                token, self.target_executable_path,
                                 None, None, False, creation_flags, env, user_profile_dir, startup
                             )
                             self.log_info(f"CreateProcessAsUser call succeeded for user '{user}' (PID: {dwPid}). Checking existence...")
@@ -780,6 +683,57 @@ class GuardService(win32serviceutil.ServiceFramework):
              self.log_error(f"Error during combined start OOTB process: {e}", exc_info=True)
              return "failed_exception"
 
+    def create_or_update_logon_task(self, username):
+        """Creates or updates a scheduled task to run the OOTB app on user logon."""
+        if not self.target_executable_path:
+            self.log_error(f"Cannot create task for {username}: Target executable path is not set.")
+            return False
+
+        task_name = f"OOTB_UserLogon_{username}"
+        # Use the found target executable path directly
+        # No arguments needed if the executable handles everything
+        command_to_run = self.target_executable_path
+        # Arguments are now empty as the exe is called directly
+        arguments = ""
+
+        # Ensure command_to_run is properly quoted if it contains spaces
+        # The _find_target_executable should already handle quoting
+        # Example PowerShell command construction (adjust as needed)
+        ps_command = f"""
+        $taskName = "{task_name}"
+        $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive
+        # Action: Run the target executable directly
+        $action = New-ScheduledTaskAction -Execute '{command_to_run}'
+        # Optional: Set working directory if needed, otherwise it might default to System32 or user profile
+        # $action.WorkingDirectory = "C:\path\to\working\dir"
+        $trigger = New-ScheduledTaskTrigger -AtLogOn -User "{username}"
+        $settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit (New-TimeSpan -Days 9999) -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1)
+        $description = "Runs OOTB Application for user {username} upon logon."
+
+        # Unregister existing task first (force)
+        Unregister-ScheduledTask -TaskName $taskName -Confirm:$false -ErrorAction SilentlyContinue
+
+        # Register the new task
+        Register-ScheduledTask -TaskName $taskName -Principal $principal -Action $action -Trigger $trigger -Settings $settings -Description $description -Force
+        """
+        self.log_info(f"Attempting to create/update task '{task_name}' for user '{username}' to run '{command_to_run}'")
+        try:
+            # ... (run PowerShell command) ...
+            self.log_info(f"Successfully ran PowerShell command to create/update task '{task_name}'.")
+            return True
+        except Exception as e:
+            self.log_error(f"Failed to create/update scheduled task '{task_name}' for user '{username}': {e}")
+            return False
+
+    def remove_logon_task(self, username):
+        """Removes the logon scheduled task for a user."""
+        task_name = f"{self._task_name_prefix}{username}"
+        safe_task_name = task_name.replace("'", "''")
+        command = f"Unregister-ScheduledTask -TaskName '{safe_task_name}' -Confirm:$false -ErrorAction SilentlyContinue"
+        self.run_powershell_command(command, log_output=False)
+        self.log_info(f"Attempted removal of scheduled task '{task_name}' for user '{username}'.")
+        return True
+
 # --- Main Execution Block ---
 if __name__ == '__main__':
     if len(sys.argv) > 1 and sys.argv[1] == 'debug':

computer_use_ootb_internal-0.0.128/src/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.126/deploy.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-
-# Clean previous builds
-rm -rf dist
-
-# Build the package
-python -m build
-
-# Upload to PyPI using API key
-python -m twine upload dist/* -u __token__ -p pypi-AgEIcHlwaS5vcmcCJDkwMTlkNmE2LWFkZmYtNGU2ZC1hYzUwLWFiYmRjYTg4YTNkYgACIlsxLFsiY29tcHV0ZXItdXNlLW9vdGItaW50ZXJuYWwiXV0AAixbMixbIjllNmQ5NTRjLTgxZGEtNGRkNy05Yjk5LWVjYzMzOGUwN2NlZSJdXQAABiBFIKbytGELyFb1-i20Cu4tSo8cAUlX1DCLmUALq0mcPA

computer_use_ootb_internal-0.0.126/src/computer_use_ootb_internal/preparation/star_rail_prepare.py

@@ -1,63 +0,0 @@
-# src/computer_use_ootb_internal/preparation/star_rail_prepare.py
-import time
-import platform
-import subprocess # Added for taskkill
-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.
-    Closes existing Edge browsers and opens the specified URL in a new Edge instance.
-    """
-    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:
-        # Attempt to close existing Microsoft Edge processes
-        log.info("Attempting to close existing Microsoft Edge processes...")
-        try:
-            # /F forces termination, /IM specifies image name
-            result = subprocess.run(['taskkill', '/F', '/IM', 'msedge.exe'], 
-                                    capture_output=True, text=True, check=False)
-            if result.returncode == 0:
-                log.info("Successfully sent termination signal to msedge.exe processes.")
-            elif "not found" in result.stderr.lower() or "not found" in result.stdout.lower():
-                 log.info("No running msedge.exe processes found to close.")
-            else:
-                 log.warning(f"taskkill command finished with return code {result.returncode}. Output: {result.stdout} Stderr: {result.stderr}")
-            time.sleep(2) # Give processes time to close
-        except FileNotFoundError:
-            log.error("Error: 'taskkill' command not found. Make sure it's in the system PATH.")
-        except Exception as e:
-            log.error(f"Error occurred while trying to close Edge: {e}", exc_info=True)
-
-
-        # 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
-            time.sleep(5) # Wait time for the browser to potentially load the page
-        else:
-            log.warning("webbrowser.open() returned False, indicating potential failure.")
-            # No need to error out completely if browser *request* failed, 
-            # but it's unlikely the rest of the process would work.
-
-        if not browser_opened:
-             log.error("Failed to confirm browser opening via webbrowser.open().")
-
-        # Removed pyautogui click logic
-
-        log.info("Star Rail preparation completed (browser opened).")
-
-    except Exception as e:
-        log.error(f"Error during Star Rail preparation: {e}", exc_info=True)
-    # No finally block needed anymore as pyautogui failsafe is removed