computer-use-ootb-internal 0.0.136__py3-none-any.whl → 0.0.138__py3-none-any.whl

computer_use_ootb_internal/app_teachmode.py

@@ -190,6 +190,11 @@ async def update_parameters(request: Request):
                 status_code=400
             )
         
+        # Clear message histories before updating parameters
+        shared_state.message_queue.clear()
+        shared_state.chatbot_messages.clear()
+        logging.info("Cleared message queue and chatbot messages.")
+
         shared_state.args = argparse.Namespace(**data)
         shared_state.task_updated = True
         
@@ -301,13 +306,26 @@ async def stop_processing(request: Request):
         shared_state.should_stop = True
         shared_state.stop_event.set()
         
+        # Clear message histories
+        shared_state.message_queue.clear()
+        shared_state.chatbot_messages.clear()
+        logging.info("Cleared message queue and chatbot messages during stop.")
+        
         # Send an immediate message to the queue to inform the user
         stop_initiated_msg = {"role": "assistant", "content": f"Stopping task '{shared_state.task}'...", "type": "text", "action_type": ""}
+        # Append the stop message AFTER clearing, so it's the only one left
+        shared_state.message_queue.append(stop_initiated_msg)
+        shared_state.chatbot_messages.append(stop_initiated_msg)
+        
         return JSONResponse(
             content={"status": "success", "message": "Task is being stopped, server will remain available for new tasks"},
             status_code=200
         )
     else:
+        # Clear message histories even if not processing, to ensure clean state
+        shared_state.message_queue.clear()
+        shared_state.chatbot_messages.clear()
+        logging.info("Cleared message queue and chatbot messages (no active process to stop).")
         return JSONResponse(
             content={"status": "error", "message": "No active processing to stop"},
             status_code=400

computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/llm_utils.py

@@ -12,7 +12,6 @@ def is_image_path(text):
     else:
         return False
 
-
 def encode_image(image_path):
     """Encode image file to base64."""
     with open(image_path, "rb") as image_file:

computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/oai.py

@@ -4,19 +4,7 @@ import logging
 import base64
 import requests
 
-
-def is_image_path(text):
-    # Checking if the input text ends with typical image file extensions
-    image_extensions = (".jpg", ".jpeg", ".png", ".gif", ".bmp", ".tiff", ".tif")
-    if text.endswith(image_extensions):
-        return True
-    else:
-        return False
-
-def encode_image(image_path):
-    """Encode image file to base64."""
-    with open(image_path, "rb") as image_file:
-        return base64.b64encode(image_file.read()).decode("utf-8")
+from .llm_utils import is_image_path, encode_image
     
 
 

computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/run_litellm.py

@@ -4,19 +4,8 @@ import logging
 import base64
 from litellm import completion
 
+from .llm_utils import is_image_path, encode_image
 
-def is_image_path(text):
-    # Checking if the input text ends with typical image file extensions
-    image_extensions = (".jpg", ".jpeg", ".png", ".gif", ".bmp", ".tiff", ".tif")
-    if text.endswith(image_extensions):
-        return True
-    else:
-        return False
-
-def encode_image(image_path):
-    """Encode image file to base64."""
-    with open(image_path, "rb") as image_file:
-        return base64.b64encode(image_file.read()).decode("utf-8")
     
 def run_litellm(messages: list, system: str, llm: str, max_tokens=256, temperature=0):
     """

computer_use_ootb_internal/guard_service.py

@@ -86,6 +86,39 @@ def receive_command():
 
     return jsonify({"message": f"Command {command_id} received and queued"}), 202 # Accepted
 
+@flask_app.route('/internal/user_connected', methods=['POST'])
+def user_connected_notification():
+    """Internal endpoint triggered by the scheduled task helper script."""
+    global _service_instance
+    if not _service_instance:
+        logging.error("Received user_connected signal but service instance is not set.")
+        return jsonify({"error": "Service not ready"}), 503
+
+    if not request.is_json:
+        logging.warning("Received non-JSON user_connected signal.")
+        return jsonify({"error": "Request must be JSON"}), 400
+
+    data = request.get_json()
+    username = data.get("username")
+    if not username:
+        logging.error("Received user_connected signal with no username.")
+        return jsonify({"error": "Missing 'username' in data"}), 400
+
+    logging.info(f"Received user_connected signal for user: {username}")
+
+    # Call the internal start logic directly (non-blocking? or blocking?)
+    # Let's make it non-blocking by putting it on the main command queue
+    # This avoids holding up the signal script and uses the existing processor.
+    internal_command = {
+        "action": "_internal_start_ootb",
+        "target_user": username
+    }
+    internal_command_id = f"internal_{username}_{time.time():.0f}"
+    _service_instance.command_queue.put((internal_command_id, internal_command))
+    logging.info(f"Queued internal start command {internal_command_id} for user {username}.")
+
+    return jsonify({"message": "Signal received and queued"}), 202
+
 # --- Helper Functions --- Only logging helpers needed adjustments
 # Move these inside the class later
 # def get_python_executable(): ...
@@ -193,7 +226,9 @@ class GuardService(win32serviceutil.ServiceFramework):
              self.log_info(f"Using target executable: {self.target_executable_path}")
 
         _service_instance = self
-        self.log_info(f"Service initialized. Target executable set to: {self.target_executable_path}")
+        # Determine path to the signal script
+        self.signal_script_path = self._find_signal_script()
+        self.log_info(f"Service initialized. Target executable: {self.target_executable_path}. Signal script: {self.signal_script_path}")
 
     def SvcStop(self):
         self.log_info(f"Service stop requested.")
@@ -263,9 +298,10 @@ class GuardService(win32serviceutil.ServiceFramework):
                 command_id, command = item
                 action = command.get("action")
                 target = command.get("target_user", "all_active")
-                status = "failed_unknown" # Default
+                status = "failed_unknown" # Default status for external commands
+                is_internal = action == "_internal_start_ootb" 
 
-                self.log_info(f"Dequeued Command ID {command_id}: action='{action}', target='{target}'")
+                self.log_info(f"Dequeued {'Internal' if is_internal else 'External'} Command ID {command_id}: action='{action}', target='{target}'")
 
                 try:
                     if action == "update":
@@ -274,6 +310,11 @@ class GuardService(win32serviceutil.ServiceFramework):
                         status = self.handle_stop(target)
                     elif action == "start_ootb":
                         status = self.handle_start(target)
+                    elif action == "_internal_start_ootb":
+                        # Call the core start logic but don't report status back externally
+                        internal_status = self._trigger_start_for_user(target)
+                        self.log_info(f"Internal start for {target} finished with status: {internal_status}")
+                        # No external status reporting for internal commands
                     else:
                         self.log_error(f"Unknown action in queue: {action}")
                         status = "failed_unknown_action"
@@ -281,7 +322,9 @@ class GuardService(win32serviceutil.ServiceFramework):
                     self.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)
+                    # Only report status for non-internal commands
+                    if not is_internal:
+                         self.report_command_status(command_id, status)
                     self.command_queue.task_done()
 
             except queue.Empty:
@@ -320,25 +363,50 @@ 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...")
         if not self.target_executable_path:
-            self.log_error("Cannot update: Target executable not found.")
+            self.log_error("Cannot update: Target executable path is not set.")
             return "failed_executable_not_found"
 
-        update_command = f"{self.target_executable_path} update"
+        # 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"]
+
         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')
-            self.log_info(f"Update successful: \nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}")
-            return "success"
-        except subprocess.CalledProcessError as e:
-            self.log_error(f"Update failed (Exit Code {e.returncode}):\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}")
-            return f"failed_exit_{e.returncode}"
-        except subprocess.TimeoutExpired:
-             self.log_error(f"Update command timed out.")
-             return "failed_timeout"
+            # Execute the command directly. Running as LocalSystem should have rights to ProgramData.
+            # Capture output for logging.
+            result = subprocess.run(
+                [executable_for_run] + args_for_run, 
+                capture_output=True, 
+                text=True, 
+                check=False, # Don't throw on non-zero exit, we 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
+
+            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}"
+                
+        except FileNotFoundError:
+             self.log_error(f"Update failed: Executable not found at '{executable_for_run}'.")
+             return "failed_executable_not_found"
         except Exception as e:
-            self.log_error(f"Unexpected error during update: {e}", exc_info=True)
+            self.log_error(f"Update failed with exception: {e}", exc_info=True)
             return "failed_exception"
 
     def _get_ootb_processes(self, target_user="all_active"):
@@ -511,218 +579,210 @@ class GuardService(win32serviceutil.ServiceFramework):
 
 
     def handle_start(self, target_user="all_active"):
-        self.log_info(f"Executing start OOTB for target '{target_user}'...")
-        start_results = {} # Track results per user {username: (task_status, immediate_status)}
-        failed_users = set()
+        """Handles external start command request (finds users, calls internal trigger)."""
+        self.log_info(f"External start requested for target '{target_user}'...")
+        # This function now primarily identifies target users and calls the internal trigger method.
+        # The status returned here reflects the process of identifying and triggering,
+        # not necessarily the final success/failure of the actual start (which happens async).
+        
+        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:
+                        self.log_error(f"Could not query session {session['SessionId']}: {query_err}")
+        except Exception as user_enum_err:
+             self.log_error(f"Error enumerating users/sessions: {user_enum_err}", exc_info=True)
+             return "failed_user_enumeration"
+
+        target_users_normalized = set()
+        if target_user == "all_active":
+             target_users_normalized = set(active_sessions.keys())
+             self.log_info(f"Targeting all active users for start: {target_users_normalized}")
+        else:
+             normalized_target = target_user.lower()
+             target_users_normalized.add(normalized_target)
+             self.log_info(f"Targeting specific user for start: {normalized_target}")
+
+        if not target_users_normalized:
+             self.log_info("No target users identified for start.")
+             return "failed_no_target_users"
+        
+        trigger_results = {}
+        for user in target_users_normalized:
+             self.log_info(f"Calling internal start trigger for user: {user}")
+             # Call the core logic directly (this is now synchronous within the handler)
+             # Or queue it? Queuing might be better to avoid blocking the handler if many users.
+             # Let's stick to the queue approach from the internal endpoint:
+             internal_command = {
+                "action": "_internal_start_ootb",
+                "target_user": user
+             }
+             internal_command_id = f"external_{user}_{time.time():.0f}"
+             self.command_queue.put((internal_command_id, internal_command))
+             trigger_results[user] = "queued"
+
+        self.log_info(f"Finished queuing start triggers. Results: {trigger_results}")
+        # The status here just means we successfully queued the actions
+        # Actual success/failure happens in the command processor later.
+        # We might need a different way to report overall status if needed.
+        return f"success_queued::{json.dumps(trigger_results)}" 
+
+
+    def _trigger_start_for_user(self, username):
+        """Core logic to start OOTB for a single user. Called internally."""
+        user = username.lower() # Ensure lowercase
+        self.log_info(f"Internal trigger: Starting OOTB check for user '{user}'...")
+        task_created_status = "task_unknown"
+        immediate_start_status = "start_not_attempted"
+        final_status = "failed_unknown"
 
         try:
-            # --- Get target users and active sessions ---
-            active_sessions = {} # user_lower: session_id
-            all_system_users = set() # user_lower
+            # 1. Ensure scheduled task exists (still useful fallback/persistence)
+            try:
+                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"Internal trigger: Exception creating/updating task for {user}: {task_err}", exc_info=True)
+                 task_created_status = "task_exception"
+                 # Don't necessarily fail the whole operation yet
+            
+            # 2. Check if user is active
+            active_sessions = {} # Re-check active sessions specifically for this user
+            session_id = None
+            token = None
+            is_active = False
             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:
-                            self.log_error(f"Could not query session {session['SessionId']}: {query_err}")
-            except Exception as user_enum_err:
-                 self.log_error(f"Error enumerating users/sessions: {user_enum_err}", exc_info=True)
-                 return "failed_user_enumeration"
-
-            self.log_info(f"Found active user sessions: {active_sessions}")
-
-            target_users_normalized = set()
-            if target_user == "all_active":
-                 # If targeting all_active, only target those CURRENTLY active
-                 target_users_normalized = set(active_sessions.keys())
-                 self.log_info(f"Targeting all active users: {target_users_normalized}")
-            else:
-                 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)
-                 self.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:
-                 self.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"
+                            current_user = win32ts.WTSQuerySessionInformation(win32ts.WTS_CURRENT_SERVER_HANDLE, session['SessionId'], win32ts.WTSUserName)
+                            if current_user and current_user.lower() == user:
+                                session_id = session['SessionId']
+                                is_active = True
+                                self.log_info(f"Internal trigger: User '{user}' is active in session {session_id}.")
+                                break
+                        except Exception: pass # Ignore errors querying other sessions
+            except Exception as e:
+                 self.log_error(f"Internal trigger: Error checking active sessions for {user}: {e}")
+                 # Continue, assume inactive if check failed?
             
-            # --- Check existing processes --- 
-            # This check is only relevant for immediate start attempt
-            running_procs_by_user = {} # user_lower: count
+            if not is_active:
+                self.log_info(f"Internal trigger: User '{user}' is not active. Skipping immediate start.")
+                immediate_start_status = "start_skipped_inactive"
+                final_status = task_created_status # Status depends only on task creation
+                return final_status # Exit early if inactive
+
+            # 3. Check if already running for this active user
+            is_running = False
             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
+                running_procs = self._get_ootb_processes(user)
+                if running_procs:
+                     is_running = True
+                     self.log_info(f"Internal trigger: OOTB already running for active user '{user}'. Skipping immediate start.")
+                     immediate_start_status = "start_skipped_already_running"
+                     final_status = "success_already_running" # Considered success
+                     return final_status # Exit early if already running
             except Exception as e:
-                 self.log_error(f"Error checking existing processes: {e}")
-            self.log_info(f"Users currently running OOTB: {running_procs_by_user}")
-
-            # --- 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
-
-                self.log_info(f"Processing start for user '{user}'...")
-
-                # 1. Always try to create/update the scheduled task
-                try:
-                    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)
-                     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"
-                        self.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) # <-- Restore creating env block
-                            startup = win32process.STARTUPINFO()
-                            creation_flags = 0x00000010 # CREATE_NEW_CONSOLE
-
-                            # --- Launch via cmd /K ---
-                            lpApplicationName = None
-                            lpCommandLine = f'cmd.exe /K "{self.target_executable_path}"' 
-                            cwd = os.path.dirname(self.target_executable_path.strip('"')) if os.path.dirname(self.target_executable_path.strip('"')) != '' else None
-                            # --- End Launch via cmd /K ---
-
-                            self.log_info(f"Calling CreateProcessAsUser to launch via cmd /K (Restored Environment Block):") # Updated log note
-                            self.log_info(f"  lpApplicationName: {lpApplicationName}")
-                            self.log_info(f"  lpCommandLine: {lpCommandLine}")
-                            self.log_info(f"  lpCurrentDirectory: {cwd if cwd else 'Default'}")
-                            self.log_info(f"  dwCreationFlags: {creation_flags} (CREATE_NEW_CONSOLE)")
-
-                            # CreateProcessAsUser call with restored env 
-                            hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
-                                token,              # User token
-                                lpApplicationName,  # Application name (None)
-                                lpCommandLine,      # Command line (cmd.exe /K "...")
-                                None,               # Process attributes
-                                None,               # Thread attributes
-                                False,              # Inherit handles
-                                creation_flags,     # Creation flags (CREATE_NEW_CONSOLE)
-                                env,                # Environment block (Restored)
-                                cwd,                # Current directory for cmd.exe
-                                startup             # Startup info
-                            )
-
-                            self.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):
-                                self.log_info(f"Immediate start succeeded for user '{user}' (PID {dwPid}).")
-                                immediate_start_status = "start_success"
-                            else:
-                                self.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:
-                             self.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
-                        self.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
-                     self.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)
+                 self.log_error(f"Internal trigger: Error checking existing processes for {user}: {e}")
+                 # Continue and attempt start despite error?
 
-
-            # --- 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"
+            # 4. Attempt immediate start (User is active and not running)
+            immediate_start_status = "start_attempted"
+            self.log_info(f"Internal trigger: User '{user}' is active and not running. Attempting immediate start via CreateProcessAsUser...")
+            try:
+                token = win32ts.WTSQueryUserToken(session_id)
+                env = win32profile.CreateEnvironmentBlock(token, False)
+                startup = win32process.STARTUPINFO()
+                creation_flags = 0x00000010 # CREATE_NEW_CONSOLE
+                lpApplicationName = None
+                lpCommandLine = f'cmd.exe /K "{self.target_executable_path}"'
+                cwd = os.path.dirname(self.target_executable_path.strip('"')) if os.path.dirname(self.target_executable_path.strip('"')) != '' else None
+
+                # Log details before call
+                self.log_info(f"Internal trigger: Calling CreateProcessAsUser:")
+                self.log_info(f"  lpCommandLine: {lpCommandLine}")
+                self.log_info(f"  lpCurrentDirectory: {cwd if cwd else 'Default'}")
+
+                hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
+                    token, lpApplicationName, lpCommandLine, None, None, False,
+                    creation_flags, env, cwd, startup
+                )
+                self.log_info(f"Internal trigger: CreateProcessAsUser call succeeded for user '{user}' (PID: {dwPid}). Checking existence...")
+                win32api.CloseHandle(hProcess)
+                win32api.CloseHandle(hThread)
+
+                time.sleep(1)
+                if psutil.pid_exists(dwPid):
+                    self.log_info(f"Internal trigger: Immediate start succeeded for user '{user}' (PID {dwPid}).")
+                    immediate_start_status = "start_success"
+                    final_status = "success" # Overall success
                 else:
-                    final_status = "failed_task_user_inactive"
-
-            self.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}" 
+                    self.log_error(f"Internal trigger: Immediate start failed for user '{user}': Process {dwPid} exited immediately.")
+                    immediate_start_status = "start_failed_exited"
+                    final_status = "failed_start_exited"
+
+            except Exception as proc_err:
+                 self.log_error(f"Internal trigger: Exception during CreateProcessAsUser for user '{user}': {proc_err}", exc_info=True)
+                 immediate_start_status = "start_failed_exception"
+                 final_status = "failed_start_exception"
+            finally:
+                 if token: win32api.CloseHandle(token)
+            
+            # Combine results (though mostly determined by start attempt now)
+            # Example: final_status = f"{task_created_status}_{immediate_start_status}"
+            return final_status
 
         except Exception as e:
-             self.log_error(f"Error during combined start OOTB process: {e}", exc_info=True)
-             return "failed_exception"
+             self.log_error(f"Internal trigger: Unexpected error processing start for {username}: {e}", exc_info=True)
+             return "failed_trigger_exception"
+
 
     def create_or_update_logon_task(self, username):
-        """Creates/updates task to run OOTB app via cmd /K on session connect/reconnect."""
-        if not self.target_executable_path:
-            self.log_error(f"Cannot create task for {username}: Target executable path is not set.")
+        """Creates/updates task to trigger the internal signal script on session connect."""
+        if not self.signal_script_path:
+            self.log_error(f"Cannot create task for {username}: Signal script path is not set.")
             return False
+        if not sys.executable:
+             self.log_error(f"Cannot create task for {username}: sys.executable is not found.")
+             return False
+        
+        # Use the python executable that the service itself is running under
+        python_exe = sys.executable
+        if ' ' in python_exe and not python_exe.startswith('"'):
+             python_exe = f'"{python_exe}"'
 
         task_name = f"OOTB_UserConnect_{username}"
-        # Action: Revert to running the actual executable via cmd /K
-        action_executable = 'cmd.exe'
-        action_arguments = f'/K "{self.target_executable_path}"'
-        safe_action_executable = action_executable.replace("'", "''")
-        safe_action_arguments = action_arguments.replace("'", "''")
+        # Action: Run python.exe with the signal script and username argument
+        action_executable = python_exe
+        # Ensure script path is quoted if needed
+        script_arg = self.signal_script_path # Should be quoted already by _find_signal_script
+        # Username might need quoting if it contains spaces, though unlikely
+        user_arg = username # Keep simple for now
+        action_arguments = f'{script_arg} "{user_arg}"' # Pass username as quoted arg
+        safe_action_executable = action_executable.replace("'", "''") # Escape for PS
+        safe_action_arguments = action_arguments.replace("'", "''") # Escape for PS
         
-        # Explicitly set the working directory to the executable's location
+        # Working directory for the script (likely its own directory)
         try:
-            executable_dir = os.path.dirname(self.target_executable_path.strip('"'))
-            if not executable_dir: executable_dir = "."
-            safe_working_directory = executable_dir.replace("'", "''")
+            script_dir = os.path.dirname(self.signal_script_path.strip('"'))
+            if not script_dir: script_dir = "."
+            safe_working_directory = script_dir.replace("'", "''")
             working_directory_setting = f"$action.WorkingDirectory = '{safe_working_directory}'"
         except Exception as e:
-             self.log_error(f"Error determining working directory for task: {e}. WD will not be set.")
+             self.log_error(f"Error determining working directory for signal script task: {e}. WD will not be set.")
              working_directory_setting = "# Could not set WorkingDirectory"
 
         # PowerShell command construction
@@ -730,33 +790,29 @@ class GuardService(win32serviceutil.ServiceFramework):
         $taskName = "{task_name}"
         $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive
         
-        # Action: Run the OOTB executable via cmd /K
+        # Action: Run python signal script
         $action = New-ScheduledTaskAction -Execute '{safe_action_executable}' -Argument '{safe_action_arguments}'
-        {working_directory_setting} # Set the working directory
+        {working_directory_setting}
 
-        # Triggers: On session connect (21) AND reconnect (25)
+        # Trigger: On session connect (Event ID 21)
         $logName = 'Microsoft-Windows-TerminalServices-LocalSessionManager/Operational'
         $source = 'Microsoft-Windows-TerminalServices-LocalSessionManager'
-        # Define multiple triggers
-        $trigger1 = New-ScheduledTaskTrigger -Event -LogName $logName -Source $source -EventId 21
-        $trigger2 = New-ScheduledTaskTrigger -Event -LogName $logName -Source $source -EventId 25
-        # Optional Delay - Apply to both triggers if desired?
-        # $trigger1.Delay = 'PT15S' 
-        # $trigger2.Delay = 'PT15S'
+        $eventIDs = @(21, 25) 
+        $trigger = New-ScheduledTaskTrigger -Event -LogName $logName -Source $source -EventId $eventIDs[0]
+        # Optional Delay: -Delay 'PT15S'
+        # $trigger.Delay = 'PT15S'
         
         $settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit (New-TimeSpan -Days 9999) -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1)
-        $description = "Runs OOTB Application (via cmd) for user {username} upon session connect/reconnect." # Updated description
+        $description = "Triggers OOTB Guard Service for user {username} upon session connect via internal signal." # Updated description
 
-        # Unregister existing task first (force) - Use the NEW task name
+        # Unregister existing task first (force)
         Unregister-ScheduledTask -TaskName $taskName -Confirm:$false -ErrorAction SilentlyContinue
 
-        # Register the new task with MULTIPLE triggers
-        Register-ScheduledTask -TaskName $taskName -Principal $principal -Action $action -Trigger $trigger1, $trigger2 -Settings $settings -Description $description -Force
-
+        # 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 OOTB on session connect/reconnect.")
+        self.log_info(f"Attempting to create/update task '{task_name}' for user '{username}' to run signal script.")
         try:
-            # Need to actually run the powershell command here!
             success = self.run_powershell_command(ps_command)
             if success:
                  self.log_info(f"Successfully ran PowerShell command to create/update task '{task_name}'.")
@@ -805,6 +861,24 @@ class GuardService(win32serviceutil.ServiceFramework):
         self.log_info(f"Attempted removal of scheduled task '{task_name}' for user '{username}'.")
         return True
 
+    def _find_signal_script(self):
+        """Finds the signal_connection.py script relative to this service file."""
+        try:
+            base_dir = os.path.dirname(os.path.abspath(__file__))
+            script_path = os.path.join(base_dir, "signal_connection.py")
+            if os.path.exists(script_path):
+                self.log_info(f"Found signal script at: {script_path}")
+                # Quote if needed?
+                if " " in script_path and not script_path.startswith('"'):
+                    return f'"{script_path}"'
+                return script_path
+            else:
+                self.log_error(f"Signal script signal_connection.py not found near {base_dir}")
+                return None
+        except Exception as e:
+            self.log_error(f"Error finding signal script: {e}")
+            return None
+
 # --- Main Execution Block ---
 if __name__ == '__main__':
     if len(sys.argv) > 1 and sys.argv[1] == 'debug':

computer_use_ootb_internal/preparation/star_rail_prepare.py

@@ -1,7 +1,6 @@
 # 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
@@ -12,8 +11,7 @@ log = logging.getLogger(__name__)
 def run_preparation(state):
     """
     Performs environment preparation specific to Star Rail on Windows.
-    Closes existing Edge browsers, opens the specified URL in a new Edge instance,
-    and performs initial clicks.
+    Opens the specified URL in Edge and performs initial clicks.
     """
     if platform.system() != "Windows":
         log.info("Star Rail preparation skipped: Not running on Windows.")
@@ -23,31 +21,11 @@ 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
-            # Keep original sleep time for browser load before clicks
-            time.sleep(5) 
         else:
             log.warning("webbrowser.open() returned False, indicating potential failure.")
 

computer_use_ootb_internal/run_teachmode_ootb_args.py

@@ -3,6 +3,7 @@ import time
 import json
 import platform
 import uuid
+import base64
 import datetime
 from datetime import datetime, timedelta, timezone
 
@@ -74,7 +75,10 @@ def simple_teachmode_sampling_loop(
         # yield {"role": "assistant", "content": "screenshot", "type": "action", "action_type": "screenshot"}
 
         if is_image_path(sc_path):
-            yield {"role": "assistant", "content": sc_path, "type": "image", "action_type": "screenshot"} 
+            # yield {"role": "assistant", "content": sc_path, "type": "image", "action_type": "screenshot"} 
+            with open(sc_path, "rb") as image_file:
+                sc_base64 = base64.b64encode(image_file.read()).decode('utf-8')
+            yield {"role": "assistant", "content": sc_base64, "type": "image_base64", "action_type": "screenshot"} 
 
         payload = {
             "task_id": unique_task_id,

computer_use_ootb_internal/signal_connection.py

@@ -0,0 +1,48 @@
+# Helper script to signal guard service about user connection
+# Save as e.g., ootb_lite_pypi/ootb_lite_pypi/src/computer_use_ootb_internal/signal_connection.py
+import sys
+import requests
+import logging
+import os
+import pathlib
+
+# Basic logging for the script itself
+LOG_DIR = pathlib.Path(os.environ.get('PROGRAMDATA', 'C:/ProgramData')) / "OOTBGuardService" / "SignalLogs"
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+LOG_FILE = LOG_DIR / "signal_connection.log"
+
+logging.basicConfig(
+    filename=LOG_FILE,
+    level=logging.INFO,
+    format='%(asctime)s %(levelname)s: %(message)s'
+)
+
+GUARD_SERVICE_URL = "http://localhost:14000/internal/user_connected"
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        logging.error("Username argument missing.")
+        sys.exit(1)
+
+    username = sys.argv[1]
+    logging.info(f"Signaling connection for user: {username}")
+
+    payload = {"username": username}
+
+    try:
+        response = requests.post(GUARD_SERVICE_URL, json=payload, timeout=10)
+        response.raise_for_status()
+        logging.info(f"Successfully signaled connection for user {username}. Status: {response.status_code}")
+        sys.exit(0)
+    except requests.exceptions.ConnectionError:
+        logging.error(f"Connection refused when trying to signal for user {username}. Guard service might not be running or accessible.")
+        sys.exit(2)
+    except requests.exceptions.Timeout:
+        logging.error(f"Timeout when trying to signal for user {username}.")
+        sys.exit(3)
+    except requests.exceptions.RequestException as e:
+        logging.error(f"Error signaling connection for user {username}: {e}")
+        sys.exit(4)
+    except Exception as e:
+        logging.error(f"Unexpected error for user {username}: {e}")
+        sys.exit(5) 

{computer_use_ootb_internal-0.0.136.dist-info → computer_use_ootb_internal-0.0.138.dist-info}/METADATA

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

{computer_use_ootb_internal-0.0.136.dist-info → computer_use_ootb_internal-0.0.138.dist-info}/RECORD

@@ -1,11 +1,12 @@
 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=ZZW98870QPNK76LN4f4k9RjBELYcF_3hl0w0fvxj3dY,22268
+computer_use_ootb_internal/app_teachmode.py,sha256=76JbhRhhB-PohVJ-PJSpqMPMqvLGH8QwKTZnPRXYO3w,23176
 computer_use_ootb_internal/dependency_check.py,sha256=y8RMEP6RXQzTgU1MS_1piBLtz4J-Hfn9RjUZg59dyvo,1333
-computer_use_ootb_internal/guard_service.py,sha256=T0j18PIbeHMTrV4myQX8DRobrL5ysi3HGraCAGrUykw,44652
+computer_use_ootb_internal/guard_service.py,sha256=RjnfBIsLU0P4T1o2lMWFY1lSmAOILhJmhUiYzrTxg4A,47329
 computer_use_ootb_internal/requirements-lite.txt,sha256=5DAHomz4A_P2BmTIXNkNqkHbnIF0AyZ4_1XAlb1LaYs,290
-computer_use_ootb_internal/run_teachmode_ootb_args.py,sha256=HB7L9vuIPUXVqeTicyNJKArzTNAfgdpsyO3JEzmByIo,7315
+computer_use_ootb_internal/run_teachmode_ootb_args.py,sha256=3ud1hvvOkODD3woc0Zwe5UG5p8x2KEHLks7JfdFRzCg,7579
 computer_use_ootb_internal/service_manager.py,sha256=SD8jzfn0VVXBOr_nP6zmBWSC2TzrU_sp2e5JJkSlQFU,9734
+computer_use_ootb_internal/signal_connection.py,sha256=8jPLOj0WSBXI_NElm5A-F146DTAE5LdL07lov7YXTNQ,1774
 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
@@ -16,9 +17,9 @@ computer_use_ootb_internal/computer_use_demo/gui_agent/gui_parser/simple_parser/
 computer_use_ootb_internal/computer_use_demo/gui_agent/gui_parser/uia_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 computer_use_ootb_internal/computer_use_demo/gui_agent/gui_parser/uia_tools/screenshot_cli.py,sha256=hrUBH3aeUe9t4EDsMhaUZLPpNLKeEaG4ZvikrFy-bOU,1313
 computer_use_ootb_internal/computer_use_demo/gui_agent/gui_parser/uia_tools/screenshot_service.py,sha256=fJ8G4_-ZLGsHLdLgHCNgjVM1osbfz21L2w8QrcvnuhA,2738
-computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/llm_utils.py,sha256=TtsB1sf8xrolt-fHyaJvRW7vY1gstlo9qqwOIG5wWww,3985
-computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/oai.py,sha256=zWAHa37fhIWCYpIEvQsIe5prfBJQ9yZFQwAi_dm8baE,4158
-computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/run_litellm.py,sha256=SBnWMhwZoCFji9-ii7VSfPYAhDKUWvlJgJzw9-Ei3-g,7750
+computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/llm_utils.py,sha256=ySvoB-ZndjKF-189ZUnRIOK5_hWYQDfc4dGgCjyuFOI,3984
+computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/oai.py,sha256=ezsUlGiNGKh1qjcEw3sf8wxvlJJopKbcqFuMfb5aTGo,3753
+computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/run_litellm.py,sha256=lKvobmbZ5mLsAxwUDdQ-RKQ1J9yiWu581tMbrO5QFOA,7346
 computer_use_ootb_internal/computer_use_demo/gui_agent/llm_utils/run_llm.py,sha256=fxC-7lg8TLAi9f69zs5y5Pwga8Y5mY7Yfc5NNZNRJgM,1558
 computer_use_ootb_internal/computer_use_demo/tools/__init__.py,sha256=Pj8_5L4_PPQK298X4NV3KMbP-84t-bM0pbjEeb5_SJQ,343
 computer_use_ootb_internal/computer_use_demo/tools/aws_request.py,sha256=12UVzeA2PmpZhpy2Pt5Vh48-_q1e8ZjVQux6r3pbAcw,2629
@@ -32,8 +33,8 @@ computer_use_ootb_internal/computer_use_demo/tools/edit.py,sha256=b0PwUitxckHCQq
 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/preparation/__init__.py,sha256=AgtGHcBpiTkxJjF0xwcs3yyQ6SyUvhL3G0vD2XO-zJw,63
-computer_use_ootb_internal/preparation/star_rail_prepare.py,sha256=Q6P9WuhtK6gNfYcHQqRGBY0XfD6vKr0f7oGknZ4Ac6I,3979
-computer_use_ootb_internal-0.0.136.dist-info/METADATA,sha256=BcPCfVBrZVzGvuhk6-v8JWlgI2ojMApI8OXWUDkBN44,1048
-computer_use_ootb_internal-0.0.136.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-computer_use_ootb_internal-0.0.136.dist-info/entry_points.txt,sha256=bXfyAU_qq-G1EiEgAQEioXvgEdRCFxaTooqdDD9Y4OA,258
-computer_use_ootb_internal-0.0.136.dist-info/RECORD,,
+computer_use_ootb_internal/preparation/star_rail_prepare.py,sha256=s1VWszcTnJAKxqCHFlaOEwPkqVSrkiFx_yKpWSnSbHs,2649
+computer_use_ootb_internal-0.0.138.dist-info/METADATA,sha256=ssU5RYeRr30uWirpkatg1lBgY0ANtqnIQ3KL_dtM0t4,1048
+computer_use_ootb_internal-0.0.138.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+computer_use_ootb_internal-0.0.138.dist-info/entry_points.txt,sha256=bXfyAU_qq-G1EiEgAQEioXvgEdRCFxaTooqdDD9Y4OA,258
+computer_use_ootb_internal-0.0.138.dist-info/RECORD,,