computer-use-ootb-internal 0.0.119__py3-none-any.whl → 0.0.120__py3-none-any.whl

computer_use_ootb_internal/guard_service.py

@@ -22,6 +22,7 @@ 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
+import json # Needed for status reporting
 
 # --- Configuration ---
 _SERVICE_NAME = "OOTBGuardService"
@@ -144,6 +145,95 @@ def log_error(msg, exc_info=False):
     except Exception as e:
         logging.warning(f"Could not write error to Windows Event Log: {e}")
 
+# --- PowerShell Task Scheduler Helpers ---
+
+_TASK_NAME_PREFIX = "OOTB_UserLogon_"
+
+def run_powershell_command(command, log_output=True):
+    """Executes a PowerShell command and handles output/errors. Returns True on success."""
+    # Use log_info from the service instance if available, otherwise use root logger
+    logger = _service_instance.log_info if _service_instance else logging.info
+    error_logger = _service_instance.log_error if _service_instance else logging.error
+    logger(f"Executing PowerShell: {command}")
+    try:
+        # Using encoding important for non-ASCII usernames/paths
+        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:
+            logger(f"PowerShell STDOUT:\n{result.stdout.strip()}")
+        if log_output and result.stderr:
+            logger(f"PowerShell STDERR:\n{result.stderr.strip()}") # Log stderr as info
+        return True
+    except FileNotFoundError:
+        error_logger("'powershell.exe' not found. Cannot manage scheduled tasks.")
+        return False
+    except subprocess.CalledProcessError as e:
+        error_logger(f"PowerShell command failed (Exit Code {e.returncode}):")
+        error_logger(f"  Command: {e.cmd}")
+        if e.stdout: error_logger(f"  STDOUT: {e.stdout.strip()}")
+        if e.stderr: error_logger(f"  STDERR: {e.stderr.strip()}")
+        return False
+    except Exception as e:
+        error_logger(f"Unexpected error running PowerShell: {e}", exc_info=True)
+        return False
+
+def create_or_update_logon_task(username, task_command, python_executable):
+    """Creates or updates a scheduled task to run a command at user logon."""
+    logger = _service_instance.log_info if _service_instance else logging.info
+    error_logger = _service_instance.log_error if _service_instance else logging.error
+    task_name = f"{_TASK_NAME_PREFIX}{username}"
+    # Escape single quotes in paths and commands for PowerShell
+    safe_python_exe = python_executable.replace("'", "''")
+    # Ensure task_command is just the arguments, not the python exe itself
+    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: # Fallback if task_command doesn't start with python_exe
+         safe_task_command_args = task_command.replace(python_executable, "").strip().replace("'", "''")
+
+    safe_task_name = task_name.replace("'", "''")
+    safe_username = username.replace("'", "''") # Handle usernames with quotes?
+
+    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 # Indicate failure
+    }}
+    """
+    success = run_powershell_command(command)
+    if success:
+        logger(f"Successfully created/updated scheduled task '{task_name}' for user '{username}'.")
+    else:
+        error_logger(f"Failed to create/update scheduled task '{task_name}' for user '{username}'.")
+    return success
+
+
+def remove_logon_task(username):
+    """Removes the logon scheduled task for a user."""
+    logger = _service_instance.log_info if _service_instance else logging.info
+    task_name = f"{_TASK_NAME_PREFIX}{username}"
+    safe_task_name = task_name.replace("'", "''")
+    command = f"Unregister-ScheduledTask -TaskName '{safe_task_name}' -Confirm:$false -ErrorAction SilentlyContinue"
+    run_powershell_command(command, log_output=False)
+    logger(f"Attempted removal of scheduled task '{task_name}' for user '{username}'.")
+    return True
+
+# --- End PowerShell Task Scheduler Helpers ---
+
 class GuardService(win32serviceutil.ServiceFramework):
     _svc_name_ = _SERVICE_NAME
     _svc_display_name_ = _SERVICE_DISPLAY_NAME
@@ -352,147 +442,306 @@ class GuardService(win32serviceutil.ServiceFramework):
 
     def handle_stop(self, target_user="all_active"):
         log_info(f"Executing stop OOTB for target '{target_user}'...")
-        stopped_count = 0
-        procs_to_stop = self._get_ootb_processes(target_user)
+        stop_results = {} # Track results per user {username: (task_status, immediate_status)}
+        failed_users = set()
 
-        if not procs_to_stop:
-            log_info("No running OOTB processes found for target.")
-            return "no_process_found"
+        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:
+                             log_error(f"Could not query session {session['SessionId']} during stop: {query_err}")
+            except Exception as user_enum_err:
+                  log_error(f"Error enumerating users/sessions during stop: {user_enum_err}", exc_info=True)
+                  return "failed_user_enumeration"
+
+            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())
+                  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)
+                  log_info(f"Stop targeting specific user: {normalized_target}")
+
+            if not target_users_normalized:
+                  log_info("No target users identified for stop.")
+                  return "failed_no_target_users" # Or success if none were targeted?
 
-        for proc in procs_to_stop:
+            # --- Process each target user ---
+            for user in target_users_normalized:
+                 task_removed_status = "task_unknown"
+                 immediate_stop_status = "stop_not_attempted"
+                 stopped_count = 0
+
+                 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
+                     remove_logon_task(user)
+                     task_removed_status = "task_removed_attempted"
+                 except Exception as task_err:
+                      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"
+                     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:
+                         log_info(f"No running OOTB processes found for active user '{user}'.")
+                         immediate_stop_status = "stop_skipped_not_running"
+                     else:
+                         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')
+                                 log_info(f"Terminating process PID={pid}, User={username}")
+                                 proc.terminate()
+                                 try:
+                                     proc.wait(timeout=3)
+                                     log_info(f"Process PID={pid} terminated successfully.")
+                                     stopped_count += 1
+                                 except psutil.TimeoutExpired:
+                                     log_error(f"Process PID={pid} did not terminate gracefully, killing.")
+                                     proc.kill()
+                                     stopped_count += 1
+                             except psutil.NoSuchProcess:
+                                  log_info(f"Process PID={pid} already terminated.")
+                                  # Don't increment stopped_count here as we didn't stop it now
+                             except psutil.AccessDenied:
+                                 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:
+                                 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
+                     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"
+
+            log_info(f"Finished stopping OOTB. Overall Status: {final_status}. Results: {stop_results}")
             try:
-                username = proc.info.get('username', 'unknown_user')
-                log_info(f"Terminating process PID={proc.pid}, User={username}")
-                proc.terminate()
-                try:
-                    proc.wait(timeout=3)
-                    log_info(f"Process PID={proc.pid} terminated successfully.")
-                    stopped_count += 1
-                except psutil.TimeoutExpired:
-                    log_error(f"Process PID={proc.pid} did not terminate gracefully, killing.")
-                    proc.kill()
-                    stopped_count += 1
-            except psutil.NoSuchProcess:
-                 log_info(f"Process PID={proc.pid} already terminated.")
-                 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:
-                log_error(f"Error stopping process PID={proc.pid}: {e}", exc_info=True)
+                details = json.dumps(stop_results)
+            except Exception:
+                details = str(stop_results) # Fallback
+            return f"{final_status}::{details}" # Use :: as separator
 
-        log_info(f"Finished stopping OOTB. Terminated {stopped_count} process(es).")
-        return f"success_stopped_{stopped_count}"
+        except Exception as e:
+             log_error(f"Error during combined stop OOTB process: {e}", exc_info=True)
+             return "failed_exception"
 
 
     def handle_start(self, target_user="all_active"):
         log_info(f"Executing start OOTB for target '{target_user}'...")
-        started_count = 0
-        target_users_started = set()
-        users_failed_to_start = set()
+        start_results = {} # Track results per user {username: (task_status, immediate_status)}
+        failed_users = set()
 
         try:
-            sessions = win32ts.WTSEnumerateSessions(win32ts.WTS_CURRENT_SERVER_HANDLE)
-            active_sessions = {}
-
-            for session in sessions:
-                 if session['State'] == win32ts.WTSActive:
-                    try:
-                         user = win32ts.WTSQuerySessionInformation(win32ts.WTS_CURRENT_SERVER_HANDLE, session['SessionId'], win32ts.WTSUserName)
-                         if user:
-                              normalized_user = user.lower()
-                              active_sessions[normalized_user] = session['SessionId']
-                    except Exception as query_err:
-                         log_error(f"Could not query session {session['SessionId']}: {query_err}")
+            # --- Get target users and active sessions ---
+            active_sessions = {} # user_lower: session_id
+            all_system_users = set() # user_lower
+            try:
+                # Use psutil for system user list, WTS for active sessions/IDs
+                for user_session in psutil.users():
+                    username_lower = user_session.name.split('\\')[-1].lower()
+                    all_system_users.add(username_lower)
+                
+                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:
+                            log_error(f"Could not query session {session['SessionId']}: {query_err}")
+            except Exception as user_enum_err:
+                 log_error(f"Error enumerating users/sessions: {user_enum_err}", exc_info=True)
+                 return "failed_user_enumeration"
 
             log_info(f"Found active user sessions: {active_sessions}")
 
-            target_session_map = {}
+            target_users_normalized = set()
             if target_user == "all_active":
-                 target_session_map = active_sessions
+                 # If targeting all_active, only target those CURRENTLY active
+                 target_users_normalized = set(active_sessions.keys())
+                 log_info(f"Targeting all active users: {target_users_normalized}")
             else:
-                normalized_target = target_user.lower()
-                if normalized_target in active_sessions:
-                     target_session_map[normalized_target] = active_sessions[normalized_target]
-                else:
-                     log_error(f"Target user '{target_user}' not found in active sessions.")
-                     return "failed_user_not_active"
+                 normalized_target = target_user.lower()
+                 # Check if the target user actually exists on the system, even if inactive
+                 # This check might be complex/unreliable. Rely on task scheduler potentially failing?
+                 # Let's assume admin provides a valid username for specific targeting.
+                 # if normalized_target in all_system_users: # Removing this check, assume valid user input
+                 target_users_normalized.add(normalized_target)
+                 log_info(f"Targeting specific user: {normalized_target}")
+                 # else:
+                 #     log_error(f"Target user '{target_user}' does not appear to exist on this system based on psutil.")
+                 #     return "failed_user_does_not_exist"
+
+            if not target_users_normalized:
+                 log_info("No target users identified (or none active for 'all_active').")
+                 # If target was specific user but they weren't found active, still try task?
+                 # Let's proceed to task creation anyway for specific user case.
+                 if target_user != "all_active": target_users_normalized.add(target_user.lower())
+                 if not target_users_normalized:
+                      return "failed_no_target_users"
+            
+            # --- Check existing processes --- 
+            # This check is only relevant for immediate start attempt
+            running_procs_by_user = {} # user_lower: count
+            try:
+                current_running = self._get_ootb_processes("all_active") # Check all
+                for proc in current_running:
+                    try:
+                        proc_username = proc.info.get('username')
+                        if proc_username:
+                             user_lower = proc_username.split('\\')[-1].lower()
+                             running_procs_by_user[user_lower] = running_procs_by_user.get(user_lower, 0) + 1
+                    except Exception: pass
+            except Exception as e:
+                 log_error(f"Error checking existing processes: {e}")
+            log_info(f"Users currently running OOTB: {running_procs_by_user}")
 
-            if not target_session_map:
-                 log_info("No target user sessions found to start OOTB in.")
-                 return "failed_no_target_sessions"
+            # --- Process each target user ---
+            for user in target_users_normalized:
+                task_created_status = "task_unknown"
+                immediate_start_status = "start_not_attempted"
+                token = None # Ensure token is reset/defined
 
-            running_procs = self._get_ootb_processes(target_user)
-            users_already_running = set()
-            for proc in running_procs:
-                try:
-                     proc_username = proc.info.get('username')
-                     if proc_username:
-                          users_already_running.add(proc_username.split('\\')[-1].lower())
-                except Exception:
-                     pass
+                log_info(f"Processing start for user '{user}'...")
 
-            log_info(f"Users already running OOTB: {users_already_running}")
+                # 1. Always try to create/update the scheduled task
+                try:
+                    task_created = create_or_update_logon_task(user, self.ootb_command, self.python_exe)
+                    task_created_status = "task_success" if task_created else "task_failed"
+                except Exception as task_err:
+                     log_error(f"Exception creating/updating scheduled task for {user}: {task_err}", exc_info=True)
+                     task_created_status = "task_exception"
+                     failed_users.add(user)
+                     # Continue to potentially try immediate start IF user is active?
+                     # Or maybe skip if task creation failed badly?
+                     # Let's skip immediate start if task creation had exception.
+                     start_results[user] = (task_created_status, immediate_start_status)
+                     continue
+
+                # 2. If user is active AND not already running, try immediate start
+                is_active = user in active_sessions
+                is_running = running_procs_by_user.get(user, 0) > 0
+
+                if is_active:
+                    if not is_running:
+                        immediate_start_status = "start_attempted"
+                        log_info(f"User '{user}' is active and not running OOTB. Attempting immediate start...")
+                        try:
+                            session_id = active_sessions[user]
+                            token = win32ts.WTSQueryUserToken(session_id)
+                            env = win32profile.CreateEnvironmentBlock(token, False)
+                            startup = win32process.STARTUPINFO()
+                            startup.dwFlags = win32process.STARTF_USESHOWWINDOW
+                            startup.wShowWindow = win32con.SW_HIDE
+                            creation_flags = win32process.CREATE_NEW_CONSOLE | win32process.CREATE_UNICODE_ENVIRONMENT
+                            user_profile_dir = win32profile.GetUserProfileDirectory(token)
+
+                            hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
+                                token, self.python_exe, self.ootb_command,
+                                None, None, False, creation_flags, env, user_profile_dir, startup
+                            )
+                            log_info(f"CreateProcessAsUser call succeeded for user '{user}' (PID: {dwPid}). Checking existence...")
+                            win32api.CloseHandle(hProcess)
+                            win32api.CloseHandle(hThread)
+
+                            time.sleep(1)
+                            if psutil.pid_exists(dwPid):
+                                log_info(f"Immediate start succeeded for user '{user}' (PID {dwPid}).")
+                                immediate_start_status = "start_success"
+                            else:
+                                log_error(f"Immediate start failed for user '{user}': Process {dwPid} exited immediately.")
+                                immediate_start_status = "start_failed_exited"
+                                failed_users.add(user)
+
+                        except Exception as proc_err:
+                             log_error(f"Exception during immediate start for user '{user}': {proc_err}", exc_info=True)
+                             immediate_start_status = "start_failed_exception"
+                             failed_users.add(user)
+                        finally:
+                             if token:
+                                  try: win32api.CloseHandle(token)
+                                  except: pass
+                    else: # User is active but already running
+                        log_info(f"User '{user}' is active but OOTB is already running. Skipping immediate start.")
+                        immediate_start_status = "start_skipped_already_running"
+                else: # User is not active
+                     log_info(f"User '{user}' is not active. Skipping immediate start (task created/updated).")
+                     immediate_start_status = "start_skipped_inactive"
+                
+                # Record final results for this user
+                start_results[user] = (task_created_status, immediate_start_status)
+
+
+            # --- Consolidate status --- 
+            total_processed = len(target_users_normalized)
+            final_status = "partial_success" if failed_users else "success"
+            if not start_results: final_status = "no_targets_processed"
+            # If all processed users failed in some way (either task or start)
+            if len(failed_users) == total_processed and total_processed > 0: final_status = "failed"
+            # Special case: target was specific user who wasn't found active
+            elif total_processed == 1 and target_user != "all_active" and target_user.lower() not in active_sessions: 
+                user_key = target_user.lower()
+                if user_key in start_results and start_results[user_key][0] == "task_success":
+                    final_status = "success_task_only_user_inactive"
+                else:
+                    final_status = "failed_task_user_inactive"
 
-            for user, session_id in target_session_map.items():
-                 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}...")
-                     token = win32ts.WTSQueryUserToken(session_id)
-                     env = win32profile.CreateEnvironmentBlock(token, False)
-                     startup = win32process.STARTUPINFO()
-                     # Simplify startup flags: Run hidden, don't explicitly set desktop
-                     startup.dwFlags = win32process.STARTF_USESHOWWINDOW
-                     startup.wShowWindow = win32con.SW_HIDE
-                     # startup.lpDesktop = 'winsta0\\default' # Removed
-
-                     creation_flags = win32process.CREATE_NEW_CONSOLE | win32process.CREATE_UNICODE_ENVIRONMENT
-                     # Define cwd as user's profile directory if possible
-                     user_profile_dir = win32profile.GetUserProfileDirectory(token)
-
-                     hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
-                         token, self.python_exe, self.ootb_command,
-                         None, None, False, creation_flags, env, 
-                         user_profile_dir, # Set current directory
-                         startup
-                     )
-                     log_info(f"CreateProcessAsUser call succeeded for user '{user}' (PID: {dwPid}).")
-
-                     # Add post-start check
-                     time.sleep(1) # Small delay
-                     if psutil.pid_exists(dwPid):
-                         log_info(f"Process PID {dwPid} confirmed to exist shortly after creation.")
-                         started_count += 1
-                         target_users_started.add(user)
-                     else:
-                         log_error(f"Process PID {dwPid} reported by CreateProcessAsUser does NOT exist shortly after creation. It likely exited immediately.")
-                         users_failed_to_start.add(user)
-                         # Attempt to get exit code? Difficult without waiting.
-
-                     win32api.CloseHandle(hProcess)
-                     win32api.CloseHandle(hThread)
-
-                 except Exception as proc_err:
-                      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:
-                      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)}"
-            elif started_count > 0:
-                 return f"success_started_{started_count}"
-            else:
-                 return "no_action_needed_already_running"
+            log_info(f"Finished starting OOTB. Overall Status: {final_status}. Results: {start_results}")
+            # Return detailed results as a JSON string for easier parsing/logging server-side
+            try: 
+                details = json.dumps(start_results)
+            except Exception: 
+                details = str(start_results) # Fallback
+            return f"{final_status}::{details}" 
 
         except Exception as e:
-             log_error(f"Error during start OOTB process: {e}", exc_info=True)
+             log_error(f"Error during combined start OOTB process: {e}", exc_info=True)
              return "failed_exception"
 
 # --- Main Execution Block ---

computer_use_ootb_internal/service_manager.py

@@ -10,6 +10,7 @@ import time
 # Constants need to match guard_service.py
 _SERVICE_NAME = "OOTBGuardService"
 _SERVICE_DISPLAY_NAME = "OOTB Guard Service"
+_TASK_NAME_PREFIX = "OOTB_UserLogon_" # Must match guard_service.py
 
 def is_admin():
     """Check if the script is running with administrative privileges."""
@@ -104,6 +105,41 @@ def run_service_command(command_args, check_errors=True):
         print(f"An unexpected error occurred running service command: {e}", file=sys.stderr)
         return False
 
+# --- Add cleanup helpers ---
+def _run_powershell_cleanup_command(command):
+    """Executes a PowerShell command specifically for cleanup, ignoring most errors."""
+    if platform.system() != "Windows": return True # Skip on non-windows
+    print(f"Executing PowerShell Cleanup: {command}")
+    try:
+        # Use check=False, don't capture output unless needed for debug
+        subprocess.run(
+            ["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", command],
+            check=False, # Don't throw error if command fails (e.g., no tasks found)
+            stdout=subprocess.DEVNULL, # Suppress stdout
+            stderr=subprocess.DEVNULL  # Suppress stderr
+        )
+        return True # Assume success for cleanup flow
+    except Exception as e:
+        print(f"Warning: PowerShell cleanup command failed: {e}", file=sys.stderr)
+        return False # Indicate potential issue
+
+def _cleanup_scheduled_tasks():
+    """Removes all OOTB user logon scheduled tasks."""
+    print("Attempting to remove any existing OOTB user logon scheduled tasks...")
+    # Use -like operator and wildcard
+    # Use try-catch within PowerShell for robustness
+    command = f"""
+    $tasks = Get-ScheduledTask | Where-Object {{ $_.TaskName -like '{_TASK_NAME_PREFIX}*' }}
+    if ($tasks) {{
+        Write-Host "Found $($tasks.Count) OOTB logon tasks to remove."
+        $tasks | Unregister-ScheduledTask -Confirm:$false -ErrorAction SilentlyContinue
+        Write-Host "OOTB logon task removal attempted."
+    }} else {{
+        Write-Host "No OOTB logon tasks found to remove."
+    }}
+    """
+    _run_powershell_cleanup_command(command)
+# --- End cleanup helpers ---
 
 def install_and_start():
     """Installs and starts the Guard Service."""
@@ -133,17 +169,24 @@ def install_and_start():
 
 
 def stop_and_remove():
-    """Stops and removes the Guard Service."""
+    """Stops and removes the Guard Service and associated scheduled tasks."""
     print(f"Attempting to stop service: '{_SERVICE_NAME}' (will ignore errors if not running)")
     # Run stop first, ignore errors (check_errors=False)
     run_service_command(['stop'], check_errors=False)
     time.sleep(2) # Give service time to stop
 
     print(f"\nAttempting to remove service: '{_SERVICE_NAME}'")
-    if run_service_command(['remove']):
-        print(f"\nService '{_SERVICE_NAME}' stopped (if running) and removed successfully.")
+    remove_success = run_service_command(['remove']) # Check if removal command itself failed
+
+    # Always attempt task cleanup, even if service removal had issues
+    _cleanup_scheduled_tasks()
+
+    if remove_success:
+        print(f"\nService '{_SERVICE_NAME}' stopped (if running) and removed successfully. Associated logon tasks cleanup attempted.")
     else:
-        print(f"\nService '{_SERVICE_NAME}' removal failed.", file=sys.stderr)
+        print(f"\nService '{_SERVICE_NAME}' removal command failed.", file=sys.stderr)
+        # Make sure to mention cleanup was still attempted
+        print(f" Associated logon tasks cleanup attempted.", file=sys.stderr)
         print(f" Ensure the service was stopped first, or check permissions.", file=sys.stderr)
 
 if __name__ == '__main__':

{computer_use_ootb_internal-0.0.119.dist-info → computer_use_ootb_internal-0.0.120.dist-info}/METADATA

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

{computer_use_ootb_internal-0.0.119.dist-info → computer_use_ootb_internal-0.0.120.dist-info}/RECORD

@@ -3,10 +3,10 @@ computer_use_ootb_internal/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4Tv
 computer_use_ootb_internal/app_teachmode.py,sha256=PClMS7X6zRGzY7YPOV6Zxkfv5BajLVqmBiv-mOBVxkw,22164
 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=d0tZgzjmS8UQGHx2Yf5HuMtRxdJIgy2zLpUTFQF5JF8,24378
+computer_use_ootb_internal/guard_service.py,sha256=1CiueJvILdqPB1Ncxq9lUIkhUk7yZ-AgVBEwnbmkCNU,39691
 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=xbLIxQ4jzMr8AdZdxKw-QcAGm2Y86vudDzSf3hGjOM4,7595
+computer_use_ootb_internal/service_manager.py,sha256=SD8jzfn0VVXBOr_nP6zmBWSC2TzrU_sp2e5JJkSlQFU,9734
 computer_use_ootb_internal/computer_use_demo/animation/click_animation.py,sha256=tP1gsayFy-CKk10UlrE9RlexwlHWiHQUe5Ogg4vQvSg,3234
 computer_use_ootb_internal/computer_use_demo/animation/icons8-select-cursor-transparent-96.gif,sha256=4LfwsfFQnREXrNRs32aJU2jO65JXianJoL_8q7-8elg,30966
 computer_use_ootb_internal/computer_use_demo/animation/test_animation.py,sha256=2R1u98OLKYalSZ5nt5vvyZ71FL5R5vLv-n8zM8jVdV8,1183
@@ -34,7 +34,7 @@ computer_use_ootb_internal/computer_use_demo/tools/run.py,sha256=xhXdnBK1di9muaO
 computer_use_ootb_internal/computer_use_demo/tools/screen_capture.py,sha256=L8qfvtUkPPQGt92N-2Zfw5ZTDBzLsDps39uMnX3_uSA,6857
 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.119.dist-info/METADATA,sha256=9FKAgkb-tPT3TpODW9nONQUvFwGnX7NwXOJvBKZGAAk,1048
-computer_use_ootb_internal-0.0.119.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-computer_use_ootb_internal-0.0.119.dist-info/entry_points.txt,sha256=bXfyAU_qq-G1EiEgAQEioXvgEdRCFxaTooqdDD9Y4OA,258
-computer_use_ootb_internal-0.0.119.dist-info/RECORD,,
+computer_use_ootb_internal-0.0.120.dist-info/METADATA,sha256=51EX1JLqwmtsEHPfkcQ4Ie2exLtQdAMh6YTigZuhxhU,1048
+computer_use_ootb_internal-0.0.120.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+computer_use_ootb_internal-0.0.120.dist-info/entry_points.txt,sha256=bXfyAU_qq-G1EiEgAQEioXvgEdRCFxaTooqdDD9Y4OA,258
+computer_use_ootb_internal-0.0.120.dist-info/RECORD,,