computer-use-ootb-internal 0.0.139__tar.gz → 0.0.140__tar.gz

{computer_use_ootb_internal-0.0.139 → computer_use_ootb_internal-0.0.140}/PKG-INFO

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

{computer_use_ootb_internal-0.0.139 → computer_use_ootb_internal-0.0.140}/pyproject.toml

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

{computer_use_ootb_internal-0.0.139 → computer_use_ootb_internal-0.0.140}/src/computer_use_ootb_internal/guard_service.py

@@ -362,49 +362,89 @@ class GuardService(win32serviceutil.ServiceFramework):
 
     # --- Command Handlers --- Now call self. for helpers
 
-    def handle_update(self):
-        """Handles the update command by running the target executable with the 'update' argument."""
-        self.log_info("Executing OOTB update...")
+    def _get_python_executable_from_target_exe(self):
+        """Attempts to find the python.exe associated with the target executable's env."""
         if not self.target_executable_path:
-            self.log_error("Cannot update: Target executable path is not set.")
-            return "failed_executable_not_found"
+            self.log_error("Cannot find python.exe: target executable path is not set.")
+            return None
+        try:
+            exe_path_unquoted = self.target_executable_path.strip('"')
+            scripts_dir = os.path.dirname(exe_path_unquoted)
+            # Assume target exe is in a 'Scripts' directory relative to env root
+            env_dir = os.path.dirname(scripts_dir)
+            if os.path.basename(scripts_dir.lower()) != 'scripts':
+                self.log_warning(f"Target executable {exe_path_unquoted} not in expected 'Scripts' directory. Cannot reliably find python.exe.")
+                # Fallback: maybe the target IS python.exe or next to it?
+                env_dir = scripts_dir # Try assuming it's env root
+
+            python_exe_path = os.path.join(env_dir, 'python.exe')
+            self.log_info(f"Checking for python.exe at: {python_exe_path}")
+            if os.path.exists(python_exe_path):
+                self.log_info(f"Found associated python.exe: {python_exe_path}")
+                if " " in python_exe_path and not python_exe_path.startswith('"'):
+                    return f'"{python_exe_path}"'
+                return python_exe_path
+            else:
+                self.log_error(f"Associated python.exe not found at {python_exe_path}")
+                # Fallback: Check pythonw.exe?
+                pythonw_exe_path = os.path.join(env_dir, 'pythonw.exe')
+                if os.path.exists(pythonw_exe_path):
+                    self.log_info(f"Found associated pythonw.exe as fallback: {pythonw_exe_path}")
+                    if " " in pythonw_exe_path and not pythonw_exe_path.startswith('"'):
+                        return f'"{pythonw_exe_path}"'
+                    return pythonw_exe_path
+                else:
+                    self.log_error(f"Associated pythonw.exe also not found.")
+                    return None
+
+        except Exception as e:
+            self.log_error(f"Error finding associated python executable: {e}")
+            return None
+
+    def handle_update(self):
+        """Handles the update command by running pip install --upgrade directly."""
+        self.log_info("Executing OOTB update via pip...")
+        
+        python_exe = self._get_python_executable_from_target_exe()
+        if not python_exe:
+            self.log_error("Cannot update: Could not find associated python.exe for pip.")
+            return "failed_python_not_found"
 
-        # Construct the command: "C:\path\to\exe" update
-        # self.target_executable_path should already be quoted if necessary
-        update_command = f'{self.target_executable_path} update'
-        # Determine the executable path without quotes for subprocess call if needed
-        executable_for_run = self.target_executable_path.strip('"')
-        args_for_run = ["update"]
+        # Package name needs to be defined (replace with actual package name)
+        package_name = "computer-use-ootb-internal" # Make sure this is correct
+        
+        # Construct the command: "C:\path\to\python.exe" -m pip install --upgrade --no-cache-dir package_name
+        python_exe_unquoted = python_exe.strip('"')
+        pip_args = ["-m", "pip", "install", "--upgrade", "--no-cache-dir", package_name]
+        update_command_display = f'{python_exe} {" ".join(pip_args)}'
 
-        self.log_info(f"Running update command: {update_command}")
+        self.log_info(f"Running update command: {update_command_display}")
         try:
-            # Execute the command directly. Running as LocalSystem should have rights to ProgramData.
-            # Capture output for logging.
+            # Execute the pip command directly. Running as LocalSystem should have rights.
             result = subprocess.run(
-                [executable_for_run] + args_for_run, 
+                [python_exe_unquoted] + pip_args, 
                 capture_output=True, 
                 text=True, 
-                check=False, # Don't throw on non-zero exit, we check manually
+                check=False, # Check manually
                 encoding='utf-8', 
                 errors='ignore'
             )
             
-            # Log stdout/stderr regardless of exit code
             if result.stdout:
                  self.log_info(f"Update process STDOUT:\n{result.stdout.strip()}")
             if result.stderr:
-                 self.log_warning(f"Update process STDERR:\n{result.stderr.strip()}") # Use warning for stderr
+                 self.log_warning(f"Update process STDERR:\n{result.stderr.strip()}")
 
             if result.returncode == 0:
                 self.log_info("Update process completed successfully (Exit Code 0).")
                 return "success"
             else:
                 self.log_error(f"Update process failed (Exit Code {result.returncode}).")
-                return f"failed_update_exit_code_{result.returncode}"
+                return f"failed_pip_exit_code_{result.returncode}"
                 
         except FileNotFoundError:
-             self.log_error(f"Update failed: Executable not found at '{executable_for_run}'.")
-             return "failed_executable_not_found"
+             self.log_error(f"Update failed: Python executable not found at '{python_exe_unquoted}'.")
+             return "failed_python_not_found"
         except Exception as e:
             self.log_error(f"Update failed with exception: {e}", exc_info=True)
             return "failed_exception"
@@ -448,135 +488,136 @@ class GuardService(win32serviceutil.ServiceFramework):
         return ootb_procs
 
     def handle_stop(self, target_user="all_active"):
+        """Stops the OOTB process for specified user(s). Uses psutil first, then taskkill fallback."""
         self.log_info(f"Executing stop OOTB for target '{target_user}'...")
-        stop_results = {} # Track results per user {username: (task_status, immediate_status)}
-        failed_users = set()
-
-        try:
-             # --- Get target users and active sessions ---
-            active_sessions = {} # user_lower: session_id
-            # No need for all_system_users for stop, we only care about active or the specific target
-            try:
-                 sessions = win32ts.WTSEnumerateSessions(win32ts.WTS_CURRENT_SERVER_HANDLE)
-                 for session in sessions:
-                     if session['State'] == win32ts.WTSActive:
-                         try:
-                             user = win32ts.WTSQuerySessionInformation(win32ts.WTS_CURRENT_SERVER_HANDLE, session['SessionId'], win32ts.WTSUserName)
-                             if user:
-                                 active_sessions[user.lower()] = session['SessionId']
-                         except Exception as query_err:
-                             self.log_error(f"Could not query session {session['SessionId']} during stop: {query_err}")
-            except Exception as user_enum_err:
-                  self.log_error(f"Error enumerating users/sessions during stop: {user_enum_err}", exc_info=True)
-                  return "failed_user_enumeration"
-
-            self.log_info(f"Stop target: '{target_user}'. Active sessions: {active_sessions}")
-
-            target_users_normalized = set()
-            if target_user == "all_active":
-                  # Target only currently active users for stop all
-                  target_users_normalized = set(active_sessions.keys())
-                  self.log_info(f"Stop targeting all active users: {target_users_normalized}")
-            else:
-                  # Target the specific user, regardless of active status (for task removal)
-                  normalized_target = target_user.lower()
-                  target_users_normalized.add(normalized_target)
-                  self.log_info(f"Stop targeting specific user: {normalized_target}")
-
-            if not target_users_normalized:
-                  self.log_info("No target users identified for stop.")
-                  return "failed_no_target_users" # Or success if none were targeted?
-
-            # --- Process each target user ---
-            for user in target_users_normalized:
-                 task_removed_status = "task_unknown"
-                 immediate_stop_status = "stop_not_attempted"
-                 stopped_count = 0
-
-                 self.log_info(f"Processing stop for user '{user}'...")
-
-                 # 1. Always try to remove the scheduled task
-                 try:
-                     # remove_logon_task always returns True for now, just logs attempt
-                     self.remove_logon_task(user)
-                     task_removed_status = "task_removed_attempted"
-                 except Exception as task_err:
-                      self.log_error(f"Exception removing scheduled task for {user}: {task_err}", exc_info=True)
-                      task_removed_status = "task_exception"
-                      failed_users.add(user)
-                      # Continue to try and stop process if active
-
-                 # 2. If user is active, try to terminate process
-                 is_active = user in active_sessions
-
-                 if is_active:
-                     immediate_stop_status = "stop_attempted"
-                     self.log_info(f"User '{user}' is active. Attempting to terminate OOTB process(es)...")
-                     # Pass the specific username to _get_ootb_processes
-                     procs_to_stop = self._get_ootb_processes(user)
-
-                     if not procs_to_stop:
-                         self.log_info(f"No running OOTB processes found for active user '{user}'.")
-                         immediate_stop_status = "stop_skipped_not_running"
-                     else:
-                         self.log_info(f"Found {len(procs_to_stop)} process(es) for user '{user}' to stop.")
-                         for proc in procs_to_stop:
-                             try:
-                                 pid = proc.pid # Get pid before potential termination
-                                 username = proc.info.get('username', 'unknown_user')
-                                 self.log_info(f"Terminating process PID={pid}, User={username}")
-                                 proc.terminate()
-                                 try:
-                                     proc.wait(timeout=3)
-                                     self.log_info(f"Process PID={pid} terminated successfully.")
-                                     stopped_count += 1
-                                 except psutil.TimeoutExpired:
-                                     self.log_error(f"Process PID={pid} did not terminate gracefully, killing.")
-                                     proc.kill()
-                                     stopped_count += 1
-                             except psutil.NoSuchProcess:
-                                  self.log_info(f"Process PID={pid} already terminated.")
-                                  # Don't increment stopped_count here as we didn't stop it now
-                             except psutil.AccessDenied:
-                                 self.log_error(f"Access denied trying to terminate process PID={pid}.")
-                                 failed_users.add(user) # Mark user as failed if stop fails
-                             except Exception as e:
-                                 self.log_error(f"Error stopping process PID={pid}: {e}", exc_info=True)
-                                 failed_users.add(user) # Mark user as failed
-
-                         # Determine status based on how many were found vs stopped
-                         if user in failed_users:
-                              immediate_stop_status = f"stop_errors_terminated_{stopped_count}_of_{len(procs_to_stop)}"
-                         elif stopped_count == len(procs_to_stop):
-                              immediate_stop_status = f"stop_success_terminated_{stopped_count}"
-                         else: # Should ideally not happen if NoSuchProcess doesn't count
-                              immediate_stop_status = f"stop_partial_terminated_{stopped_count}_of_{len(procs_to_stop)}"
-
-                 else: # User not active
-                     self.log_info(f"User '{user}' is not active. Skipping immediate process stop (task removal attempted).")
-                     immediate_stop_status = "stop_skipped_inactive"
-
-                 # Record final results for this user
-                 stop_results[user] = (task_removed_status, immediate_stop_status)
-
-
-            # --- Consolidate status ---
-            total_processed = len(target_users_normalized)
-            final_status = "partial_success" if failed_users else "success"
-            if not stop_results: final_status = "no_targets_processed"
-            if len(failed_users) == total_processed and total_processed > 0 : final_status = "failed"
-
-            self.log_info(f"Finished stopping OOTB. Overall Status: {final_status}. Results: {stop_results}")
+        stopped_count_psutil = 0
+        stopped_count_taskkill = 0
+        errors = []
+        
+        target_users_lower = set()
+        if target_user == "all_active":
             try:
-                details = json.dumps(stop_results)
-            except Exception:
-                details = str(stop_results) # Fallback
-            return f"{final_status}::{details}" # Use :: as separator
+                for user_session in psutil.users():
+                    username_lower = user_session.name.split('\\')[-1].lower()
+                    target_users_lower.add(username_lower)
+                self.log_info(f"Targeting all users found by psutil: {target_users_lower}")
+            except Exception as e:
+                 self.log_error(f"Could not list users via psutil for stop all: {e}")
+                 errors.append("failed_user_enumeration")
+                 target_users_lower = set() # Avoid proceeding if user list failed
+        else:
+            target_users_lower.add(target_user.lower())
+            self.log_info(f"Targeting specific user: {target_user.lower()}")
 
+        if not target_users_lower and target_user == "all_active":
+             self.log_info("No active users found to stop.")
+             # If specific user targeted, proceed even if psutil didn't list them (maybe inactive)
+
+        procs_to_kill_by_user = {user: [] for user in target_users_lower}
+        
+        # --- Attempt 1: psutil find and terminate ---
+        self.log_info("Attempting stop using psutil...")
+        try:
+            all_running = self._get_ootb_processes("all") # Get all regardless of user first
+            for proc in all_running:
+                try:
+                    proc_user = proc.info.get('username')
+                    if proc_user:
+                         user_lower = proc_user.split('\\')[-1].lower()
+                         if user_lower in target_users_lower:
+                              procs_to_kill_by_user[user_lower].append(proc)
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                     pass # Process ended or we can't access it
         except Exception as e:
-             self.log_error(f"Error during combined stop OOTB process: {e}", exc_info=True)
-             return "failed_exception"
+             self.log_error(f"Error getting process list for psutil stop: {e}")
+             errors.append("failed_psutil_list")
 
+        for user, procs in procs_to_kill_by_user.items():
+            if not procs:
+                self.log_info(f"psutil: No OOTB processes found running for user '{user}'.")
+                continue
+            
+            self.log_info(f"psutil: Found {len(procs)} OOTB process(es) for user '{user}'. Attempting terminate...")
+            for proc in procs:
+                try:
+                    pid = proc.pid
+                    self.log_info(f"psutil: Terminating PID {pid} for user '{user}'...")
+                    proc.terminate()
+                    try:
+                         proc.wait(timeout=3) # Wait a bit for termination
+                         self.log_info(f"psutil: PID {pid} terminated successfully.")
+                         stopped_count_psutil += 1
+                    except psutil.TimeoutExpired:
+                         self.log_warning(f"psutil: PID {pid} did not terminate within timeout. Will try taskkill.")
+                         # No error append yet, let taskkill try
+                    except (psutil.NoSuchProcess, psutil.AccessDenied):
+                         self.log_info(f"psutil: PID {pid} already gone or access denied after terminate.")
+                         stopped_count_psutil += 1 # Count it as stopped
+                except (psutil.NoSuchProcess, psutil.AccessDenied) as term_err:
+                     self.log_warning(f"psutil: Error terminating PID {proc.pid if 'proc' in locals() and proc else 'unknown'}: {term_err}. It might be gone already.")
+                     # If it's gone, count it?
+                     stopped_count_psutil += 1 # Assume it's gone if NoSuchProcess
+                except Exception as term_ex:
+                     self.log_error(f"psutil: Unexpected error terminating PID {proc.pid if 'proc' in locals() and proc else 'unknown'}: {term_ex}")
+                     errors.append(f"failed_psutil_terminate_{user}")
+
+        # --- Attempt 2: taskkill fallback (for users where psutil didn't find/stop) ---
+        # Only run taskkill if psutil didn't stop anything for a specific user OR if target was specific user
+        
+        if not self.target_executable_path:
+             errors.append("skipped_taskkill_no_exe_path")
+        else:
+            executable_name = os.path.basename(self.target_executable_path.strip('"'))
+            for user in target_users_lower:
+                run_taskkill = False
+                if user not in procs_to_kill_by_user or not procs_to_kill_by_user[user]:
+                    # psutil didn't find anything for this user initially
+                    run_taskkill = True 
+                    self.log_info(f"taskkill: psutil found no processes for '{user}', attempting taskkill as fallback.")
+                elif any(p.is_running() for p in procs_to_kill_by_user.get(user, []) if p): # Check if any psutil targets still running
+                    run_taskkill = True
+                    self.log_info(f"taskkill: Some processes for '{user}' may remain after psutil, attempting taskkill cleanup.")
+                
+                if run_taskkill:
+                    # Construct taskkill command
+                    # Username format might need adjustment (e.g., DOMAIN\user). Try simple first.
+                    taskkill_command = [
+                        "taskkill", "/F", # Force
+                        "/IM", executable_name, # Image name
+                        "/FI", f"USERNAME eq {user}" # Filter by username
+                    ]
+                    self.log_info(f"Running taskkill command: {' '.join(taskkill_command)}")
+                    try:
+                        result = subprocess.run(taskkill_command, capture_output=True, text=True, check=False)
+                        if result.returncode == 0:
+                             self.log_info(f"taskkill successful for user '{user}' (Exit Code 0).")
+                             # Can't easily count how many were killed here, assume success if exit 0
+                             stopped_count_taskkill += 1 # Indicate taskkill ran successfully for user
+                        elif result.returncode == 128: # Code 128: No tasks found matching criteria
+                             self.log_info(f"taskkill: No matching processes found for user '{user}'.")
+                        else:
+                             self.log_error(f"taskkill failed for user '{user}' (Exit Code {result.returncode}).")
+                             self.log_error(f"  taskkill STDOUT: {result.stdout.strip()}")
+                             self.log_error(f"  taskkill STDERR: {result.stderr.strip()}")
+                             errors.append(f"failed_taskkill_{user}")
+                    except FileNotFoundError:
+                         self.log_error("taskkill command not found.")
+                         errors.append("failed_taskkill_not_found")
+                         break # Stop trying taskkill if command is missing
+                    except Exception as tk_ex:
+                         self.log_error(f"Exception running taskkill for '{user}': {tk_ex}")
+                         errors.append(f"failed_taskkill_exception_{user}")
+
+        # --- Consolidate status --- 
+        final_status = "failed" # Default to failed if errors occurred
+        if stopped_count_psutil > 0 or stopped_count_taskkill > 0:
+             final_status = "success" if not errors else "partial_success"
+        elif not errors:
+             final_status = "success_no_processes_found"
+        
+        details = f"psutil_stopped={stopped_count_psutil}, taskkill_users_attempted={stopped_count_taskkill}, errors={len(errors)}"
+        self.log_info(f"Finished stopping OOTB. Status: {final_status}. Details: {details}")
+        return f"{final_status}::{details}" # Return status and details
 
     def handle_start(self, target_user="all_active"):
         """Handles external start command request (finds users, calls internal trigger)."""

{computer_use_ootb_internal-0.0.139 → computer_use_ootb_internal-0.0.140}/src/computer_use_ootb_internal/preparation/star_rail_prepare.py

@@ -1,6 +1,7 @@
 # src/computer_use_ootb_internal/preparation/star_rail_prepare.py
 import time
 import platform
+import subprocess # Added for taskkill
 import pyautogui
 import webbrowser
 import logging # Use logging instead of print for better practice
@@ -11,7 +12,8 @@ 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.
+    Closes existing Edge browsers, opens the specified URL in a new Edge instance,
+    and performs initial clicks.
     """
     if platform.system() != "Windows":
         log.info("Star Rail preparation skipped: Not running on Windows.")
@@ -21,11 +23,31 @@ def run_preparation(state):
     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
+            # Ensure sleep time for browser load before clicks is present
+            time.sleep(5)
         else:
             log.warning("webbrowser.open() returned False, indicating potential failure.")