computer-use-ootb-internal 0.0.169__py3-none-any.whl → 0.0.170__py3-none-any.whl

computer_use_ootb_internal/app_teachmode.py

@@ -19,7 +19,10 @@ from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from computer_use_ootb_internal.computer_use_demo.tools.computer import get_screen_details
 from computer_use_ootb_internal.run_teachmode_ootb_args import simple_teachmode_sampling_loop
+from computer_use_ootb_internal.computer_use_demo.executor.teachmode_executor import TeachmodeExecutor
 import uvicorn # Assuming uvicorn is used to run FastAPI
+import concurrent.futures
+import asyncio
 
 # --- App Logging Setup ---
 try:
@@ -395,6 +398,62 @@ async def get_status(request: Request):
         status_code=200
     )
 
+@app.post("/exec_computer_tool")
+async def exec_computer_tool(request: Request):
+    logging.info("Received request to /exec_computer_tool")
+    try:
+        data = await request.json()
+        
+        # Extract parameters from the request
+        selected_screen = data.get('selected_screen', 0)
+        full_screen_game_mode = data.get('full_screen_game_mode', 0)
+        response = data.get('response', {})
+        
+        logging.info(f"Executing TeachmodeExecutor with: screen={selected_screen}, mode={full_screen_game_mode}, response={response}")
+        
+        # Create TeachmodeExecutor in a separate process to avoid event loop conflicts
+        # Since TeachmodeExecutor uses asyncio.run() internally, we need to run it in a way
+        # that doesn't conflict with FastAPI's event loop
+        
+        def run_executor():
+            executor = TeachmodeExecutor(
+                selected_screen=selected_screen,
+                full_screen_game_mode=full_screen_game_mode
+            )
+            
+            results = []
+            try:
+                for action_result in executor(response):
+                    results.append(action_result)
+            except Exception as exec_error:
+                logging.error(f"Error executing action: {exec_error}", exc_info=True)
+                return {"error": str(exec_error)}
+            
+            return results
+        
+        # Execute in a thread pool to avoid blocking the event loop
+        with concurrent.futures.ThreadPoolExecutor() as pool:
+            results = await asyncio.get_event_loop().run_in_executor(pool, run_executor)
+        
+        if isinstance(results, dict) and "error" in results:
+            return JSONResponse(
+                content={"status": "error", "message": results["error"]},
+                status_code=500
+            )
+            
+        logging.info(f"Action results: {results}")
+        
+        return JSONResponse(
+            content={"status": "success", "results": results},
+            status_code=200
+        )
+    except Exception as e:
+        logging.error("Error processing /exec_computer_tool:", exc_info=True)
+        return JSONResponse(
+            content={"status": "error", "message": f"Internal server error: {str(e)}"},
+            status_code=500
+        )
+
 def process_input():
     global shared_state
     logging.info("process_input thread started.")

computer_use_ootb_internal/computer_use_demo/executor/teachmode_executor.py

@@ -115,20 +115,21 @@ class TeachmodeExecutor:
                 print(f"Error parsing action output: {e}")
                 return None
     
-    def _parse_actor_output(self, output_text: str | dict) -> Union[List[Dict[str, Any]], None]:
+    def _parse_actor_output(self, action_item: str | dict) -> Union[List[Dict[str, Any]], None]:
         try:
             # refine key: value pairs, mapping to the Anthropic's format
             refined_output = []
             
-            action_item = output_text
-            
+            if type(action_item) == str:
+                action_item = ast.literal_eval(action_item)
+
             print("[_parse_actor_output] Action Item:", action_item)
             
             # sometime showui returns lower case action names
             action_item["action"] = action_item["action"].upper()
             
             if action_item["action"] not in self.supported_action_type:
-                raise ValueError(f"Action {action_item['action']} not supported. Check the output from ShowUI: {output_text}")
+                raise ValueError(f"Action {action_item['action']} not supported. Check the output from Actor: {action_item}")
                 # continue
             
             elif action_item["action"] == "CLICK":  # 1. click -> mouse_move + left_click
@@ -314,44 +315,3 @@ class TeachmodeExecutor:
         return bbox
 
 
-
-# def _make_api_tool_result(
-#     result: ToolResult, tool_use_id: str
-# ) -> BetaToolResultBlockParam:
-#     """Convert an agent ToolResult to an API ToolResultBlockParam."""
-#     tool_result_content: list[BetaTextBlockParam | BetaImageBlockParam] | str = []
-#     is_error = False
-#     if result.error:
-#         is_error = True
-#         tool_result_content = _maybe_prepend_system_tool_result(result, result.error)
-#     else:
-#         if result.output:
-#             tool_result_content.append(
-#                 {
-#                     "type": "text",
-#                     "text": _maybe_prepend_system_tool_result(result, result.output),
-#                 }
-#             )
-#         if result.base64_image:
-#             tool_result_content.append(
-#                 {
-#                     "type": "image",
-#                     "source": {
-#                         "type": "base64",
-#                         "media_type": "image/png",
-#                         "data": result.base64_image,
-#                     },
-#                 }
-#             )
-#     return {
-#         "type": "tool_result",
-#         "content": tool_result_content,
-#         "tool_use_id": tool_use_id,
-#         "is_error": is_error,
-#     }
-
-
-# def _maybe_prepend_system_tool_result(result: ToolResult, result_text: str):
-#     if result.system:
-#         result_text = f"<system>{result.system}</system>\n{result_text}"
-#     return result_text

computer_use_ootb_internal/computer_use_demo/tools/computer.py

@@ -384,7 +384,7 @@ class ComputerTool(BaseAnthropicTool):
                     show_click(x, y)
                     time.sleep(0.25)
                     self.marbot_auto_gui.click(x=x, y=y)
-                    self.marbot_auto_gui.click(x=x, y=y)
+                    # self.marbot_auto_gui.click(x=x, y=y)
                 return ToolResult(output=f"Left click", action_base_type="click")
 
             elif action == "mouse_move_windll":

computer_use_ootb_internal/guard_service.py

@@ -23,6 +23,7 @@ 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
+import shutil # Added for shutil.which
 
 # --- Configuration ---
 _SERVICE_NAME = "OOTBGuardService"
@@ -143,7 +144,6 @@ class GuardService(win32serviceutil.ServiceFramework):
     _svc_name_ = _SERVICE_NAME
     _svc_display_name_ = _SERVICE_DISPLAY_NAME
     _svc_description_ = _SERVICE_DESCRIPTION
-    _task_name_prefix = "OOTB_UserLogon_" # Class attribute for task prefix
 
     # --- Instance Logging Methods ---
     def log_info(self, msg):
@@ -708,19 +708,9 @@ class GuardService(win32serviceutil.ServiceFramework):
 
 
         try:
-            # 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:
                 sessions = win32ts.WTSEnumerateSessions(win32ts.WTS_CURRENT_SERVER_HANDLE)
@@ -741,7 +731,7 @@ class GuardService(win32serviceutil.ServiceFramework):
             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
+                final_status = "skipped_inactive" # Simplified status
                 return final_status # Exit early if inactive
 
             # 3. Check if already running for this active user
@@ -758,80 +748,100 @@ class GuardService(win32serviceutil.ServiceFramework):
                  self.log_error(f"Internal trigger: Error checking existing processes for {user}: {e}")
                  # Continue and attempt start despite error?
 
-            # 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 PowerShell elevation...")
-            
+            # 4. Attempt immediate start using CreateProcessAsUser to run helper script
+            immediate_start_status = "start_attempted_helper_script"
+            self.log_info(f"Internal trigger: User '{user}' is active and not running. Attempting start via helper script...")
+
             if not self.target_executable_path:
                 self.log_error("Internal trigger: Cannot start process - target executable path not found.")
                 final_status = "failed_exe_not_found"
-                return final_status # Exit early if executable missing
+                return final_status
 
             try:
-                token = win32ts.WTSQueryUserToken(session_id)
-                env = win32profile.CreateEnvironmentBlock(token, False)
-                startup = win32process.STARTUPINFO()
-                # Use CREATE_NEW_CONSOLE to make the PS window visible and potentially the UAC prompt
-                creation_flags = win32con.CREATE_NEW_CONSOLE
-                
-                # Command to run PowerShell, which then elevates the target executable
+                # Find helper script path
+                helper_script_path = self._find_helper_script("launch_ootb_elevated.ps1")
+                if not helper_script_path:
+                    self.log_error("Internal trigger: Cannot start process - helper script not found.")
+                    final_status = "failed_helper_script_not_found"
+                    return final_status
+
+                # Get PowerShell executable path
+                powershell_executable = self._find_powershell_executable()
+                if not powershell_executable:
+                    self.log_error("Internal trigger: Cannot start process - powershell.exe not found.")
+                    final_status = "failed_powershell_not_found"
+                    return final_status
+
+                # Prepare arguments for the helper script (paths need quoting if they contain spaces)
                 target_exe_unquoted = self.target_executable_path.strip('"')
-                target_exe_for_ps = target_exe_unquoted.replace("'", "''") # Escape single quotes for PS
-                target_exe_dir_for_ps = os.path.dirname(target_exe_unquoted).replace("'", "''")
-                
-                # Build the second argument for cmd.exe /K, as used in the successful test command
-                # Format: "<target_exe>" --port <port> --target_user ''<user>'' 
-                cmd_k_second_arg_content = f'""{target_exe_for_ps}"" --port {calculated_port} --target_user ''{user}'''
-                # Escape single quotes within this second arg for the outer PowerShell command string
-                cmd_k_second_arg_for_ps_command = cmd_k_second_arg_content.replace("'", "''")
-
-                # Build the full Start-Process command string matching the working test command
-                start_process_cmd = (
-                    f"Start-Process -FilePath cmd.exe "
-                    f"-ArgumentList @('/K', '{cmd_k_second_arg_for_ps_command}') "
-                    f"-WorkingDirectory '{target_exe_dir_for_ps}' "
-                    f"-Verb RunAs"
+                target_exe_dir = os.path.dirname(target_exe_unquoted) # Use directory of unquoted path
+
+                # Quote paths/args for command line - IMPORTANT: Use double quotes for PowerShell args
+                helper_script_arg = f'"{helper_script_path}"' if " " in helper_script_path else helper_script_path
+                target_exe_arg = f'"{target_exe_unquoted}"' if " " in target_exe_unquoted else target_exe_unquoted
+                working_dir_arg = f'"{target_exe_dir}"' if " " in target_exe_dir else target_exe_dir
+                # Username might need quoting if it contains special characters, double quote should be safe
+                target_user_arg = f'"{user}"'
+
+                # Construct the command line to execute powershell with the helper script and args
+                lpCommandLine = (
+                    f'"{powershell_executable}" -NoProfile -ExecutionPolicy Bypass -NoExit '
+                    f'-File {helper_script_arg} '
+                    f'-TargetExePath {target_exe_arg} '
+                    f'-Port {calculated_port} '
+                    f'-TargetUser {target_user_arg} '
+                    f'-WorkingDirectory {working_dir_arg}'
                 )
 
-                # Launch powershell.exe directly, tell it to run the Start-Process command, and keep window open
-                # Use outer single quotes for -Command argument value to simplify inner quoting
-                # No need to escape inner double quotes when using outer single quotes
-                # Escape any literal single quotes within start_process_cmd itself (shouldn't be needed here but good practice)
-                start_process_cmd_escaped_for_single_quotes = start_process_cmd.replace("'", "''")
-                lpCommandLine = f'powershell.exe -NoProfile -ExecutionPolicy Bypass -NoExit -Command \'{start_process_cmd_escaped_for_single_quotes}\''
-
-                lpApplicationName = None # Must be None if using lpCommandLine
-                cwd = os.path.dirname(target_exe_unquoted) if os.path.dirname(target_exe_unquoted) else None
-
-                # Log details before call
-                self.log_info(f"Internal trigger: Launching PowerShell directly for elevation:")
+                # Use CreateProcessAsUser to launch this command in the user's session
+                token = win32ts.WTSQueryUserToken(session_id)
+                env = win32profile.CreateEnvironmentBlock(token, False)
+                startup = win32process.STARTUPINFO()
+                # Ensure the window is visible on the user's desktop
+                startup.lpDesktop = "winsta0\\default"
+                creation_flags = win32con.CREATE_NEW_CONSOLE | win32con.NORMAL_PRIORITY_CLASS
+                lpApplicationName = None # Must be None when using lpCommandLine
+                # Working directory for powershell itself? Let it default or use script dir?
+                # Let's use the script's directory as CWD for powershell.exe
+                cwd = os.path.dirname(helper_script_path) # Use directory of unquoted path
+
+                self.log_info(f"Internal trigger: Launching helper script via CreateProcessAsUser:")
                 self.log_info(f"  lpCommandLine: {lpCommandLine}")
-                self.log_info(f"  lpCurrentDirectory: {cwd if cwd else 'Default'}")
-                
+                self.log_info(f"  lpCurrentDirectory: {cwd}")
+
+                # Execute the command in the user's session
                 hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
                     token, lpApplicationName, lpCommandLine, None, None, False,
                     creation_flags, env, cwd, startup
                 )
-                # We get the PID of cmd.exe/powershell.exe here, not the final elevated process.
-                # We can't easily track the elevated process PID across the UAC boundary.
-                self.log_info(f"Internal trigger: CreateProcessAsUser call to initiate elevation succeeded for user '{user}' (Launcher PID: {dwPid}). UAC prompt expected if needed.")
+                self.log_info(f"Internal trigger: CreateProcessAsUser call for helper script succeeded (Launcher PID: {dwPid}). Helper script should now run and trigger elevation.")
                 win32api.CloseHandle(hProcess)
                 win32api.CloseHandle(hThread)
 
-                # Assume success if the call didn't raise an exception.
-                # We cannot easily verify if the *elevated* process actually started.
-                immediate_start_status = "start_elevation_initiated"
-                final_status = "success_elevation_initiated" # Report success based on initiating the elevation
-
-            except Exception as proc_err:
-                 self.log_error(f"Internal trigger: Exception during CreateProcessAsUser for elevation attempt (user '{user}'): {proc_err}", exc_info=True)
-                 immediate_start_status = "start_failed_exception"
-                 final_status = "failed_start_exception"
+                # Assume success if CreateProcessAsUser succeeded.
+                # The actual success depends on the user interacting with UAC triggered by the helper.
+                immediate_start_status = "start_success_helper_launched"
+                final_status = "success_helper_launched"
+
+            except FileNotFoundError as fnf_err:
+                # This might now be powershell.exe OR the helper script
+                self.log_error(f"Internal trigger: File not found during helper script launch: {fnf_err}")
+                immediate_start_status = "start_failed_file_not_found"
+                final_status = "failed_file_not_found"
+            except Exception as launch_err:
+                self.log_error(f"Internal trigger: Exception during CreateProcessAsUser for helper script (user '{user}'): {launch_err}", exc_info=True)
+                immediate_start_status = "start_failed_launch_exception"
+                final_status = "failed_launch_exception"
             finally:
-                 if token: win32api.CloseHandle(token)
-            
+                 # Ensure token exists and is not None before attempting to close
+                 if 'token' in locals() and token is not None:
+                      try:
+                          win32api.CloseHandle(token)
+                      except: # Ignore errors closing handle
+                          pass
+
             # Combine results (mostly determined by start attempt now)
-            # Example: final_status = f"{task_created_status}_{immediate_start_status}"
+            # Status is now primarily determined by the helper script launch attempt
             return final_status
 
         except Exception as e:
@@ -839,133 +849,47 @@ class GuardService(win32serviceutil.ServiceFramework):
              return "failed_trigger_exception"
 
 
-    def create_or_update_logon_task(self, username):
-        """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: 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
-        
-        # Working directory for the script (likely its own directory)
-        try:
-            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 signal script task: {e}. WD will not be set.")
-             working_directory_setting = "# Could not set WorkingDirectory"
-
-        # PowerShell command construction
-        ps_command = f"""
-        $taskName = "{task_name}"
-        $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive
-        
-        # Action: Run python signal script
-        $action = New-ScheduledTaskAction -Execute '{safe_action_executable}' -Argument '{safe_action_arguments}'
-        {working_directory_setting}
-
-        # Trigger: On session connect (Event ID 21)
-        $logName = 'Microsoft-Windows-TerminalServices-LocalSessionManager/Operational'
-        $source = 'Microsoft-Windows-TerminalServices-LocalSessionManager'
-        $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 = "Triggers OOTB Guard Service for user {username} upon session connect via internal signal." # Updated description
-
-        # Unregister existing task first (force)
-        Unregister-ScheduledTask -TaskName $taskName -Confirm:$false -ErrorAction SilentlyContinue
-
-        # Register the new task
-        Register-ScheduledTask -TaskName $taskName -Principal $principal -Action $action -Trigger $trigger -Settings $settings -Description $description -Force
-        """
-        self.log_info(f"Attempting to create/update task '{task_name}' for user '{username}' to run signal script.")
-        try:
-            success = self.run_powershell_command(ps_command)
-            if success:
-                 self.log_info(f"Successfully ran PowerShell command to create/update task '{task_name}'.")
-                 return True
-            else:
-                 self.log_error(f"PowerShell command failed to create/update task '{task_name}'. See previous logs.")
-                 return False
-        except Exception as e:
-            self.log_error(f"Failed to create/update scheduled task '{task_name}' for user '{username}': {e}", exc_info=True)
-            return False
-
-    def run_powershell_command(self, command, log_output=True):
-        """Executes a PowerShell command and handles output/errors. Returns True on success."""
-        self.log_info(f"Executing PowerShell: {command}")
-        try:
-            result = subprocess.run(
-                ["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", command],
-                capture_output=True, text=True, check=True, encoding='utf-8', errors='ignore'
-            )
-            if log_output and result.stdout:
-                self.log_info(f"PowerShell STDOUT:\n{result.stdout.strip()}")
-            if log_output and result.stderr:
-                # Log stderr as info, as some commands write status here (like unregister task not found)
-                self.log_info(f"PowerShell STDERR:\n{result.stderr.strip()}") 
-            return True
-        except FileNotFoundError:
-            self.log_error("'powershell.exe' not found. Cannot manage scheduled tasks.")
-            return False
-        except subprocess.CalledProcessError as e:
-            # Log error but still return False, handled by caller
-            self.log_error(f"PowerShell command failed (Exit Code {e.returncode}):")
-            self.log_error(f"  Command: {e.cmd}")
-            if e.stdout: self.log_error(f"  STDOUT: {e.stdout.strip()}")
-            if e.stderr: self.log_error(f"  STDERR: {e.stderr.strip()}")
-            return False
-        except Exception as e:
-            self.log_error(f"Unexpected error running PowerShell: {e}", exc_info=True)
-            return False
-
-    def remove_logon_task(self, username):
-        """Removes the logon scheduled task for a user."""
-        task_name = f"{self._task_name_prefix}{username}"
-        safe_task_name = task_name.replace("'", "''")
-        command = f"Unregister-ScheduledTask -TaskName '{safe_task_name}' -Confirm:$false -ErrorAction SilentlyContinue"
-        self.run_powershell_command(command, log_output=False)
-        self.log_info(f"Attempted removal of scheduled task '{task_name}' for user '{username}'.")
-        return True
-
     def _find_signal_script(self):
         """Finds the signal_connection.py script relative to this service file."""
+        return self._find_helper_script("signal_connection.py") # Reuse helper finding logic
+
+    def _find_helper_script(self, script_name):
+        """Finds a helper script relative to this service file."""
         try:
+            # Use __file__ which should be reliable when run as a service via pythonservice.exe
             base_dir = os.path.dirname(os.path.abspath(__file__))
-            script_path = os.path.join(base_dir, "signal_connection.py")
+            script_path = os.path.join(base_dir, script_name)
             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}"'
+                self.log_info(f"Found helper script '{script_name}' at: {script_path}")
+                # Return unquoted path for potential quoting later
                 return script_path
             else:
-                self.log_error(f"Signal script signal_connection.py not found near {base_dir}")
+                self.log_error(f"Helper script '{script_name}' not found near {base_dir}")
                 return None
         except Exception as e:
-            self.log_error(f"Error finding signal script: {e}")
+            self.log_error(f"Error finding helper script '{script_name}': {e}")
+            return None
+
+    def _find_powershell_executable(self):
+        """Finds powershell.exe, preferring the system path."""
+        try:
+            # Check System32 first
+            system32_path = os.path.join(os.environ.get('SystemRoot', 'C:\\Windows'), 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')
+            if os.path.exists(system32_path):
+                self.log_info(f"Found powershell.exe at: {system32_path}")
+                return system32_path
+            else:
+                # Fallback to checking PATH using shutil.which (requires Python 3.3+)
+                # Make sure to import shutil at the top of the file if not already present
+                powershell_path = shutil.which("powershell.exe")
+                if powershell_path:
+                    self.log_info(f"Found powershell.exe via PATH: {powershell_path}")
+                    return powershell_path
+                else:
+                    self.log_error("powershell.exe not found in System32 or PATH.")
+                    return None
+        except Exception as e:
+            self.log_error(f"Error finding powershell.exe: {e}")
             return None
 
 # --- Main Execution Block ---

computer_use_ootb_internal/launch_ootb_elevated.ps1

@@ -0,0 +1,63 @@
+# launch_ootb_elevated.ps1
+param(
+    [Parameter(Mandatory=$true)]
+    [string]$TargetExePath,
+
+    [Parameter(Mandatory=$true)]
+    [string]$Port,
+
+    [Parameter(Mandatory=$true)]
+    [string]$TargetUser,
+
+    [Parameter(Mandatory=$true)]
+    [string]$WorkingDirectory
+)
+
+try {
+    Write-Host "--- OOTB Elevation Helper ---"
+    Write-Host "Timestamp: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"
+    Write-Host "Received parameters:"
+    Write-Host "  Target Exe Path : $TargetExePath"
+    Write-Host "  Port            : $Port"
+    Write-Host "  Target User     : $TargetUser"
+    Write-Host "  Working Dir     : $WorkingDirectory"
+    Write-Host ""
+
+    # Validate paths
+    if (-not (Test-Path -Path $TargetExePath -PathType Leaf)) {
+        throw "Target executable not found at '$TargetExePath'"
+    }
+    if (-not (Test-Path -Path $WorkingDirectory -PathType Container)) {
+        throw "Working directory not found at '$WorkingDirectory'"
+    }
+
+    # Construct the argument list string for the target executable
+    # Ensure target user is single-quoted for the argument parser
+    $argumentList = "--port $Port --target_user '$TargetUser'"
+
+    Write-Host "Constructed ArgumentList for Target Exe: $argumentList"
+    Write-Host "Executing elevated process..."
+    Write-Host "Command: Start-Process -FilePath `$TargetExePath` -ArgumentList `$argumentList` -WorkingDirectory `$WorkingDirectory` -Verb RunAs"
+    Write-Host "--- Waiting for UAC prompt if necessary ---"
+
+    # Execute the command to launch the target exe elevated directly
+    Start-Process -FilePath $TargetExePath -ArgumentList $argumentList -WorkingDirectory $WorkingDirectory -Verb RunAs
+
+    Write-Host "--- OOTB Elevation Helper: Start-Process command executed. ---"
+    # The calling powershell window (started by CreateProcessAsUser with -NoExit) will remain open.
+
+} catch {
+    Write-Error "--- OOTB Elevation Helper Error ---"
+    Write-Error "Error launching elevated process: $($_.Exception.Message)"
+    Write-Error "Script Parameters:"
+    Write-Error "  Target Exe Path : $TargetExePath"
+    Write-Error "  Port            : $Port"
+    Write-Error "  Target User     : $TargetUser"
+    Write-Error "  Working Dir     : $WorkingDirectory"
+    Write-Host "Press Enter to exit..."
+    Read-Host # Keep window open on error
+    Exit 1
+}
+
+# Exit gracefully if successful
+Exit 0 

computer_use_ootb_internal/service_manager.py

@@ -6,11 +6,14 @@ import subprocess
 import ctypes
 import platform
 import time
+import json
+import shutil
 
 # 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
+_SHORTCUT_NAME = "OOTB AutoStart Signal.lnk" # Name for the startup shortcut
 
 def is_admin():
     """Check if the script is running with administrative privileges."""
@@ -51,142 +54,298 @@ def get_service_module_path():
          except Exception as fallback_e:
              raise FileNotFoundError(f"Could not find guard_service.py using inspect ({e}) or sys.prefix ({fallback_e}). Check installation.")
 
-
-def run_service_command(command_args, check_errors=True):
-    """Runs the guard_service.py script with specified command-line args."""
-    if not is_admin():
-        print("Error: Administrative privileges are required to manage the service.", file=sys.stderr)
-        print("Please run this command from an Administrator Command Prompt or PowerShell.", file=sys.stderr)
-        return False
-
+def _run_command(cmd_list, check_errors=True, capture_output=False, verbose=True):
+    """Helper to run an external command (like sc.exe)."""
+    if verbose:
+        # Safely join for printing, handle potential non-string elements just in case
+        print(f"Executing command: {' '.join(map(str, cmd_list))}")
     try:
-        python_exe = sys.executable # Use the same python that's running this script
-        service_script = get_service_module_path()
+        result = subprocess.run(
+            cmd_list,
+            capture_output=capture_output,
+            text=True,
+            check=check_errors,
+            encoding='utf-8',
+            errors='ignore'
+        )
+        if capture_output and verbose:
+             if result.stdout: print(f"  CMD STDOUT: {result.stdout.strip()}")
+             if result.stderr: print(f"  CMD STDERR: {result.stderr.strip()}")
+        return result if capture_output else (result.returncode == 0)
     except FileNotFoundError as e:
-         print(f"Error: {e}", file=sys.stderr)
-         return False
-
-    # Quote paths if they contain spaces
-    if " " in python_exe and not python_exe.startswith('"'):
-        python_exe = f'"{python_exe}"'
-    if " " in service_script and not service_script.startswith('"'):
-        service_script = f'"{service_script}"'
+         print(f"Error: Command not found during execution: {cmd_list[0]}", file=sys.stderr)
+         print(f" Details: {e}", file=sys.stderr)
+         return None if capture_output else False
+    except subprocess.CalledProcessError as e:
+        # Don't print error if check_errors was False and it failed
+        if check_errors and verbose:
+            print(f"Error executing command {' '.join(map(str, cmd_list))} (Exit Code {e.returncode}).", file=sys.stderr)
+            if e.stdout: print(f"Subprocess STDOUT:", file=sys.stderr); print(e.stdout, file=sys.stderr)
+            if e.stderr: print(f"Subprocess STDERR:", file=sys.stderr); print(e.stderr, file=sys.stderr)
+        return None if capture_output else False
+    except Exception as e:
+        if verbose:
+            print(f"An unexpected error occurred running command: {e}", file=sys.stderr)
+        return None if capture_output else False
 
-    # Construct command using list to avoid shell quoting issues
-    cmd = [sys.executable, get_service_module_path()] + command_args
-    print(f"Executing command: {' '.join(cmd)}")
+def _get_startup_folder():
+    """Gets the current user's Startup folder path."""
+    try:
+        # Use CSIDL value for Startup folder
+        # Requires pywin32
+        import win32com.client
+        shell = win32com.client.Dispatch("WScript.Shell")
+        # SHGetSpecialFolderPath requires integer CSIDL, Startup=7
+        # Using shell.SpecialFolders is usually easier
+        startup_path = shell.SpecialFolders("Startup")
+        if startup_path and os.path.isdir(startup_path):
+            print(f"Found Startup folder: {startup_path}")
+            return startup_path
+        else:
+            print("Error: Could not resolve Startup folder path via WScript.Shell.", file=sys.stderr)
+            return None
+    except ImportError:
+        print("Error: pywin32com is required to find Startup folder. Cannot manage startup shortcut.", file=sys.stderr)
+        return None
+    except Exception as e:
+        print(f"Error finding Startup folder: {e}", file=sys.stderr)
+        return None
 
+def _find_pythonw_executable():
+    """Finds pythonw.exe in the same directory as sys.executable."""
     try:
-        # Run the command. Use shell=False with list of args.
-        # Capture output to check for specific errors if needed, but print it too.
-        result = subprocess.run(cmd, capture_output=True, text=True, check=check_errors, encoding='utf-8')
-        if result.stdout:
-            print("Command STDOUT:")
-            print(result.stdout)
-        if result.stderr:
-            print("Command STDERR:")
-            print(result.stderr)
-        print(f"Command {' '.join(command_args)} executed successfully.")
-        return True
-    except FileNotFoundError as e:
-         print(f"Error: Could not find Python executable or service script during execution.", file=sys.stderr)
-         print(f" Details: {e}", file=sys.stderr)
-         return False
-    except subprocess.CalledProcessError as e:
-        print(f"Error executing service command {' '.join(command_args)} (Exit Code {e.returncode}).", file=sys.stderr)
-        if e.stdout:
-            print("Subprocess STDOUT:")
-            print(e.stdout)
-        if e.stderr:
-            print("Subprocess STDERR:")
-            print(e.stderr)
-        return False
+        python_dir = os.path.dirname(sys.executable)
+        pythonw_path = os.path.join(python_dir, "pythonw.exe")
+        if os.path.exists(pythonw_path):
+            return pythonw_path
+        else:
+            print(f"Warning: pythonw.exe not found next to sys.executable ({sys.executable}). Console window might flash on login.", file=sys.stderr)
+            # Fallback to python.exe if pythonw not found
+            return sys.executable
     except Exception as e:
-        print(f"An unexpected error occurred running service command: {e}", file=sys.stderr)
+        print(f"Error finding pythonw.exe: {e}. Using sys.executable as fallback.", file=sys.stderr)
+        return sys.executable
+
+def _create_startup_shortcut():
+    """Creates a shortcut in the Startup folder to run signal_connection.py."""
+    if not is_admin(): # Should already be checked, but double-check
+        print("Admin privileges needed to potentially write shortcut.")
+        return False
+
+    startup_dir = _get_startup_folder()
+    if not startup_dir:
         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}")
+    shortcut_path = os.path.join(startup_dir, _SHORTCUT_NAME)
+    python_launcher = _find_pythonw_executable()
+    signal_script = None
     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
+        # Find signal_connection.py relative to this script (service_manager.py)
+        script_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+        signal_script = os.path.join(script_dir, "signal_connection.py")
+        if not os.path.exists(signal_script):
+             print(f"Error: signal_connection.py not found in {script_dir}", file=sys.stderr)
+             return False
     except Exception as e:
-        print(f"Warning: PowerShell cleanup command failed: {e}", file=sys.stderr)
-        return False # Indicate potential issue
+        print(f"Error finding signal_connection.py: {e}", file=sys.stderr)
+        return False
+
+    # Target command for the shortcut
+    target_cmd = f'"{python_launcher}"' # Quote launcher path
+    # Quote script path
+    target_cmd += f' "{signal_script}"'
+    # Username argument - %USERNAME% will be expanded by shell when shortcut runs
+    target_cmd += ' %USERNAME%'
+
+    print(f"Creating Startup shortcut:")
+    print(f"  Shortcut : {shortcut_path}")
+    print(f"  Target   : {target_cmd}")
+
+    # Use PowerShell to create the shortcut
+    # Escape paths and arguments for the PowerShell command string
+    ps_shortcut_path = shortcut_path.replace("'", "''")
+    ps_target_cmd = target_cmd.replace("'", "''")
+    ps_working_dir = os.path.dirname(signal_script).replace("'", "''") # Use script's dir as working dir
+    ps_icon_location = python_launcher.replace("'", "''") # Use python icon
+
+    ps_command = f"""
+    $ws = New-Object -ComObject WScript.Shell
+    $s = $ws.CreateShortcut('{ps_shortcut_path}')
+    $s.TargetPath = '{ps_target_cmd.split()[0]}' # Executable part
+    $s.Arguments = '{ps_target_cmd.split(' ', 1)[1] if ' ' in ps_target_cmd else ''}' # Arguments part
+    $s.WorkingDirectory = '{ps_working_dir}'
+    $s.IconLocation = '{ps_icon_location}'
+    $s.WindowStyle = 7 # Minimized
+    $s.Description = 'Triggers OOTB Guard Service connection check on login'
+    $s.Save()
+    Write-Host 'Shortcut created successfully.'
+    """
+
+    return _run_command([sys.executable, "-NoProfile", "-NonInteractive", "-Command", ps_command])
+
+def _remove_startup_shortcut():
+    """Removes the OOTB startup shortcut if it exists."""
+    if not is_admin(): return False # Need admin to potentially delete
+    startup_dir = _get_startup_folder()
+    if not startup_dir:
+        return False
+
+    shortcut_path = os.path.join(startup_dir, _SHORTCUT_NAME)
+    print(f"Attempting to remove Startup shortcut: {shortcut_path}")
+    if os.path.exists(shortcut_path):
+        try:
+            os.remove(shortcut_path)
+            print("Shortcut removed successfully.")
+            return True
+        except OSError as e:
+            print(f"Error removing shortcut: {e}", file=sys.stderr)
+            # Fallback attempt with PowerShell just in case of permission issues
+            ps_shortcut_path = shortcut_path.replace("'", "''")
+            ps_command = f"Remove-Item -Path '{ps_shortcut_path}' -Force -ErrorAction SilentlyContinue"
+            return _run_command([sys.executable, "-NoProfile", "-NonInteractive", "-Command", ps_command], verbose=False)
+        except Exception as e:
+             print(f"Unexpected error removing shortcut: {e}", file=sys.stderr)
+             return False
+    else:
+        print("Shortcut not found, no removal needed.")
+        return True
 
 def _cleanup_scheduled_tasks():
-    """Removes all OOTB user logon scheduled tasks."""
-    print("Attempting to remove any existing OOTB user logon scheduled tasks...")
+    """Removes all OOTB user logon scheduled tasks (legacy cleanup)."""
+    print("Attempting legacy cleanup of OOTB user logon scheduled tasks...")
     # Use -like operator and wildcard
-    # Use try-catch within PowerShell for robustness
+    # Need _TASK_NAME_PREFIX defined at module level
     command = f"""
     $tasks = Get-ScheduledTask | Where-Object {{ $_.TaskName -like '{_TASK_NAME_PREFIX}*' }}
     if ($tasks) {{
-        Write-Host "Found $($tasks.Count) OOTB logon tasks to remove."
+        Write-Host "Found $($tasks.Count) legacy OOTB logon tasks to remove."
         $tasks | Unregister-ScheduledTask -Confirm:$false -ErrorAction SilentlyContinue
-        Write-Host "OOTB logon task removal attempted."
+        Write-Host "Legacy OOTB logon task removal attempted."
     }} else {{
-        Write-Host "No OOTB logon tasks found to remove."
+        Write-Host "No legacy OOTB logon tasks found to remove."
     }}
     """
-    _run_powershell_cleanup_command(command)
-# --- End cleanup helpers ---
+    # Use the generic _run_command helper, specifying powershell.exe
+    _run_command(['powershell.exe', '-NoProfile', '-NonInteractive', '-Command', command], check_errors=False, verbose=False)
 
 def install_and_start():
     """Installs and starts the Guard Service."""
     print(f"Attempting to install service: '{_SERVICE_NAME}' ('{_SERVICE_DISPLAY_NAME}')")
-    # Call 'install' command first.
-    # We pass check_errors=True to stop if installation fails fundamentally.
-    install_success = run_service_command(['--startup', 'auto', 'install'], check_errors=True)
+    # Step 1: Run the Python script to register the service class with SCM
+    install_success = False
+    try:
+        python_exe = sys.executable
+        service_script = get_service_module_path()
+        # Quote paths
+        python_exe_quoted = f'"{python_exe}"' if " " in python_exe else python_exe
+        service_script_quoted = f'"{service_script}"' if " " in service_script else service_script
+        # Use list for subprocess
+        install_cmd = [sys.executable, service_script, '--startup', 'auto', 'install']
+        print(f"Executing registration command: {' '.join(install_cmd)}")
+        # We need to check output/return code carefully
+        result = subprocess.run(install_cmd, capture_output=True, text=True, check=False, encoding='utf-8')
+        if result.stdout: print(f"  Registration STDOUT: {result.stdout.strip()}")
+        if result.stderr: print(f"  Registration STDERR: {result.stderr.strip()}")
+        # Check common success/already-installed messages or just return code 0?
+        # win32serviceutil often returns 0 even if service exists. Let's assume 0 is okay.
+        if result.returncode == 0:
+            print("Service registration command executed (might indicate success or already installed).")
+            install_success = True
+        else:
+            print(f"Service registration command failed (Exit Code {result.returncode}).", file=sys.stderr)
+            install_success = False
+
+    except FileNotFoundError as e:
+         print(f"Error finding Python or service script for registration: {e}", file=sys.stderr)
+         install_success = False
+    except Exception as e:
+        print(f"Unexpected error during service registration: {e}", file=sys.stderr)
+        install_success = False
 
     if install_success:
-        # Note: Even if install_success is True, pywin32 might have printed internal errors
-        # like 'service already installed'. We proceed to start anyway in that case.
-        print(f"\nInstallation command finished. Attempting to start service: '{_SERVICE_NAME}' (waiting a few seconds first)")
-        time.sleep(3) # Give SCM time to register the install/update
-        start_success = run_service_command(['start'], check_errors=True)
-
-        if start_success:
-            # Similar caveat: start might succeed according to subprocess, but pywin32 could print internal errors.
-            print(f"\nService '{_SERVICE_NAME}' install command executed and start command executed.")
-            print(f"Please verify service status in 'services.msc' and check logs.")
+        print(f"\nRegistration command finished. Attempting to start service using 'sc start'...")
+        time.sleep(2) # Give SCM time
+        # Step 2: Use sc start
+        start_cmd = ['sc', 'start', _SERVICE_NAME]
+        start_success = _run_command(start_cmd, check_errors=False) # Don't fail script if start fails
+
+        # Optional: Query status after attempting start
+        time.sleep(3) # Wait a bit longer
+        query_cmd = ['sc', 'query', _SERVICE_NAME]
+        query_result = _run_command(query_cmd, capture_output=True, check_errors=False, verbose=False)
+        service_running = False
+        if query_result and query_result.stdout:
+            if "RUNNING" in query_result.stdout:
+                service_running = True
+                print(f"Service '{_SERVICE_NAME}' confirmed running.")
+            else:
+                 print(f"Service '{_SERVICE_NAME}' status check returned:\n{query_result.stdout.strip()}")
         else:
-             # This path is taken if run_service_command returned False (subprocess error occurred)
-             print(f"\nService '{_SERVICE_NAME}' installed/updated but the 'start' command failed with an error.", file=sys.stderr)
+            print("Warning: Could not query service status after start attempt.")
+
+        if start_success and service_running:
+            print(f"\nService '{_SERVICE_NAME}' installed/updated and started successfully.")
+            # Step 3: Create startup shortcut only if service started
+            print("Creating startup shortcut...")
+            _create_startup_shortcut()
+        elif start_success and not service_running:
+            print(f"\nService '{_SERVICE_NAME}' installed/updated. 'sc start' command succeeded but service is not in RUNNING state.", file=sys.stderr)
+            print(" Check logs or try starting manually.", file=sys.stderr)
+        else: # start_success was False
+             print(f"\nService '{_SERVICE_NAME}' installed/updated but 'sc start' command failed.", file=sys.stderr)
              print(f" Check output above, service logs ('C:\ProgramData\OOTBGuardService\guard_post_mode.log'), or Windows Event Viewer.", file=sys.stderr)
     else:
-        # This path is taken if the initial 'install' command failed critically (subprocess error)
-        print(f"\nService '{_SERVICE_NAME}' installation failed critically. See errors above.", file=sys.stderr)
-
+        # This path is taken if the initial registration command failed critically
+        print(f"\nService '{_SERVICE_NAME}' registration failed critically. See errors above.", file=sys.stderr)
 
 def stop_and_remove():
-    """Stops and removes the Guard Service and associated scheduled tasks."""
-    print(f"Attempting to stop service: '{_SERVICE_NAME}' (will ignore errors if not running)")
+    """Stops and removes the Guard Service and associated resources."""
+    print(f"Attempting to remove Startup shortcut...")
+    _remove_startup_shortcut()
+
+    print(f"\nAttempting to stop service using 'sc stop'...")
     # Run stop first, ignore errors (check_errors=False)
-    run_service_command(['stop'], check_errors=False)
-    time.sleep(2) # Give service time to stop
+    # run_service_command(['stop'], check_errors=False)
+    stop_cmd = ['sc', 'stop', _SERVICE_NAME]
+    _run_command(stop_cmd, check_errors=False)
+    time.sleep(3) # Give service time to stop
 
-    print(f"\nAttempting to remove service: '{_SERVICE_NAME}'")
-    remove_success = run_service_command(['remove']) # Check if removal command itself failed
+    # Optional: Check if stopped
+    query_cmd = ['sc', 'query', _SERVICE_NAME]
+    query_result = _run_command(query_cmd, capture_output=True, check_errors=False, verbose=False)
+    service_exists = True # Assume it exists unless query fails specifically
+    if query_result:
+        if query_result.stderr and ("failed" in query_result.stderr.lower() or "does not exist" in query_result.stderr.lower()):
+            service_exists = False
+            print("Service does not appear to exist before removal attempt.")
+        elif query_result.stdout and "STOPPED" in query_result.stdout:
+            print("Service confirmed stopped.")
+        elif query_result.stdout:
+            print(f"Warning: Service state after stop attempt: {query_result.stdout.strip()}")
+    else:
+        print("Warning: Could not query service state after stop attempt.")
+
+    print(f"\nAttempting to remove service using 'sc delete'...")
+    # remove_success = run_service_command(['remove']) # Check if removal command itself failed
+    delete_cmd = ['sc', 'delete', _SERVICE_NAME]
+    delete_success = _run_command(delete_cmd, check_errors=False) # Ignore error if not found
 
     # 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.")
+    if delete_success:
+        # Check if it really doesn't exist now
+        time.sleep(1)
+        query_result_after = _run_command(query_cmd, capture_output=True, check_errors=False, verbose=False)
+        if query_result_after and query_result_after.stderr and ("failed" in query_result_after.stderr.lower() or "does not exist" in query_result_after.stderr.lower()):
+            print(f"\nService '{_SERVICE_NAME}' stopped (if running), removed successfully. Startup shortcut and logon tasks cleanup attempted.")
+        else:
+            print(f"\nService '{_SERVICE_NAME}' stop attempted. 'sc delete' command ran but service might still exist. Please check manually.", file=sys.stderr)
+            print(f" Startup shortcut and logon tasks cleanup attempted.", file=sys.stderr)
     else:
-        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)
+        # This might happen if sc delete failed for permission reasons etc.
+        print(f"\n'sc delete {_SERVICE_NAME}' command failed to execute properly.", file=sys.stderr)
+        print(f" Startup shortcut and 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.169.dist-info → computer_use_ootb_internal-0.0.170.dist-info}/METADATA

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

{computer_use_ootb_internal-0.0.169.dist-info → computer_use_ootb_internal-0.0.170.dist-info}/RECORD

@@ -1,17 +1,18 @@
 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=R4kLoII4dkRkOMVWZUIhD3h39nQkrnbYShQuT8Q966I,24363
+computer_use_ootb_internal/app_teachmode.py,sha256=842v79pjUvX1yck6n4uel45ysZTcsWXoskwcfEzSgw4,26866
 computer_use_ootb_internal/dependency_check.py,sha256=y8RMEP6RXQzTgU1MS_1piBLtz4J-Hfn9RjUZg59dyvo,1333
-computer_use_ootb_internal/guard_service.py,sha256=FZsztgGP4fG2U7aj8KhlbRE_gUoLuGnCW8393bMbpFs,54217
+computer_use_ootb_internal/guard_service.py,sha256=B-eNrs97lhCBsPixspcRNZJHkKYuN4IbwUnpB0W8fsw,49381
+computer_use_ootb_internal/launch_ootb_elevated.ps1,sha256=_WWVbxOU1Ow8MpOC9GUYV0B-DYEnLGaRCTkT9rNGuYY,2426
 computer_use_ootb_internal/requirements-lite.txt,sha256=5DAHomz4A_P2BmTIXNkNqkHbnIF0AyZ4_1XAlb1LaYs,290
 computer_use_ootb_internal/run_teachmode_ootb_args.py,sha256=ZYVxaOMxOOTZt2S-xmJcZqXmYqqIPl57tgheMO8OOBU,7910
-computer_use_ootb_internal/service_manager.py,sha256=_aFUtvSbovX73PY1QE01RkaqGV6swJaStrOwcg_Df94,9928
+computer_use_ootb_internal/service_manager.py,sha256=1P8FbCUNIGg650xlayCQcVmSy6ELlU8ZeqqpD7Nmg_M,18364
 computer_use_ootb_internal/signal_connection.py,sha256=e6eGByhb2Gx8HHJHrHM3HvchobSUmba1y7-YRB6L59E,1821
 computer_use_ootb_internal/test_click_0425.py,sha256=uZtP6DsPVRFonKMYlbe9eHmPY6hH5y8xWgr2KxHC8E4,1808
 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=SOJz2yffXTkjuAHqk0IZLcMriR0KQYTo7W1b8wGyRGY,1222
-computer_use_ootb_internal/computer_use_demo/executor/teachmode_executor.py,sha256=5fbEin5SDpchuCe6lEtRPK9JbO4YRqqIsD6LijJTrD8,16692
+computer_use_ootb_internal/computer_use_demo/executor/teachmode_executor.py,sha256=dP5rbO1tVxwu7GJ_LS_lGBtI_GK473_aGVnU0sfrU2o,15300
 computer_use_ootb_internal/computer_use_demo/gui_agent/gui_parser/simple_parser/__init__.py,sha256=h2CNeuACklxVpJC65QR8_6AvSybEZLmeO45hY_-lLBs,61
 computer_use_ootb_internal/computer_use_demo/gui_agent/gui_parser/simple_parser/gui_capture.py,sha256=CxFJbsSb68ERKH7-C4RaaZy7FIhhzrzGx5qQJ4C37cA,13907
 computer_use_ootb_internal/computer_use_demo/gui_agent/gui_parser/simple_parser/utils.py,sha256=OOVxy4Qlbk5q-X9kXFXqt6AmuOMl6FWWqtH269DvJJA,10005
@@ -28,14 +29,14 @@ computer_use_ootb_internal/computer_use_demo/tools/base.py,sha256=XKG8UpjTvG3-Pl
 computer_use_ootb_internal/computer_use_demo/tools/bash.py,sha256=rHetQ80_v-TTi-1oxIA7ncFEwJxFTh8FJCErIoZbGeY,4236
 computer_use_ootb_internal/computer_use_demo/tools/collection.py,sha256=8RzHLobL44_Jjt8ltXS6I8XJlEAQOfc75dmnDUaHE-8,922
 computer_use_ootb_internal/computer_use_demo/tools/colorful_text.py,sha256=cvlmnhAImDTwoRRwhT5au7mNFhfAD7ZfeoDEVdVzDKw,892
-computer_use_ootb_internal/computer_use_demo/tools/computer.py,sha256=XUFNoKkRYNrCEvNuIAhhByIYkLjEM-vWUeW0Dn_VtQA,27356
+computer_use_ootb_internal/computer_use_demo/tools/computer.py,sha256=3Fx6jZRhFrLoUWa9eVEZaM7LIv1pALvLqsZXn7pXii4,27358
 computer_use_ootb_internal/computer_use_demo/tools/computer_marbot.py,sha256=zZuWz9ArfP3Zss-afnscrPkgCtB5UWbCy7HwAOvO2bo,5970
 computer_use_ootb_internal/computer_use_demo/tools/edit.py,sha256=b0PwUitxckHCQqFP3ZwlthWdqNkn7WETeTHeB6-o98c,11486
 computer_use_ootb_internal/computer_use_demo/tools/run.py,sha256=xhXdnBK1di9muaO44CEirL9hpGy3NmKbjfMpyeVmn8Y,1595
 computer_use_ootb_internal/computer_use_demo/tools/screen_capture.py,sha256=L8qfvtUkPPQGt92N-2Zfw5ZTDBzLsDps39uMnX3_uSA,6857
 computer_use_ootb_internal/preparation/__init__.py,sha256=AgtGHcBpiTkxJjF0xwcs3yyQ6SyUvhL3G0vD2XO-zJw,63
 computer_use_ootb_internal/preparation/star_rail_prepare.py,sha256=RAriQxrv55csBNBm0m8CKyd_RW8k1tXx0kdJAcOpYlg,4734
-computer_use_ootb_internal-0.0.169.dist-info/METADATA,sha256=Vz03DAAV20UTQtUOw8USm5xCGL9kVSyY3150vQW5Mz4,910
-computer_use_ootb_internal-0.0.169.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-computer_use_ootb_internal-0.0.169.dist-info/entry_points.txt,sha256=-AbmawU7IRQuDZihgVMVDrFoY4E6rnXYOUB-5vSeBKs,93
-computer_use_ootb_internal-0.0.169.dist-info/RECORD,,
+computer_use_ootb_internal-0.0.170.dist-info/METADATA,sha256=LjpaJCl3ruC43TTqHE85N__WL-f2Iv92SgGK3B3TGdw,910
+computer_use_ootb_internal-0.0.170.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+computer_use_ootb_internal-0.0.170.dist-info/entry_points.txt,sha256=-AbmawU7IRQuDZihgVMVDrFoY4E6rnXYOUB-5vSeBKs,93
+computer_use_ootb_internal-0.0.170.dist-info/RECORD,,