computer-use-ootb-internal 0.0.169__tar.gz → 0.0.170__tar.gz

{computer_use_ootb_internal-0.0.169 → computer_use_ootb_internal-0.0.170}/PKG-INFO

@@ -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 → computer_use_ootb_internal-0.0.170}/pyproject.toml

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

{computer_use_ootb_internal-0.0.169 → computer_use_ootb_internal-0.0.170}/src/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-0.0.169 → computer_use_ootb_internal-0.0.170}/src/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-0.0.169 → computer_use_ootb_internal-0.0.170}/src/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-0.0.169 → computer_use_ootb_internal-0.0.170}/src/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-0.0.170/src/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