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

computer_use_ootb_internal/app_teachmode.py

@@ -552,9 +552,6 @@ def main():
     parser.add_argument("--trace_id", type=str, default="build_scroll_combat", help="Trace ID for the session")
     parser.add_argument("--api_keys", type=str, default="sk-proj-1234567890", help="API keys")
     parser.add_argument("--server_url", type=str, default="http://ec2-44-234-43-86.us-west-2.compute.amazonaws.com", help="Server URL for the session")
-    # Add arguments for port override and target user
-    parser.add_argument("-p", "--port", type=int, default=None, help="Specify the port to run the server on, overriding user-based calculation.")
-    parser.add_argument("--target_user", type=str, default=None, help="Specify the target username for port calculation if --port is not given.")
 
     args = parser.parse_args()
 
@@ -571,18 +568,14 @@ def main():
     rate_limiter = RateLimiter(interval_seconds=2) # Re-initialize rate limiter
     logging.info(f"Shared state initialized for user: {args.user_id}")
 
-    # --- Port Calculation Logic ---
+    # --- Restore original port calculation logic --- 
     port = 7888 # Default port
     host = "0.0.0.0" # Listen on all interfaces
     
-    if args.port is not None:
-        port = args.port
-        logging.info(f"Using specified port from --port argument: {port}")
-    elif platform.system() == "Windows" and args.target_user is not None:
+    if platform.system() == "Windows":
         try:
-            # Use the --target_user argument for calculation
-            username = args.target_user.lower()
-            logging.info(f"Determining port based on Windows username from --target_user: {username}")
+            username = os.environ["USERNAME"].lower()
+            logging.info(f"Determining port based on Windows username: {username}")
             if username == "altair":
                 port = 14000
             elif username.startswith("guest") and username[5:].isdigit():
@@ -594,10 +587,10 @@ def main():
             else:
                 logging.info(f"Username '{username}' doesn't match specific rules, using default port {port}.")
         except Exception as e:
-             logging.error(f"Error determining port from --target_user '{args.target_user}': {e}. Using default port {port}.", exc_info=True)
+             logging.error(f"Error determining port from username: {e}. Using default port {port}.", exc_info=True)
     else:
-         logging.info(f"--port not specified, and not on Windows or --target_user not specified. Using default port {port}.")
-    # --- End Port Calculation ---
+         logging.info(f"Not running on Windows, using default port {port}.")
+    # --- End of restored port calculation --- 
 
     logging.info(f"Final Host={host}, Port={port}")
 

computer_use_ootb_internal/guard_service.py

@@ -23,7 +23,6 @@ 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"
@@ -144,6 +143,7 @@ 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):
@@ -688,29 +688,21 @@ class GuardService(win32serviceutil.ServiceFramework):
         task_created_status = "task_unknown"
         immediate_start_status = "start_not_attempted"
         final_status = "failed_unknown"
-        calculated_port = 7888 # Default port
-
-        # --- Calculate Port based on username (mirroring app_teachmode logic) ---
-        try:
-            if user == "altair":
-                calculated_port = 14000
-            elif user.startswith("guest") and user[5:].isdigit():
-                num = int(user[5:])
-                if 1 <= num <= 10:
-                    calculated_port = 14000 + num
-                else:
-                    self.log_warning(f"Internal trigger: User 'guest{num}' out of range (1-10), using default port {calculated_port} for launch.")
-            # else: use default 7888
-            self.log_info(f"Internal trigger: Calculated port {calculated_port} for user '{user}'.")
-        except Exception as port_calc_e:
-            self.log_error(f"Internal trigger: Error calculating port for user '{user}': {port_calc_e}. Using default port {calculated_port}.")
-        # --- End Port Calculation ---
-
 
         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)
@@ -731,7 +723,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 = "skipped_inactive" # Simplified status
+                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
@@ -748,100 +740,50 @@ 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 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
-
+            # 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:
-                # 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_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}'
-                )
-
-                # 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:")
+                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}")
+                self.log_info(f"  lpCurrentDirectory: {cwd if cwd else 'Default'}")
 
-                # 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
                 )
-                self.log_info(f"Internal trigger: CreateProcessAsUser call for helper script succeeded (Launcher PID: {dwPid}). Helper script should now run and trigger elevation.")
+                self.log_info(f"Internal trigger: CreateProcessAsUser call succeeded for user '{user}' (PID: {dwPid}). Checking existence...")
                 win32api.CloseHandle(hProcess)
                 win32api.CloseHandle(hThread)
 
-                # 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"
+                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:
+                    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:
-                 # 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)
-            # Status is now primarily determined by the helper script launch attempt
+                 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:
@@ -849,47 +791,133 @@ 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, script_name)
+            script_path = os.path.join(base_dir, "signal_connection.py")
             if os.path.exists(script_path):
-                self.log_info(f"Found helper script '{script_name}' at: {script_path}")
-                # Return unquoted path for potential quoting later
+                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"Helper script '{script_name}' not found near {base_dir}")
+                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 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}")
+            self.log_error(f"Error finding signal script: {e}")
             return None
 
 # --- Main Execution Block ---

computer_use_ootb_internal/run_teachmode_ootb_args.py

@@ -119,17 +119,21 @@ def simple_teachmode_sampling_loop(
 
         try:
             step_plan = infer_server_response["generated_plan"]
-            step_reasoning = step_plan["reasoning"]
-            step_info = step_plan["step_info"]
+            step_plan_observation = step_plan["observation"]
+            step_plan_reasoning = step_plan["reasoning"]
+            step_plan_info = step_plan["step_info"]
             step_action = infer_server_response["generated_action"]["content"]
             step_traj_idx = infer_server_response["current_traj_step"]
 
+            # chat_visable_content = f"{step_plan_observation}{step_plan_reasoning}"
+
         except Exception as e:
             print("Error parsing generated_action content:", e)
             yield {"role": "assistant", "content": "Error parsing response from Marbot Run server. Exiting.", "type": "error"}
             break
-        
-        yield {"role": "assistant", "content": step_reasoning, "type": "text"}
+
+        yield {"role": "assistant", "content": step_plan_observation, "type": "text"}
+        yield {"role": "assistant", "content": step_plan_reasoning, "type": "text"}
 
         if step_action.get("action") == "STOP":
             final_sc, final_sc_path = get_screenshot_external_cmd(selected_screen=selected_screen)
@@ -141,7 +145,7 @@ def simple_teachmode_sampling_loop(
             action_history = []  
             break
 
-        action_history.append(f"Executing guidance trajectory step [{step_traj_idx}]: {{Plan: {step_info}, Action: {step_action}}}\n")
+        action_history.append(f"Executing guidance trajectory step [{step_traj_idx}]: {{Plan: {step_plan_info}, Action: {step_action}}}\n")
 
         for exec_message in executor({"role": "assistant", "content": step_action}):
             yield exec_message

computer_use_ootb_internal/service_manager.py

@@ -6,14 +6,11 @@ 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."""
@@ -54,298 +51,142 @@ 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_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:
-        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: 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
 
-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 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 _find_pythonw_executable():
-    """Finds pythonw.exe in the same directory as sys.executable."""
     try:
-        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"Error finding pythonw.exe: {e}. Using sys.executable as fallback.", file=sys.stderr)
-        return sys.executable
+        python_exe = sys.executable # Use the same python that's running this script
+        service_script = get_service_module_path()
+    except FileNotFoundError as e:
+         print(f"Error: {e}", file=sys.stderr)
+         return False
 
-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
+    # 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}"'
 
-    startup_dir = _get_startup_folder()
-    if not startup_dir:
-        return 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)}")
 
-    shortcut_path = os.path.join(startup_dir, _SHORTCUT_NAME)
-    python_launcher = _find_pythonw_executable()
-    signal_script = None
     try:
-        # 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"Error finding signal_connection.py: {e}", file=sys.stderr)
+        # 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
-
-    # 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:
+    except Exception as e:
+        print(f"An unexpected error occurred running service command: {e}", file=sys.stderr)
         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
+# --- Add cleanup helpers ---
+def _run_powershell_cleanup_command(command):
+    """Executes a PowerShell command specifically for cleanup, ignoring most errors."""
+    if platform.system() != "Windows": return True # Skip on non-windows
+    print(f"Executing PowerShell Cleanup: {command}")
+    try:
+        # Use check=False, don't capture output unless needed for debug
+        subprocess.run(
+            ["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", command],
+            check=False, # Don't throw error if command fails (e.g., no tasks found)
+            stdout=subprocess.DEVNULL, # Suppress stdout
+            stderr=subprocess.DEVNULL  # Suppress stderr
+        )
+        return True # Assume success for cleanup flow
+    except Exception as e:
+        print(f"Warning: PowerShell cleanup command failed: {e}", file=sys.stderr)
+        return False # Indicate potential issue
 
 def _cleanup_scheduled_tasks():
-    """Removes all OOTB user logon scheduled tasks (legacy cleanup)."""
-    print("Attempting legacy cleanup of OOTB user logon scheduled tasks...")
+    """Removes all OOTB user logon scheduled tasks."""
+    print("Attempting to remove any existing OOTB user logon scheduled tasks...")
     # Use -like operator and wildcard
-    # Need _TASK_NAME_PREFIX defined at module level
+    # Use try-catch within PowerShell for robustness
     command = f"""
     $tasks = Get-ScheduledTask | Where-Object {{ $_.TaskName -like '{_TASK_NAME_PREFIX}*' }}
     if ($tasks) {{
-        Write-Host "Found $($tasks.Count) legacy OOTB logon tasks to remove."
+        Write-Host "Found $($tasks.Count) OOTB logon tasks to remove."
         $tasks | Unregister-ScheduledTask -Confirm:$false -ErrorAction SilentlyContinue
-        Write-Host "Legacy OOTB logon task removal attempted."
+        Write-Host "OOTB logon task removal attempted."
     }} else {{
-        Write-Host "No legacy OOTB logon tasks found to remove."
+        Write-Host "No OOTB logon tasks found to remove."
     }}
     """
-    # Use the generic _run_command helper, specifying powershell.exe
-    _run_command(['powershell.exe', '-NoProfile', '-NonInteractive', '-Command', command], check_errors=False, verbose=False)
+    _run_powershell_cleanup_command(command)
+# --- End cleanup helpers ---
 
 def install_and_start():
     """Installs and starts the Guard Service."""
     print(f"Attempting to install service: '{_SERVICE_NAME}' ('{_SERVICE_DISPLAY_NAME}')")
-    # 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
+    # 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)
 
     if install_success:
-        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()}")
+        # 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.")
         else:
-            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)
+             # 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(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 registration command failed critically
-        print(f"\nService '{_SERVICE_NAME}' registration failed critically. See errors above.", file=sys.stderr)
+        # 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)
 
-def stop_and_remove():
-    """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'...")
+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)")
     # Run stop first, ignore errors (check_errors=False)
-    # 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
+    run_service_command(['stop'], check_errors=False)
+    time.sleep(2) # Give service time to stop
 
-    # 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
+    print(f"\nAttempting to remove service: '{_SERVICE_NAME}'")
+    remove_success = run_service_command(['remove']) # Check if removal command itself failed
 
     # Always attempt task cleanup, even if service removal had issues
     _cleanup_scheduled_tasks()
 
-    if 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)
+    if remove_success:
+        print(f"\nService '{_SERVICE_NAME}' stopped (if running) and removed successfully. Associated logon tasks cleanup attempted.")
     else:
-        # 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"\nService '{_SERVICE_NAME}' removal command failed.", file=sys.stderr)
+        # Make sure to mention cleanup was still attempted
+        print(f" Associated logon tasks cleanup attempted.", file=sys.stderr)
         print(f" Ensure the service was stopped first, or check permissions.", file=sys.stderr)
 
 if __name__ == '__main__':

{computer_use_ootb_internal-0.0.170.dist-info → computer_use_ootb_internal-0.0.171.dist-info}/METADATA

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

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

@@ -1,12 +1,11 @@
 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=842v79pjUvX1yck6n4uel45ysZTcsWXoskwcfEzSgw4,26866
+computer_use_ootb_internal/app_teachmode.py,sha256=MUoMkTXHJL6e6fib459rSlCyOK6AzIrs5XOfKN34-aY,26230
 computer_use_ootb_internal/dependency_check.py,sha256=y8RMEP6RXQzTgU1MS_1piBLtz4J-Hfn9RjUZg59dyvo,1333
-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/guard_service.py,sha256=ThF_Y8FcBQseXo6-5hIh_Z4cISkCLLEgjWrR2BIV-C0,50940
 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=1P8FbCUNIGg650xlayCQcVmSy6ELlU8ZeqqpD7Nmg_M,18364
+computer_use_ootb_internal/run_teachmode_ootb_args.py,sha256=wou3FkumHHy3XlYlV0orO7zdJfq2ckDLHw5hGtFnieo,8159
+computer_use_ootb_internal/service_manager.py,sha256=_aFUtvSbovX73PY1QE01RkaqGV6swJaStrOwcg_Df94,9928
 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
@@ -36,7 +35,7 @@ computer_use_ootb_internal/computer_use_demo/tools/run.py,sha256=xhXdnBK1di9muaO
 computer_use_ootb_internal/computer_use_demo/tools/screen_capture.py,sha256=L8qfvtUkPPQGt92N-2Zfw5ZTDBzLsDps39uMnX3_uSA,6857
 computer_use_ootb_internal/preparation/__init__.py,sha256=AgtGHcBpiTkxJjF0xwcs3yyQ6SyUvhL3G0vD2XO-zJw,63
 computer_use_ootb_internal/preparation/star_rail_prepare.py,sha256=RAriQxrv55csBNBm0m8CKyd_RW8k1tXx0kdJAcOpYlg,4734
-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,,
+computer_use_ootb_internal-0.0.171.dist-info/METADATA,sha256=c95CauIKJIwTWreTYiPd_j5hLg8EUJIOwNQcU5ymTcw,910
+computer_use_ootb_internal-0.0.171.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+computer_use_ootb_internal-0.0.171.dist-info/entry_points.txt,sha256=-AbmawU7IRQuDZihgVMVDrFoY4E6rnXYOUB-5vSeBKs,93
+computer_use_ootb_internal-0.0.171.dist-info/RECORD,,

computer_use_ootb_internal/launch_ootb_elevated.ps1

@@ -1,63 +0,0 @@
-# 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